Token Golden Token

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * 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.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
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 Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle 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++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

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

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

/**
 * @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://consensys.net/diligence/blog/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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

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

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

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

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

        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 overridden 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 token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @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 from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {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 an {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 Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

contract APAsoulbound is Ownable, ERC721 {
    uint256 public TotalSupply;
    mapping(address => bool) public IsAdmin;
    ERC721 public immutable APA_CONTRACT;

    error TokenIsSoulbound();
    error Unauthorized();

    constructor(string memory name_, string memory symbol_, address _apaAddress) ERC721(name_, symbol_) Ownable()
    {
        APA_CONTRACT = ERC721(_apaAddress);
    }

    function setAdmin (address _adminAddress, bool _permission) external onlyOwner {
        IsAdmin[_adminAddress] = _permission;
    }

    function mint(uint _tokenID, address _recipent) external {
        if(!IsAdmin[msg.sender]) revert Unauthorized();

        TotalSupply++;
        _mint(_recipent, _tokenID);
    }

    function batchMint(uint [] calldata _tokenIDS,  address _recipent) external {
        if(!IsAdmin[msg.sender]) revert Unauthorized();
        uint256 length = _tokenIDS.length;
        for (uint index ; index < length; ) {
            TotalSupply++;
            _mint(_recipent, _tokenIDS[index]);

            unchecked {
                ++index;
            }
        }
    }

    function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721){
        if (from != address(0)) revert TokenIsSoulbound();
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
    }

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

interface ApaRarity {
    function getRaritiesBatch(uint[] calldata tokenIds) external view returns (uint[] memory rarities);
    function getRarity(uint tokenId) external view returns (uint);

}

contract GoldenToken is Ownable, ERC721 {
    ERC721 public immutable APA_CONTRACT;
    ApaRarity public immutable APA_RARITY;
    APAsoulbound public immutable APA_SOULBOUND;
    uint256 public immutable COLLECTION_SIZE = 10000;
    uint256 immutable NULL_TOKENID = 10047;
    uint256 immutable FIESTA_TOKEN = 5;
    uint256 public immutable PUBLIC_MAX_MINTABLE_PER_TX = 5;

    bool public OpenApaBurning;
    bool public OpenWhitelistSale;
    uint256 public WhitelistSaleStartDate;
    uint256 public publicTicketSaleCost;
    uint256 public WhitelistPeriod;

    bytes32 public wlMerkleRoot;
    mapping(address => uint256) public wlRedeemed;

    uint256 public nextTokenId;
    address public exchanger;
    mapping(uint256 => uint256) public tokenRarity;
    string public baseURI;

    error Unauthorized();
    error TicketsMintedOut();
    error CostsNotCovered();
    error PublicSaleHasntStarted();
    error WhitelistSaleHasntStarted();
    error AlreadyClaimed();
    error MaxMintLimitExceeded();
    event GoldenTokenClaimed(uint apaTokenId, uint rarity, uint goldenTokenId);

    constructor(string memory name_, string memory symbol_, address _apaAddress, address _apaRarityAddress,  address _apaSoulboundAddress)
        ERC721(name_, symbol_)
    {
        APA_CONTRACT = ERC721(_apaAddress);
        WhitelistPeriod = 2 hours ;
        publicTicketSaleCost = 999;
        APA_RARITY = ApaRarity(_apaRarityAddress);
        APA_SOULBOUND = APAsoulbound(_apaSoulboundAddress);
    }

    modifier burnAllowed {
      require(OpenApaBurning);
      _;
    }

    function setExchanger(address newExchanger) public onlyOwner {
        exchanger = newExchanger;
    }

    function setBaseURI(string calldata _baseURI) external onlyOwner {
        baseURI = _baseURI;
    }

    function authorizeAPABurning(bool _allow) external onlyOwner {
        OpenApaBurning = _allow;
    }

    function authorizeWhitelistSale(bool _allow) external onlyOwner {
        OpenWhitelistSale = _allow;
        if (_allow == true) {
            OpenApaBurning = false;
            WhitelistSaleStartDate = block.timestamp;
        }
    }

    function setPublicTicketSaleCost(uint256 _ticketCost) external onlyOwner {
        publicTicketSaleCost = _ticketCost;
    }

    function setWhitelistPeriod(uint256 _period) external onlyOwner {
        WhitelistPeriod = _period;
    }

    function setWhitelistMerkleRoot (bytes32 _merkleRoot) external onlyOwner {
        wlMerkleRoot = _merkleRoot;
    }

    function withdraw (address payable recipient) external onlyOwner {
        recipient.transfer(address(this).balance);
    }

    function adminMint (address _recipient, uint256 _tokenType, uint256 _amount) external onlyOwner {
        if (_amount + nextTokenId > COLLECTION_SIZE) {
            revert TicketsMintedOut();
        }

        for (uint index ; index < _amount; ) {
            _mint(_recipient, nextTokenId);
            tokenRarity[nextTokenId] = _tokenType; // fiesta
            unchecked {
                ++index;
            }
            emit GoldenTokenClaimed(NULL_TOKENID, _tokenType, nextTokenId++);
        }
    }

    function emergencyRescue(uint[] calldata tokenIds, address _target) external onlyOwner {
        uint len = tokenIds.length;
        for(uint i; i < len;) {
            APA_CONTRACT.transferFrom(address(this),_target,tokenIds[i]);
            unchecked {
                ++i;
            }
        }    
    }

    function getGoldenTokenWithApaOnChainRarity(uint256 tokenId, bool _mintSoulbound) external burnAllowed{
        APA_CONTRACT.transferFrom(msg.sender, address(this), tokenId);
        _mint(msg.sender, nextTokenId);
        if (_mintSoulbound) {
            APA_SOULBOUND.mint(tokenId, msg.sender);
        }
        uint rarity = APA_RARITY.getRarity(tokenId);
        tokenRarity[nextTokenId] = rarity;
        emit GoldenTokenClaimed(tokenId,rarity,nextTokenId++);
    }

    function getGoldenTokenWithApaOnChainRarityMultiple(uint256[] calldata tokenIds, bool _mintSoulbound)
        external burnAllowed
    {
        uint256 tokenIdLen = tokenIds.length;
        uint[] memory rarities = APA_RARITY.getRaritiesBatch(tokenIds);
        for (uint256 i; i < tokenIdLen;) {
            uint256 tokenId = tokenIds[i];
            uint256 rarity = rarities[i];
            APA_CONTRACT.transferFrom(msg.sender, address(this), tokenId);
            _mint(msg.sender, nextTokenId);
            tokenRarity[nextTokenId] = rarity;
            unchecked {
                ++i;
            }
            emit GoldenTokenClaimed(tokenId, rarity, nextTokenId++);
        }

        if (_mintSoulbound) {
                APA_SOULBOUND.batchMint(tokenIds, msg.sender);
        }
    }

    function getGoldenTokenWithAvaxPublic(uint256 _amount) external payable {
        if (_amount > PUBLIC_MAX_MINTABLE_PER_TX ) { 
            revert MaxMintLimitExceeded();
        }
        if (block.timestamp <  WhitelistSaleStartDate + WhitelistPeriod) {
            revert PublicSaleHasntStarted();
        }

        if (msg.value < publicTicketSaleCost * _amount) {
            revert CostsNotCovered();
        }

        if (_amount + nextTokenId > COLLECTION_SIZE) {
            revert TicketsMintedOut();
        }
        for (uint index ; index < _amount; ) {
            _mint(msg.sender, nextTokenId);
            tokenRarity[nextTokenId] = FIESTA_TOKEN; // fiesta
            unchecked {
                ++index;
            }
            emit GoldenTokenClaimed(NULL_TOKENID,FIESTA_TOKEN,nextTokenId++);
        }
    }

    function getGoldenTokenWithAvaxWhitelist(uint256 _amount, uint256 _totalGiven, bytes32[] calldata _proof ) external payable{
        if (!OpenWhitelistSale) {
            revert WhitelistSaleHasntStarted();
        }

        if (msg.value < publicTicketSaleCost * _amount) {
            revert CostsNotCovered();
        }

        if (wlRedeemed[msg.sender] + _amount > _totalGiven) {
            revert AlreadyClaimed();
        }

        if (_amount + nextTokenId > COLLECTION_SIZE) {
            revert Unauthorized();
        }

        if (!MerkleProof.verify(_proof, wlMerkleRoot, keccak256(abi.encodePacked(msg.sender, _totalGiven)))) {
            revert Unauthorized();
        }

        wlRedeemed[msg.sender] += _amount;
        for (uint index ; index < _amount; ) {
            _mint(msg.sender, nextTokenId);
            tokenRarity[nextTokenId] = FIESTA_TOKEN; // fiesta
            unchecked {
                ++index;
            }
            emit GoldenTokenClaimed(NULL_TOKENID,FIESTA_TOKEN,nextTokenId++);
        }
    }

    function exchange(uint256 tokenId) external {
        if (msg.sender != exchanger) revert Unauthorized();
        _burn(tokenId);
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        uint256 rarity = tokenRarity[tokenId];
        return string(bytes.concat(bytes(baseURI), bytes(_toString(rarity))));
    }

    function _toString(uint256 value) internal pure returns (string memory) {
        //slither-disable-next-line incorrect-equality
        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;
            //slither-disable-next-line weak-prng
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"address","name":"_apaAddress","type":"address"},{"internalType":"address","name":"_apaRarityAddress","type":"address"},{"internalType":"address","name":"_apaSoulboundAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyClaimed","type":"error"},{"inputs":[],"name":"CostsNotCovered","type":"error"},{"inputs":[],"name":"MaxMintLimitExceeded","type":"error"},{"inputs":[],"name":"PublicSaleHasntStarted","type":"error"},{"inputs":[],"name":"TicketsMintedOut","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"WhitelistSaleHasntStarted","type":"error"},{"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":false,"internalType":"uint256","name":"apaTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rarity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"goldenTokenId","type":"uint256"}],"name":"GoldenTokenClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":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"},{"inputs":[],"name":"APA_CONTRACT","outputs":[{"internalType":"contract ERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"APA_RARITY","outputs":[{"internalType":"contract ApaRarity","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"APA_SOULBOUND","outputs":[{"internalType":"contract APAsoulbound","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"COLLECTION_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OpenApaBurning","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OpenWhitelistSale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PUBLIC_MAX_MINTABLE_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WhitelistPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WhitelistSaleStartDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_tokenType","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"adminMint","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":"bool","name":"_allow","type":"bool"}],"name":"authorizeAPABurning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_allow","type":"bool"}],"name":"authorizeWhitelistSale","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":"tokenIds","type":"uint256[]"},{"internalType":"address","name":"_target","type":"address"}],"name":"emergencyRescue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exchange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchanger","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bool","name":"_mintSoulbound","type":"bool"}],"name":"getGoldenTokenWithApaOnChainRarity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bool","name":"_mintSoulbound","type":"bool"}],"name":"getGoldenTokenWithApaOnChainRarityMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"getGoldenTokenWithAvaxPublic","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_totalGiven","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"getGoldenTokenWithAvaxWhitelist","outputs":[],"stateMutability":"payable","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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicTicketSaleCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":"newExchanger","type":"address"}],"name":"setExchanger","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ticketCost","type":"uint256"}],"name":"setPublicTicketSaleCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setWhitelistMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_period","type":"uint256"}],"name":"setWhitelistPeriod","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":"tokenRarity","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":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"recipient","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wlMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"wlRedeemed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000880fe52c6bc4ffffb92d6c03858c97807a900691000000000000000000000000d50afd237b15963196bd9ab7378c79ea66a6425b000000000000000000000000c82e2717d5f1c6dc74db00c28a9b2afd3eb85c71000000000000000000000000000000000000000000000000000000000000000c476f6c64656e20546f6b656e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024754000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Golden Token
Arg [1] : symbol_ (string): GT
Arg [2] : _apaAddress (address): 0x880fe52c6bc4ffffb92d6c03858c97807a900691
Arg [3] : _apaRarityAddress (address): 0xd50afd237b15963196bd9ab7378c79ea66a6425b
Arg [4] : _apaSoulboundAddress (address): 0xc82e2717d5f1c6dc74db00c28a9b2afd3eb85c71

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 000000000000000000000000880fe52c6bc4ffffb92d6c03858c97807a900691
Arg [3] : 000000000000000000000000d50afd237b15963196bd9ab7378c79ea66a6425b
Arg [4] : 000000000000000000000000c82e2717d5f1c6dc74db00c28a9b2afd3eb85c71
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [6] : 476f6c64656e20546f6b656e0000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [8] : 4754000000000000000000000000000000000000000000000000000000000000

64648:7853:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67370:524;;;;;;;;;;-1:-1:-1;67370:524:0;;;;;:::i;:::-;;:::i;:::-;;47052:305;;;;;;;;;;-1:-1:-1;47052:305:0;;;;;:::i;:::-;;:::i;:::-;;;1158:14:1;;1151:22;1133:41;;1121:2;1106:18;47052:305:0;;;;;;;;47980:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;49492:171::-;;;;;;;;;;-1:-1:-1;49492:171:0;;;;;:::i;:::-;;:::i;:::-;;;2361:42:1;2349:55;;;2331:74;;2319:2;2304:18;49492:171:0;2185:226:1;49010:416:0;;;;;;;;;;-1:-1:-1;49010:416:0;;;;;:::i;:::-;;:::i;65070:29::-;;;;;;;;;;-1:-1:-1;65070:29:0;;;;;;;;;;;50192:335;;;;;;;;;;-1:-1:-1;50192:335:0;;;;;:::i;:::-;;:::i;66861:126::-;;;;;;;;;;-1:-1:-1;66861:126:0;;;;;:::i;:::-;;:::i;50598:185::-;;;;;;;;;;-1:-1:-1;50598:185:0;;;;;:::i;:::-;;:::i;65352:24::-;;;;;;;;;;-1:-1:-1;65352:24:0;;;;;;;;67237:125;;;;;;;;;;-1:-1:-1;67237:125:0;;;;;:::i;:::-;;:::i;71488:138::-;;;;;;;;;;-1:-1:-1;71488:138:0;;;;;:::i;:::-;;:::i;65231:27::-;;;;;;;;;;;;;;;;;;;3603:25:1;;;3591:2;3576:18;65231:27:0;3457:177:1;66389:102:0;;;;;;;;;;-1:-1:-1;66389:102:0;;;;;:::i;:::-;;:::i;64782:43::-;;;;;;;;;;;;;;;69540:856;;;;;;:::i;:::-;;:::i;66499:103::-;;;;;;;;;;-1:-1:-1;66499:103:0;;;;;:::i;:::-;;:::i;67902:317::-;;;;;;;;;;-1:-1:-1;67902:317:0;;;;;:::i;:::-;;:::i;47690:223::-;;;;;;;;;;-1:-1:-1;47690:223:0;;;;;:::i;:::-;;:::i;65265:45::-;;;;;;;;;;-1:-1:-1;65265:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;65436:21;;;;;;;;;;;;;:::i;47421:207::-;;;;;;;;;;-1:-1:-1;47421:207:0;;;;;:::i;:::-;;:::i;12136:103::-;;;;;;;;;;;;;:::i;65319:26::-;;;;;;;;;;;;;;;;65150:35;;;;;;;;;;;;;;;;11488:87;;;;;;;;;;-1:-1:-1;11534:7:0;11561:6;;;11488:87;;48149:104;;;;;;;;;;;;;:::i;68227:481::-;;;;;;;;;;-1:-1:-1;68227:481:0;;;;;:::i;:::-;;:::i;64695:36::-;;;;;;;;;;;;;;;49735:155;;;;;;;;;;-1:-1:-1;49735:155:0;;;;;:::i;:::-;;:::i;65383:46::-;;;;;;;;;;-1:-1:-1;65383:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;50854:322;;;;;;;;;;-1:-1:-1;50854:322:0;;;;;:::i;:::-;;:::i;67111:118::-;;;;;;;;;;-1:-1:-1;67111:118:0;;;;;:::i;:::-;;:::i;70404:1076::-;;;;;;:::i;:::-;;:::i;71634:216::-;;;;;;;;;;-1:-1:-1;71634:216:0;;;;;:::i;:::-;;:::i;66995:108::-;;;;;;;;;;-1:-1:-1;66995:108:0;;;;;:::i;:::-;;:::i;64832:48::-;;;;;;;;;;;;;;;66277:104;;;;;;;;;;-1:-1:-1;66277:104:0;;;;;:::i;:::-;;:::i;66610:243::-;;;;;;;;;;-1:-1:-1;66610:243:0;;;;;:::i;:::-;;:::i;64738:37::-;;;;;;;;;;;;;;;65192:30;;;;;;;;;;;;;;;;49961:164;;;;;;;;;;-1:-1:-1;49961:164:0;;;;;:::i;:::-;50082:25;;;;50058:4;50082:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;49961:164;65106:37;;;;;;;;;;;;;;;;64973:55;;;;;;;;;;;;;;;68716:816;;;;;;;;;;-1:-1:-1;68716:816:0;;;;;:::i;:::-;;:::i;12394:201::-;;;;;;;;;;-1:-1:-1;12394:201:0;;;;;:::i;:::-;;:::i;65037:26::-;;;;;;;;;;-1:-1:-1;65037:26:0;;;;;;;;67370:524;11374:13;:11;:13::i;:::-;67505:15:::1;67491:11;;67481:7;:21;;;;:::i;:::-;:39;67477:97;;;67544:18;;;;;;;;;;;;;;67477:97;67591:10;67586:301;67612:7;67604:5;:15;67586:301;;;67638:30;67644:10;67656:11;;67638:5;:30::i;:::-;67695:11;::::0;;67683:24:::1;::::0;;;:11:::1;:24;::::0;;;;:37;;;67861:13;;67774:7:::1;::::0;;::::1;::::0;67816:59:::1;::::0;67835:12:::1;::::0;67710:10;;67861:13;67695:11;67861:13:::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;67816:59:0::1;::::0;;11376:25:1;;;11432:2;11417:18;;11410:34;;;;11460:18;;;11453:34;11364:2;11349:18;67816:59:0::1;;;;;;;67586:301;;;;67370:524:::0;;;:::o;47052:305::-;47154:4;47191:40;;;47206:25;47191:40;;:105;;-1:-1:-1;47248:48:0;;;47263:33;47248:48;47191:105;:158;;;-1:-1:-1;45785:25:0;45770:40;;;;47313:36;47171:178;47052:305;-1:-1:-1;;47052:305:0:o;47980:100::-;48034:13;48067:5;48060:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47980:100;:::o;49492:171::-;49568:7;49588:23;49603:7;49588:14;:23::i;:::-;-1:-1:-1;49631:24:0;;;;:15;:24;;;;;;;;;49492:171::o;49010:416::-;49091:13;49107:23;49122:7;49107:14;:23::i;:::-;49091:39;;49155:5;49149:11;;:2;:11;;;49141:57;;;;;;;12142:2:1;49141:57:0;;;12124:21:1;12181:2;12161:18;;;12154:30;12220:34;12200:18;;;12193:62;12291:3;12271:18;;;12264:31;12312:19;;49141:57:0;;;;;;;;;10277:10;49233:21;;;;;:62;;-1:-1:-1;50082:25:0;;;50058:4;50082:25;;;:18;:25;;;;;;;;10277:10;50082:35;;;;;;;;;;49258:37;49211:173;;;;;;;12544:2:1;49211:173:0;;;12526:21:1;12583:2;12563:18;;;12556:30;12622:34;12602:18;;;12595:62;12693:31;12673:18;;;12666:59;12742:19;;49211:173:0;12342:425:1;49211:173:0;49397:21;49406:2;49410:7;49397:8;:21::i;:::-;49080:346;49010:416;;:::o;50192:335::-;50387:41;10277:10;50420:7;50387:18;:41::i;:::-;50379:99;;;;;;;12974:2:1;50379:99:0;;;12956:21:1;13013:2;12993:18;;;12986:30;13052:34;13032:18;;;13025:62;13123:15;13103:18;;;13096:43;13156:19;;50379:99:0;12772:409:1;50379:99:0;50491:28;50501:4;50507:2;50511:7;50491:9;:28::i;66861:126::-;11374:13;:11;:13::i;:::-;66945:20:::1;:34:::0;66861:126::o;50598:185::-;50736:39;50753:4;50759:2;50763:7;50736:39;;;;;;;;;;;;:16;:39::i;67237:125::-;11374:13;:11;:13::i;:::-;67313:41:::1;::::0;:18:::1;::::0;::::1;::::0;67332:21:::1;67313:41:::0;::::1;;;::::0;::::1;::::0;;;67332:21;67313:18;:41;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;67237:125:::0;:::o;71488:138::-;71561:9;;;;71547:10;:23;71543:50;;71579:14;;;;;;;;;;;;;;71543:50;71604:14;71610:7;71604:5;:14::i;:::-;71488:138;:::o;66389:102::-;11374:13;:11;:13::i;:::-;66465:7:::1;:18;66475:8:::0;;66465:7;:18:::1;:::i;69540:856::-:0;69637:26;69627:7;:36;69623:100;;;69689:22;;;;;;;;;;;;;;69623:100;69781:15;;69756:22;;:40;;;;:::i;:::-;69737:15;:59;69733:123;;;69820:24;;;;;;;;;;;;;;69733:123;69907:7;69884:20;;:30;;;;:::i;:::-;69872:9;:42;69868:99;;;69938:17;;;;;;;;;;;;;;69868:99;70007:15;69993:11;;69983:7;:21;;;;:::i;:::-;:39;69979:97;;;70046:18;;;;;;;;;;;;;;69979:97;70091:10;70086:303;70112:7;70104:5;:15;70086:303;;;70138:30;70144:10;70156:11;;70138:5;:30::i;:::-;70195:11;;;70183:24;;;;:11;:24;;;;;70210:12;70183:39;;;;70363:13;;70276:7;;;;;70318:59;;70337:12;;70363:13;;;:::i;:::-;;;;-1:-1:-1;70318:59:0;;;11376:25:1;;;11432:2;11417:18;;11410:34;;;;11460:18;;;11453:34;11364:2;11349:18;70318:59:0;;;;;;;70086:303;;66499:103;11374:13;:11;:13::i;:::-;66571:14:::1;:23:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;66499:103::o;67902:317::-;11374:13;:11;:13::i;:::-;68011:8;68000::::1;68037:171;68053:3;68049:1;:7;68037:171;;;68074:12;:25;;;68108:4;68114:7;68122:8;;68131:1;68122:11;;;;;;;:::i;:::-;68074:60;::::0;;::::1;::::0;;;;;;15997:42:1;16066:15;;;68074:60:0::1;::::0;::::1;16048:34:1::0;16118:15;;;;16098:18;;;16091:43;-1:-1:-1;68122:11:0::1;::::0;;::::1;;;16150:18:1::0;;;16143:34;15960:18;;68074:60:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;68178:3;;;;;68037:171;;;;67989:230;67902:317:::0;;;:::o;47690:223::-;47762:7;52577:16;;;:7;:16;;;;;;;;;47826:56;;;;;;;16390:2:1;47826:56:0;;;16372:21:1;16429:2;16409:18;;;16402:30;16468:26;16448:18;;;16441:54;16512:18;;47826:56:0;16188:348:1;65436:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;47421:207::-;47493:7;47521:19;;;47513:73;;;;;;;16743:2:1;47513:73:0;;;16725:21:1;16782:2;16762:18;;;16755:30;16821:34;16801:18;;;16794:62;16892:11;16872:18;;;16865:39;16921:19;;47513:73:0;16541:405:1;47513:73:0;-1:-1:-1;47604:16:0;;;;;;:9;:16;;;;;;;47421:207::o;12136:103::-;11374:13;:11;:13::i;:::-;12201:30:::1;12228:1;12201:18;:30::i;:::-;12136:103::o:0;48149:104::-;48205:13;48238:7;48231:14;;;;;:::i;68227:481::-;66236:14;;;;66228:23;;;;;;68340:61:::1;::::0;;;;68366:10:::1;68340:61;::::0;::::1;16048:34:1::0;68386:4:0::1;16098:18:1::0;;;16091:43;16150:18;;;16143:34;;;68340:12:0::1;:25;;::::0;::::1;::::0;15960:18:1;;68340:61:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;68412:30;68418:10;68430:11;;68412:5;:30::i;:::-;68457:14;68453:86;;;68488:39;::::0;;;;::::1;::::0;::::1;17125:25:1::0;;;68516:10:0::1;17166:18:1::0;;;17159:83;68488:13:0::1;:18;;::::0;::::1;::::0;17098::1;;68488:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;68453:86;68563:29;::::0;;;;::::1;::::0;::::1;3603:25:1::0;;;68549:11:0::1;::::0;68563:10:::1;:20;;::::0;::::1;::::0;3576:18:1;;68563:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68615:11;::::0;;68603:24:::1;::::0;;;:11:::1;:24;::::0;;;;:33;;;68686:13;;68549:43;;-1:-1:-1;68652:48:0::1;::::0;68671:7;;68549:43;;68686:13:::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;68652:48:0::1;::::0;;11376:25:1;;;11432:2;11417:18;;11410:34;;;;11460:18;;;11453:34;11364:2;11349:18;68652:48:0::1;;;;;;;68329:379;68227:481:::0;;:::o;49735:155::-;49830:52;10277:10;49863:8;49873;49830:18;:52::i;50854:322::-;51028:41;10277:10;51061:7;51028:18;:41::i;:::-;51020:99;;;;;;;12974:2:1;51020:99:0;;;12956:21:1;13013:2;12993:18;;;12986:30;13052:34;13032:18;;;13025:62;13123:15;13103:18;;;13096:43;13156:19;;51020:99:0;12772:409:1;51020:99:0;51130:38;51144:4;51150:2;51154:7;51163:4;51130:13;:38::i;67111:118::-;11374:13;:11;:13::i;:::-;67195:12:::1;:26:::0;67111:118::o;70404:1076::-;70543:17;;;;;;;70538:85;;70584:27;;;;;;;;;;;;;;70538:85;70674:7;70651:20;;:30;;;;:::i;:::-;70639:9;:42;70635:99;;;70705:17;;;;;;;;;;;;;;70635:99;70761:10;70750:22;;;;:10;:22;;;;;;70785:11;;70750:32;;70775:7;;70750:32;:::i;:::-;:46;70746:102;;;70820:16;;;;;;;;;;;;;;70746:102;70888:15;70874:11;;70864:7;:21;;;;:::i;:::-;:39;70860:93;;;70927:14;;;;;;;;;;;;;;70860:93;70970:94;70989:6;;70970:94;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;70997:12:0;;71021:41;;17632:66:1;71038:10:0;17619:2:1;17615:15;17611:88;71021:41:0;;;17599:101:1;17716:12;;;17709:28;;;70997:12:0;;-1:-1:-1;17753:12:1;;;-1:-1:-1;71021:41:0;;;;;;;;;;;;71011:52;;;;;;70970:18;:94::i;:::-;70965:149;;71088:14;;;;;;;;;;;;;;70965:149;71137:10;71126:22;;;;:10;:22;;;;;:33;;71152:7;;71126:22;:33;;71152:7;;71126:33;:::i;:::-;;;;-1:-1:-1;71175:10:0;;-1:-1:-1;71170:303:0;71196:7;71188:5;:15;71170:303;;;71222:30;71228:10;71240:11;;71222:5;:30::i;:::-;71279:11;;;71267:24;;;;:11;:24;;;;;71294:12;71267:39;;;;71447:13;;71360:7;;;;;71402:59;;71421:12;;71447:13;;;:::i;:::-;;;;-1:-1:-1;71402:59:0;;;11376:25:1;;;11432:2;11417:18;;11410:34;;;;11460:18;;;11453:34;11364:2;11349:18;71402:59:0;;;;;;;71170:303;;71634:216;71725:14;71742:20;;;:11;:20;;;;;;71699:13;;71806:7;71822:17;71742:20;71822:9;:17::i;:::-;71787:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71773:69;;;71634:216;;;:::o;66995:108::-;11374:13;:11;:13::i;:::-;67070:15:::1;:25:::0;66995:108::o;66277:104::-;11374:13;:11;:13::i;:::-;66349:9:::1;:24:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;66277:104::o;66610:243::-;11374:13;:11;:13::i;:::-;66685:17:::1;:26:::0;;;::::1;;::::0;::::1;;::::0;;::::1;::::0;;;::::1;::::0;;;-1:-1:-1;66726:14:0;66722:124:::1;;66757:14;:22:::0;;;::::1;::::0;;66819:15:::1;66794:22;:40:::0;66610:243;:::o;68716:816::-;66236:14;;;;66228:23;;;;;;68936:37:::1;::::0;;;;68885:8;;68864:18:::1;::::0;68936:27:::1;:10;:27;::::0;::::1;::::0;:37:::1;::::0;68885:8;;;;68936:37:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;::::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;68911:62;;68989:9;68984:433;69004:10;69000:1;:14;68984:433;;;69032:15;69050:8;;69059:1;69050:11;;;;;;;:::i;:::-;;;;;;;69032:29;;69076:14;69093:8;69102:1;69093:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;69119:61:::1;::::0;;;;69145:10:::1;69119:61;::::0;::::1;16048:34:1::0;69165:4:0::1;16098:18:1::0;;;16091:43;16150:18;;;16143:34;;;69093:11:0;;-1:-1:-1;69119:25:0::1;:12;:25;::::0;::::1;::::0;15960:18:1;;69119:61:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;69195:30;69201:10;69213:11;;69195:5;:30::i;:::-;69252:11;::::0;;69240:24:::1;::::0;;;:11:::1;:24;::::0;;;;:33;;;69391:13;;69317:3:::1;::::0;;::::1;::::0;69355:50:::1;::::0;69374:7;;69267:6;;69391:13;69252:11;69391:13:::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;69355:50:0::1;::::0;;11376:25:1;;;11432:2;11417:18;;11410:34;;;;11460:18;;;11453:34;11364:2;11349:18;69355:50:0::1;;;;;;;69017:400;;68984:433;;;;69433:14;69429:96;;;69468:45;::::0;;;;:23:::1;:13;:23;::::0;::::1;::::0;:45:::1;::::0;69492:8;;;;69502:10:::1;::::0;69468:45:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;68853:679;;68716:816:::0;;;:::o;12394:201::-;11374:13;:11;:13::i;:::-;12483:22:::1;::::0;::::1;12475:73;;;::::0;::::1;::::0;;21071:2:1;12475:73:0::1;::::0;::::1;21053:21:1::0;21110:2;21090:18;;;21083:30;21149:34;21129:18;;;21122:62;21220:8;21200:18;;;21193:36;21246:19;;12475:73:0::1;20869:402:1::0;12475:73:0::1;12559:28;12578:8;12559:18;:28::i;11653:132::-:0;11534:7;11561:6;11717:23;11561:6;10277:10;11717:23;11709:68;;;;;;;21478:2:1;11709:68:0;;;21460:21:1;;;21497:18;;;21490:30;21556:34;21536:18;;;21529:62;21608:18;;11709:68:0;21276:356:1;54807:942:0;54887:16;;;54879:61;;;;;;;21839:2:1;54879:61:0;;;21821:21:1;;;21858:18;;;21851:30;21917:34;21897:18;;;21890:62;21969:18;;54879:61:0;21637:356:1;54879:61:0;52979:4;52577:16;;;:7;:16;;;;;;;;53003:31;54951:58;;;;;;;22200:2:1;54951:58:0;;;22182:21:1;22239:2;22219:18;;;22212:30;22278;22258:18;;;22251:58;22326:18;;54951:58:0;21998:352:1;54951:58:0;55022:48;55051:1;55055:2;55059:7;55068:1;55022:20;:48::i;:::-;52979:4;52577:16;;;:7;:16;;;;;;;;53003:31;55160:58;;;;;;;22200:2:1;55160:58:0;;;22182:21:1;22239:2;22219:18;;;22212:30;22278;22258:18;;;22251:58;22326:18;;55160:58:0;21998:352:1;55160:58:0;55567:13;;;;;;;:9;:13;;;;;;;;:18;;55584:1;55567:18;;;55609:16;;;:7;:16;;;;;;:21;;;;;;;;55648:33;55617:7;;55567:13;;55648:33;;55567:13;;55648:33;67313:41:::1;67237:125:::0;:::o;59311:135::-;52979:4;52577:16;;;:7;:16;;;;;;;;59385:53;;;;;;;16390:2:1;59385:53:0;;;16372:21:1;16429:2;16409:18;;;16402:30;16468:26;16448:18;;;16441:54;16512:18;;59385:53:0;16188:348:1;58590:174:0;58665:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;58719:23;58665:24;58719:14;:23::i;:::-;58710:46;;;;;;;;;;;;58590:174;;:::o;53209:264::-;53302:4;53319:13;53335:23;53350:7;53335:14;:23::i;:::-;53319:39;;53388:5;53377:16;;:7;:16;;;:52;;;-1:-1:-1;50082:25:0;;;;50058:4;50082:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;53397:32;53377:87;;;;53457:7;53433:31;;:20;53445:7;53433:11;:20::i;:::-;:31;;;53377:87;53369:96;53209:264;-1:-1:-1;;;;53209:264:0:o;57208:1263::-;57367:4;57340:31;;:23;57355:7;57340:14;:23::i;:::-;:31;;;57332:81;;;;;;;22557:2:1;57332:81:0;;;22539:21:1;22596:2;22576:18;;;22569:30;22635:34;22615:18;;;22608:62;22706:7;22686:18;;;22679:35;22731:19;;57332:81:0;22355:401:1;57332:81:0;57432:16;;;57424:65;;;;;;;22963:2:1;57424:65:0;;;22945:21:1;23002:2;22982:18;;;22975:30;23041:34;23021:18;;;23014:62;23112:6;23092:18;;;23085:34;23136:19;;57424:65:0;22761:400:1;57424:65:0;57502:42;57523:4;57529:2;57533:7;57542:1;57502:20;:42::i;:::-;57674:4;57647:31;;:23;57662:7;57647:14;:23::i;:::-;:31;;;57639:81;;;;;;;22557:2:1;57639:81:0;;;22539:21:1;22596:2;22576:18;;;22569:30;22635:34;22615:18;;;22608:62;22706:7;22686:18;;;22679:35;22731:19;;57639:81:0;22355:401:1;57639:81:0;57792:24;;;;:15;:24;;;;;;;;57785:31;;;;;;;;;;58268:15;;;;;;:9;:15;;;;;:20;;;;;;58303:13;;;;;;;;;:18;;57785:31;58303:18;;;58343:16;;;:7;:16;;;;;;:21;;;;;;;;;;58382:27;;57808:7;;58382:27;;;49080:346;49010:416;;:::o;56088:783::-;56148:13;56164:23;56179:7;56164:14;:23::i;:::-;56148:39;;56200:51;56221:5;56236:1;56240:7;56249:1;56200:20;:51::i;:::-;56364:23;56379:7;56364:14;:23::i;:::-;56435:24;;;;:15;:24;;;;;;;;56428:31;;;;;;;;;;56680:16;;;;;:9;:16;;;;;:21;;;;;;56730:16;;;:7;:16;;;;;;56723:23;;;;;;;56764:36;56356:31;;-1:-1:-1;56451:7:0;;56764:36;;56435:24;;56764:36;67313:41:::1;67237:125:::0;:::o;12755:191::-;12829:16;12848:6;;;12865:17;;;;;;;;;;12898:40;;12848:6;;;;;;;12898:40;;12829:16;12898:40;12818:128;12755:191;:::o;58907:315::-;59062:8;59053:17;;:5;:17;;;59045:55;;;;;;;23368:2:1;59045:55:0;;;23350:21:1;23407:2;23387:18;;;23380:30;23446:27;23426:18;;;23419:55;23491:18;;59045:55:0;23166:349:1;59045:55:0;59111:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;59173:41;;1133::1;;;59173::0;;1106:18:1;59173:41:0;;;;;;;58907:315;;;:::o;52057:313::-;52213:28;52223:4;52229:2;52233:7;52213:9;:28::i;:::-;52260:47;52283:4;52289:2;52293:7;52302:4;52260:22;:47::i;:::-;52252:110;;;;;;;23722:2:1;52252:110:0;;;23704:21:1;23761:2;23741:18;;;23734:30;23800:34;23780:18;;;23773:62;23871:20;23851:18;;;23844:48;23909:19;;52252:110:0;23520:414:1;1190:190:0;1315:4;1368;1339:25;1352:5;1359:4;1339:12;:25::i;:::-;:33;;1190:190;-1:-1:-1;;;;1190:190:0:o;71858:640::-;71915:13;72001:5;72010:1;72001:10;71997:53;;-1:-1:-1;;72028:10:0;;;;;;;;;;;;;;;;;;71858:640::o;71997:53::-;72075:5;72060:12;72116:78;72123:9;;72116:78;;72149:8;;;;:::i;:::-;;-1:-1:-1;72172:10:0;;-1:-1:-1;72180:2:0;72172:10;;:::i;:::-;;;72116:78;;;72204:19;72236:6;72226:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72226:17:0;;72204:39;;72254:205;72261:10;;72254:205;;72288:11;72298:1;72288:11;;:::i;:::-;;-1:-1:-1;72408:10:0;72416:2;72408:5;:10;:::i;:::-;72395:24;;:2;:24;:::i;:::-;72382:39;;72365:6;72372;72365:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;72436:11:0;72445:2;72436:11;;:::i;:::-;;;72254:205;;61595:410;61785:1;61773:9;:13;61769:229;;;61807:18;;;;61803:87;;61846:15;;;;;;;:9;:15;;;;;:28;;61865:9;;61846:15;:28;;61865:9;;61846:28;:::i;:::-;;;;-1:-1:-1;;61803:87:0;61908:16;;;;61904:83;;61945:13;;;;;;;:9;:13;;;;;:26;;61962:9;;61945:13;:26;;61962:9;;61945:26;:::i;:::-;;;;-1:-1:-1;;61595:410:0;;;;:::o;60010:853::-;60164:4;60185:13;;;21965:19;:23;60181:675;;60221:71;;;;;:36;;;;;;:71;;10277:10;;60272:4;;60278:7;;60287:4;;60221:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60221:71:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;60217:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60462:6;:13;60479:1;60462:18;60458:328;;60505:60;;;;;23722:2:1;60505:60:0;;;23704:21:1;23761:2;23741:18;;;23734:30;23800:34;23780:18;;;23773:62;23871:20;23851:18;;;23844:48;23909:19;;60505:60:0;23520:414:1;60458:328:0;60736:6;60730:13;60721:6;60717:2;60713:15;60706:38;60217:584;60343:51;;60353:41;60343:51;;-1:-1:-1;60336:58:0;;60181:675;-1:-1:-1;60840:4:0;60010:853;;;;;;:::o;2057:296::-;2140:7;2183:4;2140:7;2198:118;2222:5;:12;2218:1;:16;2198:118;;;2271:33;2281:12;2295:5;2301:1;2295:8;;;;;;;;:::i;:::-;;;;;;;2271:9;:33::i;:::-;2256:48;-1:-1:-1;2236:3:0;;;;:::i;:::-;;;;2198:118;;;-1:-1:-1;2333:12:0;2057:296;-1:-1:-1;;;2057:296:0:o;9097:149::-;9160:7;9191:1;9187;:5;:51;;9322:13;9416:15;;;9452:4;9445:15;;;9499:4;9483:21;;9187:51;;;9322:13;9416:15;;;9452:4;9445:15;;;9499:4;9483:21;;9195:20;9180:58;9097:149;-1:-1:-1;;;9097:149:0:o;14:154:1:-;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;173:383;250:6;258;266;319:2;307:9;298:7;294:23;290:32;287:52;;;335:1;332;325:12;287:52;374:9;361:23;393:31;418:5;393:31;:::i;:::-;443:5;495:2;480:18;;467:32;;-1:-1:-1;546:2:1;531:18;;;518:32;;173:383;-1:-1:-1;;;173:383:1:o;561:177::-;646:66;639:5;635:78;628:5;625:89;615:117;;728:1;725;718:12;743:245;801:6;854:2;842:9;833:7;829:23;825:32;822:52;;;870:1;867;860:12;822:52;909:9;896:23;928:30;952:5;928:30;:::i;1185:250::-;1270:1;1280:113;1294:6;1291:1;1288:13;1280:113;;;1370:11;;;1364:18;1351:11;;;1344:39;1316:2;1309:10;1280:113;;;-1:-1:-1;;1427:1:1;1409:16;;1402:27;1185:250::o;1440:330::-;1482:3;1520:5;1514:12;1547:6;1542:3;1535:19;1563:76;1632:6;1625:4;1620:3;1616:14;1609:4;1602:5;1598:16;1563:76;:::i;:::-;1684:2;1672:15;1689:66;1668:88;1659:98;;;;1759:4;1655:109;;1440:330;-1:-1:-1;;1440:330:1:o;1775:220::-;1924:2;1913:9;1906:21;1887:4;1944:45;1985:2;1974:9;1970:18;1962:6;1944:45;:::i;2000:180::-;2059:6;2112:2;2100:9;2091:7;2087:23;2083:32;2080:52;;;2128:1;2125;2118:12;2080:52;-1:-1:-1;2151:23:1;;2000:180;-1:-1:-1;2000:180:1:o;2416:315::-;2484:6;2492;2545:2;2533:9;2524:7;2520:23;2516:32;2513:52;;;2561:1;2558;2551:12;2513:52;2600:9;2587:23;2619:31;2644:5;2619:31;:::i;:::-;2669:5;2721:2;2706:18;;;;2693:32;;-1:-1:-1;;;2416:315:1:o;2736:456::-;2813:6;2821;2829;2882:2;2870:9;2861:7;2857:23;2853:32;2850:52;;;2898:1;2895;2888:12;2850:52;2937:9;2924:23;2956:31;2981:5;2956:31;:::i;:::-;3006:5;-1:-1:-1;3063:2:1;3048:18;;3035:32;3076:33;3035:32;3076:33;:::i;:::-;2736:456;;3128:7;;-1:-1:-1;;;3182:2:1;3167:18;;;;3154:32;;2736:456::o;3197:255::-;3264:6;3317:2;3305:9;3296:7;3292:23;3288:32;3285:52;;;3333:1;3330;3323:12;3285:52;3372:9;3359:23;3391:31;3416:5;3391:31;:::i;3639:592::-;3710:6;3718;3771:2;3759:9;3750:7;3746:23;3742:32;3739:52;;;3787:1;3784;3777:12;3739:52;3827:9;3814:23;3856:18;3897:2;3889:6;3886:14;3883:34;;;3913:1;3910;3903:12;3883:34;3951:6;3940:9;3936:22;3926:32;;3996:7;3989:4;3985:2;3981:13;3977:27;3967:55;;4018:1;4015;4008:12;3967:55;4058:2;4045:16;4084:2;4076:6;4073:14;4070:34;;;4100:1;4097;4090:12;4070:34;4145:7;4140:2;4131:6;4127:2;4123:15;4119:24;4116:37;4113:57;;;4166:1;4163;4156:12;4113:57;4197:2;4189:11;;;;;4219:6;;-1:-1:-1;3639:592:1;;-1:-1:-1;;;;3639:592:1:o;4488:160::-;4553:20;;4609:13;;4602:21;4592:32;;4582:60;;4638:1;4635;4628:12;4582:60;4488:160;;;:::o;4653:180::-;4709:6;4762:2;4750:9;4741:7;4737:23;4733:32;4730:52;;;4778:1;4775;4768:12;4730:52;4801:26;4817:9;4801:26;:::i;4838:367::-;4901:8;4911:6;4965:3;4958:4;4950:6;4946:17;4942:27;4932:55;;4983:1;4980;4973:12;4932:55;-1:-1:-1;5006:20:1;;5049:18;5038:30;;5035:50;;;5081:1;5078;5071:12;5035:50;5118:4;5110:6;5106:17;5094:29;;5178:3;5171:4;5161:6;5158:1;5154:14;5146:6;5142:27;5138:38;5135:47;5132:67;;;5195:1;5192;5185:12;5132:67;4838:367;;;;;:::o;5210:572::-;5305:6;5313;5321;5374:2;5362:9;5353:7;5349:23;5345:32;5342:52;;;5390:1;5387;5380:12;5342:52;5430:9;5417:23;5463:18;5455:6;5452:30;5449:50;;;5495:1;5492;5485:12;5449:50;5534:70;5596:7;5587:6;5576:9;5572:22;5534:70;:::i;:::-;5623:8;;-1:-1:-1;5508:96:1;-1:-1:-1;;5708:2:1;5693:18;;5680:32;5721:31;5680:32;5721:31;:::i;:::-;5771:5;5761:15;;;5210:572;;;;;:::o;6221:248::-;6286:6;6294;6347:2;6335:9;6326:7;6322:23;6318:32;6315:52;;;6363:1;6360;6353:12;6315:52;6399:9;6386:23;6376:33;;6428:35;6459:2;6448:9;6444:18;6428:35;:::i;:::-;6418:45;;6221:248;;;;;:::o;6720:315::-;6785:6;6793;6846:2;6834:9;6825:7;6821:23;6817:32;6814:52;;;6862:1;6859;6852:12;6814:52;6901:9;6888:23;6920:31;6945:5;6920:31;:::i;:::-;6970:5;-1:-1:-1;6994:35:1;7025:2;7010:18;;6994:35;:::i;7040:184::-;7092:77;7089:1;7082:88;7189:4;7186:1;7179:15;7213:4;7210:1;7203:15;7229:334;7300:2;7294:9;7356:2;7346:13;;7361:66;7342:86;7330:99;;7459:18;7444:34;;7480:22;;;7441:62;7438:88;;;7506:18;;:::i;:::-;7542:2;7535:22;7229:334;;-1:-1:-1;7229:334:1:o;7568:1167::-;7663:6;7671;7679;7687;7740:3;7728:9;7719:7;7715:23;7711:33;7708:53;;;7757:1;7754;7747:12;7708:53;7796:9;7783:23;7815:31;7840:5;7815:31;:::i;:::-;7865:5;-1:-1:-1;7889:2:1;7928:18;;;7915:32;7956:33;7915:32;7956:33;:::i;:::-;8008:7;-1:-1:-1;8062:2:1;8047:18;;8034:32;;-1:-1:-1;8117:2:1;8102:18;;8089:32;8140:18;8170:14;;;8167:34;;;8197:1;8194;8187:12;8167:34;8235:6;8224:9;8220:22;8210:32;;8280:7;8273:4;8269:2;8265:13;8261:27;8251:55;;8302:1;8299;8292:12;8251:55;8338:2;8325:16;8360:2;8356;8353:10;8350:36;;;8366:18;;:::i;:::-;8408:112;8516:2;8447:66;8440:4;8436:2;8432:13;8428:86;8424:95;8408:112;:::i;:::-;8395:125;;8543:2;8536:5;8529:17;8583:7;8578:2;8573;8569;8565:11;8561:20;8558:33;8555:53;;;8604:1;8601;8594:12;8555:53;8659:2;8654;8650;8646:11;8641:2;8634:5;8630:14;8617:45;8703:1;8698:2;8693;8686:5;8682:14;8678:23;8671:34;;8724:5;8714:15;;;;;7568:1167;;;;;;;:::o;8925:573::-;9029:6;9037;9045;9053;9106:2;9094:9;9085:7;9081:23;9077:32;9074:52;;;9122:1;9119;9112:12;9074:52;9158:9;9145:23;9135:33;;9215:2;9204:9;9200:18;9187:32;9177:42;;9270:2;9259:9;9255:18;9242:32;9297:18;9289:6;9286:30;9283:50;;;9329:1;9326;9319:12;9283:50;9368:70;9430:7;9421:6;9410:9;9406:22;9368:70;:::i;:::-;8925:573;;;;-1:-1:-1;9457:8:1;-1:-1:-1;;;;8925:573:1:o;9752:388::-;9820:6;9828;9881:2;9869:9;9860:7;9856:23;9852:32;9849:52;;;9897:1;9894;9887:12;9849:52;9936:9;9923:23;9955:31;9980:5;9955:31;:::i;:::-;10005:5;-1:-1:-1;10062:2:1;10047:18;;10034:32;10075:33;10034:32;10075:33;:::i;:::-;10127:7;10117:17;;;9752:388;;;;;:::o;10145:505::-;10237:6;10245;10253;10306:2;10294:9;10285:7;10281:23;10277:32;10274:52;;;10322:1;10319;10312:12;10274:52;10362:9;10349:23;10395:18;10387:6;10384:30;10381:50;;;10427:1;10424;10417:12;10381:50;10466:70;10528:7;10519:6;10508:9;10504:22;10466:70;:::i;:::-;10555:8;;-1:-1:-1;10440:96:1;-1:-1:-1;10609:35:1;;-1:-1:-1;10640:2:1;10625:18;;10609:35;:::i;:::-;10599:45;;10145:505;;;;;:::o;10655:184::-;10707:77;10704:1;10697:88;10804:4;10801:1;10794:15;10828:4;10825:1;10818:15;10844:125;10909:9;;;10930:10;;;10927:36;;;10943:18;;:::i;10974:195::-;11013:3;11044:66;11037:5;11034:77;11031:103;;11114:18;;:::i;:::-;-1:-1:-1;11161:1:1;11150:13;;10974:195::o;11498:437::-;11577:1;11573:12;;;;11620;;;11641:61;;11695:4;11687:6;11683:17;11673:27;;11641:61;11748:2;11740:6;11737:14;11717:18;11714:38;11711:218;;11785:77;11782:1;11775:88;11886:4;11883:1;11876:15;11914:4;11911:1;11904:15;11711:218;;11498:437;;;:::o;13312:545::-;13414:2;13409:3;13406:11;13403:448;;;13450:1;13475:5;13471:2;13464:17;13520:4;13516:2;13506:19;13590:2;13578:10;13574:19;13571:1;13567:27;13561:4;13557:38;13626:4;13614:10;13611:20;13608:47;;;-1:-1:-1;13649:4:1;13608:47;13704:2;13699:3;13695:12;13692:1;13688:20;13682:4;13678:31;13668:41;;13759:82;13777:2;13770:5;13767:13;13759:82;;;13822:17;;;13803:1;13792:13;13759:82;;;13763:3;;;13312:545;;;:::o;14093:1325::-;14217:18;14212:3;14209:27;14206:53;;;14239:18;;:::i;:::-;14268:94;14358:3;14318:38;14350:4;14344:11;14318:38;:::i;:::-;14312:4;14268:94;:::i;:::-;14388:1;14413:2;14408:3;14405:11;14430:1;14425:735;;;;15204:1;15221:3;15218:93;;;-1:-1:-1;15277:19:1;;;15264:33;15218:93;13999:66;13990:1;13986:11;;;13982:84;13978:89;13968:100;14074:1;14070:11;;;13965:117;15324:78;;14398:1014;;14425:735;13259:1;13252:14;;;13296:4;13283:18;;14470:66;14461:76;;;14621:9;14643:229;14657:7;14654:1;14651:14;14643:229;;;14746:19;;;14733:33;14718:49;;14853:4;14838:20;;;;14806:1;14794:14;;;;14673:12;14643:229;;;14647:3;14900;14891:7;14888:16;14885:219;;;15020:66;15014:3;15008;15005:1;15001:11;14997:21;14993:94;14989:99;14976:9;14971:3;14967:19;14954:33;14950:139;14942:6;14935:155;14885:219;;;15147:1;15141:3;15138:1;15134:11;15130:19;15124:4;15117:33;14398:1014;;14093:1325;;;:::o;15423:168::-;15496:9;;;15527;;15544:15;;;15538:22;;15524:37;15514:71;;15565:18;;:::i;15596:184::-;15648:77;15645:1;15638:88;15745:4;15742:1;15735:15;15769:4;15766:1;15759:15;17253:184;17323:6;17376:2;17364:9;17355:7;17351:23;17347:32;17344:52;;;17392:1;17389;17382:12;17344:52;-1:-1:-1;17415:16:1;;17253:184;-1:-1:-1;17253:184:1:o;17776:1078::-;17952:3;17981:1;18014:6;18008:13;18044:36;18070:9;18044:36;:::i;:::-;18099:1;18116:18;;;18143:191;;;;18348:1;18343:356;;;;18109:590;;18143:191;18191:66;18180:9;18176:82;18171:3;18164:95;18314:6;18307:14;18300:22;18292:6;18288:35;18283:3;18279:45;18272:52;;18143:191;;18343:356;18374:6;18371:1;18364:17;18404:4;18449:2;18446:1;18436:16;18474:1;18488:165;18502:6;18499:1;18496:13;18488:165;;;18580:14;;18567:11;;;18560:35;18623:16;;;;18517:10;;18488:165;;;18492:3;;;18682:6;18677:3;18673:16;18666:23;;18109:590;;;;;18730:6;18724:13;18746:68;18805:8;18800:3;18793:4;18785:6;18781:17;18746:68;:::i;:::-;18830:18;;17776:1078;-1:-1:-1;;;;17776:1078:1:o;18859:358::-;18959:6;18954:3;18947:19;18929:3;18989:66;18981:6;18978:78;18975:98;;;19069:1;19066;19059:12;18975:98;19105:6;19102:1;19098:14;19157:8;19150:5;19143:4;19138:3;19134:14;19121:45;19186:18;;;;19206:4;19182:29;;18859:358;-1:-1:-1;;;18859:358:1:o;19222:288::-;19411:2;19400:9;19393:21;19374:4;19431:73;19500:2;19489:9;19485:18;19477:6;19469;19431:73;:::i;19515:936::-;19610:6;19641:2;19684;19672:9;19663:7;19659:23;19655:32;19652:52;;;19700:1;19697;19690:12;19652:52;19733:9;19727:16;19762:18;19803:2;19795:6;19792:14;19789:34;;;19819:1;19816;19809:12;19789:34;19857:6;19846:9;19842:22;19832:32;;19902:7;19895:4;19891:2;19887:13;19883:27;19873:55;;19924:1;19921;19914:12;19873:55;19953:2;19947:9;19975:2;19971;19968:10;19965:36;;;19981:18;;:::i;:::-;20027:2;20024:1;20020:10;20010:20;;20050:28;20074:2;20070;20066:11;20050:28;:::i;:::-;20112:15;;;20182:11;;;20178:20;;;20143:12;;;;20210:19;;;20207:39;;;20242:1;20239;20232:12;20207:39;20266:11;;;;20286:135;20302:6;20297:3;20294:15;20286:135;;;20368:10;;20356:23;;20319:12;;;;20399;;;;20286:135;;;20440:5;19515:936;-1:-1:-1;;;;;;;;19515:936:1:o;20456:408::-;20673:2;20662:9;20655:21;20636:4;20693:73;20762:2;20751:9;20747:18;20739:6;20731;20693:73;:::i;:::-;20685:81;;20814:42;20806:6;20802:55;20797:2;20786:9;20782:18;20775:83;20456:408;;;;;;:::o;23939:184::-;23991:77;23988:1;23981:88;24088:4;24085:1;24078:15;24112:4;24109:1;24102:15;24128:120;24168:1;24194;24184:35;;24199:18;;:::i;:::-;-1:-1:-1;24233:9:1;;24128:120::o;24253:128::-;24320:9;;;24341:11;;;24338:37;;;24355:18;;:::i;24386:112::-;24418:1;24444;24434:35;;24449:18;;:::i;:::-;-1:-1:-1;24483:9:1;;24386:112::o;24503:512::-;24697:4;24726:42;24807:2;24799:6;24795:15;24784:9;24777:34;24859:2;24851:6;24847:15;24842:2;24831:9;24827:18;24820:43;;24899:6;24894:2;24883:9;24879:18;24872:34;24942:3;24937:2;24926:9;24922:18;24915:31;24963:46;25004:3;24993:9;24989:19;24981:6;24963:46;:::i;:::-;24955:54;24503:512;-1:-1:-1;;;;;;24503:512:1:o;25020:249::-;25089:6;25142:2;25130:9;25121:7;25117:23;25113:32;25110:52;;;25158:1;25155;25148:12;25110:52;25190:9;25184:16;25209:30;25233:5;25209:30;:::i

ipfs://8e4d1c2734ac44ec7cfd50754387f7e85071b2a8d039db94c86d867eae9e89d7