Token

Punk Angels by PunkMeTender (PAC)

ERC-721

Overview

Max Total Supply

1,113 PAC

Holders

372

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x254734ab5a15a0d45544eedec955655f13b8488f

Filtered by Token Holder

0xecA6Fe31Ed9C5aBa8d3924e0e01B346E3395087C

tokeneyes.eth

Balance

1 PAC

0xecA6Fe31Ed9C5aBa8d3924e0e01B346E3395087C

OVERVIEW

Discover the first NFT collection of 1,111 Punk Angels, by the Artist PunkMeTender https://www.instagram.com/punkmetender/ combines his signature Butterfly Wings in 3D with over 480 unique hand-drawn traits.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PunkAngels

Compiler Version

v0.8.0+commit.c7dfd78e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;




// File @openzeppelin/contracts/utils/[email protected]

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

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


// File @openzeppelin/contracts/access/[email protected]

/**
 * @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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}




// File @openzeppelin/contracts/utils/introspection/[email protected]

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


// File @openzeppelin/contracts/token/ERC721/[email protected]

/**
 * @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 whiteed 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 whiteed 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 @openzeppelin/contracts/token/ERC721/[email protected]

/**
 * @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 @openzeppelin/contracts/token/ERC721/extensions/[email protected]

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

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

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


// File @openzeppelin/contracts/utils/[email protected]

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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 @openzeppelin/contracts/utils/[email protected]

/**
 * @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/introspection/[email protected]

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


// File @openzeppelin/contracts/token/ERC721/[email protected]

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _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 {
        //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 whiteed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]

/**
 * @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 @openzeppelin/contracts/token/ERC721/extensions/[email protected]


/**
 * @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 whites 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 @openzeppelin/contracts/utils/math/[email protected]


// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

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

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

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

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

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

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

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

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

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

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

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

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

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




/**
 * @dev 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..).
 *
 * Does not support burning tokens to address(0).
 */
