Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Receiver
•    - function onERC721Received(
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function paused()
•    - function _pause()
•    - function _unpause()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
•  contract NftStaking is Ownable, IE ... *
•    - function pause()
•    - function unpause()
•    - function setRate(uint256 _rate)
•    - function setExpiration(uint256 _expir ...
•    - function setLockTime(uint _lockTime)
•    - function depositsOf(address account)
•    - function depositsOfWoD(address accoun ...
•    - function calculateRewards(address acc ...
•    - function calculateReward(address acco ...
•    - function updateAccount(uint256[] call ...
•    - function claimRewards(uint256[] calld ...
•    - function deposit(uint256[] calldata t ...
•    - function withdraw(uint256[] calldata ...
•    - function emergencyWithdraw(uint256[] ...
•    - function withdrawTokens()
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-03-15
*/

// 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 WoDcontractaddress;
    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 = 0;

    // 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 => EnumerableSet.UintSet) private _woddeposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;
    mapping (address => uint) public stakingTime;

    constructor(
      address _stakingDestinationAddress,
      address _WoDcontractaddress,
      uint256 _rate,
      uint256 _expiration,
      address _erc20Address
    ) {
        stakingDestinationAddress = _stakingDestinationAddress;
        WoDcontractaddress = _WoDcontractaddress;
        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 depositsOfWoD(address account)
    external
    view
    returns (uint256[] memory)
    {
        EnumerableSet.UintSet storage depositSetWoD = _woddeposits[account];
        uint256[] memory tokenIdsWoD = new uint256[] (depositSetWoD.length());

        for(uint256 i; i < depositSetWoD.length(); i++)
        {
            tokenIdsWoD[i] = depositSetWoD.at(i);
        }
        return tokenIdsWoD;
    }

    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, uint256[] calldata tokenIdsWoD) external whenNotPaused noContractsAllowed nonReentrant() {
        require(msg.sender != stakingDestinationAddress, "Invalid address");
        require(msg.sender != WoDcontractaddress, "Invalid address");
        require(tokenIds.length == tokenIdsWoD.length, "Invalid number of NFTs");
        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],    
                ""
            );
            IERC721(WoDcontractaddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIdsWoD[i],
                ""
            );

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

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

    	require(block.timestamp.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing.");
        require(tokenIds.length == tokenIdsWoD.length, "Invalid number of NFTs");
        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],
                ""
            );
            require(
                _woddeposits[msg.sender].contains(tokenIdsWoD[i]),
                "Staking: token not deposited"
            );

            _woddeposits[msg.sender].remove(tokenIdsWoD[i]);

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

    //withdraw without caring about Rewards
    function emergencyWithdraw(uint256[] calldata tokenIds, uint256[] calldata tokenIdsWoD) external noContractsAllowed nonReentrant() {
        require(block.timestamp.sub(stakingTime[msg.sender]) > LOCKUP_TIME, "You recently staked, please wait before withdrawing.");
        require(tokenIds.length == tokenIdsWoD.length, "Invalid number of NFTs");
        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],
                ""
            );
            require(
                _woddeposits[msg.sender].contains(tokenIdsWoD[i]),
                "Staking: token not deposited"
            );

            _woddeposits[msg.sender].remove(tokenIdsWoD[i]);

            IERC721(WoDcontractaddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIdsWoD[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":"address","name":"_WoDcontractaddress","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":[],"name":"WoDcontractaddress","outputs":[{"internalType":"address","name":"","type":"address"}],"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[]"},{"internalType":"uint256[]","name":"tokenIdsWoD","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":"address","name":"account","type":"address"}],"name":"depositsOfWoD","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"tokenIdsWoD","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[]"},{"internalType":"uint256[]","name":"tokenIdsWoD","type":"uint256[]"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d06cf9e1189feab09c844c597abc3767bc12608c000000000000000000000000cd60d912655281908ee557ce1add61e983385a030000000000000000000000000000000000000000000000000000001d3c99fcbf000000000000000000000000000000000000000000000000000000000027aeb1000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0xd06cF9e1189FEAb09c844C597abc3767BC12608c
Arg [1] : _WoDcontractaddress (address): 0xcd60d912655281908EE557CE1Add61e983385a03
Arg [2] : _rate (uint256): 125570776255
Arg [3] : _expiration (uint256): 2600625
Arg [4] : _erc20Address (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000d06cf9e1189feab09c844c597abc3767bc12608c
Arg [1] : 000000000000000000000000cd60d912655281908ee557ce1add61e983385a03
Arg [2] : 0000000000000000000000000000000000000000000000000000001d3c99fcbf
Arg [3] : 000000000000000000000000000000000000000000000000000000000027aeb1
Arg [4] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

48762:9414:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49054:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52157:534;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;56375:1230::-;;;;;;:::i;:::-;;:::i;:::-;;57954:219;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;52742:416::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49141:27::-;;;:::i;49281:19::-;;;:::i;50735:111::-;;;;;;:::i;:::-;;:::i;50556:65::-;;;:::i;49195:25::-;;;:::i;50957:162::-;;;;;;:::i;:::-;;:::i;49993:44::-;;;;;;:::i;:::-;;:::i;35634:86::-;;;:::i;:::-;;;;;;;:::i;53720:147::-;;;;;;:::i;:::-;;:::i;2560:103::-;;;:::i;55052:1270::-;;;;;;:::i;:::-;;:::i;50487:61::-;;;:::i;57641:241::-;;;:::i;1909:87::-;;;:::i;51721:428::-;;;;;;:::i;:::-;;:::i;51148:138::-;;;;;;:::i;:::-;;:::i;49917:69::-;;;;;;:::i;:::-;;:::i;51324:389::-;;;;;;:::i;:::-;;:::i;53901:1115::-;;;;;;:::i;:::-;;:::i;2818:201::-;;;;;;:::i;:::-;;:::i;49355:27::-;;;:::i;49101:33::-;;;:::i;49054:40::-;;;-1:-1:-1;;;;;49054:40:0;;:::o;52157:534::-;52272:24;52337:8;:15;52323:30;;;;;;-1:-1:-1;;;52323:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52323:30:0;;52313:40;;52369:9;52364:295;52384:8;:15;52380:1;:19;52364:295;;;52417:15;52435:8;52444:1;52435:11;;;;;;-1:-1:-1;;;52435:11:0;;;;;;;;;;;;;;;52417:29;;52616:14;:23;52631:7;-1:-1:-1;;;;;52616:23:0;-1:-1:-1;;;;;52616:23:0;;;;;;;;;;;;:32;52640:7;52616:32;;;;;;;;;;;;52565:34;52574:12;52588:10;;52565:8;:34::i;:::-;:83;;;;:::i;:::-;-1:-1:-1;;;;;52504:18:0;;;;;;:9;:18;;;;;:36;;52532:7;52504:27;:36::i;:::-;:44;;52547:1;52504:44;;;52543:1;52504:44;52484:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;52459:7;52467:1;52459:10;;;;;;-1:-1:-1;;;52459:10:0;;;;;;;;;;;;;;;;;;:190;-1:-1:-1;52401:3:0;;;;:::i;:::-;;;;52364:295;;;;52157:534;;;;;:::o;56375:1230::-;49506:32;49514:10;49506:30;:32::i;:::-;49504:35;:62;;;;-1:-1:-1;49543:9:0;49556:10;49543:23;49504:62;49496:96;;;;-1:-1:-1;;;49496: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;56572:11:::2;::::0;56557:10:::2;56545:23;::::0;;;:11:::2;:23;::::0;;;;;56525:44:::2;::::0;:15:::2;::::0;:19:::2;:44::i;:::-;:58;56517:123;;;;-1:-1:-1::0;;;56517:123:0::2;;;;;;;:::i;:::-;56659:37:::0;;::::2;56651:72;;;;-1:-1:-1::0;;;56651:72:0::2;;;;;;;:::i;:::-;56739:9;56734:864;56750:19:::0;;::::2;56734:864;;;56817:43;56848:8;;56857:1;56848:11;;;;;-1:-1:-1::0;;;56848:11:0::2;;;;;;;;;56827:10;56817:21;::::0;;;:9:::2;56848:11;56817:21:::0;;;;;;;;56848:11;::::2;;;::::0;-1:-1:-1;56817:30:0::2;:43::i;:::-;56791:133;;;;-1:-1:-1::0;;;56791:133:0::2;;;;;;;:::i;:::-;56941:41;56970:8;;56979:1;56970:11;;;;;-1:-1:-1::0;;;56970:11:0::2;;;;;;;;;56951:10;56941:21;::::0;;;:9:::2;56970:11;56941:21:::0;;;;;;;;56970:11;::::2;;;::::0;-1:-1:-1;56941:28:0::2;:41::i;:::-;-1:-1:-1::0;57007:25:0::2;::::0;-1:-1:-1;;;;;57007:25:0::2;56999:51;57077:4;57101:10;57130:8:::0;;57139:1;57130:11;;::::2;;;-1:-1:-1::0;;;57130:11:0::2;;;;;;;;;;;;;;;56999:178;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;57218:49;57252:11;;57264:1;57252:14;;;;;-1:-1:-1::0;;;57252:14:0::2;;;;;;;;;57231:10;57218:24;::::0;;;:12:::2;57252:14;57218:24:::0;;;;;;;;57252:14;::::2;;;::::0;-1:-1:-1;57218:33:0::2;:49::i;:::-;57192:139;;;;-1:-1:-1::0;;;57192:139:0::2;;;;;;;:::i;:::-;57348:47;57380:11;;57392:1;57380:14;;;;;-1:-1:-1::0;;;57380:14:0::2;;;;;;;;;57361:10;57348:24;::::0;;;:12:::2;57380:14;57348:24:::0;;;;;;;;57380:14;::::2;;;::::0;-1:-1:-1;57348:31:0::2;:47::i;:::-;-1:-1:-1::0;57420:18:0::2;::::0;-1:-1:-1;;;;;57420:18:0::2;57412:44;57483:4;57507:10;57536:11:::0;;57548:1;57536:14;;::::2;;;-1:-1:-1::0;;;57536:14:0::2;;;;;;;;;;;;;;;57412:174;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;56771:3;;;;;:::i;:::-;;;;56734:864;;;-1:-1:-1::0;;32298:1:0::1;33252:22:::0;;-1:-1:-1;;;56375:1230:0:o;57954:219::-;-1:-1:-1;;;57954:219:0;;;;;;;:::o;52742:416::-;-1:-1:-1;;;;;53117:23:0;;52846:7;53117:23;;;:14;:23;;;;;;;;:32;;;;;;;;;53089:10;;53066:34;;53075:12;;53066:8;:34::i;:::-;:83;;;;:::i;:::-;-1:-1:-1;;;;;53005:18:0;;;;;;:9;:18;;;;;:36;;53033:7;53005:27;:36::i;:::-;:44;;53048:1;53005:44;;;53044:1;53005:44;52985:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;52978:172;52742:416;-1:-1:-1;;;52742:416:0:o;49141:27::-;;;-1:-1:-1;;;;;49141:27:0;;:::o;49281:19::-;;;;:::o;50735: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;:::-;50795:4:::1;:12:::0;;;50821:17:::1;::::0;::::1;::::0;::::1;::::0;50802:5;;50821:17:::1;:::i;:::-;;;;;;;;50735:111:::0;:::o;50556: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;:::-;50603:10:::1;:8;:10::i;:::-;50556:65::o:0;49195:25::-;;;;:::o;50957: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;:::-;51042:26:::1;51057:11:::0;51042:12:::1;:26;:::i;:::-;51029:10;:39:::0;;;51082:29:::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;49993:44::-:0;;;;;;;;;;;;;:::o;35634:86::-;35705:7;;;;35634:86;:::o;53720:147::-;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;49506:32:::1;49514:10;49506:30;:32::i;:::-;49504:35;:62;;;;-1:-1:-1::0;49543:9:0::1;49556:10;49543:23;49504:62;49496:96;;;;-1:-1:-1::0;;;49496: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;53836:23:::3;53850:8:::0;;53836:13:::3;:23::i;:::-;-1:-1:-1::0;;32298:1:0::2;33252:22:::0;;53720: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;55052:1270::-:0;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;49506:32:::1;49514:10;49506:30;:32::i;:::-;49504:35;:62;;;;-1:-1:-1::0;49543:9:0::1;49556:10;49543:23;49504:62;49496:96;;;;-1:-1:-1::0;;;49496: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;55253:11:::3;::::0;55238:10:::3;55226:23;::::0;;;:11:::3;:23;::::0;;;;;55206:44:::3;::::0;:15:::3;::::0;:19:::3;:44::i;:::-;:58;55198:123;;;;-1:-1:-1::0;;;55198:123:0::3;;;;;;;:::i;:::-;55340:37:::0;;::::3;55332:72;;;;-1:-1:-1::0;;;55332:72:0::3;;;;;;;:::i;:::-;55415:23;55429:8;;55415:13;:23::i;:::-;55456:9;55451:864;55467:19:::0;;::::3;55451:864;;;55534:43;55565:8;;55574:1;55565:11;;;;;-1:-1:-1::0;;;55565:11:0::3;;;;;;;;55534:43;55508:133;;;;-1:-1:-1::0;;;55508:133:0::3;;;;;;;:::i;:::-;55658:41;55687:8;;55696:1;55687:11;;;;;-1:-1:-1::0;;;55687:11:0::3;;;;;;;;55658:41;-1:-1:-1::0;55724:25:0::3;::::0;-1:-1:-1;;;;;55724:25:0::3;55716:51;55794:4;55818:10;55847:8:::0;;55856:1;55847:11;;::::3;;;-1:-1:-1::0;;;55847:11:0::3;;;;;;;;;;;;;;;55716:178;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;55935:49;55969:11;;55981:1;55969:14;;;;;-1:-1:-1::0;;;55969:14:0::3;;;;;;;;55935:49;55909:139;;;;-1:-1:-1::0;;;55909:139:0::3;;;;;;;:::i;:::-;56065:47;56097:11;;56109:1;56097:14;;;;;-1:-1:-1::0;;;56097:14:0::3;;;;;;;;56065:47;-1:-1:-1::0;56137:18:0::3;::::0;-1:-1:-1;;;;;56137:18:0::3;56129:44;56200:4;56224:10;56253:11:::0;;56265:1;56253:14;;::::3;;;-1:-1:-1::0;;;56253:14:0::3;;;;;;;;;;;;;;;56129:174;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;55488:3;;;;;:::i;:::-;;;;55451:864;;50487: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;:::-;50532:8:::1;:6;:8::i;57641: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;:::-;57726:12:::1;::::0;57719:45:::1;::::0;-1:-1:-1;;;57719:45:0;;57697:19:::1;::::0;-1:-1:-1;;;;;57726:12:0::1;::::0;57719:30:::1;::::0;:45:::1;::::0;57758:4:::1;::::0;57719:45:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57790:12;::::0;57783:54:::1;::::0;-1:-1:-1;;;57783:54:0;;57697:67;;-1:-1:-1;;;;;;57790:12:0::1;::::0;57783:29:::1;::::0;:54:::1;::::0;57813:10:::1;::::0;57697:67;;57783:54:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57775:99;;;;-1:-1:-1::0;;;57775:99:0::1;;;;;;;:::i;:::-;2200:1;57641:241::o:0;1909:87::-;1955:7;1982:6;-1:-1:-1;;;;;1982:6:0;1909:87;:::o;51721:428::-;-1:-1:-1;;;;;51879:21:0;;51833:43;51879:21;;;:12;:21;;;;;51799:16;;51957:22;51879:21;51957:20;:22::i;:::-;51942:38;;;;;;-1:-1:-1;;;51942:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51942:38:0;;51911:69;;51997:9;51993:120;52012:22;:13;:20;:22::i;:::-;52008:1;:26;51993:120;;;52082:19;:13;52099:1;52082:16;:19::i;:::-;52065:11;52077:1;52065:14;;;;;;-1:-1:-1;;;52065:14:0;;;;;;;;;;;;;;;;;;:36;52036:3;;;;:::i;:::-;;;;51993:120;;;-1:-1:-1;52130:11:0;-1:-1:-1;;51721:428:0;;;;:::o;51148: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;:::-;51213:11:::1;:23:::0;;;51250:28:::1;::::0;::::1;::::0;::::1;::::0;51227:9;;51250:28:::1;:::i;49917:69::-:0;;;;;;;;;;;;;;;;;;;;;;;;:::o;51324:389::-;-1:-1:-1;;;;;51482:18:0;;51439:40;51482:18;;;:9;:18;;;;;51407:16;;51552:19;51482:18;51552:17;:19::i;:::-;51537:35;;;;;;-1:-1:-1;;;51537:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51537:35:0;;51509:63;;51588:9;51583:97;51603:19;:10;:17;:19::i;:::-;51599:1;:23;51583:97;;;51654:16;:10;51668:1;51654:13;:16::i;:::-;51640:8;51649:1;51640:11;;;;;;-1:-1:-1;;;51640:11:0;;;;;;;;;;;;;;;;;;:30;51624:3;;;;:::i;:::-;;;;51583:97;;53901:1115;35960:8;:6;:8::i;:::-;35959:9;35951:38;;;;-1:-1:-1;;;35951:38:0;;;;;;;:::i;:::-;49506:32:::1;49514:10;49506:30;:32::i;:::-;49504:35;:62;;;;-1:-1:-1::0;49543:9:0::1;49556:10;49543:23;49504:62;49496:96;;;;-1:-1:-1::0;;;49496: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;54069:25:::3;::::0;-1:-1:-1;;;;;54069:25:0::3;54055:10;:39;;54047:67;;;;-1:-1:-1::0;;;54047:67:0::3;;;;;;;:::i;:::-;54147:18;::::0;-1:-1:-1;;;;;54147:18:0::3;54133:10;:32;;54125:60;;;;-1:-1:-1::0;;;54125:60:0::3;;;;;;;:::i;:::-;54204:37:::0;;::::3;54196:72;;;;-1:-1:-1::0;;;54196:72:0::3;;;;;;;:::i;:::-;54302:10;;54287:12;:25;54279:77;;;;-1:-1:-1::0;;;54279:77:0::3;;;;;;;:::i;:::-;54367:23;54381:8;;54367:13;:23::i;:::-;54408:9;54403:554;54419:19:::0;;::::3;54403:554;;;54468:25;::::0;-1:-1:-1;;;;;54468:25:0::3;54460:51;54530:10;54567:4;54591:8:::0;;54600:1;54591:11;;::::3;;;-1:-1:-1::0;;;54591:11:0::3;;;;;;;;;;;;;;;54460:182;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;-1:-1:-1::0;;54665:18:0::3;::::0;-1:-1:-1;;;;;54665:18:0::3;::::0;-1:-1:-1;54657:44:0::3;::::0;-1:-1:-1;54720:10:0::3;54757:4;54781:11:::0;;54793:1;54781:14;;::::3;;;-1:-1:-1::0;;;54781:14:0::3;;;;;;;;;;;;;;;54657:174;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;54848:38;54874:8;;54883:1;54874:11;;;;;-1:-1:-1::0;;;54874:11:0::3;;;;;;;;;54858:10;54848:21;::::0;;;:9:::3;54874:11;54848:21:::0;;;;;;;;54874:11;::::3;;;::::0;-1:-1:-1;54848:25:0::3;:38::i;:::-;;54901:44;54930:11;;54942:1;54930:14;;;;;-1:-1:-1::0;;;54930:14:0::3;;;;;;;;;54914:10;54901:24;::::0;;;:12:::3;54930:14;54901:24:::0;;;;;;;;54930:14;::::3;;;::::0;-1:-1:-1;54901:28:0::3;:44::i;:::-;-1:-1:-1::0;54440:3:0;::::3;::::0;::::3;:::i;:::-;;;;54403:554;;;-1:-1:-1::0;;54979:10:0::3;54967:23;::::0;;;:11:::3;:23;::::0;;;;54993:15:::3;54967:41:::0;;-1:-1:-1;;32298:1:0::2;33252:22:::0;;-1:-1:-1;53901:1115: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;49355:27::-:0;;;;:::o;49101:33::-;;;-1:-1:-1;;;;;49101: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;40815:326::-;-1:-1:-1;;;;;41110:19:0;;:23;;;40815:326::o;6572:98::-;6630:7;6657:5;6661:1;6657;:5;:::i;28717:137::-;28787:4;28811:35;28819:3;28839:5;28811:7;:35::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;53204:479::-;53273:14;53297:16;53316:34;53325:12;53339:10;;53316:8;:34::i;:::-;53297:53;;53366:9;53361:174;53377:19;;;53361:174;;;53424:40;53440:10;53452:8;;53461:1;53452:11;;;;;-1:-1:-1;;;53452:11:0;;;;;;;;;;;;;;;53424:15;:40::i;:::-;53414:50;;;;:::i;:::-;53490:10;53475:26;;;;:14;:26;;;;;53414:50;;-1:-1:-1;53517:8:0;;53475:26;53502:8;;53511:1;53502:11;;;;;-1:-1:-1;;;53502:11:0;;;;;;;;;;;;;;;53475:39;;;;;;;;;;;:50;;;;53398:3;;;;;:::i;:::-;;;;53361:174;;;-1:-1:-1;53549:10:0;;53545:131;;53587:12;;53580:49;;-1:-1:-1;;;53580:49:0;;-1:-1:-1;;;;;53587:12:0;;;;53580:29;;:49;;53610:10;;53622:6;;53580:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53572:94;;;;-1:-1:-1;;;53572:94:0;;;;;;;:::i;:::-;53204:479;;;;:::o;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;29172:114::-:0;29232:7;29259:19;29267:3;29259:7;:19::i;29640:137::-;29711:7;29746:22;29750:3;29762:5;29746:3;:22::i;28410:131::-;28477:4;28501:32;28506:3;28526:5;28501:4;:32::i;21903:129::-;21976:4;22000:19;;;:12;;;;;:19;;;;;;:24;;;21903:129::o;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;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;;14:175:1;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:400;;;327:3;320:4;312:6;308:17;304:27;294:2;;350:6;342;335:22;294:2;-1:-1:-1;378:20:1;;421:18;410:30;;407:2;;;460:8;450;443:26;407:2;504:4;496:6;492:17;480:29;;567:3;560:4;552;544:6;540:17;532:6;528:30;524:41;521:50;518:2;;;584:1;581;574:12;518:2;284:310;;;;;:::o;599:198::-;;711:2;699:9;690:7;686:23;682:32;679:2;;;732:6;724;717:22;679:2;760:31;781:9;760:31;:::i;802:862::-;;;;;;984:3;972:9;963:7;959:23;955:33;952:2;;;1006:6;998;991:22;952:2;1034:31;1055:9;1034:31;:::i;:::-;1024:41;;1084:40;1120:2;1109:9;1105:18;1084:40;:::i;:::-;1074:50;;1171:2;1160:9;1156:18;1143:32;1133:42;;1226:2;1215:9;1211:18;1198:32;1249:18;1290:2;1282:6;1279:14;1276:2;;;1311:6;1303;1296:22;1276:2;1354:6;1343:9;1339:22;1329:32;;1399:7;1392:4;1388:2;1384:13;1380:27;1370:2;;1426:6;1418;1411:22;1370:2;1471;1458:16;1497:2;1489:6;1486:14;1483:2;;;1518:6;1510;1503:22;1483:2;1568:7;1563:2;1554:6;1550:2;1546:15;1542:24;1539:37;1536:2;;;1594:6;1586;1579:22;1536:2;942:722;;;;-1:-1:-1;942:722:1;;-1:-1:-1;1630:2:1;1622:11;;1652:6;942:722;-1:-1:-1;;;942:722:1:o;1669:1248::-;;;1823:2;1811:9;1802:7;1798:23;1794:32;1791:2;;;1844:6;1836;1829:22;1791:2;1872:31;1893:9;1872:31;:::i;:::-;1862:41;;1922:2;1975;1964:9;1960:18;1947:32;1998:18;2039:2;2031:6;2028:14;2025:2;;;2060:6;2052;2045:22;2025:2;2103:6;2092:9;2088:22;2078:32;;2148:7;2141:4;2137:2;2133:13;2129:27;2119:2;;2175:6;2167;2160:22;2119:2;2216;2203:16;2238:2;2234;2231:10;2228:2;;;2244:18;;:::i;:::-;2291:2;2287;2283:11;2323:2;2317:9;2386:2;2382:7;2377:2;2373;2369:11;2365:25;2357:6;2353:38;2441:6;2429:10;2426:22;2421:2;2409:10;2406:18;2403:46;2400:2;;;2452:18;;:::i;:::-;2488:2;2481:22;2538:18;;;2572:15;;;;-1:-1:-1;2607:11:1;;;2637;;;2633:20;;2630:33;-1:-1:-1;2627:2:1;;;2681:6;2673;2666:22;2627:2;2708:6;2699:15;;2723:163;2737:2;2734:1;2731:9;2723:163;;;2794:17;;2782:30;;2755:1;2748:9;;;;;2832:12;;;;2864;;2723:163;;;2727:3;2905:6;2895:16;;;;;;;;1781:1136;;;;;:::o;2922:266::-;;;3051:2;3039:9;3030:7;3026:23;3022:32;3019:2;;;3072:6;3064;3057:22;3019:2;3100:31;3121:9;3100:31;:::i;:::-;3090:41;3178:2;3163:18;;;;3150:32;;-1:-1:-1;;;3009:179:1:o;3193:463::-;;;3340:2;3328:9;3319:7;3315:23;3311:32;3308:2;;;3361:6;3353;3346:22;3308:2;3406:9;3393:23;3439:18;3431:6;3428:30;3425:2;;;3476:6;3468;3461:22;3425:2;3520:76;3588:7;3579:6;3568:9;3564:22;3520:76;:::i;:::-;3615:8;;3494:102;;-1:-1:-1;3298:358:1;-1:-1:-1;;;;3298:358:1:o;3661:815::-;;;;;3860:2;3848:9;3839:7;3835:23;3831:32;3828:2;;;3881:6;3873;3866:22;3828:2;3926:9;3913:23;3955:18;3996:2;3988:6;3985:14;3982:2;;;4017:6;4009;4002:22;3982:2;4061:76;4129:7;4120:6;4109:9;4105:22;4061:76;:::i;:::-;4156:8;;-1:-1:-1;4035:102:1;-1:-1:-1;4244:2:1;4229:18;;4216:32;;-1:-1:-1;4260:16:1;;;4257:2;;;4294:6;4286;4279:22;4257:2;;4338:78;4408:7;4397:8;4386:9;4382:24;4338:78;:::i;:::-;3818:658;;;;-1:-1:-1;4435:8:1;-1:-1:-1;;;;3818:658:1:o;4481:297::-;;4601:2;4589:9;4580:7;4576:23;4572:32;4569:2;;;4622:6;4614;4607:22;4569:2;4659:9;4653:16;4712:5;4705:13;4698:21;4691:5;4688:32;4678:2;;4739:6;4731;4724:22;4783:190;;4895:2;4883:9;4874:7;4870:23;4866:32;4863:2;;;4916:6;4908;4901:22;4863:2;-1:-1:-1;4944:23:1;;4853:120;-1:-1:-1;4853:120:1:o;4978:194::-;;5101:2;5089:9;5080:7;5076:23;5072:32;5069:2;;;5122:6;5114;5107:22;5069:2;-1:-1:-1;5150:16:1;;5059:113;-1:-1:-1;5059:113:1:o;5177:203::-;-1:-1:-1;;;;;5341:32:1;;;;5323:51;;5311:2;5296:18;;5278:102::o;5385:558::-;-1:-1:-1;;;;;5708:15:1;;;5690:34;;5760:15;;;;5755:2;5740:18;;5733:43;5807:2;5792:18;;5785:34;;;;5855:3;5850:2;5835:18;;5828:31;;;5385:558;5875:19;;;5868:33;5670:3;5918:19;;5642:301::o;5948:274::-;-1:-1:-1;;;;;6140:32:1;;;;6122:51;;6204:2;6189:18;;6182:34;6110:2;6095:18;;6077:145::o;6227:635::-;6398:2;6450:21;;;6520:13;;6423:18;;;6542:22;;;6227:635;;6398:2;6621:15;;;;6595:2;6580:18;;;6227:635;6667:169;6681:6;6678:1;6675:13;6667:169;;;6742:13;;6730:26;;6811:15;;;;6776:12;;;;6703:1;6696:9;6667:169;;;-1:-1:-1;6853:3:1;;6378:484;-1:-1:-1;;;;;;6378:484:1:o;6867:187::-;7032:14;;7025:22;7007:41;;6995:2;6980:18;;6962:92::o;7059:202::-;-1:-1:-1;;;;;;7221:33:1;;;;7203:52;;7191:2;7176:18;;7158:103::o;7266:344::-;7468:2;7450:21;;;7507:2;7487:18;;;7480:30;-1:-1:-1;;;7541:2:1;7526:18;;7519:50;7601:2;7586:18;;7440:170::o;7615:356::-;7817:2;7799:21;;;7836:18;;;7829:30;7895:34;7890:2;7875:18;;7868:62;7962:2;7947:18;;7789:182::o;7976:339::-;8178:2;8160:21;;;8217:2;8197:18;;;8190:30;-1:-1:-1;;;8251:2:1;8236:18;;8229:45;8306:2;8291:18;;8150:165::o;8320:402::-;8522:2;8504:21;;;8561:2;8541:18;;;8534:30;8600:34;8595:2;8580:18;;8573:62;-1:-1:-1;;;8666:2:1;8651:18;;8644:36;8712:3;8697:19;;8494:228::o;8727:346::-;8929:2;8911:21;;;8968:2;8948:18;;;8941:30;-1:-1:-1;;;9002:2:1;8987:18;;8980:52;9064:2;9049:18;;8901:172::o;9078:345::-;9280:2;9262:21;;;9319:2;9299:18;;;9292:30;-1:-1:-1;;;9353:2:1;9338:18;;9331:51;9414:2;9399:18;;9252:171::o;9428:403::-;9630:2;9612:21;;;9669:2;9649:18;;;9642:30;9708:34;9703:2;9688:18;;9681:62;-1:-1:-1;;;9774:2:1;9759:18;;9752:37;9821:3;9806:19;;9602:229::o;9836:340::-;10038:2;10020:21;;;10077:2;10057:18;;;10050:30;-1:-1:-1;;;10111:2:1;10096:18;;10089:46;10167:2;10152:18;;10010:166::o;10181:356::-;10383:2;10365:21;;;10402:18;;;10395:30;10461:34;10456:2;10441:18;;10434:62;10528:2;10513:18;;10355:182::o;10542:416::-;10744:2;10726:21;;;10783:2;10763:18;;;10756:30;10822:34;10817:2;10802:18;;10795:62;-1:-1:-1;;;10888:2:1;10873:18;;10866:50;10948:3;10933:19;;10716:242::o;10963:352::-;11165:2;11147:21;;;11204:2;11184:18;;;11177:30;11243;11238:2;11223:18;;11216:58;11306:2;11291:18;;11137:178::o;11320:355::-;11522:2;11504:21;;;11561:2;11541:18;;;11534:30;11600:33;11595:2;11580:18;;11573:61;11666:2;11651:18;;11494:181::o;11680:177::-;11826:25;;;11814:2;11799:18;;11781:76::o;11862:128::-;;11933:1;11929:6;11926:1;11923:13;11920:2;;;11939:18;;:::i;:::-;-1:-1:-1;11975:9:1;;11910:80::o;11995:168::-;;12101:1;12097;12093:6;12089:14;12086:1;12083:21;12078:1;12071:9;12064:17;12060:45;12057:2;;;12108:18;;:::i;:::-;-1:-1:-1;12148:9:1;;12047:116::o;12168:125::-;;12236:1;12233;12230:8;12227:2;;;12241:18;;:::i;:::-;-1:-1:-1;12278:9:1;;12217:76::o;12298:135::-;;-1:-1:-1;;12358:17:1;;12355:2;;;12378:18;;:::i;:::-;-1:-1:-1;12425:1:1;12414:13;;12345:88::o;12438:127::-;12499:10;12494:3;12490:20;12487:1;12480:31;12530:4;12527:1;12520:15;12554:4;12551:1;12544:15;12570:127;12631:10;12626:3;12622:20;12619:1;12612:31;12662:4;12659:1;12652:15;12686:4;12683:1;12676:15

ipfs://666723e7e7f41ce7bac0075b9bc7f76c49942803695295cf9533c1b124cd74dd