Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-05-07
*/

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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;
    }
}

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

//import "../utils/Context.sol";

/**
 * @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() {
        _transferOwnership(_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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

    /**
     * @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 a - b;
    }

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

//import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

//import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/EnumerableSet.sol)

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;
    }
}

// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;

//import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Address.sol";
// import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
// import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
// import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
// import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// import '@openzeppelin/contracts/utils/math/Math.sol';
// import "@openzeppelin/contracts/security/Pausable.sol";
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";


contract NftStaking is Ownable, IERC721Receiver, ReentrancyGuard, Pausable {
    using Address for address;
    using SafeMath for uint;
    using EnumerableSet for EnumerableSet.UintSet; 
    
    //addresses 
    address nullAddress = 0x0000000000000000000000000000000000000000;
    address public stakingDestinationAddress;
    address public erc20Address;

    //uint256's 
    uint256 public expiration; 
    //rate governs how often you receive your token
    uint256 public rate; 

    // unstaking possible after LOCKUP_TIME
    uint public LOCKUP_TIME = 30 days;

    // Contracts are not allowed to deposit, claim or withdraw
    modifier noContractsAllowed() {
        require(!(address(msg.sender).isContract()) && tx.origin == msg.sender, "No Contracts Allowed!");
        _;
    }

    event RateChanged(uint256 newRate);
    event ExpirationChanged(uint256 newExpiration);
    event LockTimeChanged(uint newLockTime);
  
    // mappings 
    mapping(address => EnumerableSet.UintSet) private _deposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;
    mapping (address => uint) public stakingTime;

    constructor(
      address _stakingDestinationAddress,
      uint256 _rate,
      uint256 _expiration,
      address _erc20Address
    ) {
        stakingDestinationAddress = _stakingDestinationAddress;
        rate = _rate;
        expiration = block.number + _expiration;
        erc20Address = _erc20Address;
        _pause();
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

/* STAKING MECHANICS */

    // Set a multiplier for how many tokens to earn each time a block passes.
    function setRate(uint256 _rate) public onlyOwner() {
      rate = _rate;
      emit RateChanged(rate);
    }

    // Set this to a block to disable the ability to continue accruing tokens past that block number.
    function setExpiration(uint256 _expiration) public onlyOwner() {
      expiration = block.number + _expiration;
      emit ExpirationChanged(expiration);
    }

    //Set Lock Time
    function setLockTime(uint _lockTime) public onlyOwner() {
      LOCKUP_TIME = _lockTime;
      emit LockTimeChanged(LOCKUP_TIME);
    }

    //check deposit amount. 
    function depositsOf(address account)
      external 
      view 
      returns (uint256[] memory)
    {
      EnumerableSet.UintSet storage depositSet = _deposits[account];
      uint256[] memory tokenIds = new uint256[] (depositSet.length());

      for (uint256 i; i < depositSet.length(); i++) {
        tokenIds[i] = depositSet.at(i);
      }

      return tokenIds;
    }

    function calculateRewards(address account, uint256[] memory tokenIds) 
      public 
      view 
      returns (uint256[] memory rewards) 
    {
      rewards = new uint256[](tokenIds.length);

      for (uint256 i; i < tokenIds.length; i++) {
        uint256 tokenId = tokenIds[i];

        rewards[i] = 
          rate * 
          (_deposits[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _depositBlocks[account][tokenId]);
      }

      return rewards;
    }

    //reward amount by address/tokenIds[]
    function calculateReward(address account, uint256 tokenId) 
      public 
      view 
      returns (uint256) 
    {
      // require(Math.min(block.number, expiration) > _depositBlocks[account][tokenId], "Invalid blocks");
      return rate * 
          (_deposits[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _depositBlocks[account][tokenId]);
    }

    //Update Account and Auto-claim 
    function updateAccount(uint256[] calldata tokenIds) private {
      uint256 reward; 
      uint256 blockCur = Math.min(block.number, expiration);

      for (uint256 i; i < tokenIds.length; i++) {
        reward += calculateReward(msg.sender, tokenIds[i]);
        _depositBlocks[msg.sender][tokenIds[i]] = blockCur;
      }

      if (reward > 0) {
        require(IERC20(erc20Address).transfer(msg.sender, reward), "Could not transfer Reward Token!");
      }
    }

    //Reward claim function
    function claimRewards(uint256[] calldata tokenIds) external whenNotPaused noContractsAllowed nonReentrant(){
      updateAccount(tokenIds);
    }

    //deposit function. 
    function deposit(uint256[] calldata tokenIds) external whenNotPaused noContractsAllowed nonReentrant() {
        require(msg.sender != stakingDestinationAddress, "Invalid address");
        require(block.number < expiration, "Staking has finished, no more deposits!");
        updateAccount(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(stakingDestinationAddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIds[i],
                ""
            );

            _deposits[msg.sender].add(tokenIds[i]);
        }
        stakingTime[msg.sender] = block.timestamp;
    }

    //withdrawal function.
    function withdraw(uint256[] calldata tokenIds) external whenNotPaused noContractsAllowed nonReentrant() {

    	require(block.timestamp.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing.");

        updateAccount(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _deposits[msg.sender].contains(tokenIds[i]),
                "Staking: token not deposited"
            );

            _deposits[msg.sender].remove(tokenIds[i]);

            IERC721(stakingDestinationAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                ""
            );
        }
    }

    //withdraw without caring about Rewards
    function emergencyWithdraw(uint256[] calldata tokenIds) external noContractsAllowed nonReentrant() {
        require(block.timestamp.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing.");
        
        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _deposits[msg.sender].contains(tokenIds[i]),
                "Staking: token not deposited"
            );

            _deposits[msg.sender].remove(tokenIds[i]);

            IERC721(stakingDestinationAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                ""
            );
        }
    }

    //withdrawal function.
    function withdrawTokens() external onlyOwner {
        uint256 tokenSupply = IERC20(erc20Address).balanceOf(address(this));
        require(IERC20(erc20Address).transfer(msg.sender, tokenSupply), "Could not transfer Reward Token!");
    }

    // Prevent sending ERC721 tokens directly to this contract
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stakingDestinationAddress","type":"address"},{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"},{"internalType":"address","name":"_erc20Address","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newExpiration","type":"uint256"}],"name":"ExpirationChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newLockTime","type":"uint256"}],"name":"LockTimeChanged","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newRate","type":"uint256"}],"name":"RateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"LOCKUP_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"_depositBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"calculateReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"calculateRewards","outputs":[{"internalType":"uint256[]","name":"rewards","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"depositsOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"erc20Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setExpiration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lockTime","type":"uint256"}],"name":"setLockTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"setRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingDestinationAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"stakingTime","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":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106101735760003560e01c80635c975abb116100de578063983d95ce11610097578063d1941b0611610071578063d1941b06146102e5578063e3a9db1a146102f8578063f2fde38b1461030b578063f5326ada1461031e57610173565b8063983d95ce146102ac578063ae04d45d146102bf578063b343ae14146102d257610173565b80635c975abb146102645780635eac623914610279578063715018a61461028c5780638456cb59146102945780638d8f2adb1461029c5780638da5cb5b146102a457610173565b806334fcf4371161013057806334fcf437146102065780633f4ba83a1461021b5780634665096d14610223578063515a20ba1461022b578063583d42fd1461023e578063598b8e711461025157610173565b80630222a2c414610178578063068c526f14610196578063150b7a02146101b65780631852e8d9146101d6578063276184ae146101f65780632c4e722e146101fe575b600080fd5b610180610326565b60405161018d91906117e5565b60405180910390f35b6101a96101a436600461162b565b610335565b60405161018d9190611845565b6101c96101c4366004611595565b6104a0565b60405161018d9190611894565b6101e96101e43660046116fd565b6104b1565b60405161018d9190611b12565b61018061053e565b6101e961054d565b6102196102143660046117b5565b610553565b005b6102196105db565b6101e9610624565b6102196102393660046117b5565b61062a565b6101e961024c36600461157b565b6106a6565b61021961025f366004611726565b6106b8565b61026c610890565b60405161018d9190611889565b610219610287366004611726565b610899565b610219610929565b610219610972565b6102196109b9565b610180610b1d565b6102196102ba366004611726565b610b2c565b6102196102cd3660046117b5565b610d3f565b6101e96102e03660046116fd565b610db3565b6102196102f3366004611726565b610dd0565b6101a961030636600461157b565b610f6f565b61021961031936600461157b565b611049565b6101e96110b7565b6003546001600160a01b031681565b6060815167ffffffffffffffff81111561035f57634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610388578160200160208202803683370190505b50905060005b82518110156104985760008382815181106103b957634e487b7160e01b600052603260045260246000fd5b6020026020010151905060096000866001600160a01b03166001600160a01b03168152602001908152602001600020600082815260200190815260200160002054610406436005546110bd565b6104109190611b52565b6001600160a01b038616600090815260086020526040902061043290836110d3565b61043d576000610440565b60015b60ff166006546104509190611b33565b61045a9190611b33565b83838151811061047a57634e487b7160e01b600052603260045260246000fd5b6020908102919091010152508061049081611b69565b91505061038e565b505b92915050565b630a85bd0160e11b95945050505050565b6001600160a01b03821660009081526009602090815260408083208484529091528120546005546104e39043906110bd565b6104ed9190611b52565b6001600160a01b038416600090815260086020526040902061050f90846110d3565b61051a57600061051d565b60015b60ff1660065461052d9190611b33565b6105379190611b33565b9392505050565b6004546001600160a01b031681565b60065481565b61055b6110df565b6001600160a01b031661056c610b1d565b6001600160a01b03161461059b5760405162461bcd60e51b815260040161059290611a1b565b60405180910390fd5b60068190556040517f595a30f13a69b616c4d568e2a2b7875fdfe86e4300a049953c76ee278f8f3f10906105d0908390611b12565b60405180910390a150565b6105e36110df565b6001600160a01b03166105f4610b1d565b6001600160a01b03161461061a5760405162461bcd60e51b815260040161059290611a1b565b6106226110e3565b565b60055481565b6106326110df565b6001600160a01b0316610643610b1d565b6001600160a01b0316146106695760405162461bcd60e51b815260040161059290611a1b565b6106738143611b1b565b60058190556040517fffd29dd25f19a74d70342c5c9d990e01f0dbd1e660f9bcda09b884705c3b0793916105d091611b12565b600a6020526000908152604090205481565b6106c0610890565b156106dd5760405162461bcd60e51b8152600401610592906119f1565b6106e633611151565b1580156106f257503233145b61070e5760405162461bcd60e51b81526004016105929061197b565b600260015414156107315760405162461bcd60e51b815260040161059290611adb565b60026001556003546001600160a01b03163314156107615760405162461bcd60e51b81526004016105929061190c565b60055443106107825760405162461bcd60e51b8152600401610592906119aa565b61078c8282611160565b60005b81811015610875576003546001600160a01b031663b88d4fde33308686868181106107ca57634e487b7160e01b600052603260045260246000fd5b905060200201356040518463ffffffff1660e01b81526004016107ef939291906117f9565b600060405180830381600087803b15801561080957600080fd5b505af115801561081d573d6000803e3d6000fd5b5050505061086283838381811061084457634e487b7160e01b600052603260045260246000fd5b336000908152600860209081526040909120939102013590506112c3565b508061086d81611b69565b91505061078f565b5050336000908152600a602052604090204290555060018055565b60025460ff1690565b6108a1610890565b156108be5760405162461bcd60e51b8152600401610592906119f1565b6108c733611151565b1580156108d357503233145b6108ef5760405162461bcd60e51b81526004016105929061197b565b600260015414156109125760405162461bcd60e51b815260040161059290611adb565b60026001556109218282611160565b505060018055565b6109316110df565b6001600160a01b0316610942610b1d565b6001600160a01b0316146109685760405162461bcd60e51b815260040161059290611a1b565b61062260006112cf565b61097a6110df565b6001600160a01b031661098b610b1d565b6001600160a01b0316146109b15760405162461bcd60e51b815260040161059290611a1b565b61062261131f565b6109c16110df565b6001600160a01b03166109d2610b1d565b6001600160a01b0316146109f85760405162461bcd60e51b815260040161059290611a1b565b600480546040516370a0823160e01b81526000926001600160a01b03909216916370a0823191610a2a913091016117e5565b60206040518083038186803b158015610a4257600080fd5b505afa158015610a56573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a7a91906117cd565b6004805460405163a9059cbb60e01b81529293506001600160a01b03169163a9059cbb91610aac91339186910161182c565b602060405180830381600087803b158015610ac657600080fd5b505af1158015610ada573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610afe9190611795565b610b1a5760405162461bcd60e51b8152600401610592906118d7565b50565b6000546001600160a01b031690565b610b34610890565b15610b515760405162461bcd60e51b8152600401610592906119f1565b610b5a33611151565b158015610b6657503233145b610b825760405162461bcd60e51b81526004016105929061197b565b60026001541415610ba55760405162461bcd60e51b815260040161059290611adb565b6002600155600754336000908152600a6020526040902054610bc890429061137a565b11610be55760405162461bcd60e51b815260040161059290611a50565b610bef8282611160565b60005b81811015610d3657610c3b838383818110610c1d57634e487b7160e01b600052603260045260246000fd5b336000908152600860209081526040909120939102013590506110d3565b610c575760405162461bcd60e51b815260040161059290611aa4565b610c98838383818110610c7a57634e487b7160e01b600052603260045260246000fd5b33600090815260086020908152604090912093910201359050611386565b506003546001600160a01b031663b88d4fde3033868686818110610ccc57634e487b7160e01b600052603260045260246000fd5b905060200201356040518463ffffffff1660e01b8152600401610cf1939291906117f9565b600060405180830381600087803b158015610d0b57600080fd5b505af1158015610d1f573d6000803e3d6000fd5b505050508080610d2e90611b69565b915050610bf2565b50506001805550565b610d476110df565b6001600160a01b0316610d58610b1d565b6001600160a01b031614610d7e5760405162461bcd60e51b815260040161059290611a1b565b60078190556040517f41a6f7a07efe36ac8a11a10901396cbbac41e0210de8914c1ca3891288b28f4e906105d0908390611b12565b600960209081526000928352604080842090915290825290205481565b610dd933611151565b158015610de557503233145b610e015760405162461bcd60e51b81526004016105929061197b565b60026001541415610e245760405162461bcd60e51b815260040161059290611adb565b6002600155600754336000908152600a6020526040902054610e4790429061137a565b11610e645760405162461bcd60e51b815260040161059290611a50565b60005b81811015610d3657610e92838383818110610c1d57634e487b7160e01b600052603260045260246000fd5b610eae5760405162461bcd60e51b815260040161059290611aa4565b610ed1838383818110610c7a57634e487b7160e01b600052603260045260246000fd5b506003546001600160a01b031663b88d4fde3033868686818110610f0557634e487b7160e01b600052603260045260246000fd5b905060200201356040518463ffffffff1660e01b8152600401610f2a939291906117f9565b600060405180830381600087803b158015610f4457600080fd5b505af1158015610f58573d6000803e3d6000fd5b505050508080610f6790611b69565b915050610e67565b6001600160a01b0381166000908152600860205260408120606091610f9382611392565b67ffffffffffffffff811115610fb957634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610fe2578160200160208202803683370190505b50905060005b610ff183611392565b81101561103f57611002838261139d565b82828151811061102257634e487b7160e01b600052603260045260246000fd5b60209081029190910101528061103781611b69565b915050610fe8565b509150505b919050565b6110516110df565b6001600160a01b0316611062610b1d565b6001600160a01b0316146110885760405162461bcd60e51b815260040161059290611a1b565b6001600160a01b0381166110ae5760405162461bcd60e51b815260040161059290611935565b610b1a816112cf565b60075481565b60008183106110cc5781610537565b5090919050565b600061053783836113a9565b3390565b6110eb610890565b6111075760405162461bcd60e51b8152600401610592906118a9565b6002805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa61113a6110df565b60405161114791906117e5565b60405180910390a1565b6001600160a01b03163b151590565b60008061116f436005546110bd565b905060005b83811015611217576111ac338686848181106111a057634e487b7160e01b600052603260045260246000fd5b905060200201356104b1565b6111b69084611b1b565b3360009081526009602052604081209194508391908787858181106111eb57634e487b7160e01b600052603260045260246000fd5b90506020020135815260200190815260200160002081905550808061120f90611b69565b915050611174565b5081156112bd576004805460405163a9059cbb60e01b81526001600160a01b039091169163a9059cbb9161124f91339187910161182c565b602060405180830381600087803b15801561126957600080fd5b505af115801561127d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112a19190611795565b6112bd5760405162461bcd60e51b8152600401610592906118d7565b50505050565b600061053783836113c1565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b611327610890565b156113445760405162461bcd60e51b8152600401610592906119f1565b6002805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a25861113a6110df565b60006105378284611b52565b6000610537838361140b565b600061049a82611528565b6000610537838361152c565b60009081526001919091016020526040902054151590565b60006113cd83836113a9565b6114035750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561049a565b50600061049a565b6000818152600183016020526040812054801561151e57600061142f600183611b52565b855490915060009061144390600190611b52565b90508181146114c457600086600001828154811061147157634e487b7160e01b600052603260045260246000fd5b90600052602060002001549050808760000184815481106114a257634e487b7160e01b600052603260045260246000fd5b6000918252602080832090910192909255918252600188019052604090208390555b85548690806114e357634e487b7160e01b600052603160045260246000fd5b60019003818190600052602060002001600090559055856001016000868152602001908152602001600020600090556001935050505061049a565b600091505061049a565b5490565b600082600001828154811061155157634e487b7160e01b600052603260045260246000fd5b9060005260206000200154905092915050565b80356001600160a01b038116811461104457600080fd5b60006020828403121561158c578081fd5b61053782611564565b6000806000806000608086880312156115ac578081fd5b6115b586611564565b94506115c360208701611564565b935060408601359250606086013567ffffffffffffffff808211156115e6578283fd5b818801915088601f8301126115f9578283fd5b813581811115611607578384fd5b896020828501011115611618578384fd5b9699959850939650602001949392505050565b6000806040838503121561163d578182fd5b61164683611564565b915060208084013567ffffffffffffffff80821115611663578384fd5b818601915086601f830112611676578384fd5b81358181111561168857611688611b9a565b838102604051601f19603f830116810181811085821117156116ac576116ac611b9a565b604052828152858101935084860182860187018b10156116ca578788fd5b8795505b838610156116ec5780358552600195909501949386019386016116ce565b508096505050505050509250929050565b6000806040838503121561170f578182fd5b61171883611564565b946020939093013593505050565b60008060208385031215611738578182fd5b823567ffffffffffffffff8082111561174f578384fd5b818501915085601f830112611762578384fd5b813581811115611770578485fd5b8660208083028501011115611783578485fd5b60209290920196919550909350505050565b6000602082840312156117a6578081fd5b81518015158114610537578182fd5b6000602082840312156117c6578081fd5b5035919050565b6000602082840312156117de578081fd5b5051919050565b6001600160a01b0391909116815260200190565b6001600160a01b039384168152919092166020820152604081019190915260806060820181905260009082015260a00190565b6001600160a01b03929092168252602082015260400190565b6020808252825182820181905260009190848201906040850190845b8181101561187d57835183529284019291840191600101611861565b50909695505050505050565b901515815260200190565b6001600160e01b031991909116815260200190565b60208082526014908201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b604082015260600190565b6020808252818101527f436f756c64206e6f74207472616e736665722052657761726420546f6b656e21604082015260600190565b6020808252600f908201526e496e76616c6964206164647265737360881b604082015260600190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201526564647265737360d01b606082015260800190565b6020808252601590820152744e6f20436f6e74726163747320416c6c6f7765642160581b604082015260600190565b60208082526027908201527f5374616b696e67206861732066696e69736865642c206e6f206d6f7265206465604082015266706f736974732160c81b606082015260800190565b60208082526010908201526f14185d5cd8589b194e881c185d5cd95960821b604082015260600190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526034908201527f596f7520726563656e746c79207374616b65642c20706c656173652077616974604082015273103132b337b932903bb4ba34323930bbb4b7339760611b606082015260800190565b6020808252601c908201527f5374616b696e673a20746f6b656e206e6f74206465706f736974656400000000604082015260600190565b6020808252601f908201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604082015260600190565b90815260200190565b60008219821115611b2e57611b2e611b84565b500190565b6000816000190483118215151615611b4d57611b4d611b84565b500290565b600082821015611b6457611b64611b84565b500390565b6000600019821415611b7d57611b7d611b84565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fdfea2646970667358221220cc81ebf4329f02385aa11b4e69988fc812a1e58df558a38b467a97f8bfc279af64736f6c63430008010033