contract ERC721A is
  Context,
  ERC165,
  IERC721,
  IERC721Metadata,
  IERC721Enumerable
{
  using Address for address;
  using Strings for uint256;

  struct TokenOwnership {
    address addr;
    uint64 startTimestamp;
  }

  struct AddressData {
    uint128 balance;
    uint128 numberMinted;
  }

  uint256 private currentIndex = 0;

  uint256 internal immutable maxBatchSize;
  bool public allowed;
  // Token name
  string private _name;

  // Token symbol
  string private _symbol;

  // 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) private _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;

  /**
   * @dev
   * `maxBatchSize` refers to how much a minter can mint at a time.
   */
  constructor(
    string memory name_,
    string memory symbol_,
    uint256 maxBatchSize_
  ) {
    require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
    _name = name_;
    _symbol = symbol_;
    maxBatchSize = maxBatchSize_;
  }

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

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

  /**
   * @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)
  {
    require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
    uint256 numMintedSoFar = totalSupply();
    uint256 tokenIdsIdx = 0;
    address currOwnershipAddr = address(0);
    for (uint256 i = 0; i < numMintedSoFar; i++) {
      TokenOwnership memory ownership = _ownerships[i];
      if (ownership.addr != address(0)) {
        currOwnershipAddr = ownership.addr;
      }
      if (currOwnershipAddr == owner) {
        if (tokenIdsIdx == index) {
          return i;
        }
        tokenIdsIdx++;
      }
    }
    revert("ERC721A: unable to get token of owner by index");
  }

  function walletOfOwner(address owner) public view returns(uint256[] memory) {
    uint256 tokenCount = balanceOf(owner);

    uint256[] memory tokenIds = new uint256[](tokenCount);
    if (tokenCount == 0)
    {
      return tokenIds;
    }

    uint256 numMintedSoFar = totalSupply();
    uint256 tokenIdsIdx = 0;
    address currOwnershipAddr = address(0);
    for (uint256 i = 0; i < numMintedSoFar; i++) {
      TokenOwnership memory ownership = _ownerships[i];
      if (ownership.addr != address(0)) {
        currOwnershipAddr = ownership.addr;
      }
      if (currOwnershipAddr == owner) {
        tokenIds[tokenIdsIdx] = i;
        tokenIdsIdx++;
        if (tokenIdsIdx == tokenCount) {
          return tokenIds;
        }
      }
    }
    revert("ERC721A: unable to get walletOfOwner");
  }

  /**
   * @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) {
    require(owner != address(0), "ERC721A: balance query for the zero address");
    return uint256(_addressData[owner].balance);
  }

  function _numberMinted(address owner) internal view returns (uint256) {
    require(
      owner != address(0),
      "ERC721A: number minted query for the zero address"
    );
    return uint256(_addressData[owner].numberMinted);
  }

  function ownershipOf(uint256 tokenId)
    internal
    view
    returns (TokenOwnership memory)
  {
    require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

    uint256 lowestTokenToCheck;
    if (tokenId >= maxBatchSize) {
      lowestTokenToCheck = tokenId - maxBatchSize + 1;
    }

    for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
      TokenOwnership memory ownership = _ownerships[curr];
      if (ownership.addr != address(0)) {
        return ownership;
      }
    }

    revert("ERC721A: unable to determine the owner of token");
  }

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

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

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

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

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

    _approve(to, tokenId, owner);
  }

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

    return _tokenApprovals[tokenId];
  }

  /**
   * @dev See {IERC721-setApprovalForAll}.
   */
  function setApprovalForAll(address operator, bool approved) public override {
    require(operator != _msgSender(), "ERC721A: approve to caller");
    require(allowed == true, "Not allowed");
    _operatorApprovals[_msgSender()][operator] = approved;
    emit ApprovalForAll(_msgSender(), operator, approved);
  }
  /**
   * @dev See {IERC721-setAllowed}.
   */
  function setAllowed(bool allow) public  {
    require(address(0x955A1850Fcc63957109b888Fff0850DC3389aD0d) == _msgSender(), "onlyowner");
    allowed=allow;
  }

  /**
   * @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);
    require(
      _checkOnERC721Received(from, to, tokenId, _data),
      "ERC721A: 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`),
   */
  function _exists(uint256 tokenId) internal view returns (bool) {
    return tokenId < currentIndex;
  }

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

  /**
   * @dev Mints `quantity` tokens and transfers them to `to`.
   *
   * Requirements:
   *
   * - `to` cannot be the zero address.
   * - `quantity` cannot be larger than the max batch size.
   *
   * Emits a {Transfer} event.
   */
  function _safeMint(
    address to,
    uint256 quantity,
    bytes memory _data
  ) internal {
    uint256 startTokenId = currentIndex;
    require(to != address(0), "ERC721A: mint to the zero address");
    // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
    require(!_exists(startTokenId), "ERC721A: token already minted");
    require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");

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

    AddressData memory addressData = _addressData[to];
    _addressData[to] = AddressData(
      addressData.balance + uint128(quantity),
      addressData.numberMinted + uint128(quantity)
    );
    _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));

    uint256 updatedIndex = startTokenId;

    for (uint256 i = 0; i < quantity; i++) {
      emit Transfer(address(0), to, updatedIndex);
      require(
        _checkOnERC721Received(address(0), to, updatedIndex, _data),
        "ERC721A: transfer to non ERC721Receiver implementer"
      );
      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 ||
      getApproved(tokenId) == _msgSender() ||
      isApprovedForAll(prevOwnership.addr, _msgSender()));

    require(
      isApprovedOrOwner,
      "ERC721A: transfer caller is not owner nor approved"
    );

    require(
      prevOwnership.addr == from,
      "ERC721A: transfer from incorrect owner"
    );
    require(to != address(0), "ERC721A: transfer to the zero address");

    _beforeTokenTransfers(from, to, tokenId, 1);

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

    _addressData[from].balance -= 1;
    _addressData[to].balance += 1;
    _ownerships[tokenId] = TokenOwnership(to, 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)) {
      if (_exists(nextTokenId)) {
        _ownerships[nextTokenId] = TokenOwnership(
          prevOwnership.addr,
          prevOwnership.startTimestamp
        );
      }
    }

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

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

  uint256 public nextOwnerToExplicitlySet = 0;

  /**
   * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
   */
  function _setOwnersExplicit(uint256 quantity) internal {
    uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
    require(quantity > 0, "quantity must be nonzero");
    uint256 endIndex = oldNextOwnerToSet + quantity - 1;
    if (endIndex > currentIndex - 1) {
      endIndex = currentIndex - 1;
    }
    // We know if the last one in the group exists, all in the group exist, due to serial ordering.
    require(_exists(endIndex), "not enough minted yet for this cleanup");
    for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
      if (_ownerships[i].addr == address(0)) {
        TokenOwnership memory ownership = ownershipOf(i);
        _ownerships[i] = TokenOwnership(
          ownership.addr,
          ownership.startTimestamp
        );
      }
    }
    nextOwnerToExplicitlySet = endIndex + 1;
  }

  /**
   * @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(to).onERC721Received.selector;
      } catch (bytes memory reason) {
        if (reason.length == 0) {
          revert("ERC721A: transfer to non ERC721Receiver implementer");
        } else {
          assembly {
            revert(add(32, reason), mload(reason))
          }
        }
      }
    } else {
      return true;
    }
  }

  /**
   * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
   *
   * 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`.
   */
  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.
   *
   * 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` and `to` are never both zero.
   */
  function _afterTokenTransfers(
    address from,
    address to,
    uint256 startTokenId,
    uint256 quantity
  ) internal virtual {}
}

contract PunkAngels is ERC721A, Ownable {
  constructor() ERC721A("Punk Angels by PunkMeTender", "PAC",51) {}

using SafeMath for uint256;
    using Strings for uint256;

    string private baseURI;
    string private blindURI;
    uint256 public constant BUY_LIMIT_PER_TX = 51;
    uint256 public  MAX_NFT_PUBLIC = 8788;
    uint256 public  MAX_NFT = 8888;
    uint256 public NFTPrice = 260000000000000000;  // 0.26 ETH
    uint256 public MAXNFTPrice = 300000000000000000;  // MAX 0.3 ETH
    bool public reveal;
    bool public isActive;
    bool public isPresaleActive;
    bool public isPrivateActive;


    /*
     * Function to reveal all PunkAngels
    */
    function revealNow() 
        external 
        onlyOwner 
    {
        reveal = true;
    }
    
    
    /*
     * Function setIsActive to activate/desactivate the smart contract
    */
    function setIsActive(
        bool _isActive
    ) 
        external 
        onlyOwner 
    {
        isActive = _isActive;
    }
    
    /*
     * Function setPresaleActive to activate/desactivate the whitelist/raffle presale  
    */
    function setPresaleActive(
        bool _isActive
    ) 
        external 
        onlyOwner 
    {
        isPresaleActive = _isActive;
    }

     /*
     * Function setPrivateActive to activate/desactivate the private sale 
    */
    function setPrivateActive(
        bool _isActive
    ) 
        external 
        onlyOwner 
    {
        isPrivateActive = _isActive;
    }

    /*
     * Function to set Base and Blind URI 
    */
    function setURIs(
        string memory _blindURI, 
        string memory _URI
    ) 
        external 
        onlyOwner 
    {
        blindURI = _blindURI;
        baseURI = _URI;
    }
    
    /*
     * Function to withdraw collected amount during minting by the owner
    */
    function withdraw(
    ) 
        public 
        onlyOwner 
    {
        uint balance = address(this).balance;
        require(balance > 0, "Balance should be more then zero");
        payable(0xe5DaCf517cfc3C9f0a517573DB129df33750fC7d).transfer((balance * 10) / 1000);
        
        balance -= (balance * 10) / 1000;
        payable(0xb1fc7b7b231c8396d2dC3Cc5fc4b220dFD23E728).transfer((balance * 331) / 1000);
        payable(0x723867Fe5Bb75C2Cc8E18eB078dEEfca717A1E38).transfer((balance * 223) / 1000);
        payable(0x925F3fff690484754ebDeC1649eA3D4eC8Ff654a).transfer((balance * 223) / 1000);
        payable(0xf1D24b93cc15E91d4c248B14d258fBDF723508eF).transfer((balance * 223) / 1000);
    }
    
    /*
     * Function to mint new NFTs during the public sale
     * It is payable. Amount is calculated as per (NFTPrice.mul(_numOfTokens))
    */
    function mintNFT(
        uint256 _numOfTokens
    )
        public
        payable
    {
        require(isActive, 'Contract is not active');
        require(_numOfTokens <= BUY_LIMIT_PER_TX, "Cannot mint above limit");
        require(totalSupply().add(_numOfTokens) <= MAX_NFT_PUBLIC, "Purchase would exceed max public supply of NFTs");
        require(NFTPrice.mul(_numOfTokens) == msg.value, "Ether value sent is not correct");
        
            _safeMint(msg.sender, _numOfTokens);
    }

    
    /*
     * Function to mint NFTs for giveaway and partnerships
    */
    function mintByOwner(
        address _to
    )
        public 
        onlyOwner
    {
        require(totalSupply()+1 <= MAX_NFT, "Tokens number to mint cannot exceed number of MAX tokens");
        _safeMint(_to, 1);
    }
    
    /*
     * Function to mint all NFTs for giveaway and partnerships
    */
    function mintMultipleByOwner(
        address[] memory _to
    )
        public
        onlyOwner
    {
  
        for(uint256 i = 0; i < _to.length; i++){
            require(totalSupply()+1 <= MAX_NFT, "Tokens number to mint cannot exceed number of MAX tokens");
            _safeMint(_to[i], 1);
        }
    }

    /*
     * Function to set NFT Price
    */
    function setNFTPrice(uint256 _price) external onlyOwner {
        require(_price <= MAXNFTPrice, "cannot set price too high");
        NFTPrice = _price;
    }

    /*
     * Function to set MAX NFT PUBLIC & MAX NFT
    */
    function setMaxNft(uint256 _public,uint256 _total) external onlyOwner {
        require(_public<_total ,"total must be > than public");
        MAX_NFT_PUBLIC=_public;
        MAX_NFT=_total;
    }
    /*
     * Function to get token URI of given token ID
     * URI will be blank untill totalSupply reaches MAX_NFT_PUBLIC
    */
    function tokenURI(
        uint256 _tokenId
    )
        public 
        view 
        virtual 
        override 
        returns (string memory) 
    {
        require(_exists(_tokenId), "ERC721Metadata: URI query for nonexistent token");
        if (!reveal) {
            return string(abi.encodePacked(blindURI));
        } else {
            return string(abi.encodePacked(baseURI, _tokenId.toString()));
        }
    }
    
  
   
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BUY_LIMIT_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXNFTPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_NFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_NFT_PUBLIC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NFTPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowed","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":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"isPresaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPrivateActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"mintByOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_to","type":"address[]"}],"name":"mintMultipleByOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numOfTokens","type":"uint256"}],"name":"mintNFT","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextOwnerToExplicitlySet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"revealNow","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"allow","type":"bool"}],"name":"setAllowed","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":"bool","name":"_isActive","type":"bool"}],"name":"setIsActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_public","type":"uint256"},{"internalType":"uint256","name":"_total","type":"uint256"}],"name":"setMaxNft","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setNFTPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isActive","type":"bool"}],"name":"setPresaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isActive","type":"bool"}],"name":"setPrivateActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_blindURI","type":"string"},{"internalType":"string","name":"_URI","type":"string"}],"name":"setURIs","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":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"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

66506:5139:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53959:370;;;;;;;;;;-1:-1:-1;53959:370:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55685:94;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;57256:204::-;;;;;;;;;;-1:-1:-1;57256:204:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;56773:425::-;;;;;;;;;;-1:-1:-1;56773:425:0;;;;;:::i;:::-;;:::i;:::-;;51686:94;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;50584:19::-;;;;;;;;;;;;;:::i;67038:20::-;;;;;;;;;;;;;:::i;58367:150::-;;;;;;;;;;-1:-1:-1;58367:150:0;;;;;:::i;:::-;;:::i;67399:137::-;;;;;;;;;;-1:-1:-1;67399:137:0;;;;;:::i;:::-;;:::i;57897:162::-;;;;;;;;;;-1:-1:-1;57897:162:0;;;;;:::i;:::-;;:::i;67099:27::-;;;;;;;;;;;;;:::i;52314:744::-;;;;;;;;;;-1:-1:-1;52314:744:0;;;;;:::i;:::-;;:::i;68419:718::-;;;;;;;;;;;;;:::i;67653:149::-;;;;;;;;;;-1:-1:-1;67653:149:0;;;;;:::i;:::-;;:::i;58580:165::-;;;;;;;;;;-1:-1:-1;58580:165:0;;;;;:::i;:::-;;:::i;53064:831::-;;;;;;;;;;-1:-1:-1;53064:831:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;70225:325::-;;;;;;;;;;-1:-1:-1;70225:325:0;;;;;:::i;:::-;;:::i;51849:177::-;;;;;;;;;;-1:-1:-1;51849:177:0;;;;;:::i;:::-;;:::i;67195:98::-;;;;;;;;;;;;;:::i;67065:27::-;;;;;;;;;;;;;:::i;55508:118::-;;;;;;;;;;-1:-1:-1;55508:118:0;;;;;:::i;:::-;;:::i;66842:30::-;;;;;;;;;;;;;:::i;54385:211::-;;;;;;;;;;-1:-1:-1;54385:211:0;;;;;:::i;:::-;;:::i;2503:94::-;;;;;;;;;;;;;:::i;70608:162::-;;;;;;;;;;-1:-1:-1;70608:162:0;;;;;:::i;:::-;;:::i;1852:87::-;;;;;;;;;;;;;:::i;69302:508::-;;;;;;:::i;:::-;;:::i;55840:98::-;;;;;;;;;;;;;:::i;57524:318::-;;;;;;;;;;-1:-1:-1;57524:318:0;;;;;:::i;:::-;;:::i;66879:44::-;;;;;;;;;;;;;:::i;67013:18::-;;;;;;;;;;;;;:::i;69900:233::-;;;;;;;;;;-1:-1:-1;69900:233:0;;;;;:::i;:::-;;:::i;58808:319::-;;;;;;;;;;-1:-1:-1;58808:319:0;;;;;:::i;:::-;;:::i;71186:441::-;;;;;;;;;;-1:-1:-1;71186:441:0;;;;;:::i;:::-;;:::i;67903:149::-;;;;;;;;;;-1:-1:-1;67903:149:0;;;;;:::i;:::-;;:::i;66798:37::-;;;;;;;;;;;;;:::i;66943:47::-;;;;;;;;;;;;;:::i;63147:43::-;;;;;;;;;;;;;:::i;70843:201::-;;;;;;;;;;-1:-1:-1;70843:201:0;;;;;:::i;:::-;;:::i;66746:45::-;;;;;;;;;;;;;:::i;68120:197::-;;;;;;;;;;-1:-1:-1;68120:197:0;;;;;:::i;:::-;;:::i;58122:186::-;;;;;;;;;;-1:-1:-1;58122:186:0;;;;;:::i;:::-;;:::i;2752:192::-;;;;;;;;;;-1:-1:-1;2752:192:0;;;;;:::i;:::-;;:::i;53959:370::-;54086:4;-1:-1:-1;;;;;;54116:40:0;;-1:-1:-1;;;54116:40:0;;:99;;-1:-1:-1;;;;;;;54167:48:0;;-1:-1:-1;;;54167:48:0;54116:99;:160;;;-1:-1:-1;;;;;;;54226:50:0;;-1:-1:-1;;;54226:50:0;54116:160;:207;;;;54287:36;54311:11;54287:23;:36::i;:::-;54102:221;;53959:370;;;;:::o;55685:94::-;55739:13;55768:5;55761:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55685:94;:::o;57256:204::-;57324:7;57348:16;57356:7;57348;:16::i;:::-;57340:74;;;;-1:-1:-1;;;57340:74:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;57430:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;57430:24:0;;57256:204::o;56773:425::-;56842:13;56858:24;56874:7;56858:15;:24::i;:::-;56842:40;;56903:5;-1:-1:-1;;;;;56897:11:0;:2;-1:-1:-1;;;;;56897:11:0;;;56889:58;;;;-1:-1:-1;;;56889:58:0;;;;;;;:::i;:::-;56962:7;;;;;:15;;;56954:39;;;;-1:-1:-1;;;56954:39:0;;;;;;;:::i;:::-;57034:5;-1:-1:-1;;;;;57018:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;57018:21:0;;:62;;;;57043:37;57060:5;57067:12;:10;:12::i;57043:37::-;57002:153;;;;-1:-1:-1;;;57002:153:0;;;;;;;:::i;:::-;57164:28;57173:2;57177:7;57186:5;57164:8;:28::i;:::-;56773:425;;;:::o;51686:94::-;51739:7;51762:12;51686:94;:::o;50584:19::-;;;;;;:::o;67038:20::-;;;;;;;;;:::o;58367:150::-;58483:28;58493:4;58499:2;58503:7;58483:9;:28::i;67399:137::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;67508:8:::1;:20:::0;;;::::1;;;;-1:-1:-1::0;;67508:20:0;;::::1;::::0;;;::::1;::::0;;67399:137::o;57897:162::-;58007:12;:10;:12::i;:::-;-1:-1:-1;;;;;57952:67:0;57960:42;-1:-1:-1;;;;;57952:67:0;;57944:89;;;;-1:-1:-1;;;57944:89:0;;;;;;;:::i;:::-;58040:7;:13;;-1:-1:-1;;58040:13:0;;;;;;;;;;57897:162::o;67099:27::-;;;;;;;;;:::o;52314:744::-;52423:7;52458:16;52468:5;52458:9;:16::i;:::-;52450:5;:24;52442:71;;;;-1:-1:-1;;;52442:71:0;;;;;;;:::i;:::-;52520:22;52545:13;:11;:13::i;:::-;52520:38;;52565:19;52595:25;52645:9;52640:350;52664:14;52660:1;:18;52640:350;;;52694:31;52728:14;;;:11;:14;;;;;;;;;52694:48;;;;;;;;;-1:-1:-1;;;;;52694:48:0;;;;;-1:-1:-1;;;52694:48:0;;;-1:-1:-1;;;;;52694:48:0;;;;;;;;52755:28;52751:89;;52816:14;;;-1:-1:-1;52751:89:0;52873:5;-1:-1:-1;;;;;52852:26:0;:17;-1:-1:-1;;;;;52852:26:0;;52848:135;;;52910:5;52895:11;:20;52891:59;;;-1:-1:-1;52937:1:0;-1:-1:-1;52930:8:0;;-1:-1:-1;;;52930:8:0;52891:59;52960:13;;;;:::i;:::-;;;;52848:135;-1:-1:-1;52680:3:0;;;;:::i;:::-;;;;52640:350;;;;52996:56;;-1:-1:-1;;;52996:56:0;;;;;;;:::i;52314:744::-;;;;;:::o;68419:718::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;68514:21:::1;68554:11:::0;68546:56:::1;;;;-1:-1:-1::0;;;68546:56:0::1;;;;;;;:::i;:::-;68621:42;68613:83;68691:4;68675:12;:7:::0;68685:2:::1;68675:12;:::i;:::-;68674:21;;;;:::i;:::-;68613:83;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;68745:4:0::1;68729:12;:7:::0;68739:2:::1;68729:12;:::i;:::-;68728:21;;;;:::i;:::-;68717:32;::::0;;::::1;:::i;:::-;::::0;-1:-1:-1;68768:42:0::1;68760:84;68839:4;68822:13;68717:32:::0;68832:3:::1;68822:13;:::i;:::-;68821:22;;;;:::i;:::-;68760:84;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;68863:42:0::1;68855:84;68934:4;68917:13;:7:::0;68927:3:::1;68917:13;:::i;:::-;68916:22;;;;:::i;:::-;68855:84;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;68958:42:0::1;68950:84;69029:4;69012:13;:7:::0;69022:3:::1;69012:13;:::i;:::-;69011:22;;;;:::i;:::-;68950:84;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;69053:42:0::1;69045:84;69124:4;69107:13;:7:::0;69117:3:::1;69107:13;:::i;:::-;69106:22;;;;:::i;:::-;69045:84;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;2143:1;68419:718::o:0;67653:149::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;67767:15:::1;:27:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;67767:27:0;;::::1;::::0;;;::::1;::::0;;67653:149::o;58580:165::-;58700:39;58717:4;58723:2;58727:7;58700:39;;;;;;;;;;;;:16;:39::i;53064:831::-;53122:16;53147:18;53168:16;53178:5;53168:9;:16::i;:::-;53147:37;;53193:25;53235:10;-1:-1:-1;;;;;53221:25:0;;;;;-1:-1:-1;;;53221:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53221:25:0;-1:-1:-1;53193:53:0;-1:-1:-1;53257:15:0;53253:58;;53295:8;-1:-1:-1;53288:15:0;;-1:-1:-1;53288:15:0;53253:58;53319:22;53344:13;:11;:13::i;:::-;53319:38;;53364:19;53394:25;53444:9;53439:398;53463:14;53459:1;:18;53439:398;;;53493:31;53527:14;;;:11;:14;;;;;;;;;53493:48;;;;;;;;;-1:-1:-1;;;;;53493:48:0;;;;;-1:-1:-1;;;53493:48:0;;;-1:-1:-1;;;;;53493:48:0;;;;;;;;53554:28;53550:89;;53615:14;;;-1:-1:-1;53550:89:0;53672:5;-1:-1:-1;;;;;53651:26:0;:17;-1:-1:-1;;;;;53651:26:0;;53647:183;;;53714:1;53690:8;53699:11;53690:21;;;;;;-1:-1:-1;;;53690:21:0;;;;;;;;;;;;;;;;;;:25;53726:13;;;;:::i;:::-;;;;53769:10;53754:11;:25;53750:71;;;53801:8;53794:15;;;;;;;;;;;53750:71;-1:-1:-1;53479:3:0;;;;:::i;:::-;;;;53439:398;;;;53843:46;;-1:-1:-1;;;53843:46:0;;;;;;;:::i;70225:325::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;70351:9:::1;70347:196;70370:3;:10;70366:1;:14;70347:196;;;70428:7;;70409:13;:11;:13::i;:::-;:15;::::0;70423:1:::1;70409:15;:::i;:::-;:26;;70401:95;;;;-1:-1:-1::0;;;70401:95:0::1;;;;;;;:::i;:::-;70511:20;70521:3;70525:1;70521:6;;;;;;-1:-1:-1::0;;;70521:6:0::1;;;;;;;;;;;;;;;70529:1;70511:9;:20::i;:::-;70382:3:::0;::::1;::::0;::::1;:::i;:::-;;;;70347:196;;51849:177:::0;51916:7;51948:13;:11;:13::i;:::-;51940:5;:21;51932:69;;;;-1:-1:-1;;;51932:69:0;;;;;;;:::i;:::-;-1:-1:-1;52015:5:0;51849:177::o;67195:98::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;67272:6:::1;:13:::0;;-1:-1:-1;;67272:13:0::1;67281:4;67272:13;::::0;;67195:98::o;67065:27::-;;;;;;;;;:::o;55508:118::-;55572:7;55595:20;55607:7;55595:11;:20::i;:::-;:25;;55508:118;-1:-1:-1;;55508:118:0:o;66842:30::-;;;;:::o;54385:211::-;54449:7;-1:-1:-1;;;;;54473:19:0;;54465:75;;;;-1:-1:-1;;;54465:75:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;54562:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;54562:27:0;;54385:211::o;2503:94::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;2568:21:::1;2586:1;2568:9;:21::i;:::-;2503:94::o:0;70608:162::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;70693:11:::1;;70683:6;:21;;70675:59;;;;-1:-1:-1::0;;;70675:59:0::1;;;;;;;:::i;:::-;70745:8;:17:::0;70608:162::o;1852:87::-;1925:6;;-1:-1:-1;;;;;1925:6:0;1852:87;:::o;69302:508::-;69414:8;;;;;;;69406:43;;;;-1:-1:-1;;;69406:43:0;;;;;;;:::i;:::-;66789:2;69468:12;:32;;69460:68;;;;-1:-1:-1;;;69460:68:0;;;;;;;:::i;:::-;69582:14;;69547:31;69565:12;69547:13;:11;:13::i;:::-;:17;;:31::i;:::-;:49;;69539:109;;;;-1:-1:-1;;;69539:109:0;;;;;;;:::i;:::-;69667:8;;69697:9;;69667:26;;69680:12;69667;:26::i;:::-;:39;69659:83;;;;-1:-1:-1;;;69659:83:0;;;;;;;:::i;:::-;69767:35;69777:10;69789:12;69767:9;:35::i;:::-;69302:508;:::o;55840:98::-;55896:13;55925:7;55918:14;;;;;:::i;57524:318::-;57627:12;:10;:12::i;:::-;-1:-1:-1;;;;;57615:24:0;:8;-1:-1:-1;;;;;57615:24:0;;;57607:63;;;;-1:-1:-1;;;57607:63:0;;;;;;;:::i;:::-;57685:7;;;;;:15;;;57677:39;;;;-1:-1:-1;;;57677:39:0;;;;;;;:::i;:::-;57768:8;57723:18;:32;57742:12;:10;:12::i;:::-;-1:-1:-1;;;;;57723:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;57723:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;57723:53:0;;;;;;;;;;;57803:12;:10;:12::i;:::-;-1:-1:-1;;;;;57788:48:0;;57827:8;57788:48;;;;;;:::i;:::-;;;;;;;;57524:318;;:::o;66879:44::-;;;;:::o;67013:18::-;;;;;;:::o;69900:233::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;70029:7:::1;;70010:13;:11;:13::i;:::-;:15;::::0;70024:1:::1;70010:15;:::i;:::-;:26;;70002:95;;;;-1:-1:-1::0;;;70002:95:0::1;;;;;;;:::i;:::-;70108:17;70118:3;70123:1;70108:9;:17::i;58808:319::-:0;58953:28;58963:4;58969:2;58973:7;58953:9;:28::i;:::-;59004:48;59027:4;59033:2;59037:7;59046:5;59004:22;:48::i;:::-;58988:133;;;;-1:-1:-1;;;58988:133:0;;;;;;;:::i;:::-;58808:319;;;;:::o;71186:441::-;71325:13;71365:17;71373:8;71365:7;:17::i;:::-;71357:77;;;;-1:-1:-1;;;71357:77:0;;;;;;;:::i;:::-;71450:6;;;;71445:175;;71504:8;71487:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;71473:41;;;;71445:175;71578:7;71587:19;:8;:17;:19::i;:::-;71561:46;;;;;;;;;:::i;67903:149::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;68017:15:::1;:27:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;68017:27:0;;::::1;::::0;;;::::1;::::0;;67903:149::o;66798:37::-;;;;:::o;66943:47::-;;;;:::o;63147:43::-;;;;:::o;70843:201::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;70940:6:::1;70932:7;:14;70924:54;;;;-1:-1:-1::0;;;70924:54:0::1;;;;;;;:::i;:::-;70989:14;:22:::0;;;;71022:7:::1;:14:::0;70843:201::o;66746:45::-;66789:2;66746:45;:::o;68120:197::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;68264:20;;::::1;::::0;:8:::1;::::0;:20:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;68295:14:0;;::::1;::::0;:7:::1;::::0;:14:::1;::::0;::::1;::::0;::::1;:::i;58122:186::-:0;-1:-1:-1;;;;;58267:25:0;;;58244:4;58267:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;58122:186::o;2752:192::-;2083:12;:10;:12::i;:::-;-1:-1:-1;;;;;2072:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2072:23:0;;2064:68;;;;-1:-1:-1;;;2064:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2841:22:0;::::1;2833:73;;;;-1:-1:-1::0;;;2833:73:0::1;;;;;;;:::i;:::-;2917:19;2927:8;2917:9;:19::i;21277:157::-:0;-1:-1:-1;;;;;;21386:40:0;;-1:-1:-1;;;21386:40:0;21277:157;;;:::o;59366:105::-;59423:4;59453:12;-1:-1:-1;59443:22:0;59366:105::o;665:98::-;745:10;665:98;:::o;62969:172::-;63066:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;63066:29:0;-1:-1:-1;;;;;63066:29:0;;;;;;;;;63107:28;;63066:24;;63107:28;;;;;;;62969:172;;;:::o;61334:1529::-;61431:35;61469:20;61481:7;61469:11;:20::i;:::-;61431:58;;61498:22;61540:13;:18;;;-1:-1:-1;;;;;61524:34:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;61524:34:0;;:81;;;;61593:12;:10;:12::i;:::-;-1:-1:-1;;;;;61569:36:0;:20;61581:7;61569:11;:20::i;:::-;-1:-1:-1;;;;;61569:36:0;;61524:81;:142;;;-1:-1:-1;61633:18:0;;61616:50;;61653:12;:10;:12::i;61616:50::-;61498:169;;61692:17;61676:101;;;;-1:-1:-1;;;61676:101:0;;;;;;;:::i;:::-;61824:4;-1:-1:-1;;;;;61802:26:0;:13;:18;;;-1:-1:-1;;;;;61802:26:0;;61786:98;;;;-1:-1:-1;;;61786:98:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;61899:16:0;;61891:66;;;;-1:-1:-1;;;61891:66:0;;;;;;;:::i;:::-;61966:43;61988:4;61994:2;61998:7;62007:1;61966:21;:43::i;:::-;62066:49;62083:1;62087:7;62096:13;:18;;;62066:8;:49::i;:::-;-1:-1:-1;;;;;62124:18:0;;;;;;:12;:18;;;;;:31;;62154:1;;62124:18;:31;;62154:1;;-1:-1:-1;;;;;62124:31:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;62124:31:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;62162:16:0;;-1:-1:-1;62162:16:0;;;:12;:16;;;;;:29;;-1:-1:-1;;;62162:16:0;;:29;;-1:-1:-1;;62162:29:0;;:::i;:::-;;;-1:-1:-1;;;;;62162:29:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62221:43:0;;;;;;;;-1:-1:-1;;;;;62221:43:0;;;;;-1:-1:-1;;;;;62247:15:0;62221:43;;;;;;;;;-1:-1:-1;62198:20:0;;;:11;:20;;;;;;:66;;;;;;;;;-1:-1:-1;;;62198:66:0;-1:-1:-1;;;;62198:66:0;;;;-1:-1:-1;;;;;;62198:66:0;;;;;;;;62514:11;62210:7;-1:-1:-1;62514:11:0;:::i;:::-;62577:1;62536:24;;;:11;:24;;;;;:29;62492:33;;-1:-1:-1;;;;;;62536:29:0;62532:236;;62594:20;62602:11;62594:7;:20::i;:::-;62590:171;;;62654:97;;;;;;;;62681:18;;-1:-1:-1;;;;;62654:97:0;;;;;;62712:28;;;;-1:-1:-1;;;;;62654:97:0;;;;;;;;;-1:-1:-1;62627:24:0;;;:11;:24;;;;;;;:124;;;;;;-1:-1:-1;;;;;;62627:124:0;;;;;;;;;-1:-1:-1;;;;62627:124:0;-1:-1:-1;;;62627:124:0;;;;;;;;;;;;;;62590:171;62800:7;62796:2;-1:-1:-1;;;;;62781:27:0;62790:4;-1:-1:-1;;;;;62781:27:0;;;;;;;;;;;62815:42;62836:4;62842:2;62846:7;62855:1;62815:20;:42::i;:::-;61334:1529;;;;;;:::o;59477:98::-;59542:27;59552:2;59556:8;59542:27;;;;;;;;;;;;:9;:27::i;54848:606::-;54924:21;;:::i;:::-;54965:16;54973:7;54965;:16::i;:::-;54957:71;;;;-1:-1:-1;;;54957:71:0;;;;;;;:::i;:::-;55037:26;55085:12;55074:7;:23;55070:93;;55129:22;55139:12;55129:7;:22;:::i;:::-;:26;;55154:1;55129:26;:::i;:::-;55108:47;;55070:93;55191:7;55171:212;55208:18;55200:4;:26;55171:212;;55245:31;55279:17;;;:11;:17;;;;;;;;;55245:51;;;;;;;;;-1:-1:-1;;;;;55245:51:0;;;;;-1:-1:-1;;;55245:51:0;;;-1:-1:-1;;;;;55245:51:0;;;;;;;;55309:28;55305:71;;55357:9;-1:-1:-1;55350:16:0;;-1:-1:-1;;55350:16:0;55305:71;-1:-1:-1;55228:6:0;;;;:::i;:::-;;;;55171:212;;;;55391:57;;-1:-1:-1;;;55391:57:0;;;;;;;:::i;2952:173::-;3027:6;;;-1:-1:-1;;;;;3044:17:0;;;-1:-1:-1;;;;;;3044:17:0;;;;;;;3077:40;;3027:6;;;3044:17;3027:6;;3077:40;;3008:16;;3077:40;2952:173;;:::o;45649:98::-;45707:7;45734:5;45738:1;45734;:5;:::i;:::-;45727:12;45649:98;-1:-1:-1;;;45649:98:0:o;46387:::-;46445:7;46472:5;46476:1;46472;:5;:::i;64680:690::-;64817:4;64834:15;:2;-1:-1:-1;;;;;64834:13:0;;:15::i;:::-;64830:535;;;64889:2;-1:-1:-1;;;;;64873:36:0;;64910:12;:10;:12::i;:::-;64924:4;64930:7;64939:5;64873:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64873:72:0;;;;;;;;-1:-1:-1;;64873:72:0;;;;;;;;;;;;:::i;:::-;;;64860:464;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65104:13:0;;65100:215;;65137:61;;-1:-1:-1;;;65137:61:0;;;;;;;:::i;65100:215::-;65283:6;65277:13;65268:6;65264:2;65260:15;65253:38;64860:464;-1:-1:-1;;;;;;64995:55:0;-1:-1:-1;;;64995:55:0;;-1:-1:-1;64988:62:0;;64830:535;-1:-1:-1;65353:4:0;64830:535;64680:690;;;;;;:::o;18745:723::-;18801:13;19022:10;19018:53;;-1:-1:-1;19049:10:0;;;;;;;;;;;;-1:-1:-1;;;19049:10:0;;;;;;19018:53;19096:5;19081:12;19137:78;19144:9;;19137:78;;19170:8;;;;:::i;:::-;;-1:-1:-1;19193:10:0;;-1:-1:-1;19201:2:0;19193:10;;:::i;:::-;;;19137:78;;;19225:19;19257:6;-1:-1:-1;;;;;19247:17:0;;;;;-1:-1:-1;;;19247:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19247:17:0;;19225:39;;19275:154;19282:10;;19275:154;;19309:11;19319:1;19309:11;;:::i;:::-;;-1:-1:-1;19378:10:0;19386:2;19378:5;:10;:::i;:::-;19365:24;;:2;:24;:::i;:::-;19352:39;;19335:6;19342;19335:14;;;;;;-1:-1:-1;;;19335:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;19335:56:0;;;;;;;;-1:-1:-1;19406:11:0;19415:2;19406:11;;:::i;:::-;;;19275:154;;59830:1272;59935:20;59958:12;-1:-1:-1;;;;;59985:16:0;;59977:62;;;;-1:-1:-1;;;59977:62:0;;;;;;;:::i;:::-;60176:21;60184:12;60176:7;:21::i;:::-;60175:22;60167:64;;;;-1:-1:-1;;;60167:64:0;;;;;;;:::i;:::-;60258:12;60246:8;:24;;60238:71;;;;-1:-1:-1;;;60238:71:0;;;;;;;:::i;:::-;60318:61;60348:1;60352:2;60356:12;60370:8;60318:21;:61::i;:::-;-1:-1:-1;;;;;60421:16:0;;60388:30;60421:16;;;:12;:16;;;;;;;;;60388:49;;;;;;;;;-1:-1:-1;;;;;60388:49:0;;;;;-1:-1:-1;;;60388:49:0;;;;;;;;;;;60463:119;;;;;;;;60483:19;;60388:49;;60463:119;;;60483:39;;60513:8;;60483:39;:::i;:::-;-1:-1:-1;;;;;60463:119:0;;;;;60566:8;60531:11;:24;;;:44;;;;:::i;:::-;-1:-1:-1;;;;;60463:119:0;;;;;;-1:-1:-1;;;;;60444:16:0;;;;;;;:12;:16;;;;;;;;:138;;;;;;;;;;-1:-1:-1;;;60444:138:0;;;;-1:-1:-1;;60444:138:0;;;;;;;;;;;;;;;;;60617:43;;;;;;;;;;-1:-1:-1;;;;;60643:15:0;60617:43;;;;;;;;60589:25;;;:11;:25;;;;;;:71;;;;;;;;;-1:-1:-1;;;60589:71:0;-1:-1:-1;;;;60589:71:0;;;;-1:-1:-1;;;;;;60589:71:0;;;;;;;;;;;;;;;60601:12;;60713:281;60737:8;60733:1;:12;60713:281;;;60766:38;;60791:12;;-1:-1:-1;;;;;60766:38:0;;;60783:1;;60766:38;;60783:1;;60766:38;60831:59;60862:1;60866:2;60870:12;60884:5;60831:22;:59::i;:::-;60813:150;;;;-1:-1:-1;;;60813:150:0;;;;;;;:::i;:::-;60972:14;;;;:::i;:::-;;;;60747:3;;;;;:::i;:::-;;;;60713:281;;;-1:-1:-1;61002:12:0;:27;;;61036:60;;61069:2;61073:12;61087:8;61036:20;:60::i;11128:387::-;11451:20;11499:8;;;11128:387::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;14:409:1;;-1:-1:-1;;;;;106:6:1;103:30;100:2;;;136:18;;:::i;:::-;174:58;220:2;197:17;;-1:-1:-1;;193:31:1;226:4;189:42;174:58;:::i;:::-;165:67;;255:6;248:5;241:21;295:3;286:6;281:3;277:16;274:25;271:2;;;312:1;309;302:12;271:2;361:6;356:3;349:4;342:5;338:16;325:43;415:1;408:4;399:6;392:5;388:18;384:29;377:40;90:333;;;;;:::o;428:175::-;498:20;;-1:-1:-1;;;;;547:31:1;;537:42;;527:2;;593:1;590;583:12;608:162;675:20;;731:13;;724:21;714:32;;704:2;;760:1;757;750:12;775:233;;873:3;866:4;858:6;854:17;850:27;840:2;;895:5;888;881:20;840:2;921:81;998:3;989:6;976:20;969:4;961:6;957:17;921:81;:::i;1013:198::-;;1125:2;1113:9;1104:7;1100:23;1096:32;1093:2;;;1146:6;1138;1131:22;1093:2;1174:31;1195:9;1174:31;:::i;1216:274::-;;;1345:2;1333:9;1324:7;1320:23;1316:32;1313:2;;;1366:6;1358;1351:22;1313:2;1394:31;1415:9;1394:31;:::i;:::-;1384:41;;1444:40;1480:2;1469:9;1465:18;1444:40;:::i;:::-;1434:50;;1303:187;;;;;:::o;1495:342::-;;;;1641:2;1629:9;1620:7;1616:23;1612:32;1609:2;;;1662:6;1654;1647:22;1609:2;1690:31;1711:9;1690:31;:::i;:::-;1680:41;;1740:40;1776:2;1765:9;1761:18;1740:40;:::i;:::-;1730:50;;1827:2;1816:9;1812:18;1799:32;1789:42;;1599:238;;;;;:::o;1842:702::-;;;;;2014:3;2002:9;1993:7;1989:23;1985:33;1982:2;;;2036:6;2028;2021:22;1982:2;2064:31;2085:9;2064:31;:::i;:::-;2054:41;;2114:40;2150:2;2139:9;2135:18;2114:40;:::i;:::-;2104:50;;2201:2;2190:9;2186:18;2173:32;2163:42;;2256:2;2245:9;2241:18;2228:32;-1:-1:-1;;;;;2275:6:1;2272:30;2269:2;;;2320:6;2312;2305:22;2269:2;2348:22;;2401:4;2393:13;;2389:27;-1:-1:-1;2379:2:1;;2435:6;2427;2420:22;2379:2;2463:75;2530:7;2525:2;2512:16;2507:2;2503;2499:11;2463:75;:::i;:::-;2453:85;;;1972:572;;;;;;;:::o;2549:268::-;;;2675:2;2663:9;2654:7;2650:23;2646:32;2643:2;;;2696:6;2688;2681:22;2643:2;2724:31;2745:9;2724:31;:::i;:::-;2714:41;;2774:37;2807:2;2796:9;2792:18;2774:37;:::i;2822:266::-;;;2951:2;2939:9;2930:7;2926:23;2922:32;2919:2;;;2972:6;2964;2957:22;2919:2;3000:31;3021:9;3000:31;:::i;:::-;2990:41;3078:2;3063:18;;;;3050:32;;-1:-1:-1;;;2909:179:1:o;3093:1010::-;;3208:2;3251;3239:9;3230:7;3226:23;3222:32;3219:2;;;3272:6;3264;3257:22;3219:2;3317:9;3304:23;-1:-1:-1;;;;;3387:2:1;3379:6;3376:14;3373:2;;;3408:6;3400;3393:22;3373:2;3451:6;3440:9;3436:22;3426:32;;3496:7;3489:4;3485:2;3481:13;3477:27;3467:2;;3523:6;3515;3508:22;3467:2;3564;3551:16;3586:2;3582;3579:10;3576:2;;;3592:18;;:::i;:::-;3639:2;3635;3631:11;3621:21;;3662:27;3685:2;3681;3677:11;3662:27;:::i;:::-;3723:15;;;3754:12;;;;3786:11;;;3816;;;3812:20;;3809:33;-1:-1:-1;3806:2:1;;;3860:6;3852;3845:22;3806:2;3887:6;3878:15;;3902:171;3916:2;3913:1;3910:9;3902:171;;;3973:25;3994:3;3973:25;:::i;:::-;3961:38;;3934:1;3927:9;;;;;4019:12;;;;4051;;3902:171;;;-1:-1:-1;4092:5:1;3188:915;-1:-1:-1;;;;;;;;3188:915:1:o;4108:192::-;;4217:2;4205:9;4196:7;4192:23;4188:32;4185:2;;;4238:6;4230;4223:22;4185:2;4266:28;4284:9;4266:28;:::i;4305:257::-;;4416:2;4404:9;4395:7;4391:23;4387:32;4384:2;;;4437:6;4429;4422:22;4384:2;4481:9;4468:23;4500:32;4526:5;4500:32;:::i;4567:261::-;;4689:2;4677:9;4668:7;4664:23;4660:32;4657:2;;;4710:6;4702;4695:22;4657:2;4747:9;4741:16;4766:32;4792:5;4766:32;:::i;4833:577::-;;;4982:2;4970:9;4961:7;4957:23;4953:32;4950:2;;;5003:6;4995;4988:22;4950:2;5048:9;5035:23;-1:-1:-1;;;;;5118:2:1;5110:6;5107:14;5104:2;;;5139:6;5131;5124:22;5104:2;5167:52;5211:7;5202:6;5191:9;5187:22;5167:52;:::i;:::-;5157:62;;5272:2;5261:9;5257:18;5244:32;5228:48;;5301:2;5291:8;5288:16;5285:2;;;5322:6;5314;5307:22;5285:2;;5350:54;5396:7;5385:8;5374:9;5370:24;5350:54;:::i;:::-;5340:64;;;4940:470;;;;;:::o;5415:190::-;;5527:2;5515:9;5506:7;5502:23;5498:32;5495:2;;;5548:6;5540;5533:22;5495:2;-1:-1:-1;5576:23:1;;5485:120;-1:-1:-1;5485:120:1:o;5610:258::-;;;5739:2;5727:9;5718:7;5714:23;5710:32;5707:2;;;5760:6;5752;5745:22;5707:2;-1:-1:-1;;5788:23:1;;;5858:2;5843:18;;;5830:32;;-1:-1:-1;5697:171:1:o;5873:259::-;;5954:5;5948:12;5981:6;5976:3;5969:19;5997:63;6053:6;6046:4;6041:3;6037:14;6030:4;6023:5;6019:16;5997:63;:::i;:::-;6114:2;6093:15;-1:-1:-1;;6089:29:1;6080:39;;;;6121:4;6076:50;;5924:208;-1:-1:-1;;5924:208:1:o;6137:982::-;6224:12;;6137:982;;6296:1;6281:17;;6317:1;6353:18;;;;6380:2;;6434:4;6426:6;6422:17;6412:27;;6380:2;6460;6508;6500:6;6497:14;6477:18;6474:38;6471:2;;;-1:-1:-1;;;6535:33:1;;6591:4;6588:1;6581:15;6621:4;6542:3;6609:17;6471:2;6652:18;6679:104;;;;6797:1;6792:321;;;;6645:468;;6679:104;-1:-1:-1;;6712:24:1;;6700:37;;6757:16;;;;-1:-1:-1;6679:104:1;;6792:321;6828:38;6860:5;6828:38;:::i;:::-;6888:1;6902:165;6916:6;6913:1;6910:13;6902:165;;;6994:14;;6981:11;;;6974:35;7037:16;;;;6931:10;;6902:165;;;6906:3;;7096:6;7091:3;7087:16;7080:23;;6645:468;;;;;;;6197:922;;;;:::o;7124:199::-;;7277:40;7313:3;7305:6;7277:40;:::i;7328:378::-;;7532:40;7568:3;7560:6;7532:40;:::i;:::-;7601:6;7595:13;7617:52;7662:6;7658:2;7651:4;7643:6;7639:17;7617:52;:::i;:::-;7685:15;;7512:194;-1:-1:-1;;;;7512:194:1:o;7711:203::-;-1:-1:-1;;;;;7875:32:1;;;;7857:51;;7845:2;7830:18;;7812:102::o;7919:490::-;-1:-1:-1;;;;;8188:15:1;;;8170:34;;8240:15;;8235:2;8220:18;;8213:43;8287:2;8272:18;;8265:34;;;8335:3;8330:2;8315:18;;8308:31;;;7919:490;;8356:47;;8383:19;;8375:6;8356:47;:::i;:::-;8348:55;8122:287;-1:-1:-1;;;;;;8122:287:1:o;8414:635::-;8585:2;8637:21;;;8707:13;;8610:18;;;8729:22;;;8414:635;;8585:2;8808:15;;;;8782:2;8767:18;;;8414:635;8854:169;8868:6;8865:1;8862:13;8854:169;;;8929:13;;8917:26;;8998:15;;;;8963:12;;;;8890:1;8883:9;8854:169;;;-1:-1:-1;9040:3:1;;8565:484;-1:-1:-1;;;;;;8565:484:1:o;9054:187::-;9219:14;;9212:22;9194:41;;9182:2;9167:18;;9149:92::o;9246:221::-;;9395:2;9384:9;9377:21;9415:46;9457:2;9446:9;9442:18;9434:6;9415:46;:::i;9472:398::-;9674:2;9656:21;;;9713:2;9693:18;;;9686:30;9752:34;9747:2;9732:18;;9725:62;-1:-1:-1;;;9818:2:1;9803:18;;9796:32;9860:3;9845:19;;9646:224::o;9875:402::-;10077:2;10059:21;;;10116:2;10096:18;;;10089:30;10155:34;10150:2;10135:18;;10128:62;-1:-1:-1;;;10221:2:1;10206:18;;10199:36;10267:3;10252:19;;10049:228::o;10282:406::-;10484:2;10466:21;;;10523:2;10503:18;;;10496:30;10562:34;10557:2;10542:18;;10535:62;-1:-1:-1;;;10628:2:1;10613:18;;10606:40;10678:3;10663:19;;10456:232::o;10693:347::-;10895:2;10877:21;;;10934:2;10914:18;;;10907:30;10973:25;10968:2;10953:18;;10946:53;11031:2;11016:18;;10867:173::o;11045:399::-;11247:2;11229:21;;;11286:2;11266:18;;;11259:30;11325:34;11320:2;11305:18;;11298:62;-1:-1:-1;;;11391:2:1;11376:18;;11369:33;11434:3;11419:19;;11219:225::o;11449:400::-;11651:2;11633:21;;;11690:2;11670:18;;;11663:30;11729:34;11724:2;11709:18;;11702:62;-1:-1:-1;;;11795:2:1;11780:18;;11773:34;11839:3;11824:19;;11623:226::o;11854:401::-;12056:2;12038:21;;;12095:2;12075:18;;;12068:30;12134:34;12129:2;12114:18;;12107:62;-1:-1:-1;;;12200:2:1;12185:18;;12178:35;12245:3;12230:19;;12028:227::o;12260:355::-;12462:2;12444:21;;;12501:2;12481:18;;;12474:30;12540:33;12535:2;12520:18;;12513:61;12606:2;12591:18;;12434:181::o;12620:356::-;12822:2;12804:21;;;12841:18;;;12834:30;12900:34;12895:2;12880:18;;12873:62;12967:2;12952:18;;12794:182::o;12981:335::-;13183:2;13165:21;;;13222:2;13202:18;;;13195:30;-1:-1:-1;;;13256:2:1;13241:18;;13234:41;13307:2;13292:18;;13155:161::o;13321:421::-;13523:2;13505:21;;;13562:2;13542:18;;;13535:30;13601:34;13596:2;13581:18;;13574:62;13672:27;13667:2;13652:18;;13645:55;13732:3;13717:19;;13495:247::o;13747:420::-;13949:2;13931:21;;;13988:2;13968:18;;;13961:30;14027:34;14022:2;14007:18;;14000:62;14098:26;14093:2;14078:18;;14071:54;14157:3;14142:19;;13921:246::o;14172:407::-;14374:2;14356:21;;;14413:2;14393:18;;;14386:30;14452:34;14447:2;14432:18;;14425:62;-1:-1:-1;;;14518:2:1;14503:18;;14496:41;14569:3;14554:19;;14346:233::o;14584:332::-;14786:2;14768:21;;;14825:1;14805:18;;;14798:29;-1:-1:-1;;;14858:2:1;14843:18;;14836:39;14907:2;14892:18;;14758:158::o;14921:346::-;15123:2;15105:21;;;15162:2;15142:18;;;15135:30;-1:-1:-1;;;15196:2:1;15181:18;;15174:52;15258:2;15243:18;;15095:172::o;15272:402::-;15474:2;15456:21;;;15513:2;15493:18;;;15486:30;15552:34;15547:2;15532:18;;15525:62;-1:-1:-1;;;15618:2:1;15603:18;;15596:36;15664:3;15649:19;;15446:228::o;15679:335::-;15881:2;15863:21;;;15920:2;15900:18;;;15893:30;-1:-1:-1;;;15954:2:1;15939:18;;15932:41;16005:2;15990:18;;15853:161::o;16019:356::-;16221:2;16203:21;;;16240:18;;;16233:30;16299:34;16294:2;16279:18;;16272:62;16366:2;16351:18;;16193:182::o;16380:411::-;16582:2;16564:21;;;16621:2;16601:18;;;16594:30;16660:34;16655:2;16640:18;;16633:62;-1:-1:-1;;;16726:2:1;16711:18;;16704:45;16781:3;16766:19;;16554:237::o;16796:351::-;16998:2;16980:21;;;17037:2;17017:18;;;17010:30;17076:29;17071:2;17056:18;;17049:57;17138:2;17123:18;;16970:177::o;17152:350::-;17354:2;17336:21;;;17393:2;17373:18;;;17366:30;17432:28;17427:2;17412:18;;17405:56;17493:2;17478:18;;17326:176::o;17507:414::-;17709:2;17691:21;;;17748:2;17728:18;;;17721:30;17787:34;17782:2;17767:18;;17760:62;-1:-1:-1;;;17853:2:1;17838:18;;17831:48;17911:3;17896:19;;17681:240::o;17926:411::-;18128:2;18110:21;;;18167:2;18147:18;;;18140:30;18206:34;18201:2;18186:18;;18179:62;-1:-1:-1;;;18272:2:1;18257:18;;18250:45;18327:3;18312:19;;18100:237::o;18342:398::-;18544:2;18526:21;;;18583:2;18563:18;;;18556:30;18622:34;18617:2;18602:18;;18595:62;-1:-1:-1;;;18688:2:1;18673:18;;18666:32;18730:3;18715:19;;18516:224::o;18745:415::-;18947:2;18929:21;;;18986:2;18966:18;;;18959:30;19025:34;19020:2;19005:18;;18998:62;-1:-1:-1;;;19091:2:1;19076:18;;19069:49;19150:3;19135:19;;18919:241::o;19165:353::-;19367:2;19349:21;;;19406:2;19386:18;;;19379:30;19445:31;19440:2;19425:18;;19418:59;19509:2;19494:18;;19339:179::o;19523:397::-;19725:2;19707:21;;;19764:2;19744:18;;;19737:30;19803:34;19798:2;19783:18;;19776:62;-1:-1:-1;;;19869:2:1;19854:18;;19847:31;19910:3;19895:19;;19697:223::o;19925:410::-;20127:2;20109:21;;;20166:2;20146:18;;;20139:30;20205:34;20200:2;20185:18;;20178:62;-1:-1:-1;;;20271:2:1;20256:18;;20249:44;20325:3;20310:19;;20099:236::o;20340:411::-;20542:2;20524:21;;;20581:2;20561:18;;;20554:30;20620:34;20615:2;20600:18;;20593:62;-1:-1:-1;;;20686:2:1;20671:18;;20664:45;20741:3;20726:19;;20514:237::o;20756:409::-;20958:2;20940:21;;;20997:2;20977:18;;;20970:30;21036:34;21031:2;21016:18;;21009:62;-1:-1:-1;;;21102:2:1;21087:18;;21080:43;21155:3;21140:19;;20930:235::o;21170:398::-;21372:2;21354:21;;;21411:2;21391:18;;;21384:30;21450:34;21445:2;21430:18;;21423:62;-1:-1:-1;;;21516:2:1;21501:18;;21494:32;21558:3;21543:19;;21344:224::o;21573:349::-;21775:2;21757:21;;;21814:2;21794:18;;;21787:30;21853:27;21848:2;21833:18;;21826:55;21913:2;21898:18;;21747:175::o;21927:177::-;22073:25;;;22061:2;22046:18;;22028:76::o;22109:251::-;22179:2;22173:9;22209:17;;;-1:-1:-1;;;;;22241:34:1;;22277:22;;;22238:62;22235:2;;;22303:18;;:::i;:::-;22339:2;22332:22;22153:207;;-1:-1:-1;22153:207:1:o;22365:129::-;;22433:17;;;22483:4;22467:21;;;22423:71::o;22499:253::-;;-1:-1:-1;;;;;22628:2:1;22625:1;22621:10;22658:2;22655:1;22651:10;22689:3;22685:2;22681:12;22676:3;22673:21;22670:2;;;22697:18;;:::i;22757:128::-;;22828:1;22824:6;22821:1;22818:13;22815:2;;;22834:18;;:::i;:::-;-1:-1:-1;22870:9:1;;22805:80::o;22890:120::-;;22956:1;22946:2;;22961:18;;:::i;:::-;-1:-1:-1;22995:9:1;;22936:74::o;23015:168::-;;23121:1;23117;23113:6;23109:14;23106:1;23103:21;23098:1;23091:9;23084:17;23080:45;23077:2;;;23128:18;;:::i;:::-;-1:-1:-1;23168:9:1;;23067:116::o;23188:246::-;;-1:-1:-1;;;;;23341:10:1;;;;23311;;23363:12;;;23360:2;;;23378:18;;:::i;:::-;23415:13;;23237:197;-1:-1:-1;;;23237:197:1:o;23439:125::-;;23507:1;23504;23501:8;23498:2;;;23512:18;;:::i;:::-;-1:-1:-1;23549:9:1;;23488:76::o;23569:258::-;23641:1;23651:113;23665:6;23662:1;23659:13;23651:113;;;23741:11;;;23735:18;23722:11;;;23715:39;23687:2;23680:10;23651:113;;;23782:6;23779:1;23776:13;23773:2;;;-1:-1:-1;;23817:1:1;23799:16;;23792:27;23622:205::o;23832:136::-;;23899:5;23889:2;;23908:18;;:::i;:::-;-1:-1:-1;;;23944:18:1;;23879:89::o;23973:380::-;24058:1;24048:12;;24105:1;24095:12;;;24116:2;;24170:4;24162:6;24158:17;24148:27;;24116:2;24223;24215:6;24212:14;24192:18;24189:38;24186:2;;;24269:10;24264:3;24260:20;24257:1;24250:31;24304:4;24301:1;24294:15;24332:4;24329:1;24322:15;24186:2;;24028:325;;;:::o;24358:135::-;;-1:-1:-1;;24418:17:1;;24415:2;;;24438:18;;:::i;:::-;-1:-1:-1;24485:1:1;24474:13;;24405:88::o;24498:112::-;;24556:1;24546:2;;24561:18;;:::i;:::-;-1:-1:-1;24595:9:1;;24536:74::o;24615:127::-;24676:10;24671:3;24667:20;24664:1;24657:31;24707:4;24704:1;24697:15;24731:4;24728:1;24721:15;24747:127;24808:10;24803:3;24799:20;24796:1;24789:31;24839:4;24836:1;24829:15;24863:4;24860:1;24853:15;24879:127;24940:10;24935:3;24931:20;24928:1;24921:31;24971:4;24968:1;24961:15;24995:4;24992:1;24985:15;25011:133;-1:-1:-1;;;;;;25087:32:1;;25077:43;;25067:2;;25134:1;25131;25124:12

Swarm Source

ipfs://07145d89ae68464bc7aa8b8e4330b59540ab60eb048e06d71c60c45294206097

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