Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function paused()
•    - function _pause()
•    - function _unpause()
• 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 ...
• 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)
• interface IERC721Receiver
•    - function onERC721Received(
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• 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(
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
•  contract LiquidKeyForge is Ownable ... *
•    - function pause()
•    - function unpause()
•    - function forgedKeyOwnerAddress(addres ...
•    - function forgeLiquidKey(uint256[] cal ...
•    - function removeLiquidKey(uint256[] ca ...
•    - function withdrawKeysBackdoor(uint256 ...
•    - function withdrawTokens()
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-08-18
*/

// SPDX-License-Identifier: MIT
/*
   .____    .__             .__    .___   ___________
   |    |   |__| ________ __|__| __| _/   \_   _____/__________  ____   ____
   |    |   |  |/ ____/  |  \  |/ __ |     |    __)/  _ \_  __ \/ ___\_/ __ \
   |    |___|  < <_|  |  |  /  / /_/ |     |     \(  <_> )  | \/ /_/  >  ___/
   |_______ \__|\__   |____/|__\____ |     \___  / \____/|__|  \___  / \___  >
           \/      |__|             \/         \/             /_____/      \/

    * Liquid Key Forge Contract for ApeLiquid.io | August 2022 **************
*/

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

pragma solidity ^0.8.0;

/**
 * @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`, 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId)
        external
        view
        returns (address operator);

    /**
     * @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 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);

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @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());
    }
}

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

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

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

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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

pragma solidity ^0.8.0;

/**
 * @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 tokenId);

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

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 no longer needed starting with Solidity 0.8. 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 substraction 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;
        }
    }
}

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        _setOwner(newOwner);
    }

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

pragma solidity ^0.8.0;

contract LiquidKeyForge is Ownable, IERC721Receiver, ReentrancyGuard, Pausable {
    using EnumerableSet for EnumerableSet.UintSet;

    // addresses for Liquid Key & METL token
    address public liquidKeyAddress = 0x753412F4FB7245BCF1c0714fDf59ba89110f39b8;
    address public erc20Address = 0xFcbE615dEf610E806BB64427574A2c5c1fB55510;

    // address public liquidRecoveryAddress;

    mapping(address => EnumerableSet.UintSet) private _liquidKeyForges;
    mapping(address => uint256) public _liquidKeyForgeBlocks;

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

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

    // Check which Key is forged
    function forgedKeyOwnerAddress(address account)
        external
        view
        returns (uint256[] memory)
    {
        EnumerableSet.UintSet storage forgeSet = _liquidKeyForges[account];
        uint256[] memory tokenIds = new uint256[](forgeSet.length());

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

        return tokenIds;
    }

    // Forge Liquid Key
    function forgeLiquidKey(uint256[] calldata tokenIds)
        external
        whenNotPaused
    {
        uint256 blockCur = block.number;
        require(msg.sender != liquidKeyAddress, "Invalid address");

        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(liquidKeyAddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIds[i],
                "Transfer from Member to Forge"
            );
            _liquidKeyForges[msg.sender].add(tokenIds[i]);
        }
        _liquidKeyForgeBlocks[msg.sender] = blockCur;
    }

    // Remove Liquid Key from Forge
    function removeLiquidKey(uint256[] calldata tokenIds)
        external
        whenNotPaused
        nonReentrant
    {
        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _liquidKeyForges[msg.sender].contains(tokenIds[i]),
                "Forge: Key NOT Forged"
            );

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

            IERC721(liquidKeyAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                "Transfer from Forge to Member"
            );
        }
    }

    // Withdraw keys (backdoor)
    function withdrawKeysBackdoor(uint256 tokenId)
        external
        whenNotPaused
        nonReentrant
    {
        require(
            tokenId > 9999,
            "You really think we would add a backdoor? lol"
        );
        return;
    }

    // Withdraw all ERC20 tokens (METL)
    function withdrawTokens() external onlyOwner {
        uint256 tokenSupply = IERC20(erc20Address).balanceOf(address(this));
        IERC20(erc20Address).transfer(msg.sender, tokenSupply);
    }

    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_liquidKeyForgeBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"forgeLiquidKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"forgedKeyOwnerAddress","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidKeyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"removeLiquidKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":"tokenId","type":"uint256"}],"name":"withdrawKeysBackdoor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

39942:3216:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42936:219;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40413:56;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40211:72;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42423:260;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40547:65;;;:::i;:::-;;10885:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39249:94;;;:::i;:::-;;40128:76;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40478:61;;;:::i;:::-;;42732:196;;;:::i;:::-;;38598:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41760:622;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40654:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41103:612;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39498:229;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42936:219;43080:6;43106:41;;;43099:48;;42936:219;;;;;;;:::o;40413:56::-;;;;;;;;;;;;;;;;;:::o;40211:72::-;;;;;;;;;;;;;:::o;42423:260::-;11211:8;:6;:8::i;:::-;11210:9;11202:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;14915:1:::1;15511:7;;:19;;15503:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;14915:1;15644:7;:18;;;;42581:4:::2;42571:7;:14;42549:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;14871:1:::1;15823:7:::0;:22:::1;;;;42423:260:::0;:::o;40547:65::-;38829:12;:10;:12::i;:::-;38818:23;;:7;:5;:7::i;:::-;:23;;;38810:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;40594:10:::1;:8;:10::i;:::-;40547:65::o:0;10885:86::-;10932:4;10956:7;;;;;;;;;;;10949:14;;10885:86;:::o;39249:94::-;38829:12;:10;:12::i;:::-;38818:23;;:7;:5;:7::i;:::-;:23;;;38810:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;39314:21:::1;39332:1;39314:9;:21::i;:::-;39249:94::o:0;40128:76::-;;;;;;;;;;;;;:::o;40478:61::-;38829:12;:10;:12::i;:::-;38818:23;;:7;:5;:7::i;:::-;:23;;;38810:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;40523:8:::1;:6;:8::i;:::-;40478:61::o:0;42732:196::-;38829:12;:10;:12::i;:::-;38818:23;;:7;:5;:7::i;:::-;:23;;;38810:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;42788:19:::1;42817:12;;;;;;;;;;;42810:30;;;42849:4;42810:45;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42788:67;;42873:12;;;;;;;;;;;42866:29;;;42896:10;42908:11;42866:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42777:151;42732:196::o:0;38598:87::-;38644:7;38671:6;;;;;;;;;;;38664:13;;38598:87;:::o;41760:622::-;11211:8;:6;:8::i;:::-;11210:9;11202:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;14915:1:::1;15511:7;;:19;;15503:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;14915:1;15644:7;:18;;;;41898:9:::2;41893:482;41913:8;;:15;;41909:1;:19;41893:482;;;41976:50;42014:8;;42023:1;42014:11;;;;;;;:::i;:::-;;;;;;;;41976:16;:28;41993:10;41976:28;;;;;;;;;;;;;;;:37;;:50;;;;:::i;:::-;41950:133;;;;;;;;;;;;:::i;:::-;;;;;;;;;42100:48;42136:8;;42145:1;42136:11;;;;;;;:::i;:::-;;;;;;;;42100:16;:28;42117:10;42100:28;;;;;;;;;;;;;;;:35;;:48;;;;:::i;:::-;;42173:16;;;;;;;;;;;42165:42;;;42234:4;42258:10;42287:8;;42296:1;42287:11;;;;;;;:::i;:::-;;;;;;;;42165:198;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;41930:3;;;;;:::i;:::-;;;;41893:482;;;;14871:1:::1;15823:7:::0;:22:::1;;;;41760:622:::0;;:::o;40654:416::-;40752:16;40786:38;40827:16;:25;40844:7;40827:25;;;;;;;;;;;;;;;40786:66;;40863:25;40905:17;:8;:15;:17::i;:::-;40891:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40863:60;;40941:9;40936:99;40956:17;:8;:15;:17::i;:::-;40952:1;:21;40936:99;;;41009:14;41021:1;41009:8;:11;;:14;;;;:::i;:::-;40995:8;41004:1;40995:11;;;;;;;;:::i;:::-;;;;;;;:28;;;;;40975:3;;;;;:::i;:::-;;;;40936:99;;;;41054:8;41047:15;;;;40654:416;;;:::o;41103:612::-;11211:8;:6;:8::i;:::-;11210:9;11202:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;41213:16:::1;41232:12;41213:31;;41277:16;;;;;;;;;;;41263:30;;:10;:30;;;;41255:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;41331:9;41326:327;41346:8;;:15;;41342:1;:19;41326:327;;;41391:16;;;;;;;;;;;41383:42;;;41444:10;41481:4;41505:8;;41514:1;41505:11;;;;;;;:::i;:::-;;;;;;;;41383:198;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;41596:45;41629:8;;41638:1;41629:11;;;;;;;:::i;:::-;;;;;;;;41596:16;:28;41613:10;41596:28;;;;;;;;;;;;;;;:32;;:45;;;;:::i;:::-;;41363:3;;;;;:::i;:::-;;;;41326:327;;;;41699:8;41663:21;:33;41685:10;41663:33;;;;;;;;;;;;;;;:44;;;;41202:513;41103:612:::0;;:::o;39498:229::-;38829:12;:10;:12::i;:::-;38818:23;;:7;:5;:7::i;:::-;:23;;;38810:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;39621:1:::1;39601:22;;:8;:22;;;;39579:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;39700:19;39710:8;39700:9;:19::i;:::-;39498:229:::0;:::o;6808:98::-;6861:7;6888:10;6881:17;;6808:98;:::o;11944:120::-;11488:8;:6;:8::i;:::-;11480:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;12013:5:::1;12003:7;;:15;;;;;;;;;;;;;;;;;;12034:22;12043:12;:10;:12::i;:::-;12034:22;;;;;;:::i;:::-;;;;;;;;11944:120::o:0;39735:173::-;39791:16;39810:6;;;;;;;;;;;39791:25;;39836:8;39827:6;;:17;;;;;;;;;;;;;;;;;;39891:8;39860:40;;39881:8;39860:40;;;;;;;;;;;;39780:128;39735:173;:::o;11685:118::-;11211:8;:6;:8::i;:::-;11210:9;11202:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;11755:4:::1;11745:7;;:14;;;;;;;;;;;;;;;;;;11775:20;11782:12;:10;:12::i;:::-;11775:20;;;;;;:::i;:::-;;;;;;;;11685:118::o:0;27011:178::-;27115:4;27144:37;27154:3;:10;;27174:5;27166:14;;27144:9;:37::i;:::-;27137:44;;27011:178;;;;:::o;26765:160::-;26853:4;26882:35;26890:3;:10;;26910:5;26902:14;;26882:7;:35::i;:::-;26875:42;;26765:160;;;;:::o;27275:114::-;27335:7;27362:19;27370:3;:10;;27362:7;:19::i;:::-;27355:26;;27275:114;;;:::o;27743:169::-;27841:7;27881:22;27885:3;:10;;27897:5;27881:3;:22::i;:::-;27873:31;;27866:38;;27743:169;;;;:::o;26458:131::-;26525:4;26549:32;26554:3;:10;;26574:5;26566:14;;26549:4;:32::i;:::-;26542:39;;26458:131;;;;:::o;19603:161::-;19703:4;19755:1;19732:3;:12;;:19;19745:5;19732:19;;;;;;;;;;;;:24;;19725:31;;19603:161;;;;:::o;18097:1420::-;18163:4;18281:18;18302:3;:12;;:19;18315:5;18302:19;;;;;;;;;;;;18281:40;;18352:1;18338:10;:15;18334:1176;;18713:21;18750:1;18737:10;:14;;;;:::i;:::-;18713:38;;18766:17;18807:1;18786:3;:11;;:18;;;;:22;;;;:::i;:::-;18766:42;;18842:13;18829:9;:26;18825:405;;18876:17;18896:3;:11;;18908:9;18896:22;;;;;;;;:::i;:::-;;;;;;;;;;18876:42;;19050:9;19021:3;:11;;19033:13;19021:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;19161:10;19135:3;:12;;:23;19148:9;19135:23;;;;;;;;;;;:36;;;;18857:373;18825:405;19311:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;19406:3;:12;;:19;19419:5;19406:19;;;;;;;;;;;19399:26;;;19449:4;19442:11;;;;;;;18334:1176;19493:5;19486:12;;;18097:1420;;;;;:::o;19850:109::-;19906:7;19933:3;:11;;:18;;;;19926:25;;19850:109;;;:::o;20313:152::-;20407:7;20439:3;:11;;20451:5;20439:18;;;;;;;;:::i;:::-;;;;;;;;;;20432:25;;20313:152;;;;:::o;17507:414::-;17570:4;17592:21;17602:3;17607:5;17592:9;:21::i;:::-;17587:327;;17630:3;:11;;17647:5;17630:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17813:3;:11;;:18;;;;17791:3;:12;;:19;17804:5;17791:19;;;;;;;;;;;:40;;;;17853:4;17846:11;;;;17587:327;17897:5;17890:12;;17507:414;;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:117::-;1306:1;1303;1296:12;1320:117;1429:1;1426;1419:12;1443:117;1552:1;1549;1542:12;1579:552;1636:8;1646:6;1696:3;1689:4;1681:6;1677:17;1673:27;1663:122;;1704:79;;:::i;:::-;1663:122;1817:6;1804:20;1794:30;;1847:18;1839:6;1836:30;1833:117;;;1869:79;;:::i;:::-;1833:117;1983:4;1975:6;1971:17;1959:29;;2037:3;2029:4;2021:6;2017:17;2007:8;2003:32;2000:41;1997:128;;;2044:79;;:::i;:::-;1997:128;1579:552;;;;;:::o;2137:963::-;2234:6;2242;2250;2258;2266;2315:3;2303:9;2294:7;2290:23;2286:33;2283:120;;;2322:79;;:::i;:::-;2283:120;2442:1;2467:53;2512:7;2503:6;2492:9;2488:22;2467:53;:::i;:::-;2457:63;;2413:117;2569:2;2595:53;2640:7;2631:6;2620:9;2616:22;2595:53;:::i;:::-;2585:63;;2540:118;2697:2;2723:53;2768:7;2759:6;2748:9;2744:22;2723:53;:::i;:::-;2713:63;;2668:118;2853:2;2842:9;2838:18;2825:32;2884:18;2876:6;2873:30;2870:117;;;2906:79;;:::i;:::-;2870:117;3019:64;3075:7;3066:6;3055:9;3051:22;3019:64;:::i;:::-;3001:82;;;;2796:297;2137:963;;;;;;;;:::o;3106:149::-;3142:7;3182:66;3175:5;3171:78;3160:89;;3106:149;;;:::o;3261:115::-;3346:23;3363:5;3346:23;:::i;:::-;3341:3;3334:36;3261:115;;:::o;3382:218::-;3473:4;3511:2;3500:9;3496:18;3488:26;;3524:69;3590:1;3579:9;3575:17;3566:6;3524:69;:::i;:::-;3382:218;;;;:::o;3606:329::-;3665:6;3714:2;3702:9;3693:7;3689:23;3685:32;3682:119;;;3720:79;;:::i;:::-;3682:119;3840:1;3865:53;3910:7;3901:6;3890:9;3886:22;3865:53;:::i;:::-;3855:63;;3811:117;3606:329;;;;:::o;3941:118::-;4028:24;4046:5;4028:24;:::i;:::-;4023:3;4016:37;3941:118;;:::o;4065:222::-;4158:4;4196:2;4185:9;4181:18;4173:26;;4209:71;4277:1;4266:9;4262:17;4253:6;4209:71;:::i;:::-;4065:222;;;;:::o;4293:118::-;4380:24;4398:5;4380:24;:::i;:::-;4375:3;4368:37;4293:118;;:::o;4417:222::-;4510:4;4548:2;4537:9;4533:18;4525:26;;4561:71;4629:1;4618:9;4614:17;4605:6;4561:71;:::i;:::-;4417:222;;;;:::o;4645:329::-;4704:6;4753:2;4741:9;4732:7;4728:23;4724:32;4721:119;;;4759:79;;:::i;:::-;4721:119;4879:1;4904:53;4949:7;4940:6;4929:9;4925:22;4904:53;:::i;:::-;4894:63;;4850:117;4645:329;;;;:::o;4980:90::-;5014:7;5057:5;5050:13;5043:21;5032:32;;4980:90;;;:::o;5076:109::-;5157:21;5172:5;5157:21;:::i;:::-;5152:3;5145:34;5076:109;;:::o;5191:210::-;5278:4;5316:2;5305:9;5301:18;5293:26;;5329:65;5391:1;5380:9;5376:17;5367:6;5329:65;:::i;:::-;5191:210;;;;:::o;5424:568::-;5497:8;5507:6;5557:3;5550:4;5542:6;5538:17;5534:27;5524:122;;5565:79;;:::i;:::-;5524:122;5678:6;5665:20;5655:30;;5708:18;5700:6;5697:30;5694:117;;;5730:79;;:::i;:::-;5694:117;5844:4;5836:6;5832:17;5820:29;;5898:3;5890:4;5882:6;5878:17;5868:8;5864:32;5861:41;5858:128;;;5905:79;;:::i;:::-;5858:128;5424:568;;;;;:::o;5998:559::-;6084:6;6092;6141:2;6129:9;6120:7;6116:23;6112:32;6109:119;;;6147:79;;:::i;:::-;6109:119;6295:1;6284:9;6280:17;6267:31;6325:18;6317:6;6314:30;6311:117;;;6347:79;;:::i;:::-;6311:117;6460:80;6532:7;6523:6;6512:9;6508:22;6460:80;:::i;:::-;6442:98;;;;6238:312;5998:559;;;;;:::o;6563:114::-;6630:6;6664:5;6658:12;6648:22;;6563:114;;;:::o;6683:184::-;6782:11;6816:6;6811:3;6804:19;6856:4;6851:3;6847:14;6832:29;;6683:184;;;;:::o;6873:132::-;6940:4;6963:3;6955:11;;6993:4;6988:3;6984:14;6976:22;;6873:132;;;:::o;7011:108::-;7088:24;7106:5;7088:24;:::i;:::-;7083:3;7076:37;7011:108;;:::o;7125:179::-;7194:10;7215:46;7257:3;7249:6;7215:46;:::i;:::-;7293:4;7288:3;7284:14;7270:28;;7125:179;;;;:::o;7310:113::-;7380:4;7412;7407:3;7403:14;7395:22;;7310:113;;;:::o;7459:732::-;7578:3;7607:54;7655:5;7607:54;:::i;:::-;7677:86;7756:6;7751:3;7677:86;:::i;:::-;7670:93;;7787:56;7837:5;7787:56;:::i;:::-;7866:7;7897:1;7882:284;7907:6;7904:1;7901:13;7882:284;;;7983:6;7977:13;8010:63;8069:3;8054:13;8010:63;:::i;:::-;8003:70;;8096:60;8149:6;8096:60;:::i;:::-;8086:70;;7942:224;7929:1;7926;7922:9;7917:14;;7882:284;;;7886:14;8182:3;8175:10;;7583:608;;;7459:732;;;;:::o;8197:373::-;8340:4;8378:2;8367:9;8363:18;8355:26;;8427:9;8421:4;8417:20;8413:1;8402:9;8398:17;8391:47;8455:108;8558:4;8549:6;8455:108;:::i;:::-;8447:116;;8197:373;;;;:::o;8576:169::-;8660:11;8694:6;8689:3;8682:19;8734:4;8729:3;8725:14;8710:29;;8576:169;;;;:::o;8751:166::-;8891:18;8887:1;8879:6;8875:14;8868:42;8751:166;:::o;8923:366::-;9065:3;9086:67;9150:2;9145:3;9086:67;:::i;:::-;9079:74;;9162:93;9251:3;9162:93;:::i;:::-;9280:2;9275:3;9271:12;9264:19;;8923:366;;;:::o;9295:419::-;9461:4;9499:2;9488:9;9484:18;9476:26;;9548:9;9542:4;9538:20;9534:1;9523:9;9519:17;9512:47;9576:131;9702:4;9576:131;:::i;:::-;9568:139;;9295:419;;;:::o;9720:181::-;9860:33;9856:1;9848:6;9844:14;9837:57;9720:181;:::o;9907:366::-;10049:3;10070:67;10134:2;10129:3;10070:67;:::i;:::-;10063:74;;10146:93;10235:3;10146:93;:::i;:::-;10264:2;10259:3;10255:12;10248:19;;9907:366;;;:::o;10279:419::-;10445:4;10483:2;10472:9;10468:18;10460:26;;10532:9;10526:4;10522:20;10518:1;10507:9;10503:17;10496:47;10560:131;10686:4;10560:131;:::i;:::-;10552:139;;10279:419;;;:::o;10704:232::-;10844:34;10840:1;10832:6;10828:14;10821:58;10913:15;10908:2;10900:6;10896:15;10889:40;10704:232;:::o;10942:366::-;11084:3;11105:67;11169:2;11164:3;11105:67;:::i;:::-;11098:74;;11181:93;11270:3;11181:93;:::i;:::-;11299:2;11294:3;11290:12;11283:19;;10942:366;;;:::o;11314:419::-;11480:4;11518:2;11507:9;11503:18;11495:26;;11567:9;11561:4;11557:20;11553:1;11542:9;11538:17;11531:47;11595:131;11721:4;11595:131;:::i;:::-;11587:139;;11314:419;;;:::o;11739:182::-;11879:34;11875:1;11867:6;11863:14;11856:58;11739:182;:::o;11927:366::-;12069:3;12090:67;12154:2;12149:3;12090:67;:::i;:::-;12083:74;;12166:93;12255:3;12166:93;:::i;:::-;12284:2;12279:3;12275:12;12268:19;;11927:366;;;:::o;12299:419::-;12465:4;12503:2;12492:9;12488:18;12480:26;;12552:9;12546:4;12542:20;12538:1;12527:9;12523:17;12516:47;12580:131;12706:4;12580:131;:::i;:::-;12572:139;;12299:419;;;:::o;12724:143::-;12781:5;12812:6;12806:13;12797:22;;12828:33;12855:5;12828:33;:::i;:::-;12724:143;;;;:::o;12873:351::-;12943:6;12992:2;12980:9;12971:7;12967:23;12963:32;12960:119;;;12998:79;;:::i;:::-;12960:119;13118:1;13143:64;13199:7;13190:6;13179:9;13175:22;13143:64;:::i;:::-;13133:74;;13089:128;12873:351;;;;:::o;13230:332::-;13351:4;13389:2;13378:9;13374:18;13366:26;;13402:71;13470:1;13459:9;13455:17;13446:6;13402:71;:::i;:::-;13483:72;13551:2;13540:9;13536:18;13527:6;13483:72;:::i;:::-;13230:332;;;;;:::o;13568:116::-;13638:21;13653:5;13638:21;:::i;:::-;13631:5;13628:32;13618:60;;13674:1;13671;13664:12;13618:60;13568:116;:::o;13690:137::-;13744:5;13775:6;13769:13;13760:22;;13791:30;13815:5;13791:30;:::i;:::-;13690:137;;;;:::o;13833:345::-;13900:6;13949:2;13937:9;13928:7;13924:23;13920:32;13917:119;;;13955:79;;:::i;:::-;13917:119;14075:1;14100:61;14153:7;14144:6;14133:9;14129:22;14100:61;:::i;:::-;14090:71;;14046:125;13833:345;;;;:::o;14184:180::-;14232:77;14229:1;14222:88;14329:4;14326:1;14319:15;14353:4;14350:1;14343:15;14370:171;14510:23;14506:1;14498:6;14494:14;14487:47;14370:171;:::o;14547:366::-;14689:3;14710:67;14774:2;14769:3;14710:67;:::i;:::-;14703:74;;14786:93;14875:3;14786:93;:::i;:::-;14904:2;14899:3;14895:12;14888:19;;14547:366;;;:::o;14919:419::-;15085:4;15123:2;15112:9;15108:18;15100:26;;15172:9;15166:4;15162:20;15158:1;15147:9;15143:17;15136:47;15200:131;15326:4;15200:131;:::i;:::-;15192:139;;14919:419;;;:::o;15344:168::-;15427:11;15461:6;15456:3;15449:19;15501:4;15496:3;15492:14;15477:29;;15344:168;;;;:::o;15518:179::-;15658:31;15654:1;15646:6;15642:14;15635:55;15518:179;:::o;15703:364::-;15844:3;15865:66;15928:2;15923:3;15865:66;:::i;:::-;15858:73;;15940:93;16029:3;15940:93;:::i;:::-;16058:2;16053:3;16049:12;16042:19;;15703:364;;;:::o;16073:748::-;16322:4;16360:3;16349:9;16345:19;16337:27;;16374:71;16442:1;16431:9;16427:17;16418:6;16374:71;:::i;:::-;16455:72;16523:2;16512:9;16508:18;16499:6;16455:72;:::i;:::-;16537;16605:2;16594:9;16590:18;16581:6;16537:72;:::i;:::-;16656:9;16650:4;16646:20;16641:2;16630:9;16626:18;16619:48;16684:130;16809:4;16684:130;:::i;:::-;16676:138;;16073:748;;;;;;:::o;16827:180::-;16875:77;16872:1;16865:88;16972:4;16969:1;16962:15;16996:4;16993:1;16986:15;17013:233;17052:3;17075:24;17093:5;17075:24;:::i;:::-;17066:33;;17121:66;17114:5;17111:77;17108:103;;;17191:18;;:::i;:::-;17108:103;17238:1;17231:5;17227:13;17220:20;;17013:233;;;:::o;17252:180::-;17300:77;17297:1;17290:88;17397:4;17394:1;17387:15;17421:4;17418:1;17411:15;17438:165;17578:17;17574:1;17566:6;17562:14;17555:41;17438:165;:::o;17609:366::-;17751:3;17772:67;17836:2;17831:3;17772:67;:::i;:::-;17765:74;;17848:93;17937:3;17848:93;:::i;:::-;17966:2;17961:3;17957:12;17950:19;;17609:366;;;:::o;17981:419::-;18147:4;18185:2;18174:9;18170:18;18162:26;;18234:9;18228:4;18224:20;18220:1;18209:9;18205:17;18198:47;18262:131;18388:4;18262:131;:::i;:::-;18254:139;;17981:419;;;:::o;18406:179::-;18546:31;18542:1;18534:6;18530:14;18523:55;18406:179;:::o;18591:364::-;18732:3;18753:66;18816:2;18811:3;18753:66;:::i;:::-;18746:73;;18828:93;18917:3;18828:93;:::i;:::-;18946:2;18941:3;18937:12;18930:19;;18591:364;;;:::o;18961:748::-;19210:4;19248:3;19237:9;19233:19;19225:27;;19262:71;19330:1;19319:9;19315:17;19306:6;19262:71;:::i;:::-;19343:72;19411:2;19400:9;19396:18;19387:6;19343:72;:::i;:::-;19425;19493:2;19482:9;19478:18;19469:6;19425:72;:::i;:::-;19544:9;19538:4;19534:20;19529:2;19518:9;19514:18;19507:48;19572:130;19697:4;19572:130;:::i;:::-;19564:138;;18961:748;;;;;;:::o;19715:225::-;19855:34;19851:1;19843:6;19839:14;19832:58;19924:8;19919:2;19911:6;19907:15;19900:33;19715:225;:::o;19946:366::-;20088:3;20109:67;20173:2;20168:3;20109:67;:::i;:::-;20102:74;;20185:93;20274:3;20185:93;:::i;:::-;20303:2;20298:3;20294:12;20287:19;;19946:366;;;:::o;20318:419::-;20484:4;20522:2;20511:9;20507:18;20499:26;;20571:9;20565:4;20561:20;20557:1;20546:9;20542:17;20535:47;20599:131;20725:4;20599:131;:::i;:::-;20591:139;;20318:419;;;:::o;20743:170::-;20883:22;20879:1;20871:6;20867:14;20860:46;20743:170;:::o;20919:366::-;21061:3;21082:67;21146:2;21141:3;21082:67;:::i;:::-;21075:74;;21158:93;21247:3;21158:93;:::i;:::-;21276:2;21271:3;21267:12;21260:19;;20919:366;;;:::o;21291:419::-;21457:4;21495:2;21484:9;21480:18;21472:26;;21544:9;21538:4;21534:20;21530:1;21519:9;21515:17;21508:47;21572:131;21698:4;21572:131;:::i;:::-;21564:139;;21291:419;;;:::o;21716:191::-;21756:4;21776:20;21794:1;21776:20;:::i;:::-;21771:25;;21810:20;21828:1;21810:20;:::i;:::-;21805:25;;21849:1;21846;21843:8;21840:34;;;21854:18;;:::i;:::-;21840:34;21899:1;21896;21892:9;21884:17;;21716:191;;;;:::o;21913:180::-;21961:77;21958:1;21951:88;22058:4;22055:1;22048:15;22082:4;22079:1;22072:15

ipfs://012d7c3cb78d7398eab2b454bfab6b767bdc65adf5b19e5729100028aa353d2a