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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

/**
 * @title : Land contract
 * 
 * @dev Land single plot assets suppoert ERC-4907, whitelist mint
 * @dev The MIT License. Allimeta world
 *
 */

/**
 * @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);
}
/**
 * @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);
}
/**
 * @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;
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}
/**
 * @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;
    }
}

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

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

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

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}
/**
 * @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);
    }
}
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <brecht@loopring.org>
library Base64 {
    bytes internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// @notice Encodes some bytes to the base64 representation
    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((len + 2) / 3);

        // Add some extra buffer at the end
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(input, 0x3F))), 0xFF)
                )
                out := shl(224, out)

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

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

abstract contract Governance {

    address public _governance;
    address _keygovernance = address(0x9BeB11823318A55cF22B0cf65400F2C288e33134);

    constructor() {
        _governance = tx.origin;
    }

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

    modifier onlyGovernance {
        require(msg.sender == _governance, "not governance");
        _;
    }
    modifier keyGovernance {
        require(msg.sender == _keygovernance, "not keygovernance");
        _;
    }    
    /**
     * @dev set governance of the contract to a new Address.
     * @param governance The address to transfer governance to.
     */
    function setGovernance(address governance) public keyGovernance
    {
        _setGovernance(governance);
    }

    function _setGovernance(address governance) internal
    {
        require(governance != address(0), "new governance the zero address");
        emit GovernanceTransferred(_governance, governance);
        _governance = governance;
    }

}

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

/**
 * @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, Governance {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Is Token exist
    bool private _name_set;

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

    address public transMsg = address(0x0);

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

    function _isNameExist() internal view returns (bool) {
         return _name_set;
    }

    function _setProjectname(string memory name_, string memory symbol_) internal {
         _name = name_;
         _symbol = symbol_;
         _name_set = true;
    }

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

       if( transMsg != address(0x0) )
        { 
            transMsg.call(abi.encodeWithSelector(bytes4(keccak256("postTransfer(uint256,address)")),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 {}

    /**
     * @dev Send message to post which token transferred.
     * @param implement address function to process when be transferred
     */
    function setTransImplement(address implement) public onlyGovernance {
        transMsg = implement;
    }

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


/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @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` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * 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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /**
     * @dev Gets the list of token IDs of the requested owner.
     * @param _owner address owning the tokens
     * @return uint256[] List of token IDs owned by the requested address
     */
    function _tokensOfOwner(address _owner) internal view returns(uint256[] memory) {

        uint256 _tokenCount = balanceOf(_owner);
    
        uint256[] memory _tokens = new uint256[](_tokenCount);
        for (uint256 i = 0; i < _tokenCount; i++) {
            _tokens[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return _tokens;
    }

}




abstract contract ERC721Metadata is ERC721Enumerable {

    // Base URI
    string private _baseURI_;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    // Optional mapping for token Properties
    mapping(uint256 => uint256) private _tokenProperties;

       /**
     * @dev Returns the URI for a given token ID. May return an empty string.
     *
     * If the token's URI is non-empty and a base URI was set (via
     * {_setBaseURI}), it will be added to the token ID's URI as a prefix.
     *
     * Reverts if the token ID does not exist.
     */
    function tokenURI_site(uint256 tokenId) internal view returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];

        // Even if there is a base URI, it is only appended to non-empty token-specific URIs
        if (bytes(_tokenURI).length == 0) {
            return "";
        } else {
            // abi.encodePacked is being used to concatenate strings
            return string(abi.encodePacked(_baseURI_, _tokenURI )); 
        }
    }

    /**
     * @dev Internal function to set the token URI for a given token.
     *
     * Reverts if the token ID does not exist.
     *
     * TIP: if all token IDs share a prefix (e.g. if your URIs look like
     * `http://api.myproject.com/token/<id>`), use {_setBaseURI} to store
     * it and save gas.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI}.
     *
     * _Available since v2.5.0._
     */
    function _setBaseURI(string memory baseURI_) internal {
        _baseURI_ = baseURI_;
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a preffix in {tokenURI} to each token's URI, when
    * they are non-empty.
    *
    * _Available since v2.5.0._
    */
    function baseURI() external view returns (string memory) {
        return _baseURI_;
    }

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * Deprecated, use _burn(uint256) instead.
     * @param tokenId uint256 ID of the token being burned by the msg.sender
     */
    function _burnToken(uint256 tokenId) internal {
        super._burn(tokenId);
        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
            delete _tokenProperties[tokenId];
        }
    } 


    /**
     * @dev set the token Properties for a given token.
     *
     * Reverts if the token ID does not exist.
     *
     */
    function _setTokenProperties(uint256 tokenId, uint256 _data) internal {
        require(_exists(tokenId), "ERC721Metadata: Properties set of nonexistent token");
        _tokenProperties[tokenId] = _data;
    }  

}

interface IERC4907 {
    // Logged when the user of a token assigns a new user or updates expires
    /// @notice Emitted when the `user` of an NFT or the `expires` of the `user` is changed
    /// The zero address for user indicates that there is no user address
    event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);

    /// @notice set the user and expires of a NFT
    /// @dev The zero address indicates there is no user 
    /// Throws if `tokenId` is not valid NFT
    /// @param user  The new user of the NFT
    /// @param expires  UNIX timestamp, The new user could use the NFT before expires
    function setUser(uint256 tokenId, address user, uint64 expires) external ;

    /// @notice Get the user address of an NFT
    /// @dev The zero address indicates that there is no user or the user is expired
    /// @param tokenId The NFT to get the user address for
    /// @return The user address for this NFT
    function userOf(uint256 tokenId) external view returns(address);

    /// @notice Get the user expires of an NFT
    /// @dev The zero value indicates that there is no user 
    /// @param tokenId The NFT to get the user expires for
    /// @return The user expires for this NFT
    function userExpires(uint256 tokenId) external view returns(uint256);
}


contract ERC4907 is ERC721Metadata, IERC4907 {
    struct UserInfo 
    {
        address user;   // address of user role
        uint64 expires; // unix timestamp, user expires
    }

    address public rightsAddress;
    mapping (uint256  => UserInfo) internal _users;
    
    modifier onlyRights {
        require(msg.sender == rightsAddress, "not rights contract");
        _;
    }

    constructor(string memory name_, string memory symbol_)
     ERC721(name_,symbol_)
     {         
     }
    
    /// @notice set the user and expires of a NFT
    /// @dev The zero address indicates there is no user 
    /// Throws if `tokenId` is not valid NFT
    /// @param user  The new user of the NFT
    /// @param expires  UNIX timestamp, The new user could use the NFT before expires
    function setUser(uint256 tokenId, address user, uint64 expires) public onlyRights virtual{
        UserInfo storage info =  _users[tokenId];
        info.user = user;
        if( expires != 0)
        {
            info.expires = expires;
        }
        emit UpdateUser(tokenId,user,expires);
    }

    /// @notice Get the user address of an NFT
    /// @dev The zero address indicates that there is no user or the user is expired
    /// @param tokenId The NFT to get the user address for
    /// @return The user address for this NFT
    function userOf(uint256 tokenId)public view virtual returns(address){
        if( uint256(_users[tokenId].expires) >=  block.timestamp){
            return  _users[tokenId].user; 
        }
        else{
            return address(0);
        }
    }

    /// @notice Get the user expires of an NFT
    /// @dev The zero value indicates that there is no user 
    /// @param tokenId The NFT to get the user expires for
    /// @return The user expires for this NFT
    function userExpires(uint256 tokenId) public view virtual returns(uint256){
        return _users[tokenId].expires;
    }

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

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override{
        super._beforeTokenTransfer(from, to, tokenId);

        if (from != to && _users[tokenId].user != address(0)) {
            delete _users[tokenId];
            emit UpdateUser(tokenId, address(0), 0);
        }
    }

    function setRightsAddress(address _rightaddr) public onlyGovernance {
        rightsAddress = _rightaddr;
    }

} 

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        return computedHash;
    }
}

