Token

(0x213019b9e4c0eed9f4fa3ea0da15f328657d7b5b)

This is a fake Cybernetic Punks token.

ERC-721

Phish / Hack

Overview

Max Total Supply

676 ERC-721 TOKEN*

Holders

159

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x213019b9e4c0eed9f4fa3ea0da15f328657d7b5b

Filtered by Token Holder

0x30EeDD4EA7E1959Fc9d6879cd26F1d8BaabBC5f6

Balance

1 ERC-721 TOKEN*

0x30EeDD4EA7E1959Fc9d6879cd26F1d8BaabBC5f6

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

CyberneticPunks

Compiler Version

v0.8.15+commit.e14f2714

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT
// ERC721A Contracts v3.3.0
// Creator: Chiru Labs

pragma solidity ^0.8.14;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721A is IERC721, IERC721Metadata {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

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

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);
}

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // 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) internal _ownerships;

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

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

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

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

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public override view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
    unchecked {
        return _currentIndex - _burnCounter - _startTokenId();
    }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
    unchecked {
        return _currentIndex - _startTokenId();
    }
    }

    /**
     * @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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

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

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

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

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

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

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

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

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

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

        if (_msgSender() != owner) if(!isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract()) if(!_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

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

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

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

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

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

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

        uint256 updatedIndex = startTokenId;
        uint256 end = updatedIndex + quantity;

        if (to.isContract()) {
            do {
                emit Transfer(address(0), to, updatedIndex);
                if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                    revert TransferToNonERC721ReceiverImplementer();
                }
            } while (updatedIndex < end);
            // Reentrancy protection
            if (_currentIndex != startTokenId) revert();
        } else {
            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex < end);
        }
        _currentIndex = updatedIndex;
    }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

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

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

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

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

        uint256 updatedIndex = startTokenId;
        uint256 end = updatedIndex + quantity;

        do {
            emit Transfer(address(0), to, updatedIndex++);
        } while (updatedIndex < end);

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

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
        isApprovedForAll(from, _msgSender()) ||
        getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

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

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

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

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

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        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 TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

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

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

abstract contract ContextMixin {
    function msgSender()
    internal
    view
    returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
            // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                mload(add(array, index)),
                0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since 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 subtraction 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;
    }
    }
}

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
    internal
    initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
    internal
    view
    returns (bytes32)
    {
        return
        keccak256(
            abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
        );
    }
}

contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
        nonce: nonces[userAddress],
        from: userAddress,
        functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
    internal
    pure
    returns (bytes32)
    {
        return
        keccak256(
            abi.encode(
                META_TRANSACTION_TYPEHASH,
                metaTx.nonce,
                metaTx.from,
                keccak256(metaTx.functionSignature)
            )
        );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
        signer ==
        ecrecover(
            toTypedMessageHash(hashMetaTransaction(metaTx)),
            sigV,
            sigR,
            sigS
        );
    }
}

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

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

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

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

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

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

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

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

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

contract OwnableDelegateProxy {}

/**
 * Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
 */
contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

