Contract 0xA1a938855735C0651A6CfE2E93a32A28A236d0E9 2

/**
 *Submitted for verification at FtmScan.com on 2022-01-24
*/

// File contracts/OpenZeppelin/math/SafeMath.sol

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File contracts/OpenZeppelin/token/ERC20/IERC20.sol

pragma solidity >=0.4.0;

interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the token decimals.
     */
    function decimals() external view returns (uint8);

    /**
     * @dev Returns the token symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the token name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the ERC token owner.
     */
    function getOwner() external view returns (address);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address _owner, address spender)
        external
        view
        returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

// File contracts/OpenZeppelin/utils/Address.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File contracts/OpenZeppelin/token/ERC20/SafeERC20.sol

pragma solidity ^0.6.0;

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(
            value
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            "SafeERC20: decreased allowance below zero"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// File contracts/OpenZeppelin/GSN/Context.sol

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File contracts/OpenZeppelin/access/Ownable.sol

pragma solidity >=0.4.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File contracts/OpenZeppelin/token/ERC20/ERC20.sol

pragma solidity >=0.4.0;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-ERC20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the ERC token owner.
     */
    function getOwner() external view override returns (address) {
        return owner();
    }

    /**
     * @dev Returns the token name.
     */
    function name() public view override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token decimals.
     */
    function decimals() public view override returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Returns the token symbol.
     */
    function symbol() public view override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {ERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {ERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {ERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount)
        public
        override
        returns (bool)
    {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {ERC20-allowance}.
     */
    function allowance(address owner, address spender)
        public
        view
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {ERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount)
        public
        override
        returns (bool)
    {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {ERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue)
        public
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].add(addedValue)
        );
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: transfer amount exceeds balance"
        );
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: burn amount exceeds balance"
        );
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(
            account,
            _msgSender(),
            _allowances[account][_msgSender()].sub(
                amount,
                "ERC20: burn amount exceeds allowance"
            )
        );
    }
}

// File contracts/WigoToken.sol

pragma solidity 0.6.12;

// WigoToken
contract WigoToken is ERC20("WigoSwap Token", "WIGO") {
    uint256 private constant MAX_SUPPLY = 2000000000e18;
    uint256 public _totalMinted = 0;
    uint256 public _totalBurned = 0;
    address public treasuryAddr;

    event Mint(address indexed sender, address indexed to, uint256 amount);
    event Burn(address indexed sender, address indexed from, uint256 amount);

    constructor(address _treasuryAddr) public {
        treasuryAddr = _treasuryAddr;

        // Mints 160,000,000 WIGO (8%) for Airdrop, IDO and Seed Funders.
        _mint(treasuryAddr, 160000000e18);
        _totalMinted = _totalMinted.add(160000000e18);
        emit Mint(msg.sender, treasuryAddr, 160000000e18);
    }

    function maxSupply() public pure returns (uint256) {
        return MAX_SUPPLY;
    }

    function totalMinted() public view returns (uint256) {
        return _totalMinted;
    }

    function totalBurned() public view returns (uint256) {
        return _totalBurned;
    }

    /// @notice Must only be called by the owner (MasterFarmer).
    function mint(address _to, uint256 _amount) public onlyOwner {
        require(
            totalSupply().add(_amount) <= MAX_SUPPLY,
            "ERC20: minting more than maxSupply"
        );
        _mint(_to, _amount);
        _totalMinted = _totalMinted.add(_amount);
        emit Mint(msg.sender, _to, _amount);
    }

    /// @notice Burns only from treasury address. Must only be called by MasterFarmer.
    function burn(address _from, uint256 _amount) public onlyOwner {
        _burn(_from, _amount);
        _totalBurned = _totalBurned.add(_amount);
        emit Burn(msg.sender, _from, _amount);
    }
}

// File contracts/WigoBank.sol

pragma solidity 0.6.12;

// WigoBank
contract WigoBank is ERC20("WigoBank Token", "xWIGO") {
    // The WIGO TOKEN!
    WigoToken public wigo;

    event Mint(address indexed sender, address indexed to, uint256 amount);
    event Burn(address indexed sender, address indexed from, uint256 amount);

    constructor(WigoToken _wigo) public {
        wigo = _wigo;
    }

    /// @notice Must only be called by the owner (MasterFarmer).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        emit Mint(msg.sender, _to, _amount);
    }

    /// @notice Must only be called by the owner (MasterFarmer).
    function burn(address _from, uint256 _amount) public onlyOwner {
        _burn(_from, _amount);
        emit Burn(msg.sender, _from, _amount);
    }

    // Safe wigo transfer function, just in case if rounding error causes pool to not have enough WIGOs.
    function safeWigoTransfer(address _to, uint256 _amount) public onlyOwner {
        uint256 wigoBal = wigo.balanceOf(address(this));
        if (_amount > wigoBal) {
            wigo.transfer(_to, wigoBal);
        } else {
            wigo.transfer(_to, _amount);
        }
    }
}

// File contracts/MasterFarmer.sol

pragma solidity 0.6.12;

