Token

Adneo Token (AT)

ERC-721

Overview

Max Total Supply

1,000 AT

Holders

244

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x3f0b6fe90aa17c59d200fa4baedc8935cea24f7c

Filtered by Token Holder

0xdAa7c1B5fEAca5D1bC1bea7E7C07d91d3e6dfe51

cvd.eth

Balance

12 AT

0xdaa7c1b5feaca5d1bc1bea7e7c07d91d3e6dfe51

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-24
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
    bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

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

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

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

        bytes memory table = TABLE;

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

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

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

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

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

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

            mstore(result, encodedLen)
        }

        return string(result);
    }
}


// File: @openzeppelin/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // 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);
    }

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

// File: @openzeppelin/contracts/utils/Context.sol


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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

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

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

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

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


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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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



// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.7.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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (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 `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: 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 Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


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

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.7.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: address zero is not a valid owner");
        return _balances[owner];
    }

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner 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: caller is not token 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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

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

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

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

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

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

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

        _afterTokenTransfer(address(0), to, 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 an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

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

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * 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 {}
}

interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/IOperatorFilterRegistry.sol

pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/OperatorFilterer.sol
pragma solidity ^0.8.13;

/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            // Allow spending tokens from addresses with balance
            // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
            // from an EOA.
            if (from == msg.sender) {
                _;
                return;
            }
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), msg.sender)) {
                revert OperatorNotAllowed(msg.sender);
            }
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
        _;
    }
}

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol
pragma solidity ^0.8.13;

/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}

pragma solidity ^0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

pragma solidity ^0.8.0;

/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
    abstract contract ERC721Pausable is ERC721, Ownable, Pausable {
    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);
        if (_msgSender() != owner()) {
            require(!paused(), "ERC721Pausable: token transfer while paused");
        }
    }
}

