Token

LoserApeClubOfficial1 (LACO1)

ERC-721

Overview

Max Total Supply

7,777 LACO1

Holders

1,262

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x8df62bdc215bcf5f1acffccb206fe01e63c3dfff

Filtered by Token Holder

0x3ebceB1D81705B238FED9AD02F8fAE69EA1199c5

Balance

10 LACO1

0x3ebceb1d81705b238fed9ad02f8fae69ea1199c5

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

LoserApeClubOfficial1

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

/**
 *Submitted for verification at Etherscan.io on 2022-04-08
*/

// SPDX-License-Identifier: MIT

// File 1: Address.sol

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// FILE 2: 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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File 3: Strings.sol

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

pragma solidity ^0.8.0;

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

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

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

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

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


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


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File 4: 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 () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}





// File 5: 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 6: IERC721.sol

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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



// File 7: 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 returns (string memory);
}




// File 8: 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 9: ERC721.sol

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

pragma solidity ^0.8.0;


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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be 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 owner nor approved for all"
        );
        if (to.isContract()) {
            revert ("Token transfer to contract address is not allowed.");
        } else {
            _approve(to, tokenId);
        }
        // _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

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

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

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

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





// File 10: IERC721Enumerable.sol

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

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

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






// File 11: ERC721Enumerable.sol

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



// File 12: IERC721Receiver.sol

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

pragma solidity ^0.8.0;

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



// File 13: ERC721A.sol

pragma solidity ^0.8.0;


error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, Ownable {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex = 1;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    //Allow all tokens to transfer to contract
    bool public allowedToContract = false;

    function setAllowToContract() external onlyOwner {
        allowedToContract = !allowedToContract;
    }

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

    // Mapping token to allow to transfer to contract
    mapping(uint256 => bool) public _transferToContract;


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

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




    function setAllowTokenToContract(uint256 _tokenId, bool _allow) external onlyOwner {
        _transferToContract[_tokenId] = _allow;
    }

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex times
        unchecked {
            return _currentIndex - _burnCounter;    
        }
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenByIndex(uint256 index) public view override returns (uint256) {
        uint256 numMintedSoFar = _currentIndex;
        uint256 tokenIdsIdx;

        // Counter overflow is impossible as the loop breaks when
        // uint256 i is equal to another uint256 numMintedSoFar.
        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (!ownership.burned) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }
        revert TokenIndexOutOfBounds();
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        if (index >= balanceOf(owner)) revert OwnerIndexOutOfBounds();
        uint256 numMintedSoFar = _currentIndex;
        uint256 tokenIdsIdx;
        address currOwnershipAddr;

        // Counter overflow is impossible as the loop breaks when
        // uint256 i is equal to another uint256 numMintedSoFar.
        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }

        // Execution should never reach this point.
        revert();
    }

    /**
     * @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 ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    function _numberMinted(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert MintedQueryForZeroAddress();
        return uint256(_addressData[owner].numberMinted);
    }

    function _numberBurned(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert BurnedQueryForZeroAddress();
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant: 
                    // There will always be an ownership that has an address and is not burned 
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return ownershipOf(tokenId).addr;
    }

    /**
     * @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 virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }
        if(!allowedToContract && !_transferToContract[tokenId]){
            if (to.isContract()) {
                revert ("Token transfer to contract address is not allowed.");
            } else {
                _approve(to, tokenId, owner);
            }
        } else {
            _approve(to, tokenId, owner);
        }
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public override {
        if (operator == _msgSender()) revert ApproveToCaller();
        
        if(!allowedToContract){
            if (operator.isContract()) {
                revert ("Token transfer to contract address is not allowed.");
            } else {
                _operatorApprovals[_msgSender()][operator] = approved;
                emit ApprovalForAll(_msgSender(), operator, approved);
            }
        } else {
            _operatorApprovals[_msgSender()][operator] = approved;
            emit ApprovalForAll(_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 {
        _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 {
        _transfer(from, to, tokenId);
        if (!_checkOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        require(tokenId > 0, "Invalid TokenId");
        return tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;

            for (uint256 i; i < quantity; i++) {
                emit Transfer(address(0), to, updatedIndex);
                if (safe && !_checkOnERC721Received(address(0), to, updatedIndex, _data)) {
                    revert TransferToNonERC721ReceiverImplementer();
                }
                updatedIndex++;
            }

            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

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

        _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[prevOwnership.addr].balance -= 1;
            _addressData[prevOwnership.addr].numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            _ownerships[tokenId].addr = prevOwnership.addr;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);
            _ownerships[tokenId].burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(prevOwnership.addr, address(0), tokenId);
        _afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked { 
            _burnCounter++;
        }
    }

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

    /**
     * @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(!allowedToContract && !_transferToContract[tokenId]){
            if (to.isContract()) {
                revert ("Token transfer to contract address is not allowed.");
            } else {
                return true;
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * 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, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// FILE 14: T12.sol

pragma solidity ^0.8.0;

contract LoserApeClubOfficial1 is ERC721A {
  using Strings for uint256;
  using Counters for Counters.Counter;

  Counters.Counter private supply;

  string private uriPrefix = "";
  string public uriSuffix = ".json";
  string private hiddenMetadataUri;

    constructor() ERC721A("LoserApeClubOfficial1", "LACO1") {
        setHiddenMetadataUri("ipfs://__CID__/hidden.json");
    }

    uint256 public constant maxSupply = 7777;
    uint256 private mintCount = 0;
    uint256 public maxMintPerTx = 10;
    uint256 public maxMintPerWallet = 10;   
    uint256 public price = 0.022 ether;
     
  bool public paused = false;
  bool public revealed = false;


  mapping (address => uint256) public addressMintedBalance;


    event Minted(uint256 totalMinted);

      
    function totalSupply() public view override returns (uint256) {
        return mintCount;
    }

    function changePrice(uint256 _newPrice) external onlyOwner {
        price = _newPrice;
    }

    function withdraw() external onlyOwner {
        (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }

    function mint(uint256 _count) external payable {

        require(!paused, "The contract is paused!");

        require(totalSupply() + _count <= maxSupply, "Exceeds maximum supply");
        require(_count > 0, "Minimum 1 NFT has to be minted per transaction");

        if (msg.sender != owner()) {
            require(
                _count <= maxMintPerTx,
                "Maximum NFTs can be minted per transaction"
            );
            require(
                msg.value >= price * _count,
                "Ether sent with this transaction is not correct"
            );

            uint256 ownerMintedCount = addressMintedBalance[msg.sender];
            require (ownerMintedCount + _count <= maxMintPerWallet, "max per address exceeded!");
        }

        mintCount += _count;
        addressMintedBalance[msg.sender]+= _count;      
        _safeMint(msg.sender, _count);
        emit Minted(_count);       
    }

    function walletOfOwner(address _owner)
        public
        view
        returns (uint256[] memory)
    {
        uint256 ownerTokenCount = balanceOf(_owner);
        uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
        uint256 currentTokenId = 1;
        uint256 ownedTokenIndex = 0;

        while (ownedTokenIndex < ownerTokenCount && currentTokenId <= maxSupply) {
        address currentTokenOwner = ownerOf(currentTokenId);

        if (currentTokenOwner == _owner) {
            ownedTokenIds[ownedTokenIndex] = currentTokenId;

            ownedTokenIndex++;
        }

        currentTokenId++;
        }

        return ownedTokenIds;
    }
  
  function tokenURI(uint256 _tokenId)
    public
    /*view*/
    virtual
    override
    returns (string memory)
  {
    require(
      _exists(_tokenId),
      "ERC721Metadata: URI query for nonexistent token"
    );

    if (revealed == false) {
      return hiddenMetadataUri;
    }

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

  function setRevealed(bool _state) public onlyOwner {
    revealed = _state;
  }  

  function setMaxMintPerTx(uint256 _maxMintPerTx) public onlyOwner {
    maxMintPerTx = _maxMintPerTx;
  }

  function setMaxMintPerWallet(uint256 _maxMintPerWallet) public onlyOwner {
    maxMintPerWallet = _maxMintPerWallet;
  }  

  function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
    hiddenMetadataUri = _hiddenMetadataUri;
  }  

  function setUriPrefix(string memory _uriPrefix) public onlyOwner {
    uriPrefix = _uriPrefix;
  }  

  function setUriSuffix(string memory _uriSuffix) public onlyOwner {
    uriSuffix = _uriSuffix;
  }

  function setPaused(bool _state) public onlyOwner {
    paused = _state;
  }

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerIndexOutOfBounds","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TokenIndexOutOfBounds","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"totalMinted","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_transferToContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressMintedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowedToContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrice","type":"uint256"}],"name":"changePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","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":[],"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":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setAllowToContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"bool","name":"_allow","type":"bool"}],"name":"setAllowTokenToContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hiddenMetadataUri","type":"string"}],"name":"setHiddenMetadataUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxMintPerTx","type":"uint256"}],"name":"setMaxMintPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxMintPerWallet","type":"uint256"}],"name":"setMaxMintPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriPrefix","type":"string"}],"name":"setUriPrefix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriSuffix","type":"string"}],"name":"setUriSuffix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"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":"nonpayable","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":"uriSuffix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","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