contract CyberneticPunks is
ERC721A,
ContextMixin,
NativeMetaTransaction,
Ownable,
ReentrancyGuard
{
    using Strings for uint256;

    address proxyRegistryAddress;

    string public constant collectionName = "Cybernetic Punks";
    string public constant collectionSymbol = "CPUNK";
    uint256 public constant maxQuantityPerMint = 10;
    uint256 public mintPrice = 0.022 ether;
    uint256 public maxTotalSupply = 3022;

    bool public mintActive = false;

    string public baseTokenURI;
    string public _contractURI;
    string public baseExtension = ".json";

    constructor(
        address _proxyRegistryAddress,
        string memory contractURI_
    ) ERC721A(collectionName, collectionSymbol) {
        _contractURI = contractURI_;
        proxyRegistryAddress = _proxyRegistryAddress;
        _initializeEIP712(collectionName);
    }

    modifier callerIsUser() {
        require(tx.origin == msg.sender, "The caller is another contract");
        _;
    }

    function gift(address to, uint256 quantity) external onlyOwner nonReentrant {
        require(totalSupply() + quantity <= maxTotalSupply, "Total supply would be exceeded");
        _safeMint(to, quantity);
    }

    function mint(uint256 quantity) external payable callerIsUser {
        uint256 currentPrice = quantity * mintPrice;
        require(mintActive, "Mint is currently paused");
        require(quantity <= maxQuantityPerMint, "Mint quantity limit 10");
        require(msg.value >= currentPrice, "Not enough payed");
        require(totalSupply() + quantity <= maxTotalSupply, "Total supply would be exceeded");

        _safeMint(_msgSender(), quantity);
        refundIfOver(currentPrice);
    }

    function refundIfOver(uint256 price) private {
        require(msg.value >= price, "Need to send more ETH.");
        if (msg.value > price) {
            payable(msg.sender).transfer(msg.value - price);
        }
    }

    function setMintActive(bool value) public onlyOwner {
        mintActive = value;
    }

    function setBaseURI(string calldata baseURI) public onlyOwner {
        baseTokenURI = baseURI;
    }

    function setContractURI(string calldata contractURI_) public onlyOwner {
        _contractURI = contractURI_;
    }

    function setBaseExtension(string calldata extension) public onlyOwner {
        baseExtension = extension;
    }

    function changeMintPrice(uint256 newPrice) public onlyOwner {
        mintPrice = newPrice;
    }

    function changeTotalSupply(uint256 newSupply) public onlyOwner {
        maxTotalSupply = newSupply;
    }

    function getMintPrice() public view returns (uint256) {
        return mintPrice;
    }

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

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

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

    function contractURI() public view returns (string memory) {
        return _contractURI;
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
     */
    function isApprovedForAll(address owner, address operator)
    override
    public
    view
    returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(owner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
    internal
    override
    view
    returns (address sender)
    {
        return ContextMixin.msgSender();
    }

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_proxyRegistryAddress","type":"address"},{"internalType":"string","name":"contractURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","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":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"changeMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSupply","type":"uint256"}],"name":"changeTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"collectionName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"collectionSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"gift","outputs":[],"stateMutability":"nonpayable","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":"maxQuantityPerMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"extension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"contractURI_","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setMintActive","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":"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":[],"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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

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

000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d6244384d5831397932526e53383658737a724c6f796656684655634b704c6a653864556d464d535841594e4a0000000000000000000000

-----Decoded View---------------
Arg [0] : _proxyRegistryAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1
Arg [1] : contractURI_ (string): ipfs://QmbD8MX19y2RnS86XszrLoyfVhFUcKpLje8dUmFMSXAYNJ

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [3] : 697066733a2f2f516d6244384d5831397932526e53383658737a724c6f796656
Arg [4] : 684655634b704c6a653864556d464d535841594e4a0000000000000000000000

Deployed Bytecode Sourcemap

60293:4425:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24524:293;;;;;;;;;;-1:-1:-1;24524:293:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;24524:293:0;;;;;;;;27543:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;29092:204::-;;;;;;;;;;-1:-1:-1;29092:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;29092:204:0;1528:203:1;28609:417:0;;;;;;;;;;-1:-1:-1;28609:417:0;;;;;:::i;:::-;;:::i;:::-;;52938:1139;;;;;;:::i;:::-;;:::i;50235:43::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;50235:43:0;;;;;23788:300;;;;;;;;;;-1:-1:-1;24043:12:0;;23841:7;24027:13;:28;23788:300;;;4179:25:1;;;4167:2;4152:18;23788:300:0;4033:177:1;51236:101:0;;;;;;;;;;-1:-1:-1;51314:15:0;;51236:101;;29957:170;;;;;;;;;;-1:-1:-1;29957:170:0;;;;;:::i;:::-;;:::i;60741:30::-;;;;;;;;;;-1:-1:-1;60741:30:0;;;;;;;;60696:36;;;;;;;;;;;;;;;;54459:107;;;;;;;;;;-1:-1:-1;54459:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;54546:12:0;54512:13;54546:12;;;:6;:12;;;;;;;54459:107;60541:49;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;60541:49:0;;;;;51345:161;;;;;;;;;;-1:-1:-1;51459:9:0;51345:161;;64531:184;;;;;;;;;;;;;:::i;62731:99::-;;;;;;;;;;-1:-1:-1;62731:99:0;;;;;:::i;:::-;;:::i;30198:185::-;;;;;;;;;;-1:-1:-1;30198:185:0;;;;;:::i;:::-;;:::i;62838:108::-;;;;;;;;;;-1:-1:-1;62838:108:0;;;;;:::i;:::-;;:::i;62373:103::-;;;;;;;;;;-1:-1:-1;62373:103:0;;;;;:::i;:::-;;:::i;27351:125::-;;;;;;;;;;-1:-1:-1;27351:125:0;;;;;:::i;:::-;;:::i;60651:38::-;;;;;;;;;;;;;;;;60597:47;;;;;;;;;;;;60642:2;60597:47;;24881:206;;;;;;;;;;-1:-1:-1;24881:206:0;;;;;:::i;:::-;;:::i;56609:103::-;;;;;;;;;;;;;:::i;55958:87::-;;;;;;;;;;-1:-1:-1;56031:6:0;;-1:-1:-1;;;;;56031:6:0;55958:87;;62484:117;;;;;;;;;;-1:-1:-1;62484:117:0;;;;;:::i;:::-;;:::i;27712:104::-;;;;;;;;;;;;;:::i;61534:502::-;;;;;;:::i;:::-;;:::i;29368:287::-;;;;;;;;;;-1:-1:-1;29368:287:0;;;;;:::i;:::-;;:::i;62954:89::-;;;;;;;;;;-1:-1:-1;63026:9:0;;62954:89;;30454:370;;;;;;;;;;-1:-1:-1;30454:370:0;;;;;:::i;:::-;;:::i;60813:26::-;;;;;;;;;;;;;:::i;60846:37::-;;;;;;;;;;;;;:::i;63235:333::-;;;;;;;;;;-1:-1:-1;63235:333:0;;;;;:::i;:::-;;:::i;61312:214::-;;;;;;;;;;-1:-1:-1;61312:214:0;;;;;:::i;:::-;;:::i;60780:26::-;;;;;;;;;;;;;:::i;62609:114::-;;;;;;;;;;-1:-1:-1;62609:114:0;;;;;:::i;:::-;;:::i;60476:58::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;60476:58:0;;;;;63576:97;;;;;;;;;;;;;:::i;63805:429::-;;;;;;;;;;-1:-1:-1;63805:429:0;;;;;:::i;:::-;;:::i;62276:89::-;;;;;;;;;;-1:-1:-1;62276:89:0;;;;;:::i;:::-;;:::i;56867:201::-;;;;;;;;;;-1:-1:-1;56867:201:0;;;;;:::i;:::-;;:::i;24524:293::-;24626:4;-1:-1:-1;;;;;;24659:40:0;;-1:-1:-1;;;24659:40:0;;:101;;-1:-1:-1;;;;;;;24712:48:0;;-1:-1:-1;;;24712:48:0;24659:101;:150;;;-1:-1:-1;;;;;;;;;;21782:40:0;;;24773:36;24643:166;24524:293;-1:-1:-1;;24524:293:0:o;27543:100::-;27597:13;27630:5;27623:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27543:100;:::o;29092:204::-;29160:7;29185:16;29193:7;29185;:16::i;:::-;29180:64;;29210:34;;-1:-1:-1;;;29210:34:0;;;;;;;;;;;29180:64;-1:-1:-1;29264:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;29264:24:0;;29092:204::o;28609:417::-;28682:13;28698:24;28714:7;28698:15;:24::i;:::-;28682:40;;28743:5;-1:-1:-1;;;;;28737:11:0;:2;-1:-1:-1;;;;;28737:11:0;;28733:48;;28757:24;;-1:-1:-1;;;28757:24:0;;;;;;;;;;;28733:48;28814:5;-1:-1:-1;;;;;28798:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;28798:21:0;;28794:139;;28825:37;28842:5;28849:12;:10;:12::i;28825:37::-;28821:112;;28886:35;;-1:-1:-1;;;28886:35:0;;;;;;;;;;;28821:112;28945:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;28945:29:0;-1:-1:-1;;;;;28945:29:0;;;;;;;;;28990:28;;28945:24;;28990:28;;;;;;;28671:355;28609:417;;:::o;52938:1139::-;53196:140;;;53139:12;53196:140;;;;;-1:-1:-1;;;;;53230:19:0;;53164:29;53230:19;;;:6;:19;;;;;;;;;53196:140;;;;;;;;;;;53371:45;53237:11;53196:140;53399:4;53405;53411;53371:6;:45::i;:::-;53349:128;;;;-1:-1:-1;;;53349:128:0;;8027:2:1;53349:128:0;;;8009:21:1;8066:2;8046:18;;;8039:30;8105:34;8085:18;;;8078:62;-1:-1:-1;;;8156:18:1;;;8149:31;8197:19;;53349:128:0;;;;;;;;;-1:-1:-1;;;;;53566:19:0;;;;;;:6;:19;;;;;;:26;;53590:1;53566:23;:26::i;:::-;-1:-1:-1;;;;;53544:19:0;;;;;;:6;:19;;;;;;;:48;;;;53610:126;;;;;53551:11;;53682:10;;53708:17;;53610:126;:::i;:::-;;;;;;;;53847:12;53861:23;53896:4;-1:-1:-1;;;;;53888:18:0;53938:17;53957:11;53921:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;53921:48:0;;;;;;;;;;53888:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53846:134;;;;53999:7;53991:48;;;;-1:-1:-1;;;53991:48:0;;9565:2:1;53991:48:0;;;9547:21:1;9604:2;9584:18;;;9577:30;9643;9623:18;;;9616:58;9691:18;;53991:48:0;9363:352:1;53991:48:0;54059:10;52938:1139;-1:-1:-1;;;;;;;;52938:1139:0:o;29957:170::-;30091:28;30101:4;30107:2;30111:7;30091:9;:28::i;:::-;29957:170;;;:::o;64531:184::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;59077:1:::1;59673:7;;:19:::0;59665:63:::1;;;::::0;-1:-1:-1;;;59665:63:0;;10283:2:1;59665:63:0::1;::::0;::::1;10265:21:1::0;10322:2;10302:18;;;10295:30;10361:33;10341:18;;;10334:61;10412:18;;59665:63:0::1;10081:355:1::0;59665:63:0::1;59077:1;59806:7;:18:::0;64611:49:::2;::::0;64593:12:::2;::::0;64611:10:::2;::::0;64634:21:::2;::::0;64593:12;64611:49;64593:12;64611:49;64634:21;64611:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64592:68;;;64679:7;64671:36;;;::::0;-1:-1:-1;;;64671:36:0;;10853:2:1;64671:36:0::2;::::0;::::2;10835:21:1::0;10892:2;10872:18;;;10865:30;-1:-1:-1;;;10911:18:1;;;10904:46;10967:18;;64671:36:0::2;10651:340:1::0;64671:36:0::2;-1:-1:-1::0;59033:1:0::1;59985:7;:22:::0;64531:184::o;62731:99::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;62802:9:::1;:20:::0;62731:99::o;30198:185::-;30336:39;30353:4;30359:2;30363:7;30336:39;;;;;;;;;;;;:16;:39::i;62838:108::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;62912:14:::1;:26:::0;62838:108::o;62373:103::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;62446:12:::1;:22;62461:7:::0;;62446:12;:22:::1;:::i;27351:125::-:0;27415:7;27442:21;27455:7;27442:12;:21::i;:::-;:26;;27351:125;-1:-1:-1;;27351:125:0:o;24881:206::-;24945:7;-1:-1:-1;;;;;24969:19:0;;24965:60;;24997:28;;-1:-1:-1;;;24997:28:0;;;;;;;;;;;24965:60;-1:-1:-1;;;;;;25051:19:0;;;;;:12;:19;;;;;:27;;;;24881:206::o;56609:103::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;56674:30:::1;56701:1;56674:18;:30::i;:::-;56609:103::o:0;62484:117::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;62566:12:::1;:27;62581:12:::0;;62566;:27:::1;:::i;27712:104::-:0;27768:13;27801:7;27794:14;;;;;:::i;61534:502::-;61226:9;61239:10;61226:23;61218:66;;;;-1:-1:-1;;;61218:66:0;;13256:2:1;61218:66:0;;;13238:21:1;13295:2;13275:18;;;13268:30;13334:32;13314:18;;;13307:60;13384:18;;61218:66:0;13054:354:1;61218:66:0;61607:20:::1;61641:9;;61630:8;:20;;;;:::i;:::-;61669:10;::::0;61607:43;;-1:-1:-1;61669:10:0::1;;61661:47;;;::::0;-1:-1:-1;;;61661:47:0;;13920:2:1;61661:47:0::1;::::0;::::1;13902:21:1::0;13959:2;13939:18;;;13932:30;13998:26;13978:18;;;13971:54;14042:18;;61661:47:0::1;13718:348:1::0;61661:47:0::1;60642:2;61727:8;:30;;61719:65;;;::::0;-1:-1:-1;;;61719:65:0;;14273:2:1;61719:65:0::1;::::0;::::1;14255:21:1::0;14312:2;14292:18;;;14285:30;-1:-1:-1;;;14331:18:1;;;14324:52;14393:18;;61719:65:0::1;14071:346:1::0;61719:65:0::1;61816:12;61803:9;:25;;61795:54;;;::::0;-1:-1:-1;;;61795:54:0;;14624:2:1;61795:54:0::1;::::0;::::1;14606:21:1::0;14663:2;14643:18;;;14636:30;-1:-1:-1;;;14682:18:1;;;14675:46;14738:18;;61795:54:0::1;14422:340:1::0;61795:54:0::1;61896:14;;61884:8;61868:13;24043:12:::0;;23841:7;24027:13;:28;;23788:300;61868:13:::1;:24;;;;:::i;:::-;:42;;61860:85;;;::::0;-1:-1:-1;;;61860:85:0;;15102:2:1;61860:85:0::1;::::0;::::1;15084:21:1::0;15141:2;15121:18;;;15114:30;15180:32;15160:18;;;15153:60;15230:18;;61860:85:0::1;14900:354:1::0;61860:85:0::1;61958:33;61968:12;:10;:12::i;:::-;61982:8;61958:9;:33::i;:::-;62002:26;62015:12;62002;:26::i;:::-;61596:440;61534:502:::0;:::o;29368:287::-;29479:12;:10;:12::i;:::-;-1:-1:-1;;;;;29467:24:0;:8;-1:-1:-1;;;;;29467:24:0;;29463:54;;29500:17;;-1:-1:-1;;;29500:17:0;;;;;;;;;;;29463:54;29575:8;29530:18;:32;29549:12;:10;:12::i;:::-;-1:-1:-1;;;;;29530:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;29530:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;29530:53:0;;;;;;;;;;;29614:12;:10;:12::i;:::-;-1:-1:-1;;;;;29599:48:0;;29638:8;29599:48;;;;565:14:1;558:22;540:41;;528:2;513:18;;400:187;29599:48:0;;;;;;;;29368:287;;:::o;30454:370::-;30621:28;30631:4;30637:2;30641:7;30621:9;:28::i;:::-;-1:-1:-1;;;;;30664:13:0;;11261:19;:23;30660:157;;30685:56;30716:4;30722:2;30726:7;30735:5;30685:30;:56::i;:::-;30681:136;;30765:40;;-1:-1:-1;;;30765:40:0;;;;;;;;;;;30681:136;30454:370;;;;:::o;60813:26::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;60846:37::-;;;;;;;:::i;63235:333::-;63308:13;63339:16;63347:7;63339;:16::i;:::-;63334:59;;63364:29;;-1:-1:-1;;;63364:29:0;;;;;;;;;;;63334:59;63406:21;63430:10;:8;:10::i;:::-;63406:34;;63464:7;63458:21;63483:1;63458:26;:102;;;;;;;;;;;;;;;;;63511:7;63520:18;:7;:16;:18::i;:::-;63540:13;63494:60;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63458:102;63451:109;63235:333;-1:-1:-1;;;63235:333:0:o;61312:214::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;59077:1:::1;59673:7;;:19:::0;59665:63:::1;;;::::0;-1:-1:-1;;;59665:63:0;;10283:2:1;59665:63:0::1;::::0;::::1;10265:21:1::0;10322:2;10302:18;;;10295:30;10361:33;10341:18;;;10334:61;10412:18;;59665:63:0::1;10081:355:1::0;59665:63:0::1;59077:1;59806:7;:18:::0;61435:14:::2;::::0;61423:8;61407:13:::2;24043:12:::0;;23841:7;24027:13;:28;;23788:300;61407:13:::2;:24;;;;:::i;:::-;:42;;61399:85;;;::::0;-1:-1:-1;;;61399:85:0;;15102:2:1;61399:85:0::2;::::0;::::2;15084:21:1::0;15141:2;15121:18;;;15114:30;15180:32;15160:18;;;15153:60;15230:18;;61399:85:0::2;14900:354:1::0;61399:85:0::2;61495:23;61505:2;61509:8;61495:9;:23::i;:::-;-1:-1:-1::0;;59033:1:0::1;59985:7;:22:::0;61312:214::o;60780:26::-;;;;;;;:::i;62609:114::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;62690:13:::1;:25;62706:9:::0;;62690:13;:25:::1;:::i;63576:97::-:0;63620:13;63653:12;63646:19;;;;;:::i;63805:429::-;64043:20;;64087:28;;-1:-1:-1;;;64087:28:0;;-1:-1:-1;;;;;1692:32:1;;;64087:28:0;;;1674:51:1;63914:4:0;;64043:20;;;64079:49;;;;64043:20;;64087:21;;1647:18:1;;64087:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64079:49:0;;64075:93;;64152:4;64145:11;;;;;64075:93;-1:-1:-1;;;;;29847:25:0;;;29823:4;29847:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;64187:39;64180:46;63805:429;-1:-1:-1;;;;63805:429:0:o;62276:89::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;62339:10:::1;:18:::0;;-1:-1:-1;;62339:18:0::1;::::0;::::1;;::::0;;;::::1;::::0;;62276:89::o;56867:201::-;56189:12;:10;:12::i;:::-;-1:-1:-1;;;;;56178:23:0;:7;56031:6;;-1:-1:-1;;;;;56031:6:0;;55958:87;56178:7;-1:-1:-1;;;;;56178:23:0;;56170:68;;;;-1:-1:-1;;;56170:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56956:22:0;::::1;56948:73;;;::::0;-1:-1:-1;;;56948:73:0;;16981:2:1;56948:73:0::1;::::0;::::1;16963:21:1::0;17020:2;17000:18;;;16993:30;17059:34;17039:18;;;17032:62;-1:-1:-1;;;17110:18:1;;;17103:36;17156:19;;56948:73:0::1;16779:402:1::0;56948:73:0::1;57032:28;57051:8;57032:18;:28::i;:::-;56867:201:::0;:::o;42673:626::-;42732:22;42798:4;42776:10;:27;42772:496;;42820:18;42841:8;;42820:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;42880:8:0;43083:17;43077:24;-1:-1:-1;;;;;43055:126:0;;-1:-1:-1;42772:496:0;;-1:-1:-1;42772:496:0;;-1:-1:-1;43245:10:0;42772:496;42673:626;:::o;31079:174::-;31136:4;31200:13;;31190:7;:23;31160:85;;;;-1:-1:-1;;31218:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;31218:27:0;;;;31217:28;;31079:174::o;64378:145::-;64452:14;64491:24;:22;:24::i;:::-;64484:31;;64378:145;:::o;54574:458::-;54752:4;-1:-1:-1;;;;;54777:20:0;;54769:70;;;;-1:-1:-1;;;54769:70:0;;17388:2:1;54769:70:0;;;17370:21:1;17427:2;17407:18;;;17400:30;17466:34;17446:18;;;17439:62;-1:-1:-1;;;17517:18:1;;;17510:35;17562:19;;54769:70:0;17186:401:1;54769:70:0;54885:139;54909:47;54928:27;54948:6;54928:19;:27::i;:::-;54909:18;:47::i;:::-;54885:139;;;;;;;;;;;;17819:25:1;;;;17892:4;17880:17;;17860:18;;;17853:45;17914:18;;;17907:34;;;17957:18;;;17950:34;;;17791:19;;54885:139:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54866:158:0;:6;-1:-1:-1;;;;;54866:158:0;;54850:174;;54574:458;;;;;;;:::o;45755:98::-;45813:7;45840:5;45844:1;45840;:5;:::i;35109:2043::-;35224:35;35262:21;35275:7;35262:12;:21::i;:::-;35224:59;;35322:4;-1:-1:-1;;;;;35300:26:0;:13;:18;;;-1:-1:-1;;;;;35300:26:0;;35296:67;;35335:28;;-1:-1:-1;;;35335:28:0;;;;;;;;;;;35296:67;35376:22;35418:4;-1:-1:-1;;;;;35402:20:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;35402:20:0;;:69;;;;35435:36;35452:4;35458:12;:10;:12::i;35435:36::-;35402:118;;;;35508:12;:10;:12::i;:::-;-1:-1:-1;;;;;35484:36:0;:20;35496:7;35484:11;:20::i;:::-;-1:-1:-1;;;;;35484:36:0;;35402:118;35376:145;;35539:17;35534:66;;35565:35;;-1:-1:-1;;;35565:35:0;;;;;;;;;;;35534:66;-1:-1:-1;;;;;35615:16:0;;35611:52;;35640:23;;-1:-1:-1;;;35640:23:0;;;;;;;;;;;35611:52;35792:24;;;;:15;:24;;;;;;;;35785:31;;-1:-1:-1;;;;;;35785:31:0;;;-1:-1:-1;;;;;36104:18:0;;;;;:12;:18;;;;;:31;;-1:-1:-1;;36104:31:0;;;;;;;-1:-1:-1;;36104:31:0;;;;;;;36146:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;36146:29:0;;;;;;;;;;;36222:20;;;:11;:20;;;;;;36253:18;;-1:-1:-1;;;;;;36282:49:0;;;;-1:-1:-1;;;36315:15:0;36282:49;;;;;;;;;;36593:11;;36649:24;;;;;;;36688:13;;36222:20;;36593:11;;36649:24;;36688:13;36684:356;;36886:13;;36871:11;:28;36867:162;;36920:20;;36985:28;;;;36959:54;;-1:-1:-1;;;36959:54:0;-1:-1:-1;;;;;;36959:54:0;;;-1:-1:-1;;;;;36920:20:0;;36959:54;;;;36867:162;36083:964;;;37083:7;37079:2;-1:-1:-1;;;;;37064:27:0;37073:4;-1:-1:-1;;;;;37064:27:0;;;;;;;;;;;37102:42;35213:1939;;35109:2043;;;:::o;26262:1027::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;26373:7:0;26450:13;;26443:4;:20;26439:787;;;26480:31;26514:17;;;:11;:17;;;;;;;;;26480:51;;;;;;;;;-1:-1:-1;;;;;26480:51:0;;;;-1:-1:-1;;;26480:51:0;;;;;;;;;;;-1:-1:-1;;;26480:51:0;;;;;;;;;;;;;;26546:669;;26592:14;;-1:-1:-1;;;;;26592:28:0;;26588:93;;26652:9;26262:1027;-1:-1:-1;;;26262:1027:0:o;26588:93::-;-1:-1:-1;;;26999:6:0;27040:17;;;;:11;:17;;;;;;;;;27028:29;;;;;;;;;-1:-1:-1;;;;;27028:29:0;;;;;-1:-1:-1;;;27028:29:0;;;;;;;;;;;-1:-1:-1;;;27028:29:0;;;;;;;;;;;;;27084:28;27080:101;;27148:9;26262:1027;-1:-1:-1;;;26262:1027:0:o;27080:101::-;26963:237;;;26465:761;26439:787;27250:31;;-1:-1:-1;;;27250:31:0;;;;;;;;;;;57228:191;57321:6;;;-1:-1:-1;;;;;57338:17:0;;;-1:-1:-1;;;;;;57338:17:0;;;;;;;57371:40;;57321:6;;;57338:17;57321:6;;57371:40;;57302:16;;57371:40;57291:128;57228:191;:::o;31337:104::-;31406:27;31416:2;31420:8;31406:27;;;;;;;;;;;;:9;:27::i;62044:224::-;62121:5;62108:9;:18;;62100:53;;;;-1:-1:-1;;;62100:53:0;;18197:2:1;62100:53:0;;;18179:21:1;18236:2;18216:18;;;18209:30;-1:-1:-1;;;18255:18:1;;;18248:52;18317:18;;62100:53:0;17995:346:1;62100:53:0;62180:5;62168:9;:17;62164:97;;;62210:10;62202:47;62231:17;62243:5;62231:9;:17;:::i;:::-;62202:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40337:667;40500:4;40537:2;-1:-1:-1;;;;;40521:36:0;;40558:12;:10;:12::i;:::-;40572:4;40578:7;40587:5;40521:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40521:72:0;;;;;;;;-1:-1:-1;;40521:72:0;;;;;;;;;;;;:::i;:::-;;;40517:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40755:6;:13;40772:1;40755:18;40751:235;;40801:40;;-1:-1:-1;;;40801:40:0;;;;;;;;;;;40751:235;40944:6;40938:13;40929:6;40925:2;40921:15;40914:38;40517:480;-1:-1:-1;;;;;;40640:55:0;-1:-1:-1;;;40640:55:0;;-1:-1:-1;40337:667:0;;;;;;:::o;63051:113::-;63111:13;63144:12;63137:19;;;;;:::i;19216:723::-;19272:13;19493:5;19502:1;19493:10;19489:53;;-1:-1:-1;;19520:10:0;;;;;;;;;;;;-1:-1:-1;;;19520:10:0;;;;;19216:723::o;19489:53::-;19567:5;19552:12;19608:78;19615:9;;19608:78;;19641:8;;;;:::i;:::-;;-1:-1:-1;19664:10:0;;-1:-1:-1;19672:2:0;19664:10;;:::i;:::-;;;19608:78;;;19696:19;19728:6;19718:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19718:17:0;;19696:39;;19746:154;19753:10;;19746:154;;19780:11;19790:1;19780:11;;:::i;:::-;;-1:-1:-1;19849:10:0;19857:2;19849:5;:10;:::i;:::-;19836:24;;:2;:24;:::i;:::-;19823:39;;19806:6;19813;19806:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;19806:56:0;;;;;;;;-1:-1:-1;19877:11:0;19886:2;19877:11;;:::i;:::-;;;19746:154;;54085:366;54183:7;52274:100;;;;;;;;;;;;;;;;;52254:127;;;;;;;54321:12;;54352:11;;;;54392:24;;;;;54382:35;;;;;;54248:184;;;;;20101:25:1;;;20157:2;20142:18;;20135:34;;;;-1:-1:-1;;;;;20205:32:1;20200:2;20185:18;;20178:60;20269:2;20254:18;;20247:34;20088:3;20073:19;;19870:417;54248:184:0;;;;;;;;;;;;;54224:219;;;;;;54208:235;;54085:366;;;:::o;51875:234::-;51962:7;52056:20;51314:15;;;51236:101;52056:20;52027:63;;-1:-1:-1;;;52027:63:0;;;20550:27:1;20593:11;;;20586:27;;;;20629:12;;;20622:28;;;20666:12;;52027:63:0;20292:392:1;31814:1657:0;31937:20;31960:13;-1:-1:-1;;;;;31988:16:0;;31984:48;;32013:19;;-1:-1:-1;;;32013:19:0;;;;;;;;;;;31984:48;32047:8;32059:1;32047:13;32043:44;;32069:18;;-1:-1:-1;;;32069:18:0;;;;;;;;;;;32043:44;-1:-1:-1;;;;;32430:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;32485:49:0;;32430:44;;;;;;;;32485:49;;;;-1:-1:-1;;32430:44:0;;;;;;32485:49;;;;;;;;;;;;;;;;32547:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;32593:66:0;;;-1:-1:-1;;;32643:15:0;32593:66;;;;;;;;;;;;;32547:25;;32732:23;;;;11261:19;:23;32768:579;;32804:293;32831:38;;32856:12;;-1:-1:-1;;;;;32831:38:0;;;32848:1;;32831:38;;32848:1;;32831:38;32893:69;32932:1;32936:2;32940:14;;;;;;32956:5;32893:30;:69::i;:::-;32888:166;;32994:40;;-1:-1:-1;;;32994:40:0;;;;;;;;;;;32888:166;33092:3;33077:12;:18;32804:293;;33170:12;33153:13;;:29;33149:43;;33184:8;;;33149:43;32768:579;;;33225:111;33252:40;;33277:14;;;;;-1:-1:-1;;;;;33252:40:0;;;33269:1;;33252:40;;33269:1;;33252:40;33331:3;33316:12;:18;33225:111;;32768:579;-1:-1:-1;33357:13:0;:28;;;33403:60;;33436:2;33440:12;33454:8;33403:60;:::i;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:131::-;-1:-1:-1;;;;;1811:31:1;;1801:42;;1791:70;;1857:1;1854;1847:12;1872:315;1940:6;1948;2001:2;1989:9;1980:7;1976:23;1972:32;1969:52;;;2017:1;2014;2007:12;1969:52;2056:9;2043:23;2075:31;2100:5;2075:31;:::i;:::-;2125:5;2177:2;2162:18;;;;2149:32;;-1:-1:-1;;;1872:315:1:o;2192:127::-;2253:10;2248:3;2244:20;2241:1;2234:31;2284:4;2281:1;2274:15;2308:4;2305:1;2298:15;2324:718;2366:5;2419:3;2412:4;2404:6;2400:17;2396:27;2386:55;;2437:1;2434;2427:12;2386:55;2473:6;2460:20;2499:18;2536:2;2532;2529:10;2526:36;;;2542:18;;:::i;:::-;2617:2;2611:9;2585:2;2671:13;;-1:-1:-1;;2667:22:1;;;2691:2;2663:31;2659:40;2647:53;;;2715:18;;;2735:22;;;2712:46;2709:72;;;2761:18;;:::i;:::-;2801:10;2797:2;2790:22;2836:2;2828:6;2821:18;2882:3;2875:4;2870:2;2862:6;2858:15;2854:26;2851:35;2848:55;;;2899:1;2896;2889:12;2848:55;2963:2;2956:4;2948:6;2944:17;2937:4;2929:6;2925:17;2912:54;3010:1;3003:4;2998:2;2990:6;2986:15;2982:26;2975:37;3030:6;3021:15;;;;;;2324:718;;;;:::o;3047:758::-;3149:6;3157;3165;3173;3181;3234:3;3222:9;3213:7;3209:23;3205:33;3202:53;;;3251:1;3248;3241:12;3202:53;3290:9;3277:23;3309:31;3334:5;3309:31;:::i;:::-;3359:5;-1:-1:-1;3415:2:1;3400:18;;3387:32;3442:18;3431:30;;3428:50;;;3474:1;3471;3464:12;3428:50;3497:49;3538:7;3529:6;3518:9;3514:22;3497:49;:::i;:::-;3487:59;;;3593:2;3582:9;3578:18;3565:32;3555:42;;3644:2;3633:9;3629:18;3616:32;3606:42;;3700:3;3689:9;3685:19;3672:33;3749:4;3740:7;3736:18;3727:7;3724:31;3714:59;;3769:1;3766;3759:12;3714:59;3792:7;3782:17;;;3047:758;;;;;;;;:::o;4397:456::-;4474:6;4482;4490;4543:2;4531:9;4522:7;4518:23;4514:32;4511:52;;;4559:1;4556;4549:12;4511:52;4598:9;4585:23;4617:31;4642:5;4617:31;:::i;:::-;4667:5;-1:-1:-1;4724:2:1;4709:18;;4696:32;4737:33;4696:32;4737:33;:::i;:::-;4397:456;;4789:7;;-1:-1:-1;;;4843:2:1;4828:18;;;;4815:32;;4397:456::o;4858:247::-;4917:6;4970:2;4958:9;4949:7;4945:23;4941:32;4938:52;;;4986:1;4983;4976:12;4938:52;5025:9;5012:23;5044:31;5069:5;5044:31;:::i;5110:592::-;5181:6;5189;5242:2;5230:9;5221:7;5217:23;5213:32;5210:52;;;5258:1;5255;5248:12;5210:52;5298:9;5285:23;5327:18;5368:2;5360:6;5357:14;5354:34;;;5384:1;5381;5374:12;5354:34;5422:6;5411:9;5407:22;5397:32;;5467:7;5460:4;5456:2;5452:13;5448:27;5438:55;;5489:1;5486;5479:12;5438:55;5529:2;5516:16;5555:2;5547:6;5544:14;5541:34;;;5571:1;5568;5561:12;5541:34;5616:7;5611:2;5602:6;5598:2;5594:15;5590:24;5587:37;5584:57;;;5637:1;5634;5627:12;5584:57;5668:2;5660:11;;;;;5690:6;;-1:-1:-1;5110:592:1;;-1:-1:-1;;;;5110:592:1:o;5707:160::-;5772:20;;5828:13;;5821:21;5811:32;;5801:60;;5857:1;5854;5847:12;5801:60;5707:160;;;:::o;5872:315::-;5937:6;5945;5998:2;5986:9;5977:7;5973:23;5969:32;5966:52;;;6014:1;6011;6004:12;5966:52;6053:9;6040:23;6072:31;6097:5;6072:31;:::i;:::-;6122:5;-1:-1:-1;6146:35:1;6177:2;6162:18;;6146:35;:::i;:::-;6136:45;;5872:315;;;;;:::o;6192:665::-;6287:6;6295;6303;6311;6364:3;6352:9;6343:7;6339:23;6335:33;6332:53;;;6381:1;6378;6371:12;6332:53;6420:9;6407:23;6439:31;6464:5;6439:31;:::i;:::-;6489:5;-1:-1:-1;6546:2:1;6531:18;;6518:32;6559:33;6518:32;6559:33;:::i;:::-;6611:7;-1:-1:-1;6665:2:1;6650:18;;6637:32;;-1:-1:-1;6720:2:1;6705:18;;6692:32;6747:18;6736:30;;6733:50;;;6779:1;6776;6769:12;6733:50;6802:49;6843:7;6834:6;6823:9;6819:22;6802:49;:::i;:::-;6792:59;;;6192:665;;;;;;;:::o;6862:388::-;6930:6;6938;6991:2;6979:9;6970:7;6966:23;6962:32;6959:52;;;7007:1;7004;6997:12;6959:52;7046:9;7033:23;7065:31;7090:5;7065:31;:::i;:::-;7115:5;-1:-1:-1;7172:2:1;7157:18;;7144:32;7185:33;7144:32;7185:33;:::i;:::-;7237:7;7227:17;;;6862:388;;;;;:::o;7255:180::-;7311:6;7364:2;7352:9;7343:7;7339:23;7335:32;7332:52;;;7380:1;7377;7370:12;7332:52;7403:26;7419:9;7403:26;:::i;7440:380::-;7519:1;7515:12;;;;7562;;;7583:61;;7637:4;7629:6;7625:17;7615:27;;7583:61;7690:2;7682:6;7679:14;7659:18;7656:38;7653:161;;7736:10;7731:3;7727:20;7724:1;7717:31;7771:4;7768:1;7761:15;7799:4;7796:1;7789:15;7653:161;;7440:380;;;:::o;8227:432::-;-1:-1:-1;;;;;8484:15:1;;;8466:34;;8536:15;;8531:2;8516:18;;8509:43;8588:2;8583;8568:18;;8561:30;;;8409:4;;8608:45;;8634:18;;8626:6;8608:45;:::i;:::-;8600:53;8227:432;-1:-1:-1;;;;;8227:432:1:o;8664:415::-;8821:3;8859:6;8853:13;8875:53;8921:6;8916:3;8909:4;8901:6;8897:17;8875:53;:::i;:::-;8997:2;8993:15;;;;-1:-1:-1;;8989:53:1;8950:16;;;;8975:68;;;9070:2;9059:14;;8664:415;-1:-1:-1;;8664:415:1:o;9084:274::-;9213:3;9251:6;9245:13;9267:53;9313:6;9308:3;9301:4;9293:6;9289:17;9267:53;:::i;:::-;9336:16;;;;;9084:274;-1:-1:-1;;9084:274:1:o;9720:356::-;9922:2;9904:21;;;9941:18;;;9934:30;10000:34;9995:2;9980:18;;9973:62;10067:2;10052:18;;9720:356::o;11122:545::-;11224:2;11219:3;11216:11;11213:448;;;11260:1;11285:5;11281:2;11274:17;11330:4;11326:2;11316:19;11400:2;11388:10;11384:19;11381:1;11377:27;11371:4;11367:38;11436:4;11424:10;11421:20;11418:47;;;-1:-1:-1;11459:4:1;11418:47;11514:2;11509:3;11505:12;11502:1;11498:20;11492:4;11488:31;11478:41;;11569:82;11587:2;11580:5;11577:13;11569:82;;;11632:17;;;11613:1;11602:13;11569:82;;;11573:3;;;11122:545;;;:::o;11843:1206::-;11967:18;11962:3;11959:27;11956:53;;;11989:18;;:::i;:::-;12018:94;12108:3;12068:38;12100:4;12094:11;12068:38;:::i;:::-;12062:4;12018:94;:::i;:::-;12138:1;12163:2;12158:3;12155:11;12180:1;12175:616;;;;12835:1;12852:3;12849:93;;;-1:-1:-1;12908:19:1;;;12895:33;12849:93;-1:-1:-1;;11800:1:1;11796:11;;;11792:24;11788:29;11778:40;11824:1;11820:11;;;11775:57;12955:78;;12148:895;;12175:616;11069:1;11062:14;;;11106:4;11093:18;;-1:-1:-1;;12211:17:1;;;12312:9;12334:229;12348:7;12345:1;12342:14;12334:229;;;12437:19;;;12424:33;12409:49;;12544:4;12529:20;;;;12497:1;12485:14;;;;12364:12;12334:229;;;12338:3;12591;12582:7;12579:16;12576:159;;;12715:1;12711:6;12705:3;12699;12696:1;12692:11;12688:21;12684:34;12680:39;12667:9;12662:3;12658:19;12645:33;12641:79;12633:6;12626:95;12576:159;;;12778:1;12772:3;12769:1;12765:11;12761:19;12755:4;12748:33;12148:895;;11843:1206;;;:::o;13413:127::-;13474:10;13469:3;13465:20;13462:1;13455:31;13505:4;13502:1;13495:15;13529:4;13526:1;13519:15;13545:168;13585:7;13651:1;13647;13643:6;13639:14;13636:1;13633:21;13628:1;13621:9;13614:17;13610:45;13607:71;;;13658:18;;:::i;:::-;-1:-1:-1;13698:9:1;;13545:168::o;14767:128::-;14807:3;14838:1;14834:6;14831:1;14828:13;14825:39;;;14844:18;;:::i;:::-;-1:-1:-1;14880:9:1;;14767:128::o;15259:1230::-;15483:3;15521:6;15515:13;15547:4;15560:51;15604:6;15599:3;15594:2;15586:6;15582:15;15560:51;:::i;:::-;15674:13;;15633:16;;;;15696:55;15674:13;15633:16;15718:15;;;15696:55;:::i;:::-;15840:13;;15773:20;;;15813:1;;15878:36;15840:13;15878:36;:::i;:::-;15933:1;15950:18;;;15977:141;;;;16132:1;16127:337;;;;15943:521;;15977:141;-1:-1:-1;;16012:24:1;;15998:39;;16089:16;;16082:24;16068:39;;16057:51;;;-1:-1:-1;15977:141:1;;16127:337;16158:6;16155:1;16148:17;16206:2;16203:1;16193:16;16231:1;16245:169;16259:8;16256:1;16253:15;16245:169;;;16341:14;;16326:13;;;16319:37;16384:16;;;;16276:10;;16245:169;;;16249:3;;16445:8;16438:5;16434:20;16427:27;;15943:521;-1:-1:-1;16480:3:1;;15259:1230;-1:-1:-1;;;;;;;;;;15259:1230:1:o;16494:280::-;16593:6;16646:2;16634:9;16625:7;16621:23;16617:32;16614:52;;;16662:1;16659;16652:12;16614:52;16694:9;16688:16;16713:31;16738:5;16713:31;:::i;18346:125::-;18386:4;18414:1;18411;18408:8;18405:34;;;18419:18;;:::i;:::-;-1:-1:-1;18456:9:1;;18346:125::o;18476:489::-;-1:-1:-1;;;;;18745:15:1;;;18727:34;;18797:15;;18792:2;18777:18;;18770:43;18844:2;18829:18;;18822:34;;;18892:3;18887:2;18872:18;;18865:31;;;18670:4;;18913:46;;18939:19;;18931:6;18913:46;:::i;:::-;18905:54;18476:489;-1:-1:-1;;;;;;18476:489:1:o;18970:249::-;19039:6;19092:2;19080:9;19071:7;19067:23;19063:32;19060:52;;;19108:1;19105;19098:12;19060:52;19140:9;19134:16;19159:30;19183:5;19159:30;:::i;19224:135::-;19263:3;19284:17;;;19281:43;;19304:18;;:::i;:::-;-1:-1:-1;19351:1:1;19340:13;;19224:135::o;19364:127::-;19425:10;19420:3;19416:20;19413:1;19406:31;19456:4;19453:1;19446:15;19480:4;19477:1;19470:15;19496:120;19536:1;19562;19552:35;;19567:18;;:::i;:::-;-1:-1:-1;19601:9:1;;19496:120::o;19621:112::-;19653:1;19679;19669:35;;19684:18;;:::i;:::-;-1:-1:-1;19718:9:1;;19621:112::o;19738:127::-;19799:10;19794:3;19790:20;19787:1;19780:31;19830:4;19827:1;19820:15;19854:4;19851:1;19844:15

Swarm Source

ipfs://286cfa726ca95d066e29c84bb6e0584b182f75fd378495872a5f36a62269c5d9

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