contract AT is ERC721Enumerable, ReentrancyGuard, DefaultOperatorFilterer, Pausable, Ownable {
    
    uint256 public price = 60000000000000000; //0.06 ETH
    uint256 public constant supplyCap = 1000;

    constructor() ERC721("Adneo Token", "AT") {}

    function tokenURI(uint256 tokenId) public pure override returns (string memory) {
        string[4] memory parts;
        parts[
            0
        ] = '<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 290 500"><g><rect width="100%" height="100%" fill="#000" border-radius="25px" rx="25" ry="25" /><g shape-rendering="geometricPrecision" transform="translate(1.000000,385.000000) scale(0.005500,-0.005500)" fill="#fff" stroke="none"><path shape-rendering="geometricPrecision" d="M8463 65783 c-4 -10 -352 -997 -774 -2193 l-767 -2175 -1361 -3 c-749 -1 -1361 -5 -1361 -10 0 -4 304 -869 676 -1922 372 -1053 676 -1924 676 -1935 0 -11 -304 -882 -676 -1935 -372 -1053 -676 -1918 -676 -1922 0 -5 612 -9 1361 -10 l1361 -3 772 -2190 772 -2190 1359 0 1359 0 772 2190 772 2190 1361 3 c749 1 1361 5 1361 10 0 4 -304 869 -676 1922 -372 1053 -676 1924 -676 1935 0 11 304 882 676 1935 372 1053 676 1918 676 1922 0 5 -612 9 -1361 10 l-1361 3 -772 2190 -772 2190 -1358 3 c-1285 2 -1357 1 -1363 -15z m2192 -4796 l781 -2322 -802 -3 c-441 -1 -1166 -1 -1611 0 l-809 3 781 2322 780 2323 50 0 50 0 780 -2323z m666 -4904 c-65 -192 -417 -1238 -782 -2325 l-664 -1978 -50 0 -50 0 -664 1978 c-365 1087 -717 2133 -782 2325 l-118 347 1614 0 1614 0 -118 -347z" /></g></g>';

        parts[1] = '<text transform="translate(23.000000,474.000000)" fill="#fff" font-family="sans-serif" font-size="10px" font-weight="bold">';

        parts[2] = string(abi.encodePacked('#', toString(tokenId)));

        parts[3] = '</text></svg>';

        
        string memory output = string(
            abi.encodePacked(parts[0], parts[1], parts[2], parts[3])
        );

        string memory json = Base64.encode(
            bytes(
                string(
                    abi.encodePacked(
                        '{"name": "Adneo Token #',
                        toString(tokenId),
                        '", "description": "", "image": "data:image/svg+xml;base64,',
                        Base64.encode(bytes(output)),
                        '"}'
                    )
                )
            )
        );
        output = string(abi.encodePacked("data:application/json;base64,", json));

            return output;

    }

    // =============================================================================
    
    function mint(uint256 tokenId) public payable nonReentrant {
        require(tokenId > 0 && tokenId <= 1000, "Token ID invalid");
        require(price <= msg.value, "Ether value sent is not correct");
        require(!paused(), "Pausable: paused");
        _safeMint(_msgSender(), tokenId);
    }
  
    // =============================================================================

    function withdraw() public onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
          
    }    
    
    // =============================================================================
    
    function pause(bool val) public onlyOwner {
        if (val == true) {
            _pause();
            return;
        }
        _unpause();
    }

    // =============================================================================
  
    // Operator Filter Registry https://github.com/ProjectOpenSea/operator-filter-registry
    function setApprovalForAll(address operator, bool approved) public override (ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override (ERC721, IERC721) 
        onlyAllowedOperator(from)
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }

    
    function toString(uint256 value) internal pure returns (string memory) {
    // Inspired by OraclizeAPI's implementation - MIT license
    // 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);
    }
    
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","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":[{"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","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":[{"internalType":"bool","name":"val","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"supplyCap","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":[{"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":"pure","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":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

58424:5364:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43439:224;;;;;;;;;;-1:-1:-1;43439:224:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;43439:224:0;;;;;;;;61688:154;;;;;;;;;;-1:-1:-1;61688:154:0;;;;;:::i;:::-;;:::i;:::-;;30277:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;31790:171::-;;;;;;;;;;-1:-1:-1;31790:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2061:32:1;;;2043:51;;2031:2;2016:18;31790:171:0;1897:203:1;62234:175:0;;;;;;;;;;-1:-1:-1;62234:175:0;;;;;:::i;:::-;;:::i;44079:113::-;;;;;;;;;;-1:-1:-1;44167:10:0;:17;44079:113;;;2688:25:1;;;2676:2;2661:18;44079:113:0;2542:177:1;62417:181:0;;;;;;;;;;-1:-1:-1;62417:181:0;;;;;:::i;:::-;;:::i;43747:256::-;;;;;;;;;;-1:-1:-1;43747:256:0;;;;;:::i;:::-;;:::i;61461:119::-;;;;;;;;;;;;;:::i;52596:143::-;;;;;;;;;;;;52696:42;52596:143;;62606:189;;;;;;;;;;-1:-1:-1;62606:189:0;;;;;:::i;:::-;;:::i;44269:233::-;;;;;;;;;;-1:-1:-1;44269:233:0;;;;;:::i;:::-;;:::i;56378:86::-;;;;;;;;;;-1:-1:-1;56449:7:0;;;;56378:86;;29988:222;;;;;;;;;;-1:-1:-1;29988:222:0;;;;;:::i;:::-;;:::i;29719:207::-;;;;;;;;;;-1:-1:-1;29719:207:0;;;;;:::i;:::-;;:::i;7298:103::-;;;;;;;;;;;;;:::i;6650:87::-;;;;;;;;;;-1:-1:-1;6723:6:0;;;;;-1:-1:-1;;;;;6723:6:0;6650:87;;58588:40;;;;;;;;;;;;58624:4;58588:40;;30446:104;;;;;;;;;;;;;:::i;58530:40::-;;;;;;;;;;;;;;;;61061:302;;;;;;:::i;:::-;;:::i;62032:194::-;;;;;;;;;;-1:-1:-1;62032:194:0;;;;;:::i;:::-;;:::i;62803:247::-;;;;;;;;;;-1:-1:-1;62803:247:0;;;;;:::i;:::-;;:::i;58689:2272::-;;;;;;;;;;-1:-1:-1;58689:2272:0;;;;;:::i;:::-;;:::i;32259:164::-;;;;;;;;;;-1:-1:-1;32259:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;32380:25:0;;;32356:4;32380:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;32259:164;7556:201;;;;;;;;;;-1:-1:-1;7556:201:0;;;;;:::i;:::-;;:::i;43439:224::-;43541:4;-1:-1:-1;;;;;;43565:50:0;;-1:-1:-1;;;43565:50:0;;:90;;;43619:36;43643:11;43619:23;:36::i;:::-;43558:97;43439:224;-1:-1:-1;;43439:224:0:o;61688:154::-;6536:13;:11;:13::i;:::-;61745:11;::::1;;61752:4;61745:11:::0;61741:73:::1;;61773:8;:6;:8::i;:::-;61688:154:::0;:::o;61741:73::-:1;61824:10;:8;:10::i;30277:100::-:0;30331:13;30364:5;30357:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30277:100;:::o;31790:171::-;31866:7;31886:23;31901:7;31886:14;:23::i;:::-;-1:-1:-1;31929:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;31929:24:0;;31790:171::o;62234:175::-;62348:8;52696:42;54590:45;:49;54586:225;;54661:67;;-1:-1:-1;;;54661:67:0;;54712:4;54661:67;;;5945:34:1;-1:-1:-1;;;;;6015:15:1;;5995:18;;;5988:43;52696:42:0;;54661;;5880:18:1;;54661:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54656:144;;54756:28;;-1:-1:-1;;;54756:28:0;;-1:-1:-1;;;;;2061:32:1;;54756:28:0;;;2043:51:1;2016:18;;54756:28:0;;;;;;;;54656:144;62369:32:::1;62383:8;62393:7;62369:13;:32::i;:::-;62234:175:::0;;;:::o;62417:181::-;62536:4;52696:42;53844:45;:49;53840:539;;54133:10;-1:-1:-1;;;;;54125:18:0;;;54121:85;;62553:37:::1;62572:4;62578:2;62582:7;62553:18;:37::i;:::-;54184:7:::0;;54121:85;54225:69;;-1:-1:-1;;;54225:69:0;;54276:4;54225:69;;;5945:34:1;54283:10:0;5995:18:1;;;5988:43;52696:42:0;;54225;;5880:18:1;;54225:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54220:148;;54322:30;;-1:-1:-1;;;54322:30:0;;54341:10;54322:30;;;2043:51:1;2016:18;;54322:30:0;1897:203:1;54220:148:0;62553:37:::1;62572:4;62578:2;62582:7;62553:18;:37::i;:::-;62417:181:::0;;;;:::o;43747:256::-;43844:7;43880:23;43897:5;43880:16;:23::i;:::-;43872:5;:31;43864:87;;;;-1:-1:-1;;;43864:87:0;;6494:2:1;43864:87:0;;;6476:21:1;6533:2;6513:18;;;6506:30;6572:34;6552:18;;;6545:62;-1:-1:-1;;;6623:18:1;;;6616:41;6674:19;;43864:87:0;6292:407:1;43864:87:0;-1:-1:-1;;;;;;43969:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;43747:256::o;61461:119::-;6536:13;:11;:13::i;:::-;61509:51:::1;::::0;61517:10:::1;::::0;61538:21:::1;61509:51:::0;::::1;;;::::0;::::1;::::0;;;61538:21;61517:10;61509:51;::::1;;;;;;;;;;;;;::::0;::::1;;;;62606:189:::0;62729:4;52696:42;53844:45;:49;53840:539;;54133:10;-1:-1:-1;;;;;54125:18:0;;;54121:85;;62746:41:::1;62769:4;62775:2;62779:7;62746:22;:41::i;54121:85::-:0;54225:69;;-1:-1:-1;;;54225:69:0;;54276:4;54225:69;;;5945:34:1;54283:10:0;5995:18:1;;;5988:43;52696:42:0;;54225;;5880:18:1;;54225:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54220:148;;54322:30;;-1:-1:-1;;;54322:30:0;;54341:10;54322:30;;;2043:51:1;2016:18;;54322:30:0;1897:203:1;54220:148:0;62746:41:::1;62769:4;62775:2;62779:7;62746:22;:41::i;44269:233::-:0;44344:7;44380:30;44167:10;:17;;44079:113;44380:30;44372:5;:38;44364:95;;;;-1:-1:-1;;;44364:95:0;;6906:2:1;44364:95:0;;;6888:21:1;6945:2;6925:18;;;6918:30;6984:34;6964:18;;;6957:62;-1:-1:-1;;;7035:18:1;;;7028:42;7087:19;;44364:95:0;6704:408:1;44364:95:0;44477:10;44488:5;44477:17;;;;;;;;:::i;:::-;;;;;;;;;44470:24;;44269:233;;;:::o;29988:222::-;30060:7;30096:16;;;:7;:16;;;;;;-1:-1:-1;;;;;30096:16:0;;30123:56;;;;-1:-1:-1;;;30123:56:0;;7451:2:1;30123:56:0;;;7433:21:1;7490:2;7470:18;;;7463:30;-1:-1:-1;;;7509:18:1;;;7502:54;7573:18;;30123:56:0;7249:348:1;29719:207:0;29791:7;-1:-1:-1;;;;;29819:19:0;;29811:73;;;;-1:-1:-1;;;29811:73:0;;7804:2:1;29811:73:0;;;7786:21:1;7843:2;7823:18;;;7816:30;7882:34;7862:18;;;7855:62;-1:-1:-1;;;7933:18:1;;;7926:39;7982:19;;29811:73:0;7602:405:1;29811:73:0;-1:-1:-1;;;;;;29902:16:0;;;;;:9;:16;;;;;;;29719:207::o;7298:103::-;6536:13;:11;:13::i;:::-;7363:30:::1;7390:1;7363:18;:30::i;:::-;7298:103::o:0;30446:104::-;30502:13;30535:7;30528:14;;;;;:::i;61061:302::-;9768:1;10364:7;;:19;10356:63;;;;-1:-1:-1;;;10356:63:0;;8214:2:1;10356:63:0;;;8196:21:1;8253:2;8233:18;;;8226:30;8292:33;8272:18;;;8265:61;8343:18;;10356:63:0;8012:355:1;10356:63:0;9768:1;10497:7;:18;61139:11;;;;;:30:::1;;;61165:4;61154:7;:15;;61139:30;61131:59;;;::::0;-1:-1:-1;;;61131:59:0;;8574:2:1;61131:59:0::1;::::0;::::1;8556:21:1::0;8613:2;8593:18;;;8586:30;-1:-1:-1;;;8632:18:1;;;8625:46;8688:18;;61131:59:0::1;8372:340:1::0;61131:59:0::1;61218:9;61209:5;;:18;;61201:62;;;::::0;-1:-1:-1;;;61201:62:0;;8919:2:1;61201:62:0::1;::::0;::::1;8901:21:1::0;8958:2;8938:18;;;8931:30;8997:33;8977:18;;;8970:61;9048:18;;61201:62:0::1;8717:355:1::0;61201:62:0::1;56449:7:::0;;;;61282:9:::1;61274:38;;;::::0;-1:-1:-1;;;61274:38:0;;9279:2:1;61274:38:0::1;::::0;::::1;9261:21:1::0;9318:2;9298:18;;;9291:30;-1:-1:-1;;;9337:18:1;;;9330:46;9393:18;;61274:38:0::1;9077:340:1::0;61274:38:0::1;61323:32;5281:10:::0;61347:7:::1;61323:9;:32::i;:::-;-1:-1:-1::0;9724:1:0;10676:7;:22;61061:302::o;62032:194::-;62154:8;52696:42;54590:45;:49;54586:225;;54661:67;;-1:-1:-1;;;54661:67:0;;54712:4;54661:67;;;5945:34:1;-1:-1:-1;;;;;6015:15:1;;5995:18;;;5988:43;52696:42:0;;54661;;5880:18:1;;54661:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54656:144;;54756:28;;-1:-1:-1;;;54756:28:0;;-1:-1:-1;;;;;2061:32:1;;54756:28:0;;;2043:51:1;2016:18;;54756:28:0;1897:203:1;54656:144:0;62175:43:::1;62199:8;62209;62175:23;:43::i;62803:247::-:0;62973:4;52696:42;53844:45;:49;53840:539;;54133:10;-1:-1:-1;;;;;54125:18:0;;;54121:85;;62995:47:::1;63018:4;63024:2;63028:7;63037:4;62995:22;:47::i;:::-;54184:7:::0;;54121:85;54225:69;;-1:-1:-1;;;54225:69:0;;54276:4;54225:69;;;5945:34:1;54283:10:0;5995:18:1;;;5988:43;52696:42:0;;54225;;5880:18:1;;54225:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54220:148;;54322:30;;-1:-1:-1;;;54322:30:0;;54341:10;54322:30;;;2043:51:1;2016:18;;54322:30:0;1897:203:1;54220:148:0;62995:47:::1;63018:4;63024:2;63028:7;63037:4;62995:22;:47::i;:::-;62803:247:::0;;;;;:::o;58689:2272::-;58754:13;58780:22;;:::i;:::-;58813:1163;;;;;;;;;;;;;;;;;;;59989:136;;;;;;;;;;;;;;58813:32;59989:136;;;:8;;;:136;60178:17;60187:7;60178:8;:17::i;:::-;60156:40;;;;;;;;:::i;:::-;;;;-1:-1:-1;;60156:40:0;;;;;;;;;60138:8;;;:59;;;60210:26;;;;;;;;;;-1:-1:-1;;;60138:8:0;60210:26;;;;;;;:8;;;:26;;;60320:8;;60330;;;;60340;;60303:56;;-1:-1:-1;;60303:56:0;;60320:8;;60330;;60210:26;;60303:56;;:::i;:::-;;;;;;;;;;;;;60259:111;;60383:18;60404:434;60580:17;60589:7;60580:8;:17::i;:::-;60711:28;60731:6;60711:13;:28::i;:::-;60485:308;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60404:13;:434::i;:::-;60383:455;;60915:4;60865:55;;;;;;;;:::i;:::-;;;;-1:-1:-1;;60865:55:0;;;;;;;;;;58689:2272;-1:-1:-1;;;;;58689:2272:0:o;7556:201::-;6536:13;:11;:13::i;:::-;-1:-1:-1;;;;;7645:22:0;::::1;7637:73;;;::::0;-1:-1:-1;;;7637:73:0;;12466:2:1;7637:73:0::1;::::0;::::1;12448:21:1::0;12505:2;12485:18;;;12478:30;12544:34;12524:18;;;12517:62;-1:-1:-1;;;12595:18:1;;;12588:36;12641:19;;7637:73:0::1;12264:402:1::0;7637:73:0::1;7721:28;7740:8;7721:18;:28::i;29350:305::-:0;29452:4;-1:-1:-1;;;;;;29489:40:0;;-1:-1:-1;;;29489:40:0;;:105;;-1:-1:-1;;;;;;;29546:48:0;;-1:-1:-1;;;29546:48:0;29489:105;:158;;;-1:-1:-1;;;;;;;;;;22215:40:0;;;29611:36;22106:157;6815:132;6723:6;;-1:-1:-1;;;;;6723:6:0;;;;;5281:10;6879:23;6871:68;;;;-1:-1:-1;;;6871:68:0;;12873:2:1;6871:68:0;;;12855:21:1;;;12892:18;;;12885:30;12951:34;12931:18;;;12924:62;13003:18;;6871:68:0;12671:356:1;57178:118:0;56449:7;;;;56703:9;56695:38;;;;-1:-1:-1;;;56695:38:0;;9279:2:1;56695:38:0;;;9261:21:1;9318:2;9298:18;;;9291:30;-1:-1:-1;;;9337:18:1;;;9330:46;9393:18;;56695:38:0;9077:340:1;56695:38:0;57238:7:::1;:14:::0;;-1:-1:-1;;57238:14:0::1;57248:4;57238:14;::::0;;57268:20:::1;57275:12;5281:10:::0;;5201:98;57275:12:::1;57268:20;::::0;-1:-1:-1;;;;;2061:32:1;;;2043:51;;2031:2;2016:18;57268:20:0::1;;;;;;;57178:118::o:0;57437:120::-;56449:7;;;;56973:41;;;;-1:-1:-1;;;56973:41:0;;13234:2:1;56973:41:0;;;13216:21:1;13273:2;13253:18;;;13246:30;-1:-1:-1;;;13292:18:1;;;13285:50;13352:18;;56973:41:0;13032:344:1;56973:41:0;57496:7:::1;:15:::0;;-1:-1:-1;;57496:15:0::1;::::0;;57527:22:::1;5281:10:::0;57536:12:::1;5201:98:::0;39121:135;35048:4;35072:16;;;:7;:16;;;;;;-1:-1:-1;;;;;35072:16:0;39195:53;;;;-1:-1:-1;;;39195:53:0;;7451:2:1;39195:53:0;;;7433:21:1;7490:2;7470:18;;;7463:30;-1:-1:-1;;;7509:18:1;;;7502:54;7573:18;;39195:53:0;7249:348:1;31307:417:0;31388:13;31404:23;31419:7;31404:14;:23::i;:::-;31388:39;;31452:5;-1:-1:-1;;;;;31446:11:0;:2;-1:-1:-1;;;;;31446:11:0;;31438:57;;;;-1:-1:-1;;;31438:57:0;;13583:2:1;31438:57:0;;;13565:21:1;13622:2;13602:18;;;13595:30;13661:34;13641:18;;;13634:62;-1:-1:-1;;;13712:18:1;;;13705:31;13753:19;;31438:57:0;13381:397:1;31438:57:0;5281:10;-1:-1:-1;;;;;31530:21:0;;;;:62;;-1:-1:-1;31555:37:0;31572:5;5281:10;32259:164;:::i;31555:37::-;31508:174;;;;-1:-1:-1;;;31508:174:0;;13985:2:1;31508:174:0;;;13967:21:1;14024:2;14004:18;;;13997:30;14063:34;14043:18;;;14036:62;14134:32;14114:18;;;14107:60;14184:19;;31508:174:0;13783:426:1;31508:174:0;31695:21;31704:2;31708:7;31695:8;:21::i;32490:336::-;32685:41;5281:10;32718:7;32685:18;:41::i;:::-;32677:100;;;;-1:-1:-1;;;32677:100:0;;;;;;;:::i;:::-;32790:28;32800:4;32806:2;32810:7;32790:9;:28::i;32897:185::-;33035:39;33052:4;33058:2;33062:7;33035:39;;;;;;;;;;;;:16;:39::i;7917:191::-;8010:6;;;-1:-1:-1;;;;;8027:17:0;;;8010:6;8027:17;;;-1:-1:-1;;;;;;8027:17:0;;;;;;8060:40;;8010:6;;;;;;;;8060:40;;7991:16;;8060:40;7980:128;7917:191;:::o;35883:110::-;35959:26;35969:2;35973:7;35959:26;;;;;;;;;;;;:9;:26::i;:::-;35883:110;;:::o;32033:155::-;32128:52;5281:10;32161:8;32171;32128:18;:52::i;33153:323::-;33327:41;5281:10;33360:7;33327:18;:41::i;:::-;33319:100;;;;-1:-1:-1;;;33319:100:0;;;;;;;:::i;:::-;33430:38;33444:4;33450:2;33454:7;33463:4;33430:13;:38::i;63064:715::-;63120:13;63333:5;63342:1;63333:10;63329:53;;-1:-1:-1;;63360:10:0;;;;;;;;;;;;-1:-1:-1;;;63360:10:0;;;;;63064:715::o;63329:53::-;63407:5;63392:12;63448:78;63455:9;;63448:78;;63481:8;;;;:::i;:::-;;-1:-1:-1;63504:10:0;;-1:-1:-1;63512:2:0;63504:10;;:::i;:::-;;;63448:78;;;63536:19;63568:6;63558:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63558:17:0;;63536:39;;63586:154;63593:10;;63586:154;;63620:11;63630:1;63620:11;;:::i;:::-;;-1:-1:-1;63689:10:0;63697:2;63689:5;:10;:::i;:::-;63676:24;;:2;:24;:::i;:::-;63663:39;;63646:6;63653;63646:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;63646:56:0;;;;;;;;-1:-1:-1;63717:11:0;63726:2;63717:11;;:::i;:::-;;;63586:154;;;63764:6;63064:715;-1:-1:-1;;;;63064:715:0:o;409:1607::-;507:11;;467:13;;493:11;533:8;;;529:23;;-1:-1:-1;;543:9:0;;;;;;;;;-1:-1:-1;543:9:0;;;409:1607;-1:-1:-1;409:1607:0:o;529:23::-;604:18;642:1;631:7;:3;637:1;631:7;:::i;:::-;630:13;;;;:::i;:::-;625:19;;:1;:19;:::i;:::-;604:40;-1:-1:-1;702:19:0;734:15;604:40;747:2;734:15;:::i;:::-;724:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;724:26:0;;702:48;;763:18;784:5;;;;;;;;;;;;;;;;;763:26;;853:1;846:5;842:13;898:2;890:6;886:15;949:1;917:777;972:3;969:1;966:10;917:777;;;1027:1;1070:12;;;;;1064:19;1165:4;1153:2;1149:14;;;;;1131:40;;1125:47;1274:2;1270:14;;;1266:25;;1252:40;;1246:47;1403:1;1399:13;;;1395:24;;1381:39;;1375:46;1523:16;;;;1509:31;;1503:38;1201:1;1197:11;;;1295:4;1242:58;;;1233:68;1326:11;;1371:57;;;1362:67;;;;1454:11;;1499:49;;1490:59;1578:3;1574:13;1607:22;;1677:1;1662:17;;;;1020:9;917:777;;;921:44;1726:1;1721:3;1717:11;1747:1;1742:84;;;;1845:1;1840:82;;;;1710:212;;1742:84;-1:-1:-1;;;;;1775:17:0;;1768:43;1742:84;;1840:82;-1:-1:-1;;;;;1873:17:0;;1866:41;1710:212;-1:-1:-1;;;1938:26:0;;;1945:6;409:1607;-1:-1:-1;;;;409:1607:0:o;38400:174::-;38475:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;38475:29:0;-1:-1:-1;;;;;38475:29:0;;;;;;;;:24;;38529:23;38475:24;38529:14;:23::i;:::-;-1:-1:-1;;;;;38520:46:0;;;;;;;;;;;38400:174;;:::o;35277:264::-;35370:4;35387:13;35403:23;35418:7;35403:14;:23::i;:::-;35387:39;;35456:5;-1:-1:-1;;;;;35445:16:0;:7;-1:-1:-1;;;;;35445:16:0;;:52;;;-1:-1:-1;;;;;;32380:25:0;;;32356:4;32380:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;35465:32;35445:87;;;;35525:7;-1:-1:-1;;;;;35501:31:0;:20;35513:7;35501:11;:20::i;:::-;-1:-1:-1;;;;;35501:31:0;;35437:96;35277:264;-1:-1:-1;;;;35277:264:0:o;37656:625::-;37815:4;-1:-1:-1;;;;;37788:31:0;:23;37803:7;37788:14;:23::i;:::-;-1:-1:-1;;;;;37788:31:0;;37780:81;;;;-1:-1:-1;;;37780:81:0;;15913:2:1;37780:81:0;;;15895:21:1;15952:2;15932:18;;;15925:30;15991:34;15971:18;;;15964:62;-1:-1:-1;;;16042:18:1;;;16035:35;16087:19;;37780:81:0;15711:401:1;37780:81:0;-1:-1:-1;;;;;37880:16:0;;37872:65;;;;-1:-1:-1;;;37872:65:0;;16319:2:1;37872:65:0;;;16301:21:1;16358:2;16338:18;;;16331:30;16397:34;16377:18;;;16370:62;-1:-1:-1;;;16448:18:1;;;16441:34;16492:19;;37872:65:0;16117:400:1;37872:65:0;37950:39;37971:4;37977:2;37981:7;37950:20;:39::i;:::-;38054:29;38071:1;38075:7;38054:8;:29::i;:::-;-1:-1:-1;;;;;38096:15:0;;;;;;:9;:15;;;;;:20;;38115:1;;38096:15;:20;;38115:1;;38096:20;:::i;:::-;;;;-1:-1:-1;;;;;;;38127:13:0;;;;;;:9;:13;;;;;:18;;38144:1;;38127:13;:18;;38144:1;;38127:18;:::i;:::-;;;;-1:-1:-1;;38156:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;38156:21:0;-1:-1:-1;;;;;38156:21:0;;;;;;;;;38195:27;;38156:16;;38195:27;;;;;;;62234:175;;;:::o;36220:319::-;36349:18;36355:2;36359:7;36349:5;:18::i;:::-;36400:53;36431:1;36435:2;36439:7;36448:4;36400:22;:53::i;:::-;36378:153;;;;-1:-1:-1;;;36378:153:0;;;;;;;:::i;38717:315::-;38872:8;-1:-1:-1;;;;;38863:17:0;:5;-1:-1:-1;;;;;38863:17:0;;38855:55;;;;-1:-1:-1;;;38855:55:0;;17143:2:1;38855:55:0;;;17125:21:1;17182:2;17162:18;;;17155:30;17221:27;17201:18;;;17194:55;17266:18;;38855:55:0;16941:349:1;38855:55:0;-1:-1:-1;;;;;38921:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;38921:46:0;;;;;;;;;;38983:41;;540::1;;;38983::0;;513:18:1;38983:41:0;;;;;;;38717:315;;;:::o;34357:313::-;34513:28;34523:4;34529:2;34533:7;34513:9;:28::i;:::-;34560:47;34583:4;34589:2;34593:7;34602:4;34560:22;:47::i;:::-;34552:110;;;;-1:-1:-1;;;34552:110:0;;;;;;;:::i;45115:589::-;-1:-1:-1;;;;;45321:18:0;;45317:187;;45356:40;45388:7;46531:10;:17;;46504:24;;;;:15;:24;;;;;:44;;;46559:24;;;;;;;;;;;;46427:164;45356:40;45317:187;;;45426:2;-1:-1:-1;;;;;45418:10:0;:4;-1:-1:-1;;;;;45418:10:0;;45414:90;;45445:47;45478:4;45484:7;45445:32;:47::i;:::-;-1:-1:-1;;;;;45518:16:0;;45514:183;;45551:45;45588:7;45551:36;:45::i;45514:183::-;45624:4;-1:-1:-1;;;;;45618:10:0;:2;-1:-1:-1;;;;;45618:10:0;;45614:83;;45645:40;45673:2;45677:7;45645:27;:40::i;36875:439::-;-1:-1:-1;;;;;36955:16:0;;36947:61;;;;-1:-1:-1;;;36947:61:0;;17497:2:1;36947:61:0;;;17479:21:1;;;17516:18;;;17509:30;17575:34;17555:18;;;17548:62;17627:18;;36947:61:0;17295:356:1;36947:61:0;35048:4;35072:16;;;:7;:16;;;;;;-1:-1:-1;;;;;35072:16:0;:30;37019:58;;;;-1:-1:-1;;;37019:58:0;;17858:2:1;37019:58:0;;;17840:21:1;17897:2;17877:18;;;17870:30;17936;17916:18;;;17909:58;17984:18;;37019:58:0;17656:352:1;37019:58:0;37090:45;37119:1;37123:2;37127:7;37090:20;:45::i;:::-;-1:-1:-1;;;;;37148:13:0;;;;;;:9;:13;;;;;:18;;37165:1;;37148:13;:18;;37165:1;;37148:18;:::i;:::-;;;;-1:-1:-1;;37177:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;37177:21:0;-1:-1:-1;;;;;37177:21:0;;;;;;;;37216:33;;37177:16;;;37216:33;;37177:16;;37216:33;35883:110;;:::o;39820:853::-;39974:4;-1:-1:-1;;;;;39995:13:0;;12245:19;:23;39991:675;;40031:71;;-1:-1:-1;;;40031:71:0;;-1:-1:-1;;;;;40031:36:0;;;;;:71;;5281:10;;40082:4;;40088:7;;40097:4;;40031:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40031:71:0;;;;;;;;-1:-1:-1;;40031:71:0;;;;;;;;;;;;:::i;:::-;;;40027:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40272:6;:13;40289:1;40272:18;40268:328;;40315:60;;-1:-1:-1;;;40315:60:0;;;;;;;:::i;40268:328::-;40546:6;40540:13;40531:6;40527:2;40523:15;40516:38;40027:584;-1:-1:-1;;;;;;40153:51:0;-1:-1:-1;;;40153:51:0;;-1:-1:-1;40146:58:0;;39991:675;-1:-1:-1;40650:4:0;39820:853;;;;;;:::o;47218:988::-;47484:22;47534:1;47509:22;47526:4;47509:16;:22::i;:::-;:26;;;;:::i;:::-;47546:18;47567:26;;;:17;:26;;;;;;47484:51;;-1:-1:-1;47700:28:0;;;47696:328;;-1:-1:-1;;;;;47767:18:0;;47745:19;47767:18;;;:12;:18;;;;;;;;:34;;;;;;;;;47818:30;;;;;;:44;;;47935:30;;:17;:30;;;;;:43;;;47696:328;-1:-1:-1;48120:26:0;;;;:17;:26;;;;;;;;48113:33;;;-1:-1:-1;;;;;48164:18:0;;;;;:12;:18;;;;;:34;;;;;;;48157:41;47218:988::o;48501:1079::-;48779:10;:17;48754:22;;48779:21;;48799:1;;48779:21;:::i;:::-;48811:18;48832:24;;;:15;:24;;;;;;49205:10;:26;;48754:46;;-1:-1:-1;48832:24:0;;48754:46;;49205:26;;;;;;:::i;:::-;;;;;;;;;49183:48;;49269:11;49244:10;49255;49244:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;49349:28;;;:15;:28;;;;;;;:41;;;49521:24;;;;;49514:31;49556:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;48572:1008;;;48501:1079;:::o;46005:221::-;46090:14;46107:20;46124:2;46107:16;:20::i;:::-;-1:-1:-1;;;;;46138:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;46183:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;46005:221:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:1:o;592:118::-;678:5;671:13;664:21;657:5;654:32;644:60;;700:1;697;690:12;715:241;771:6;824:2;812:9;803:7;799:23;795:32;792:52;;;840:1;837;830:12;792:52;879:9;866:23;898:28;920:5;898:28;:::i;961:258::-;1033:1;1043:113;1057:6;1054:1;1051:13;1043:113;;;1133:11;;;1127:18;1114:11;;;1107:39;1079:2;1072:10;1043:113;;;1174:6;1171:1;1168:13;1165:48;;;-1:-1:-1;;1209:1:1;1191:16;;1184:27;961:258::o;1224:::-;1266:3;1304:5;1298:12;1331:6;1326:3;1319:19;1347:63;1403:6;1396:4;1391:3;1387:14;1380:4;1373:5;1369:16;1347:63;:::i;:::-;1464:2;1443:15;-1:-1:-1;;1439:29:1;1430:39;;;;1471:4;1426:50;;1224:258;-1:-1:-1;;1224:258:1:o;1487:220::-;1636:2;1625:9;1618:21;1599:4;1656:45;1697:2;1686:9;1682:18;1674:6;1656:45;:::i;1712:180::-;1771:6;1824:2;1812:9;1803:7;1799:23;1795:32;1792:52;;;1840:1;1837;1830:12;1792:52;-1:-1:-1;1863:23:1;;1712:180;-1:-1:-1;1712:180:1:o;2105:173::-;2173:20;;-1:-1:-1;;;;;2222:31:1;;2212:42;;2202:70;;2268:1;2265;2258:12;2202:70;2105:173;;;:::o;2283:254::-;2351:6;2359;2412:2;2400:9;2391:7;2387:23;2383:32;2380:52;;;2428:1;2425;2418:12;2380:52;2451:29;2470:9;2451:29;:::i;:::-;2441:39;2527:2;2512:18;;;;2499:32;;-1:-1:-1;;;2283:254:1:o;2724:328::-;2801:6;2809;2817;2870:2;2858:9;2849:7;2845:23;2841:32;2838:52;;;2886:1;2883;2876:12;2838:52;2909:29;2928:9;2909:29;:::i;:::-;2899:39;;2957:38;2991:2;2980:9;2976:18;2957:38;:::i;:::-;2947:48;;3042:2;3031:9;3027:18;3014:32;3004:42;;2724:328;;;;;:::o;3297:186::-;3356:6;3409:2;3397:9;3388:7;3384:23;3380:32;3377:52;;;3425:1;3422;3415:12;3377:52;3448:29;3467:9;3448:29;:::i;3488:315::-;3553:6;3561;3614:2;3602:9;3593:7;3589:23;3585:32;3582:52;;;3630:1;3627;3620:12;3582:52;3653:29;3672:9;3653:29;:::i;:::-;3643:39;;3732:2;3721:9;3717:18;3704:32;3745:28;3767:5;3745:28;:::i;:::-;3792:5;3782:15;;;3488:315;;;;;:::o;3808:127::-;3869:10;3864:3;3860:20;3857:1;3850:31;3900:4;3897:1;3890:15;3924:4;3921:1;3914:15;3940:1138;4035:6;4043;4051;4059;4112:3;4100:9;4091:7;4087:23;4083:33;4080:53;;;4129:1;4126;4119:12;4080:53;4152:29;4171:9;4152:29;:::i;:::-;4142:39;;4200:38;4234:2;4223:9;4219:18;4200:38;:::i;:::-;4190:48;;4285:2;4274:9;4270:18;4257:32;4247:42;;4340:2;4329:9;4325:18;4312:32;4363:18;4404:2;4396:6;4393:14;4390:34;;;4420:1;4417;4410:12;4390:34;4458:6;4447:9;4443:22;4433:32;;4503:7;4496:4;4492:2;4488:13;4484:27;4474:55;;4525:1;4522;4515:12;4474:55;4561:2;4548:16;4583:2;4579;4576:10;4573:36;;;4589:18;;:::i;:::-;4664:2;4658:9;4632:2;4718:13;;-1:-1:-1;;4714:22:1;;;4738:2;4710:31;4706:40;4694:53;;;4762:18;;;4782:22;;;4759:46;4756:72;;;4808:18;;:::i;:::-;4848:10;4844:2;4837:22;4883:2;4875:6;4868:18;4923:7;4918:2;4913;4909;4905:11;4901:20;4898:33;4895:53;;;4944:1;4941;4934:12;4895:53;5000:2;4995;4991;4987:11;4982:2;4974:6;4970:15;4957:46;5045:1;5040:2;5035;5027:6;5023:15;5019:24;5012:35;5066:6;5056:16;;;;;;;3940:1138;;;;;;;:::o;5083:260::-;5151:6;5159;5212:2;5200:9;5191:7;5187:23;5183:32;5180:52;;;5228:1;5225;5218:12;5180:52;5251:29;5270:9;5251:29;:::i;:::-;5241:39;;5299:38;5333:2;5322:9;5318:18;5299:38;:::i;:::-;5289:48;;5083:260;;;;;:::o;5348:380::-;5427:1;5423:12;;;;5470;;;5491:61;;5545:4;5537:6;5533:17;5523:27;;5491:61;5598:2;5590:6;5587:14;5567:18;5564:38;5561:161;;5644:10;5639:3;5635:20;5632:1;5625:31;5679:4;5676:1;5669:15;5707:4;5704:1;5697:15;5561:161;;5348:380;;;:::o;6042:245::-;6109:6;6162:2;6150:9;6141:7;6137:23;6133:32;6130:52;;;6178:1;6175;6168:12;6130:52;6210:9;6204:16;6229:28;6251:5;6229:28;:::i;7117:127::-;7178:10;7173:3;7169:20;7166:1;7159:31;7209:4;7206:1;7199:15;7233:4;7230:1;7223:15;9422:418;-1:-1:-1;;;9679:3:1;9672:16;9654:3;9717:6;9711:13;9733:61;9787:6;9783:1;9778:3;9774:11;9767:4;9759:6;9755:17;9733:61;:::i;:::-;9814:16;;;;9832:1;9810:24;;9422:418;-1:-1:-1;;9422:418:1:o;9845:858::-;10120:3;10158:6;10152:13;10174:53;10220:6;10215:3;10208:4;10200:6;10196:17;10174:53;:::i;:::-;10290:13;;10249:16;;;;10312:57;10290:13;10249:16;10346:4;10334:17;;10312:57;:::i;:::-;10436:13;;10391:20;;;10458:57;10436:13;10391:20;10492:4;10480:17;;10458:57;:::i;:::-;10582:13;;10537:20;;;10604:57;10582:13;10537:20;10638:4;10626:17;;10604:57;:::i;:::-;10677:20;;9845:858;-1:-1:-1;;;;;;9845:858:1:o;10708:1098::-;11220:66;11215:3;11208:79;11190:3;11316:6;11310:13;11332:62;11387:6;11382:2;11377:3;11373:12;11366:4;11358:6;11354:17;11332:62;:::i;:::-;11458:66;11453:2;11413:16;;;11445:11;;;11438:87;11554:28;11549:2;11541:11;;11534:49;11608:13;;11630:63;11608:13;11679:2;11671:11;;11664:4;11652:17;;11630:63;:::i;:::-;-1:-1:-1;;;11753:2:1;11712:17;;;;11745:11;;;11738:35;11797:2;11789:11;;10708:1098;-1:-1:-1;;;;10708:1098:1:o;11811:448::-;12073:31;12068:3;12061:44;12043:3;12134:6;12128:13;12150:62;12205:6;12200:2;12195:3;12191:12;12184:4;12176:6;12172:17;12150:62;:::i;:::-;12232:16;;;;12250:2;12228:25;;11811:448;-1:-1:-1;;11811:448:1:o;14214:410::-;14416:2;14398:21;;;14455:2;14435:18;;;14428:30;14494:34;14489:2;14474:18;;14467:62;-1:-1:-1;;;14560:2:1;14545:18;;14538:44;14614:3;14599:19;;14214:410::o;14629:127::-;14690:10;14685:3;14681:20;14678:1;14671:31;14721:4;14718:1;14711:15;14745:4;14742:1;14735:15;14761:135;14800:3;14821:17;;;14818:43;;14841:18;;:::i;:::-;-1:-1:-1;14888:1:1;14877:13;;14761:135::o;14901:127::-;14962:10;14957:3;14953:20;14950:1;14943:31;14993:4;14990:1;14983:15;15017:4;15014:1;15007:15;15033:120;15073:1;15099;15089:35;;15104:18;;:::i;:::-;-1:-1:-1;15138:9:1;;15033:120::o;15158:125::-;15198:4;15226:1;15223;15220:8;15217:34;;;15231:18;;:::i;:::-;-1:-1:-1;15268:9:1;;15158:125::o;15288:112::-;15320:1;15346;15336:35;;15351:18;;:::i;:::-;-1:-1:-1;15385:9:1;;15288:112::o;15405:128::-;15445:3;15476:1;15472:6;15469:1;15466:13;15463:39;;;15482:18;;:::i;:::-;-1:-1:-1;15518:9:1;;15405:128::o;15538:168::-;15578:7;15644:1;15640;15636:6;15632:14;15629:1;15626:21;15621:1;15614:9;15607:17;15603:45;15600:71;;;15651:18;;:::i;:::-;-1:-1:-1;15691:9:1;;15538:168::o;16522:414::-;16724:2;16706:21;;;16763:2;16743:18;;;16736:30;16802:34;16797:2;16782:18;;16775:62;-1:-1:-1;;;16868:2:1;16853:18;;16846:48;16926:3;16911:19;;16522:414::o;18013:489::-;-1:-1:-1;;;;;18282:15:1;;;18264:34;;18334:15;;18329:2;18314:18;;18307:43;18381:2;18366:18;;18359:34;;;18429:3;18424:2;18409:18;;18402:31;;;18207:4;;18450:46;;18476:19;;18468:6;18450:46;:::i;:::-;18442:54;18013:489;-1:-1:-1;;;;;;18013:489:1:o;18507:249::-;18576:6;18629:2;18617:9;18608:7;18604:23;18600:32;18597:52;;;18645:1;18642;18635:12;18597:52;18677:9;18671:16;18696:30;18720:5;18696:30;:::i;18761:127::-;18822:10;18817:3;18813:20;18810:1;18803:31;18853:4;18850:1;18843:15;18877:4;18874:1;18867:15

Swarm Source

ipfs://1bcd589a13631f418902e1ecd4e99e407cba092e01230902c8e9c3c2dc9635fc

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.

Tools & Services