Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function _msgSender()
•    - function _msgData()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
• functionStaticCall(
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
• functionDelegateCall(
•    - function functionDelegateCall(
•    - function verifyCallResult(
• interface IERC721Receiver
•    - function onERC721Received(
• 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(
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•  contract ERC721 is Context, ERC165 ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _safeTransfer(
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(
•    - function _approve(address to, uint256 ...
•    - function _setApprovalForAll(
•    - function _checkOnERC721Received(
•    - function _beforeTokenTransfer(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• 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()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• 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 liquidForgeStaking
•    - function _liquidKeyForgeBlocks(addres ...
•    - function forgedKeyOwnerAddress(addres ...
•  contract CryptoChicksForge is Owna ... *
•    - function pause()
•    - function unpause()
•    - function setRates(
•    - function setAddresses(
•    - function rewardClaimable(uint256 toke ...
•    - function CalculateEarnedMETL(address ...
•    - function ClaimEarnedMETL(uint256[] ca ...
•    - function ForgeNFT(uint256[] calldata ...
•    - function WithdrawNFT(uint256[] callda ...
•    - function WithdrawEarnedMETL()
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

    * Liquid Forge Contract for ApeLiquid.io | August 2022
    *
    * For the Forge of Crypto.Chicks with METL rewards earned over time
*/

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 Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override
        returns (bool)
    {
        return interfaceId == type(IERC165).interfaceId;
    }
}

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

pragma solidity ^0.8.0;

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC165, IERC165)
        returns (bool)
    {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            owner != address(0),
            "ERC721: balance query for the zero address"
        );
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        address owner = _owners[tokenId];
        require(
            owner != address(0),
            "ERC721: owner query for nonexistent token"
        );
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        require(
            _exists(tokenId),
            "ERC721: approved query for nonexistent token"
        );

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        override
        returns (bool)
    {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId)
        internal
        view
        virtual
        returns (bool)
    {
        require(
            _exists(tokenId),
            "ERC721: operator query for nonexistent token"
        );
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner ||
            getApproved(tokenId) == spender ||
            isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(
            ERC721.ownerOf(tokenId) == from,
            "ERC721: transfer of token that is not own"
        );
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try
                IERC721Receiver(to).onERC721Received(
                    _msgSender(),
                    from,
                    tokenId,
                    _data
                )
            returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert(
                        "ERC721: transfer to non ERC721Receiver implementer"
                    );
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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;

interface liquidForgeStaking {
    // get the forgeblocks for the forged liquid key
    function _liquidKeyForgeBlocks(address) external view returns (uint256);

    // Retrieve the Token IDs of the Forged Liquid Key address
    function forgedKeyOwnerAddress(address account)
        external
        view
        returns (uint256[] memory);
}

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

    mapping(uint256 => uint256) public nftForgeBlocks;
    mapping(address => EnumerableSet.UintSet) private nftForges; // private
    mapping(uint256 => address) public _nftTokenForges;

    // NFT Collection, Forge, and METL token addresses
    address public nftAddress = 0x1981CC36b59cffdd24B01CC5d698daa75e367e04; // Crypto Chicks
    address public forgeAddress = 0x346e31ddE260c6BEEA84186ad99878C1D8C7D90F; // Liquid Key Forge
    address public metlTokenAddress = 0xFcbE615dEf610E806BB64427574A2c5c1fB55510; // METL Token

    // how many blocks before a claim (30 days) and when do we expire?
    uint256 public expiration = 1000000000;
    uint256 public minBlockToClaim = 180204;

    // rate governs how often you receive your token
    uint256 public nftRate = 2247452886728; // nft earning rate

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

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

    // Set this to a expiration block to disable the ability to continue accruing tokens past that block number.
    // which is calculated as current block plus the parameters
    //
    // Set a multiplier for how many tokens to earn each time a block passes
    // and the min number of blocks needed to pass to claim rewards
    function setRates(
        uint256 _nftRate,
        uint256 _minBlockToClaim,
        uint256 _expiration
    ) public onlyOwner {
        nftRate = _nftRate;
        minBlockToClaim = _minBlockToClaim;
        expiration = block.number + _expiration;
    }

    // Set addresses
    function setAddresses(
        address _nftAddress, 
        address _forgeAddress, 
        address _metlTokenAddress
    ) public onlyOwner {
        nftAddress = _nftAddress;
        forgeAddress = _forgeAddress;
        metlTokenAddress = _metlTokenAddress;
    }

    // Reward Claimable information
    function rewardClaimable(uint256 tokenId) public view returns (bool) {
        uint256 blockCur = Math.min(block.number, expiration);
        if (nftForgeBlocks[tokenId] > 0) {
            return (blockCur - nftForgeBlocks[tokenId] > minBlockToClaim);
        }
        return false;
    }

    // reward amount by address/tokenIds[]
    function CalculateEarnedMETL(address account, uint256 tokenId)
        public
        view
        returns (uint256)
    {
        require(
            Math.min(block.number, expiration) > nftForgeBlocks[tokenId],
            "Invalid blocks"
        );
        return
            nftRate *
            (nftForges[msg.sender].contains(tokenId) ? 1 : 0) *
            (Math.min(block.number, expiration) -
                Math.max(
                    liquidForgeStaking(forgeAddress)._liquidKeyForgeBlocks(
                        account
                    ),
                    nftForgeBlocks[tokenId]
                ));
    }

    // claim rewards (earned METL)
    function ClaimEarnedMETL(uint256[] calldata tokenIds) public whenNotPaused {
        uint256 reward;
        uint256 blockCur = Math.min(block.number, expiration);

        require(
            liquidForgeStaking(forgeAddress)
                .forgedKeyOwnerAddress(msg.sender)
                .length > 0,
            "No Liquid Key Forged"
        );

        for (uint256 i; i < tokenIds.length; i++) {
            require(
                nftForges[msg.sender].contains(tokenIds[i]),
                "Staking: token not forged"
            );
            require(blockCur - nftForgeBlocks[tokenIds[i]] > minBlockToClaim);
        }

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

        if (reward > 0) {
            IERC20(metlTokenAddress).transfer(msg.sender, reward);
        }
    }

    // Forge NFT
    function ForgeNFT(uint256[] calldata tokenIds)
        external
        whenNotPaused
    {
        uint256 blockCur = block.number;
        require(msg.sender != nftAddress, "Invalid NFT contract address");

        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(nftAddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIds[i],
                "Transfer from Member to Forge"
            );
            nftForges[msg.sender].add(tokenIds[i]);
            nftForgeBlocks[tokenIds[i]] = blockCur;
            // write the entry for the ETH address
            _nftTokenForges[tokenIds[i]] = msg.sender;
        }
    }

    // withdrawal function
    function WithdrawNFT(uint256[] calldata tokenIds)
        external
        whenNotPaused
        nonReentrant
    {
        for (uint256 i; i < tokenIds.length; i++) {
            require(
                nftForges[msg.sender].contains(tokenIds[i]),
                "Staking: token not forged"
            );

            nftForges[msg.sender].remove(tokenIds[i]);
            _nftTokenForges[tokenIds[i]] = 0x0000000000000000000000000000000000000000;

            IERC721(nftAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                "Not withdrawn: Transfer failed"
            );
        }
    }

    // withdraw earned METL
    function WithdrawEarnedMETL() external onlyOwner {
        uint256 tokenSupply = IERC20(metlTokenAddress).balanceOf(address(this));
        IERC20(metlTokenAddress).transfer(msg.sender, tokenSupply);
    }
    
    // ERC721 token receiver for transferred NFT to Forge
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure  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":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"CalculateEarnedMETL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"ClaimEarnedMETL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"ForgeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"WithdrawEarnedMETL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"WithdrawNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_nftTokenForges","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"forgeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metlTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBlockToClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nftForgeBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftRate","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"rewardClaimable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"address","name":"_forgeAddress","type":"address"},{"internalType":"address","name":"_metlTokenAddress","type":"address"}],"name":"setAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nftRate","type":"uint256"},{"internalType":"uint256","name":"_minBlockToClaim","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setRates","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"}]

6080604052731981cc36b59cffdd24b01cc5d698daa75e367e04600660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555073346e31dde260c6beea84186ad99878c1d8c7d90f600760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555073fcbe615def610e806bb64427574a2c5c1fb55510600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550633b9aca006009556202bfec600a5565020b46a186c8600b553480156200012957600080fd5b506200014a6200013e6200017260201b60201c565b6200017a60201b60201c565b600180819055506000600260006101000a81548160ff0219169083151502179055506200023e565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6128ac806200024e6000396000f3fe608060405234801561001057600080fd5b506004361061014d5760003560e01c80635e674cf0116100c357806394a7eb491161007c57806394a7eb49146103425780639e822c2314610372578063bb4705281461037c578063be9a2ee91461039a578063d004f38b146103ca578063f2fde38b146103e65761014d565b80635e674cf0146102ba578063715018a6146102d65780638456cb59146102e057806387a95808146102ea5780638bf1efd8146103065780638da5cb5b146103245761014d565b8063363bf96411610115578063363bf9641461020a5780633f4ba83a146102265780634665096d14610230578063593517d11461024e5780635bf8633a1461027e5780635c975abb1461029c5761014d565b806307ce352414610152578063150b7a021461018257806326ab82c9146101b25780632c7db196146101d05780633552c035146101ee575b600080fd5b61016c60048036038101906101679190611b12565b610402565b6040516101799190611b5a565b60405180910390f35b61019c60048036038101906101979190611c38565b610465565b6040516101a99190611cfb565b60405180910390f35b6101ba61047a565b6040516101c79190611d25565b60405180910390f35b6101d8610480565b6040516101e59190611d4f565b60405180910390f35b61020860048036038101906102039190611dc0565b6104a6565b005b610224600480360381019061021f9190611e0d565b610793565b005b61022e6108d7565b005b61023861095d565b6040516102459190611d25565b60405180910390f35b61026860048036038101906102639190611b12565b610963565b6040516102759190611d25565b60405180910390f35b61028661097b565b6040516102939190611d4f565b60405180910390f35b6102a46109a1565b6040516102b19190611b5a565b60405180910390f35b6102d460048036038101906102cf9190611dc0565b6109b8565b005b6102de610c6e565b005b6102e8610cf6565b005b61030460048036038101906102ff9190611dc0565b610d7c565b005b61030e6110fd565b60405161031b9190611d4f565b60405180910390f35b61032c611123565b6040516103399190611d4f565b60405180910390f35b61035c60048036038101906103579190611b12565b61114c565b6040516103699190611d4f565b60405180910390f35b61037a61117f565b005b61038461133f565b6040516103919190611d25565b60405180910390f35b6103b460048036038101906103af9190611e60565b611345565b6040516103c19190611d25565b60405180910390f35b6103e460048036038101906103df9190611ea0565b6114f6565b005b61040060048036038101906103fb9190611ef3565b611597565b005b6000806104114360095461168f565b905060006003600085815260200190815260200160002054111561045a57600a546003600085815260200190815260200160002054826104519190611f4f565b11915050610460565b60009150505b919050565b600063150b7a0260e01b905095945050505050565b600b5481565b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6104ae6109a1565b156104ee576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104e590611fe0565b60405180910390fd5b60026001541415610534576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161052b9061204c565b60405180910390fd5b600260018190555060005b82829050811015610787576105b48383838181106105605761055f61206c565b5b90506020020135600460003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206116a890919063ffffffff16565b6105f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105ea906120e7565b60405180910390fd5b61065d8383838181106106095761060861206c565b5b90506020020135600460003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206116c290919063ffffffff16565b506000600560008585858181106106775761067661206c565b5b90506020020135815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde303386868681811061071d5761071c61206c565b5b905060200201356040518463ffffffff1660e01b815260040161074293929190612164565b600060405180830381600087803b15801561075c57600080fd5b505af1158015610770573d6000803e3d6000fd5b50505050808061077f906121ae565b91505061053f565b50600180819055505050565b61079b6116dc565b73ffffffffffffffffffffffffffffffffffffffff166107b9611123565b73ffffffffffffffffffffffffffffffffffffffff161461080f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161080690612243565b60405180910390fd5b82600660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555081600760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505050565b6108df6116dc565b73ffffffffffffffffffffffffffffffffffffffff166108fd611123565b73ffffffffffffffffffffffffffffffffffffffff1614610953576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161094a90612243565b60405180910390fd5b61095b6116e4565b565b60095481565b60036020528060005260406000206000915090505481565b600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000600260009054906101000a900460ff16905090565b6109c06109a1565b15610a00576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109f790611fe0565b60405180910390fd5b6000439050600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610a96576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a8d906122af565b60405180910390fd5b60005b83839050811015610c6857600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde3330878786818110610af757610af661206c565b5b905060200201356040518463ffffffff1660e01b8152600401610b1c9392919061231b565b600060405180830381600087803b158015610b3657600080fd5b505af1158015610b4a573d6000803e3d6000fd5b50505050610bb8848483818110610b6457610b6361206c565b5b90506020020135600460003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061178690919063ffffffff16565b508160036000868685818110610bd157610bd061206c565b5b905060200201358152602001908152602001600020819055503360056000868685818110610c0257610c0161206c565b5b90506020020135815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508080610c60906121ae565b915050610a99565b50505050565b610c766116dc565b73ffffffffffffffffffffffffffffffffffffffff16610c94611123565b73ffffffffffffffffffffffffffffffffffffffff1614610cea576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ce190612243565b60405180910390fd5b610cf460006117a0565b565b610cfe6116dc565b73ffffffffffffffffffffffffffffffffffffffff16610d1c611123565b73ffffffffffffffffffffffffffffffffffffffff1614610d72576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d6990612243565b60405180910390fd5b610d7a611864565b565b610d846109a1565b15610dc4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dbb90611fe0565b60405180910390fd5b600080610dd34360095461168f565b90506000600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b7735a29336040518263ffffffff1660e01b8152600401610e329190611d4f565b600060405180830381865afa158015610e4f573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f82011682018060405250810190610e7891906124c9565b5111610eb9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eb09061255e565b60405180910390fd5b60005b84849050811015610fc857610f31858583818110610edd57610edc61206c565b5b90506020020135600460003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206116a890919063ffffffff16565b610f70576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f67906120e7565b60405180910390fd5b600a5460036000878785818110610f8a57610f8961206c565b5b9050602002013581526020019081526020016000205483610fab9190611f4f565b11610fb557600080fd5b8080610fc0906121ae565b915050610ebc565b5060005b8484905081101561104b57610ffa33868684818110610fee57610fed61206c565b5b90506020020135611345565b83611005919061257e565b9250816003600087878581811061101f5761101e61206c565b5b905060200201358152602001908152602001600020819055508080611043906121ae565b915050610fcc565b5060008211156110f757600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33846040518363ffffffff1660e01b81526004016110b29291906125d4565b6020604051808303816000875af11580156110d1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110f59190612629565b505b50505050565b600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60056020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6111876116dc565b73ffffffffffffffffffffffffffffffffffffffff166111a5611123565b73ffffffffffffffffffffffffffffffffffffffff16146111fb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111f290612243565b60405180910390fd5b6000600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016112589190611d4f565b602060405180830381865afa158015611275573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112999190612656565b9050600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33836040518363ffffffff1660e01b81526004016112f89291906125d4565b6020604051808303816000875af1158015611317573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061133b9190612629565b5050565b600a5481565b600060036000838152602001908152602001600020546113674360095461168f565b116113a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161139e906126cf565b60405180910390fd5b61145f600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166320eb6546856040518263ffffffff1660e01b81526004016114059190611d4f565b602060405180830381865afa158015611422573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906114469190612656565b6003600085815260200190815260200160002054611907565b61146b4360095461168f565b6114759190611f4f565b6114c683600460003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206116a890919063ffffffff16565b6114d15760006114d4565b60015b60ff16600b546114e491906126ef565b6114ee91906126ef565b905092915050565b6114fe6116dc565b73ffffffffffffffffffffffffffffffffffffffff1661151c611123565b73ffffffffffffffffffffffffffffffffffffffff1614611572576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161156990612243565b60405180910390fd5b82600b8190555081600a81905550804361158c919061257e565b600981905550505050565b61159f6116dc565b73ffffffffffffffffffffffffffffffffffffffff166115bd611123565b73ffffffffffffffffffffffffffffffffffffffff1614611613576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161160a90612243565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611683576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161167a906127bb565b60405180910390fd5b61168c816117a0565b50565b600081831061169e57816116a0565b825b905092915050565b60006116ba836000018360001b611921565b905092915050565b60006116d4836000018360001b611944565b905092915050565b600033905090565b6116ec6109a1565b61172b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161172290612827565b60405180910390fd5b6000600260006101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa61176f6116dc565b60405161177c9190611d4f565b60405180910390a1565b6000611798836000018360001b611a58565b905092915050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61186c6109a1565b156118ac576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118a390611fe0565b60405180910390fd5b6001600260006101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586118f06116dc565b6040516118fd9190611d4f565b60405180910390a1565b6000818310156119175781611919565b825b905092915050565b600080836001016000848152602001908152602001600020541415905092915050565b60008083600101600084815260200190815260200160002054905060008114611a4c5760006001826119769190611f4f565b905060006001866000018054905061198e9190611f4f565b90508181146119fd5760008660000182815481106119af576119ae61206c565b5b90600052602060002001549050808760000184815481106119d3576119d261206c565b5b90600052602060002001819055508387600101600083815260200190815260200160002081905550505b85600001805480611a1157611a10612847565b5b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050611a52565b60009150505b92915050565b6000611a648383611921565b611abd578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050611ac2565b600090505b92915050565b6000604051905090565b600080fd5b600080fd5b6000819050919050565b611aef81611adc565b8114611afa57600080fd5b50565b600081359050611b0c81611ae6565b92915050565b600060208284031215611b2857611b27611ad2565b5b6000611b3684828501611afd565b91505092915050565b60008115159050919050565b611b5481611b3f565b82525050565b6000602082019050611b6f6000830184611b4b565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000611ba082611b75565b9050919050565b611bb081611b95565b8114611bbb57600080fd5b50565b600081359050611bcd81611ba7565b92915050565b600080fd5b600080fd5b600080fd5b60008083601f840112611bf857611bf7611bd3565b5b8235905067ffffffffffffffff811115611c1557611c14611bd8565b5b602083019150836001820283011115611c3157611c30611bdd565b5b9250929050565b600080600080600060808688031215611c5457611c53611ad2565b5b6000611c6288828901611bbe565b9550506020611c7388828901611bbe565b9450506040611c8488828901611afd565b935050606086013567ffffffffffffffff811115611ca557611ca4611ad7565b5b611cb188828901611be2565b92509250509295509295909350565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b611cf581611cc0565b82525050565b6000602082019050611d106000830184611cec565b92915050565b611d1f81611adc565b82525050565b6000602082019050611d3a6000830184611d16565b92915050565b611d4981611b95565b82525050565b6000602082019050611d646000830184611d40565b92915050565b60008083601f840112611d8057611d7f611bd3565b5b8235905067ffffffffffffffff811115611d9d57611d9c611bd8565b5b602083019150836020820283011115611db957611db8611bdd565b5b9250929050565b60008060208385031215611dd757611dd6611ad2565b5b600083013567ffffffffffffffff811115611df557611df4611ad7565b5b611e0185828601611d6a565b92509250509250929050565b600080600060608486031215611e2657611e25611ad2565b5b6000611e3486828701611bbe565b9350506020611e4586828701611bbe565b9250506040611e5686828701611bbe565b9150509250925092565b60008060408385031215611e7757611e76611ad2565b5b6000611e8585828601611bbe565b9250506020611e9685828601611afd565b9150509250929050565b600080600060608486031215611eb957611eb8611ad2565b5b6000611ec786828701611afd565b9350506020611ed886828701611afd565b9250506040611ee986828701611afd565b9150509250925092565b600060208284031215611f0957611f08611ad2565b5b6000611f1784828501611bbe565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000611f5a82611adc565b9150611f6583611adc565b925082821015611f7857611f77611f20565b5b828203905092915050565b600082825260208201905092915050565b7f5061757361626c653a2070617573656400000000000000000000000000000000600082015250565b6000611fca601083611f83565b9150611fd582611f94565b602082019050919050565b60006020820190508181036000830152611ff981611fbd565b9050919050565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b6000612036601f83611f83565b915061204182612000565b602082019050919050565b6000602082019050818103600083015261206581612029565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f5374616b696e673a20746f6b656e206e6f7420666f7267656400000000000000600082015250565b60006120d1601983611f83565b91506120dc8261209b565b602082019050919050565b60006020820190508181036000830152612100816120c4565b9050919050565b600082825260208201905092915050565b7f4e6f742077697468647261776e3a205472616e73666572206661696c65640000600082015250565b600061214e601e83612107565b915061215982612118565b602082019050919050565b60006080820190506121796000830186611d40565b6121866020830185611d40565b6121936040830184611d16565b81810360608301526121a481612141565b9050949350505050565b60006121b982611adc565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156121ec576121eb611f20565b5b600182019050919050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b600061222d602083611f83565b9150612238826121f7565b602082019050919050565b6000602082019050818103600083015261225c81612220565b9050919050565b7f496e76616c6964204e465420636f6e7472616374206164647265737300000000600082015250565b6000612299601c83611f83565b91506122a482612263565b602082019050919050565b600060208201905081810360008301526122c88161228c565b9050919050565b7f5472616e736665722066726f6d204d656d62657220746f20466f726765000000600082015250565b6000612305601d83612107565b9150612310826122cf565b602082019050919050565b60006080820190506123306000830186611d40565b61233d6020830185611d40565b61234a6040830184611d16565b818103606083015261235b816122f8565b9050949350505050565b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6123ae82612365565b810181811067ffffffffffffffff821117156123cd576123cc612376565b5b80604052505050565b60006123e0611ac8565b90506123ec82826123a5565b919050565b600067ffffffffffffffff82111561240c5761240b612376565b5b602082029050602081019050919050565b60008151905061242c81611ae6565b92915050565b6000612445612440846123f1565b6123d6565b9050808382526020820190506020840283018581111561246857612467611bdd565b5b835b81811015612491578061247d888261241d565b84526020840193505060208101905061246a565b5050509392505050565b600082601f8301126124b0576124af611bd3565b5b81516124c0848260208601612432565b91505092915050565b6000602082840312156124df576124de611ad2565b5b600082015167ffffffffffffffff8111156124fd576124fc611ad7565b5b6125098482850161249b565b91505092915050565b7f4e6f204c6971756964204b657920466f72676564000000000000000000000000600082015250565b6000612548601483611f83565b915061255382612512565b602082019050919050565b600060208201905081810360008301526125778161253b565b9050919050565b600061258982611adc565b915061259483611adc565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156125c9576125c8611f20565b5b828201905092915050565b60006040820190506125e96000830185611d40565b6125f66020830184611d16565b9392505050565b61260681611b3f565b811461261157600080fd5b50565b600081519050612623816125fd565b92915050565b60006020828403121561263f5761263e611ad2565b5b600061264d84828501612614565b91505092915050565b60006020828403121561266c5761266b611ad2565b5b600061267a8482850161241d565b91505092915050565b7f496e76616c696420626c6f636b73000000000000000000000000000000000000600082015250565b60006126b9600e83611f83565b91506126c482612683565b602082019050919050565b600060208201905081810360008301526126e8816126ac565b9050919050565b60006126fa82611adc565b915061270583611adc565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561273e5761273d611f20565b5b828202905092915050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b60006127a5602683611f83565b91506127b082612749565b604082019050919050565b600060208201905081810360008301526127d481612798565b9050919050565b7f5061757361626c653a206e6f7420706175736564000000000000000000000000600082015250565b6000612811601483611f83565b915061281c826127db565b602082019050919050565b6000602082019050818103600083015261284081612804565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fdfea26469706673582212204c04b6b7cc961901a128027d8a438d9cb8b13fd4f241785d320e674ebd5e977664736f6c634300080a0033

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

64631:6029:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66675:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70446:211;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65516:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65198:76;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69439:691;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66355:275;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65652:65;;;:::i;:::-;;65369:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64757:49;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65005:70;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43892:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68697:706;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46700:103;;;:::i;:::-;;65583:61;;;:::i;:::-;;67716:955;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65099:72;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46049:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64890:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70167:208;;;:::i;:::-;;65414:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67022:650;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66059:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46958:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66675:295;66738:4;66755:16;66774:34;66783:12;66797:10;;66774:8;:34::i;:::-;66755:53;;66849:1;66823:14;:23;66838:7;66823:23;;;;;;;;;;;;:27;66819:121;;;66912:15;;66886:14;:23;66901:7;66886:23;;;;;;;;;;;;66875:8;:34;;;;:::i;:::-;:52;66867:61;;;;;66819:121;66957:5;66950:12;;;66675:295;;;;:::o;70446:211::-;70582:6;70608:41;;;70601:48;;70446:211;;;;;;;:::o;65516:38::-;;;;:::o;65198:76::-;;;;;;;;;;;;;:::o;69439:691::-;44218:8;:6;:8::i;:::-;44217:9;44209:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;50398:1:::1;50994:7;;:19;;50986:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;50398:1;51127:7;:18;;;;69573:9:::2;69568:555;69588:8;;:15;;69584:1;:19;69568:555;;;69651:43;69682:8;;69691:1;69682:11;;;;;;;:::i;:::-;;;;;;;;69651:9;:21;69661:10;69651:21;;;;;;;;;;;;;;;:30;;:43;;;;:::i;:::-;69625:130;;;;;;;;;;;;:::i;:::-;;;;;;;;;69772:41;69801:8;;69810:1;69801:11;;;;;;;:::i;:::-;;;;;;;;69772:9;:21;69782:10;69772:21;;;;;;;;;;;;;;;:28;;:41;;;;:::i;:::-;;69859:42;69828:15;:28;69844:8;;69853:1;69844:11;;;;;;;:::i;:::-;;;;;;;;69828:28;;;;;;;;;;;;:73;;;;;;;;;;;;;;;;;;69926:10;;;;;;;;;;;69918:36;;;69981:4;70005:10;70034:8;;70043:1;70034:11;;;;;;;:::i;:::-;;;;;;;;69918:193;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;69605:3;;;;;:::i;:::-;;;;69568:555;;;;50354:1:::1;51306:7:::0;:22:::1;;;;69439:691:::0;;:::o;66355:275::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66525:11:::1;66512:10;;:24;;;;;;;;;;;;;;;;;;66562:13;66547:12;;:28;;;;;;;;;;;;;;;;;;66605:17;66586:16;;:36;;;;;;;;;;;;;;;;;;66355:275:::0;;;:::o;65652:65::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;65699:10:::1;:8;:10::i;:::-;65652:65::o:0;65369:38::-;;;;:::o;64757:49::-;;;;;;;;;;;;;;;;;:::o;65005:70::-;;;;;;;;;;;;;:::o;43892:86::-;43939:4;43963:7;;;;;;;;;;;43956:14;;43892:86;:::o;68697:706::-;44218:8;:6;:8::i;:::-;44217:9;44209:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;68801:16:::1;68820:12;68801:31;;68865:10;;;;;;;;;;;68851:24;;:10;:24;;;;68843:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;68926:9;68921:475;68941:8;;:15;;68937:1;:19;68921:475;;;68986:10;;;;;;;;;;;68978:36;;;69033:10;69070:4;69094:8;;69103:1;69094:11;;;;;;;:::i;:::-;;;;;;;;68978:192;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;69185:38;69211:8;;69220:1;69211:11;;;;;;;:::i;:::-;;;;;;;;69185:9;:21;69195:10;69185:21;;;;;;;;;;;;;;;:25;;:38;;;;:::i;:::-;;69268:8;69238:14;:27;69253:8;;69262:1;69253:11;;;;;;;:::i;:::-;;;;;;;;69238:27;;;;;;;;;;;:38;;;;69374:10;69343:15;:28;69359:8;;69368:1;69359:11;;;;;;;:::i;:::-;;;;;;;;69343:28;;;;;;;;;;;;:41;;;;;;;;;;;;;;;;;;68958:3;;;;;:::i;:::-;;;;68921:475;;;;68790:613;68697:706:::0;;:::o;46700:103::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;46765:30:::1;46792:1;46765:18;:30::i;:::-;46700:103::o:0;65583:61::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;65628:8:::1;:6;:8::i;:::-;65583:61::o:0;67716:955::-;44218:8;:6;:8::i;:::-;44217:9;44209:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;67802:14:::1;67827:16:::0;67846:34:::1;67855:12;67869:10;;67846:8;:34::i;:::-;67827:53;;68027:1;67934:12;;;;;;;;;;;67915:72;;;67988:10;67915:84;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:109;:113;67893:183;;;;;;;;;;;;:::i;:::-;;;;;;;;;68094:9;68089:279;68109:8;;:15;;68105:1;:19;68089:279;;;68172:43;68203:8;;68212:1;68203:11;;;;;;;:::i;:::-;;;;;;;;68172:9;:21;68182:10;68172:21;;;;;;;;;;;;;;;:30;;:43;;;;:::i;:::-;68146:130;;;;;;;;;;;;:::i;:::-;;;;;;;;;68340:15;;68310:14;:27;68325:8;;68334:1;68325:11;;;;;;;:::i;:::-;;;;;;;;68310:27;;;;;;;;;;;;68299:8;:38;;;;:::i;:::-;:56;68291:65;;;::::0;::::1;;68126:3;;;;;:::i;:::-;;;;68089:279;;;;68385:9;68380:176;68400:8;;:15;;68396:1;:19;68380:176;;;68447:44;68467:10;68479:8;;68488:1;68479:11;;;;;;;:::i;:::-;;;;;;;;68447:19;:44::i;:::-;68437:54;;;;;:::i;:::-;;;68536:8;68506:14;:27;68521:8;;68530:1;68521:11;;;;;;;:::i;:::-;;;;;;;;68506:27;;;;;;;;;;;:38;;;;68417:3;;;;;:::i;:::-;;;;68380:176;;;;68581:1;68572:6;:10;68568:96;;;68606:16;;;;;;;;;;;68599:33;;;68633:10;68645:6;68599:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;68568:96;67791:880;;67716:955:::0;;:::o;65099:72::-;;;;;;;;;;;;;:::o;46049:87::-;46095:7;46122:6;;;;;;;;;;;46115:13;;46049:87;:::o;64890:50::-;;;;;;;;;;;;;;;;;;;;;;:::o;70167:208::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70227:19:::1;70256:16;;;;;;;;;;;70249:34;;;70292:4;70249:49;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70227:71;;70316:16;;;;;;;;;;;70309:33;;;70343:10;70355:11;70309:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;70216:159;70167:208::o:0;65414:39::-;;;;:::o;67022:650::-;67133:7;67217:14;:23;67232:7;67217:23;;;;;;;;;;;;67180:34;67189:12;67203:10;;67180:8;:34::i;:::-;:60;67158:124;;;;;;;;;;;;:::i;:::-;;;;;;;;;67456:207;67506:12;;;;;;;;;;;67487:54;;;67568:7;67487:111;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67621:14;:23;67636:7;67621:23;;;;;;;;;;;;67456:8;:207::i;:::-;67402:34;67411:12;67425:10;;67402:8;:34::i;:::-;:261;;;;:::i;:::-;67337:39;67368:7;67337:9;:21;67347:10;67337:21;;;;;;;;;;;;;;;:30;;:39;;;;:::i;:::-;:47;;67383:1;67337:47;;;67379:1;67337:47;67313:72;;:7;;:72;;;;:::i;:::-;:351;;;;:::i;:::-;67293:371;;67022:650;;;;:::o;66059:266::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66214:8:::1;66204:7;:18;;;;66251:16;66233:15;:34;;;;66306:11;66291:12;:26;;;;:::i;:::-;66278:10;:39;;;;66059:266:::0;;;:::o;46958:238::-;46280:12;:10;:12::i;:::-;46269:23;;:7;:5;:7::i;:::-;:23;;;46261:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;47081:1:::1;47061:22;;:8;:22;;;;47039:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;47160:28;47179:8;47160:18;:28::i;:::-;46958:238:::0;:::o;47928:106::-;47986:7;48017:1;48013;:5;:13;;48025:1;48013:13;;;48021:1;48013:13;48006:20;;47928:106;;;;:::o;62494:178::-;62598:4;62627:37;62637:3;:10;;62657:5;62649:14;;62627:9;:37::i;:::-;62620:44;;62494:178;;;;:::o;62248:160::-;62336:4;62365:35;62373:3;:10;;62393:5;62385:14;;62365:7;:35::i;:::-;62358:42;;62248:160;;;;:::o;4962:98::-;5015:7;5042:10;5035:17;;4962:98;:::o;44951:120::-;44495:8;:6;:8::i;:::-;44487:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;45020:5:::1;45010:7;;:15;;;;;;;;;;;;;;;;;;45041:22;45050:12;:10;:12::i;:::-;45041:22;;;;;;:::i;:::-;;;;;;;;44951:120::o:0;61941:131::-;62008:4;62032:32;62037:3;:10;;62057:5;62049:14;;62032:4;:32::i;:::-;62025:39;;61941:131;;;;:::o;47356:191::-;47430:16;47449:6;;;;;;;;;;;47430:25;;47475:8;47466:6;;:17;;;;;;;;;;;;;;;;;;47530:8;47499:40;;47520:8;47499:40;;;;;;;;;;;;47419:128;47356:191;:::o;44692:118::-;44218:8;:6;:8::i;:::-;44217:9;44209:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;44762:4:::1;44752:7;;:14;;;;;;;;;;;;;;;;;;44782:20;44789:12;:10;:12::i;:::-;44782:20;;;;;;:::i;:::-;;;;;;;;44692:118::o:0;47745:107::-;47803:7;47835:1;47830;:6;;:14;;47843:1;47830:14;;;47839:1;47830:14;47823:21;;47745:107;;;;:::o;55086:161::-;55186:4;55238:1;55215:3;:12;;:19;55228:5;55215:19;;;;;;;;;;;;:24;;55208:31;;55086:161;;;;:::o;53580:1420::-;53646:4;53764:18;53785:3;:12;;:19;53798:5;53785:19;;;;;;;;;;;;53764:40;;53835:1;53821:10;:15;53817:1176;;54196:21;54233:1;54220:10;:14;;;;:::i;:::-;54196:38;;54249:17;54290:1;54269:3;:11;;:18;;;;:22;;;;:::i;:::-;54249:42;;54325:13;54312:9;:26;54308:405;;54359:17;54379:3;:11;;54391:9;54379:22;;;;;;;;:::i;:::-;;;;;;;;;;54359:42;;54533:9;54504:3;:11;;54516:13;54504:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;54644:10;54618:3;:12;;:23;54631:9;54618:23;;;;;;;;;;;:36;;;;54340:373;54308:405;54794:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54889:3;:12;;:19;54902:5;54889:19;;;;;;;;;;;54882:26;;;54932:4;54925:11;;;;;;;53817:1176;54976:5;54969:12;;;53580:1420;;;;;:::o;52990:414::-;53053:4;53075:21;53085:3;53090:5;53075:9;:21::i;:::-;53070:327;;53113:3;:11;;53130:5;53113:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53296:3;:11;;:18;;;;53274:3;:12;;:19;53287:5;53274:19;;;;;;;;;;;:40;;;;53336:4;53329:11;;;;53070:327;53380:5;53373:12;;52990:414;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:90::-;1059:7;1102:5;1095:13;1088:21;1077:32;;1025:90;;;:::o;1121:109::-;1202:21;1217:5;1202:21;:::i;:::-;1197:3;1190:34;1121:109;;:::o;1236:210::-;1323:4;1361:2;1350:9;1346:18;1338:26;;1374:65;1436:1;1425:9;1421:17;1412:6;1374:65;:::i;:::-;1236:210;;;;:::o;1452:126::-;1489:7;1529:42;1522:5;1518:54;1507:65;;1452:126;;;:::o;1584:96::-;1621:7;1650:24;1668:5;1650:24;:::i;:::-;1639:35;;1584:96;;;:::o;1686:122::-;1759:24;1777:5;1759:24;:::i;:::-;1752:5;1749:35;1739:63;;1798:1;1795;1788:12;1739:63;1686:122;:::o;1814:139::-;1860:5;1898:6;1885:20;1876:29;;1914:33;1941:5;1914:33;:::i;:::-;1814:139;;;;:::o;1959:117::-;2068:1;2065;2058:12;2082:117;2191:1;2188;2181:12;2205:117;2314:1;2311;2304:12;2341:552;2398:8;2408:6;2458:3;2451:4;2443:6;2439:17;2435:27;2425:122;;2466:79;;:::i;:::-;2425:122;2579:6;2566:20;2556:30;;2609:18;2601:6;2598:30;2595:117;;;2631:79;;:::i;:::-;2595:117;2745:4;2737:6;2733:17;2721:29;;2799:3;2791:4;2783:6;2779:17;2769:8;2765:32;2762:41;2759:128;;;2806:79;;:::i;:::-;2759:128;2341:552;;;;;:::o;2899:963::-;2996:6;3004;3012;3020;3028;3077:3;3065:9;3056:7;3052:23;3048:33;3045:120;;;3084:79;;:::i;:::-;3045:120;3204:1;3229:53;3274:7;3265:6;3254:9;3250:22;3229:53;:::i;:::-;3219:63;;3175:117;3331:2;3357:53;3402:7;3393:6;3382:9;3378:22;3357:53;:::i;:::-;3347:63;;3302:118;3459:2;3485:53;3530:7;3521:6;3510:9;3506:22;3485:53;:::i;:::-;3475:63;;3430:118;3615:2;3604:9;3600:18;3587:32;3646:18;3638:6;3635:30;3632:117;;;3668:79;;:::i;:::-;3632:117;3781:64;3837:7;3828:6;3817:9;3813:22;3781:64;:::i;:::-;3763:82;;;;3558:297;2899:963;;;;;;;;:::o;3868:149::-;3904:7;3944:66;3937:5;3933:78;3922:89;;3868:149;;;:::o;4023:115::-;4108:23;4125:5;4108:23;:::i;:::-;4103:3;4096:36;4023:115;;:::o;4144:218::-;4235:4;4273:2;4262:9;4258:18;4250:26;;4286:69;4352:1;4341:9;4337:17;4328:6;4286:69;:::i;:::-;4144:218;;;;:::o;4368:118::-;4455:24;4473:5;4455:24;:::i;:::-;4450:3;4443:37;4368:118;;:::o;4492:222::-;4585:4;4623:2;4612:9;4608:18;4600:26;;4636:71;4704:1;4693:9;4689:17;4680:6;4636:71;:::i;:::-;4492:222;;;;:::o;4720:118::-;4807:24;4825:5;4807:24;:::i;:::-;4802:3;4795:37;4720:118;;:::o;4844:222::-;4937:4;4975:2;4964:9;4960:18;4952:26;;4988:71;5056:1;5045:9;5041:17;5032:6;4988:71;:::i;:::-;4844:222;;;;:::o;5089:568::-;5162:8;5172:6;5222:3;5215:4;5207:6;5203:17;5199:27;5189:122;;5230:79;;:::i;:::-;5189:122;5343:6;5330:20;5320:30;;5373:18;5365:6;5362:30;5359:117;;;5395:79;;:::i;:::-;5359:117;5509:4;5501:6;5497:17;5485:29;;5563:3;5555:4;5547:6;5543:17;5533:8;5529:32;5526:41;5523:128;;;5570:79;;:::i;:::-;5523:128;5089:568;;;;;:::o;5663:559::-;5749:6;5757;5806:2;5794:9;5785:7;5781:23;5777:32;5774:119;;;5812:79;;:::i;:::-;5774:119;5960:1;5949:9;5945:17;5932:31;5990:18;5982:6;5979:30;5976:117;;;6012:79;;:::i;:::-;5976:117;6125:80;6197:7;6188:6;6177:9;6173:22;6125:80;:::i;:::-;6107:98;;;;5903:312;5663:559;;;;;:::o;6228:619::-;6305:6;6313;6321;6370:2;6358:9;6349:7;6345:23;6341:32;6338:119;;;6376:79;;:::i;:::-;6338:119;6496:1;6521:53;6566:7;6557:6;6546:9;6542:22;6521:53;:::i;:::-;6511:63;;6467:117;6623:2;6649:53;6694:7;6685:6;6674:9;6670:22;6649:53;:::i;:::-;6639:63;;6594:118;6751:2;6777:53;6822:7;6813:6;6802:9;6798:22;6777:53;:::i;:::-;6767:63;;6722:118;6228:619;;;;;:::o;6853:474::-;6921:6;6929;6978:2;6966:9;6957:7;6953:23;6949:32;6946:119;;;6984:79;;:::i;:::-;6946:119;7104:1;7129:53;7174:7;7165:6;7154:9;7150:22;7129:53;:::i;:::-;7119:63;;7075:117;7231:2;7257:53;7302:7;7293:6;7282:9;7278:22;7257:53;:::i;:::-;7247:63;;7202:118;6853:474;;;;;:::o;7333:619::-;7410:6;7418;7426;7475:2;7463:9;7454:7;7450:23;7446:32;7443:119;;;7481:79;;:::i;:::-;7443:119;7601:1;7626:53;7671:7;7662:6;7651:9;7647:22;7626:53;:::i;:::-;7616:63;;7572:117;7728:2;7754:53;7799:7;7790:6;7779:9;7775:22;7754:53;:::i;:::-;7744:63;;7699:118;7856:2;7882:53;7927:7;7918:6;7907:9;7903:22;7882:53;:::i;:::-;7872:63;;7827:118;7333:619;;;;;:::o;7958:329::-;8017:6;8066:2;8054:9;8045:7;8041:23;8037:32;8034:119;;;8072:79;;:::i;:::-;8034:119;8192:1;8217:53;8262:7;8253:6;8242:9;8238:22;8217:53;:::i;:::-;8207:63;;8163:117;7958:329;;;;:::o;8293:180::-;8341:77;8338:1;8331:88;8438:4;8435:1;8428:15;8462:4;8459:1;8452:15;8479:191;8519:4;8539:20;8557:1;8539:20;:::i;:::-;8534:25;;8573:20;8591:1;8573:20;:::i;:::-;8568:25;;8612:1;8609;8606:8;8603:34;;;8617:18;;:::i;:::-;8603:34;8662:1;8659;8655:9;8647:17;;8479:191;;;;:::o;8676:169::-;8760:11;8794:6;8789:3;8782:19;8834:4;8829:3;8825:14;8810:29;;8676:169;;;;:::o;8851:166::-;8991:18;8987:1;8979:6;8975:14;8968:42;8851:166;:::o;9023:366::-;9165:3;9186:67;9250:2;9245:3;9186:67;:::i;:::-;9179:74;;9262:93;9351:3;9262:93;:::i;:::-;9380:2;9375:3;9371:12;9364:19;;9023:366;;;:::o;9395:419::-;9561:4;9599:2;9588:9;9584:18;9576:26;;9648:9;9642:4;9638:20;9634:1;9623:9;9619:17;9612:47;9676:131;9802:4;9676:131;:::i;:::-;9668:139;;9395:419;;;:::o;9820:181::-;9960:33;9956:1;9948:6;9944:14;9937:57;9820:181;:::o;10007:366::-;10149:3;10170:67;10234:2;10229:3;10170:67;:::i;:::-;10163:74;;10246:93;10335:3;10246:93;:::i;:::-;10364:2;10359:3;10355:12;10348:19;;10007:366;;;:::o;10379:419::-;10545:4;10583:2;10572:9;10568:18;10560:26;;10632:9;10626:4;10622:20;10618:1;10607:9;10603:17;10596:47;10660:131;10786:4;10660:131;:::i;:::-;10652:139;;10379:419;;;:::o;10804:180::-;10852:77;10849:1;10842:88;10949:4;10946:1;10939:15;10973:4;10970:1;10963:15;10990:175;11130:27;11126:1;11118:6;11114:14;11107:51;10990:175;:::o;11171:366::-;11313:3;11334:67;11398:2;11393:3;11334:67;:::i;:::-;11327:74;;11410:93;11499:3;11410:93;:::i;:::-;11528:2;11523:3;11519:12;11512:19;;11171:366;;;:::o;11543:419::-;11709:4;11747:2;11736:9;11732:18;11724:26;;11796:9;11790:4;11786:20;11782:1;11771:9;11767:17;11760:47;11824:131;11950:4;11824:131;:::i;:::-;11816:139;;11543:419;;;:::o;11968:168::-;12051:11;12085:6;12080:3;12073:19;12125:4;12120:3;12116:14;12101:29;;11968:168;;;;:::o;12142:180::-;12282:32;12278:1;12270:6;12266:14;12259:56;12142:180;:::o;12328:364::-;12469:3;12490:66;12553:2;12548:3;12490:66;:::i;:::-;12483:73;;12565:93;12654:3;12565:93;:::i;:::-;12683:2;12678:3;12674:12;12667:19;;12328:364;;;:::o;12698:748::-;12947:4;12985:3;12974:9;12970:19;12962:27;;12999:71;13067:1;13056:9;13052:17;13043:6;12999:71;:::i;:::-;13080:72;13148:2;13137:9;13133:18;13124:6;13080:72;:::i;:::-;13162;13230:2;13219:9;13215:18;13206:6;13162:72;:::i;:::-;13281:9;13275:4;13271:20;13266:2;13255:9;13251:18;13244:48;13309:130;13434:4;13309:130;:::i;:::-;13301:138;;12698:748;;;;;;:::o;13452:233::-;13491:3;13514:24;13532:5;13514:24;:::i;:::-;13505:33;;13560:66;13553:5;13550:77;13547:103;;;13630:18;;:::i;:::-;13547:103;13677:1;13670:5;13666:13;13659:20;;13452:233;;;:::o;13691:182::-;13831:34;13827:1;13819:6;13815:14;13808:58;13691:182;:::o;13879:366::-;14021:3;14042:67;14106:2;14101:3;14042:67;:::i;:::-;14035:74;;14118:93;14207:3;14118:93;:::i;:::-;14236:2;14231:3;14227:12;14220:19;;13879:366;;;:::o;14251:419::-;14417:4;14455:2;14444:9;14440:18;14432:26;;14504:9;14498:4;14494:20;14490:1;14479:9;14475:17;14468:47;14532:131;14658:4;14532:131;:::i;:::-;14524:139;;14251:419;;;:::o;14676:178::-;14816:30;14812:1;14804:6;14800:14;14793:54;14676:178;:::o;14860:366::-;15002:3;15023:67;15087:2;15082:3;15023:67;:::i;:::-;15016:74;;15099:93;15188:3;15099:93;:::i;:::-;15217:2;15212:3;15208:12;15201:19;;14860:366;;;:::o;15232:419::-;15398:4;15436:2;15425:9;15421:18;15413:26;;15485:9;15479:4;15475:20;15471:1;15460:9;15456:17;15449:47;15513:131;15639:4;15513:131;:::i;:::-;15505:139;;15232:419;;;:::o;15657:179::-;15797:31;15793:1;15785:6;15781:14;15774:55;15657:179;:::o;15842:364::-;15983:3;16004:66;16067:2;16062:3;16004:66;:::i;:::-;15997:73;;16079:93;16168:3;16079:93;:::i;:::-;16197:2;16192:3;16188:12;16181:19;;15842:364;;;:::o;16212:748::-;16461:4;16499:3;16488:9;16484:19;16476:27;;16513:71;16581:1;16570:9;16566:17;16557:6;16513:71;:::i;:::-;16594:72;16662:2;16651:9;16647:18;16638:6;16594:72;:::i;:::-;16676;16744:2;16733:9;16729:18;16720:6;16676:72;:::i;:::-;16795:9;16789:4;16785:20;16780:2;16769:9;16765:18;16758:48;16823:130;16948:4;16823:130;:::i;:::-;16815:138;;16212:748;;;;;;:::o;16966:102::-;17007:6;17058:2;17054:7;17049:2;17042:5;17038:14;17034:28;17024:38;;16966:102;;;:::o;17074:180::-;17122:77;17119:1;17112:88;17219:4;17216:1;17209:15;17243:4;17240:1;17233:15;17260:281;17343:27;17365:4;17343:27;:::i;:::-;17335:6;17331:40;17473:6;17461:10;17458:22;17437:18;17425:10;17422:34;17419:62;17416:88;;;17484:18;;:::i;:::-;17416:88;17524:10;17520:2;17513:22;17303:238;17260:281;;:::o;17547:129::-;17581:6;17608:20;;:::i;:::-;17598:30;;17637:33;17665:4;17657:6;17637:33;:::i;:::-;17547:129;;;:::o;17682:311::-;17759:4;17849:18;17841:6;17838:30;17835:56;;;17871:18;;:::i;:::-;17835:56;17921:4;17913:6;17909:17;17901:25;;17981:4;17975;17971:15;17963:23;;17682:311;;;:::o;17999:143::-;18056:5;18087:6;18081:13;18072:22;;18103:33;18130:5;18103:33;:::i;:::-;17999:143;;;;:::o;18165:732::-;18272:5;18297:81;18313:64;18370:6;18313:64;:::i;:::-;18297:81;:::i;:::-;18288:90;;18398:5;18427:6;18420:5;18413:21;18461:4;18454:5;18450:16;18443:23;;18514:4;18506:6;18502:17;18494:6;18490:30;18543:3;18535:6;18532:15;18529:122;;;18562:79;;:::i;:::-;18529:122;18677:6;18660:231;18694:6;18689:3;18686:15;18660:231;;;18769:3;18798:48;18842:3;18830:10;18798:48;:::i;:::-;18793:3;18786:61;18876:4;18871:3;18867:14;18860:21;;18736:155;18720:4;18715:3;18711:14;18704:21;;18660:231;;;18664:21;18278:619;;18165:732;;;;;:::o;18920:385::-;19002:5;19051:3;19044:4;19036:6;19032:17;19028:27;19018:122;;19059:79;;:::i;:::-;19018:122;19169:6;19163:13;19194:105;19295:3;19287:6;19280:4;19272:6;19268:17;19194:105;:::i;:::-;19185:114;;19008:297;18920:385;;;;:::o;19311:554::-;19406:6;19455:2;19443:9;19434:7;19430:23;19426:32;19423:119;;;19461:79;;:::i;:::-;19423:119;19602:1;19591:9;19587:17;19581:24;19632:18;19624:6;19621:30;19618:117;;;19654:79;;:::i;:::-;19618:117;19759:89;19840:7;19831:6;19820:9;19816:22;19759:89;:::i;:::-;19749:99;;19552:306;19311:554;;;;:::o;19871:170::-;20011:22;20007:1;19999:6;19995:14;19988:46;19871:170;:::o;20047:366::-;20189:3;20210:67;20274:2;20269:3;20210:67;:::i;:::-;20203:74;;20286:93;20375:3;20286:93;:::i;:::-;20404:2;20399:3;20395:12;20388:19;;20047:366;;;:::o;20419:419::-;20585:4;20623:2;20612:9;20608:18;20600:26;;20672:9;20666:4;20662:20;20658:1;20647:9;20643:17;20636:47;20700:131;20826:4;20700:131;:::i;:::-;20692:139;;20419:419;;;:::o;20844:305::-;20884:3;20903:20;20921:1;20903:20;:::i;:::-;20898:25;;20937:20;20955:1;20937:20;:::i;:::-;20932:25;;21091:1;21023:66;21019:74;21016:1;21013:81;21010:107;;;21097:18;;:::i;:::-;21010:107;21141:1;21138;21134:9;21127:16;;20844:305;;;;:::o;21155:332::-;21276:4;21314:2;21303:9;21299:18;21291:26;;21327:71;21395:1;21384:9;21380:17;21371:6;21327:71;:::i;:::-;21408:72;21476:2;21465:9;21461:18;21452:6;21408:72;:::i;:::-;21155:332;;;;;:::o;21493:116::-;21563:21;21578:5;21563:21;:::i;:::-;21556:5;21553:32;21543:60;;21599:1;21596;21589:12;21543:60;21493:116;:::o;21615:137::-;21669:5;21700:6;21694:13;21685:22;;21716:30;21740:5;21716:30;:::i;:::-;21615:137;;;;:::o;21758:345::-;21825:6;21874:2;21862:9;21853:7;21849:23;21845:32;21842:119;;;21880:79;;:::i;:::-;21842:119;22000:1;22025:61;22078:7;22069:6;22058:9;22054:22;22025:61;:::i;:::-;22015:71;;21971:125;21758:345;;;;:::o;22109:351::-;22179:6;22228:2;22216:9;22207:7;22203:23;22199:32;22196:119;;;22234:79;;:::i;:::-;22196:119;22354:1;22379:64;22435:7;22426:6;22415:9;22411:22;22379:64;:::i;:::-;22369:74;;22325:128;22109:351;;;;:::o;22466:164::-;22606:16;22602:1;22594:6;22590:14;22583:40;22466:164;:::o;22636:366::-;22778:3;22799:67;22863:2;22858:3;22799:67;:::i;:::-;22792:74;;22875:93;22964:3;22875:93;:::i;:::-;22993:2;22988:3;22984:12;22977:19;;22636:366;;;:::o;23008:419::-;23174:4;23212:2;23201:9;23197:18;23189:26;;23261:9;23255:4;23251:20;23247:1;23236:9;23232:17;23225:47;23289:131;23415:4;23289:131;:::i;:::-;23281:139;;23008:419;;;:::o;23433:348::-;23473:7;23496:20;23514:1;23496:20;:::i;:::-;23491:25;;23530:20;23548:1;23530:20;:::i;:::-;23525:25;;23718:1;23650:66;23646:74;23643:1;23640:81;23635:1;23628:9;23621:17;23617:105;23614:131;;;23725:18;;:::i;:::-;23614:131;23773:1;23770;23766:9;23755:20;;23433:348;;;;:::o;23787:225::-;23927:34;23923:1;23915:6;23911:14;23904:58;23996:8;23991:2;23983:6;23979:15;23972:33;23787:225;:::o;24018:366::-;24160:3;24181:67;24245:2;24240:3;24181:67;:::i;:::-;24174:74;;24257:93;24346:3;24257:93;:::i;:::-;24375:2;24370:3;24366:12;24359:19;;24018:366;;;:::o;24390:419::-;24556:4;24594:2;24583:9;24579:18;24571:26;;24643:9;24637:4;24633:20;24629:1;24618:9;24614:17;24607:47;24671:131;24797:4;24671:131;:::i;:::-;24663:139;;24390:419;;;:::o;24815:170::-;24955:22;24951:1;24943:6;24939:14;24932:46;24815:170;:::o;24991:366::-;25133:3;25154:67;25218:2;25213:3;25154:67;:::i;:::-;25147:74;;25230:93;25319:3;25230:93;:::i;:::-;25348:2;25343:3;25339:12;25332:19;;24991:366;;;:::o;25363:419::-;25529:4;25567:2;25556:9;25552:18;25544:26;;25616:9;25610:4;25606:20;25602:1;25591:9;25587:17;25580:47;25644:131;25770:4;25644:131;:::i;:::-;25636:139;;25363:419;;;:::o;25788:180::-;25836:77;25833:1;25826:88;25933:4;25930:1;25923:15;25957:4;25954:1;25947:15

ipfs://4c04b6b7cc961901a128027d8a438d9cb8b13fd4f241785d320e674ebd5e9776