FTM Testnet

Fantom Animals (FANTAM)

Overview

TokenID

14

Total Transfers

-

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-

Other Info

TokenID: 14
Loading
Loading
Loading

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:
FantomAnimals
Compiler Version
v0.8.2+commit.661d1103
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

blockscan-logoblockscan-logoblockscan-logoIDE
/**
 *Submitted for verification at testnet.ftmscan.com on 2022-08-29
*/

// SPDX-License-Identifier: MIT

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.0;

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;

/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(account, totalReceived, released(account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        uint256 payment = _pendingPayment(account, totalReceived, released(token, account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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

pragma solidity ^0.8.0;

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

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

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

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

contract FantomAnimals is 
    ERC721Enumerable, 
    Ownable, 
    ReentrancyGuard, 
    PaymentSplitter 
{
    using Strings for uint256;
    using Counters for Counters.Counter;

    bytes32 public root;
    
    uint256 public maxSupply = 100;

    string public baseURI; 
    string public notRevealedUri = "ipfs://QmXA5ooR2eCj3k85WzG9gDPgjX6FJTZoczd85qEQebjKSK/";
    string public baseExtension = ".json";

    bool public paused = false;
    bool public revealed = true;
    bool public presaleM = false;
    bool public publicM = false;

    uint256 presaleAmountLimit = 10;
    mapping(address => uint256) public _presaleClaimed;

    uint256 _price = 200000000000000000000; // 200 FTM  
    uint256 _presalePrice = 150000000000000000000; // 150 FTM

    Counters.Counter private _tokenIds;

    uint256[] private _teamShares = [93, 7]; 
    address[] private _team = [
        0xBD6c17659777D3758996B51E805A7F7899872068 , // Treasury Account gets 93% of the total revenue
        0x309E506C6AE36290D4dE062ABF7A957a0d796e5B // Developer Account gets 7% of the total revenue
    ];

    constructor(string memory uri, bytes32 merkleroot)
        ERC721("Fantom Animals", "FANTAM")
        PaymentSplitter(_team, _teamShares) 
        ReentrancyGuard() 
    {
        root = merkleroot;
        setBaseURI(uri);
    }

    function setPrice(uint256 _newPrice) public onlyOwner {
    _price = _newPrice;
    }

    function setPresalePrice(uint256 _newPresalePrice) public onlyOwner {
    _presalePrice = _newPresalePrice;
    }

    function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
        baseURI = _tokenBaseURI;
    }

    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    function reveal() public onlyOwner {
        revealed = true;
    }

    function setMerkleRoot(bytes32 merkleroot) 
    onlyOwner 
    public 
    {
        root = merkleroot;
    }

    modifier onlyAccounts () {
        require(msg.sender == tx.origin, "Not allowed origin");
        _;
    }

    modifier isValidMerkleProof(bytes32[] calldata _proof) {
         require(MerkleProof.verify(
            _proof,
            root,
            keccak256(abi.encodePacked(msg.sender))
            ) == true, "Not allowed origin");
        _;
   }

    function togglePause() public onlyOwner {
        paused = !paused;
    }

    function togglePresale() public onlyOwner {
        presaleM = !presaleM;
    }

    function togglePublicSale() public onlyOwner {
        publicM = !publicM;
    }


    function presaleMint(address account, uint256 _amount, bytes32[] calldata _proof)
    external
    payable
    isValidMerkleProof(_proof)
    onlyAccounts
    {
        require(msg.sender == account,          "FantomAnimals: Not allowed");
        require(presaleM,                       "FantomAnimals: Presale is OFF");
        require(!paused,                        "FantomAnimals: Contract is paused");
        require(
            _amount <= presaleAmountLimit,      "FantomAnimals: You can't mint so much tokens");
        require(
            _presaleClaimed[msg.sender] + _amount <= presaleAmountLimit,  "FantomAnimals: You can't mint so much tokens");


        uint current = _tokenIds.current();

        require(
            current + _amount <= maxSupply,
            "FantomAnimals: max supply exceeded"
        );
        require(
            _presalePrice * _amount <= msg.value,
            "FantomAnimals: Not enough ethers sent"
        );
             
        _presaleClaimed[msg.sender] += _amount;

        for (uint i = 0; i < _amount; i++) {
            mintInternal();
        }
    }

    /// @dev only for test
    function testMint() external {
        mintInternal();
    }

    function publicSaleMint(uint256 _amount) 
    external 
    payable
    onlyAccounts
    {
        require(publicM, "FantomAnimals: PublicSale is OFF");
        require(!paused, "FantomAnimals: Contract is paused");
        require(_amount > 0, "FantomAnimals: zero amount");

        uint current = _tokenIds.current();

        require(
            current + _amount <= maxSupply,
            "FantomAnimals: Max supply exceeded"
        );
        require(
            _price * _amount <= msg.value,
            "FantomAnimals: Not enough ethers sent"
        );
        
        
        for (uint i = 0; i < _amount; i++) {
            mintInternal();
        }
    }

    function mintInternal() internal nonReentrant {
        _tokenIds.increment();

        uint256 tokenId = _tokenIds.current();
        _safeMint(msg.sender, tokenId);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );
        if (revealed == false) {
            return notRevealedUri;
        }

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

    function setBaseExtension(string memory _newBaseExtension)
        public
        onlyOwner
    {
        baseExtension = _newBaseExtension;
    }

    function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
        notRevealedUri = _notRevealedURI;
    }

    function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
    {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {
      tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
    }
    return tokenIds;
  }

}

Contract ABI

[{"inputs":[{"internalType":"string","name":"uri","type":"string"},{"internalType":"bytes32","name":"merkleroot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","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":[{"internalType":"address","name":"","type":"address"}],"name":"_presaleClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedUri","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"presaleM","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"presaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicM","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"publicSaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleroot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealedURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPresalePrice","type":"uint256"}],"name":"setPresalePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"testMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"togglePause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"togglePresale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"togglePublicSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View
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

Deployed Bytecode

0x6080604052600436106103035760003560e01c80638b83209b11610190578063c4ae3168116100dc578063da3ef23f11610095578063e985e9c51161006f578063e985e9c514610953578063ebf0c7171461099c578063f2c4ce1e146109b2578063f2fde38b146109d25761034c565b8063da3ef23f14610909578063e222c7f914610929578063e33b7de31461093e5761034c565b8063c4ae31681461083d578063c668286214610852578063c87b56dd14610867578063ce7c2ac214610887578063d5abeb01146108bd578063d79779b2146108d35761034c565b80639642ddaf11610149578063a45063c011610123578063a45063c0146107d4578063a475b5dd146107f5578063b3ab66b01461080a578063b88d4fde1461081d5761034c565b80639642ddaf146107695780639852595c1461077e578063a22cb465146107b45761034c565b80638b83209b146106b65780638cc4de19146106d65780638da5cb5b1461070357806391b7f5ed14610721578063954dc3e31461074157806395d89b41146107545761034c565b8063406072a91161024f57806355f804b3116102085780636c0360eb116101e25780636c0360eb1461064c57806370a0823114610661578063715018a6146106815780637cb64759146106965761034c565b806355f804b3146105f25780635c975abb146106125780636352211e1461062c5761034c565b8063406072a91461050057806342842e0e14610546578063438b63001461056657806348b75044146105935780634f6ccce7146105b357806351830227146105d35761034c565b806318160ddd116102bc5780632f745c59116102965780632f745c591461049657806334393743146104b65780633549345e146104cb5780633a98ef39146104eb5761034c565b806318160ddd14610437578063191655871461045657806323b872dd146104765761034c565b806301ffc9a71461035157806306fdde0314610386578063081812fc146103a8578063081c8c44146103e0578063095ea7b3146103f55780631798d58b146104175761034c565b3661034c577f6ef95f06320e7a25a04a175ca677b7052bdd97131872c2192525a629f51be77033604080516001600160a01b0390921682523460208301520160405180910390a1005b600080fd5b34801561035d57600080fd5b5061037161036c366004613065565b6109f2565b60405190151581526020015b60405180910390f35b34801561039257600080fd5b5061039b610a1f565b60405161037d9190613298565b3480156103b457600080fd5b506103c86103c336600461304d565b610ab1565b6040516001600160a01b03909116815260200161037d565b3480156103ec57600080fd5b5061039b610b4b565b34801561040157600080fd5b50610415610410366004612f80565b610bd9565b005b34801561042357600080fd5b506018546103719062010000900460ff1681565b34801561044357600080fd5b506008545b60405190815260200161037d565b34801561046257600080fd5b50610415610471366004612e42565b610cef565b34801561048257600080fd5b50610415610491366004612e96565b610e1d565b3480156104a257600080fd5b506104486104b1366004612f80565b610e4e565b3480156104c257600080fd5b50610415610ee4565b3480156104d757600080fd5b506104156104e636600461304d565b610f2d565b3480156104f757600080fd5b50600c54610448565b34801561050c57600080fd5b5061044861051b36600461309d565b6001600160a01b03918216600090815260126020908152604080832093909416825291909152205490565b34801561055257600080fd5b50610415610561366004612e96565b610f5c565b34801561057257600080fd5b50610586610581366004612e42565b610f77565b60405161037d9190613254565b34801561059f57600080fd5b506104156105ae36600461309d565b611035565b3480156105bf57600080fd5b506104486105ce36600461304d565b61121d565b3480156105df57600080fd5b5060185461037190610100900460ff1681565b3480156105fe57600080fd5b5061041561060d3660046130af565b6112be565b34801561061e57600080fd5b506018546103719060ff1681565b34801561063857600080fd5b506103c861064736600461304d565b6112ff565b34801561065857600080fd5b5061039b611376565b34801561066d57600080fd5b5061044861067c366004612e42565b611383565b34801561068d57600080fd5b5061041561140a565b3480156106a257600080fd5b506104156106b136600461304d565b611440565b3480156106c257600080fd5b506103c86106d136600461304d565b61146f565b3480156106e257600080fd5b506104486106f1366004612e42565b601a6020526000908152604090205481565b34801561070f57600080fd5b50600a546001600160a01b03166103c8565b34801561072d57600080fd5b5061041561073c36600461304d565b6114ad565b61041561074f366004612fab565b6114dc565b34801561076057600080fd5b5061039b6117b9565b34801561077557600080fd5b506104156117c8565b34801561078a57600080fd5b50610448610799366004612e42565b6001600160a01b03166000908152600f602052604090205490565b3480156107c057600080fd5b506104156107cf366004612f53565b6117d0565b3480156107e057600080fd5b50601854610371906301000000900460ff1681565b34801561080157600080fd5b506104156117db565b61041561081836600461304d565b611816565b34801561082957600080fd5b50610415610838366004612ed6565b6119c7565b34801561084957600080fd5b506104156119ff565b34801561085e57600080fd5b5061039b611a3d565b34801561087357600080fd5b5061039b61088236600461304d565b611a4a565b34801561089357600080fd5b506104486108a2366004612e42565b6001600160a01b03166000908152600e602052604090205490565b3480156108c957600080fd5b5061044860145481565b3480156108df57600080fd5b506104486108ee366004612e42565b6001600160a01b031660009081526011602052604090205490565b34801561091557600080fd5b506104156109243660046130af565b611bc9565b34801561093557600080fd5b50610415611c06565b34801561094a57600080fd5b50600d54610448565b34801561095f57600080fd5b5061037161096e366004612e5e565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b3480156109a857600080fd5b5061044860135481565b3480156109be57600080fd5b506104156109cd3660046130af565b611c51565b3480156109de57600080fd5b506104156109ed366004612e42565b611c8e565b60006001600160e01b0319821663780e9d6360e01b1480610a175750610a1782611d29565b90505b919050565b606060008054610a2e906135a0565b80601f0160208091040260200160405190810160405280929190818152602001828054610a5a906135a0565b8015610aa75780601f10610a7c57610100808354040283529160200191610aa7565b820191906000526020600020905b815481529060010190602001808311610a8a57829003601f168201915b5050505050905090565b6000818152600260205260408120546001600160a01b0316610b2f5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084015b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b60168054610b58906135a0565b80601f0160208091040260200160405190810160405280929190818152602001828054610b84906135a0565b8015610bd15780601f10610ba657610100808354040283529160200191610bd1565b820191906000526020600020905b815481529060010190602001808311610bb457829003601f168201915b505050505081565b6000610be4826112ff565b9050806001600160a01b0316836001600160a01b03161415610c525760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b6064820152608401610b26565b336001600160a01b0382161480610c6e5750610c6e813361096e565b610ce05760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c00000000000000006064820152608401610b26565b610cea8383611d79565b505050565b6001600160a01b0381166000908152600e6020526040902054610d245760405162461bcd60e51b8152600401610b2690613383565b6000610d2f600d5490565b610d399047613512565b90506000610d668383610d61866001600160a01b03166000908152600f602052604090205490565b611de7565b905080610d855760405162461bcd60e51b8152600401610b26906133c9565b6001600160a01b0383166000908152600f602052604081208054839290610dad908490613512565b9250508190555080600d6000828254610dc69190613512565b90915550610dd690508382611e2d565b604080516001600160a01b0385168152602081018390527fdf20fd1e76bc69d672e4814fafb2c449bba3a5369d8359adf9e05e6fde87b056910160405180910390a1505050565b610e273382611f46565b610e435760405162461bcd60e51b8152600401610b2690613475565b610cea83838361203c565b6000610e5983611383565b8210610ebb5760405162461bcd60e51b815260206004820152602b60248201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560448201526a74206f6620626f756e647360a81b6064820152608401610b26565b506001600160a01b03919091166000908152600660209081526040808320938352929052205490565b600a546001600160a01b03163314610f0e5760405162461bcd60e51b8152600401610b2690613414565b6018805462ff0000198116620100009182900460ff1615909102179055565b600a546001600160a01b03163314610f575760405162461bcd60e51b8152600401610b2690613414565b601c55565b610cea838383604051806020016040528060008152506119c7565b60606000610f8483611383565b905060008167ffffffffffffffff811115610faf57634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610fd8578160200160208202803683370190505b50905060005b8281101561102d57610ff08582610e4e565b82828151811061101057634e487b7160e01b600052603260045260246000fd5b602090810291909101015280611025816135db565b915050610fde565b509392505050565b6001600160a01b0381166000908152600e602052604090205461106a5760405162461bcd60e51b8152600401610b2690613383565b6001600160a01b0382166000908152601160205260408120546040516370a0823160e01b81523060048201526001600160a01b038516906370a082319060240160206040518083038186803b1580156110c257600080fd5b505afa1580156110d6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110fa91906130f5565b6111049190613512565b9050600061113d8383610d6187876001600160a01b03918216600090815260126020908152604080832093909416825291909152205490565b90508061115c5760405162461bcd60e51b8152600401610b26906133c9565b6001600160a01b03808516600090815260126020908152604080832093871683529290529081208054839290611193908490613512565b90915550506001600160a01b038416600090815260116020526040812080548392906111c0908490613512565b909155506111d190508484836121e3565b604080516001600160a01b038581168252602082018490528616917f3be5b7a71e84ed12875d241991c70855ac5817d847039e17a9d895c1ceb0f18a910160405180910390a250505050565b600061122860085490565b821061128b5760405162461bcd60e51b815260206004820152602c60248201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60448201526b7574206f6620626f756e647360a01b6064820152608401610b26565b600882815481106112ac57634e487b7160e01b600052603260045260246000fd5b90600052602060002001549050919050565b600a546001600160a01b031633146112e85760405162461bcd60e51b8152600401610b2690613414565b80516112fb906015906020840190612d33565b5050565b6000818152600260205260408120546001600160a01b031680610a175760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201526832b73a103a37b5b2b760b91b6064820152608401610b26565b60158054610b58906135a0565b60006001600160a01b0382166113ee5760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604482015269726f206164647265737360b01b6064820152608401610b26565b506001600160a01b031660009081526003602052604090205490565b600a546001600160a01b031633146114345760405162461bcd60e51b8152600401610b2690613414565b61143e6000612235565b565b600a546001600160a01b0316331461146a5760405162461bcd60e51b8152600401610b2690613414565b601355565b60006010828154811061149257634e487b7160e01b600052603260045260246000fd5b6000918252602090912001546001600160a01b031692915050565b600a546001600160a01b031633146114d75760405162461bcd60e51b8152600401610b2690613414565b601b55565b8181611553828280806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250506013546040516bffffffffffffffffffffffff193360601b166020820152909250603401905060405160208183030381529060405280519060200120612287565b15156001146115745760405162461bcd60e51b8152600401610b2690613449565b3332146115935760405162461bcd60e51b8152600401610b2690613449565b336001600160a01b038716146115eb5760405162461bcd60e51b815260206004820152601a60248201527f46616e746f6d416e696d616c733a204e6f7420616c6c6f7765640000000000006044820152606401610b26565b60185462010000900460ff166116435760405162461bcd60e51b815260206004820152601d60248201527f46616e746f6d416e696d616c733a2050726573616c65206973204f46460000006044820152606401610b26565b60185460ff16156116665760405162461bcd60e51b8152600401610b26906132fd565b6019548511156116885760405162461bcd60e51b8152600401610b26906134c6565b601954336000908152601a60205260409020546116a6908790613512565b11156116c45760405162461bcd60e51b8152600401610b26906134c6565b60006116cf601d5490565b6014549091506116df8783613512565b11156117385760405162461bcd60e51b815260206004820152602260248201527f46616e746f6d416e696d616c733a206d617820737570706c7920657863656564604482015261195960f21b6064820152608401610b26565b3486601c54611747919061353e565b11156117655760405162461bcd60e51b8152600401610b269061333e565b336000908152601a602052604081208054889290611784908490613512565b90915550600090505b868110156117af5761179d61229d565b806117a7816135db565b91505061178d565b5050505050505050565b606060018054610a2e906135a0565b61143e61229d565b6112fb338383612322565b600a546001600160a01b031633146118055760405162461bcd60e51b8152600401610b2690613414565b6018805461ff001916610100179055565b3332146118355760405162461bcd60e51b8152600401610b2690613449565b6018546301000000900460ff1661188e5760405162461bcd60e51b815260206004820181905260248201527f46616e746f6d416e696d616c733a205075626c696353616c65206973204f46466044820152606401610b26565b60185460ff16156118b15760405162461bcd60e51b8152600401610b26906132fd565b600081116119015760405162461bcd60e51b815260206004820152601a60248201527f46616e746f6d416e696d616c733a207a65726f20616d6f756e740000000000006044820152606401610b26565b600061190c601d5490565b60145490915061191c8383613512565b11156119755760405162461bcd60e51b815260206004820152602260248201527f46616e746f6d416e696d616c733a204d617820737570706c7920657863656564604482015261195960f21b6064820152608401610b26565b3482601b54611984919061353e565b11156119a25760405162461bcd60e51b8152600401610b269061333e565b60005b82811015610cea576119b561229d565b806119bf816135db565b9150506119a5565b6119d13383611f46565b6119ed5760405162461bcd60e51b8152600401610b2690613475565b6119f9848484846123f1565b50505050565b600a546001600160a01b03163314611a295760405162461bcd60e51b8152600401610b2690613414565b6018805460ff19811660ff90911615179055565b60178054610b58906135a0565b6000818152600260205260409020546060906001600160a01b0316611ac95760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b6064820152608401610b26565b601854610100900460ff16611b6a5760168054611ae5906135a0565b80601f0160208091040260200160405190810160405280929190818152602001828054611b11906135a0565b8015611b5e5780601f10611b3357610100808354040283529160200191611b5e565b820191906000526020600020905b815481529060010190602001808311611b4157829003601f168201915b50505050509050610a1a565b6000611b74612424565b90506000815111611b945760405180602001604052806000815250611bc2565b80611b9e84612433565b6017604051602001611bb293929190613155565b6040516020818303038152906040525b9392505050565b600a546001600160a01b03163314611bf35760405162461bcd60e51b8152600401610b2690613414565b80516112fb906017906020840190612d33565b600a546001600160a01b03163314611c305760405162461bcd60e51b8152600401610b2690613414565b6018805463ff00000019811663010000009182900460ff1615909102179055565b600a546001600160a01b03163314611c7b5760405162461bcd60e51b8152600401610b2690613414565b80516112fb906016906020840190612d33565b600a546001600160a01b03163314611cb85760405162461bcd60e51b8152600401610b2690613414565b6001600160a01b038116611d1d5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610b26565b611d2681612235565b50565b60006001600160e01b031982166380ac58cd60e01b1480611d5a57506001600160e01b03198216635b5e139f60e01b145b80610a1757506301ffc9a760e01b6001600160e01b0319831614610a17565b600081815260046020526040902080546001600160a01b0319166001600160a01b0384169081179091558190611dae826112ff565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600c546001600160a01b0384166000908152600e602052604081205490918391611e11908661353e565b611e1b919061352a565b611e25919061355d565b949350505050565b80471015611e7d5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e63650000006044820152606401610b26565b6000826001600160a01b03168260405160006040518083038185875af1925050503d8060008114611eca576040519150601f19603f3d011682016040523d82523d6000602084013e611ecf565b606091505b5050905080610cea5760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d617920686176652072657665727465640000000000006064820152608401610b26565b6000818152600260205260408120546001600160a01b0316611fbf5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b6064820152608401610b26565b6000611fca836112ff565b9050806001600160a01b0316846001600160a01b031614806120055750836001600160a01b0316611ffa84610ab1565b6001600160a01b0316145b80611e2557506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff16949350505050565b826001600160a01b031661204f826112ff565b6001600160a01b0316146120b35760405162461bcd60e51b815260206004820152602560248201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060448201526437bbb732b960d91b6064820152608401610b26565b6001600160a01b0382166121155760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b6064820152608401610b26565b61212083838361254e565b61212b600082611d79565b6001600160a01b038316600090815260036020526040812080546001929061215490849061355d565b90915550506001600160a01b0382166000908152600360205260408120805460019290612182908490613512565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4610cea565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052610cea90849061260b565b600a80546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60008261229485846126dd565b14949350505050565b6002600b5414156122f05760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610b26565b6002600b55612303601d80546001019055565b600061230e601d5490565b905061231a3382612757565b506001600b55565b816001600160a01b0316836001600160a01b031614156123845760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c6572000000000000006044820152606401610b26565b6001600160a01b03838116600081815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6123fc84848461203c565b61240884848484612771565b6119f95760405162461bcd60e51b8152600401610b26906132ab565b606060158054610a2e906135a0565b60608161245857506040805180820190915260018152600360fc1b6020820152610a1a565b8160005b8115612482578061246c816135db565b915061247b9050600a8361352a565b915061245c565b60008167ffffffffffffffff8111156124ab57634e487b7160e01b600052604160045260246000fd5b6040519080825280601f01601f1916602001820160405280156124d5576020820181803683370190505b5090505b8415611e25576124ea60018361355d565b91506124f7600a866135f6565b612502906030613512565b60f81b81838151811061252557634e487b7160e01b600052603260045260246000fd5b60200101906001600160f81b031916908160001a905350612547600a8661352a565b94506124d9565b6001600160a01b0383166125a9576125a481600880546000838152600960205260408120829055600182018355919091527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee30155565b6125cc565b816001600160a01b0316836001600160a01b0316146125cc576125cc838261287e565b6001600160a01b0382166125e8576125e38161291b565b610cea565b826001600160a01b0316826001600160a01b031614610cea57610cea82826129f4565b6000612660826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b0316612a389092919063ffffffff16565b805190915015610cea578080602001905181019061267e9190613031565b610cea5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608401610b26565b600081815b845181101561102d57600085828151811061270d57634e487b7160e01b600052603260045260246000fd5b602002602001015190508083116127335760008381526020829052604090209250612744565b600081815260208490526040902092505b508061274f816135db565b9150506126e2565b6112fb828260405180602001604052806000815250612a47565b60006001600160a01b0384163b1561287357604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906127b5903390899088908890600401613217565b602060405180830381600087803b1580156127cf57600080fd5b505af19250505080156127ff575060408051601f3d908101601f191682019092526127fc91810190613081565b60015b612859573d80801561282d576040519150601f19603f3d011682016040523d82523d6000602084013e612832565b606091505b5080516128515760405162461bcd60e51b8152600401610b26906132ab565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611e25565b506001949350505050565b6000600161288b84611383565b612895919061355d565b6000838152600760205260409020549091508082146128e8576001600160a01b03841660009081526006602090815260408083208584528252808320548484528184208190558352600790915290208190555b5060009182526007602090815260408084208490556001600160a01b039094168352600681528383209183525290812055565b60085460009061292d9060019061355d565b6000838152600960205260408120546008805493945090928490811061296357634e487b7160e01b600052603260045260246000fd5b90600052602060002001549050806008838154811061299257634e487b7160e01b600052603260045260246000fd5b60009182526020808320909101929092558281526009909152604080822084905585825281205560088054806129d857634e487b7160e01b600052603160045260246000fd5b6001900381819060005260206000200160009055905550505050565b60006129ff83611383565b6001600160a01b039093166000908152600660209081526040808320868452825280832085905593825260079052919091209190915550565b6060611e258484600085612a7a565b612a518383612bab565b612a5e6000848484612771565b610cea5760405162461bcd60e51b8152600401610b26906132ab565b606082471015612adb5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b6064820152608401610b26565b6001600160a01b0385163b612b325760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610b26565b600080866001600160a01b03168587604051612b4e9190613139565b60006040518083038185875af1925050503d8060008114612b8b576040519150601f19603f3d011682016040523d82523d6000602084013e612b90565b606091505b5091509150612ba0828286612cfa565b979650505050505050565b6001600160a01b038216612c015760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f20616464726573736044820152606401610b26565b6000818152600260205260409020546001600160a01b031615612c665760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606401610b26565b612c726000838361254e565b6001600160a01b0382166000908152600360205260408120805460019290612c9b908490613512565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a46112fb565b60608315612d09575081611bc2565b825115612d195782518084602001fd5b8160405162461bcd60e51b8152600401610b269190613298565b828054612d3f906135a0565b90600052602060002090601f016020900481019282612d615760008555612da7565b82601f10612d7a57805160ff1916838001178555612da7565b82800160010185558215612da7579182015b82811115612da7578251825591602001919060010190612d8c565b50612db3929150612db7565b5090565b5b80821115612db35760008155600101612db8565b600067ffffffffffffffff80841115612de757612de7613636565b604051601f8501601f19908116603f01168101908282118183101715612e0f57612e0f613636565b81604052809350858152868686011115612e2857600080fd5b858560208301376000602087830101525050509392505050565b600060208284031215612e53578081fd5b8135611bc28161364c565b60008060408385031215612e70578081fd5b8235612e7b8161364c565b91506020830135612e8b8161364c565b809150509250929050565b600080600060608486031215612eaa578081fd5b8335612eb58161364c565b92506020840135612ec58161364c565b929592945050506040919091013590565b60008060008060808587031215612eeb578081fd5b8435612ef68161364c565b93506020850135612f068161364c565b925060408501359150606085013567ffffffffffffffff811115612f28578182fd5b8501601f81018713612f38578182fd5b612f4787823560208401612dcc565b91505092959194509250565b60008060408385031215612f65578182fd5b8235612f708161364c565b91506020830135612e8b81613661565b60008060408385031215612f92578182fd5b8235612f9d8161364c565b946020939093013593505050565b60008060008060608587031215612fc0578384fd5b8435612fcb8161364c565b935060208501359250604085013567ffffffffffffffff80821115612fee578384fd5b818701915087601f830112613001578384fd5b81358181111561300f578485fd5b8860208083028501011115613022578485fd5b95989497505060200194505050565b600060208284031215613042578081fd5b8151611bc281613661565b60006020828403121561305e578081fd5b5035919050565b600060208284031215613076578081fd5b8135611bc28161366f565b600060208284031215613092578081fd5b8151611bc28161366f565b60008060408385031215612e70578182fd5b6000602082840312156130c0578081fd5b813567ffffffffffffffff8111156130d6578182fd5b8201601f810184136130e6578182fd5b611e2584823560208401612dcc565b600060208284031215613106578081fd5b5051919050565b60008151808452613125816020860160208601613574565b601f01601f19169290920160200192915050565b6000825161314b818460208701613574565b9190910192915050565b6000845160206131688285838a01613574565b85519184019161317b8184848a01613574565b855492019183906002810460018083168061319757607f831692505b8583108114156131b557634e487b7160e01b88526022600452602488fd5b8080156131c957600181146131da57613206565b60ff19851688528388019550613206565b60008b815260209020895b858110156131fe5781548a8201529084019088016131e5565b505083880195505b50939b9a5050505050505050505050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061324a9083018461310d565b9695505050505050565b6020808252825182820181905260009190848201906040850190845b8181101561328c57835183529284019291840191600101613270565b50909695505050505050565b600060208252611bc2602083018461310d565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b60208082526021908201527f46616e746f6d416e696d616c733a20436f6e74726163742069732070617573656040820152601960fa1b606082015260800190565b60208082526025908201527f46616e746f6d416e696d616c733a204e6f7420656e6f75676820657468657273604082015264081cd95b9d60da1b606082015260800190565b60208082526026908201527f5061796d656e7453706c69747465723a206163636f756e7420686173206e6f2060408201526573686172657360d01b606082015260800190565b6020808252602b908201527f5061796d656e7453706c69747465723a206163636f756e74206973206e6f742060408201526a191d59481c185e5b595b9d60aa1b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b6020808252601290820152712737ba1030b63637bbb2b21037b934b3b4b760711b604082015260600190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6020808252602c908201527f46616e746f6d416e696d616c733a20596f752063616e2774206d696e7420736f60408201526b206d75636820746f6b656e7360a01b606082015260800190565b600082198211156135255761352561360a565b500190565b60008261353957613539613620565b500490565b60008160001904831182151516156135585761355861360a565b500290565b60008282101561356f5761356f61360a565b500390565b60005b8381101561358f578181015183820152602001613577565b838111156119f95750506000910152565b6002810460018216806135b457607f821691505b602082108114156135d557634e487b7160e01b600052602260045260246000fd5b50919050565b60006000198214156135ef576135ef61360a565b5060010190565b60008261360557613605613620565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160a01b0381168114611d2657600080fd5b8015158114611d2657600080fd5b6001600160e01b031981168114611d2657600080fdfea2646970667358221220b4570b56ec1964352686298799f0416ad28ddb6c3a3c54924434d25063584ee264736f6c63430008020033

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037878780000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : uri (string): xxx
Arg [1] : merkleroot (bytes32): 0x0000000000000000000000000000000000000000000000000000000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [3] : 7878780000000000000000000000000000000000000000000000000000000000


Deployed Bytecode Sourcemap

65344:6181:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32058:40;18584:10;32058:40;;;-1:-1:-1;;;;;9965:32:1;;;9947:51;;32088:9:0;10029:2:1;10014:18;;10007:34;9920:18;32058:40:0;;;;;;;65344:6181;;;;;59196:224;;;;;;;;;;-1:-1:-1;59196:224:0;;;;;:::i;:::-;;:::i;:::-;;;11629:14:1;;11622:22;11604:41;;11592:2;11577:18;59196:224:0;;;;;;;;45109:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46668:221::-;;;;;;;;;;-1:-1:-1;46668:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;9721:32:1;;;9703:51;;9691:2;9676:18;46668:221:0;9658:102:1;65639:87:0;;;;;;;;;;;;;:::i;46191:411::-;;;;;;;;;;-1:-1:-1;46191:411:0;;;;;:::i;:::-;;:::i;:::-;;65846:28;;;;;;;;;;-1:-1:-1;65846:28:0;;;;;;;;;;;59836:113;;;;;;;;;;-1:-1:-1;59924:10:0;:17;59836:113;;;11802:25:1;;;11790:2;11775:18;59836:113:0;11757:76:1;33844:566:0;;;;;;;;;;-1:-1:-1;33844:566:0;;;;;:::i;:::-;;:::i;47418:339::-;;;;;;;;;;-1:-1:-1;47418:339:0;;;;;:::i;:::-;;:::i;59504:256::-;;;;;;;;;;-1:-1:-1;59504:256:0;;;;;:::i;:::-;;:::i;67822:81::-;;;;;;;;;;;;;:::i;66815:115::-;;;;;;;;;;-1:-1:-1;66815:115:0;;;;;:::i;:::-;;:::i;32189:91::-;;;;;;;;;;-1:-1:-1;32260:12:0;;32189:91;;33318:135;;;;;;;;;;-1:-1:-1;33318:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;33415:21:0;;;33388:7;33415:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;33318:135;47828:185;;;;;;;;;;-1:-1:-1;47828:185:0;;;;;:::i;:::-;;:::i;71170:350::-;;;;;;;;;;-1:-1:-1;71170:350:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;34678:641::-;;;;;;;;;;-1:-1:-1;34678:641:0;;;;;:::i;:::-;;:::i;60026:233::-;;;;;;;;;;-1:-1:-1;60026:233:0;;;;;:::i;:::-;;:::i;65812:27::-;;;;;;;;;;-1:-1:-1;65812:27:0;;;;;;;;;;;66938:108;;;;;;;;;;-1:-1:-1;66938:108:0;;;;;:::i;:::-;;:::i;65779:26::-;;;;;;;;;;-1:-1:-1;65779:26:0;;;;;;;;44803:239;;;;;;;;;;-1:-1:-1;44803:239:0;;;;;:::i;:::-;;:::i;65610:21::-;;;;;;;;;;;;;:::i;44533:208::-;;;;;;;;;;-1:-1:-1;44533:208:0;;;;;:::i;:::-;;:::i;20372:103::-;;;;;;;;;;;;;:::i;67239:114::-;;;;;;;;;;-1:-1:-1;67239:114:0;;;;;:::i;:::-;;:::i;33544:100::-;;;;;;;;;;-1:-1:-1;33544:100:0;;;;;:::i;:::-;;:::i;65955:50::-;;;;;;;;;;-1:-1:-1;65955:50:0;;;;;:::i;:::-;;;;;;;;;;;;;;19721:87;;;;;;;;;;-1:-1:-1;19794:6:0;;-1:-1:-1;;;;;19794:6:0;19721:87;;66720;;;;;;;;;;-1:-1:-1;66720:87:0;;;;;:::i;:::-;;:::i;68003:1142::-;;;;;;:::i;:::-;;:::i;45278:104::-;;;;;;;;;;;;;:::i;69181:62::-;;;;;;;;;;;;;:::i;33040:109::-;;;;;;;;;;-1:-1:-1;33040:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;33123:18:0;33096:7;33123:18;;;:9;:18;;;;;;;33040:109;46961:155;;;;;;;;;;-1:-1:-1;46961:155:0;;;;;:::i;:::-;;:::i;65881:27::-;;;;;;;;;;-1:-1:-1;65881:27:0;;;;;;;;;;;67162:69;;;;;;;;;;;;;:::i;69251:696::-;;;;;;:::i;:::-;;:::i;48084:328::-;;;;;;;;;;-1:-1:-1;48084:328:0;;;;;:::i;:::-;;:::i;67739:75::-;;;;;;;;;;;;;:::i;65733:37::-;;;;;;;;;;;;;:::i;70140:729::-;;;;;;;;;;-1:-1:-1;70140:729:0;;;;;:::i;:::-;;:::i;32836:105::-;;;;;;;;;;-1:-1:-1;32836:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;32917:16:0;32890:7;32917:16;;;:7;:16;;;;;;;32836:105;65571:30;;;;;;;;;;;;;;;;32626:119;;;;;;;;;;-1:-1:-1;32626:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;32711:26:0;32684:7;32711:26;;;:19;:26;;;;;;;32626:119;70877:151;;;;;;;;;;-1:-1:-1;70877:151:0;;;;;:::i;:::-;;:::i;67911:82::-;;;;;;;;;;;;;:::i;32374:95::-;;;;;;;;;;-1:-1:-1;32447:14:0;;32374:95;;47187:164;;;;;;;;;;-1:-1:-1;47187:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;47308:25:0;;;47284:4;47308:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;47187:164;65539:19;;;;;;;;;;;;;;;;71036:126;;;;;;;;;;-1:-1:-1;71036:126:0;;;;;:::i;:::-;;:::i;20630:201::-;;;;;;;;;;-1:-1:-1;20630:201:0;;;;;:::i;:::-;;:::i;59196:224::-;59298:4;-1:-1:-1;;;;;;59322:50:0;;-1:-1:-1;;;59322:50:0;;:90;;;59376:36;59400:11;59376:23;:36::i;:::-;59315:97;;59196:224;;;;:::o;45109:100::-;45163:13;45196:5;45189:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45109:100;:::o;46668:221::-;46744:7;50011:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50011:16:0;46764:73;;;;-1:-1:-1;;;46764:73:0;;21743:2:1;46764:73:0;;;21725:21:1;21782:2;21762:18;;;21755:30;21821:34;21801:18;;;21794:62;-1:-1:-1;;;21872:18:1;;;21865:42;21924:19;;46764:73:0;;;;;;;;;-1:-1:-1;46857:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46857:24:0;;46668:221::o;65639:87::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;46191:411::-;46272:13;46288:23;46303:7;46288:14;:23::i;:::-;46272:39;;46336:5;-1:-1:-1;;;;;46330:11:0;:2;-1:-1:-1;;;;;46330:11:0;;;46322:57;;;;-1:-1:-1;;;46322:57:0;;22933:2:1;46322:57:0;;;22915:21:1;22972:2;22952:18;;;22945:30;23011:34;22991:18;;;22984:62;-1:-1:-1;;;23062:18:1;;;23055:31;23103:19;;46322:57:0;22905:223:1;46322:57:0;18584:10;-1:-1:-1;;;;;46414:21:0;;;;:62;;-1:-1:-1;46439:37:0;46456:5;18584:10;46463:12;18504:98;46439:37;46392:168;;;;-1:-1:-1;;;46392:168:0;;19062:2:1;46392:168:0;;;19044:21:1;19101:2;19081:18;;;19074:30;19140:34;19120:18;;;19113:62;19211:26;19191:18;;;19184:54;19255:19;;46392:168:0;19034:246:1;46392:168:0;46573:21;46582:2;46586:7;46573:8;:21::i;:::-;46191:411;;;:::o;33844:566::-;-1:-1:-1;;;;;33920:16:0;;33939:1;33920:16;;;:7;:16;;;;;;33912:71;;;;-1:-1:-1;;;33912:71:0;;;;;;;:::i;:::-;33996:21;34044:15;32447:14;;32374:95;;34044:15;34020:39;;:21;:39;:::i;:::-;33996:63;;34070:15;34088:58;34104:7;34113:13;34128:17;34137:7;-1:-1:-1;;;;;33123:18:0;33096:7;33123:18;;;:9;:18;;;;;;;33040:109;34128:17;34088:15;:58::i;:::-;34070:76;-1:-1:-1;34167:12:0;34159:68;;;;-1:-1:-1;;;34159:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;34240:18:0;;;;;;:9;:18;;;;;:29;;34262:7;;34240:18;:29;;34262:7;;34240:29;:::i;:::-;;;;;;;;34298:7;34280:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;34318:35:0;;-1:-1:-1;34336:7:0;34345;34318:17;:35::i;:::-;34369:33;;;-1:-1:-1;;;;;9965:32:1;;9947:51;;10029:2;10014:18;;10007:34;;;34369:33:0;;9920:18:1;34369:33:0;;;;;;;33844:566;;;:::o;47418:339::-;47613:41;18584:10;47646:7;47613:18;:41::i;:::-;47605:103;;;;-1:-1:-1;;;47605:103:0;;;;;;;:::i;:::-;47721:28;47731:4;47737:2;47741:7;47721:9;:28::i;59504:256::-;59601:7;59637:23;59654:5;59637:16;:23::i;:::-;59629:5;:31;59621:87;;;;-1:-1:-1;;;59621:87:0;;12264:2:1;59621:87:0;;;12246:21:1;12303:2;12283:18;;;12276:30;12342:34;12322:18;;;12315:62;-1:-1:-1;;;12393:18:1;;;12386:41;12444:19;;59621:87:0;12236:233:1;59621:87:0;-1:-1:-1;;;;;;59726:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;59504:256::o;67822:81::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;67887:8:::1;::::0;;-1:-1:-1;;67875:20:0;::::1;67887:8:::0;;;;::::1;;;67886:9;67875:20:::0;;::::1;;::::0;;67822:81::o;66815:115::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;66890:13:::1;:32:::0;66815:115::o;47828:185::-;47966:39;47983:4;47989:2;47993:7;47966:39;;;;;;;;;;;;:16;:39::i;71170:350::-;71245:16;71275:23;71301:17;71311:6;71301:9;:17::i;:::-;71275:43;;71325:25;71367:15;71353:30;;;;;;-1:-1:-1;;;71353:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71353:30:0;;71325:58;;71395:9;71390:103;71410:15;71406:1;:19;71390:103;;;71455:30;71475:6;71483:1;71455:19;:30::i;:::-;71441:8;71450:1;71441:11;;;;;;-1:-1:-1;;;71441:11:0;;;;;;;;;;;;;;;;;;:44;71427:3;;;;:::i;:::-;;;;71390:103;;;-1:-1:-1;71506:8:0;71170:350;-1:-1:-1;;;71170:350:0:o;34678:641::-;-1:-1:-1;;;;;34760:16:0;;34779:1;34760:16;;;:7;:16;;;;;;34752:71;;;;-1:-1:-1;;;34752:71:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;32711:26:0;;34836:21;32711:26;;;:19;:26;;;;;;34860:30;;-1:-1:-1;;;34860:30:0;;34884:4;34860:30;;;9703:51:1;-1:-1:-1;;;;;34860:15:0;;;;;9676:18:1;;34860:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;34836:77;;34924:15;34942:65;34958:7;34967:13;34982:24;34991:5;34998:7;-1:-1:-1;;;;;33415:21:0;;;33388:7;33415:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;33318:135;34942:65;34924:83;-1:-1:-1;35028:12:0;35020:68;;;;-1:-1:-1;;;35020:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;35101:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;;;:41;;35135:7;;35101:21;:41;;35135:7;;35101:41;:::i;:::-;;;;-1:-1:-1;;;;;;;35153:26:0;;;;;;:19;:26;;;;;:37;;35183:7;;35153:26;:37;;35183:7;;35153:37;:::i;:::-;;;;-1:-1:-1;35203:47:0;;-1:-1:-1;35226:5:0;35233:7;35242;35203:22;:47::i;:::-;35266:45;;;-1:-1:-1;;;;;9965:32:1;;;9947:51;;10029:2;10014:18;;10007:34;;;35266:45:0;;;;;9920:18:1;35266:45:0;;;;;;;34678:641;;;;:::o;60026:233::-;60101:7;60137:30;59924:10;:17;59836:113;;60137:30;60129:5;:38;60121:95;;;;-1:-1:-1;;;60121:95:0;;24458:2:1;60121:95:0;;;24440:21:1;24497:2;24477:18;;;24470:30;24536:34;24516:18;;;24509:62;-1:-1:-1;;;24587:18:1;;;24580:42;24639:19;;60121:95:0;24430:234:1;60121:95:0;60234:10;60245:5;60234:17;;;;;;-1:-1:-1;;;60234:17:0;;;;;;;;;;;;;;;;;60227:24;;60026:233;;;:::o;66938:108::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;67015:23;;::::1;::::0;:7:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;:::-;;66938:108:::0;:::o;44803:239::-;44875:7;44911:16;;;:7;:16;;;;;;-1:-1:-1;;;;;44911:16:0;44946:19;44938:73;;;;-1:-1:-1;;;44938:73:0;;19898:2:1;44938:73:0;;;19880:21:1;19937:2;19917:18;;;19910:30;19976:34;19956:18;;;19949:62;-1:-1:-1;;;20027:18:1;;;20020:39;20076:19;;44938:73:0;19870:231:1;65610:21:0;;;;;;;:::i;44533:208::-;44605:7;-1:-1:-1;;;;;44633:19:0;;44625:74;;;;-1:-1:-1;;;44625:74:0;;19487:2:1;44625:74:0;;;19469:21:1;19526:2;19506:18;;;19499:30;19565:34;19545:18;;;19538:62;-1:-1:-1;;;19616:18:1;;;19609:40;19666:19;;44625:74:0;19459:232:1;44625:74:0;-1:-1:-1;;;;;;44717:16:0;;;;;:9;:16;;;;;;;44533:208::o;20372:103::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;20437:30:::1;20464:1;20437:18;:30::i;:::-;20372:103::o:0;67239:114::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;67328:4:::1;:17:::0;67239:114::o;33544:100::-;33595:7;33622;33630:5;33622:14;;;;;;-1:-1:-1;;;33622:14:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;33622:14:0;;33544:100;-1:-1:-1;;33544:100:0:o;66720:87::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;66781:6:::1;:18:::0;66720:87::o;68003:1142::-;68136:6;;67554:127;67587:6;;67554:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;67608:4:0;;67637:28;;-1:-1:-1;;67654:10:0;7448:2:1;7444:15;7440:53;67637:28:0;;;7428:66:1;67608:4:0;;-1:-1:-1;7510:12:1;;;-1:-1:-1;67637:28:0;;;;;;;;;;;;67627:39;;;;;;67554:18;:127::i;:::-;:135;;67685:4;67554:135;67546:166;;;;-1:-1:-1;;;67546:166:0;;;;;;;:::i;:::-;67405:10:::1;67419:9;67405:23;67397:54;;;;-1:-1:-1::0;;;67397:54:0::1;;;;;;;:::i;:::-;68186:10:::2;-1:-1:-1::0;;;;;68186:21:0;::::2;;68178:69;;;::::0;-1:-1:-1;;;68178:69:0;;20666:2:1;68178:69:0::2;::::0;::::2;20648:21:1::0;20705:2;20685:18;;;20678:30;20744:28;20724:18;;;20717:56;20790:18;;68178:69:0::2;20638:176:1::0;68178:69:0::2;68266:8;::::0;;;::::2;;;68258:72;;;::::0;-1:-1:-1;;;68258:72:0;;20308:2:1;68258:72:0::2;::::0;::::2;20290:21:1::0;20347:2;20327:18;;;20320:30;20386:31;20366:18;;;20359:59;20435:18;;68258:72:0::2;20280:179:1::0;68258:72:0::2;68350:6;::::0;::::2;;68349:7;68341:76;;;;-1:-1:-1::0;;;68341:76:0::2;;;;;;;:::i;:::-;68461:18;;68450:7;:29;;68428:105;;;;-1:-1:-1::0;;;68428:105:0::2;;;;;;;:::i;:::-;68607:18;::::0;68582:10:::2;68566:27;::::0;;;:15:::2;:27;::::0;;;;;:37:::2;::::0;68596:7;;68566:37:::2;:::i;:::-;:59;;68544:131;;;;-1:-1:-1::0;;;68544:131:0::2;;;;;;;:::i;:::-;68690:12;68705:19;:9;42332:14:::0;;42240:114;68705:19:::2;68780:9;::::0;68690:34;;-1:-1:-1;68759:17:0::2;68769:7:::0;68690:34;68759:17:::2;:::i;:::-;:30;;68737:114;;;::::0;-1:-1:-1;;;68737:114:0;;14667:2:1;68737:114:0::2;::::0;::::2;14649:21:1::0;14706:2;14686:18;;;14679:30;14745:34;14725:18;;;14718:62;-1:-1:-1;;;14796:18:1;;;14789:32;14838:19;;68737:114:0::2;14639:224:1::0;68737:114:0::2;68911:9;68900:7;68884:13;;:23;;;;:::i;:::-;:36;;68862:123;;;;-1:-1:-1::0;;;68862:123:0::2;;;;;;;:::i;:::-;69027:10;69011:27;::::0;;;:15:::2;:27;::::0;;;;:38;;69042:7;;69011:27;:38:::2;::::0;69042:7;;69011:38:::2;:::i;:::-;::::0;;;-1:-1:-1;69067:6:0::2;::::0;-1:-1:-1;69062:76:0::2;69083:7;69079:1;:11;69062:76;;;69112:14;:12;:14::i;:::-;69092:3:::0;::::2;::::0;::::2;:::i;:::-;;;;69062:76;;;;67462:1;68003:1142:::0;;;;;;:::o;45278:104::-;45334:13;45367:7;45360:14;;;;;:::i;69181:62::-;69221:14;:12;:14::i;46961:155::-;47056:52;18584:10;47089:8;47099;47056:18;:52::i;67162:69::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;67208:8:::1;:15:::0;;-1:-1:-1;;67208:15:0::1;;;::::0;;67162:69::o;69251:696::-;67405:10;67419:9;67405:23;67397:54;;;;-1:-1:-1;;;67397:54:0;;;;;;;:::i;:::-;69363:7:::1;::::0;;;::::1;;;69355:52;;;::::0;-1:-1:-1;;;69355:52:0;;21382:2:1;69355:52:0::1;::::0;::::1;21364:21:1::0;;;21401:18;;;21394:30;21460:34;21440:18;;;21433:62;21512:18;;69355:52:0::1;21354:182:1::0;69355:52:0::1;69427:6;::::0;::::1;;69426:7;69418:53;;;;-1:-1:-1::0;;;69418:53:0::1;;;;;;;:::i;:::-;69500:1;69490:7;:11;69482:50;;;::::0;-1:-1:-1;;;69482:50:0;;25695:2:1;69482:50:0::1;::::0;::::1;25677:21:1::0;25734:2;25714:18;;;25707:30;25773:28;25753:18;;;25746:56;25819:18;;69482:50:0::1;25667:176:1::0;69482:50:0::1;69545:12;69560:19;:9;42332:14:::0;;42240:114;69560:19:::1;69635:9;::::0;69545:34;;-1:-1:-1;69614:17:0::1;69624:7:::0;69545:34;69614:17:::1;:::i;:::-;:30;;69592:114;;;::::0;-1:-1:-1;;;69592:114:0;;18659:2:1;69592:114:0::1;::::0;::::1;18641:21:1::0;18698:2;18678:18;;;18671:30;18737:34;18717:18;;;18710:62;-1:-1:-1;;;18788:18:1;;;18781:32;18830:19;;69592:114:0::1;18631:224:1::0;69592:114:0::1;69759:9;69748:7;69739:6;;:16;;;;:::i;:::-;:29;;69717:116;;;;-1:-1:-1::0;;;69717:116:0::1;;;;;;;:::i;:::-;69869:6;69864:76;69885:7;69881:1;:11;69864:76;;;69914:14;:12;:14::i;:::-;69894:3:::0;::::1;::::0;::::1;:::i;:::-;;;;69864:76;;48084:328:::0;48259:41;18584:10;48292:7;48259:18;:41::i;:::-;48251:103;;;;-1:-1:-1;;;48251:103:0;;;;;;;:::i;:::-;48365:39;48379:4;48385:2;48389:7;48398:5;48365:13;:39::i;:::-;48084:328;;;;:::o;67739:75::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;67800:6:::1;::::0;;-1:-1:-1;;67790:16:0;::::1;67800:6;::::0;;::::1;67799:7;67790:16;::::0;;67739:75::o;65733:37::-;;;;;;;:::i;70140:729::-;49987:4;50011:16;;;:7;:16;;;;;;70258:13;;-1:-1:-1;;;;;50011:16:0;70289:113;;;;-1:-1:-1;;;70289:113:0;;22517:2:1;70289:113:0;;;22499:21:1;22556:2;22536:18;;;22529:30;22595:34;22575:18;;;22568:62;-1:-1:-1;;;22646:18:1;;;22639:45;22701:19;;70289:113:0;22489:237:1;70289:113:0;70417:8;;;;;;;70413:71;;70458:14;70451:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70413:71;70496:28;70527:10;:8;:10::i;:::-;70496:41;;70605:1;70580:14;70574:28;:32;:287;;;;;;;;;;;;;;;;;70698:14;70739:18;:7;:16;:18::i;:::-;70784:13;70655:165;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;70574:287;70554:307;70140:729;-1:-1:-1;;;70140:729:0:o;70877:151::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;70987:33;;::::1;::::0;:13:::1;::::0;:33:::1;::::0;::::1;::::0;::::1;:::i;67911:82::-:0;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;67978:7:::1;::::0;;-1:-1:-1;;67967:18:0;::::1;67978:7:::0;;;;::::1;;;67977:8;67967:18:::0;;::::1;;::::0;;67911:82::o;71036:126::-;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;71122:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;20630:201::-:0;19794:6;;-1:-1:-1;;;;;19794:6:0;18584:10;19941:23;19933:68;;;;-1:-1:-1;;;19933:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20719:22:0;::::1;20711:73;;;::::0;-1:-1:-1;;;20711:73:0;;13497:2:1;20711:73:0::1;::::0;::::1;13479:21:1::0;13536:2;13516:18;;;13509:30;13575:34;13555:18;;;13548:62;-1:-1:-1;;;13626:18:1;;;13619:36;13672:19;;20711:73:0::1;13469:228:1::0;20711:73:0::1;20795:28;20814:8;20795:18;:28::i;:::-;20630:201:::0;:::o;44164:305::-;44266:4;-1:-1:-1;;;;;;44303:40:0;;-1:-1:-1;;;44303:40:0;;:105;;-1:-1:-1;;;;;;;44360:48:0;;-1:-1:-1;;;44360:48:0;44303:105;:158;;;-1:-1:-1;;;;;;;;;;12300:40:0;;;44425:36;12191:157;54068:174;54143:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;54143:29:0;-1:-1:-1;;;;;54143:29:0;;;;;;;;:24;;54197:23;54143:24;54197:14;:23::i;:::-;-1:-1:-1;;;;;54188:46:0;;;;;;;;;;;54068:174;;:::o;35497:248::-;35707:12;;-1:-1:-1;;;;;35687:16:0;;35643:7;35687:16;;;:7;:16;;;;;;35643:7;;35722:15;;35671:32;;:13;:32;:::i;:::-;35670:49;;;;:::i;:::-;:67;;;;:::i;:::-;35663:74;35497:248;-1:-1:-1;;;;35497:248:0:o;4541:317::-;4656:6;4631:21;:31;;4623:73;;;;-1:-1:-1;;;4623:73:0;;17069:2:1;4623:73:0;;;17051:21:1;17108:2;17088:18;;;17081:30;17147:31;17127:18;;;17120:59;17196:18;;4623:73:0;17041:179:1;4623:73:0;4710:12;4728:9;-1:-1:-1;;;;;4728:14:0;4750:6;4728:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4709:52;;;4780:7;4772:78;;;;-1:-1:-1;;;4772:78:0;;16642:2:1;4772:78:0;;;16624:21:1;16681:2;16661:18;;;16654:30;16720:34;16700:18;;;16693:62;16791:28;16771:18;;;16764:56;16837:19;;4772:78:0;16614:248:1;50216:348:0;50309:4;50011:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50011:16:0;50326:73;;;;-1:-1:-1;;;50326:73:0;;17834:2:1;50326:73:0;;;17816:21:1;17873:2;17853:18;;;17846:30;17912:34;17892:18;;;17885:62;-1:-1:-1;;;17963:18:1;;;17956:42;18015:19;;50326:73:0;17806:234:1;50326:73:0;50410:13;50426:23;50441:7;50426:14;:23::i;:::-;50410:39;;50479:5;-1:-1:-1;;;;;50468:16:0;:7;-1:-1:-1;;;;;50468:16:0;;:51;;;;50512:7;-1:-1:-1;;;;;50488:31:0;:20;50500:7;50488:11;:20::i;:::-;-1:-1:-1;;;;;50488:31:0;;50468:51;:87;;;-1:-1:-1;;;;;;47308:25:0;;;47284:4;47308:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;50460:96;50216:348;-1:-1:-1;;;;50216:348:0:o;53325:625::-;53484:4;-1:-1:-1;;;;;53457:31:0;:23;53472:7;53457:14;:23::i;:::-;-1:-1:-1;;;;;53457:31:0;;53449:81;;;;-1:-1:-1;;;53449:81:0;;13904:2:1;53449:81:0;;;13886:21:1;13943:2;13923:18;;;13916:30;13982:34;13962:18;;;13955:62;-1:-1:-1;;;14033:18:1;;;14026:35;14078:19;;53449:81:0;13876:227:1;53449:81:0;-1:-1:-1;;;;;53549:16:0;;53541:65;;;;-1:-1:-1;;;53541:65:0;;15883:2:1;53541:65:0;;;15865:21:1;15922:2;15902:18;;;15895:30;15961:34;15941:18;;;15934:62;-1:-1:-1;;;16012:18:1;;;16005:34;16056:19;;53541:65:0;15855:226:1;53541:65:0;53619:39;53640:4;53646:2;53650:7;53619:20;:39::i;:::-;53723:29;53740:1;53744:7;53723:8;:29::i;:::-;-1:-1:-1;;;;;53765:15:0;;;;;;:9;:15;;;;;:20;;53784:1;;53765:15;:20;;53784:1;;53765:20;:::i;:::-;;;;-1:-1:-1;;;;;;;53796:13:0;;;;;;:9;:13;;;;;:18;;53813:1;;53796:13;:18;;53813:1;;53796:18;:::i;:::-;;;;-1:-1:-1;;53825:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;53825:21:0;-1:-1:-1;;;;;53825:21:0;;;;;;;;;53864:27;;53825:16;;53864:27;;;;;;;53904:38;46191:411;25590:211;25734:58;;;-1:-1:-1;;;;;9965:32:1;;25734:58:0;;;9947:51:1;10014:18;;;;10007:34;;;25734:58:0;;;;;;;;;;9920:18:1;;;;25734:58:0;;;;;;;;-1:-1:-1;;;;;25734:58:0;-1:-1:-1;;;25734:58:0;;;25707:86;;25727:5;;25707:19;:86::i;20991:191::-;21084:6;;;-1:-1:-1;;;;;21101:17:0;;;-1:-1:-1;;;;;;21101:17:0;;;;;;;21134:40;;21084:6;;;21101:17;21084:6;;21134:40;;21065:16;;21134:40;20991:191;;:::o;39959:190::-;40084:4;40137;40108:25;40121:5;40128:4;40108:12;:25::i;:::-;:33;;39959:190;-1:-1:-1;;;;39959:190:0:o;69955:177::-;38162:1;38760:7;;:19;;38752:63;;;;-1:-1:-1;;;38752:63:0;;26050:2:1;38752:63:0;;;26032:21:1;26089:2;26069:18;;;26062:30;26128:33;26108:18;;;26101:61;26179:18;;38752:63:0;26022:181:1;38752:63:0;38162:1;38893:7;:18;70012:21:::1;:9;42451:19:::0;;42469:1;42451:19;;;42362:127;70012:21:::1;70046:15;70064:19;:9;42332:14:::0;;42240:114;70064:19:::1;70046:37;;70094:30;70104:10;70116:7;70094:9;:30::i;:::-;-1:-1:-1::0;38118:1:0;39072:7;:22;69955:177::o;54384:315::-;54539:8;-1:-1:-1;;;;;54530:17:0;:5;-1:-1:-1;;;;;54530:17:0;;;54522:55;;;;-1:-1:-1;;;54522:55:0;;16288:2:1;54522:55:0;;;16270:21:1;16327:2;16307:18;;;16300:30;16366:27;16346:18;;;16339:55;16411:18;;54522:55:0;16260:175:1;54522:55:0;-1:-1:-1;;;;;54588:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;54588:46:0;;;;;;;;;;54650:41;;11604::1;;;54650::0;;11577:18:1;54650:41:0;;;;;;;54384:315;;;:::o;49294:::-;49451:28;49461:4;49467:2;49471:7;49451:9;:28::i;:::-;49498:48;49521:4;49527:2;49531:7;49540:5;49498:22;:48::i;:::-;49490:111;;;;-1:-1:-1;;;49490:111:0;;;;;;;:::i;67054:100::-;67106:13;67139:7;67132:14;;;;;:::i;344:723::-;400:13;621:10;617:53;;-1:-1:-1;648:10:0;;;;;;;;;;;;-1:-1:-1;;;648:10:0;;;;;;617:53;695:5;680:12;736:78;743:9;;736:78;;769:8;;;;:::i;:::-;;-1:-1:-1;792:10:0;;-1:-1:-1;800:2:0;792:10;;:::i;:::-;;;736:78;;;824:19;856:6;846:17;;;;;;-1:-1:-1;;;846:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;846:17:0;;824:39;;874:154;881:10;;874:154;;908:11;918:1;908:11;;:::i;:::-;;-1:-1:-1;977:10:0;985:2;977:5;:10;:::i;:::-;964:24;;:2;:24;:::i;:::-;951:39;;934:6;941;934:14;;;;;;-1:-1:-1;;;934:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;934:56:0;;;;;;;;-1:-1:-1;1005:11:0;1014:2;1005:11;;:::i;:::-;;;874:154;;60872:589;-1:-1:-1;;;;;61078:18:0;;61074:187;;61113:40;61145:7;62288:10;:17;;62261:24;;;;:15;:24;;;;;:44;;;62316:24;;;;;;;;;;;;62184:164;61113:40;61074:187;;;61183:2;-1:-1:-1;;;;;61175:10:0;:4;-1:-1:-1;;;;;61175:10:0;;61171:90;;61202:47;61235:4;61241:7;61202:32;:47::i;:::-;-1:-1:-1;;;;;61275:16:0;;61271:183;;61308:45;61345:7;61308:36;:45::i;:::-;61271:183;;;61381:4;-1:-1:-1;;;;;61375:10:0;:2;-1:-1:-1;;;;;61375:10:0;;61371:83;;61402:40;61430:2;61434:7;61402:27;:40::i;28163:716::-;28587:23;28613:69;28641:4;28613:69;;;;;;;;;;;;;;;;;28621:5;-1:-1:-1;;;;;28613:27:0;;;:69;;;;;:::i;:::-;28697:17;;28587:95;;-1:-1:-1;28697:21:0;28693:179;;28794:10;28783:30;;;;;;;;;;;;:::i;:::-;28775:85;;;;-1:-1:-1;;;28775:85:0;;25284:2:1;28775:85:0;;;25266:21:1;25323:2;25303:18;;;25296:30;25362:34;25342:18;;;25335:62;-1:-1:-1;;;25413:18:1;;;25406:40;25463:19;;28775:85:0;25256:232:1;40511:675:0;40594:7;40637:4;40594:7;40652:497;40676:5;:12;40672:1;:16;40652:497;;;40710:20;40733:5;40739:1;40733:8;;;;;;-1:-1:-1;;;40733:8:0;;;;;;;;;;;;;;;40710:31;;40776:12;40760;:28;40756:382;;41262:13;41312:15;;;41348:4;41341:15;;;41395:4;41379:21;;40888:57;;40756:382;;;41262:13;41312:15;;;41348:4;41341:15;;;41395:4;41379:21;;41065:57;;40756:382;-1:-1:-1;40690:3:0;;;;:::i;:::-;;;;40652:497;;50906:110;50982:26;50992:2;50996:7;50982:26;;;;;;;;;;;;:9;:26::i;55264:799::-;55419:4;-1:-1:-1;;;;;55440:13:0;;3575:19;:23;55436:620;;55476:72;;-1:-1:-1;;;55476:72:0;;-1:-1:-1;;;;;55476:36:0;;;;;:72;;18584:10;;55527:4;;55533:7;;55542:5;;55476:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55476:72:0;;;;;;;;-1:-1:-1;;55476:72:0;;;;;;;;;;;;:::i;:::-;;;55472:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55718:13:0;;55714:272;;55761:60;;-1:-1:-1;;;55761:60:0;;;;;;;:::i;55714:272::-;55936:6;55930:13;55921:6;55917:2;55913:15;55906:38;55472:529;-1:-1:-1;;;;;;55599:51:0;-1:-1:-1;;;55599:51:0;;-1:-1:-1;55592:58:0;;55436:620;-1:-1:-1;56040:4:0;55264:799;;;;;;:::o;62975:988::-;63241:22;63291:1;63266:22;63283:4;63266:16;:22::i;:::-;:26;;;;:::i;:::-;63303:18;63324:26;;;:17;:26;;;;;;63241:51;;-1:-1:-1;63457:28:0;;;63453:328;;-1:-1:-1;;;;;63524:18:0;;63502:19;63524:18;;;:12;:18;;;;;;;;:34;;;;;;;;;63575:30;;;;;;:44;;;63692:30;;:17;:30;;;;;:43;;;63453:328;-1:-1:-1;63877:26:0;;;;:17;:26;;;;;;;;63870:33;;;-1:-1:-1;;;;;63921:18:0;;;;;:12;:18;;;;;:34;;;;;;;63914:41;62975:988::o;64258:1079::-;64536:10;:17;64511:22;;64536:21;;64556:1;;64536:21;:::i;:::-;64568:18;64589:24;;;:15;:24;;;;;;64962:10;:26;;64511:46;;-1:-1:-1;64589:24:0;;64511:46;;64962:26;;;;-1:-1:-1;;;64962:26:0;;;;;;;;;;;;;;;;;64940:48;;65026:11;65001:10;65012;65001:22;;;;;;-1:-1:-1;;;65001:22:0;;;;;;;;;;;;;;;;;;;;:36;;;;65106:28;;;:15;:28;;;;;;;:41;;;65278:24;;;;;65271:31;65313:10;:16;;;;;-1:-1:-1;;;65313:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;64258:1079;;;;:::o;61762:221::-;61847:14;61864:20;61881:2;61864:16;:20::i;:::-;-1:-1:-1;;;;;61895:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;61940:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;61762:221:0:o;6025:229::-;6162:12;6194:52;6216:6;6224:4;6230:1;6233:12;6194:21;:52::i;51243:321::-;51373:18;51379:2;51383:7;51373:5;:18::i;:::-;51424:54;51455:1;51459:2;51463:7;51472:5;51424:22;:54::i;:::-;51402:154;;;;-1:-1:-1;;;51402:154:0;;;;;;;:::i;7145:510::-;7315:12;7373:5;7348:21;:30;;7340:81;;;;-1:-1:-1;;;7340:81:0;;17427:2:1;7340:81:0;;;17409:21:1;17466:2;17446:18;;;17439:30;17505:34;17485:18;;;17478:62;-1:-1:-1;;;17556:18:1;;;17549:36;17602:19;;7340:81:0;17399:228:1;7340:81:0;-1:-1:-1;;;;;3575:19:0;;;7432:60;;;;-1:-1:-1;;;7432:60:0;;24100:2:1;7432:60:0;;;24082:21:1;24139:2;24119:18;;;24112:30;24178:31;24158:18;;;24151:59;24227:18;;7432:60:0;24072:179:1;7432:60:0;7506:12;7520:23;7547:6;-1:-1:-1;;;;;7547:11:0;7566:5;7573:4;7547:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7505:73;;;;7596:51;7613:7;7622:10;7634:12;7596:16;:51::i;:::-;7589:58;7145:510;-1:-1:-1;;;;;;;7145:510:0:o;51900:439::-;-1:-1:-1;;;;;51980:16:0;;51972:61;;;;-1:-1:-1;;;51972:61:0;;21021:2:1;51972:61:0;;;21003:21:1;;;21040:18;;;21033:30;21099:34;21079:18;;;21072:62;21151:18;;51972:61:0;20993:182:1;51972:61:0;49987:4;50011:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50011:16:0;:30;52044:58;;;;-1:-1:-1;;;52044:58:0;;14310:2:1;52044:58:0;;;14292:21:1;14349:2;14329:18;;;14322:30;14388;14368:18;;;14361:58;14436:18;;52044:58:0;14282:178:1;52044:58:0;52115:45;52144:1;52148:2;52152:7;52115:20;:45::i;:::-;-1:-1:-1;;;;;52173:13:0;;;;;;:9;:13;;;;;:18;;52190:1;;52173:13;:18;;52190:1;;52173:18;:::i;:::-;;;;-1:-1:-1;;52202:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;52202:21:0;-1:-1:-1;;;;;52202:21:0;;;;;;;;52241:33;;52202:16;;;52241:33;;52202:16;;52241:33;52287:44;46191:411;9831:712;9981:12;10010:7;10006:530;;;-1:-1:-1;10041:10:0;10034:17;;10006:530;10155:17;;:21;10151:374;;10353:10;10347:17;10414:15;10401:10;10397:2;10393:19;10386:44;10301:148;10496:12;10489:20;;-1:-1:-1;;;10489:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:257::-;;762:2;750:9;741:7;737:23;733:32;730:2;;;783:6;775;768:22;730:2;827:9;814:23;846:31;871:5;846:31;:::i;1182:398::-;;;1311:2;1299:9;1290:7;1286:23;1282:32;1279:2;;;1332:6;1324;1317:22;1279:2;1376:9;1363:23;1395:31;1420:5;1395:31;:::i;:::-;1445:5;-1:-1:-1;1502:2:1;1487:18;;1474:32;1515:33;1474:32;1515:33;:::i;:::-;1567:7;1557:17;;;1269:311;;;;;:::o;1585:466::-;;;;1731:2;1719:9;1710:7;1706:23;1702:32;1699:2;;;1752:6;1744;1737:22;1699:2;1796:9;1783:23;1815:31;1840:5;1815:31;:::i;:::-;1865:5;-1:-1:-1;1922:2:1;1907:18;;1894:32;1935:33;1894:32;1935:33;:::i;:::-;1689:362;;1987:7;;-1:-1:-1;;;2041:2:1;2026:18;;;;2013:32;;1689:362::o;2056:824::-;;;;;2228:3;2216:9;2207:7;2203:23;2199:33;2196:2;;;2250:6;2242;2235:22;2196:2;2294:9;2281:23;2313:31;2338:5;2313:31;:::i;:::-;2363:5;-1:-1:-1;2420:2:1;2405:18;;2392:32;2433:33;2392:32;2433:33;:::i;:::-;2485:7;-1:-1:-1;2539:2:1;2524:18;;2511:32;;-1:-1:-1;2594:2:1;2579:18;;2566:32;2621:18;2610:30;;2607:2;;;2658:6;2650;2643:22;2607:2;2686:22;;2739:4;2731:13;;2727:27;-1:-1:-1;2717:2:1;;2773:6;2765;2758:22;2717:2;2801:73;2866:7;2861:2;2848:16;2843:2;2839;2835:11;2801:73;:::i;:::-;2791:83;;;2186:694;;;;;;;:::o;2885:392::-;;;3011:2;2999:9;2990:7;2986:23;2982:32;2979:2;;;3032:6;3024;3017:22;2979:2;3076:9;3063:23;3095:31;3120:5;3095:31;:::i;:::-;3145:5;-1:-1:-1;3202:2:1;3187:18;;3174:32;3215:30;3174:32;3215:30;:::i;3282:325::-;;;3411:2;3399:9;3390:7;3386:23;3382:32;3379:2;;;3432:6;3424;3417:22;3379:2;3476:9;3463:23;3495:31;3520:5;3495:31;:::i;:::-;3545:5;3597:2;3582:18;;;;3569:32;;-1:-1:-1;;;3369:238:1:o;3612:869::-;;;;;3793:2;3781:9;3772:7;3768:23;3764:32;3761:2;;;3814:6;3806;3799:22;3761:2;3858:9;3845:23;3877:31;3902:5;3877:31;:::i;:::-;3927:5;-1:-1:-1;3979:2:1;3964:18;;3951:32;;-1:-1:-1;4034:2:1;4019:18;;4006:32;4057:18;4087:14;;;4084:2;;;4119:6;4111;4104:22;4084:2;4162:6;4151:9;4147:22;4137:32;;4207:7;4200:4;4196:2;4192:13;4188:27;4178:2;;4234:6;4226;4219:22;4178:2;4279;4266:16;4305:2;4297:6;4294:14;4291:2;;;4326:6;4318;4311:22;4291:2;4385:7;4380:2;4374;4366:6;4362:15;4358:2;4354:24;4350:33;4347:46;4344:2;;;4411:6;4403;4396:22;4344:2;3751:730;;;;-1:-1:-1;;4447:2:1;4439:11;;-1:-1:-1;;;3751:730:1:o;4486:255::-;;4606:2;4594:9;4585:7;4581:23;4577:32;4574:2;;;4627:6;4619;4612:22;4574:2;4664:9;4658:16;4683:28;4705:5;4683:28;:::i;4746:190::-;;4858:2;4846:9;4837:7;4833:23;4829:32;4826:2;;;4879:6;4871;4864:22;4826:2;-1:-1:-1;4907:23:1;;4816:120;-1:-1:-1;4816:120:1:o;4941:255::-;;5052:2;5040:9;5031:7;5027:23;5023:32;5020:2;;;5073:6;5065;5058:22;5020:2;5117:9;5104:23;5136:30;5160:5;5136:30;:::i;5201:259::-;;5323:2;5311:9;5302:7;5298:23;5294:32;5291:2;;;5344:6;5336;5329:22;5291:2;5381:9;5375:16;5400:30;5424:5;5400:30;:::i;5741:412::-;;;5884:2;5872:9;5863:7;5859:23;5855:32;5852:2;;;5905:6;5897;5890:22;6158:480;;6280:2;6268:9;6259:7;6255:23;6251:32;6248:2;;;6301:6;6293;6286:22;6248:2;6346:9;6333:23;6379:18;6371:6;6368:30;6365:2;;;6416:6;6408;6401:22;6365:2;6444:22;;6497:4;6489:13;;6485:27;-1:-1:-1;6475:2:1;;6531:6;6523;6516:22;6475:2;6559:73;6624:7;6619:2;6606:16;6601:2;6597;6593:11;6559:73;:::i;6838:194::-;;6961:2;6949:9;6940:7;6936:23;6932:32;6929:2;;;6982:6;6974;6967:22;6929:2;-1:-1:-1;7010:16:1;;6919:113;-1:-1:-1;6919:113:1:o;7037:257::-;;7116:5;7110:12;7143:6;7138:3;7131:19;7159:63;7215:6;7208:4;7203:3;7199:14;7192:4;7185:5;7181:16;7159:63;:::i;:::-;7276:2;7255:15;-1:-1:-1;;7251:29:1;7242:39;;;;7283:4;7238:50;;7086:208;-1:-1:-1;;7086:208:1:o;7533:274::-;;7700:6;7694:13;7716:53;7762:6;7757:3;7750:4;7742:6;7738:17;7716:53;:::i;:::-;7785:16;;;;;7670:137;-1:-1:-1;;7670:137:1:o;7812:1530::-;;8074:6;8068:13;8100:4;8113:51;8157:6;8152:3;8147:2;8139:6;8135:15;8113:51;:::i;:::-;8227:13;;8186:16;;;;8249:55;8227:13;8186:16;8271:15;;;8249:55;:::i;:::-;8395:13;;8326:20;;;8366:3;;8472:1;8457:17;;8493:1;8529:18;;;;8556:2;;8634:4;8624:8;8620:19;8608:31;;8556:2;8697;8687:8;8684:16;8664:18;8661:40;8658:2;;;-1:-1:-1;;;8724:33:1;;8780:4;8777:1;8770:15;8810:4;8731:3;8798:17;8658:2;8841:18;8868:110;;;;8992:1;8987:330;;;;8834:483;;8868:110;-1:-1:-1;;8903:24:1;;8889:39;;8948:20;;;;-1:-1:-1;8868:110:1;;8987:330;26390:127;26456:17;;;26506:4;26490:21;;9082:3;9098:169;9112:8;9109:1;9106:15;9098:169;;;9194:14;;9179:13;;;9172:37;9237:16;;;;9129:10;;9098:169;;;9102:3;;9298:8;9291:5;9287:20;9280:27;;8834:483;-1:-1:-1;9333:3:1;;8044:1298;-1:-1:-1;;;;;;;;;;;8044:1298:1:o;10052:488::-;-1:-1:-1;;;;;10321:15:1;;;10303:34;;10373:15;;10368:2;10353:18;;10346:43;10420:2;10405:18;;10398:34;;;10468:3;10463:2;10448:18;;10441:31;;;10052:488;;10489:45;;10514:19;;10506:6;10489:45;:::i;:::-;10481:53;10255:285;-1:-1:-1;;;;;;10255:285:1:o;10824:635::-;10995:2;11047:21;;;11117:13;;11020:18;;;11139:22;;;10824:635;;10995:2;11218:15;;;;11192:2;11177:18;;;10824:635;11264:169;11278:6;11275:1;11272:13;11264:169;;;11339:13;;11327:26;;11408:15;;;;11373:12;;;;11300:1;11293:9;11264:169;;;-1:-1:-1;11450:3:1;;10975:484;-1:-1:-1;;;;;;10975:484:1:o;11838:219::-;;11987:2;11976:9;11969:21;12007:44;12047:2;12036:9;12032:18;12024:6;12007:44;:::i;12474:414::-;12676:2;12658:21;;;12715:2;12695:18;;;12688:30;12754:34;12749:2;12734:18;;12727:62;-1:-1:-1;;;12820:2:1;12805:18;;12798:48;12878:3;12863:19;;12648:240::o;12893:397::-;13095:2;13077:21;;;13134:2;13114:18;;;13107:30;13173:34;13168:2;13153:18;;13146:62;-1:-1:-1;;;13239:2:1;13224:18;;13217:31;13280:3;13265:19;;13067:223::o;14868:401::-;15070:2;15052:21;;;15109:2;15089:18;;;15082:30;15148:34;15143:2;15128:18;;15121:62;-1:-1:-1;;;15214:2:1;15199:18;;15192:35;15259:3;15244:19;;15042:227::o;15274:402::-;15476:2;15458:21;;;15515:2;15495:18;;;15488:30;15554:34;15549:2;15534:18;;15527:62;-1:-1:-1;;;15620:2:1;15605:18;;15598:36;15666:3;15651:19;;15448:228::o;18045:407::-;18247:2;18229:21;;;18286:2;18266:18;;;18259:30;18325:34;18320:2;18305:18;;18298:62;-1:-1:-1;;;18391:2:1;18376:18;;18369:41;18442:3;18427:19;;18219:233::o;21954:356::-;22156:2;22138:21;;;22175:18;;;22168:30;22234:34;22229:2;22214:18;;22207:62;22301:2;22286:18;;22128:182::o;23133:342::-;23335:2;23317:21;;;23374:2;23354:18;;;23347:30;-1:-1:-1;;;23408:2:1;23393:18;;23386:48;23466:2;23451:18;;23307:168::o;23480:413::-;23682:2;23664:21;;;23721:2;23701:18;;;23694:30;23760:34;23755:2;23740:18;;23733:62;-1:-1:-1;;;23826:2:1;23811:18;;23804:47;23883:3;23868:19;;23654:239::o;24669:408::-;24871:2;24853:21;;;24910:2;24890:18;;;24883:30;24949:34;24944:2;24929:18;;24922:62;-1:-1:-1;;;25015:2:1;25000:18;;24993:42;25067:3;25052:19;;24843:234::o;26522:128::-;;26593:1;26589:6;26586:1;26583:13;26580:2;;;26599:18;;:::i;:::-;-1:-1:-1;26635:9:1;;26570:80::o;26655:120::-;;26721:1;26711:2;;26726:18;;:::i;:::-;-1:-1:-1;26760:9:1;;26701:74::o;26780:168::-;;26886:1;26882;26878:6;26874:14;26871:1;26868:21;26863:1;26856:9;26849:17;26845:45;26842:2;;;26893:18;;:::i;:::-;-1:-1:-1;26933:9:1;;26832:116::o;26953:125::-;;27021:1;27018;27015:8;27012:2;;;27026:18;;:::i;:::-;-1:-1:-1;27063:9:1;;27002:76::o;27083:258::-;27155:1;27165:113;27179:6;27176:1;27173:13;27165:113;;;27255:11;;;27249:18;27236:11;;;27229:39;27201:2;27194:10;27165:113;;;27296:6;27293:1;27290:13;27287:2;;;-1:-1:-1;;27331:1:1;27313:16;;27306:27;27136:205::o;27346:380::-;27431:1;27421:12;;27478:1;27468:12;;;27489:2;;27543:4;27535:6;27531:17;27521:27;;27489:2;27596;27588:6;27585:14;27565:18;27562:38;27559:2;;;27642:10;27637:3;27633:20;27630:1;27623:31;27677:4;27674:1;27667:15;27705:4;27702:1;27695:15;27559:2;;27401:325;;;:::o;27731:135::-;;-1:-1:-1;;27791:17:1;;27788:2;;;27811:18;;:::i;:::-;-1:-1:-1;27858:1:1;27847:13;;27778:88::o;27871:112::-;;27929:1;27919:2;;27934:18;;:::i;:::-;-1:-1:-1;27968:9:1;;27909:74::o;27988:127::-;28049:10;28044:3;28040:20;28037:1;28030:31;28080:4;28077:1;28070:15;28104:4;28101:1;28094:15;28120:127;28181:10;28176:3;28172:20;28169:1;28162:31;28212:4;28209:1;28202:15;28236:4;28233:1;28226:15;28252:127;28313:10;28308:3;28304:20;28301:1;28294:31;28344:4;28341:1;28334:15;28368:4;28365:1;28358:15;28384:131;-1:-1:-1;;;;;28459:31:1;;28449:42;;28439:2;;28505:1;28502;28495:12;28520:118;28606:5;28599:13;28592:21;28585:5;28582:32;28572:2;;28628:1;28625;28618:12;28643:131;-1:-1:-1;;;;;;28717:32:1;;28707:43;;28697:2;;28764:1;28761;28754:12

Swarm Source

ipfs://b4570b56ec1964352686298799f0416ad28ddb6c3a3c54924434d25063584ee2
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.