Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• library Counters
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
•    - function reset(Counter storage counte ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
•    - function migrate(uint256 amount)
•    - function incrementCounters(uint256 am ...
•    - function migrated()
•    - function seal()
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
•  contract XPower is ERC20, ERC20Bur ...
•    - function decimals()
•    - function init()
•    - function mint(uint256 nonce, bytes32 ...
•    - function _requireRecent(bytes32 block ...
•    - function _interval()
•    - function _hash(
•    - function _amount(bytes32 nonceHash)
•    - function _zeros(bytes32 nonceHash)
•  contract XPowerCpu is XPower
•    - function _hash(
•    - function _amount(bytes32 nonceHash)
•  contract XPowerGpu is XPower *
•    - function _hash(
•    - function _amount(bytes32 nonceHash)
•  contract XPowerAsic is XPower
•    - function _hash(
•    - function _amount(bytes32 nonceHash)
•  contract XPowerCpuTest is XPowerCp ...
•    - function interval()
•    - function hash(
•    - function amount(bytes32 _nonceHash)
•    - function zeros(bytes32 _nonceHash)
•  contract XPowerGpuTest is XPowerGp ... *
•    - function interval()
•    - function hash(
•    - function amount(bytes32 _nonceHash)
•    - function zeros(bytes32 _nonceHash)
•  contract XPowerAsicTest is XPowerA ...
•    - function interval()
•    - function hash(
•    - function amount(bytes32 _nonceHash)
•    - function zeros(bytes32 _nonceHash)

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at snowscan.xyz on 2021-11-15
*/

// Sources flattened with hardhat v2.6.8 https://hardhat.org
// File @openzeppelin/contracts/utils/[email protected]
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File @openzeppelin/contracts/utils/[email protected]


pragma solidity ^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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]


pragma solidity ^0.8.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.
 */
abstract 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() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual 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 virtual onlyOwner {
        _setOwner(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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity ^0.8.0;

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

    /**
     * @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 @openzeppelin/contracts/token/ERC20/extensions/[email protected]


pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]


pragma solidity ^0.8.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 Contracts guidelines: functions revert
 * instead 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, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

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

    /**
     * @dev See {IERC20-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 virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

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

    /**
     * @dev See {IERC20-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 virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        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 {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + 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 {IERC20-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 virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This 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 virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(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 virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This 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 virtual {
        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 Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}


// File contracts/Migratable.sol

// solhint-disable not-rely-on-time
pragma solidity ^0.8.0;




/**
 * Allows migration of tokens from an old contract upto a certain deadline.
 * Further, it is possible to close down the migration window earlier than
 * the specified deadline.
 */
abstract contract Migratable is ERC20, ERC20Burnable, Ownable {
    /** old contract to migrate from */
    ERC20Burnable private _token;
    /** timestamp of migration deadline */
    uint256 private _deadlineBy;
    /** flag to control migration */
    bool private _migratable = true;
    /** number of migrated tokens */
    uint256 private _migratedTotal = 0;
    uint256 private _migratedOther = 0;
    uint256 private _migratedOwner = 0;

    /** @param base address of old contract*/
    /** @param deadlineIn seconds to end-of-migration */
    constructor(address base, uint256 deadlineIn) {
        _deadlineBy = block.timestamp + deadlineIn;
        _token = ERC20Burnable(base);
    }

    /** import amount from old contract */
    function migrate(uint256 amount) public virtual {
        require(amount > 0, "non-positive amount");
        require(_migratable, "migration sealed");
        uint256 myAllowance = _token.allowance(msg.sender, address(this));
        require(amount <= myAllowance, "insufficient allowance");
        uint256 oldBalance = _token.balanceOf(msg.sender);
        require(amount <= oldBalance, "insufficient balance");
        uint256 timestamp = block.timestamp;
        require(_deadlineBy >= timestamp, "deadline passed");
        _token.burnFrom(msg.sender, amount);
        uint256 newBalance = _token.balanceOf(msg.sender);
        require(newBalance + amount == oldBalance, "invalid balance");
        _mint(msg.sender, amount);
        incrementCounters(amount);
    }

    /** ensure 2 * fund's is less than (or eq) to other's */
    function incrementCounters(uint256 amount) internal {
        if (msg.sender == owner()) {
            _migratedOwner += amount;
        } else {
            _migratedOther += amount;
        }
        if (2 * _migratedOwner > _migratedOther) {
            revert("fund's share > 33.33%");
        }
        _migratedTotal += amount;
    }

    /** @return number of migrated tokens */
    function migrated() public view returns (uint256) {
        return _migratedTotal;
    }

    /** seal migration (manually) */
    function seal() public onlyOwner {
        _migratable = false;
    }
}


// File @openzeppelin/contracts/utils/structs/[email protected]


pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File contracts/XPower.sol

// solhint-disable not-rely-on-time
// solhint-disable no-empty-blocks
pragma solidity ^0.8.0;




/**
 * Base class for the XPOW-CPU, XPOW-GPU & XPOW-ASIC proof-of-work tokens. It
 * verifies that the provided nonce & block-hash result in a positive amount,
 * as specified by the sub-classes. After the verification, the corresponding
 * number of tokens are minted for the sender (plus for the project fund).
 */
contract XPower is ERC20, ERC20Burnable, Ownable, Migratable {
    using EnumerableSet for EnumerableSet.UintSet;
    /** set of nonce-hashes already minted for */
    EnumerableSet.UintSet private _hashes;
    /** map from block-hashes to timestamps */
    mapping(bytes32 => uint256) internal _timestamps;
    /** current snapshot identifier */
    uint256 private _snapshotId = 0;

    constructor(
        string memory symbol,
        address base,
        uint256 deadlineIn
    )
        // ERC20 constructor: name, symbol
        ERC20("XPower", symbol)
        // Migratable: old contract, rel. deadline [seconds]
        Migratable(base, deadlineIn)
    {}

    /** @return number of decimal places of the token */
    function decimals() public pure override returns (uint8) {
        return 0;
    }

    /** emitted on caching most recent block-hash */
    event Init(bytes32 blockHash, uint256 timestamp);

    /** cache most recent block-hash */
    function init() public {
        bytes32 blockHash = blockhash(block.number - 1);
        require(blockHash > 0, "invalid block-hash");
        uint256 timestamp = block.timestamp;
        require(timestamp > 0, "invalid timestamp");
        _timestamps[blockHash] = timestamp;
        emit Init(blockHash, timestamp);
    }

    /** mint tokens for nonce, sender, interval and block-hash */
    function mint(uint256 nonce, bytes32 blockHash) public {
        // get current interval (in hours)
        uint256 interval = _interval();
        // check block-hash to be recent
        _requireRecent(blockHash, interval);
        // calculate nonce-hash of nonce for sender, interval & block-hash
        bytes32 nonceHash = _hash(nonce, msg.sender, interval, blockHash);
        require(!_hashes.contains(uint256(nonceHash)), "duplicate nonce-hash");
        // calculate amount of tokens for nonce-hash
        uint256 amount = _amount(nonceHash);
        require(amount > 0, "empty nonce-hash");
        // ensure unique nonce-hash (to be used once)
        _hashes.add(uint256(nonceHash));
        // mint tokens for minter (i.e. nonce provider)
        _mint(msg.sender, amount);
        // mint tokens for owner (5.88% of total supply)
        if (amount / 2 > 0) _mint(owner(), amount / 2);
    }

    /** check whether block-hash has recently been cached or is recent */
    function _requireRecent(bytes32 blockHash, uint256 interval) internal view {
        require(blockHash > 0, "invalid block-hash");
        uint256 timestamp = _timestamps[blockHash];
        if (timestamp / (1 hours) != interval) {
            for (uint256 i = 1; i <= 256; i++) {
                if (block.number >= i && blockhash(block.number - i) == blockHash) {
                    return; // block-hash is within the last 256 blocks
                }
            }
            revert("expired block-hash");
        }
    }

    /** @return current interval (in hours) */
    function _interval() internal view returns (uint256) {
        uint256 interval = block.timestamp / (1 hours);
        require(interval > 0, "invalid interval");
        return interval;
    }

    /** @return hash of nonce for sender, interval & block-hash */
    function _hash(
        uint256 nonce,
        address sender,
        uint256 interval,
        bytes32 blockHash
    ) internal pure virtual returns (bytes32) {
        return keccak256(abi.encode("XPOW", nonce, sender, interval, blockHash));
    }

    /** @return amount for provided nonce-hash */
    function _amount(bytes32 nonceHash) internal pure virtual returns (uint256) {
        require(nonceHash >= 0, "invalid nonce-hash");
        return 0;
    }

    /** @return leading zeros for nonce-hash */
    function _zeros(bytes32 nonceHash) internal pure returns (uint8) {
        uint8 counter = 0;
        for (uint8 i = 0; i < 32; i++) {
            bytes1 b = nonceHash[i];
            if (b == 0x00) {
                counter += 2;
                continue;
            }
            if (
                b == 0x01 ||
                b == 0x02 ||
                b == 0x03 ||
                b == 0x04 ||
                b == 0x05 ||
                b == 0x06 ||
                b == 0x07 ||
                b == 0x08 ||
                b == 0x09 ||
                b == 0x0a ||
                b == 0x0b ||
                b == 0x0c ||
                b == 0x0d ||
                b == 0x0e ||
                b == 0x0f
            ) {
                counter += 1;
                break;
            }
            break;
        }
        return counter;
    }
}

/**
 * Allow mining & minting for XPOW.CPU proof-of-work tokens, where the rewarded
 * amount equals to *only* |leading-zeros(nonce-hash)|.
 */
contract XPowerCpu is XPower {
    constructor(address _base, uint256 _deadlineIn) XPower("XPOW.CPU", _base, _deadlineIn) {}

    /** @return hash of nonce for sender, interval & block-hash */
    function _hash(
        uint256 nonce,
        address sender,
        uint256 interval,
        bytes32 blockHash
    ) internal pure override returns (bytes32) {
        return keccak256(abi.encode("XPOW.CPU", nonce, sender, interval, blockHash));
    }

    /** @return amount for provided nonce-hash */
    function _amount(bytes32 nonceHash) internal pure override returns (uint256) {
        return _zeros(nonceHash);
    }
}

/**
 * Allow mining & minting for XPOW.GPU proof-of-work tokens, where the rewarded
 * amount equals to 2 ^ |leading-zeros(nonce-hash)| - 1.
 */
contract XPowerGpu is XPower {
    constructor(address _base, uint256 _deadlineIn) XPower("XPOW.GPU", _base, _deadlineIn) {}

    /** @return hash of nonce for sender, interval & block-hash */
    function _hash(
        uint256 nonce,
        address sender,
        uint256 interval,
        bytes32 blockHash
    ) internal pure override returns (bytes32) {
        return keccak256(abi.encode("XPOW.GPU", nonce, sender, interval, blockHash));
    }

    /** @return amount for provided nonce-hash */
    function _amount(bytes32 nonceHash) internal pure override returns (uint256) {
        return 2**_zeros(nonceHash) - 1;
    }
}

/**
 * Allow mining & minting for XPOW.ASIC proof-of-work tokens, where the rewarded
 * amount equals to 16 ^ |leading-zeros(nonce-hash)| - 1.
 */
contract XPowerAsic is XPower {
    constructor(address _base, uint256 _deadlineIn) XPower("XPOW.ASIC", _base, _deadlineIn) {}

    /** @return hash of nonce for sender, interval & block-hash */
    function _hash(
        uint256 nonce,
        address sender,
        uint256 interval,
        bytes32 blockHash
    ) internal pure override returns (bytes32) {
        return keccak256(abi.encode("XPOW.ASIC", nonce, sender, interval, blockHash));
    }

    /** @return amount for provided nonce-hash */
    function _amount(bytes32 nonceHash) internal pure override returns (uint256) {
        return 16**_zeros(nonceHash) - 1;
    }
}


// File contracts/XPowerTest.sol

// solhint-disable not-rely-on-time
// solhint-disable no-empty-blocks
pragma solidity ^0.8.0;

/** Test class for XPowerCpu */
contract XPowerCpuTest is XPowerCpu {
    constructor(address _base, uint256 _deadlineIn) XPowerCpu(_base, _deadlineIn) {}

    function interval() public view returns (uint256) {
        return _interval();
    }

    function hash(
        uint256 _nonce,
        address _sender,
        uint256 _interval,
        bytes32 _blockHash
    ) public pure returns (bytes32) {
        return _hash(_nonce, _sender, _interval, _blockHash);
    }

    function amount(bytes32 _nonceHash) public pure returns (uint256) {
        return _amount(_nonceHash);
    }

    function zeros(bytes32 _nonceHash) public pure returns (uint8) {
        return _zeros(_nonceHash);
    }
}

/** Test class for XPowerGpu */
contract XPowerGpuTest is XPowerGpu {
    constructor(address _base, uint256 _deadlineIn) XPowerGpu(_base, _deadlineIn) {}

    function interval() public view returns (uint256) {
        return _interval();
    }

    function hash(
        uint256 _nonce,
        address _sender,
        uint256 _interval,
        bytes32 _blockHash
    ) public pure returns (bytes32) {
        return _hash(_nonce, _sender, _interval, _blockHash);
    }

    function amount(bytes32 _nonceHash) public pure returns (uint256) {
        return _amount(_nonceHash);
    }

    function zeros(bytes32 _nonceHash) public pure returns (uint8) {
        return _zeros(_nonceHash);
    }
}

/** Test class for XPowerAsic */
contract XPowerAsicTest is XPowerAsic {
    constructor(address _base, uint256 _deadlineIn) XPowerAsic(_base, _deadlineIn) {}

    function interval() public view returns (uint256) {
        return _interval();
    }

    function hash(
        uint256 _nonce,
        address _sender,
        uint256 _interval,
        bytes32 _blockHash
    ) public pure returns (bytes32) {
        return _hash(_nonce, _sender, _interval, _blockHash);
    }

    function amount(bytes32 _nonceHash) public pure returns (uint256) {
        return _amount(_nonceHash);
    }

    function zeros(bytes32 _nonceHash) public pure returns (uint8) {
        return _zeros(_nonceHash);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_base","type":"address"},{"internalType":"uint256","name":"_deadlineIn","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"blockHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Init","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes32","name":"blockHash","type":"bytes32"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"seal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000074a68215aedf59f317a23e87c13b848a292f27a400000000000000000000000000000000000000000000000000000000001baf80

-----Decoded View---------------
Arg [0] : _base (address): 0x74A68215AEdf59f317a23E87C13B848a292F27A4
Arg [1] : _deadlineIn (uint256): 1814400

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000074a68215aedf59f317a23e87c13b848a292f27a4
Arg [1] : 00000000000000000000000000000000000000000000000000000000001baf80

42619:652:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10213:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12380:169;;;;;;:::i;:::-;;:::i;:::-;;;1218:14:1;;1211:22;1193:41;;1181:2;1166:18;12380:169:0;1053:187:1;38369:924:0;;;;;;:::i;:::-;;:::i;:::-;;11333:108;11421:12;;11333:108;;;1644:25:1;;;1632:2;1617:18;11333:108:0;1498:177:1;13031:492:0;;;;;;:::i;:::-;;:::i;23777:90::-;23845:14;;23777:90;;37719:84;;;37769:5;2155:36:1;;2143:2;2128:18;37719:84:0;2013:184:1;13932:215:0;;;;;;:::i;:::-;;:::i;23913:71::-;;;:::i;20669:91::-;;;;;;:::i;:::-;;:::i;22518:786::-;;;;;;:::i;:::-;;:::i;11504:127::-;;;;;;:::i;:::-;-1:-1:-1;;;;;11605:18:0;11578:7;11605:18;;;;;;;;;;;;11504:127;4003:94;;;:::i;21079:368::-;;;;;;:::i;:::-;;:::i;3352:87::-;3425:6;;3352:87;;-1:-1:-1;;;;;3425:6:0;;;2724:51:1;;2712:2;2697:18;3352:87:0;2578:203:1;10432:104:0;;;:::i;14650:413::-;;;;;;:::i;:::-;;:::i;11844:175::-;;;;;;:::i;:::-;;:::i;12082:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;12198:18:0;;;12171:7;12198:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;12082:151;37963:331;;;:::i;4252:192::-;;;;;;:::i;:::-;;:::i;10213:100::-;10267:13;10300:5;10293:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10213:100;:::o;12380:169::-;12463:4;12480:39;2216:10;12503:7;12512:6;12480:8;:39::i;:::-;-1:-1:-1;12537:4:0;12380:169;;;;;:::o;38369:924::-;38479:16;38498:11;:9;:11::i;:::-;38479:30;;38562:35;38577:9;38588:8;38562:14;:35::i;:::-;43015:58;;;12493:3:1;43015:58:0;;;;12475:22:1;;;12534:1;12513:19;;;12506:30;-1:-1:-1;;;12552:19:1;;;;12545:39;;;;12636:20;;;12629:36;;;38717:10:0;12681:18:1;;;12674:60;-1:-1:-1;12750:18:1;;12743:34;;;12793:19;;;12786:35;;;43015:58:0;;;;;;;;;;12601:19:1;;;;43015:58:0;;;43005:69;;;;;38769:36;:7;38684:65;38769:16;:36::i;:::-;38768:37;38760:70;;;;-1:-1:-1;;;38760:70:0;;3638:2:1;38760:70:0;;;3620:21:1;3677:2;3657:18;;;3650:30;-1:-1:-1;;;3696:18:1;;;3689:50;3756:18;;38760:70:0;;;;;;;;;38895:14;38912:18;38920:9;38912:7;:18::i;:::-;38895:35;;38958:1;38949:6;:10;38941:39;;;;-1:-1:-1;;;38941:39:0;;3987:2:1;38941:39:0;;;3969:21:1;4026:2;4006:18;;;3999:30;-1:-1:-1;;;4045:18:1;;;4038:46;4101:18;;38941:39:0;3785:340:1;38941:39:0;39046:31;:7;39066:9;39046:11;:31::i;:::-;;39145:25;39151:10;39163:6;39145:5;:25::i;:::-;39256:1;39243:10;39252:1;39243:6;:10;:::i;:::-;:14;39239:46;;;39259:26;39265:7;3425:6;;-1:-1:-1;;;;;3425:6:0;;3352:87;39265:7;39274:10;39283:1;39274:6;:10;:::i;:::-;39259:5;:26::i;:::-;38424:869;;;38369:924;;:::o;13031:492::-;13171:4;13188:36;13198:6;13206:9;13217:6;13188:9;:36::i;:::-;-1:-1:-1;;;;;13264:19:0;;13237:24;13264:19;;;:11;:19;;;;;;;;2216:10;13264:33;;;;;;;;13316:26;;;;13308:79;;;;-1:-1:-1;;;13308:79:0;;4686:2:1;13308:79:0;;;4668:21:1;4725:2;4705:18;;;4698:30;4764:34;4744:18;;;4737:62;-1:-1:-1;;;4815:18:1;;;4808:38;4863:19;;13308:79:0;4484:404:1;13308:79:0;13423:57;13432:6;2216:10;13473:6;13454:16;:25;13423:8;:57::i;:::-;-1:-1:-1;13511:4:0;;13031:492;-1:-1:-1;;;;13031:492:0:o;13932:215::-;2216:10;14020:4;14069:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;14069:34:0;;;;;;;;;;14020:4;;14037:80;;14060:7;;14069:47;;14106:10;;14069:47;:::i;:::-;14037:8;:80::i;23913:71::-;3425:6;;-1:-1:-1;;;;;3425:6:0;2216:10;3572:23;3564:68;;;;-1:-1:-1;;;3564:68:0;;;;;;;:::i;:::-;23957:11:::1;:19:::0;;-1:-1:-1;;23957:19:0::1;::::0;;23913:71::o;20669:91::-;20725:27;2216:10;20745:6;20725:5;:27::i;:::-;20669:91;:::o;22518:786::-;22594:1;22585:6;:10;22577:42;;;;-1:-1:-1;;;22577:42:0;;5589:2:1;22577:42:0;;;5571:21:1;5628:2;5608:18;;;5601:30;-1:-1:-1;;;5647:18:1;;;5640:49;5706:18;;22577:42:0;5387:343:1;22577:42:0;22638:11;;;;22630:40;;;;-1:-1:-1;;;22630:40:0;;5937:2:1;22630:40:0;;;5919:21:1;5976:2;5956:18;;;5949:30;-1:-1:-1;;;5995:18:1;;;5988:46;6051:18;;22630:40:0;5735:340:1;22630:40:0;22703:6;;:43;;-1:-1:-1;;;22703:43:0;;22720:10;22703:43;;;6292:34:1;22740:4:0;6342:18:1;;;6335:43;22681:19:0;;-1:-1:-1;;;;;22703:6:0;;:16;;6227:18:1;;22703:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22681:65;;22775:11;22765:6;:21;;22757:56;;;;-1:-1:-1;;;22757:56:0;;6780:2:1;22757:56:0;;;6762:21:1;6819:2;6799:18;;;6792:30;-1:-1:-1;;;6838:18:1;;;6831:52;6900:18;;22757:56:0;6578:346:1;22757:56:0;22845:6;;:28;;-1:-1:-1;;;22845:28:0;;22862:10;22845:28;;;2724:51:1;22824:18:0;;-1:-1:-1;;;;;22845:6:0;;:16;;2697:18:1;;22845:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22824:49;;22902:10;22892:6;:20;;22884:53;;;;-1:-1:-1;;;22884:53:0;;7131:2:1;22884:53:0;;;7113:21:1;7170:2;7150:18;;;7143:30;-1:-1:-1;;;7189:18:1;;;7182:50;7249:18;;22884:53:0;6929:344:1;22884:53:0;23002:11;;22968:15;;23002:24;-1:-1:-1;23002:24:0;22994:52;;;;-1:-1:-1;;;22994:52:0;;7480:2:1;22994:52:0;;;7462:21:1;7519:2;7499:18;;;7492:30;-1:-1:-1;;;7538:18:1;;;7531:45;7593:18;;22994:52:0;7278:339:1;22994:52:0;23057:6;;:35;;-1:-1:-1;;;23057:35:0;;23073:10;23057:35;;;7796:51:1;7863:18;;;7856:34;;;-1:-1:-1;;;;;23057:6:0;;;;:15;;7769:18:1;;23057:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23124:6:0;;:28;;-1:-1:-1;;;23124:28:0;;23141:10;23124:28;;;2724:51:1;23103:18:0;;-1:-1:-1;;;;;;23124:6:0;;;;-1:-1:-1;23124:16:0;;2697:18:1;;23124:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23103:49;-1:-1:-1;23194:10:0;23171:19;23184:6;23103:49;23171:19;:::i;:::-;:33;23163:61;;;;-1:-1:-1;;;23163:61:0;;8103:2:1;23163:61:0;;;8085:21:1;8142:2;8122:18;;;8115:30;-1:-1:-1;;;8161:18:1;;;8154:45;8216:18;;23163:61:0;7901:339:1;23163:61:0;23235:25;23241:10;23253:6;23235:5;:25::i;:::-;23271;23289:6;23271:17;:25::i;4003:94::-;3425:6;;-1:-1:-1;;;;;3425:6:0;2216:10;3572:23;3564:68;;;;-1:-1:-1;;;3564:68:0;;;;;;;:::i;:::-;4068:21:::1;4086:1;4068:9;:21::i;:::-;4003:94::o:0;21079:368::-;21156:24;21183:32;21193:7;2216:10;12082:151;:::i;21183:32::-;21156:59;;21254:6;21234:16;:26;;21226:75;;;;-1:-1:-1;;;21226:75:0;;8447:2:1;21226:75:0;;;8429:21:1;8486:2;8466:18;;;8459:30;8525:34;8505:18;;;8498:62;-1:-1:-1;;;8576:18:1;;;8569:34;8620:19;;21226:75:0;8245:400:1;21226:75:0;21337:58;21346:7;2216:10;21388:6;21369:16;:25;21337:8;:58::i;:::-;21417:22;21423:7;21432:6;21417:5;:22::i;:::-;21145:302;21079:368;;:::o;10432:104::-;10488:13;10521:7;10514:14;;;;;:::i;14650:413::-;2216:10;14743:4;14787:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;14787:34:0;;;;;;;;;;14840:35;;;;14832:85;;;;-1:-1:-1;;;14832:85:0;;8852:2:1;14832:85:0;;;8834:21:1;8891:2;8871:18;;;8864:30;8930:34;8910:18;;;8903:62;-1:-1:-1;;;8981:18:1;;;8974:35;9026:19;;14832:85:0;8650:401:1;14832:85:0;14953:67;2216:10;14976:7;15004:15;14985:16;:34;14953:8;:67::i;:::-;-1:-1:-1;15051:4:0;;14650:413;-1:-1:-1;;;14650:413:0:o;11844:175::-;11930:4;11947:42;2216:10;11971:9;11982:6;11947:9;:42::i;37963:331::-;37997:17;38027:16;38042:1;38027:12;:16;:::i;:::-;38017:27;;-1:-1:-1;38063:13:0;38055:44;;;;-1:-1:-1;;;38055:44:0;;9388:2:1;38055:44:0;;;9370:21:1;9427:2;9407:18;;;9400:30;-1:-1:-1;;;9446:18:1;;;9439:48;9504:18;;38055:44:0;9186:342:1;38055:44:0;38130:15;38164:13;38156:43;;;;-1:-1:-1;;;38156:43:0;;9735:2:1;38156:43:0;;;9717:21:1;9774:2;9754:18;;;9747:30;-1:-1:-1;;;9793:18:1;;;9786:47;9850:18;;38156:43:0;9533:341:1;38156:43:0;38210:22;;;;:11;:22;;;;;;;;;:34;;;38260:26;;10053:25:1;;;10094:18;;;10087:34;;;38260:26:0;;10026:18:1;38260:26:0;;;;;;;37986:308;;37963:331::o;4252:192::-;3425:6;;-1:-1:-1;;;;;3425:6:0;2216:10;3572:23;3564:68;;;;-1:-1:-1;;;3564:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;4341:22:0;::::1;4333:73;;;::::0;-1:-1:-1;;;4333:73:0;;10334:2:1;4333:73:0::1;::::0;::::1;10316:21:1::0;10373:2;10353:18;;;10346:30;10412:34;10392:18;;;10385:62;-1:-1:-1;;;10463:18:1;;;10456:36;10509:19;;4333:73:0::1;10132:402:1::0;4333:73:0::1;4417:19;4427:8;4417:9;:19::i;18334:380::-:0;-1:-1:-1;;;;;18470:19:0;;18462:68;;;;-1:-1:-1;;;18462:68:0;;10741:2:1;18462:68:0;;;10723:21:1;10780:2;10760:18;;;10753:30;10819:34;10799:18;;;10792:62;-1:-1:-1;;;10870:18:1;;;10863:34;10914:19;;18462:68:0;10539:400:1;18462:68:0;-1:-1:-1;;;;;18549:21:0;;18541:68;;;;-1:-1:-1;;;18541:68:0;;11146:2:1;18541:68:0;;;11128:21:1;11185:2;11165:18;;;11158:30;11224:34;11204:18;;;11197:62;-1:-1:-1;;;11275:18:1;;;11268:32;11317:19;;18541:68:0;10944:398:1;18541:68:0;-1:-1:-1;;;;;18622:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18674:32;;1644:25:1;;;18674:32:0;;1617:18:1;18674:32:0;;;;;;;18334:380;;;:::o;39970:196::-;40014:7;;40053:27;40072:7;40053:15;:27;:::i;:::-;40034:46;;40110:1;40099:8;:12;40091:41;;;;-1:-1:-1;;;40091:41:0;;11549:2:1;40091:41:0;;;11531:21:1;11588:2;11568:18;;;11561:30;-1:-1:-1;;;11607:18:1;;;11600:46;11663:18;;40091:41:0;11347:340:1;40091:41:0;40150:8;39970:196;-1:-1:-1;39970:196:0:o;39376:538::-;39470:13;39462:44;;;;-1:-1:-1;;;39462:44:0;;9388:2:1;39462:44:0;;;9370:21:1;9427:2;9407:18;;;9400:30;-1:-1:-1;;;9446:18:1;;;9439:48;9504:18;;39462:44:0;9186:342:1;39462:44:0;39517:17;39537:22;;;:11;:22;;;;;;39599:8;39574:21;39587:7;39537:22;39574:21;:::i;:::-;:33;39570:337;;39641:1;39624:229;39649:3;39644:1;:8;39624:229;;39698:1;39682:12;:17;;:61;;;;-1:-1:-1;39734:9:0;39713:16;39728:1;39713:12;:16;:::i;:::-;39703:27;:40;39682:61;39678:160;;;39768:7;;39376:538;;:::o;39678:160::-;39654:3;;;;:::i;:::-;;;;39624:229;;;-1:-1:-1;39867:28:0;;-1:-1:-1;;;39867:28:0;;12034:2:1;39867:28:0;;;12016:21:1;12073:2;12053:18;;;12046:30;-1:-1:-1;;;12092:18:1;;;12085:48;12150:18;;39867:28:0;11832:342:1;34849:146:0;34926:4;27909:19;;;:12;;;:19;;;;;;:24;;34950:37;34943:44;34849:146;-1:-1:-1;;;34849:146:0:o;43141:127::-;43209:7;43259:1;43239:17;43246:9;43239:6;:17::i;:::-;43236:20;;:1;:20;:::i;:::-;:24;;;;:::i;34319:131::-;34386:4;34410:32;34415:3;34435:5;34410:4;:32::i;16573:399::-;-1:-1:-1;;;;;16657:21:0;;16649:65;;;;-1:-1:-1;;;16649:65:0;;14417:2:1;16649:65:0;;;14399:21:1;14456:2;14436:18;;;14429:30;14495:33;14475:18;;;14468:61;14546:18;;16649:65:0;14215:355:1;16649:65:0;16805:6;16789:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16822:18:0;;:9;:18;;;;;;;;;;:28;;16844:6;;16822:9;:28;;16844:6;;16822:28;:::i;:::-;;;;-1:-1:-1;;16866:37:0;;1644:25:1;;;-1:-1:-1;;;;;16866:37:0;;;16883:1;;16866:37;;1632:2:1;1617:18;16866:37:0;;;;;;;16573:399;;:::o;15553:733::-;-1:-1:-1;;;;;15693:20:0;;15685:70;;;;-1:-1:-1;;;15685:70:0;;14777:2:1;15685:70:0;;;14759:21:1;14816:2;14796:18;;;14789:30;14855:34;14835:18;;;14828:62;-1:-1:-1;;;14906:18:1;;;14899:35;14951:19;;15685:70:0;14575:401:1;15685:70:0;-1:-1:-1;;;;;15774:23:0;;15766:71;;;;-1:-1:-1;;;15766:71:0;;15183:2:1;15766:71:0;;;15165:21:1;15222:2;15202:18;;;15195:30;15261:34;15241:18;;;15234:62;-1:-1:-1;;;15312:18:1;;;15305:33;15355:19;;15766:71:0;14981:399:1;15766:71:0;-1:-1:-1;;;;;15934:17:0;;15910:21;15934:17;;;;;;;;;;;15970:23;;;;15962:74;;;;-1:-1:-1;;;15962:74:0;;15587:2:1;15962:74:0;;;15569:21:1;15626:2;15606:18;;;15599:30;15665:34;15645:18;;;15638:62;-1:-1:-1;;;15716:18:1;;;15709:36;15762:19;;15962:74:0;15385:402:1;15962:74:0;-1:-1:-1;;;;;16072:17:0;;;:9;:17;;;;;;;;;;;16092:22;;;16072:42;;16136:20;;;;;;;;:30;;16108:6;;16072:9;16136:30;;16108:6;;16136:30;:::i;:::-;;;;;;;;16201:9;-1:-1:-1;;;;;16184:35:0;16193:6;-1:-1:-1;;;;;16184:35:0;;16212:6;16184:35;;;;1644:25:1;;1632:2;1617:18;;1498:177;16184:35:0;;;;;;;;15674:612;15553:733;;;:::o;17305:591::-;-1:-1:-1;;;;;17389:21:0;;17381:67;;;;-1:-1:-1;;;17381:67:0;;15994:2:1;17381:67:0;;;15976:21:1;16033:2;16013:18;;;16006:30;16072:34;16052:18;;;16045:62;-1:-1:-1;;;16123:18:1;;;16116:31;16164:19;;17381:67:0;15792:397:1;17381:67:0;-1:-1:-1;;;;;17548:18:0;;17523:22;17548:18;;;;;;;;;;;17585:24;;;;17577:71;;;;-1:-1:-1;;;17577:71:0;;16396:2:1;17577:71:0;;;16378:21:1;16435:2;16415:18;;;16408:30;16474:34;16454:18;;;16447:62;-1:-1:-1;;;16525:18:1;;;16518:32;16567:19;;17577:71:0;16194:398:1;17577:71:0;-1:-1:-1;;;;;17684:18:0;;:9;:18;;;;;;;;;;17705:23;;;17684:44;;17750:12;:22;;17722:6;;17684:9;17750:22;;17722:6;;17750:22;:::i;:::-;;;;-1:-1:-1;;17790:37:0;;1644:25:1;;;17816:1:0;;-1:-1:-1;;;;;17790:37:0;;;;;1632:2:1;1617:18;17790:37:0;;;;;;;21145:302;21079:368;;:::o;23374:349::-;3425:6;;-1:-1:-1;;;;;3425:6:0;23441:10;:21;23437:135;;;23497:6;23479:14;;:24;;;;;;;:::i;:::-;;;;-1:-1:-1;23437:135:0;;-1:-1:-1;23437:135:0;;23554:6;23536:14;;:24;;;;;;;:::i;:::-;;;;-1:-1:-1;;23437:135:0;23607:14;;23590;;23586:18;;:1;:18;:::i;:::-;:35;23582:99;;;23638:31;;-1:-1:-1;;;23638:31:0;;16972:2:1;23638:31:0;;;16954:21:1;17011:2;16991:18;;;16984:30;-1:-1:-1;;;17030:18:1;;;17023:51;17091:18;;23638:31:0;16770:345:1;23582:99:0;23709:6;23691:14;;:24;;;;;;;:::i;:::-;;;;-1:-1:-1;;;23374:349:0:o;4452:173::-;4527:6;;;-1:-1:-1;;;;;4544:17:0;;;-1:-1:-1;;;;;;4544:17:0;;;;;;;4577:40;;4527:6;;;4544:17;4527:6;;4577:40;;4508:16;;4577:40;4497:128;4452:173;:::o;40774:892::-;40832:5;;;40878:756;40900:2;40896:1;:6;;;40878:756;;;40924:8;40935:9;40945:1;40935:12;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;;40966:9:0;;40962:89;;40996:12;41007:1;40996:12;;:::i;:::-;;;41027:8;;;40962:89;-1:-1:-1;;;;;;;;;41087:9:0;;;;:39;;-1:-1:-1;;;;;;;;;;41117:9:0;;;41087:39;:69;;;-1:-1:-1;;;;;;;;;;41147:9:0;;;41087:69;:99;;;-1:-1:-1;;;;;;;;;;41177:9:0;;;41087:99;:129;;;-1:-1:-1;;;;;;;;;;41207:9:0;;;41087:129;:159;;;-1:-1:-1;;;;;;;;;;41237:9:0;;;41087:159;:189;;;-1:-1:-1;;;;;;;;;;41267:9:0;;;41087:189;:219;;;-1:-1:-1;;;;;;;;;;41297:9:0;;;41087:219;:249;;;-1:-1:-1;;;;;;;;;;41327:9:0;;;41087:249;:279;;;-1:-1:-1;;;;;;;;;;41357:9:0;;;41087:279;:309;;;-1:-1:-1;;;;;;;;;;41387:9:0;;;41087:309;:339;;;-1:-1:-1;;;;;;;;;;41417:9:0;;;41087:339;:369;;;-1:-1:-1;;;;;;;;;;41447:9:0;;;41087:369;:399;;;-1:-1:-1;;;;;;;;;;41477:9:0;;;41087:399;:429;;;-1:-1:-1;;;;;;;;;;41507:9:0;;;41087:429;41065:538;;;41551:12;41562:1;41551:12;;:::i;:::-;;;41582:5;;;41065:538;41617:5;;;40878:756;40904:3;;;;:::i;:::-;;;;40878:756;;;-1:-1:-1;41651:7:0;40774:892;-1:-1:-1;;40774:892:0:o;25716:414::-;25779:4;27909:19;;;:12;;;:19;;;;;;25796:327;;-1:-1:-1;25839:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;26022:18;;26000:19;;;:12;;;:19;;;;;;:40;;;;26055:11;;25796:327;-1:-1:-1;26106:5:0;26099:12;;14:597:1;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;616:173::-;684:20;;-1:-1:-1;;;;;733:31:1;;723:42;;713:70;;779:1;776;769:12;794:254;862:6;870;923:2;911:9;902:7;898:23;894:32;891:52;;;939:1;936;929:12;891:52;962:29;981:9;962:29;:::i;:::-;952:39;1038:2;1023:18;;;;1010:32;;-1:-1:-1;;;794:254:1:o;1245:248::-;1313:6;1321;1374:2;1362:9;1353:7;1349:23;1345:32;1342:52;;;1390:1;1387;1380:12;1342:52;-1:-1:-1;;1413:23:1;;;1483:2;1468:18;;;1455:32;;-1:-1:-1;1245:248:1:o;1680:328::-;1757:6;1765;1773;1826:2;1814:9;1805:7;1801:23;1797:32;1794:52;;;1842:1;1839;1832:12;1794:52;1865:29;1884:9;1865:29;:::i;:::-;1855:39;;1913:38;1947:2;1936:9;1932:18;1913:38;:::i;:::-;1903:48;;1998:2;1987:9;1983:18;1970:32;1960:42;;1680:328;;;;;:::o;2202:180::-;2261:6;2314:2;2302:9;2293:7;2289:23;2285:32;2282:52;;;2330:1;2327;2320:12;2282:52;-1:-1:-1;2353:23:1;;2202:180;-1:-1:-1;2202:180:1:o;2387:186::-;2446:6;2499:2;2487:9;2478:7;2474:23;2470:32;2467:52;;;2515:1;2512;2505:12;2467:52;2538:29;2557:9;2538:29;:::i;2786:260::-;2854:6;2862;2915:2;2903:9;2894:7;2890:23;2886:32;2883:52;;;2931:1;2928;2921:12;2883:52;2954:29;2973:9;2954:29;:::i;:::-;2944:39;;3002:38;3036:2;3025:9;3021:18;3002:38;:::i;:::-;2992:48;;2786:260;;;;;:::o;3051:380::-;3130:1;3126:12;;;;3173;;;3194:61;;3248:4;3240:6;3236:17;3226:27;;3194:61;3301:2;3293:6;3290:14;3270:18;3267:38;3264:161;;;3347:10;3342:3;3338:20;3335:1;3328:31;3382:4;3379:1;3372:15;3410:4;3407:1;3400:15;3264:161;;3051:380;;;:::o;4130:127::-;4191:10;4186:3;4182:20;4179:1;4172:31;4222:4;4219:1;4212:15;4246:4;4243:1;4236:15;4262:217;4302:1;4328;4318:132;;4372:10;4367:3;4363:20;4360:1;4353:31;4407:4;4404:1;4397:15;4435:4;4432:1;4425:15;4318:132;-1:-1:-1;4464:9:1;;4262:217::o;4893:128::-;4933:3;4964:1;4960:6;4957:1;4954:13;4951:39;;;4970:18;;:::i;:::-;-1:-1:-1;5006:9:1;;4893:128::o;5026:356::-;5228:2;5210:21;;;5247:18;;;5240:30;5306:34;5301:2;5286:18;;5279:62;5373:2;5358:18;;5026:356::o;6389:184::-;6459:6;6512:2;6500:9;6491:7;6487:23;6483:32;6480:52;;;6528:1;6525;6518:12;6480:52;-1:-1:-1;6551:16:1;;6389:184;-1:-1:-1;6389:184:1:o;9056:125::-;9096:4;9124:1;9121;9118:8;9115:34;;;9129:18;;:::i;:::-;-1:-1:-1;9166:9:1;;9056:125::o;11692:135::-;11731:3;-1:-1:-1;;11752:17:1;;11749:43;;;11772:18;;:::i;:::-;-1:-1:-1;11819:1:1;11808:13;;11692:135::o;12832:422::-;12921:1;12964:5;12921:1;12978:270;12999:7;12989:8;12986:21;12978:270;;;13058:4;13054:1;13050:6;13046:17;13040:4;13037:27;13034:53;;;13067:18;;:::i;:::-;13117:7;13107:8;13103:22;13100:55;;;13137:16;;;;13100:55;13216:22;;;;13176:15;;;;12978:270;;;12982:3;12832:422;;;;;:::o;13259:806::-;13308:5;13338:8;13328:80;;-1:-1:-1;13379:1:1;13393:5;;13328:80;13427:4;13417:76;;-1:-1:-1;13464:1:1;13478:5;;13417:76;13509:4;13527:1;13522:59;;;;13595:1;13590:130;;;;13502:218;;13522:59;13552:1;13543:10;;13566:5;;;13590:130;13627:3;13617:8;13614:17;13611:43;;;13634:18;;:::i;:::-;-1:-1:-1;;13690:1:1;13676:16;;13705:5;;13502:218;;13804:2;13794:8;13791:16;13785:3;13779:4;13776:13;13772:36;13766:2;13756:8;13753:16;13748:2;13742:4;13739:12;13735:35;13732:77;13729:159;;;-1:-1:-1;13841:19:1;;;13873:5;;13729:159;13920:34;13945:8;13939:4;13920:34;:::i;:::-;13990:6;13986:1;13982:6;13978:19;13969:7;13966:32;13963:58;;;14001:18;;:::i;:::-;14039:20;;13259:806;-1:-1:-1;;;13259:806:1:o;14070:140::-;14128:5;14157:47;14198:4;14188:8;14184:19;14178:4;14157:47;:::i;16597:168::-;16637:7;16703:1;16699;16695:6;16691:14;16688:1;16685:21;16680:1;16673:9;16666:17;16662:45;16659:71;;;16710:18;;:::i;:::-;-1:-1:-1;16750:9:1;;16597:168::o;17120:127::-;17181:10;17176:3;17172:20;17169:1;17162:31;17212:4;17209:1;17202:15;17236:4;17233:1;17226:15;17252:204;17290:3;17326:4;17323:1;17319:12;17358:4;17355:1;17351:12;17393:3;17387:4;17383:14;17378:3;17375:23;17372:49;;;17401:18;;:::i;:::-;17437:13;;17252:204;-1:-1:-1;;;17252:204:1:o;17461:175::-;17498:3;17542:4;17535:5;17531:16;17571:4;17562:7;17559:17;17556:43;;;17579:18;;:::i;:::-;17628:1;17615:15;;17461:175;-1:-1:-1;;17461:175:1:o

ipfs://ce85ba4a1070cd2fddd0d7e8a121db49a90c5bcc0bf79b99e60d5f995c1d5463