000000000000000000000000d06cf9e1189feab09c844c597abc3767bc12608c000000000000000000000000000000000000000000000000000000040da6c54e000000000000000000000000000000000000000000000000000000000103ce72000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0xd06cF9e1189FEAb09c844C597abc3767BC12608c
Arg [1] : _rate (uint256): 17408902478
Arg [2] : _expiration (uint256): 17026674
Arg [3] : _erc20Address (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000d06cf9e1189feab09c844c597abc3767bc12608c
Arg [1] : 000000000000000000000000000000000000000000000000000000040da6c54e
Arg [2] : 000000000000000000000000000000000000000000000000000000000103ce72
Arg [3] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

48762:7314:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49054:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51531:534;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;55854:219::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;52116:416::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49101:27::-;;;:::i;49241:19::-;;;:::i;50545:111::-;;;;;;:::i;:::-;;:::i;:::-;;50366:65;;;:::i;49155:25::-;;;:::i;50767:162::-;;;;;;:::i;:::-;;:::i;49890:44::-;;;;;;:::i;:::-;;:::i;53275:677::-;;;;;;:::i;:::-;;:::i;35634:86::-;;;:::i;:::-;;;;;;;:::i;53094:147::-;;;;;;:::i;:::-;;:::i;2560:103::-;;;:::i;50297:61::-;;;:::i;55541:241::-;;;:::i;1909:87::-;;;:::i;53988:748::-;;;;;;:::i;:::-;;:::i;50958:138::-;;;;;;:::i;:::-;;:::i;49814:69::-;;;;;;:::i;:::-;;:::i;54789:716::-;;;;;;:::i;:::-;;:::i;51134:389::-;;;;;;:::i;:::-;;:::i;2818:201::-;;;;;;:::i;:::-;;:::i;49315:33::-;;;:::i;49054:40::-;;;-1:-1:-1;;;;;49054:40:0;;:::o;51531:534::-;51646:24;51711:8;:15;51697:30;;;;;;-1:-1:-1;;;51697:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51697:30:0;;51687:40;;51743:9;51738:295;51758:8;:15;51754:1;:19;51738:295;;;51791:15;51809:8;51818:1;51809:11;;;;;;-1:-1:-1;;;51809:11:0;;;;;;;;;;;;;;;51791:29;;51990:14;:23;52005:7;-1:-1:-1;;;;;51990:23:0;-1:-1:-1;;;;;51990:23:0;;;;;;;;;;;;:32;52014:7;51990:32;;;;;;;;;;;;51939:34;51948:12;51962:10;;51939:8;:34::i;:::-;:83;;;;:::i;:::-;-1:-1:-1;;;;;51878:18:0;;;;;;:9;:18;;;;;:36;;51906:7;51878:27;:36::i;:::-;:44;;51921:1;51878:44;;;51917:1;51878:44;51858:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;51833:7;51841:1;51833:10;;;;;;-1:-1:-1;;;51833:10:0;;;;;;;;;;;;;;;;;;:190;-1:-1:-1;51775:3:0;;;;:::i;:::-;;;;51738:295;;;;51531:534;;;;;:::o;55854:219::-;-1:-1:-1;;;55854:219:0;;;;;;;:::o;52116:416::-;-1:-1:-1;;;;;52491:23:0;;52220:7;52491:23;;;:14;:23;;;;;;;;:32;;;;;;;;;52463:10;;52440:34;;52449:12;;52440:8;:34::i;:::-;:83;;;;:::i;:::-;-1:-1:-1;;;;;52379:18:0;;;;;;:9;:18;;;;;:36;;52407:7;52379:27;:36::i;:::-;:44;;52422:1;52379:44;;;52418:1;52379:44;52359:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;52352:172;52116:416;-1:-1:-1;;;52116:416:0:o;49101:27::-;;;-1:-1:-1;;;;;49101:27:0;;:::o;49241:19::-;;;;:::o;50545:111::-;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;;;;;;;;;50605:4:::1;:12:::0;;;50631:17:::1;::::0;::::1;::::0;::::1;::::0;50612:5;;50631:17:::1;:::i;:::-;;;;;;;;50545:111:::0;:::o;50366:65::-;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;50413:10:::1;:8;:10::i;:::-;50366:65::o:0;49155:25::-;;;;:::o;50767:162::-;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;50852:26:::1;50867:11:::0;50852:12:::1;:26;:::i;:::-;50839:10;:39:::0;;;50892:29:::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;49890:44::-:0;;;;;;;;;;;;;:::o;53275:677::-;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;49472:32:::1;49480:10;49472:30;:32::i;:::-;49470:35;:62;;;;-1:-1:-1::0;49509:9:0::1;49522:10;49509:23;49470:62;49462:96;;;;-1:-1:-1::0;;;49462:96:0::1;;;;;;;:::i;:::-;32342:1:::2;32940:7;;:19;;32932:63;;;;-1:-1:-1::0;;;32932:63:0::2;;;;;;;:::i;:::-;32342:1;33073:7;:18:::0;53411:25:::3;::::0;-1:-1:-1;;;;;53411:25:0::3;53397:10;:39;;53389:67;;;;-1:-1:-1::0;;;53389:67:0::3;;;;;;;:::i;:::-;53490:10;;53475:12;:25;53467:77;;;;-1:-1:-1::0;;;53467:77:0::3;;;;;;;:::i;:::-;53555:23;53569:8;;53555:13;:23::i;:::-;53596:9;53591:302;53607:19:::0;;::::3;53591:302;;;53656:25;::::0;-1:-1:-1;;;;;53656:25:0::3;53648:51;53718:10;53755:4;53779:8:::0;;53788:1;53779:11;;::::3;;;-1:-1:-1::0;;;53779:11:0::3;;;;;;;;;;;;;;;53648:178;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;53843:38;53869:8;;53878:1;53869:11;;;;;-1:-1:-1::0;;;53869:11:0::3;;;;;;;;;53853:10;53843:21;::::0;;;:9:::3;53869:11;53843:21:::0;;;;;;;;53869:11;::::3;;;::::0;-1:-1:-1;53843:25:0::3;:38::i;:::-;-1:-1:-1::0;53628:3:0;::::3;::::0;::::3;:::i;:::-;;;;53591:302;;;-1:-1:-1::0;;53915:10:0::3;53903:23;::::0;;;:11:::3;:23;::::0;;;;53929:15:::3;53903:41:::0;;-1:-1:-1;32298:1:0::2;33252:22:::0;;53275:677::o;35634:86::-;35705:7;;;;35634:86;:::o;53094:147::-;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;49472:32:::1;49480:10;49472:30;:32::i;:::-;49470:35;:62;;;;-1:-1:-1::0;49509:9:0::1;49522:10;49509:23;49470:62;49462:96;;;;-1:-1:-1::0;;;49462:96:0::1;;;;;;;:::i;:::-;32342:1:::2;32940:7;;:19;;32932:63;;;;-1:-1:-1::0;;;32932:63:0::2;;;;;;;:::i;:::-;32342:1;33073:7;:18:::0;53210:23:::3;53224:8:::0;;53210:13:::3;:23::i;:::-;-1:-1:-1::0;;32298:1:0::2;33252:22:::0;;53094:147::o;2560:103::-;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;2625:30:::1;2652:1;2625:18;:30::i;50297:61::-:0;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;50342:8:::1;:6;:8::i;55541:241::-:0;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;55626:12:::1;::::0;;55619:45:::1;::::0;-1:-1:-1;;;55619:45:0;;55597:19:::1;::::0;-1:-1:-1;;;;;55626:12:0;;::::1;::::0;55619:30:::1;::::0;:45:::1;::::0;55658:4:::1;::::0;55619:45:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55690:12;::::0;;55683:54:::1;::::0;-1:-1:-1;;;55683:54:0;;55597:67;;-1:-1:-1;;;;;;55690:12:0::1;::::0;55683:29:::1;::::0;:54:::1;::::0;55713:10:::1;::::0;55597:67;;55683:54:::1;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55675:99;;;;-1:-1:-1::0;;;55675:99:0::1;;;;;;;:::i;:::-;2200:1;55541:241::o:0;1909:87::-;1955:7;1982:6;-1:-1:-1;;;;;1982:6:0;1909:87;:::o;53988:748::-;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;49472:32:::1;49480:10;49472:30;:32::i;:::-;49470:35;:62;;;;-1:-1:-1::0;49509:9:0::1;49522:10;49509:23;49470:62;49462:96;;;;-1:-1:-1::0;;;49462:96:0::1;;;;;;;:::i;:::-;32342:1:::2;32940:7;;:19;;32932:63;;;;-1:-1:-1::0;;;32932:63:0::2;;;;;;;:::i;:::-;32342:1;33073:7;:18:::0;54157:11:::3;::::0;54142:10:::3;54130:23;::::0;;;:11:::3;:23;::::0;;;;;54110:44:::3;::::0;:15:::3;::::0;:19:::3;:44::i;:::-;:58;54102:123;;;;-1:-1:-1::0;;;54102:123:0::3;;;;;;;:::i;:::-;54238:23;54252:8;;54238:13;:23::i;:::-;54279:9;54274:455;54290:19:::0;;::::3;54274:455;;;54357:43;54388:8;;54397:1;54388:11;;;;;-1:-1:-1::0;;;54388:11:0::3;;;;;;;;;54367:10;54357:21;::::0;;;:9:::3;54388:11;54357:21:::0;;;;;;;;54388:11;::::3;;;::::0;-1:-1:-1;54357:30:0::3;:43::i;:::-;54331:133;;;;-1:-1:-1::0;;;54331:133:0::3;;;;;;;:::i;:::-;54481:41;54510:8;;54519:1;54510:11;;;;;-1:-1:-1::0;;;54510:11:0::3;;;;;;;;;54491:10;54481:21;::::0;;;:9:::3;54510:11;54481:21:::0;;;;;;;;54510:11;::::3;;;::::0;-1:-1:-1;54481:28:0::3;:41::i;:::-;-1:-1:-1::0;54547:25:0::3;::::0;-1:-1:-1;;;;;54547:25:0::3;54539:51;54617:4;54641:10;54670:8:::0;;54679:1;54670:11;;::::3;;;-1:-1:-1::0;;;54670:11:0::3;;;;;;;;;;;;;;;54539:178;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;54311:3;;;;;:::i;:::-;;;;54274:455;;;-1:-1:-1::0;;32298:1:0::2;33252:22:::0;;-1:-1:-1;53988:748:0:o;50958:138::-;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;51023:11:::1;:23:::0;;;51060:28:::1;::::0;::::1;::::0;::::1;::::0;51037:9;;51060:28:::1;:::i;49814:69::-:0;;;;;;;;;;;;;;;;;;;;;;;;:::o;54789:716::-;49472:32;49480:10;49472:30;:32::i;:::-;49470:35;:62;;;;-1:-1:-1;49509:9:0;49522:10;49509:23;49470:62;49462:96;;;;-1:-1:-1;;;49462:96:0;;;;;;;:::i;:::-;32342:1:::1;32940:7;;:19;;32932:63;;;;-1:-1:-1::0;;;32932:63:0::1;;;;;;;:::i;:::-;32342:1;33073:7;:18:::0;54954:11:::2;::::0;54939:10:::2;54927:23;::::0;;;:11:::2;:23;::::0;;;;;54907:44:::2;::::0;:15:::2;::::0;:19:::2;:44::i;:::-;:58;54899:123;;;;-1:-1:-1::0;;;54899:123:0::2;;;;;;;:::i;:::-;55048:9;55043:455;55059:19:::0;;::::2;55043:455;;;55126:43;55157:8;;55166:1;55157:11;;;;;-1:-1:-1::0;;;55157:11:0::2;;;;;;;;55126:43;55100:133;;;;-1:-1:-1::0;;;55100:133:0::2;;;;;;;:::i;:::-;55250:41;55279:8;;55288:1;55279:11;;;;;-1:-1:-1::0;;;55279:11:0::2;;;;;;;;55250:41;-1:-1:-1::0;55316:25:0::2;::::0;-1:-1:-1;;;;;55316:25:0::2;55308:51;55386:4;55410:10;55439:8:::0;;55448:1;55439:11;;::::2;;;-1:-1:-1::0;;;55439:11:0::2;;;;;;;;;;;;;;;55308:178;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;55080:3;;;;;:::i;:::-;;;;55043:455;;51134:389:::0;-1:-1:-1;;;;;51292:18:0;;51249:40;51292:18;;;:9;:18;;;;;51217:16;;51362:19;51292:18;51362:17;:19::i;:::-;51347:35;;;;;;-1:-1:-1;;;51347:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51347:35:0;;51319:63;;51398:9;51393:97;51413:19;:10;:17;:19::i;:::-;51409:1;:23;51393:97;;;51464:16;:10;51478:1;51464:13;:16::i;:::-;51450:8;51459:1;51450:11;;;;;;-1:-1:-1;;;51450:11:0;;;;;;;;;;;;;;;;;;:30;51434:3;;;;:::i;:::-;;;;51393:97;;;-1:-1:-1;51507:8:0;-1:-1:-1;;51134:389:0;;;;:::o;2818:201::-;2140:12;:10;:12::i;:::-;-1:-1:-1;;;;;2129:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2129:23:0;;2121:68;;;;-1:-1:-1;;;2121:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2907:22:0;::::1;2899:73;;;;-1:-1:-1::0;;;2899:73:0::1;;;;;;;:::i;:::-;2983:28;3002:8;2983:18;:28::i;49315:33::-:0;;;;:::o;33736:106::-;33794:7;33825:1;33821;:5;:13;;33833:1;33821:13;;;-1:-1:-1;33829:1:0;;33736:106;-1:-1:-1;33736:106:0:o;28940:146::-;29017:4;29041:37;29051:3;29071:5;29041:9;:37::i;656:98::-;736:10;656:98;:::o;36693:120::-;36237:8;:6;:8::i;:::-;36229:41;;;;-1:-1:-1;;;36229:41:0;;;;;;;:::i;:::-;36752:7:::1;:15:::0;;-1:-1:-1;;36752:15:0::1;::::0;;36783:22:::1;36792:12;:10;:12::i;:::-;36783:22;;;;;;:::i;:::-;;;;;;;;36693:120::o:0;40815:326::-;-1:-1:-1;;;;;41110:19:0;;:23;;;40815:326::o;52578:479::-;52647:14;52671:16;52690:34;52699:12;52713:10;;52690:8;:34::i;:::-;52671:53;;52740:9;52735:174;52751:19;;;52735:174;;;52798:40;52814:10;52826:8;;52835:1;52826:11;;;;;-1:-1:-1;;;52826:11:0;;;;;;;;;;;;;;;52798:15;:40::i;:::-;52788:50;;;;:::i;:::-;52864:10;52849:26;;;;:14;:26;;;;;52788:50;;-1:-1:-1;52891:8:0;;52849:26;52876:8;;52885:1;52876:11;;;;;-1:-1:-1;;;52876:11:0;;;;;;;;;;;;;;;52849:39;;;;;;;;;;;:50;;;;52772:3;;;;;:::i;:::-;;;;52735:174;;;-1:-1:-1;52923:10:0;;52919:131;;52961:12;;;52954:49;;-1:-1:-1;;;52954:49:0;;-1:-1:-1;;;;;52961:12:0;;;;52954:29;;:49;;52984:10;;52996:6;;52954:49;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52946:94;;;;-1:-1:-1;;;52946:94:0;;;;;;;:::i;:::-;52578:479;;;;:::o;28410:131::-;28477:4;28501:32;28506:3;28526:5;28501:4;:32::i;3179:191::-;3253:16;3272:6;;-1:-1:-1;;;;;3289:17:0;;;-1:-1:-1;;;;;;3289:17:0;;;;;;3322:40;;3272:6;;;;;;;3322:40;;3253:16;3322:40;3179:191;;:::o;36434:118::-;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;36494:7:::1;:14:::0;;-1:-1:-1;;36494:14:0::1;36504:4;36494:14;::::0;;36524:20:::1;36531:12;:10;:12::i;6572:98::-:0;6630:7;6657:5;6661:1;6657;:5;:::i;28717:137::-;28787:4;28811:35;28819:3;28839:5;28811:7;:35::i;29172:114::-;29232:7;29259:19;29267:3;29259:7;:19::i;29640:137::-;29711:7;29746:22;29750:3;29762:5;29746:3;:22::i;21903:129::-;21976:4;22000:19;;;:12;;;;;:19;;;;;;:24;;;21903:129::o;19807:414::-;19870:4;19892:21;19902:3;19907:5;19892:9;:21::i;:::-;19887:327;;-1:-1:-1;19930:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;20113:18;;20091:19;;;:12;;;:19;;;;;;:40;;;;20146:11;;19887:327;-1:-1:-1;20197:5:0;20190:12;;20397:1420;20463:4;20602:19;;;:12;;;:19;;;;;;20638:15;;20634:1176;;21013:21;21037:14;21050:1;21037:10;:14;:::i;:::-;21086:18;;21013:38;;-1:-1:-1;21066:17:0;;21086:22;;21107:1;;21086:22;:::i;:::-;21066:42;;21142:13;21129:9;:26;21125:405;;21176:17;21196:3;:11;;21208:9;21196:22;;;;;;-1:-1:-1;;;21196:22:0;;;;;;;;;;;;;;;;;21176:42;;21350:9;21321:3;:11;;21333:13;21321:26;;;;;;-1:-1:-1;;;21321:26:0;;;;;;;;;;;;;;;;;;;;:38;;;;21435:23;;;:12;;;:23;;;;;:36;;;21125:405;21611:17;;:3;;:17;;;-1:-1:-1;;;21611:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;21706:3;:12;;:19;21719:5;21706:19;;;;;;;;;;;21699:26;;;21749:4;21742:11;;;;;;;20634:1176;21793:5;21786:12;;;;;22118:109;22201:18;;22118:109::o;22581:120::-;22648:7;22675:3;:11;;22687:5;22675:18;;;;;;-1:-1:-1;;;22675:18:0;;;;;;;;;;;;;;;;;22668:25;;22581:120;;;;:::o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:862::-;;;;;;579:3;567:9;558:7;554:23;550:33;547:2;;;601:6;593;586:22;547:2;629:31;650:9;629:31;:::i;:::-;619:41;;679:40;715:2;704:9;700:18;679:40;:::i;:::-;669:50;;766:2;755:9;751:18;738:32;728:42;;821:2;810:9;806:18;793:32;844:18;885:2;877:6;874:14;871:2;;;906:6;898;891:22;871:2;949:6;938:9;934:22;924:32;;994:7;987:4;983:2;979:13;975:27;965:2;;1021:6;1013;1006:22;965:2;1066;1053:16;1092:2;1084:6;1081:14;1078:2;;;1113:6;1105;1098:22;1078:2;1163:7;1158:2;1149:6;1145:2;1141:15;1137:24;1134:37;1131:2;;;1189:6;1181;1174:22;1131:2;537:722;;;;-1:-1:-1;537:722:1;;-1:-1:-1;1225:2:1;1217:11;;1247:6;537:722;-1:-1:-1;;;537:722:1:o;1264:1248::-;;;1418:2;1406:9;1397:7;1393:23;1389:32;1386:2;;;1439:6;1431;1424:22;1386:2;1467:31;1488:9;1467:31;:::i;:::-;1457:41;;1517:2;1570;1559:9;1555:18;1542:32;1593:18;1634:2;1626:6;1623:14;1620:2;;;1655:6;1647;1640:22;1620:2;1698:6;1687:9;1683:22;1673:32;;1743:7;1736:4;1732:2;1728:13;1724:27;1714:2;;1770:6;1762;1755:22;1714:2;1811;1798:16;1833:2;1829;1826:10;1823:2;;;1839:18;;:::i;:::-;1886:2;1882;1878:11;1918:2;1912:9;1981:2;1977:7;1972:2;1968;1964:11;1960:25;1952:6;1948:38;2036:6;2024:10;2021:22;2016:2;2004:10;2001:18;1998:46;1995:2;;;2047:18;;:::i;:::-;2083:2;2076:22;2133:18;;;2167:15;;;;-1:-1:-1;2202:11:1;;;2232;;;2228:20;;2225:33;-1:-1:-1;2222:2:1;;;2276:6;2268;2261:22;2222:2;2303:6;2294:15;;2318:163;2332:2;2329:1;2326:9;2318:163;;;2389:17;;2377:30;;2350:1;2343:9;;;;;2427:12;;;;2459;;2318:163;;;2322:3;2500:6;2490:16;;;;;;;;1376:1136;;;;;:::o;2517:266::-;;;2646:2;2634:9;2625:7;2621:23;2617:32;2614:2;;;2667:6;2659;2652:22;2614:2;2695:31;2716:9;2695:31;:::i;:::-;2685:41;2773:2;2758:18;;;;2745:32;;-1:-1:-1;;;2604:179:1:o;2788:666::-;;;2935:2;2923:9;2914:7;2910:23;2906:32;2903:2;;;2956:6;2948;2941:22;2903:2;3001:9;2988:23;3030:18;3071:2;3063:6;3060:14;3057:2;;;3092:6;3084;3077:22;3057:2;3135:6;3124:9;3120:22;3110:32;;3180:7;3173:4;3169:2;3165:13;3161:27;3151:2;;3207:6;3199;3192:22;3151:2;3252;3239:16;3278:2;3270:6;3267:14;3264:2;;;3299:6;3291;3284:22;3264:2;3358:7;3353:2;3347;3339:6;3335:15;3331:2;3327:24;3323:33;3320:46;3317:2;;;3384:6;3376;3369:22;3317:2;3420;3412:11;;;;;3442:6;;-1:-1:-1;2893:561:1;;-1:-1:-1;;;;2893:561:1:o;3459:297::-;;3579:2;3567:9;3558:7;3554:23;3550:32;3547:2;;;3600:6;3592;3585:22;3547:2;3637:9;3631:16;3690:5;3683:13;3676:21;3669:5;3666:32;3656:2;;3717:6;3709;3702:22;3761:190;;3873:2;3861:9;3852:7;3848:23;3844:32;3841:2;;;3894:6;3886;3879:22;3841:2;-1:-1:-1;3922:23:1;;3831:120;-1:-1:-1;3831:120:1:o;3956:194::-;;4079:2;4067:9;4058:7;4054:23;4050:32;4047:2;;;4100:6;4092;4085:22;4047:2;-1:-1:-1;4128:16:1;;4037:113;-1:-1:-1;4037:113:1:o;4155:203::-;-1:-1:-1;;;;;4319:32:1;;;;4301:51;;4289:2;4274:18;;4256:102::o;4363:558::-;-1:-1:-1;;;;;4686:15:1;;;4668:34;;4738:15;;;;4733:2;4718:18;;4711:43;4785:2;4770:18;;4763:34;;;;4833:3;4828:2;4813:18;;4806:31;;;4363:558;4853:19;;;4846:33;4648:3;4896:19;;4620:301::o;4926:274::-;-1:-1:-1;;;;;5118:32:1;;;;5100:51;;5182:2;5167:18;;5160:34;5088:2;5073:18;;5055:145::o;5205:635::-;5376:2;5428:21;;;5498:13;;5401:18;;;5520:22;;;5205:635;;5376:2;5599:15;;;;5573:2;5558:18;;;5205:635;5645:169;5659:6;5656:1;5653:13;5645:169;;;5720:13;;5708:26;;5789:15;;;;5754:12;;;;5681:1;5674:9;5645:169;;;-1:-1:-1;5831:3:1;;5356:484;-1:-1:-1;;;;;;5356:484:1:o;5845:187::-;6010:14;;6003:22;5985:41;;5973:2;5958:18;;5940:92::o;6037:202::-;-1:-1:-1;;;;;;6199:33:1;;;;6181:52;;6169:2;6154:18;;6136:103::o;6244:344::-;6446:2;6428:21;;;6485:2;6465:18;;;6458:30;-1:-1:-1;;;6519:2:1;6504:18;;6497:50;6579:2;6564:18;;6418:170::o;6593:356::-;6795:2;6777:21;;;6814:18;;;6807:30;6873:34;6868:2;6853:18;;6846:62;6940:2;6925:18;;6767:182::o;6954:339::-;7156:2;7138:21;;;7195:2;7175:18;;;7168:30;-1:-1:-1;;;7229:2:1;7214:18;;7207:45;7284:2;7269:18;;7128:165::o;7298:402::-;7500:2;7482:21;;;7539:2;7519:18;;;7512:30;7578:34;7573:2;7558:18;;7551:62;-1:-1:-1;;;7644:2:1;7629:18;;7622:36;7690:3;7675:19;;7472:228::o;7705:345::-;7907:2;7889:21;;;7946:2;7926:18;;;7919:30;-1:-1:-1;;;7980:2:1;7965:18;;7958:51;8041:2;8026:18;;7879:171::o;8055:403::-;8257:2;8239:21;;;8296:2;8276:18;;;8269:30;8335:34;8330:2;8315:18;;8308:62;-1:-1:-1;;;8401:2:1;8386:18;;8379:37;8448:3;8433:19;;8229:229::o;8463:340::-;8665:2;8647:21;;;8704:2;8684:18;;;8677:30;-1:-1:-1;;;8738:2:1;8723:18;;8716:46;8794:2;8779:18;;8637:166::o;8808:356::-;9010:2;8992:21;;;9029:18;;;9022:30;9088:34;9083:2;9068:18;;9061:62;9155:2;9140:18;;8982:182::o;9169:416::-;9371:2;9353:21;;;9410:2;9390:18;;;9383:30;9449:34;9444:2;9429:18;;9422:62;-1:-1:-1;;;9515:2:1;9500:18;;9493:50;9575:3;9560:19;;9343:242::o;9590:352::-;9792:2;9774:21;;;9831:2;9811:18;;;9804:30;9870;9865:2;9850:18;;9843:58;9933:2;9918:18;;9764:178::o;9947:355::-;10149:2;10131:21;;;10188:2;10168:18;;;10161:30;10227:33;10222:2;10207:18;;10200:61;10293:2;10278:18;;10121:181::o;10307:177::-;10453:25;;;10441:2;10426:18;;10408:76::o;10489:128::-;;10560:1;10556:6;10553:1;10550:13;10547:2;;;10566:18;;:::i;:::-;-1:-1:-1;10602:9:1;;10537:80::o;10622:168::-;;10728:1;10724;10720:6;10716:14;10713:1;10710:21;10705:1;10698:9;10691:17;10687:45;10684:2;;;10735:18;;:::i;:::-;-1:-1:-1;10775:9:1;;10674:116::o;10795:125::-;;10863:1;10860;10857:8;10854:2;;;10868:18;;:::i;:::-;-1:-1:-1;10905:9:1;;10844:76::o;10925:135::-;;-1:-1:-1;;10985:17:1;;10982:2;;;11005:18;;:::i;:::-;-1:-1:-1;11052:1:1;11041:13;;10972:88::o;11065:127::-;11126:10;11121:3;11117:20;11114:1;11107:31;11157:4;11154:1;11147:15;11181:4;11178:1;11171:15;11197:127;11258:10;11253:3;11249:20;11246:1;11239:31;11289:4;11286:1;11279:15;11313:4;11310:1;11303:15

ipfs://cc81ebf4329f02385aa11b4e69988fc812a1e58df558a38b467a97f8bfc279af