// MasterFarmer is the master of Wigo. He can make Wigo and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once WIGO is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterFarmer is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of WIGOs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accWigoPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accWigoPerShare` (and `lastRewardBlockTime`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool.
        uint256 lastRewardBlockTime; // Last block time that WIGOs distribution occurs.
        uint256 accWigoPerShare; // Accumulated WIGOs per share, times 1e12. See below.
    }

    // The WIGO TOKEN!
    WigoToken public wigo;
    // The WIGOBANK (xWIGO) TOKEN!
    WigoBank public bank;
    // Treasury address.
    address public treasuryAddr;
    // Dev team address.
    address public devAddr;
    // WIGO tokens created per second.
    uint256 public wigoPerSecond;
    // Reward muliplier for early wigo makers.
    uint256[] public REWARD_MULTIPLIER = [9, 8, 7, 6, 5, 4, 3, 2, 1];
    // When multiplier changes.
    uint256[] public CHANGE_MULTIPLIER_AT_TIME;
    // When multiplier will change to 1.
    uint256 public FINISH_BONUS_AT_TIME;
    // 15% reward for devs (12.5%) and treasury (2.5%).
    uint256 public constant PERCENT_FOR_DEV = 125;
    uint256 public constant PERCENT_FOR_TREASURY = 25;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block time when WIGO mining starts.
    uint256 public startBlockTime;

    event WigoBurn(address indexed from, uint256 amount);
    event EmergencyWithdraw(
        address indexed user,
        uint256 indexed pid,
        uint256 amount
    );
    event SetTreasury(address indexed user, address indexed newTreasury);
    event SetDev(address indexed user, address indexed newDev);
    event Add(address indexed user, IERC20 indexed pair, uint256 indexed point);
    event Set(address indexed user, uint256 indexed pid, uint256 indexed point);

    constructor(
        WigoToken _wigo,
        WigoBank _bank,
        address _treasuryAddr,
        address _devAddr,
        uint256 _wigoPerSecond,
        uint256 _startBlockTime,
        uint256 _changeMultiplierAfterTime
    ) public {
        wigo = _wigo;
        bank = _bank;
        treasuryAddr = _treasuryAddr;
        devAddr = _devAddr;
        wigoPerSecond = _wigoPerSecond;
        startBlockTime = _startBlockTime;

        for (uint256 i = 0; i < REWARD_MULTIPLIER.length - 1; i++) {
            uint256 changeMultiplierAtTime = _changeMultiplierAfterTime
                .mul(i + 1)
                .add(_startBlockTime);
            CHANGE_MULTIPLIER_AT_TIME.push(changeMultiplierAtTime);
        }
        FINISH_BONUS_AT_TIME = _changeMultiplierAfterTime
            .mul(REWARD_MULTIPLIER.length - 1)
            .add(_startBlockTime);

        // staking pool
        poolInfo.push(
            PoolInfo({
                lpToken: _wigo,
                allocPoint: 1000,
                lastRewardBlockTime: startBlockTime,
                accWigoPerShare: 0
            })
        );

        totalAllocPoint = 1000;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    function checkForDuplicate(IERC20 _lpToken) internal view {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            require(
                poolInfo[pid].lpToken != _lpToken,
                "Add: pool already exists!!!!"
            );
        }
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        bool _withUpdate
    ) public onlyOwner {
        checkForDuplicate(_lpToken); // ensure you can't add duplicate pools
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlockTime = block.timestamp > startBlockTime
            ? block.timestamp
            : startBlockTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlockTime: lastRewardBlockTime,
                accWigoPerShare: 0
            })
        );
        updateStakingPool();
        emit Add(msg.sender, _lpToken, _allocPoint);
    }

    // Update the given pool's WIGO allocation point. Can only be called by the owner.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        bool _withUpdate
    ) public onlyOwner {
        require(_pid != 0, "You can't set allocPoint for staking pool.");
        if (_withUpdate) {
            massUpdatePools();
        }
        if (poolInfo[_pid].allocPoint != _allocPoint) {
            uint256 prevAllocPoint = poolInfo[_pid].allocPoint;
            poolInfo[_pid].allocPoint = _allocPoint;
            totalAllocPoint = totalAllocPoint.sub(prevAllocPoint).add(
                _allocPoint
            );
            updateStakingPool();
            emit Set(msg.sender, _pid, _allocPoint);
        }
    }

    function updateStakingPool() internal {
        uint256 length = poolInfo.length;
        uint256 points = 0;
        for (uint256 pid = 1; pid < length; ++pid) {
            points = points.add(poolInfo[pid].allocPoint);
        }
        if (points != 0) {
            points = points.div(4);
            totalAllocPoint = totalAllocPoint.sub(poolInfo[0].allocPoint).add(
                points
            );
            poolInfo[0].allocPoint = points;
        }
    }

    // Return reward multiplier over the given _from to _to block time.
    function getMultiplier(uint256 _from, uint256 _to)
        public
        view
        returns (uint256)
    {
        require(_to >= _from, "Multiplier: _from is bigger than _to");
        _from = _from > startBlockTime ? _from : startBlockTime;
        if (_to < startBlockTime) {
            return 0;
        }
        if (_from >= FINISH_BONUS_AT_TIME) {
            return _to.sub(_from);
        } else {
            uint256 result = 0;
            uint256 fromTime = _from;
            uint256 toTime = _to;
            for (uint256 i = 0; i < CHANGE_MULTIPLIER_AT_TIME.length; i++) {
                uint256 endTime = CHANGE_MULTIPLIER_AT_TIME[i];
                if (fromTime < endTime) {
                    uint256 m = endTime.sub(fromTime).mul(REWARD_MULTIPLIER[i]);
                    fromTime = endTime;
                    result = result.add(m);
                }
                if (toTime < endTime) {
                    uint256 m = endTime.sub(toTime).mul(REWARD_MULTIPLIER[i]);
                    toTime = endTime;
                    result = result.sub(m);
                }
            }
            if (_to >= FINISH_BONUS_AT_TIME) {
                uint256 m = _to.sub(FINISH_BONUS_AT_TIME);
                result = result.add(m);
            }
            return result;
        }
    }

    // Return how many wigo can mint based on wigo remaining supply.
    function wigoCanMint(uint256 _amount)
        internal
        view
        returns (uint256 wigoReward)
    {
        uint256 canMint = wigo
            .maxSupply()
            .sub(wigo.totalSupply())
            .mul(1000)
            .div(1000 + PERCENT_FOR_TREASURY + PERCENT_FOR_DEV);
        if (canMint < _amount) {
            wigoReward = canMint;
        } else {
            wigoReward = _amount;
        }
    }

    // View function to see pending WIGOs on frontend.
    function pendingWigo(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accWigoPerShare = pool.accWigoPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardBlockTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(
                pool.lastRewardBlockTime,
                block.timestamp
            );
            uint256 rewardAmount = multiplier
                .mul(wigoPerSecond)
                .mul(pool.allocPoint)
                .div(totalAllocPoint);
            uint256 wigoReward = wigoCanMint(rewardAmount);
            accWigoPerShare = accWigoPerShare.add(
                wigoReward.mul(1e12).div(lpSupply)
            );
        }
        return user.amount.mul(accWigoPerShare).div(1e12).sub(user.rewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardBlockTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlockTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(
            pool.lastRewardBlockTime,
            block.timestamp
        );
        uint256 rewardAmount = multiplier
            .mul(wigoPerSecond)
            .mul(pool.allocPoint)
            .div(totalAllocPoint);
        uint256 wigoReward = wigoCanMint(rewardAmount);
        // Minting for devs and treasury will stop when total minted exceeds max supply.
        if (wigo.totalMinted() < wigo.maxSupply()) {
            wigo.mint(devAddr, wigoReward.mul(PERCENT_FOR_DEV).div(1000));
            wigo.mint(
                treasuryAddr,
                wigoReward.mul(PERCENT_FOR_TREASURY).div(1000)
            );
        }
        wigo.mint(address(bank), wigoReward);
        pool.accWigoPerShare = pool.accWigoPerShare.add(
            wigoReward.mul(1e12).div(lpSupply)
        );
        pool.lastRewardBlockTime = block.timestamp;
    }

    // Deposit LP tokens to MasterFarmer for WIGO allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        require(_pid != 0, "deposit WIGO by staking");
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user
                .amount
                .mul(pool.accWigoPerShare)
                .div(1e12)
                .sub(user.rewardDebt);
            if (pending > 0) {
                safeWigoTransfer(msg.sender, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accWigoPerShare).div(1e12);
    }

    // Withdraw LP tokens from MasterFarmer.
    function withdraw(uint256 _pid, uint256 _amount) public {
        require(_pid != 0, "withdraw WIGO by unstaking");
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accWigoPerShare).div(1e12).sub(
            user.rewardDebt
        );
        if (pending > 0) {
            safeWigoTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accWigoPerShare).div(1e12);
    }

    // Stake WIGO tokens to MasterFarmer
    function enterStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        updatePool(0);
        if (user.amount > 0) {
            uint256 pending = user
                .amount
                .mul(pool.accWigoPerShare)
                .div(1e12)
                .sub(user.rewardDebt);
            if (pending > 0) {
                safeWigoTransfer(msg.sender, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accWigoPerShare).div(1e12);

        bank.mint(msg.sender, _amount);
    }

    // Withdraw WIGO tokens from STAKING.
    function leaveStaking(uint256 _amount) public {
        PoolInfo storage pool = poolInfo[0];
        UserInfo storage user = userInfo[0][msg.sender];
        uint256 userBankBalance = bank.balanceOf(msg.sender);
        require(
            userBankBalance >= _amount,
            "withdraw: You do not have enough xWIGO!"
        );
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(0);
        uint256 pending = user.amount.mul(pool.accWigoPerShare).div(1e12).sub(
            user.rewardDebt
        );
        if (pending > 0) {
            safeWigoTransfer(msg.sender, pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accWigoPerShare).div(1e12);
        bank.burn(msg.sender, _amount);
    }

    // Burning WIGO tokens.
    function wigoBurn(uint256 _amount) public {
        uint256 balance = wigo.balanceOf(msg.sender);
        require(balance >= _amount, "Burning: You don't have WIGO enough!");
        wigo.burn(msg.sender, _amount);
        emit WigoBurn(msg.sender, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        if (_pid == 0) {
            uint256 userBankBalance = bank.balanceOf(msg.sender);
            require(
                userBankBalance >= user.amount,
                "EmergencyWithdraw: You do not have enough xWIGO!"
            );
            bank.burn(msg.sender, user.amount);
        }
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    // Safe wigo transfer function, just in case if rounding error causes pool to not have enough WIGOs.
    function safeWigoTransfer(address _to, uint256 _amount) internal {
        bank.safeWigoTransfer(_to, _amount);
    }

    // Update treasury address by the previous treasury.
    function setTreasury(address _treasuryAddr) public {
        require(msg.sender == treasuryAddr, "Set Treasury: wut?");
        require(_treasuryAddr != address(0), "Cannot be zero address");
        treasuryAddr = _treasuryAddr;
        emit SetTreasury(msg.sender, _treasuryAddr);
    }

    // Update dev address by the previous dev.
    function setDev(address _devAddr) public {
        require(msg.sender == devAddr, "Set Dev: wut?");
        require(_devAddr != address(0), "Cannot be zero address");
        devAddr = _devAddr;
        emit SetDev(msg.sender, _devAddr);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract WigoToken","name":"_wigo","type":"address"},{"internalType":"contract WigoBank","name":"_bank","type":"address"},{"internalType":"address","name":"_treasuryAddr","type":"address"},{"internalType":"address","name":"_devAddr","type":"address"},{"internalType":"uint256","name":"_wigoPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startBlockTime","type":"uint256"},{"internalType":"uint256","name":"_changeMultiplierAfterTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"pair","type":"address"},{"indexed":true,"internalType":"uint256","name":"point","type":"uint256"}],"name":"Add","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"point","type":"uint256"}],"name":"Set","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newDev","type":"address"}],"name":"SetDev","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newTreasury","type":"address"}],"name":"SetTreasury","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WigoBurn","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"CHANGE_MULTIPLIER_AT_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FINISH_BONUS_AT_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENT_FOR_DEV","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENT_FOR_TREASURY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"REWARD_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bank","outputs":[{"internalType":"contract WigoBank","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"enterStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"leaveStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingWigo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlockTime","type":"uint256"},{"internalType":"uint256","name":"accWigoPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddr","type":"address"}],"name":"setDev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasuryAddr","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wigo","outputs":[{"internalType":"contract WigoToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"wigoBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wigoPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

6101a060405260096080818152600860a052600760c052600660e08190526005610100526004610120526003610140526002610160526001610180526200004992909190620003db565b506000600b553480156200005c57600080fd5b506040516200348438038062003484833981810160405260e08110156200008257600080fd5b508051602082015160408301516060840151608085015160a086015160c09096015194959394929391929091906000620000bb62000315565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600180546001600160a01b03808a166001600160a01b031992831617909255600280548984169083161790556003805488841690831617905560048054928716929091169190911790556005839055600c82905560005b60065460001901811015620001e6576000620001a3846200018f84600101866200031960201b620022f01790919060201c565b6200038060201b6200236a1790919060201c565b60078054600181810183556000929092527fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68801919091559190910190506200015c565b506200020e826200018f600160068054905003846200031960201b620022f01790919060201c565b6008555050604080516080810182526001600160a01b0396871681526103e860208201818152600c5493830193845260006060840181815260098054600181018255925293517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af600490920291820180546001600160a01b03191691909b1617909955517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b089015591517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b1880155517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b290960195909555505050600b919091555062000447565b3390565b6000826200032a575060006200037a565b828202828482816200033857fe5b0414620003775760405162461bcd60e51b8152600401808060200182810382526021815260200180620034636021913960400191505060405180910390fd5b90505b92915050565b60008282018381101562000377576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b8280548282559060005260206000209081019282156200041e579160200282015b828111156200041e578251829060ff16905591602001919060010190620003fc565b506200042c92915062000430565b5090565b5b808211156200042c576000815560010162000431565b61300c80620004576000396000f3fe608060405234801561001057600080fd5b50600436106101f05760003560e01c8063630b5ba11161010f578063afe87e01116100a2578063e2bbb15811610071578063e2bbb1581461052f578063ed9bdeda14610552578063f0f442601461055a578063f2fde38b1461058d576101f0565b8063afe87e01146104cf578063d42c3c45146104ec578063d477f05f146104f4578063da09c72c14610527576101f0565b80638da5cb5b116100de5780638da5cb5b146104355780638dbb1e3a1461043d57806393f1a40b14610460578063a8f408e0146104b2576101f0565b8063630b5ba1146103f257806364482f79146103fa578063715018a61461042557806376cdb03b1461042d576101f0565b80633540efb111610187578063503e4ded11610156578063503e4ded1461037757806351eb05a6146103b05780635312ea8e146103cd57806353e85600146103ea576101f0565b80633540efb11461032757806341441d3b1461032f578063441a3e701461034c5780634abbbd281461036f576101f0565b806317caf6f1116101c357806317caf6f1146102905780631eaaa045146102985780632fda7735146102d957806330d9a62a146102f6576101f0565b8063081e3eda146101f55780630c18d4ce1461020f5780631058d281146102175780631526fe2714610236575b600080fd5b6101fd6105c0565b60408051918252519081900360200190f35b6101fd6105c6565b6102346004803603602081101561022d57600080fd5b50356105cc565b005b6102536004803603602081101561024c57600080fd5b50356108c5565b6040805173ffffffffffffffffffffffffffffffffffffffff90951685526020850193909352838301919091526060830152519081900360800190f35b6101fd610913565b610234600480360360608110156102ae57600080fd5b5080359073ffffffffffffffffffffffffffffffffffffffff60208201351690604001351515610919565b6101fd600480360360208110156102ef57600080fd5b5035610b4b565b6102fe610b69565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b6101fd610b85565b6102346004803603602081101561034557600080fd5b5035610b8a565b6102346004803603604081101561036257600080fd5b5080359060200135610d19565b6101fd610ed6565b6101fd6004803603604081101561038d57600080fd5b508035906020013573ffffffffffffffffffffffffffffffffffffffff16610edc565b610234600480360360208110156103c657600080fd5b503561107a565b610234600480360360208110156103e357600080fd5b50356114ed565b6102fe611727565b610234611743565b6102346004803603606081101561041057600080fd5b50803590602081013590604001351515611766565b610234611926565b6102fe611a26565b6102fe611a42565b6101fd6004803603604081101561045357600080fd5b5080359060200135611a5e565b6104996004803603604081101561047657600080fd5b508035906020013573ffffffffffffffffffffffffffffffffffffffff16611bf5565b6040805192835260208301919091528051918290030190f35b6101fd600480360360208110156104c857600080fd5b5035611c19565b610234600480360360208110156104e557600080fd5b5035611c26565b6101fd611de9565b6102346004803603602081101561050a57600080fd5b503573ffffffffffffffffffffffffffffffffffffffff16611def565b6102fe611f68565b6102346004803603604081101561054557600080fd5b5080359060200135611f84565b6101fd6120d8565b6102346004803603602081101561057057600080fd5b503573ffffffffffffffffffffffffffffffffffffffff166120dd565b610234600480360360208110156105a357600080fd5b503573ffffffffffffffffffffffffffffffffffffffff16612256565b60095490565b600c5481565b600060096000815481106105dc57fe5b60009182526020808320338085527f13da86008ba1c6922daee3e07db95305ef49ebced9f5467a0b8613fcc6b343e38352604080862060025482517f70a08231000000000000000000000000000000000000000000000000000000008152600481810195909552925193909602909301965091949373ffffffffffffffffffffffffffffffffffffffff16926370a082319260248082019391829003018186803b15801561068957600080fd5b505afa15801561069d573d6000803e3d6000fd5b505050506040513d60208110156106b357600080fd5b5051905083811015610710576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526027815260200180612f566027913960400191505060405180910390fd5b815484111561078057604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f77697468647261773a206e6f7420676f6f640000000000000000000000000000604482015290519081900360640190fd5b61078a600061107a565b60006107c483600101546107be64e8d4a510006107b8886003015488600001546122f090919063ffffffff16565b906123de565b90612420565b905080156107d6576107d63382612462565b841561080d5782546107e89086612420565b8355835461080d9073ffffffffffffffffffffffffffffffffffffffff1633876124f9565b600384015483546108289164e8d4a51000916107b8916122f0565b6001840155600254604080517f9dc29fac00000000000000000000000000000000000000000000000000000000815233600482015260248101889052905173ffffffffffffffffffffffffffffffffffffffff90921691639dc29fac9160448082019260009290919082900301818387803b1580156108a657600080fd5b505af11580156108ba573d6000803e3d6000fd5b505050505050505050565b600981815481106108d257fe5b6000918252602090912060049091020180546001820154600283015460039093015473ffffffffffffffffffffffffffffffffffffffff9092169350919084565b600b5481565b610921612586565b60005473ffffffffffffffffffffffffffffffffffffffff9081169116146109aa57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6109b38261258a565b80156109c1576109c1611743565b6000600c5442116109d457600c546109d6565b425b600b549091506109e6908561236a565b600b556040805160808101825273ffffffffffffffffffffffffffffffffffffffff85811682526020820187815292820184815260006060840181815260098054600181018255925293517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af600490920291820180547fffffffffffffffffffffffff000000000000000000000000000000000000000016919094161790925592517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b082015591517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b1830155517f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b290910155610b00612658565b604051849073ffffffffffffffffffffffffffffffffffffffff85169033907f5f43b6be860b00b28d44981331005a0503e6b566155ca1423af4299a6bde1f4690600090a450505050565b60068181548110610b5857fe5b600091825260209091200154905081565b60035473ffffffffffffffffffffffffffffffffffffffff1681565b601981565b60006009600081548110610b9a57fe5b600091825260208083203384527f13da86008ba1c6922daee3e07db95305ef49ebced9f5467a0b8613fcc6b343e390915260408320600490920201925090610be19061107a565b805415610c2a576000610c1682600101546107be64e8d4a510006107b8876003015487600001546122f090919063ffffffff16565b90508015610c2857610c283382612462565b505b8215610c63578154610c549073ffffffffffffffffffffffffffffffffffffffff1633308661271d565b8054610c60908461236a565b81555b60038201548154610c7e9164e8d4a51000916107b8916122f0565b6001820155600254604080517f40c10f1900000000000000000000000000000000000000000000000000000000815233600482015260248101869052905173ffffffffffffffffffffffffffffffffffffffff909216916340c10f199160448082019260009290919082900301818387803b158015610cfc57600080fd5b505af1158015610d10573d6000803e3d6000fd5b50505050505050565b81610d8557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f7769746864726177205749474f20627920756e7374616b696e67000000000000604482015290519081900360640190fd5b600060098381548110610d9457fe5b60009182526020808320868452600a825260408085203386529092529220805460049092029092019250831115610e2c57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f77697468647261773a206e6f7420676f6f640000000000000000000000000000604482015290519081900360640190fd5b610e358461107a565b6000610e6382600101546107be64e8d4a510006107b8876003015487600001546122f090919063ffffffff16565b90508015610e7557610e753382612462565b8315610eac578154610e879085612420565b82558254610eac9073ffffffffffffffffffffffffffffffffffffffff1633866124f9565b60038301548254610ec79164e8d4a51000916107b8916122f0565b82600101819055505050505050565b60085481565b60008060098481548110610eec57fe5b60009182526020808320878452600a8252604080852073ffffffffffffffffffffffffffffffffffffffff898116875290845281862060049586029093016003810154815484517f70a082310000000000000000000000000000000000000000000000000000000081523098810198909852935191985093969395939492909116926370a08231926024808301939192829003018186803b158015610f9057600080fd5b505afa158015610fa4573d6000803e3d6000fd5b505050506040513d6020811015610fba57600080fd5b5051600285015490915042118015610fd157508015155b15611045576000610fe6856002015442611a5e565b90506000611013600b546107b8886001015461100d600554876122f090919063ffffffff16565b906122f0565b90506000611020826127b8565b905061103f611038856107b88464e8d4a510006122f0565b869061236a565b94505050505b61106d83600101546107be64e8d4a510006107b88688600001546122f090919063ffffffff16565b9450505050505b92915050565b60006009828154811061108957fe5b90600052602060002090600402019050806002015442116110aa57506114ea565b8054604080517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152905160009273ffffffffffffffffffffffffffffffffffffffff16916370a08231916024808301926020929190829003018186803b15801561111a57600080fd5b505afa15801561112e573d6000803e3d6000fd5b505050506040513d602081101561114457600080fd5b505190508061115a5750426002909101556114ea565b600061116a836002015442611a5e565b90506000611191600b546107b8866001015461100d600554876122f090919063ffffffff16565b9050600061119e826127b8565b9050600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663d5abeb016040518163ffffffff1660e01b815260040160206040518083038186803b15801561120857600080fd5b505afa15801561121c573d6000803e3d6000fd5b505050506040513d602081101561123257600080fd5b5051600154604080517fa2309ff8000000000000000000000000000000000000000000000000000000008152905173ffffffffffffffffffffffffffffffffffffffff9092169163a2309ff891600480820192602092909190829003018186803b15801561129f57600080fd5b505afa1580156112b3573d6000803e3d6000fd5b505050506040513d60208110156112c957600080fd5b505110156114165760015460045473ffffffffffffffffffffffffffffffffffffffff918216916340c10f1991166113086103e86107b886607d6122f0565b6040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050600060405180830381600087803b15801561135b57600080fd5b505af115801561136f573d6000803e3d6000fd5b505060015460035473ffffffffffffffffffffffffffffffffffffffff91821693506340c10f199250166113aa6103e86107b88660196122f0565b6040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050600060405180830381600087803b1580156113fd57600080fd5b505af1158015611411573d6000803e3d6000fd5b505050505b600154600254604080517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff928316600482015260248101859052905191909216916340c10f1991604480830192600092919082900301818387803b15801561149457600080fd5b505af11580156114a8573d6000803e3d6000fd5b505050506114d66114cb856107b864e8d4a51000856122f090919063ffffffff16565b60038701549061236a565b600386015550504260029093019290925550505b50565b6000600982815481106114fc57fe5b60009182526020808320858452600a82526040808520338652909252922060049091029091019150826116b857600254604080517f70a08231000000000000000000000000000000000000000000000000000000008152336004820152905160009273ffffffffffffffffffffffffffffffffffffffff16916370a08231916024808301926020929190829003018186803b15801561159a57600080fd5b505afa1580156115ae573d6000803e3d6000fd5b505050506040513d60208110156115c457600080fd5b50518254909150811015611623576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526030815260200180612fa76030913960400191505060405180910390fd5b6002548254604080517f9dc29fac00000000000000000000000000000000000000000000000000000000815233600482015260248101929092525173ffffffffffffffffffffffffffffffffffffffff90921691639dc29fac9160448082019260009290919082900301818387803b15801561169e57600080fd5b505af11580156116b2573d6000803e3d6000fd5b50505050505b805482546116e09173ffffffffffffffffffffffffffffffffffffffff9091169033906124f9565b80546040805191825251849133917fbb757047c2b5f3974fe26b7c10f732e7bce710b0952a71082702781e62ae05959181900360200190a360008082556001909101555050565b60015473ffffffffffffffffffffffffffffffffffffffff1681565b60095460005b818110156117625761175a8161107a565b600101611749565b5050565b61176e612586565b60005473ffffffffffffffffffffffffffffffffffffffff9081169116146117f757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b8261184d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602a815260200180612f08602a913960400191505060405180910390fd5b801561185b5761185b611743565b816009848154811061186957fe5b906000526020600020906004020160010154146119215760006009848154811061188f57fe5b906000526020600020906004020160010154905082600985815481106118b157fe5b9060005260206000209060040201600101819055506118e5836118df83600b5461242090919063ffffffff16565b9061236a565b600b556118f0612658565b6040518390859033907f9eca8f7bcfb868d72b4ed95b71c627c194ab6bcb9b83adb2280e8a0320bb847690600090a4505b505050565b61192e612586565b60005473ffffffffffffffffffffffffffffffffffffffff9081169116146119b757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6000805460405173ffffffffffffffffffffffffffffffffffffffff909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169055565b60025473ffffffffffffffffffffffffffffffffffffffff1681565b60005473ffffffffffffffffffffffffffffffffffffffff1690565b600082821015611ab9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526024815260200180612ee46024913960400191505060405180910390fd5b600c548311611aca57600c54611acc565b825b9250600c54821015611ae057506000611074565b6008548310611afa57611af38284612420565b9050611074565b60008383825b600754811015611bb957600060078281548110611b1957fe5b9060005260206000200154905080841015611b6b576000611b5660068481548110611b4057fe5b60009182526020909120015461100d8488612420565b91945084919050611b67868261236a565b9550505b80831015611bb0576000611b9b60068481548110611b8557fe5b60009182526020909120015461100d8487612420565b91935083919050611bac8682612420565b9550505b50600101611b00565b506008548510611bea576000611bda6008548761242090919063ffffffff16565b9050611be6848261236a565b9350505b829350505050611074565b600a6020908152600092835260408084209091529082529020805460019091015482565b60078181548110610b5857fe5b600154604080517f70a08231000000000000000000000000000000000000000000000000000000008152336004820152905160009273ffffffffffffffffffffffffffffffffffffffff16916370a08231916024808301926020929190829003018186803b158015611c9757600080fd5b505afa158015611cab573d6000803e3d6000fd5b505050506040513d6020811015611cc157600080fd5b5051905081811015611d1e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526024815260200180612f326024913960400191505060405180910390fd5b600154604080517f9dc29fac00000000000000000000000000000000000000000000000000000000815233600482015260248101859052905173ffffffffffffffffffffffffffffffffffffffff90921691639dc29fac9160448082019260009290919082900301818387803b158015611d9757600080fd5b505af1158015611dab573d6000803e3d6000fd5b50506040805185815290513393507fbff75c9bae03d397e5737a568c16119d3ff3f29467d966dfca0acd2a3b2604d492509081900360200190a25050565b60055481565b60045473ffffffffffffffffffffffffffffffffffffffff163314611e7557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600d60248201527f536574204465763a207775743f00000000000000000000000000000000000000604482015290519081900360640190fd5b73ffffffffffffffffffffffffffffffffffffffff8116611ef757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601660248201527f43616e6e6f74206265207a65726f206164647265737300000000000000000000604482015290519081900360640190fd5b600480547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff831690811790915560405133907f7b4a3682445cf2b8276b6dde2faa9f9a653ea60d9ebadf169518e64f55666aae90600090a350565b60045473ffffffffffffffffffffffffffffffffffffffff1681565b81611ff057604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f6465706f736974205749474f206279207374616b696e67000000000000000000604482015290519081900360640190fd5b600060098381548110611fff57fe5b60009182526020808320868452600a825260408085203386529092529220600490910290910191506120308461107a565b80541561207957600061206582600101546107be64e8d4a510006107b8876003015487600001546122f090919063ffffffff16565b90508015612077576120773382612462565b505b82156120b25781546120a39073ffffffffffffffffffffffffffffffffffffffff1633308661271d565b80546120af908461236a565b81555b600382015481546120cd9164e8d4a51000916107b8916122f0565b600190910155505050565b607d81565b60035473ffffffffffffffffffffffffffffffffffffffff16331461216357604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f5365742054726561737572793a207775743f0000000000000000000000000000604482015290519081900360640190fd5b73ffffffffffffffffffffffffffffffffffffffff81166121e557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601660248201527f43616e6e6f74206265207a65726f206164647265737300000000000000000000604482015290519081900360640190fd5b600380547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff831690811790915560405133907f190c262dc6f09322c68a13bf67c9659e58367755ba6190fa7ce5ca8aa45a877d90600090a350565b61225e612586565b60005473ffffffffffffffffffffffffffffffffffffffff9081169116146122e757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6114ea8161291d565b6000826122ff57506000611074565b8282028284828161230c57fe5b0414612363576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526021815260200180612ec36021913960400191505060405180910390fd5b9392505050565b60008282018381101561236357604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b600061236383836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612a16565b600061236383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612ad2565b600254604080517f28ec1e2900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff858116600483015260248201859052915191909216916328ec1e2991604480830192600092919082900301818387803b1580156124dd57600080fd5b505af11580156124f1573d6000803e3d6000fd5b505050505050565b6040805173ffffffffffffffffffffffffffffffffffffffff8416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052611921908490612b46565b3390565b60095460005b81811015611921578273ffffffffffffffffffffffffffffffffffffffff16600982815481106125bc57fe5b600091825260209091206004909102015473ffffffffffffffffffffffffffffffffffffffff16141561265057604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f4164643a20706f6f6c20616c7265616479206578697374732121212100000000604482015290519081900360640190fd5b600101612590565b600954600060015b828110156126a3576126996009828154811061267857fe5b9060005260206000209060040201600101548361236a90919063ffffffff16565b9150600101612660565b508015611762576126b58160046123de565b90506126ef816118df60096000815481106126cc57fe5b906000526020600020906004020160010154600b5461242090919063ffffffff16565b600b8190555080600960008154811061270457fe5b9060005260206000209060040201600101819055505050565b6040805173ffffffffffffffffffffffffffffffffffffffff80861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f23b872dd000000000000000000000000000000000000000000000000000000001790526127b2908590612b46565b50505050565b600080612901607d60196103e801016107b86103e861100d600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561283857600080fd5b505afa15801561284c573d6000803e3d6000fd5b505050506040513d602081101561286257600080fd5b5051600154604080517fd5abeb01000000000000000000000000000000000000000000000000000000008152905173ffffffffffffffffffffffffffffffffffffffff9092169163d5abeb0191600480820192602092909190829003018186803b1580156128cf57600080fd5b505afa1580156128e3573d6000803e3d6000fd5b505050506040513d60208110156128f957600080fd5b505190612420565b90508281101561291357809150612917565b8291505b50919050565b73ffffffffffffffffffffffffffffffffffffffff8116612989576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526026815260200180612e776026913960400191505060405180910390fd5b6000805460405173ffffffffffffffffffffffffffffffffffffffff808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b60008183612abc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b83811015612a81578181015183820152602001612a69565b50505050905090810190601f168015612aae5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b506000838581612ac857fe5b0495945050505050565b60008184841115612b3e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201818152835160248401528351909283926044909101919085019080838360008315612a81578181015183820152602001612a69565b505050900390565b6060612ba8826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16612c1e9092919063ffffffff16565b80519091501561192157808060200190516020811015612bc757600080fd5b5051611921576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602a815260200180612f7d602a913960400191505060405180910390fd5b6060612c2d8484600085612c35565b949350505050565b606082471015612c90576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526026815260200180612e9d6026913960400191505060405180910390fd5b612c9985612df0565b612d0457604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b600060608673ffffffffffffffffffffffffffffffffffffffff1685876040518082805190602001908083835b60208310612d6e57805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101612d31565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d8060008114612dd0576040519150601f19603f3d011682016040523d82523d6000602084013e612dd5565b606091505b5091509150612de5828286612df6565b979650505050505050565b3b151590565b60608315612e05575081612363565b825115612e155782518084602001fd5b6040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201818152845160248401528451859391928392604401919085019080838360008315612a81578181015183820152602001612a6956fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373416464726573733a20696e73756666696369656e742062616c616e636520666f722063616c6c536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774d756c7469706c6965723a205f66726f6d20697320626967676572207468616e205f746f596f752063616e27742073657420616c6c6f63506f696e7420666f72207374616b696e6720706f6f6c2e4275726e696e673a20596f7520646f6e27742068617665205749474f20656e6f7567682177697468647261773a20596f7520646f206e6f74206861766520656e6f75676820785749474f215361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564456d657267656e637957697468647261773a20596f7520646f206e6f74206861766520656e6f75676820785749474f21a264697066735822122086a4f4d456f31bc6ea158ffe0e78ea7ef73c1fa2dd50513b0ba63d0bb08eb82064736f6c634300060c0033536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77000000000000000000000000e992beab6659bff447893641a378fbbf031c5bd6000000000000000000000000b9bbe9355828a1ad0e2d605480f969c6903ad9e40000000000000000000000006571c18ddea876ce67932be7115a4e2d11b5d94300000000000000000000000061e468f685392948504da7a49463fd508ec1e2cd0000000000000000000000000000000000000000000000007ce66c50e2840000000000000000000000000000000000000000000000000000000000006203bad00000000000000000000000000000000000000000000000000000000000278d00

000000000000000000000000e992beab6659bff447893641a378fbbf031c5bd6000000000000000000000000b9bbe9355828a1ad0e2d605480f969c6903ad9e40000000000000000000000006571c18ddea876ce67932be7115a4e2d11b5d94300000000000000000000000061e468f685392948504da7a49463fd508ec1e2cd0000000000000000000000000000000000000000000000007ce66c50e2840000000000000000000000000000000000000000000000000000000000006203bad00000000000000000000000000000000000000000000000000000000000278d00

-----Decoded View---------------
Arg [0] : _wigo (address): 0xe992beab6659bff447893641a378fbbf031c5bd6
Arg [1] : _bank (address): 0xb9bbe9355828a1ad0e2d605480f969c6903ad9e4
Arg [2] : _treasuryAddr (address): 0x6571c18ddea876ce67932be7115a4e2d11b5d943
Arg [3] : _devAddr (address): 0x61e468f685392948504da7a49463fd508ec1e2cd
Arg [4] : _wigoPerSecond (uint256): 9000000000000000000
Arg [5] : _startBlockTime (uint256): 1644411600
Arg [6] : _changeMultiplierAfterTime (uint256): 2592000

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000e992beab6659bff447893641a378fbbf031c5bd6
Arg [1] : 000000000000000000000000b9bbe9355828a1ad0e2d605480f969c6903ad9e4
Arg [2] : 0000000000000000000000006571c18ddea876ce67932be7115a4e2d11b5d943
Arg [3] : 00000000000000000000000061e468f685392948504da7a49463fd508ec1e2cd
Arg [4] : 0000000000000000000000000000000000000000000000007ce66c50e2840000
Arg [5] : 000000000000000000000000000000000000000000000000000000006203bad0
Arg [6] : 0000000000000000000000000000000000000000000000000000000000278d00

38083:16975:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42233:95;;;:::i;:::-;;;;;;;;;;;;;;;;40512:29;;;:::i;52192:926::-;;;;;;;;;;;;;;;;-1:-1:-1;52192:926:0;;:::i;:::-;;40182:26;;;;;;;;;;;;;;;;-1:-1:-1;40182:26:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40423:34;;;:::i;42723:805::-;;;;;;;;;;;;;;;;-1:-1:-1;42723:805:0;;;;;;;;;;;;;;;;:::i;39751:64::-;;;;;;;;;;;;;;;;-1:-1:-1;39751:64:0;;:::i;39539:27::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40097:49;;;:::i;51274:867::-;;;;;;;;;;;;;;;;-1:-1:-1;51274:867:0;;:::i;50450:774::-;;;;;;;;;;;;;;;;-1:-1:-1;50450:774:0;;;;;;;:::i;39946:35::-;;;:::i;46795:1004::-;;;;;;;;;;;;;;;;-1:-1:-1;46795:1004:0;;;;;;;;;:::i;48138:1289::-;;;;;;;;;;;;;;;;-1:-1:-1;48138:1289:0;;:::i;53495:664::-;;;;;;;;;;;;;;;;-1:-1:-1;53495:664:0;;:::i;39422:21::-;;;:::i;47882:180::-;;;:::i;43624:663::-;;;;;;;;;;;;;;;;-1:-1:-1;43624:663:0;;;;;;;;;;;;;;:::i;23549:140::-;;;:::i;39486:20::-;;;:::i;22907:79::-;;;:::i;44861:1352::-;;;;;;;;;;;;;;;;-1:-1:-1;44861:1352:0;;;;;;;:::i;40264:64::-;;;;;;;;;;;;;;;;-1:-1:-1;40264:64:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;39855:42;;;;;;;;;;;;;;;;-1:-1:-1;39855:42:0;;:::i;53155:269::-;;;;;;;;;;;;;;;;-1:-1:-1;53155:269:0;;:::i;39668:28::-;;;:::i;54807:248::-;;;;;;;;;;;;;;;;-1:-1:-1;54807:248:0;;;;:::i;39599:22::-;;;:::i;49498:898::-;;;;;;;;;;;;;;;;-1:-1:-1;49498:898:0;;;;;;;:::i;40045:45::-;;;:::i;54458:293::-;;;;;;;;;;;;;;;;-1:-1:-1;54458:293:0;;;;:::i;23844:109::-;;;;;;;;;;;;;;;;-1:-1:-1;23844:109:0;;;;:::i;42233:95::-;42305:8;:15;42233:95;:::o;40512:29::-;;;;:::o;52192:926::-;52249:21;52273:8;52282:1;52273:11;;;;;;;;;;;;;;;;52331:10;52319:23;;;:11;:23;;:11;:23;;;52379:4;;:26;;;;;52273:11;52379:26;;;;;;;;;52273:11;;;;;;;;-1:-1:-1;52319:23:0;;52273:11;52319:23;52379:4;;:14;;:26;;;;;;;;;;;:4;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52379:26:0;;-1:-1:-1;52438:26:0;;;;52416:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52550:11;;:22;-1:-1:-1;52550:22:0;52542:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52606:13;52617:1;52606:10;:13::i;:::-;52630:15;52648:92;52714:4;:15;;;52648:47;52690:4;52648:37;52664:4;:20;;;52648:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47::i;:::-;:51;;:92::i;:::-;52630:110;-1:-1:-1;52755:11:0;;52751:81;;52783:37;52800:10;52812:7;52783:16;:37::i;:::-;52846:11;;52842:152;;52888:11;;:24;;52904:7;52888:15;:24::i;:::-;52874:38;;52927:12;;:55;;:12;;52961:10;52974:7;52927:25;:55::i;:::-;53038:20;;;;53022:11;;:47;;53064:4;;53022:37;;:15;:37::i;:47::-;53004:15;;;:65;53080:4;;:30;;;;;;53090:10;53080:30;;;;;;;;;;;;:4;;;;;:9;;:30;;;;;:4;;:30;;;;;;;;:4;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52192:926;;;;;:::o;40182:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40182:26:0;;;:::o;40423:34::-;;;;:::o;42723:805::-;23129:12;:10;:12::i;:::-;23119:6;;:22;:6;;;:22;;;23111:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42854:27:::1;42872:8;42854:17;:27::i;:::-;42936:11;42932:61;;;42964:17;:15;:17::i;:::-;43003:27;43051:14;;43033:15;:32;:93;;43112:14;;43033:93;;;43081:15;43033:93;43155:15;::::0;43003:123;;-1:-1:-1;43155:32:0::1;::::0;43175:11;43155:19:::1;:32::i;:::-;43137:15;:50:::0;43226:199:::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;43226:199:0;;;;;;43198:8:::1;:238:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;43447:19:::1;:17;:19::i;:::-;43482:38;::::0;43508:11;;43482:38:::1;::::0;::::1;::::0;43486:10:::1;::::0;43482:38:::1;::::0;;;::::1;23189:1;42723:805:::0;;;:::o;39751:64::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39751:64:0;:::o;39539:27::-;;;;;;:::o;40097:49::-;40144:2;40097:49;:::o;51274:867::-;51331:21;51355:8;51364:1;51355:11;;;;;;;;;;;;;;;;51413:10;51401:23;;:11;:23;;;:11;:23;;51355:11;;;;;;-1:-1:-1;51401:23:0;51435:13;;:10;:13::i;:::-;51463:11;;:15;51459:309;;51495:15;51513:140;51637:4;:15;;;51513:101;51609:4;51513:73;51565:4;:20;;;51513:4;:29;;;:51;;:73;;;;:::i;:140::-;51495:158;-1:-1:-1;51672:11:0;;51668:89;;51704:37;51721:10;51733:7;51704:16;:37::i;:::-;51459:309;;51782:11;;51778:237;;51810:12;;:140;;:12;;51866:10;51904:4;51928:7;51810:29;:140::i;:::-;51979:11;;:24;;51995:7;51979:15;:24::i;:::-;51965:38;;51778:237;52059:20;;;;52043:11;;:47;;52085:4;;52043:37;;:15;:37::i;:47::-;52025:15;;;:65;52103:4;;:30;;;;;;52113:10;52103:30;;;;;;;;;;;;:4;;;;;:9;;:30;;;;;:4;;:30;;;;;;;;:4;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51274:867;;;:::o;50450:774::-;50525:9;50517:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50576:21;50600:8;50609:4;50600:14;;;;;;;;;;;;;;;;50649;;;:8;:14;;;;;;50664:10;50649:26;;;;;;;50694:11;;50600:14;;;;;;;;-1:-1:-1;50694:22:0;-1:-1:-1;50694:22:0;50686:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50750:16;50761:4;50750:10;:16::i;:::-;50777:15;50795:92;50861:4;:15;;;50795:47;50837:4;50795:37;50811:4;:20;;;50795:4;:11;;;:15;;:37;;;;:::i;:92::-;50777:110;-1:-1:-1;50902:11:0;;50898:81;;50930:37;50947:10;50959:7;50930:16;:37::i;:::-;50993:11;;50989:152;;51035:11;;:24;;51051:7;51035:15;:24::i;:::-;51021:38;;51074:12;;:55;;:12;;51108:10;51121:7;51074:25;:55::i;:::-;51185:20;;;;51169:11;;:47;;51211:4;;51169:37;;:15;:37::i;:47::-;51151:4;:15;;:65;;;;50450:774;;;;;:::o;39946:35::-;;;;:::o;46795:1004::-;46895:7;46920:21;46944:8;46953:4;46944:14;;;;;;;;;;;;;;;;46993;;;:8;:14;;;;;;:21;;;;;;;;;;;;46944:14;;;;;;;47051:20;;;;47101:12;;:37;;;;;47132:4;47101:37;;;;;;;;;46944:14;;-1:-1:-1;46993:21:0;;47051:20;;46944:14;;47101:12;;;;;:22;;:37;;;;;46944:14;;47101:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47101:37:0;47171:24;;;;47101:37;;-1:-1:-1;47153:15:0;:42;:59;;;;-1:-1:-1;47199:13:0;;;47153:59;47149:562;;;47229:18;47250:105;47282:4;:24;;;47325:15;47250:13;:105::i;:::-;47229:126;;47370:20;47393:125;47502:15;;47393:86;47463:4;:15;;;47393:47;47426:13;;47393:10;:32;;:47;;;;:::i;:::-;:69;;:86::i;:125::-;47370:148;;47533:18;47554:25;47566:12;47554:11;:25::i;:::-;47533:46;-1:-1:-1;47612:87:0;47650:34;47675:8;47650:20;47533:46;47665:4;47650:14;:20::i;:34::-;47612:15;;:19;:87::i;:::-;47594:105;;47149:562;;;;47728:63;47775:4;:15;;;47728:42;47765:4;47728:32;47744:15;47728:4;:11;;;:15;;:32;;;;:::i;:63::-;47721:70;;;;;;46795:1004;;;;;:::o;48138:1289::-;48190:21;48214:8;48223:4;48214:14;;;;;;;;;;;;;;;;;;48190:38;;48262:4;:24;;;48243:15;:43;48239:82;;48303:7;;;48239:82;48350:12;;:37;;;;;;48381:4;48350:37;;;;;;48331:16;;48350:12;;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48350:37:0;;-1:-1:-1;48402:13:0;48398:109;;-1:-1:-1;48459:15:0;48432:24;;;;:42;48489:7;;48398:109;48517:18;48538:93;48566:4;:24;;;48605:15;48538:13;:93::i;:::-;48517:114;;48642:20;48665:113;48762:15;;48665:78;48727:4;:15;;;48665:43;48694:13;;48665:10;:28;;:43;;;;:::i;:113::-;48642:136;;48789:18;48810:25;48822:12;48810:11;:25::i;:::-;48789:46;;48961:4;;;;;;;;;;;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48961:16:0;48940:4;;:18;;;;;;;;:4;;;;;:16;;:18;;;;;48961:16;;48940:18;;;;;;;;:4;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48940:18:0;:37;48936:266;;;48994:4;;49004:7;;48994:4;;;;;:9;;49004:7;49013:41;49049:4;49013:31;:10;40087:3;49013:14;:31::i;:41::-;48994:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49070:4:0;;49098:12;;49070:4;;;;;-1:-1:-1;49070:9:0;;-1:-1:-1;49098:12:0;49129:46;49170:4;49129:36;:10;40144:2;49129:14;:36::i;:46::-;49070:120;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48936:266;49212:4;;49230;;49212:36;;;;;;:4;49230;;;49212:36;;;;;;;;;;;;:4;;;;;:9;;:36;;;;;:4;;:36;;;;;;;:4;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49282:84;49321:34;49346:8;49321:20;49336:4;49321:10;:14;;:20;;;;:::i;:34::-;49282:20;;;;;:24;:84::i;:::-;49259:20;;;:107;-1:-1:-1;;49404:15:0;49377:24;;;;:42;;;;-1:-1:-1;;48138:1289:0;;:::o;53495:664::-;53554:21;53578:8;53587:4;53578:14;;;;;;;;;;;;;;;;53627;;;:8;:14;;;;;;53642:10;53627:26;;;;;;;53578:14;;;;;;;;-1:-1:-1;53668:9:0;53664:298;;53720:4;;:26;;;;;;53735:10;53720:26;;;;;;53694:23;;53720:4;;;:14;;:26;;;;;;;;;;;;;;:4;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53720:26:0;53806:11;;53720:26;;-1:-1:-1;53787:30:0;;;53761:140;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53916:4;;53938:11;;53916:34;;;;;;53926:10;53916:34;;;;;;;;;;;;:4;;;;;:9;;:34;;;;;:4;;:34;;;;;;;;:4;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53664:298;;54019:11;;53972:12;;:59;;:12;;;;;54006:10;;53972:25;:59::i;:::-;54083:11;;54047:48;;;;;;;54077:4;;54065:10;;54047:48;;;;;;;;;54120:1;54106:15;;;54132;;;;:19;-1:-1:-1;;53495:664:0:o;39422:21::-;;;;;;:::o;47882:180::-;47944:8;:15;47927:14;47970:85;47998:6;47992:3;:12;47970:85;;;48028:15;48039:3;48028:10;:15::i;:::-;48006:5;;47970:85;;;;47882:180;:::o;43624:663::-;23129:12;:10;:12::i;:::-;23119:6;;:22;:6;;;:22;;;23111:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43760:9;43752:64:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43831:11;43827:61;;;43859:17;:15;:17::i;:::-;43931:11;43902:8;43911:4;43902:14;;;;;;;;;;;;;;;;;;:25;;;:40;43898:382;;43959:22;43984:8;43993:4;43984:14;;;;;;;;;;;;;;;;;;:25;;;43959:50;;44052:11;44024:8;44033:4;44024:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;44096:84;44154:11;44096:35;44116:14;44096:15;;:19;;:35;;;;:::i;:::-;:39:::0;::::1;:84::i;:::-;44078:15;:102:::0;44195:19:::1;:17;:19::i;:::-;44234:34;::::0;44256:11;;44250:4;;44238:10:::1;::::0;44234:34:::1;::::0;;;::::1;43898:382;;43624:663:::0;;;:::o;23549:140::-;23129:12;:10;:12::i;:::-;23119:6;;:22;:6;;;:22;;;23111:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23648:1:::1;23632:6:::0;;23611:40:::1;::::0;::::1;23632:6:::0;;::::1;::::0;23611:40:::1;::::0;23648:1;;23611:40:::1;23679:1;23662:19:::0;;;::::1;::::0;;23549:140::o;39486:20::-;;;;;;:::o;22907:79::-;22945:7;22972:6;;;22907:79;:::o;44861:1352::-;44960:7;45000:5;44993:3;:12;;44985:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45073:14;;45065:5;:22;:47;;45098:14;;45065:47;;;45090:5;45065:47;45057:55;;45133:14;;45127:3;:20;45123:61;;;-1:-1:-1;45171:1:0;45164:8;;45123:61;45207:20;;45198:5;:29;45194:1012;;45251:14;:3;45259:5;45251:7;:14::i;:::-;45244:21;;;;45194:1012;45298:14;45350:5;45387:3;45298:14;45405:598;45429:25;:32;45425:36;;45405:598;;;45487:15;45505:25;45531:1;45505:28;;;;;;;;;;;;;;;;45487:46;;45567:7;45556:8;:18;45552:212;;;45599:9;45611:47;45637:17;45655:1;45637:20;;;;;;;;;;;;;;;;;;45611:21;:7;45623:8;45611:11;:21::i;:47::-;45692:7;;-1:-1:-1;45692:7:0;;45599:59;-1:-1:-1;45731:13:0;:6;45599:59;45731:10;:13::i;:::-;45722:22;;45552:212;;45795:7;45786:6;:16;45782:206;;;45827:9;45839:45;45863:17;45881:1;45863:20;;;;;;;;;;;;;;;;;;45839:19;:7;45851:6;45839:11;:19::i;:45::-;45916:7;;-1:-1:-1;45916:7:0;;45827:57;-1:-1:-1;45955:13:0;:6;45827:57;45955:10;:13::i;:::-;45946:22;;45782:206;;-1:-1:-1;45463:3:0;;45405:598;;;;46028:20;;46021:3;:27;46017:150;;46069:9;46081:29;46089:20;;46081:3;:7;;:29;;;;:::i;:::-;46069:41;-1:-1:-1;46138:13:0;:6;46069:41;46138:10;:13::i;:::-;46129:22;;46017:150;;46188:6;46181:13;;;;;;;40264:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;39855:42::-;;;;;;;;;;53155:269;53226:4;;:26;;;;;;53241:10;53226:26;;;;;;53208:15;;53226:4;;;:14;;:26;;;;;;;;;;;;;;:4;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53226:26:0;;-1:-1:-1;53271:18:0;;;;53263:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53341:4;;:30;;;;;;53351:10;53341:30;;;;;;;;;;;;:4;;;;;:9;;:30;;;;;:4;;:30;;;;;;;;:4;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53387:29:0;;;;;;;;53396:10;;-1:-1:-1;53387:29:0;;-1:-1:-1;53387:29:0;;;;;;;;53155:269;;:::o;39668:28::-;;;;:::o;54807:248::-;54881:7;;;;54867:10;:21;54859:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54925:22;;;54917:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54985:7;:18;;;;;;;;;;;;;55019:28;;55026:10;;55019:28;;-1:-1:-1;;55019:28:0;54807:248;:::o;39599:22::-;;;;;;:::o;49498:898::-;49572:9;49564:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49620:21;49644:8;49653:4;49644:14;;;;;;;;;;;;;;;;49693;;;:8;:14;;;;;;49708:10;49693:26;;;;;;;49644:14;;;;;;;;-1:-1:-1;49730:16:0;49702:4;49730:10;:16::i;:::-;49761:11;;:15;49757:309;;49793:15;49811:140;49935:4;:15;;;49811:101;49907:4;49811:73;49863:4;:20;;;49811:4;:29;;;:51;;:73;;;;:::i;:140::-;49793:158;-1:-1:-1;49970:11:0;;49966:89;;50002:37;50019:10;50031:7;50002:16;:37::i;:::-;49757:309;;50080:11;;50076:237;;50108:12;;:140;;:12;;50164:10;50202:4;50226:7;50108:29;:140::i;:::-;50277:11;;:24;;50293:7;50277:15;:24::i;:::-;50263:38;;50076:237;50357:20;;;;50341:11;;:47;;50383:4;;50341:37;;:15;:37::i;:47::-;50323:15;;;;:65;-1:-1:-1;;;49498:898:0:o;40045:45::-;40087:3;40045:45;:::o;54458:293::-;54542:12;;;;54528:10;:26;54520:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54596:27;;;54588:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54661:12;:28;;;;;;;;;;;;;54705:38;;54717:10;;54705:38;;-1:-1:-1;;54705:38:0;54458:293;:::o;23844:109::-;23129:12;:10;:12::i;:::-;23119:6;;:22;:6;;;:22;;;23111:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23917:28:::1;23936:8;23917:18;:28::i;2348:471::-:0;2406:7;2651:6;2647:47;;-1:-1:-1;2681:1:0;2674:8;;2647:47;2718:5;;;2722:1;2718;:5;:1;2742:5;;;;;:10;2734:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2810:1;2348:471;-1:-1:-1;;;2348:471:0:o;960:181::-;1018:7;1050:5;;;1074:6;;;;1066:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3295:132;3353:7;3380:39;3384:1;3387;3380:39;;;;;;;;;;;;;;;;;:3;:39::i;1424:136::-;1482:7;1509:43;1513:1;1516;1509:43;;;;;;;;;;;;;;;;;:3;:43::i;54273:119::-;54349:4;;:35;;;;;;:4;:35;;;;;;;;;;;;;;;:4;;;;;:21;;:35;;;;;:4;;:35;;;;;;;:4;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54273:119;;:::o;17069:248::-;17240:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17263:23;17240:58;;;17186:123;;17220:5;;17186:19;:123::i;21440:106::-;21528:10;21440:106;:::o;42336:312::-;42422:8;:15;42405:14;42448:193;42476:6;42470:3;:12;42448:193;;;42557:8;42532:33;;:8;42541:3;42532:13;;;;;;;;;;;;;;;;;;;;;:21;;;:33;;42506:123;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42484:5;;42448:193;;44295:485;44361:8;:15;44344:14;44435:1;44416:115;44444:6;44438:3;:12;44416:115;;;44483:36;44494:8;44503:3;44494:13;;;;;;;;;;;;;;;;;;:24;;;44483:6;:10;;:36;;;;:::i;:::-;44474:45;-1:-1:-1;44452:5:0;;44416:115;;;-1:-1:-1;44545:11:0;;44541:232;;44582:13;:6;44593:1;44582:10;:13::i;:::-;44573:22;;44628:87;44694:6;44628:43;44648:8;44657:1;44648:11;;;;;;;;;;;;;;;;;;:22;;;44628:15;;:19;;:43;;;;:::i;:87::-;44610:15;:105;;;;44755:6;44730:8;44739:1;44730:11;;;;;;;;;;;;;;;;;;:22;;:31;;;;44295:485;;:::o;17325:285::-;17523:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17546:27;17523:68;;;17469:133;;17503:5;;17469:19;:133::i;:::-;17325:285;;;;:::o;46291:440::-;46379:18;46415:15;46433:157;40087:3;40144:2;46544:4;:27;:45;46433:92;46520:4;46433:68;46482:4;;;;;;;;;;;:16;;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46482:18:0;46433:4;;:30;;;;;;;;:4;;;;;:28;;:30;;;;;46482:18;;46433:30;;;;;;;;:4;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46433:30:0;;:48;:68::i;:157::-;46415:175;;46615:7;46605;:17;46601:123;;;46652:7;46639:20;;46601:123;;;46705:7;46692:20;;46601:123;46291:440;;;;:::o;24059:266::-;24147:22;;;24125:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24272:6;;;24251:38;;;;;;;24272:6;;;24251:38;;;24300:6;:17;;;;;;;;;;;;;;;24059:266::o;3923:312::-;4043:7;4078:12;4071:5;4063:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4102:9;4118:1;4114;:5;;;;;;;3923:312;-1:-1:-1;;;;;3923:312:0:o;1863:226::-;1983:7;2019:12;2011:6;;;;2003:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2055:5:0;;;1863:226::o;19945:860::-;20369:23;20395:106;20437:4;20395:106;;;;;;;;;;;;;;;;;20403:5;20395:27;;;;:106;;;;;:::i;:::-;20516:17;;20369:132;;-1:-1:-1;20516:21:0;20512:286;;20689:10;20678:30;;;;;;;;;;;;;;;-1:-1:-1;20678:30:0;20652:134;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12640:229;12777:12;12809:52;12831:6;12839:4;12845:1;12848:12;12809:21;:52::i;:::-;12802:59;12640:229;-1:-1:-1;;;;12640:229:0:o;13856:632::-;14026:12;14098:5;14073:21;:30;;14051:118;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14188:18;14199:6;14188:10;:18::i;:::-;14180:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14314:12;14328:23;14355:6;:11;;14374:5;14395:4;14355:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14313:97;;;;14428:52;14446:7;14455:10;14467:12;14428:17;:52::i;:::-;14421:59;13856:632;-1:-1:-1;;;;;;;13856:632:0:o;9603:444::-;9983:20;10031:8;;;9603:444::o;15639:777::-;15789:12;15818:7;15814:595;;;-1:-1:-1;15849:10:0;15842:17;;15814:595;15963:17;;:21;15959:439;;16226:10;16220:17;16287:15;16274:10;16270:2;16266:19;16259:44;16174:148;16362:20;;;;;;;;;;;;;;;;;;;;16369:12;;16362:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://86a4f4d456f31bc6ea158ffe0e78ea7ef73c1fa2dd50513b0ba63d0bb08eb820