69657:4263:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52733:372;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55343:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57154:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56420:668;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73610:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73716:77;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70459:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70342:56;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58392:170;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51556:1105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70667:182;;;;;;;;;;;;;:::i;:::-;;58633:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71824:695;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48562:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50543:713;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73362:132;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70305:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69848:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49622:140;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70274:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73120:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55152:124;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53169:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14781:148;;;;;;;;;;;;;:::i;:::-;;73502:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48608:106;;;;;;;;;;;;;:::i;:::-;;14130:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55512:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70228:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70857:959;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57430:660;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70564:95;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73232:122;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70182:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58889:342;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49360:51;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72527:498;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70060:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70143:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73031:81;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58161:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15084:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52733:372;52835:4;52887:25;52872:40;;;:11;:40;;;;:105;;;;52944:33;52929:48;;;:11;:48;;;;52872:105;:172;;;;53009:35;52994:50;;;:11;:50;;;;52872:172;:225;;;;53061:36;53085:11;53061:23;:36::i;:::-;52872:225;52852:245;;52733:372;;;:::o;55343:100::-;55397:13;55430:5;55423:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55343:100;:::o;57154:204::-;57222:7;57247:16;57255:7;57247;:16::i;:::-;57242:64;;57272:34;;;;;;;;;;;;;;57242:64;57326:15;:24;57342:7;57326:24;;;;;;;;;;;;;;;;;;;;;57319:31;;57154:204;;;:::o;56420:668::-;56493:13;56509:24;56525:7;56509:15;:24::i;:::-;56493:40;;56554:5;56548:11;;:2;:11;;;56544:48;;;56568:24;;;;;;;;;;;;;;56544:48;56625:5;56609:21;;:12;:10;:12::i;:::-;:21;;;;:63;;;;;56635:37;56652:5;56659:12;:10;:12::i;:::-;56635:16;:37::i;:::-;56634:38;56609:63;56605:138;;;56696:35;;;;;;;;;;;;;;56605:138;56757:17;;;;;;;;;;;56756:18;:51;;;;;56779:19;:28;56799:7;56779:28;;;;;;;;;;;;;;;;;;;;;56778:29;56756:51;56753:328;;;56827:15;:2;:13;;;:15::i;:::-;56823:186;;;56863:61;;;;;;;;;;:::i;:::-;;;;;;;;56823:186;56965:28;56974:2;56978:7;56987:5;56965:8;:28::i;:::-;56753:328;;;57041:28;57050:2;57054:7;57063:5;57041:8;:28::i;:::-;56753:328;56482:606;56420:668;;:::o;73610:100::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73694:10:::1;73682:9;:22;;;;;;;;;;;;:::i;:::-;;73610:100:::0;:::o;73716:77::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73781:6:::1;73772;;:15;;;;;;;;;;;;;;;;;;73716:77:::0;:::o;70459:97::-;70512:7;70539:9;;70532:16;;70459:97;:::o;70342:56::-;;;;;;;;;;;;;;;;;:::o;58392:170::-;58526:28;58536:4;58542:2;58546:7;58526:9;:28::i;:::-;58392:170;;;:::o;51556:1105::-;51645:7;51678:16;51688:5;51678:9;:16::i;:::-;51669:5;:25;51665:61;;51703:23;;;;;;;;;;;;;;51665:61;51737:22;51762:13;;51737:38;;51786:19;51816:25;52017:9;52012:557;52032:14;52028:1;:18;52012:557;;;52072:31;52106:11;:14;52118:1;52106:14;;;;;;;;;;;52072:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52143:9;:16;;;52139:73;;;52184:8;;;52139:73;52260:1;52234:28;;:9;:14;;;:28;;;52230:111;;52307:9;:14;;;52287:34;;52230:111;52384:5;52363:26;;:17;:26;;;52359:195;;;52433:5;52418:11;:20;52414:85;;;52474:1;52467:8;;;;;;;;;52414:85;52521:13;;;;;;;52359:195;52053:516;52012:557;52048:3;;;;;;;52012:557;;;;52645:8;;;51556:1105;;;;;:::o;70667:182::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70718:12:::1;70744:10;70736:24;;70768:21;70736:58;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70717:77;;;70813:7;70805:36;;;;;;;;;;;;:::i;:::-;;;;;;;;;70706:143;70667:182::o:0;58633:185::-;58771:39;58788:4;58794:2;58798:7;58771:39;;;;;;;;;;;;:16;:39::i;:::-;58633:185;;;:::o;71824:695::-;71911:16;71945:23;71971:17;71981:6;71971:9;:17::i;:::-;71945:43;;71999:30;72046:15;72032:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71999:63;;72073:22;72098:1;72073:26;;72110:23;72150:329;72175:15;72157;:33;:64;;;;;70096:4;72194:14;:27;;72157:64;72150:329;;;72234:25;72262:23;72270:14;72262:7;:23::i;:::-;72234:51;;72323:6;72302:27;;:17;:27;;;72298:141;;;72379:14;72346:13;72360:15;72346:30;;;;;;;;:::i;:::-;;;;;;;:47;;;;;72410:17;;;;;:::i;:::-;;;;72298:141;72451:16;;;;;:::i;:::-;;;;72223:256;72150:329;;;72498:13;72491:20;;;;;;71824:695;;;:::o;48562:37::-;;;;;;;;;;;;;:::o;50543:713::-;50610:7;50630:22;50655:13;;50630:38;;50679:19;50874:9;50869:328;50889:14;50885:1;:18;50869:328;;;50929:31;50963:11;:14;50975:1;50963:14;;;;;;;;;;;50929:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51001:9;:16;;;50996:186;;51061:5;51046:11;:20;51042:85;;;51102:1;51095:8;;;;;;;;51042:85;51149:13;;;;;;;50996:186;50910:287;50905:3;;;;;;;50869:328;;;;51225:23;;;;;;;;;;;;;;50543:713;;;;:::o;73362:132::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73470:18:::1;73450:17;:38;;;;;;;;;;;;:::i;:::-;;73362:132:::0;:::o;70305:28::-;;;;;;;;;;;;;:::o;69848:33::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49622:140::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49748:6:::1;49716:19;:29;49736:8;49716:29;;;;;;;;;;;;:38;;;;;;;;;;;;;;;;;;49622:140:::0;;:::o;70274:26::-;;;;;;;;;;;;;:::o;73120:106::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73207:13:::1;73192:12;:28;;;;73120:106:::0;:::o;55152:124::-;55216:7;55243:20;55255:7;55243:11;:20::i;:::-;:25;;;55236:32;;55152:124;;;:::o;53169:206::-;53233:7;53274:1;53257:19;;:5;:19;;;53253:60;;;53285:28;;;;;;;;;;;;;;53253:60;53339:12;:19;53352:5;53339:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;53331:36;;53324:43;;53169:206;;;:::o;14781:148::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14888:1:::1;14851:40;;14872:6;::::0;::::1;;;;;;;;14851:40;;;;;;;;;;;;14919:1;14902:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;14781:148::o:0;73502:100::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73586:10:::1;73574:9;:22;;;;;;;;;;;;:::i;:::-;;73502:100:::0;:::o;48608:106::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;48689:17:::1;;;;;;;;;;;48688:18;48668:17;;:38;;;;;;;;;;;;;;;;;;48608:106::o:0;14130:87::-;14176:7;14203:6;;;;;;;;;;;14196:13;;14130:87;:::o;55512:104::-;55568:13;55601:7;55594:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55512:104;:::o;70228:34::-;;;;:::o;70857:959::-;70926:6;;;;;;;;;;;70925:7;70917:43;;;;;;;;;;;;:::i;:::-;;;;;;;;;70096:4;70997:6;70981:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:35;;70973:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;71071:1;71062:6;:10;71054:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;71154:7;:5;:7::i;:::-;71140:21;;:10;:21;;;71136:506;;71214:12;;71204:6;:22;;71178:126;;;;;;;;;;;;:::i;:::-;;;;;;;;;71366:6;71358:5;;:14;;;;:::i;:::-;71345:9;:27;;71319:136;;;;;;;;;;;;:::i;:::-;;;;;;;;;71472:24;71499:20;:32;71520:10;71499:32;;;;;;;;;;;;;;;;71472:59;;71584:16;;71574:6;71555:16;:25;;;;:::i;:::-;:45;;71546:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;71163:479;71136:506;71667:6;71654:9;;:19;;;;;;;:::i;:::-;;;;;;;;71719:6;71684:20;:32;71705:10;71684:32;;;;;;;;;;;;;;;;:41;;;;;;;:::i;:::-;;;;;;;;71742:29;71752:10;71764:6;71742:9;:29::i;:::-;71787:14;71794:6;71787:14;;;;;;:::i;:::-;;;;;;;;70857:959;:::o;57430:660::-;57533:12;:10;:12::i;:::-;57521:24;;:8;:24;;;57517:54;;;57554:17;;;;;;;;;;;;;;57517:54;57596:17;;;;;;;;;;;57592:491;;57633:21;:8;:19;;;:21::i;:::-;57629:289;;;57675:61;;;;;;;;;;:::i;:::-;;;;;;;;57629:289;57822:8;57777:18;:32;57796:12;:10;:12::i;:::-;57777:32;;;;;;;;;;;;;;;:42;57810:8;57777:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;57883:8;57854:48;;57869:12;:10;:12::i;:::-;57854:48;;;57893:8;57854:48;;;;;;:::i;:::-;;;;;;;;57592:491;;;57995:8;57950:18;:32;57969:12;:10;:12::i;:::-;57950:32;;;;;;;;;;;;;;;:42;57983:8;57950:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;58052:8;58023:48;;58038:12;:10;:12::i;:::-;58023:48;;;58062:8;58023:48;;;;;;:::i;:::-;;;;;;;;57592:491;57430:660;;:::o;70564:95::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70642:9:::1;70634:5;:17;;;;70564:95:::0;:::o;73232:122::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73331:17:::1;73312:16;:36;;;;73232:122:::0;:::o;70182:36::-;;;;:::o;58889:342::-;59056:28;59066:4;59072:2;59076:7;59056:9;:28::i;:::-;59100:48;59123:4;59129:2;59133:7;59142:5;59100:22;:48::i;:::-;59095:129;;59172:40;;;;;;;;;;;;;;59095:129;58889:342;;;;:::o;49360:51::-;;;;;;;;;;;;;;;;;;;;;;:::o;72527:498::-;72630:13;72671:17;72679:8;72671:7;:17::i;:::-;72655:98;;;;;;;;;;;;:::i;:::-;;;;;;;;;72778:5;72766:17;;:8;;;;;;;;;;;:17;;;72762:64;;;72801:17;72794:24;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72762:64;72834:28;72865:10;:8;:10::i;:::-;72834:41;;72920:1;72895:14;72889:28;:32;:130;;;;;;;;;;;;;;;;;72957:14;72973:19;:8;:17;:19::i;:::-;72994:9;72940:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;72889:130;72882:137;;;72527:498;;;;:::o;70060:40::-;70096:4;70060:40;:::o;70143:32::-;;;;:::o;73031:81::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;73100:6:::1;73089:8;;:17;;;;;;;;;;;;;;;;;;73031:81:::0;:::o;58161:164::-;58258:4;58282:18;:25;58301:5;58282:25;;;;;;;;;;;;;;;:35;58308:8;58282:35;;;;;;;;;;;;;;;;;;;;;;;;;58275:42;;58161:164;;;;:::o;15084:244::-;14361:12;:10;:12::i;:::-;14350:23;;:7;:5;:7::i;:::-;:23;;;14342:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;15193:1:::1;15173:22;;:8;:22;;;;15165:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;15283:8;15254:38;;15275:6;::::0;::::1;;;;;;;;15254:38;;;;;;;;;;;;15312:8;15303:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;15084:244:::0;:::o;22404:157::-;22489:4;22528:25;22513:40;;;:11;:40;;;;22506:47;;22404:157;;;:::o;59486:194::-;59543:4;59578:1;59568:7;:11;59560:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;59627:13;;59617:7;:23;:55;;;;;59645:11;:20;59657:7;59645:20;;;;;;;;;;;:27;;;;;;;;;;;;59644:28;59617:55;59610:62;;59486:194;;;:::o;9156:98::-;9209:7;9236:10;9229:17;;9156:98;:::o;1294:326::-;1354:4;1611:1;1589:7;:19;;;:23;1582:30;;1294:326;;;:::o;66742:196::-;66884:2;66857:15;:24;66873:7;66857:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;66922:7;66918:2;66902:28;;66911:5;66902:28;;;;;;;;;;;;66742:196;;;:::o;62243:2112::-;62358:35;62396:20;62408:7;62396:11;:20::i;:::-;62358:58;;62429:22;62471:13;:18;;;62455:34;;:12;:10;:12::i;:::-;:34;;;:101;;;;62506:50;62523:13;:18;;;62543:12;:10;:12::i;:::-;62506:16;:50::i;:::-;62455:101;:154;;;;62597:12;:10;:12::i;:::-;62573:36;;:20;62585:7;62573:11;:20::i;:::-;:36;;;62455:154;62429:181;;62628:17;62623:66;;62654:35;;;;;;;;;;;;;;62623:66;62726:4;62704:26;;:13;:18;;;:26;;;62700:67;;62739:28;;;;;;;;;;;;;;62700:67;62796:1;62782:16;;:2;:16;;;62778:52;;;62807:23;;;;;;;;;;;;;;62778:52;62843:43;62865:4;62871:2;62875:7;62884:1;62843:21;:43::i;:::-;62951:49;62968:1;62972:7;62981:13;:18;;;62951:8;:49::i;:::-;63326:1;63296:12;:18;63309:4;63296:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63370:1;63342:12;:16;63355:2;63342:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63416:2;63388:11;:20;63400:7;63388:20;;;;;;;;;;;:25;;;:30;;;;;;;;;;;;;;;;;;63478:15;63433:11;:20;63445:7;63433:20;;;;;;;;;;;:35;;;:61;;;;;;;;;;;;;;;;;;63746:19;63778:1;63768:7;:11;63746:33;;63839:1;63798:43;;:11;:24;63810:11;63798:24;;;;;;;;;;;:29;;;;;;;;;;;;:43;;;63794:445;;;64023:13;;64009:11;:27;64005:219;;;64093:13;:18;;;64061:11;:24;64073:11;64061:24;;;;;;;;;;;:29;;;:50;;;;;;;;;;;;;;;;;;64176:13;:28;;;64134:11;:24;64146:11;64134:24;;;;;;;;;;;:39;;;:70;;;;;;;;;;;;;;;;;;64005:219;63794:445;63271:979;64286:7;64282:2;64267:27;;64276:4;64267:27;;;;;;;;;;;;64305:42;64326:4;64332:2;64336:7;64345:1;64305:20;:42::i;:::-;62347:2008;;62243:2112;;;:::o;54007:1083::-;54068:21;;:::i;:::-;54102:12;54117:7;54102:22;;54173:13;;54166:4;:20;54162:861;;;54207:31;54241:11;:17;54253:4;54241:17;;;;;;;;;;;54207:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54282:9;:16;;;54277:731;;54353:1;54327:28;;:9;:14;;;:28;;;54323:101;;54391:9;54384:16;;;;;;54323:101;54728:261;54735:4;54728:261;;;54768:6;;;;;;;;54813:11;:17;54825:4;54813:17;;;;;;;;;;;54801:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54887:1;54861:28;;:9;:14;;;:28;;;54857:109;;54929:9;54922:16;;;;;;54857:109;54728:261;;;54277:731;54188:835;54162:861;55051:31;;;;;;;;;;;;;;54007:1083;;;;:::o;59688:104::-;59757:27;59767:2;59771:8;59757:27;;;;;;;;;;;;:9;:27::i;:::-;59688:104;;:::o;67503:473::-;67658:4;67679:17;;;;;;;;;;;67678:18;:51;;;;;67701:19;:28;67721:7;67701:28;;;;;;;;;;;;;;;;;;;;;67700:29;67678:51;67675:294;;;67749:15;:2;:13;;;:15::i;:::-;67745:169;;;67785:61;;;;;;;;;;:::i;:::-;;;;;;;;67745:169;67894:4;67887:11;;;;67675:294;67953:4;67946:11;;67503:473;;;;;;;:::o;73801:110::-;73861:13;73894:9;73887:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73801:110;:::o;9839:723::-;9895:13;10125:1;10116:5;:10;10112:53;;;10143:10;;;;;;;;;;;;;;;;;;;;;10112:53;10175:12;10190:5;10175:20;;10206:14;10231:78;10246:1;10238:4;:9;10231:78;;10264:8;;;;;:::i;:::-;;;;10295:2;10287:10;;;;;:::i;:::-;;;10231:78;;;10319:19;10351:6;10341:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10319:39;;10369:154;10385:1;10376:5;:10;10369:154;;10413:1;10403:11;;;;;:::i;:::-;;;10480:2;10472:5;:10;;;;:::i;:::-;10459:2;:24;;;;:::i;:::-;10446:39;;10429:6;10436;10429:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;10509:2;10500:11;;;;;:::i;:::-;;;10369:154;;;10547:6;10533:21;;;;;9839:723;;;;:::o;68624:159::-;;;;;:::o;69442:158::-;;;;;:::o;60155:163::-;60278:32;60284:2;60288:8;60298:5;60305:4;60278:5;:32::i;:::-;60155:163;;;:::o;60577:1412::-;60716:20;60739:13;;60716:36;;60781:1;60767:16;;:2;:16;;;60763:48;;;60792:19;;;;;;;;;;;;;;60763:48;60838:1;60826:8;:13;60822:44;;;60848:18;;;;;;;;;;;;;;60822:44;60879:61;60909:1;60913:2;60917:12;60931:8;60879:21;:61::i;:::-;61252:8;61217:12;:16;61230:2;61217:16;;;;;;;;;;;;;;;:24;;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61316:8;61276:12;:16;61289:2;61276:16;;;;;;;;;;;;;;;:29;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61375:2;61342:11;:25;61354:12;61342:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;61442:15;61392:11;:25;61404:12;61392:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;61475:20;61498:12;61475:35;;61532:9;61527:328;61547:8;61543:1;:12;61527:328;;;61611:12;61607:2;61586:38;;61603:1;61586:38;;;;;;;;;;;;61647:4;:68;;;;;61656:59;61687:1;61691:2;61695:12;61709:5;61656:22;:59::i;:::-;61655:60;61647:68;61643:164;;;61747:40;;;;;;;;;;;;;;61643:164;61825:14;;;;;;;61557:3;;;;;;;61527:328;;;;61887:12;61871:13;:28;;;;61192:719;61921:60;61950:1;61954:2;61958:12;61972:8;61921:20;:60::i;:::-;60705:1284;60577:1412;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:412::-;501:5;526:66;542:49;584:6;542:49;:::i;:::-;526:66;:::i;:::-;517:75;;615:6;608:5;601:21;653:4;646:5;642:16;691:3;682:6;677:3;673:16;670:25;667:112;;;698:79;;:::i;:::-;667:112;788:41;822:6;817:3;812;788:41;:::i;:::-;507:328;423:412;;;;;:::o;841:139::-;887:5;925:6;912:20;903:29;;941:33;968:5;941:33;:::i;:::-;841:139;;;;:::o;986:133::-;1029:5;1067:6;1054:20;1045:29;;1083:30;1107:5;1083:30;:::i;:::-;986:133;;;;:::o;1125:137::-;1170:5;1208:6;1195:20;1186:29;;1224:32;1250:5;1224:32;:::i;:::-;1125:137;;;;:::o;1281:338::-;1336:5;1385:3;1378:4;1370:6;1366:17;1362:27;1352:122;;1393:79;;:::i;:::-;1352:122;1510:6;1497:20;1535:78;1609:3;1601:6;1594:4;1586:6;1582:17;1535:78;:::i;:::-;1526:87;;1342:277;1281:338;;;;:::o;1639:340::-;1695:5;1744:3;1737:4;1729:6;1725:17;1721:27;1711:122;;1752:79;;:::i;:::-;1711:122;1869:6;1856:20;1894:79;1969:3;1961:6;1954:4;1946:6;1942:17;1894:79;:::i;:::-;1885:88;;1701:278;1639:340;;;;:::o;1985:139::-;2031:5;2069:6;2056:20;2047:29;;2085:33;2112:5;2085:33;:::i;:::-;1985:139;;;;:::o;2130:329::-;2189:6;2238:2;2226:9;2217:7;2213:23;2209:32;2206:119;;;2244:79;;:::i;:::-;2206:119;2364:1;2389:53;2434:7;2425:6;2414:9;2410:22;2389:53;:::i;:::-;2379:63;;2335:117;2130:329;;;;:::o;2465:474::-;2533:6;2541;2590:2;2578:9;2569:7;2565:23;2561:32;2558:119;;;2596:79;;:::i;:::-;2558:119;2716:1;2741:53;2786:7;2777:6;2766:9;2762:22;2741:53;:::i;:::-;2731:63;;2687:117;2843:2;2869:53;2914:7;2905:6;2894:9;2890:22;2869:53;:::i;:::-;2859:63;;2814:118;2465:474;;;;;:::o;2945:619::-;3022:6;3030;3038;3087:2;3075:9;3066:7;3062:23;3058:32;3055:119;;;3093:79;;:::i;:::-;3055:119;3213:1;3238:53;3283:7;3274:6;3263:9;3259:22;3238:53;:::i;:::-;3228:63;;3184:117;3340:2;3366:53;3411:7;3402:6;3391:9;3387:22;3366:53;:::i;:::-;3356:63;;3311:118;3468:2;3494:53;3539:7;3530:6;3519:9;3515:22;3494:53;:::i;:::-;3484:63;;3439:118;2945:619;;;;;:::o;3570:943::-;3665:6;3673;3681;3689;3738:3;3726:9;3717:7;3713:23;3709:33;3706:120;;;3745:79;;:::i;:::-;3706:120;3865:1;3890:53;3935:7;3926:6;3915:9;3911:22;3890:53;:::i;:::-;3880:63;;3836:117;3992:2;4018:53;4063:7;4054:6;4043:9;4039:22;4018:53;:::i;:::-;4008:63;;3963:118;4120:2;4146:53;4191:7;4182:6;4171:9;4167:22;4146:53;:::i;:::-;4136:63;;4091:118;4276:2;4265:9;4261:18;4248:32;4307:18;4299:6;4296:30;4293:117;;;4329:79;;:::i;:::-;4293:117;4434:62;4488:7;4479:6;4468:9;4464:22;4434:62;:::i;:::-;4424:72;;4219:287;3570:943;;;;;;;:::o;4519:468::-;4584:6;4592;4641:2;4629:9;4620:7;4616:23;4612:32;4609:119;;;4647:79;;:::i;:::-;4609:119;4767:1;4792:53;4837:7;4828:6;4817:9;4813:22;4792:53;:::i;:::-;4782:63;;4738:117;4894:2;4920:50;4962:7;4953:6;4942:9;4938:22;4920:50;:::i;:::-;4910:60;;4865:115;4519:468;;;;;:::o;4993:474::-;5061:6;5069;5118:2;5106:9;5097:7;5093:23;5089:32;5086:119;;;5124:79;;:::i;:::-;5086:119;5244:1;5269:53;5314:7;5305:6;5294:9;5290:22;5269:53;:::i;:::-;5259:63;;5215:117;5371:2;5397:53;5442:7;5433:6;5422:9;5418:22;5397:53;:::i;:::-;5387:63;;5342:118;4993:474;;;;;:::o;5473:323::-;5529:6;5578:2;5566:9;5557:7;5553:23;5549:32;5546:119;;;5584:79;;:::i;:::-;5546:119;5704:1;5729:50;5771:7;5762:6;5751:9;5747:22;5729:50;:::i;:::-;5719:60;;5675:114;5473:323;;;;:::o;5802:327::-;5860:6;5909:2;5897:9;5888:7;5884:23;5880:32;5877:119;;;5915:79;;:::i;:::-;5877:119;6035:1;6060:52;6104:7;6095:6;6084:9;6080:22;6060:52;:::i;:::-;6050:62;;6006:116;5802:327;;;;:::o;6135:509::-;6204:6;6253:2;6241:9;6232:7;6228:23;6224:32;6221:119;;;6259:79;;:::i;:::-;6221:119;6407:1;6396:9;6392:17;6379:31;6437:18;6429:6;6426:30;6423:117;;;6459:79;;:::i;:::-;6423:117;6564:63;6619:7;6610:6;6599:9;6595:22;6564:63;:::i;:::-;6554:73;;6350:287;6135:509;;;;:::o;6650:329::-;6709:6;6758:2;6746:9;6737:7;6733:23;6729:32;6726:119;;;6764:79;;:::i;:::-;6726:119;6884:1;6909:53;6954:7;6945:6;6934:9;6930:22;6909:53;:::i;:::-;6899:63;;6855:117;6650:329;;;;:::o;6985:468::-;7050:6;7058;7107:2;7095:9;7086:7;7082:23;7078:32;7075:119;;;7113:79;;:::i;:::-;7075:119;7233:1;7258:53;7303:7;7294:6;7283:9;7279:22;7258:53;:::i;:::-;7248:63;;7204:117;7360:2;7386:50;7428:7;7419:6;7408:9;7404:22;7386:50;:::i;:::-;7376:60;;7331:115;6985:468;;;;;:::o;7459:179::-;7528:10;7549:46;7591:3;7583:6;7549:46;:::i;:::-;7627:4;7622:3;7618:14;7604:28;;7459:179;;;;:::o;7644:118::-;7731:24;7749:5;7731:24;:::i;:::-;7726:3;7719:37;7644:118;;:::o;7798:732::-;7917:3;7946:54;7994:5;7946:54;:::i;:::-;8016:86;8095:6;8090:3;8016:86;:::i;:::-;8009:93;;8126:56;8176:5;8126:56;:::i;:::-;8205:7;8236:1;8221:284;8246:6;8243:1;8240:13;8221:284;;;8322:6;8316:13;8349:63;8408:3;8393:13;8349:63;:::i;:::-;8342:70;;8435:60;8488:6;8435:60;:::i;:::-;8425:70;;8281:224;8268:1;8265;8261:9;8256:14;;8221:284;;;8225:14;8521:3;8514:10;;7922:608;;;7798:732;;;;:::o;8536:109::-;8617:21;8632:5;8617:21;:::i;:::-;8612:3;8605:34;8536:109;;:::o;8651:364::-;8739:3;8767:39;8800:5;8767:39;:::i;:::-;8822:71;8886:6;8881:3;8822:71;:::i;:::-;8815:78;;8902:52;8947:6;8942:3;8935:4;8928:5;8924:16;8902:52;:::i;:::-;8979:29;9001:6;8979:29;:::i;:::-;8974:3;8970:39;8963:46;;8743:272;8651:364;;;;:::o;9021:377::-;9127:3;9155:39;9188:5;9155:39;:::i;:::-;9210:89;9292:6;9287:3;9210:89;:::i;:::-;9203:96;;9308:52;9353:6;9348:3;9341:4;9334:5;9330:16;9308:52;:::i;:::-;9385:6;9380:3;9376:16;9369:23;;9131:267;9021:377;;;;:::o;9428:845::-;9531:3;9568:5;9562:12;9597:36;9623:9;9597:36;:::i;:::-;9649:89;9731:6;9726:3;9649:89;:::i;:::-;9642:96;;9769:1;9758:9;9754:17;9785:1;9780:137;;;;9931:1;9926:341;;;;9747:520;;9780:137;9864:4;9860:9;9849;9845:25;9840:3;9833:38;9900:6;9895:3;9891:16;9884:23;;9780:137;;9926:341;9993:38;10025:5;9993:38;:::i;:::-;10053:1;10067:154;10081:6;10078:1;10075:13;10067:154;;;10155:7;10149:14;10145:1;10140:3;10136:11;10129:35;10205:1;10196:7;10192:15;10181:26;;10103:4;10100:1;10096:12;10091:17;;10067:154;;;10250:6;10245:3;10241:16;10234:23;;9933:334;;9747:520;;9535:738;;9428:845;;;;:::o;10279:366::-;10421:3;10442:67;10506:2;10501:3;10442:67;:::i;:::-;10435:74;;10518:93;10607:3;10518:93;:::i;:::-;10636:2;10631:3;10627:12;10620:19;;10279:366;;;:::o;10651:::-;10793:3;10814:67;10878:2;10873:3;10814:67;:::i;:::-;10807:74;;10890:93;10979:3;10890:93;:::i;:::-;11008:2;11003:3;10999:12;10992:19;;10651:366;;;:::o;11023:::-;11165:3;11186:67;11250:2;11245:3;11186:67;:::i;:::-;11179:74;;11262:93;11351:3;11262:93;:::i;:::-;11380:2;11375:3;11371:12;11364:19;;11023:366;;;:::o;11395:::-;11537:3;11558:67;11622:2;11617:3;11558:67;:::i;:::-;11551:74;;11634:93;11723:3;11634:93;:::i;:::-;11752:2;11747:3;11743:12;11736:19;;11395:366;;;:::o;11767:::-;11909:3;11930:67;11994:2;11989:3;11930:67;:::i;:::-;11923:74;;12006:93;12095:3;12006:93;:::i;:::-;12124:2;12119:3;12115:12;12108:19;;11767:366;;;:::o;12139:::-;12281:3;12302:67;12366:2;12361:3;12302:67;:::i;:::-;12295:74;;12378:93;12467:3;12378:93;:::i;:::-;12496:2;12491:3;12487:12;12480:19;;12139:366;;;:::o;12511:::-;12653:3;12674:67;12738:2;12733:3;12674:67;:::i;:::-;12667:74;;12750:93;12839:3;12750:93;:::i;:::-;12868:2;12863:3;12859:12;12852:19;;12511:366;;;:::o;12883:::-;13025:3;13046:67;13110:2;13105:3;13046:67;:::i;:::-;13039:74;;13122:93;13211:3;13122:93;:::i;:::-;13240:2;13235:3;13231:12;13224:19;;12883:366;;;:::o;13255:::-;13397:3;13418:67;13482:2;13477:3;13418:67;:::i;:::-;13411:74;;13494:93;13583:3;13494:93;:::i;:::-;13612:2;13607:3;13603:12;13596:19;;13255:366;;;:::o;13627:::-;13769:3;13790:67;13854:2;13849:3;13790:67;:::i;:::-;13783:74;;13866:93;13955:3;13866:93;:::i;:::-;13984:2;13979:3;13975:12;13968:19;;13627:366;;;:::o;13999:::-;14141:3;14162:67;14226:2;14221:3;14162:67;:::i;:::-;14155:74;;14238:93;14327:3;14238:93;:::i;:::-;14356:2;14351:3;14347:12;14340:19;;13999:366;;;:::o;14371:398::-;14530:3;14551:83;14632:1;14627:3;14551:83;:::i;:::-;14544:90;;14643:93;14732:3;14643:93;:::i;:::-;14761:1;14756:3;14752:11;14745:18;;14371:398;;;:::o;14775:366::-;14917:3;14938:67;15002:2;14997:3;14938:67;:::i;:::-;14931:74;;15014:93;15103:3;15014:93;:::i;:::-;15132:2;15127:3;15123:12;15116:19;;14775:366;;;:::o;15147:108::-;15224:24;15242:5;15224:24;:::i;:::-;15219:3;15212:37;15147:108;;:::o;15261:118::-;15348:24;15366:5;15348:24;:::i;:::-;15343:3;15336:37;15261:118;;:::o;15385:589::-;15610:3;15632:95;15723:3;15714:6;15632:95;:::i;:::-;15625:102;;15744:95;15835:3;15826:6;15744:95;:::i;:::-;15737:102;;15856:92;15944:3;15935:6;15856:92;:::i;:::-;15849:99;;15965:3;15958:10;;15385:589;;;;;;:::o;15980:379::-;16164:3;16186:147;16329:3;16186:147;:::i;:::-;16179:154;;16350:3;16343:10;;15980:379;;;:::o;16365:222::-;16458:4;16496:2;16485:9;16481:18;16473:26;;16509:71;16577:1;16566:9;16562:17;16553:6;16509:71;:::i;:::-;16365:222;;;;:::o;16593:373::-;16736:4;16774:2;16763:9;16759:18;16751:26;;16823:9;16817:4;16813:20;16809:1;16798:9;16794:17;16787:47;16851:108;16954:4;16945:6;16851:108;:::i;:::-;16843:116;;16593:373;;;;:::o;16972:210::-;17059:4;17097:2;17086:9;17082:18;17074:26;;17110:65;17172:1;17161:9;17157:17;17148:6;17110:65;:::i;:::-;16972:210;;;;:::o;17188:313::-;17301:4;17339:2;17328:9;17324:18;17316:26;;17388:9;17382:4;17378:20;17374:1;17363:9;17359:17;17352:47;17416:78;17489:4;17480:6;17416:78;:::i;:::-;17408:86;;17188:313;;;;:::o;17507:419::-;17673:4;17711:2;17700:9;17696:18;17688:26;;17760:9;17754:4;17750:20;17746:1;17735:9;17731:17;17724:47;17788:131;17914:4;17788:131;:::i;:::-;17780:139;;17507:419;;;:::o;17932:::-;18098:4;18136:2;18125:9;18121:18;18113:26;;18185:9;18179:4;18175:20;18171:1;18160:9;18156:17;18149:47;18213:131;18339:4;18213:131;:::i;:::-;18205:139;;17932:419;;;:::o;18357:::-;18523:4;18561:2;18550:9;18546:18;18538:26;;18610:9;18604:4;18600:20;18596:1;18585:9;18581:17;18574:47;18638:131;18764:4;18638:131;:::i;:::-;18630:139;;18357:419;;;:::o;18782:::-;18948:4;18986:2;18975:9;18971:18;18963:26;;19035:9;19029:4;19025:20;19021:1;19010:9;19006:17;18999:47;19063:131;19189:4;19063:131;:::i;:::-;19055:139;;18782:419;;;:::o;19207:::-;19373:4;19411:2;19400:9;19396:18;19388:26;;19460:9;19454:4;19450:20;19446:1;19435:9;19431:17;19424:47;19488:131;19614:4;19488:131;:::i;:::-;19480:139;;19207:419;;;:::o;19632:::-;19798:4;19836:2;19825:9;19821:18;19813:26;;19885:9;19879:4;19875:20;19871:1;19860:9;19856:17;19849:47;19913:131;20039:4;19913:131;:::i;:::-;19905:139;;19632:419;;;:::o;20057:::-;20223:4;20261:2;20250:9;20246:18;20238:26;;20310:9;20304:4;20300:20;20296:1;20285:9;20281:17;20274:47;20338:131;20464:4;20338:131;:::i;:::-;20330:139;;20057:419;;;:::o;20482:::-;20648:4;20686:2;20675:9;20671:18;20663:26;;20735:9;20729:4;20725:20;20721:1;20710:9;20706:17;20699:47;20763:131;20889:4;20763:131;:::i;:::-;20755:139;;20482:419;;;:::o;20907:::-;21073:4;21111:2;21100:9;21096:18;21088:26;;21160:9;21154:4;21150:20;21146:1;21135:9;21131:17;21124:47;21188:131;21314:4;21188:131;:::i;:::-;21180:139;;20907:419;;;:::o;21332:::-;21498:4;21536:2;21525:9;21521:18;21513:26;;21585:9;21579:4;21575:20;21571:1;21560:9;21556:17;21549:47;21613:131;21739:4;21613:131;:::i;:::-;21605:139;;21332:419;;;:::o;21757:::-;21923:4;21961:2;21950:9;21946:18;21938:26;;22010:9;22004:4;22000:20;21996:1;21985:9;21981:17;21974:47;22038:131;22164:4;22038:131;:::i;:::-;22030:139;;21757:419;;;:::o;22182:::-;22348:4;22386:2;22375:9;22371:18;22363:26;;22435:9;22429:4;22425:20;22421:1;22410:9;22406:17;22399:47;22463:131;22589:4;22463:131;:::i;:::-;22455:139;;22182:419;;;:::o;22607:222::-;22700:4;22738:2;22727:9;22723:18;22715:26;;22751:71;22819:1;22808:9;22804:17;22795:6;22751:71;:::i;:::-;22607:222;;;;:::o;22835:129::-;22869:6;22896:20;;:::i;:::-;22886:30;;22925:33;22953:4;22945:6;22925:33;:::i;:::-;22835:129;;;:::o;22970:75::-;23003:6;23036:2;23030:9;23020:19;;22970:75;:::o;23051:307::-;23112:4;23202:18;23194:6;23191:30;23188:56;;;23224:18;;:::i;:::-;23188:56;23262:29;23284:6;23262:29;:::i;:::-;23254:37;;23346:4;23340;23336:15;23328:23;;23051:307;;;:::o;23364:308::-;23426:4;23516:18;23508:6;23505:30;23502:56;;;23538:18;;:::i;:::-;23502:56;23576:29;23598:6;23576:29;:::i;:::-;23568:37;;23660:4;23654;23650:15;23642:23;;23364:308;;;:::o;23678:132::-;23745:4;23768:3;23760:11;;23798:4;23793:3;23789:14;23781:22;;23678:132;;;:::o;23816:141::-;23865:4;23888:3;23880:11;;23911:3;23908:1;23901:14;23945:4;23942:1;23932:18;23924:26;;23816:141;;;:::o;23963:114::-;24030:6;24064:5;24058:12;24048:22;;23963:114;;;:::o;24083:99::-;24135:6;24169:5;24163:12;24153:22;;24083:99;;;:::o;24188:113::-;24258:4;24290;24285:3;24281:14;24273:22;;24188:113;;;:::o;24307:184::-;24406:11;24440:6;24435:3;24428:19;24480:4;24475:3;24471:14;24456:29;;24307:184;;;;:::o;24497:147::-;24598:11;24635:3;24620:18;;24497:147;;;;:::o;24650:169::-;24734:11;24768:6;24763:3;24756:19;24808:4;24803:3;24799:14;24784:29;;24650:169;;;;:::o;24825:148::-;24927:11;24964:3;24949:18;;24825:148;;;;:::o;24979:305::-;25019:3;25038:20;25056:1;25038:20;:::i;:::-;25033:25;;25072:20;25090:1;25072:20;:::i;:::-;25067:25;;25226:1;25158:66;25154:74;25151:1;25148:81;25145:107;;;25232:18;;:::i;:::-;25145:107;25276:1;25273;25269:9;25262:16;;24979:305;;;;:::o;25290:185::-;25330:1;25347:20;25365:1;25347:20;:::i;:::-;25342:25;;25381:20;25399:1;25381:20;:::i;:::-;25376:25;;25420:1;25410:35;;25425:18;;:::i;:::-;25410:35;25467:1;25464;25460:9;25455:14;;25290:185;;;;:::o;25481:348::-;25521:7;25544:20;25562:1;25544:20;:::i;:::-;25539:25;;25578:20;25596:1;25578:20;:::i;:::-;25573:25;;25766:1;25698:66;25694:74;25691:1;25688:81;25683:1;25676:9;25669:17;25665:105;25662:131;;;25773:18;;:::i;:::-;25662:131;25821:1;25818;25814:9;25803:20;;25481:348;;;;:::o;25835:191::-;25875:4;25895:20;25913:1;25895:20;:::i;:::-;25890:25;;25929:20;25947:1;25929:20;:::i;:::-;25924:25;;25968:1;25965;25962:8;25959:34;;;25973:18;;:::i;:::-;25959:34;26018:1;26015;26011:9;26003:17;;25835:191;;;;:::o;26032:96::-;26069:7;26098:24;26116:5;26098:24;:::i;:::-;26087:35;;26032:96;;;:::o;26134:90::-;26168:7;26211:5;26204:13;26197:21;26186:32;;26134:90;;;:::o;26230:149::-;26266:7;26306:66;26299:5;26295:78;26284:89;;26230:149;;;:::o;26385:126::-;26422:7;26462:42;26455:5;26451:54;26440:65;;26385:126;;;:::o;26517:77::-;26554:7;26583:5;26572:16;;26517:77;;;:::o;26600:154::-;26684:6;26679:3;26674;26661:30;26746:1;26737:6;26732:3;26728:16;26721:27;26600:154;;;:::o;26760:307::-;26828:1;26838:113;26852:6;26849:1;26846:13;26838:113;;;26937:1;26932:3;26928:11;26922:18;26918:1;26913:3;26909:11;26902:39;26874:2;26871:1;26867:10;26862:15;;26838:113;;;26969:6;26966:1;26963:13;26960:101;;;27049:1;27040:6;27035:3;27031:16;27024:27;26960:101;26809:258;26760:307;;;:::o;27073:320::-;27117:6;27154:1;27148:4;27144:12;27134:22;;27201:1;27195:4;27191:12;27222:18;27212:81;;27278:4;27270:6;27266:17;27256:27;;27212:81;27340:2;27332:6;27329:14;27309:18;27306:38;27303:84;;;27359:18;;:::i;:::-;27303:84;27124:269;27073:320;;;:::o;27399:281::-;27482:27;27504:4;27482:27;:::i;:::-;27474:6;27470:40;27612:6;27600:10;27597:22;27576:18;27564:10;27561:34;27558:62;27555:88;;;27623:18;;:::i;:::-;27555:88;27663:10;27659:2;27652:22;27442:238;27399:281;;:::o;27686:233::-;27725:3;27748:24;27766:5;27748:24;:::i;:::-;27739:33;;27794:66;27787:5;27784:77;27781:103;;;27864:18;;:::i;:::-;27781:103;27911:1;27904:5;27900:13;27893:20;;27686:233;;;:::o;27925:176::-;27957:1;27974:20;27992:1;27974:20;:::i;:::-;27969:25;;28008:20;28026:1;28008:20;:::i;:::-;28003:25;;28047:1;28037:35;;28052:18;;:::i;:::-;28037:35;28093:1;28090;28086:9;28081:14;;27925:176;;;;:::o;28107:180::-;28155:77;28152:1;28145:88;28252:4;28249:1;28242:15;28276:4;28273:1;28266:15;28293:180;28341:77;28338:1;28331:88;28438:4;28435:1;28428:15;28462:4;28459:1;28452:15;28479:180;28527:77;28524:1;28517:88;28624:4;28621:1;28614:15;28648:4;28645:1;28638:15;28665:180;28713:77;28710:1;28703:88;28810:4;28807:1;28800:15;28834:4;28831:1;28824:15;28851:180;28899:77;28896:1;28889:88;28996:4;28993:1;28986:15;29020:4;29017:1;29010:15;29037:117;29146:1;29143;29136:12;29160:117;29269:1;29266;29259:12;29283:117;29392:1;29389;29382:12;29406:117;29515:1;29512;29505:12;29529:102;29570:6;29621:2;29617:7;29612:2;29605:5;29601:14;29597:28;29587:38;;29529:102;;;:::o;29637:233::-;29777:34;29773:1;29765:6;29761:14;29754:58;29846:16;29841:2;29833:6;29829:15;29822:41;29637:233;:::o;29876:225::-;30016:34;30012:1;30004:6;30000:14;29993:58;30085:8;30080:2;30072:6;30068:15;30061:33;29876:225;:::o;30107:237::-;30247:34;30243:1;30235:6;30231:14;30224:58;30316:20;30311:2;30303:6;30299:15;30292:45;30107:237;:::o;30350:165::-;30490:17;30486:1;30478:6;30474:14;30467:41;30350:165;:::o;30521:175::-;30661:27;30657:1;30649:6;30645:14;30638:51;30521:175;:::o;30702:234::-;30842:34;30838:1;30830:6;30826:14;30819:58;30911:17;30906:2;30898:6;30894:15;30887:42;30702:234;:::o;30942:182::-;31082:34;31078:1;31070:6;31066:14;31059:58;30942:182;:::o;31130:173::-;31270:25;31266:1;31258:6;31254:14;31247:49;31130:173;:::o;31309:234::-;31449:34;31445:1;31437:6;31433:14;31426:58;31518:17;31513:2;31505:6;31501:15;31494:42;31309:234;:::o;31549:172::-;31689:24;31685:1;31677:6;31673:14;31666:48;31549:172;:::o;31727:229::-;31867:34;31863:1;31855:6;31851:14;31844:58;31936:12;31931:2;31923:6;31919:15;31912:37;31727:229;:::o;31962:114::-;;:::o;32082:166::-;32222:18;32218:1;32210:6;32206:14;32199:42;32082:166;:::o;32254:122::-;32327:24;32345:5;32327:24;:::i;:::-;32320:5;32317:35;32307:63;;32366:1;32363;32356:12;32307:63;32254:122;:::o;32382:116::-;32452:21;32467:5;32452:21;:::i;:::-;32445:5;32442:32;32432:60;;32488:1;32485;32478:12;32432:60;32382:116;:::o;32504:120::-;32576:23;32593:5;32576:23;:::i;:::-;32569:5;32566:34;32556:62;;32614:1;32611;32604:12;32556:62;32504:120;:::o;32630:122::-;32703:24;32721:5;32703:24;:::i;:::-;32696:5;32693:35;32683:63;;32742:1;32739;32732:12;32683:63;32630:122;:::o

Swarm Source

ipfs://a0725430478bab9bb10ab8028490e3833c91a8c7c8df070f9cf2f314ac39cd9f

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