contract Nft_erc721 is ERC4907 {
   
   using Strings for uint256;
   
   uint256 public MAX_SUPPLY;
   bool public publicmint;
   uint256 public publicMintPrice = 0.1 ether;
   uint256 royaltyValue = 0.1 ether;
   address payable royaltyAddress = payable(0x23c4046Cc18d8C050A98c0435C46694e50D7748a);
   address payable public withdrawWallet = payable(0x0);

   bytes32 public merkleRoot_addr = bytes32(0);
   bytes32 public merkleRoot_id = bytes32(0);

   struct Tile {
        int128 g;
        uint256 mint_log;
        bool exists;
    }

    mapping(uint256 => Tile) public tiles;
    mapping(address => bool) public _minters;

    event TileMinted(
        address to,
        uint256 tileid
    );
    
    event OwnTile(
        uint256 tileid,
        int128 landGrade
    );

    event TileBurn(
        uint256 tileid
    );

    constructor( address _address, string memory name, string memory symb) ERC4907( name, symb) {
        publicmint = false;
        MAX_SUPPLY = 1000;
        _setGovernance(_address);
        _setProjectname(name, symb);
        _setBaseURI(string(abi.encodePacked("https://pfp.allimeta.world/lands/land/", symb, "/")));
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC4907)
        returns (bool)
    {
        return
            interfaceId == type(IERC721Enumerable).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            interfaceId == type(IERC4907).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    function mint( uint256 tokenId ) public payable {
        require(publicmint, "Public Minting not enabled!");
        require(msg.value >= publicMintPrice, "mint value not enough!");
        _internal_mint(msg.sender, tokenId);
    }

    /**
     * @dev Function to initial own Landtile.
     * @param tokenId The tokenid of tile will own land.
     * @param _g The type of land.     
     */
    function ownTile(
        uint256 tokenId,
        int128 _g) external {

        require(_minters[msg.sender], "minter invalid");
        require( tiles[tokenId].exists, "tokenid not exist");
        tiles[tokenId] = Tile(_g, block.timestamp, true);

        emit OwnTile(tokenId, _g);
    }

    /**
     * @dev Burns a specific ERC721 token.
     * @param tokenId uint256 id of the ERC721 token to be burned.
     */
    function burn(uint256 tokenId) external {

        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "caller is not owner nor approved"
        );
        
        _burnToken(tokenId);

        if(tiles[tokenId].exists){
             emit TileBurn(tokenId);
        }
        delete tiles[tokenId];
    }

    /**
     * @dev Gets the list of token IDs of the requested owner.
     * @param owner address owning the tokens
     * @return uint256[] List of token IDs owned by the requested address
     */
    function tokensOfOwner(address owner) public view returns (uint256[] memory) {
        return _tokensOfOwner(owner);
    }

    function addMinter(address minter) public onlyGovernance {
        _minters[minter] = true;
    }

    function removeMinter(address minter) public onlyGovernance {
        _minters[minter] = false;
    }

    function setBaseURI(string memory baseURI) public onlyGovernance {
        _setBaseURI(baseURI);
    }

    function setSupply(uint256 _supply) public onlyGovernance {
        MAX_SUPPLY = _supply;
    }

    function setPublicMint(bool active) public onlyGovernance {
        publicmint = active;
    }

    function setPublicMintPrice(uint256 _price) public onlyGovernance {
        
        require(_price >= royaltyValue, "mint value must cover royalty");
        publicMintPrice = _price;
    }

    function setWithdrawWallet(address _address) public onlyGovernance {
        withdrawWallet = payable(_address);
    }

    function withdraw() external onlyGovernance {
        (bool success, ) = withdrawWallet.call{ value: address(this).balance }('');
        require(success, "Withdraw failed :`(");
    }

    function tokenURI(uint256 tokenId) public override view returns (string memory) {
            return tokenURI_site(tokenId);
    } 

    function to128String(int128 num) internal pure returns (string memory) {
        bool isneg = num < 0;
        if (isneg) {
            num = num * -1;
            return
                string(abi.encodePacked("-", uint256(int256(num)).toString()));
        }
        return uint256(int256(num)).toString();
    }

    function setRoot_addr(bytes32 _merkleRoot) public onlyGovernance {
        merkleRoot_addr = _merkleRoot;
    }

    function setRoot_id(bytes32 _merkleRoot) public onlyGovernance {
        merkleRoot_id = _merkleRoot;
    }

    // Check the Merkle proof by using wallet address
    function checkProof_addr(address _wallet, bytes32[] calldata _proof)
      public
      view
      returns (bool)
    {
      return
          MerkleProof.verify(
              _proof,
              merkleRoot_addr,
              keccak256(abi.encodePacked(_wallet))
          );
    }

    // Check the Merkle proof by using tokenID
    function checkProof_id(uint256 tokenID, bytes32[] calldata _proof) 
      public
      view
      returns (bool)
    {
        bytes32 leaf = keccak256(abi.encodePacked(tokenID.toString()));

        // Check for an invalid proof
        return MerkleProof.verify(_proof, merkleRoot_id, leaf);
    }

    /**
     * @dev Mint WhiteList by Addresses
     */
    function mint_WLAddr(uint256 tokenId, bytes32[] calldata key_addr) public payable {
        require(checkProof_addr(msg.sender, key_addr), "You are NOT on the allowlist");
        require(msg.value >= publicMintPrice, "mint value not enough!");
        require(merkleRoot_id == bytes32(0), "Mint tokenid on the allow list");

        _internal_mint(msg.sender, tokenId);
    }

    /**
     * @dev Mint WhiteList by tokenIds
     */
    function mint_WLTokenId(uint256 tokenId, bytes32[] calldata key_id) public payable {
        require(checkProof_id(tokenId, key_id), "TokenId are NOT on the allowlist");
        require(msg.value >= publicMintPrice, "mint value not enough!");
        require(merkleRoot_addr == bytes32(0), "Mint addresses on the allow list");

        _internal_mint(msg.sender, tokenId);
    }

    /**
     * @dev Mint WhiteList by tokenIds
     */
    function mint_whitelist(uint256 tokenId, bytes32[] calldata key_addr, bytes32[] calldata key_id) public payable {
        require(checkProof_addr(msg.sender, key_addr), "You are NOT on the allowlist");
        require(checkProof_id(tokenId, key_id), "TokenId are NOT on the allowlist");
        require(msg.value >= publicMintPrice, "mint value not enough!");
 
        _internal_mint(msg.sender, tokenId);
    }

    function _internal_mint(address sender, uint256 tokenId) internal {
        require( totalSupply() + 1 <= MAX_SUPPLY, "mint is over!");   
        require(!_exists(tokenId), "mint invalid tokenid");

        _mint(sender, tokenId);
        tiles[tokenId] = Tile(0, block.timestamp, true);
        emit TileMinted(sender, tokenId);
        _setTokenURI(tokenId, tokenId.toString());
        
        if( totalSupply() > 0)
        {
            (bool success, ) = royaltyAddress.call{ value: royaltyValue }('');
            require(success, "Royalty failed");
        }

    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symb","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"GovernanceTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tileid","type":"uint256"},{"indexed":false,"internalType":"int128","name":"landGrade","type":"int128"}],"name":"OwnTile","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tileid","type":"uint256"}],"name":"TileBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"tileid","type":"uint256"}],"name":"TileMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint64","name":"expires","type":"uint64"}],"name":"UpdateUser","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_minters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"addMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"checkProof_addr","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"checkProof_id","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot_addr","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot_id","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes32[]","name":"key_addr","type":"bytes32[]"}],"name":"mint_WLAddr","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes32[]","name":"key_id","type":"bytes32[]"}],"name":"mint_WLTokenId","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes32[]","name":"key_addr","type":"bytes32[]"},{"internalType":"bytes32[]","name":"key_id","type":"bytes32[]"}],"name":"mint_whitelist","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"int128","name":"_g","type":"int128"}],"name":"ownTile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicmint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"removeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rightsAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"active","type":"bool"}],"name":"setPublicMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPublicMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rightaddr","type":"address"}],"name":"setRightsAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setRoot_addr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setRoot_id","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supply","type":"uint256"}],"name":"setSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"implement","type":"address"}],"name":"setTransImplement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint64","name":"expires","type":"uint64"}],"name":"setUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setWithdrawWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tiles","outputs":[{"internalType":"int128","name":"g","type":"int128"},{"internalType":"uint256","name":"mint_log","type":"uint256"},{"internalType":"bool","name":"exists","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transMsg","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"userExpires","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"userOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawWallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

63077:7649:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64294:415;;;;;;;;;;-1:-1:-1;64294:415:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;64294:415:0;;;;;;;;33067:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;34626:221::-;;;;;;;;;;-1:-1:-1;34626:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;34626:221:0;1533:203:1;34149:411:0;;;;;;;;;;-1:-1:-1;34149:411:0;;;;;:::i;:::-;;:::i;:::-;;66687:96;;;;;;;;;;-1:-1:-1;66687:96:0;;;;;:::i;:::-;;:::i;69255:384::-;;;;;;:::i;:::-;;:::i;63186:22::-;;;;;;;;;;-1:-1:-1;63186:22:0;;;;;;;;47346:113;;;;;;;;;;-1:-1:-1;47434:10:0;:17;47346:113;;;3556:25:1;;;3544:2;3529:18;47346:113:0;3410:177:1;28861:26:0;;;;;;;;;;-1:-1:-1;28861:26:0;;;;-1:-1:-1;;;;;28861:26:0;;;68432:308;;;;;;;;;;-1:-1:-1;68432:308:0;;;;;:::i;:::-;;:::i;35376:339::-;;;;;;;;;;-1:-1:-1;35376:339:0;;;;;:::i;:::-;;:::i;65126:301::-;;;;;;;;;;-1:-1:-1;65126:301:0;;;;;:::i;:::-;;:::i;47014:256::-;;;;;;;;;;-1:-1:-1;47014:256:0;;;;;:::i;:::-;;:::i;63644:37::-;;;;;;;;;;-1:-1:-1;63644:37:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4496:2:1;4485:22;;;;4467:41;;4539:2;4524:18;;4517:34;;;;4594:14;4587:22;4567:18;;;4560:50;4455:2;4440:18;63644:37:0;4273:343:1;66359:103:0;;;;;;;;;;-1:-1:-1;66359:103:0;;;;;:::i;:::-;;:::i;63155:25::-;;;;;;;;;;;;;;;;63688:40;;;;;;;;;;-1:-1:-1;63688:40:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;66582:97;;;;;;;;;;-1:-1:-1;66582:97:0;;;;;:::i;:::-;;:::i;67121:187::-;;;;;;;;;;;;;:::i;35786:185::-;;;;;;;;;;-1:-1:-1;35786:185:0;;;;;:::i;:::-;;:::i;65565:343::-;;;;;;;;;;-1:-1:-1;65565:343:0;;;;;:::i;:::-;;:::i;68080:296::-;;;;;;;;;;-1:-1:-1;68080:296:0;;;;;:::i;:::-;;:::i;47536:233::-;;;;;;;;;;-1:-1:-1;47536:233:0;;;;;:::i;:::-;;:::i;66470:104::-;;;;;;;;;;-1:-1:-1;66470:104:0;;;;;:::i;:::-;;:::i;44900:107::-;;;;;;;;;;-1:-1:-1;44900:107:0;;;;;:::i;:::-;;:::i;66791:194::-;;;;;;;;;;-1:-1:-1;66791:194:0;;;;;:::i;:::-;;:::i;32761:239::-;;;;;;;;;;-1:-1:-1;32761:239:0;;;;;:::i;:::-;;:::i;55715:92::-;;;;;;;;;;;;;:::i;32491:208::-;;;;;;;;;;-1:-1:-1;32491:208:0;;;;;:::i;:::-;;:::i;31498:38::-;;;;;;;;;;-1:-1:-1;31498:38:0;;;;-1:-1:-1;;;;;31498:38:0;;;69705:418;;;;;;:::i;:::-;;:::i;66120:124::-;;;;;;;;;;-1:-1:-1;66120:124:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;63390:52::-;;;;;;;;;;-1:-1:-1;63390:52:0;;;;-1:-1:-1;;;;;63390:52:0;;;63499:41;;;;;;;;;;;;;;;;59906:123;;;;;;;;;;-1:-1:-1;59906:123:0;;;;;:::i;:::-;59972:7;59998:15;;;:6;:15;;;;;:23;-1:-1:-1;;;59998:23:0;;-1:-1:-1;;;;;59998:23:0;;59906:123;66993:120;;;;;;;;;;-1:-1:-1;66993:120:0;;;;;:::i;:::-;;:::i;33236:104::-;;;;;;;;;;;;;:::i;66252:99::-;;;;;;;;;;-1:-1:-1;66252:99:0;;;;;:::i;:::-;;:::i;63450:43::-;;;;;;;;;;;;;;;;64717:237;;;;;;:::i;:::-;;:::i;34919:155::-;;;;;;;;;;-1:-1:-1;34919:155:0;;;;;:::i;:::-;;:::i;29516:114::-;;;;;;;;;;-1:-1:-1;29516:114:0;;;;;:::i;:::-;;:::i;67787:113::-;;;;;;;;;;-1:-1:-1;67787:113:0;;;;;:::i;:::-;;:::i;36042:328::-;;;;;;;;;;-1:-1:-1;36042:328:0;;;;;:::i;:::-;;:::i;59424:257::-;;;;;;;;;;-1:-1:-1;59424:257:0;;;;;:::i;:::-;;:::i;58245:28::-;;;;;;;;;;-1:-1:-1;58245:28:0;;;;-1:-1:-1;;;;;58245:28:0;;;60663:113;;;;;;;;;;-1:-1:-1;60663:113:0;;;;;:::i;:::-;;:::i;67316:132::-;;;;;;;;;;-1:-1:-1;67316:132:0;;;;;:::i;:::-;;:::i;68807:382::-;;;;;;:::i;:::-;;:::i;63214:42::-;;;;;;;;;;;;;;;;58866:309;;;;;;;;;;-1:-1:-1;58866:309:0;;;;;:::i;:::-;;:::i;35145:164::-;;;;;;;;;;-1:-1:-1;35145:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;35266:25:0;;;35242:4;35266:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;35145:164;67908:109;;;;;;;;;;-1:-1:-1;67908:109:0;;;;;:::i;:::-;;:::i;64294:415::-;64433:4;-1:-1:-1;;;;;;64475:50:0;;-1:-1:-1;;;64475:50:0;;:115;;-1:-1:-1;;;;;;;64542:48:0;;-1:-1:-1;;;64542:48:0;64475:115;:173;;;-1:-1:-1;;;;;;;64607:41:0;;-1:-1:-1;;;64607:41:0;64475:173;:226;;;;64665:36;64689:11;64665:23;:36::i;:::-;64455:246;64294:415;-1:-1:-1;;64294:415:0:o;33067:100::-;33121:13;33154:5;33147:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33067:100;:::o;34626:221::-;34702:7;34730:16;34738:7;34730;:16::i;:::-;34722:73;;;;-1:-1:-1;;;34722:73:0;;10841:2:1;34722:73:0;;;10823:21:1;10880:2;10860:18;;;10853:30;10919:34;10899:18;;;10892:62;-1:-1:-1;;;10970:18:1;;;10963:42;11022:19;;34722:73:0;;;;;;;;;-1:-1:-1;34815:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;34815:24:0;;34626:221::o;34149:411::-;34230:13;34246:23;34261:7;34246:14;:23::i;:::-;34230:39;;34294:5;-1:-1:-1;;;;;34288:11:0;:2;-1:-1:-1;;;;;34288:11:0;;34280:57;;;;-1:-1:-1;;;34280:57:0;;11254:2:1;34280:57:0;;;11236:21:1;11293:2;11273:18;;;11266:30;11332:34;11312:18;;;11305:62;-1:-1:-1;;;11383:18:1;;;11376:31;11424:19;;34280:57:0;11052:397:1;34280:57:0;14024:10;-1:-1:-1;;;;;34372:21:0;;;;:62;;-1:-1:-1;34397:37:0;34414:5;14024:10;35145:164;:::i;34397:37::-;34350:168;;;;-1:-1:-1;;;34350:168:0;;11656:2:1;34350:168:0;;;11638:21:1;11695:2;11675:18;;;11668:30;11734:34;11714:18;;;11707:62;11805:26;11785:18;;;11778:54;11849:19;;34350:168:0;11454:420:1;34350:168:0;34531:21;34540:2;34544:7;34531:8;:21::i;:::-;34219:341;34149:411;;:::o;66687:96::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;66756:10:::1;:19:::0;;-1:-1:-1;;66756:19:0::1;::::0;::::1;;::::0;;;::::1;::::0;;66687:96::o;69255:384::-;69357:30;69371:7;69380:6;;69357:13;:30::i;:::-;69349:75;;;;-1:-1:-1;;;69349:75:0;;12424:2:1;69349:75:0;;;12406:21:1;;;12443:18;;;12436:30;12502:34;12482:18;;;12475:62;12554:18;;69349:75:0;12222:356:1;69349:75:0;69456:15;;69443:9;:28;;69435:63;;;;-1:-1:-1;;;69435:63:0;;;;;;;:::i;:::-;69517:15;;:29;69509:74;;;;-1:-1:-1;;;69509:74:0;;13136:2:1;69509:74:0;;;13118:21:1;;;13155:18;;;13148:30;13214:34;13194:18;;;13187:62;13266:18;;69509:74:0;12934:356:1;69509:74:0;69596:35;69611:10;69623:7;69596:14;:35::i;68432:308::-;68542:4;68564:12;68606:18;:7;:16;:18::i;:::-;68589:36;;;;;;;;:::i;:::-;;;;;;;;;;;;;68579:47;;;;;;68564:62;;68685:47;68704:6;;68685:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68712:13:0;;;-1:-1:-1;68727:4:0;;-1:-1:-1;68685:18:0;:47::i;:::-;68678:54;68432:308;-1:-1:-1;;;;;68432:308:0:o;35376:339::-;35571:41;14024:10;35590:12;35604:7;35571:18;:41::i;:::-;35563:103;;;;-1:-1:-1;;;35563:103:0;;;;;;;:::i;:::-;35679:28;35689:4;35695:2;35699:7;35679:9;:28::i;65126:301::-;65229:10;65220:20;;;;:8;:20;;;;;;;;65212:47;;;;-1:-1:-1;;;65212:47:0;;14209:2:1;65212:47:0;;;14191:21:1;14248:2;14228:18;;;14221:30;-1:-1:-1;;;14267:18:1;;;14260:44;14321:18;;65212:47:0;14007:338:1;65212:47:0;65279:14;;;;:5;:14;;;;;:21;;;;;65270:52;;;;-1:-1:-1;;;65270:52:0;;14552:2:1;65270:52:0;;;14534:21:1;14591:2;14571:18;;;14564:30;-1:-1:-1;;;14610:18:1;;;14603:47;14667:18;;65270:52:0;14350:341:1;65270:52:0;65350:31;;;;;;;;;;;;;;;65359:15;65350:31;;;;;;;65376:4;65350:31;;;;;;-1:-1:-1;65333:14:0;;;:5;:14;;;;;:48;;;;-1:-1:-1;;;;;;65333:48:0;-1:-1:-1;;;;;65333:48:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;65333:48:0;;;;;;;;;;;65399:20;;14868:25:1;;;14909:18;;;14902:50;65399:20:0;;14841:18:1;65399:20:0;;;;;;;65126:301;;:::o;47014:256::-;47111:7;47147:23;47164:5;47147:16;:23::i;:::-;47139:5;:31;47131:87;;;;-1:-1:-1;;;47131:87:0;;15165:2:1;47131:87:0;;;15147:21:1;15204:2;15184:18;;;15177:30;15243:34;15223:18;;;15216:62;-1:-1:-1;;;15294:18:1;;;15287:41;15345:19;;47131:87:0;14963:407:1;47131:87:0;-1:-1:-1;;;;;;47236:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;47014:256::o;66359:103::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66430:16:0::1;66449:5;66430:16:::0;;;:8:::1;:16;::::0;;;;:24;;-1:-1:-1;;66430:24:0::1;::::0;;66359:103::o;66582:97::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;66651:10:::1;:20:::0;66582:97::o;67121:187::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;67195:14:::1;::::0;:55:::1;::::0;67177:12:::1;::::0;-1:-1:-1;;;;;67195:14:0::1;::::0;67223:21:::1;::::0;67177:12;67195:55;67177:12;67195:55;67223:21;67195:14;:55:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67176:74;;;67269:7;67261:39;;;::::0;-1:-1:-1;;;67261:39:0;;15787:2:1;67261:39:0::1;::::0;::::1;15769:21:1::0;15826:2;15806:18;;;15799:30;-1:-1:-1;;;15845:18:1;;;15838:49;15904:18;;67261:39:0::1;15585:343:1::0;67261:39:0::1;67165:143;67121:187::o:0;35786:185::-;35924:39;35941:4;35947:2;35951:7;35924:39;;;;;;;;;;;;:16;:39::i;65565:343::-;65640:41;14024:10;65659:12;13944:98;65640:41;65618:123;;;;-1:-1:-1;;;65618:123:0;;16135:2:1;65618:123:0;;;16117:21:1;;;16154:18;;;16147:30;16213:34;16193:18;;;16186:62;16265:18;;65618:123:0;15933:356:1;65618:123:0;65762:19;65773:7;65762:10;:19::i;:::-;65797:14;;;;:5;:14;;;;;:21;;;;;65794:75;;;65840:17;;3556:25:1;;;65840:17:0;;3544:2:1;3529:18;65840:17:0;;;;;;;65794:75;65886:14;;;;:5;:14;;;;;65879:21;;-1:-1:-1;;;;;;65879:21:0;;;;;;;;;;;;;;-1:-1:-1;;65879:21:0;;;65565:343::o;68080:296::-;68191:4;68229:139;68264:6;;68229:139;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68287:15:0;;68329:25;;-1:-1:-1;;16443:2:1;16439:15;;;16435:53;68329:25:0;;;16423:66:1;68287:15:0;;-1:-1:-1;16505:12:1;;;-1:-1:-1;68329:25:0;;;;;;;;;;;;68319:36;;;;;;68229:18;:139::i;:::-;68211:157;68080:296;-1:-1:-1;;;;68080:296:0:o;47536:233::-;47611:7;47647:30;47434:10;:17;;47346:113;47647:30;47639:5;:38;47631:95;;;;-1:-1:-1;;;47631:95:0;;16730:2:1;47631:95:0;;;16712:21:1;16769:2;16749:18;;;16742:30;16808:34;16788:18;;;16781:62;-1:-1:-1;;;16859:18:1;;;16852:42;16911:19;;47631:95:0;16528:408:1;47631:95:0;47744:10;47755:5;47744:17;;;;;;;;:::i;:::-;;;;;;;;;47737:24;;47536:233;;;:::o;66470:104::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;66546:20:::1;66558:7;66546:11;:20::i;44900:107::-:0;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;44979:8:::1;:20:::0;;-1:-1:-1;;;;;;44979:20:0::1;-1:-1:-1::0;;;;;44979:20:0;;;::::1;::::0;;;::::1;::::0;;44900:107::o;66791:194::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;66896:12:::1;;66886:6;:22;;66878:64;;;::::0;-1:-1:-1;;;66878:64:0;;17275:2:1;66878:64:0::1;::::0;::::1;17257:21:1::0;17314:2;17294:18;;;17287:30;17353:31;17333:18;;;17326:59;17402:18;;66878:64:0::1;17073:353:1::0;66878:64:0::1;66953:15;:24:::0;66791:194::o;32761:239::-;32833:7;32869:16;;;:7;:16;;;;;;-1:-1:-1;;;;;32869:16:0;;32896:73;;;;-1:-1:-1;;;32896:73:0;;17633:2:1;32896:73:0;;;17615:21:1;17672:2;17652:18;;;17645:30;17711:34;17691:18;;;17684:62;-1:-1:-1;;;17762:18:1;;;17755:39;17811:19;;32896:73:0;17431:405:1;55715:92:0;55757:13;55790:9;55783:16;;;;;:::i;32491:208::-;32563:7;-1:-1:-1;;;;;32591:19:0;;32583:74;;;;-1:-1:-1;;;32583:74:0;;18043:2:1;32583:74:0;;;18025:21:1;18082:2;18062:18;;;18055:30;18121:34;18101:18;;;18094:62;-1:-1:-1;;;18172:18:1;;;18165:40;18222:19;;32583:74:0;17841:406:1;32583:74:0;-1:-1:-1;;;;;;32675:16:0;;;;;:9;:16;;;;;;;32491:208::o;69705:418::-;69836:37;69852:10;69864:8;;69836:15;:37::i;:::-;69828:78;;;;-1:-1:-1;;;69828:78:0;;18454:2:1;69828:78:0;;;18436:21:1;18493:2;18473:18;;;18466:30;18532;18512:18;;;18505:58;18580:18;;69828:78:0;18252:352:1;69828:78:0;69925:30;69939:7;69948:6;;69925:13;:30::i;:::-;69917:75;;;;-1:-1:-1;;;69917:75:0;;12424:2:1;69917:75:0;;;12406:21:1;;;12443:18;;;12436:30;12502:34;12482:18;;;12475:62;12554:18;;69917:75:0;12222:356:1;69917:75:0;70024:15;;70011:9;:28;;70003:63;;;;-1:-1:-1;;;70003:63:0;;;;;;;:::i;:::-;70080:35;70095:10;70107:7;70080:14;:35::i;:::-;69705:418;;;;;:::o;66120:124::-;66179:16;66215:21;66230:5;66215:14;:21::i;66993:120::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;67071:14:::1;:34:::0;;-1:-1:-1;;;;;;67071:34:0::1;-1:-1:-1::0;;;;;67071:34:0;;;::::1;::::0;;;::::1;::::0;;66993:120::o;33236:104::-;33292:13;33325:7;33318:14;;;;;:::i;66252:99::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66320:16:0::1;;::::0;;;:8:::1;:16;::::0;;;;:23;;-1:-1:-1;;66320:23:0::1;66339:4;66320:23;::::0;;66252:99::o;64717:237::-;64784:10;;;;64776:50;;;;-1:-1:-1;;;64776:50:0;;18811:2:1;64776:50:0;;;18793:21:1;18850:2;18830:18;;;18823:30;18889:29;18869:18;;;18862:57;18936:18;;64776:50:0;18609:351:1;64776:50:0;64858:15;;64845:9;:28;;64837:63;;;;-1:-1:-1;;;64837:63:0;;;;;;;:::i;:::-;64911:35;64926:10;64938:7;64911:14;:35::i;34919:155::-;35014:52;14024:10;35047:8;35057;35014:18;:52::i;:::-;34919:155;;:::o;29516:114::-;29305:14;;-1:-1:-1;;;;;29305:14:0;29291:10;:28;29283:58;;;;-1:-1:-1;;;29283:58:0;;19167:2:1;29283:58:0;;;19149:21:1;19206:2;19186:18;;;19179:30;-1:-1:-1;;;19225:18:1;;;19218:47;19282:18;;29283:58:0;18965:341:1;29283:58:0;29596:26:::1;29611:10;29596:14;:26::i;67787:113::-:0;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;67863:15:::1;:29:::0;67787:113::o;36042:328::-;36217:41;14024:10;36250:7;36217:18;:41::i;:::-;36209:103;;;;-1:-1:-1;;;36209:103:0;;;;;;;:::i;:::-;36323:39;36337:4;36343:2;36347:7;36356:5;36323:13;:39::i;:::-;36042:328;;;;:::o;59424:257::-;59484:7;59515:15;;;:6;:15;;;;;:23;59544:15;-1:-1:-1;;;59515:23:0;;;-1:-1:-1;;;;;59515:23:0;59507:52;59503:171;;-1:-1:-1;59583:15:0;;;;:6;:15;;;;;:20;-1:-1:-1;;;;;59583:20:0;;59424:257::o;59503:171::-;-1:-1:-1;59660:1:0;;59424:257;-1:-1:-1;59424:257:0:o;59503:171::-;59424:257;;;:::o;60663:113::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;60742:13:::1;:26:::0;;-1:-1:-1;;;;;;60742:26:0::1;-1:-1:-1::0;;;;;60742:26:0;;;::::1;::::0;;;::::1;::::0;;60663:113::o;67316:132::-;67381:13;67418:22;67432:7;67418:13;:22::i;68807:382::-;68908:37;68924:10;68936:8;;68908:15;:37::i;:::-;68900:78;;;;-1:-1:-1;;;68900:78:0;;18454:2:1;68900:78:0;;;18436:21:1;18493:2;18473:18;;;18466:30;18532;18512:18;;;18505:58;18580:18;;68900:78:0;18252:352:1;68900:78:0;69010:15;;68997:9;:28;;68989:63;;;;-1:-1:-1;;;68989:63:0;;;;;;;:::i;:::-;69071:13;;:27;69063:70;;;;-1:-1:-1;;;69063:70:0;;19513:2:1;69063:70:0;;;19495:21:1;19552:2;19532:18;;;19525:30;19591:32;19571:18;;;19564:60;19641:18;;69063:70:0;19311:354:1;58866:309:0;58392:13;;-1:-1:-1;;;;;58392:13:0;58378:10;:27;58370:59;;;;-1:-1:-1;;;58370:59:0;;19872:2:1;58370:59:0;;;19854:21:1;19911:2;19891:18;;;19884:30;-1:-1:-1;;;19930:18:1;;;19923:49;19989:18;;58370:59:0;19670:343:1;58370:59:0;58966:21:::1;58991:15:::0;;;:6:::1;:15;::::0;;;;59017:16;;-1:-1:-1;;;;;;59017:16:0::1;-1:-1:-1::0;;;;;59017:16:0;::::1;;::::0;;-1:-1:-1;;;;;59048:12:0;::::1;::::0;59044:76:::1;;59086:22:::0;;-1:-1:-1;;;;59086:22:0::1;-1:-1:-1::0;;;;;;;;59086:22:0;::::1;;;::::0;;59044:76:::1;59135:32;::::0;-1:-1:-1;;;;;20180:31:1;;20162:50;;-1:-1:-1;;;;;59135:32:0;::::1;::::0;59146:7;;59135:32:::1;::::0;20150:2:1;20135:18;59135:32:0::1;;;;;;;58955:220;58866:309:::0;;;:::o;67908:109::-;29193:11;;-1:-1:-1;;;;;29193:11:0;29179:10;:25;29171:52;;;;-1:-1:-1;;;29171:52:0;;;;;;;:::i;:::-;67982:13:::1;:27:::0;67908:109::o;60084:198::-;60169:4;-1:-1:-1;;;;;;60193:41:0;;-1:-1:-1;;;60193:41:0;;:81;;;60238:36;60262:11;60238:23;:36::i;37880:127::-;37945:4;37969:16;;;:7;:16;;;;;;-1:-1:-1;;;;;37969:16:0;:30;;;37880:127::o;42049:174::-;42124:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;42124:29:0;-1:-1:-1;;;;;42124:29:0;;;;;;;;:24;;42178:23;42124:24;42178:14;:23::i;:::-;-1:-1:-1;;;;;42169:46:0;;;;;;;;;;;42049:174;;:::o;70131:590::-;70238:10;;47434;:17;70217;;70233:1;70217:17;:::i;:::-;:31;;70208:58;;;;-1:-1:-1;;;70208:58:0;;20687:2:1;70208:58:0;;;20669:21:1;20726:2;20706:18;;;20699:30;-1:-1:-1;;;20745:18:1;;;20738:43;20798:18;;70208:58:0;20485:337:1;70208:58:0;70289:16;70297:7;70289;:16::i;:::-;70288:17;70280:50;;;;-1:-1:-1;;;70280:50:0;;21029:2:1;70280:50:0;;;21011:21:1;21068:2;21048:18;;;21041:30;-1:-1:-1;;;21087:18:1;;;21080:50;21147:18;;70280:50:0;20827:344:1;70280:50:0;70343:22;70349:6;70357:7;70343:5;:22::i;:::-;70393:30;;;;;;;;-1:-1:-1;70393:30:0;;;70401:15;70393:30;;;;;;;70418:4;70393:30;;;;;;70376:14;;;:5;:14;;;;;;:47;;;;-1:-1:-1;;;;;;70376:47:0;-1:-1:-1;;;;;70376:47:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;70376:47:0;;;;;;;;;;;70439:27;;-1:-1:-1;;;;;21368:32:1;;21350:51;;21417:18;;;21410:34;;;70439:27:0;;21323:18:1;70439:27:0;;;;;;;70477:41;70490:7;70499:18;:7;:16;:18::i;:::-;70477:12;:41::i;:::-;70559:1;70543:13;47434:10;:17;;47346:113;70543:13;:17;70539:173;;;70605:14;;70633:12;;70605:46;;70587:12;;-1:-1:-1;;;;;70605:14:0;;70633:12;70587;70605:46;70587:12;70605:46;70633:12;70605:14;:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70586:65;;;70674:7;70666:34;;;;-1:-1:-1;;;70666:34:0;;21657:2:1;70666:34:0;;;21639:21:1;21696:2;21676:18;;;21669:30;-1:-1:-1;;;21715:18:1;;;21708:44;21769:18;;70666:34:0;21455:338:1;24053:723:0;24109:13;24330:5;24339:1;24330:10;24326:53;;-1:-1:-1;;24357:10:0;;;;;;;;;;;;-1:-1:-1;;;24357:10:0;;;;;24053:723::o;24326:53::-;24404:5;24389:12;24445:78;24452:9;;24445:78;;24478:8;;;;:::i;:::-;;-1:-1:-1;24501:10:0;;-1:-1:-1;24509:2:0;24501:10;;:::i;:::-;;;24445:78;;;24533:19;24565:6;-1:-1:-1;;;;;24555:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24555:17:0;;24533:39;;24583:154;24590:10;;24583:154;;24617:11;24627:1;24617:11;;:::i;:::-;;-1:-1:-1;24686:10:0;24694:2;24686:5;:10;:::i;:::-;24673:24;;:2;:24;:::i;:::-;24660:39;;24643:6;24650;24643:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;24643:56:0;;;;;;;;-1:-1:-1;24714:11:0;24723:2;24714:11;;:::i;:::-;;;24583:154;;61817:190;61942:4;61995;61966:25;61979:5;61986:4;61966:12;:25::i;:::-;:33;;61817:190;-1:-1:-1;;;;61817:190:0:o;38174:348::-;38267:4;38292:16;38300:7;38292;:16::i;:::-;38284:73;;;;-1:-1:-1;;;38284:73:0;;22647:2:1;38284:73:0;;;22629:21:1;22686:2;22666:18;;;22659:30;22725:34;22705:18;;;22698:62;-1:-1:-1;;;22776:18:1;;;22769:42;22828:19;;38284:73:0;22445:408:1;38284:73:0;38368:13;38384:23;38399:7;38384:14;:23::i;:::-;38368:39;;38437:5;-1:-1:-1;;;;;38426:16:0;:7;-1:-1:-1;;;;;38426:16:0;;:51;;;;38470:7;-1:-1:-1;;;;;38446:31:0;:20;38458:7;38446:11;:20::i;:::-;-1:-1:-1;;;;;38446:31:0;;38426:51;:87;;;-1:-1:-1;;;;;;35266:25:0;;;35242:4;35266:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;38481:32;35145:164;41166:765;41325:4;-1:-1:-1;;;;;41298:31:0;:23;41313:7;41298:14;:23::i;:::-;-1:-1:-1;;;;;41298:31:0;;41290:85;;;;-1:-1:-1;;;41290:85:0;;23060:2:1;41290:85:0;;;23042:21:1;23099:2;23079:18;;;23072:30;23138:34;23118:18;;;23111:62;-1:-1:-1;;;23189:18:1;;;23182:39;23238:19;;41290:85:0;22858:405:1;41290:85:0;-1:-1:-1;;;;;41394:16:0;;41386:65;;;;-1:-1:-1;;;41386:65:0;;23470:2:1;41386:65:0;;;23452:21:1;23509:2;23489:18;;;23482:30;23548:34;23528:18;;;23521:62;-1:-1:-1;;;23599:18:1;;;23592:34;23643:19;;41386:65:0;23268:400:1;41386:65:0;41464:39;41485:4;41491:2;41495:7;41464:20;:39::i;:::-;41568:29;41585:1;41589:7;41568:8;:29::i;:::-;-1:-1:-1;;;;;41610:15:0;;;;;;:9;:15;;;;;:20;;41629:1;;41610:15;:20;;41629:1;;41610:20;:::i;:::-;;;;-1:-1:-1;;;;;;;41641:13:0;;;;;;:9;:13;;;;;:18;;41658:1;;41641:13;:18;;41658:1;;41641:18;:::i;:::-;;;;-1:-1:-1;;41670:16:0;;;;:7;:16;;;;;:21;;-1:-1:-1;;;;;;41670:21:0;-1:-1:-1;;;;;41670:21:0;;;;;;;;;;41707:8;;;:24;41703:168;;41759:8;;41773:85;;;;;;23847:25:1;;;-1:-1:-1;;;;;23908:32:1;;;23888:18;;;;23881:60;;;;41773:85:0;;;;;;;;;;23820:18:1;;;;41773:85:0;;;;;;;-1:-1:-1;;;;;41773:85:0;-1:-1:-1;;;41773:85:0;;;41759:100;;:8;;;;;:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41703:168;41915:7;41911:2;-1:-1:-1;;;;;41896:27:0;41905:4;-1:-1:-1;;;;;41896:27:0;;;;;;;;;;;41166:765;;;:::o;56061:275::-;56118:20;56130:7;56118:11;:20::i;:::-;56195:19;;;;:10;:19;;;;;56189:33;;;;;:::i;:::-;:38;;-1:-1:-1;56185:144:0;;56251:19;;;;:10;:19;;;;;56244:26;;;:::i;:::-;56292:25;;;;:16;:25;;;;;56285:32;56061:275::o;55381:93::-;55446:9;:20;55458:8;55446:9;:20;:::i;53060:357::-;53122:16;53153:19;53175:17;53185:6;53175:9;:17::i;:::-;53153:39;;53209:24;53250:11;-1:-1:-1;;;;;53236:26:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53236:26:0;;53209:53;;53278:9;53273:112;53297:11;53293:1;:15;53273:112;;;53343:30;53363:6;53371:1;53343:19;:30::i;:::-;53330:7;53338:1;53330:10;;;;;;;;:::i;:::-;;;;;;;;;;:43;53310:3;;;;:::i;:::-;;;;53273:112;;;-1:-1:-1;53402:7:0;53060:357;-1:-1:-1;;;53060:357:0:o;42365:315::-;42520:8;-1:-1:-1;;;;;42511:17:0;:5;-1:-1:-1;;;;;42511:17:0;;42503:55;;;;-1:-1:-1;;;42503:55:0;;26650:2:1;42503:55:0;;;26632:21:1;26689:2;26669:18;;;26662:30;26728:27;26708:18;;;26701:55;26773:18;;42503:55:0;26448:349:1;42503:55:0;-1:-1:-1;;;;;42569:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;42569:46:0;;;;;;;;;;42631:41;;540::1;;;42631::0;;513:18:1;42631:41:0;;;;;;;;42365:315;;;:::o;29638:242::-;-1:-1:-1;;;;;29715:24:0;;29707:68;;;;-1:-1:-1;;;29707:68:0;;27004:2:1;29707:68:0;;;26986:21:1;27043:2;27023:18;;;27016:30;27082:33;27062:18;;;27055:61;27133:18;;29707:68:0;26802:355:1;29707:68:0;29813:11;;;29791:46;;-1:-1:-1;;;;;29791:46:0;;;;29813:11;;;29791:46;;;29848:11;:24;;-1:-1:-1;;;;;;29848:24:0;-1:-1:-1;;;;;29848:24:0;;;;;;;;;;29638:242::o;37252:315::-;37409:28;37419:4;37425:2;37429:7;37409:9;:28::i;:::-;37456:48;37479:4;37485:2;37489:7;37498:5;37456:22;:48::i;:::-;37448:111;;;;-1:-1:-1;;;37448:111:0;;;;;;;:::i;54053:565::-;54116:13;54150:16;54158:7;54150;:16::i;:::-;54142:76;;;;-1:-1:-1;;;54142:76:0;;27783:2:1;54142:76:0;;;27765:21:1;27822:2;27802:18;;;27795:30;27861:34;27841:18;;;27834:62;-1:-1:-1;;;27912:18:1;;;27905:45;27967:19;;54142:76:0;27581:411:1;54142:76:0;54231:23;54257:19;;;:10;:19;;;;;54231:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54393:9;54387:23;54414:1;54387:28;54383:228;;-1:-1:-1;;54432:9:0;;;;;;;;;-1:-1:-1;54432:9:0;;;54053:565;-1:-1:-1;54053:565:0:o;54383:228::-;54575:9;54586;54558:39;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54544:54;;;54053:565;;;:::o;54383:228::-;54131:487;54053:565;;;:::o;46706:224::-;46808:4;-1:-1:-1;;;;;;46832:50:0;;-1:-1:-1;;;46832:50:0;;:90;;;46886:36;46910:11;46886:23;:36::i;39858:382::-;-1:-1:-1;;;;;39938:16:0;;39930:61;;;;-1:-1:-1;;;39930:61:0;;29224:2:1;39930:61:0;;;29206:21:1;;;29243:18;;;29236:30;29302:34;29282:18;;;29275:62;29354:18;;39930:61:0;29022:356:1;39930:61:0;40011:16;40019:7;40011;:16::i;:::-;40010:17;40002:58;;;;-1:-1:-1;;;40002:58:0;;29585:2:1;40002:58:0;;;29567:21:1;29624:2;29604:18;;;29597:30;29663;29643:18;;;29636:58;29711:18;;40002:58:0;29383:352:1;40002:58:0;40073:45;40102:1;40106:2;40110:7;40073:20;:45::i;:::-;-1:-1:-1;;;;;40131:13:0;;;;;;:9;:13;;;;;:18;;40148:1;;40131:13;:18;;40148:1;;40131:18;:::i;:::-;;;;-1:-1:-1;;40160:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;40160:21:0;-1:-1:-1;;;;;40160:21:0;;;;;;;;40199:33;;40160:16;;;40199:33;;40160:16;;40199:33;39858:382;;:::o;54953:207::-;55045:16;55053:7;55045;:16::i;:::-;55037:73;;;;-1:-1:-1;;;55037:73:0;;29942:2:1;55037:73:0;;;29924:21:1;29981:2;29961:18;;;29954:30;30020:34;30000:18;;;29993:62;-1:-1:-1;;;30071:18:1;;;30064:42;30123:19;;55037:73:0;29740:408:1;55037:73:0;55121:19;;;;:10;:19;;;;;:31;55143:9;55121:19;:31;:::i;62369:701::-;62452:7;62495:4;62452:7;62510:523;62534:5;:12;62530:1;:16;62510:523;;;62568:20;62591:5;62597:1;62591:8;;;;;;;;:::i;:::-;;;;;;;62568:31;;62634:12;62618;:28;62614:408;;62771:44;;;;;;30310:19:1;;;30345:12;;;30338:28;;;30382:12;;62771:44:0;;;;;;;;;;;;62761:55;;;;;;62746:70;;62614:408;;;62961:44;;;;;;30310:19:1;;;30345:12;;;30338:28;;;30382:12;;62961:44:0;;;;;;;;;;;;62951:55;;;;;;62936:70;;62614:408;-1:-1:-1;62548:3:0;;;;:::i;:::-;;;;62510:523;;60290:365;60433:45;60460:4;60466:2;60470:7;60433:26;:45::i;:::-;60503:2;-1:-1:-1;;;;;60495:10:0;:4;-1:-1:-1;;;;;60495:10:0;;;:48;;;;-1:-1:-1;60541:1:0;60509:15;;;:6;:15;;;;;:20;-1:-1:-1;;;;;60509:20:0;:34;;60495:48;60491:157;;;60567:15;;;;:6;:15;;;;;;;;60560:22;;-1:-1:-1;;;;;;60560:22:0;;;60602:34;20162:50:1;;;60567:15:0;;60602:34;;20135:18:1;60602:34:0;20018:200:1;40469:360:0;40529:13;40545:23;40560:7;40545:14;:23::i;:::-;40529:39;;40581:48;40602:5;40617:1;40621:7;40581:20;:48::i;:::-;40670:29;40687:1;40691:7;40670:8;:29::i;:::-;-1:-1:-1;;;;;40712:16:0;;;;;;:9;:16;;;;;:21;;40732:1;;40712:16;:21;;40732:1;;40712:21;:::i;:::-;;;;-1:-1:-1;;40751:16:0;;;;:7;:16;;;;;;40744:23;;-1:-1:-1;;;;;;40744:23:0;;;40785:36;40759:7;;40751:16;-1:-1:-1;;;;;40785:36:0;;;;;40751:16;;40785:36;40518:311;40469:360;:::o;43245:799::-;43400:4;-1:-1:-1;;;;;43421:13:0;;15532:19;:23;43417:620;;43457:72;;-1:-1:-1;;;43457:72:0;;-1:-1:-1;;;;;43457:36:0;;;;;:72;;14024:10;;43508:4;;43514:7;;43523:5;;43457:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43457:72:0;;;;;;;;-1:-1:-1;;43457:72:0;;;;;;;;;;;;:::i;:::-;;;43453:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43699:6;:13;43716:1;43699:18;43695:272;;43742:60;;-1:-1:-1;;;43742:60:0;;;;;;;:::i;43695:272::-;43917:6;43911:13;43902:6;43898:2;43894:15;43887:38;43453:529;-1:-1:-1;;;;;;43580:51:0;-1:-1:-1;;;43580:51:0;;-1:-1:-1;43573:58:0;;43417:620;-1:-1:-1;44021:4:0;43245:799;;;;;;:::o;32122:305::-;32224:4;-1:-1:-1;;;;;;32261:40:0;;-1:-1:-1;;;32261:40:0;;:105;;-1:-1:-1;;;;;;;32318:48:0;;-1:-1:-1;;;32318:48:0;32261:105;:158;;;-1:-1:-1;;;;;;;;;;28768:40:0;;;32383:36;28659:157;48382:589;-1:-1:-1;;;;;48588:18:0;;48584:187;;48623:40;48655:7;49798:10;:17;;49771:24;;;;:15;:24;;;;;:44;;;49826:24;;;;;;;;;;;;49694:164;48623:40;48584:187;;;48693:2;-1:-1:-1;;;;;48685:10:0;:4;-1:-1:-1;;;;;48685:10:0;;48681:90;;48712:47;48745:4;48751:7;48712:32;:47::i;:::-;-1:-1:-1;;;;;48785:16:0;;48781:183;;48818:45;48855:7;48818:36;:45::i;48781:183::-;48891:4;-1:-1:-1;;;;;48885:10:0;:2;-1:-1:-1;;;;;48885:10:0;;48881:83;;48912:40;48940:2;48944:7;48912:27;:40::i;50485:988::-;50751:22;50801:1;50776:22;50793:4;50776:16;:22::i;:::-;:26;;;;:::i;:::-;50813:18;50834:26;;;:17;:26;;;;;;50751:51;;-1:-1:-1;50967:28:0;;;50963:328;;-1:-1:-1;;;;;51034:18:0;;51012:19;51034:18;;;:12;:18;;;;;;;;:34;;;;;;;;;51085:30;;;;;;:44;;;51202:30;;:17;:30;;;;;:43;;;50963:328;-1:-1:-1;51387:26:0;;;;:17;:26;;;;;;;;51380:33;;;-1:-1:-1;;;;;51431:18:0;;;;;:12;:18;;;;;:34;;;;;;;51424:41;50485:988::o;51768:1079::-;52046:10;:17;52021:22;;52046:21;;52066:1;;52046:21;:::i;:::-;52078:18;52099:24;;;:15;:24;;;;;;52472:10;:26;;52021:46;;-1:-1:-1;52099:24:0;;52021:46;;52472:26;;;;;;:::i;:::-;;;;;;;;;52450:48;;52536:11;52511:10;52522;52511:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;52616:28;;;:15;:28;;;;;;;:41;;;52788:24;;;;;52781:31;52823:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;51839:1008;;;51768:1079;:::o;49272:221::-;49357:14;49374:20;49391:2;49374:16;:20::i;:::-;-1:-1:-1;;;;;49405:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;49450:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;49272:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:1:o;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1919:254;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2178:160::-;2243:20;;2299:13;;2292:21;2282:32;;2272:60;;2328:1;2325;2318:12;2343:180;2399:6;2452:2;2440:9;2431:7;2427:23;2423:32;2420:52;;;2468:1;2465;2458:12;2420:52;2491:26;2507:9;2491:26;:::i;2528:367::-;2591:8;2601:6;2655:3;2648:4;2640:6;2636:17;2632:27;2622:55;;2673:1;2670;2663:12;2622:55;-1:-1:-1;2696:20:1;;-1:-1:-1;;;;;2728:30:1;;2725:50;;;2771:1;2768;2761:12;2725:50;2808:4;2800:6;2796:17;2784:29;;2868:3;2861:4;2851:6;2848:1;2844:14;2836:6;2832:27;2828:38;2825:47;2822:67;;;2885:1;2882;2875:12;2822:67;2528:367;;;;;:::o;2900:505::-;2995:6;3003;3011;3064:2;3052:9;3043:7;3039:23;3035:32;3032:52;;;3080:1;3077;3070:12;3032:52;3116:9;3103:23;3093:33;;3177:2;3166:9;3162:18;3149:32;-1:-1:-1;;;;;3196:6:1;3193:30;3190:50;;;3236:1;3233;3226:12;3190:50;3275:70;3337:7;3328:6;3317:9;3313:22;3275:70;:::i;:::-;2900:505;;3364:8;;-1:-1:-1;3249:96:1;;-1:-1:-1;;;;2900:505:1:o;3592:328::-;3669:6;3677;3685;3738:2;3726:9;3717:7;3713:23;3709:32;3706:52;;;3754:1;3751;3744:12;3706:52;3777:29;3796:9;3777:29;:::i;:::-;3767:39;;3825:38;3859:2;3848:9;3844:18;3825:38;:::i;:::-;3815:48;;3910:2;3899:9;3895:18;3882:32;3872:42;;3592:328;;;;;:::o;3925:343::-;3992:6;4000;4053:2;4041:9;4032:7;4028:23;4024:32;4021:52;;;4069:1;4066;4059:12;4021:52;4105:9;4092:23;4082:33;;4165:2;4154:9;4150:18;4137:32;4213:5;4209:2;4198:21;4191:5;4188:32;4178:60;;4234:1;4231;4224:12;4178:60;4257:5;4247:15;;;3925:343;;;;;:::o;4621:186::-;4680:6;4733:2;4721:9;4712:7;4708:23;4704:32;4701:52;;;4749:1;4746;4739:12;4701:52;4772:29;4791:9;4772:29;:::i;4812:511::-;4907:6;4915;4923;4976:2;4964:9;4955:7;4951:23;4947:32;4944:52;;;4992:1;4989;4982:12;4944:52;5015:29;5034:9;5015:29;:::i;:::-;5005:39;;5095:2;5084:9;5080:18;5067:32;-1:-1:-1;;;;;5114:6:1;5111:30;5108:50;;;5154:1;5151;5144:12;5328:127;5389:10;5384:3;5380:20;5377:1;5370:31;5420:4;5417:1;5410:15;5444:4;5441:1;5434:15;5460:632;5525:5;-1:-1:-1;;;;;5596:2:1;5588:6;5585:14;5582:40;;;5602:18;;:::i;:::-;5677:2;5671:9;5645:2;5731:15;;-1:-1:-1;;5727:24:1;;;5753:2;5723:33;5719:42;5707:55;;;5777:18;;;5797:22;;;5774:46;5771:72;;;5823:18;;:::i;:::-;5863:10;5859:2;5852:22;5892:6;5883:15;;5922:6;5914;5907:22;5962:3;5953:6;5948:3;5944:16;5941:25;5938:45;;;5979:1;5976;5969:12;5938:45;6029:6;6024:3;6017:4;6009:6;6005:17;5992:44;6084:1;6077:4;6068:6;6060;6056:19;6052:30;6045:41;;;;5460:632;;;;;:::o;6097:451::-;6166:6;6219:2;6207:9;6198:7;6194:23;6190:32;6187:52;;;6235:1;6232;6225:12;6187:52;6275:9;6262:23;-1:-1:-1;;;;;6300:6:1;6297:30;6294:50;;;6340:1;6337;6330:12;6294:50;6363:22;;6416:4;6408:13;;6404:27;-1:-1:-1;6394:55:1;;6445:1;6442;6435:12;6394:55;6468:74;6534:7;6529:2;6516:16;6511:2;6507;6503:11;6468:74;:::i;6553:841::-;6684:6;6692;6700;6708;6716;6769:2;6757:9;6748:7;6744:23;6740:32;6737:52;;;6785:1;6782;6775:12;6737:52;6821:9;6808:23;6798:33;;6882:2;6871:9;6867:18;6854:32;-1:-1:-1;;;;;6946:2:1;6938:6;6935:14;6932:34;;;6962:1;6959;6952:12;6932:34;7001:70;7063:7;7054:6;7043:9;7039:22;7001:70;:::i;:::-;7090:8;;-1:-1:-1;6975:96:1;-1:-1:-1;7178:2:1;7163:18;;7150:32;;-1:-1:-1;7194:16:1;;;7191:36;;;7223:1;7220;7213:12;7191:36;;7262:72;7326:7;7315:8;7304:9;7300:24;7262:72;:::i;:::-;6553:841;;;;-1:-1:-1;6553:841:1;;-1:-1:-1;7353:8:1;;7236:98;6553:841;-1:-1:-1;;;6553:841:1:o;7399:632::-;7570:2;7622:21;;;7692:13;;7595:18;;;7714:22;;;7541:4;;7570:2;7793:15;;;;7767:2;7752:18;;;7541:4;7836:169;7850:6;7847:1;7844:13;7836:169;;;7911:13;;7899:26;;7980:15;;;;7945:12;;;;7872:1;7865:9;7836:169;;;-1:-1:-1;8022:3:1;;7399:632;-1:-1:-1;;;;;;7399:632:1:o;8442:254::-;8507:6;8515;8568:2;8556:9;8547:7;8543:23;8539:32;8536:52;;;8584:1;8581;8574:12;8536:52;8607:29;8626:9;8607:29;:::i;:::-;8597:39;;8655:35;8686:2;8675:9;8671:18;8655:35;:::i;:::-;8645:45;;8442:254;;;;;:::o;8886:667::-;8981:6;8989;8997;9005;9058:3;9046:9;9037:7;9033:23;9029:33;9026:53;;;9075:1;9072;9065:12;9026:53;9098:29;9117:9;9098:29;:::i;:::-;9088:39;;9146:38;9180:2;9169:9;9165:18;9146:38;:::i;:::-;9136:48;;9231:2;9220:9;9216:18;9203:32;9193:42;;9286:2;9275:9;9271:18;9258:32;-1:-1:-1;;;;;9305:6:1;9302:30;9299:50;;;9345:1;9342;9335:12;9299:50;9368:22;;9421:4;9413:13;;9409:27;-1:-1:-1;9399:55:1;;9450:1;9447;9440:12;9399:55;9473:74;9539:7;9534:2;9521:16;9516:2;9512;9508:11;9473:74;:::i;:::-;9463:84;;;8886:667;;;;;;;:::o;9558:426::-;9634:6;9642;9650;9703:2;9691:9;9682:7;9678:23;9674:32;9671:52;;;9719:1;9716;9709:12;9671:52;9755:9;9742:23;9732:33;;9784:38;9818:2;9807:9;9803:18;9784:38;:::i;:::-;9774:48;;9872:2;9861:9;9857:18;9844:32;-1:-1:-1;;;;;9909:5:1;9905:30;9898:5;9895:41;9885:69;;9950:1;9947;9940:12;9885:69;9973:5;9963:15;;;9558:426;;;;;:::o;9989:260::-;10057:6;10065;10118:2;10106:9;10097:7;10093:23;10089:32;10086:52;;;10134:1;10131;10124:12;10086:52;10157:29;10176:9;10157:29;:::i;:::-;10147:39;;10205:38;10239:2;10228:9;10224:18;10205:38;:::i;10254:380::-;10333:1;10329:12;;;;10376;;;10397:61;;10451:4;10443:6;10439:17;10429:27;;10397:61;10504:2;10496:6;10493:14;10473:18;10470:38;10467:161;;10550:10;10545:3;10541:20;10538:1;10531:31;10585:4;10582:1;10575:15;10613:4;10610:1;10603:15;11879:338;12081:2;12063:21;;;12120:2;12100:18;;;12093:30;-1:-1:-1;;;12154:2:1;12139:18;;12132:44;12208:2;12193:18;;11879:338::o;12583:346::-;12785:2;12767:21;;;12824:2;12804:18;;;12797:30;-1:-1:-1;;;12858:2:1;12843:18;;12836:52;12920:2;12905:18;;12583:346::o;13295:289::-;13426:3;13464:6;13458:13;13480:66;13539:6;13534:3;13527:4;13519:6;13515:17;13480:66;:::i;:::-;13562:16;;;;;13295:289;-1:-1:-1;;13295:289:1:o;13589:413::-;13791:2;13773:21;;;13830:2;13810:18;;;13803:30;13869:34;13864:2;13849:18;;13842:62;-1:-1:-1;;;13935:2:1;13920:18;;13913:47;13992:3;13977:19;;13589:413::o;16941:127::-;17002:10;16997:3;16993:20;16990:1;16983:31;17033:4;17030:1;17023:15;17057:4;17054:1;17047:15;20223:127;20284:10;20279:3;20275:20;20272:1;20265:31;20315:4;20312:1;20305:15;20339:4;20336:1;20329:15;20355:125;20420:9;;;20441:10;;;20438:36;;;20454:18;;:::i;21798:135::-;21837:3;21858:17;;;21855:43;;21878:18;;:::i;:::-;-1:-1:-1;21925:1:1;21914:13;;21798:135::o;21938:127::-;21999:10;21994:3;21990:20;21987:1;21980:31;22030:4;22027:1;22020:15;22054:4;22051:1;22044:15;22070:120;22110:1;22136;22126:35;;22141:18;;:::i;:::-;-1:-1:-1;22175:9:1;;22070:120::o;22195:128::-;22262:9;;;22283:11;;;22280:37;;;22297:18;;:::i;22328:112::-;22360:1;22386;22376:35;;22391:18;;:::i;:::-;-1:-1:-1;22425:9:1;;22328:112::o;24370:545::-;24472:2;24467:3;24464:11;24461:448;;;24508:1;24533:5;24529:2;24522:17;24578:4;24574:2;24564:19;24648:2;24636:10;24632:19;24629:1;24625:27;24619:4;24615:38;24684:4;24672:10;24669:20;24666:47;;;-1:-1:-1;24707:4:1;24666:47;24762:2;24757:3;24753:12;24750:1;24746:20;24740:4;24736:31;24726:41;;24817:82;24835:2;24828:5;24825:13;24817:82;;;24880:17;;;24861:1;24850:13;24817:82;;;24821:3;;;24370:545;;;:::o;25091:1352::-;25217:3;25211:10;-1:-1:-1;;;;;25236:6:1;25233:30;25230:56;;;25266:18;;:::i;:::-;25295:97;25385:6;25345:38;25377:4;25371:11;25345:38;:::i;:::-;25339:4;25295:97;:::i;:::-;25447:4;;25511:2;25500:14;;25528:1;25523:663;;;;26230:1;26247:6;26244:89;;;-1:-1:-1;26299:19:1;;;26293:26;26244:89;-1:-1:-1;;25048:1:1;25044:11;;;25040:24;25036:29;25026:40;25072:1;25068:11;;;25023:57;26346:81;;25493:944;;25523:663;24317:1;24310:14;;;24354:4;24341:18;;-1:-1:-1;;25559:20:1;;;25677:236;25691:7;25688:1;25685:14;25677:236;;;25780:19;;;25774:26;25759:42;;25872:27;;;;25840:1;25828:14;;;;25707:19;;25677:236;;;25681:3;25941:6;25932:7;25929:19;25926:201;;;26002:19;;;25996:26;-1:-1:-1;;26085:1:1;26081:14;;;26097:3;26077:24;26073:37;26069:42;26054:58;26039:74;;25926:201;-1:-1:-1;;;;;26173:1:1;26157:14;;;26153:22;26140:36;;-1:-1:-1;25091:1352:1:o;27162:414::-;27364:2;27346:21;;;27403:2;27383:18;;;27376:30;27442:34;27437:2;27422:18;;27415:62;-1:-1:-1;;;27508:2:1;27493:18;;27486:48;27566:3;27551:19;;27162:414::o;27997:1020::-;28173:3;28202:1;28235:6;28229:13;28265:36;28291:9;28265:36;:::i;:::-;28320:1;28337:18;;;28364:133;;;;28511:1;28506:356;;;;28330:532;;28364:133;-1:-1:-1;;28397:24:1;;28385:37;;28470:14;;28463:22;28451:35;;28442:45;;;-1:-1:-1;28364:133:1;;28506:356;28537:6;28534:1;28527:17;28567:4;28612:2;28609:1;28599:16;28637:1;28651:165;28665:6;28662:1;28659:13;28651:165;;;28743:14;;28730:11;;;28723:35;28786:16;;;;28680:10;;28651:165;;;28655:3;;;28845:6;28840:3;28836:16;28829:23;;28330:532;;;;;28893:6;28887:13;28909:68;28968:8;28963:3;28956:4;28948:6;28944:17;28909:68;:::i;:::-;28993:18;;27997:1020;-1:-1:-1;;;;27997:1020:1:o;30619:489::-;-1:-1:-1;;;;;30888:15:1;;;30870:34;;30940:15;;30935:2;30920:18;;30913:43;30987:2;30972:18;;30965:34;;;31035:3;31030:2;31015:18;;31008:31;;;30813:4;;31056:46;;31082:19;;31074:6;31056:46;:::i;:::-;31048:54;30619:489;-1:-1:-1;;;;;;30619:489:1:o;31113:249::-;31182:6;31235:2;31223:9;31214:7;31210:23;31206:32;31203:52;;;31251:1;31248;31241:12;31203:52;31283:9;31277:16;31302:30;31326:5;31302:30;:::i;31367:127::-;31428:10;31423:3;31419:20;31416:1;31409:31;31459:4;31456:1;31449:15;31483:4;31480:1;31473:15

ipfs://2dc19192d79b1141db09812e9071dd8d15b0d5c480af32f110a563bfbae1471a