Token

AzukiArt (AzukiArt)

ERC-721

NFT

Overview

Max Total Supply

3,421 AzukiArt

Holders

1,093

Market

Volume (24H)

0.0053 ETH

Min Price (24H)

$5.43 @ 0.001600 ETH

Max Price (24H)

$12.56 @ 0.003700 ETH

Other Info

Token Contract

0xebbb641dfe14805939b6cc25d2a90c93bd6a2021

Filtered by Token Holder

0xed3d058f0034ab41FE825cc5a8f0996F801aaC5a

Balance

6 AzukiArt

0xed3d058f0034ab41FE825cc5a8f0996F801aaC5a

OVERVIEW

AzukiArt brings visual experience and it’s about the art and community.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MintableNFTa

Compiler Version

v0.8.7+commit.e28d00a7

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-06-22
*/

/**
 *  SPDX-License-Identifier: MIT
*/
pragma solidity ^0.8.7;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721A {
    /**
     * 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();

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

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

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

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

    // ==============================
    //            IERC721
    // ==============================

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

    // ==============================
    //        IERC721Metadata
    // ==============================

    /**
     * @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 ERC721 token receiver interface.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


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

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

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

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

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

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

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

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

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

contract SignatureVerifiable{
    
    using SafeMath for uint256;
    
    bytes32 public constant DOMAIN_TYPEHASH =keccak256(
      abi.encodePacked(
        "EIP712Domain(",
        "string name,",
        "string version,",
        "uint256 chainId,",
        "address verifyingContract",
        ")"
      )
    );

    
    bytes32 public constant DOMAIN_NAME = keccak256("MintableNFT");
    bytes32 public constant DOMAIN_VERSION = keccak256("1");
    bytes32 public DOMAIN_SEPARATOR;
    address public verifyAddress;
    
    function getChainId() public view returns (uint256 id) {
        // no-inline-assembly
        assembly {
          id := chainid()
        }
    }

   /**
   * @notice Recover the signatory from a signature
   * @param hash bytes32
   * @param v uint8
   * @param r bytes32
   * @param s bytes32
   */
    function getSignatory(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
      ) internal view returns (address) {
        bytes32 digest =
          keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash));
        address signatory = ecrecover(digest, v, r, s);
        // Ensure the signatory is not null
        require(signatory != address(0), "INVALID_SIG");
        return signatory;
    }
}

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

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

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

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

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

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

/**
 * @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 MintableNFTa is IERC721A,Ownable,SignatureVerifiable {

    using SafeMath for uint256; 
    using SafeERC20 for IERC20;

    // Mask of an entry in packed address data.
    uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;

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

    // The number of tokens burned.
    uint256 private _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 `_packedOwnershipOf` implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

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

    uint256 private _maxSupply;

    //baseURI prefix
    string private _baseURI = "";

    string private _blindURI = "";

    mapping(address=>mapping(uint256=>uint256)) public userStageMintTotal;
    mapping(uint256=>uint256) public stageMintTotal;
    address public devAddress;

    constructor(string memory __name,string memory __symbol,uint256 __maxSupply,address _verifyAddress,string memory __blindURI) {
        _currentIndex = _startTokenId();
        _name = __name;
        _symbol = __symbol;
        _blindURI = __blindURI;
        _maxSupply = __maxSupply;
        devAddress = msg.sender;
        verifyAddress = _verifyAddress;

        //init signatory
        uint256 currentChainId = getChainId();
        DOMAIN_SEPARATOR = keccak256(
          abi.encode(
            DOMAIN_TYPEHASH,
            DOMAIN_NAME,
            DOMAIN_VERSION,
            currentChainId,
            this
          )
        );
    }

    
    function verifyMint(address sender,uint256 stage,uint256 mintCount,uint256 maxCount,uint256 stageCount,uint256 mintPrice,uint256 expire,uint8 v,uint256 _r,uint256 _s) internal view returns(bool){
        bytes32 r = bytes32(_r);
        bytes32 s = bytes32(_s);        
        bytes32 hash = keccak256(
            abi.encode(
              keccak256(abi.encodePacked("payment(address sender,uint256 stage,uint256 mintCount,uint256 maxCount,uint256 stageCount,uint256 mintPrice,uint256 expire)")),
              sender,stage,mintCount,maxCount,stageCount,mintPrice,expire
            )
        );
        if(getSignatory(hash,v,r,s) == verifyAddress){
            return true;
        }
        else{
            return false;
        }
    }
    
    function setDevAddress(address _devAddress) public onlyOwner{
        require(_devAddress!=address(0),"address invalid.");
        devAddress = _devAddress;
    }

    function setVerifyAddress(address _addr) public onlyOwner{
        verifyAddress = _addr;
    }

    function sweep(address _tokenAddress) public onlyOwner{
        uint256 amount = IERC20(_tokenAddress).balanceOf(address(this));
        if(amount > 0){
            IERC20(_tokenAddress).safeTransfer(msg.sender,amount);
        }
    }
    
    //admin function 
    function setBaseURI(string memory baseURI_) public onlyOwner{
        _baseURI = baseURI_;
    }

    function setBlindURI(string memory blindURI_) public onlyOwner{
        _blindURI = blindURI_;
    }

    function mint(address sender,uint256 stage,uint256 mintCount,uint256 maxCount,uint256 stageCount,uint256 mintPrice,uint256 expire,uint8 v,uint256 _r,uint256 _s) public payable{
        require(msg.sender==tx.origin,"human only"); 
        require(userStageMintTotal[msg.sender][stage].add(mintCount)<=maxCount,"user mint max");
        require(totalSupply().add(mintCount)<=_maxSupply,"max"); 
        require(totalSupply().add(mintCount)<=stageCount,"stage max"); 
        require(block.timestamp<=expire,"expired.");
        require(verifyMint(sender,stage,mintCount,maxCount,stageCount,mintPrice,expire,v,_r,_s),"invalid sig");

        require(msg.value>=mintPrice,"payment insufficient");
        uint256 lessAmount = msg.value.sub(mintPrice);
        if(lessAmount>0)
                payable(msg.sender).transfer(lessAmount);
        payable(devAddress).transfer(mintPrice); 
        
        //mint...
        _safeMint(msg.sender,mintCount);
        userStageMintTotal[msg.sender][stage]  = userStageMintTotal[msg.sender][stage].add(mintCount);    
        stageMintTotal[stage] = stageMintTotal[stage].add(mintCount);
    }

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

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see `_totalMinted`.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    function maxSupply() public view returns (uint256){
        return _maxSupply;
    }

    /**
     * @dev 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 Returns the total number of tokens burned.
     */
    function _totalBurned() internal view returns (uint256) {
        return _burnCounter;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes of the XOR of
        // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165
        // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

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

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> BITPOS_NUMBER_MINTED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

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

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

    /**
     * Sets the auxiliary 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 {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        assembly {
            // Cast aux without masking.
            auxCasted := aux
        }
        packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & BITMASK_BURNED == 0) {
                        // 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.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed is zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP);
        ownership.burned = packed & BITMASK_BURNED != 0;
    }

    /**
     * Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * 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) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

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

    /**
     * @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();
        return bytes(_baseURI).length > 0 ? string(abi.encodePacked(_baseURI, _toString(tokenId))) : _blindURI;
    }

    /**
     * @dev Casts the address to uint256 without masking.
     */
    function _addressToUint256(address value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev Casts the boolean to uint256 without branching.
     */
    function _boolToUint256(bool value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = address(uint160(_packedOwnershipOf(tokenId)));

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                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 == _msgSenderERC721A()) revert ApproveToCaller();

        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), 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.code.length != 0)
            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 && // If within bounds,
            _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not 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 for each mint.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (index < end);
                // Reentrancy protection.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @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 for each mint.
     */
    function _mint(address to, uint256 quantity) internal {
        uint256 startTokenId = _currentIndex;
        if (_addressToUint256(to) == 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 {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 offset;
            do {
                emit Transfer(address(0), to, startTokenId + offset++);
            } while (offset < quantity);

            _currentIndex = startTokenId + quantity;
        }
        _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 {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        address approvedAddress = _tokenApprovals[tokenId];

        bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
            isApprovedForAll(from, _msgSenderERC721A()) ||
            approvedAddress == _msgSenderERC721A());

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

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        if (_addressToUint256(approvedAddress) != 0) {
            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 {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_NEXT_INITIALIZED;

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        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 {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        address from = address(uint160(prevOwnershipPacked));
        address approvedAddress = _tokenApprovals[tokenId];

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
                isApprovedForAll(from, _msgSenderERC721A()) ||
                approvedAddress == _msgSenderERC721A());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

        // Clear approvals from the previous owner.
        if (_addressToUint256(approvedAddress) != 0) {
            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 {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _addressToUint256(from) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_BURNED |
                BITMASK_NEXT_INITIALIZED;

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        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 ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__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 {}

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function _toString(uint256 value) internal pure returns (string memory ptr) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit),
            // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged.
            // We will need 1 32-byte word to store the length,
            // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128.
            ptr := add(mload(0x40), 128)
            // Update the free memory pointer to allocate.
            mstore(0x40, ptr)

            // Cache the end of the memory to calculate the length later.
            let end := ptr

            // We write the string from the rightmost digit to the leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // Costs a bit more than early returning for the zero case,
            // but cheaper in terms of deployment and overall runtime costs.
            for {
                // Initialize and perform the first pass without check.
                let temp := value
                // Move the pointer 1 byte leftwards to point to an empty character slot.
                ptr := sub(ptr, 1)
                // Write the character to the pointer. 48 is the ASCII index of '0'.
                mstore8(ptr, add(48, mod(temp, 10)))
                temp := div(temp, 10)
            } temp {
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
            } {
                // Body of the for loop.
                ptr := sub(ptr, 1)
                mstore8(ptr, add(48, mod(temp, 10)))
            }

            let length := sub(end, ptr)
            // Move the pointer 32 bytes leftwards to make room for the length.
            ptr := sub(ptr, 32)
            // Store the length.
            mstore(ptr, length)
        }
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"__name","type":"string"},{"internalType":"string","name":"__symbol","type":"string"},{"internalType":"uint256","name":"__maxSupply","type":"uint256"},{"internalType":"address","name":"_verifyAddress","type":"address"},{"internalType":"string","name":"__blindURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","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":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":"DOMAIN_NAME","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_VERSION","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"stage","type":"uint256"},{"internalType":"uint256","name":"mintCount","type":"uint256"},{"internalType":"uint256","name":"maxCount","type":"uint256"},{"internalType":"uint256","name":"stageCount","type":"uint256"},{"internalType":"uint256","name":"mintPrice","type":"uint256"},{"internalType":"uint256","name":"expire","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"uint256","name":"_r","type":"uint256"},{"internalType":"uint256","name":"_s","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"blindURI_","type":"string"}],"name":"setBlindURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setVerifyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stageMintTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"}],"name":"sweep","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"userStageMintTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"verifyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60a06040819052600060808190526200001b91600c916200027b565b506040805160208101918290526000908190526200003c91600d916200027b565b503480156200004a57600080fd5b50604051620026a2380380620026a28339810160408190526200006d91620003d8565b62000078336200022b565b60006003558451620000929060059060208801906200027b565b508351620000a89060069060208701906200027b565b508051620000be90600d9060208401906200027b565b50600b83905560108054336001600160a01b031991821617909155600280549091166001600160a01b0384161790556000620000f74690565b6040516c08a92a06e626488dedac2d2dc5609b1b60208201526b1cdd1c9a5b99c81b985b594b60a21b602d8201526e1cdd1c9a5b99c81d995c9cda5bdb8b608a1b60398201526f1d5a5b9d0c8d4d8818da185a5b92590b60821b60488201527f6164647265737320766572696679696e67436f6e7472616374000000000000006058820152602960f81b607182015290915060720160408051601f198184030181528282528051602091820120908301527f37584ce3963d949a6d4f89dfc14ad4fb9d1eacecb8c5b0981a34d001a6c36a69908201527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc66060820152608081018290523060a082015260c00160405160208183030381529060405280519060200120600181905550505050505050620004e8565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b828054620002899062000495565b90600052602060002090601f016020900481019282620002ad5760008555620002f8565b82601f10620002c857805160ff1916838001178555620002f8565b82800160010185558215620002f8579182015b82811115620002f8578251825591602001919060010190620002db565b50620003069291506200030a565b5090565b5b808211156200030657600081556001016200030b565b600082601f8301126200033357600080fd5b81516001600160401b0380821115620003505762000350620004d2565b604051601f8301601f19908116603f011681019082821181831017156200037b576200037b620004d2565b816040528381526020925086838588010111156200039857600080fd5b600091505b83821015620003bc57858201830151818301840152908201906200039d565b83821115620003ce5760008385830101525b9695505050505050565b600080600080600060a08688031215620003f157600080fd5b85516001600160401b03808211156200040957600080fd5b6200041789838a0162000321565b965060208801519150808211156200042e57600080fd5b6200043c89838a0162000321565b604089015160608a0151919750955091506001600160a01b03821682146200046357600080fd5b6080880151919350808211156200047957600080fd5b50620004888882890162000321565b9150509295509295909350565b600181811c90821680620004aa57607f821691505b60208210811415620004cc57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052604160045260246000fd5b6121aa80620004f86000396000f3fe6080604052600436106101ee5760003560e01c806370a082311161010d578063b6e66b16116100a0578063d0d41fe11161006f578063d0d41fe114610664578063d5abeb0114610684578063e985e9c514610699578063f1e08653146106e2578063f2fde38b146106f557600080fd5b8063b6e66b16146105e4578063b88d4fde14610604578063ba0a064314610624578063c87b56dd1461064457600080fd5b806395d89b41116100dc57806395d89b4114610543578063a22cb46514610558578063a347af5414610578578063acb8cc49146105b057600080fd5b806370a08231146104bc578063715018a6146104dc578063796f077b146104f15780638da5cb5b1461052557600080fd5b806323b872dd1161018557806342842e0e1161015457806342842e0e1461043c57806355f804b31461045c5780636352211e1461047c57806365925b901461049c57600080fd5b806323b872dd146103d35780633408e470146103f35780633644e515146104065780633ad10ef61461041c57600080fd5b8063095ea7b3116101c1578063095ea7b3146102a45780630ae89e95146102c457806318160ddd146102ff57806320606b701461031857600080fd5b806301681a62146101f357806301ffc9a71461021557806306fdde031461024a578063081812fc1461026c575b600080fd5b3480156101ff57600080fd5b5061021361020e366004611c43565b610715565b005b34801561022157600080fd5b50610235610230366004611e53565b6107e2565b60405190151581526020015b60405180910390f35b34801561025657600080fd5b5061025f610834565b6040516102419190612046565b34801561027857600080fd5b5061028c610287366004611ed6565b6108c6565b6040516001600160a01b039091168152602001610241565b3480156102b057600080fd5b506102136102bf366004611d80565b61090a565b3480156102d057600080fd5b506102f16102df366004611ed6565b600f6020526000908152604090205481565b604051908152602001610241565b34801561030b57600080fd5b50600454600354036102f1565b34801561032457600080fd5b506102f16040516c08a92a06e626488dedac2d2dc5609b1b60208201526b1cdd1c9a5b99c81b985b594b60a21b602d8201526e1cdd1c9a5b99c81d995c9cda5bdb8b608a1b60398201526f1d5a5b9d0c8d4d8818da185a5b92590b60821b60488201527f6164647265737320766572696679696e67436f6e7472616374000000000000006058820152602960f81b60718201526072016040516020818303038152906040528051906020012081565b3480156103df57600080fd5b506102136103ee366004611c91565b6109aa565b3480156103ff57600080fd5b50466102f1565b34801561041257600080fd5b506102f160015481565b34801561042857600080fd5b5060105461028c906001600160a01b031681565b34801561044857600080fd5b50610213610457366004611c91565b6109ba565b34801561046857600080fd5b50610213610477366004611e8d565b6109d5565b34801561048857600080fd5b5061028c610497366004611ed6565b610a12565b3480156104a857600080fd5b5060025461028c906001600160a01b031681565b3480156104c857600080fd5b506102f16104d7366004611c43565b610a1d565b3480156104e857600080fd5b50610213610a63565b3480156104fd57600080fd5b506102f17f37584ce3963d949a6d4f89dfc14ad4fb9d1eacecb8c5b0981a34d001a6c36a6981565b34801561053157600080fd5b506000546001600160a01b031661028c565b34801561054f57600080fd5b5061025f610a99565b34801561056457600080fd5b50610213610573366004611d49565b610aa8565b34801561058457600080fd5b506102f1610593366004611d80565b600e60209081526000928352604080842090915290825290205481565b3480156105bc57600080fd5b506102f17fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc681565b3480156105f057600080fd5b506102136105ff366004611c43565b610b3e565b34801561061057600080fd5b5061021361061f366004611ccd565b610b8a565b34801561063057600080fd5b5061021361063f366004611e8d565b610bd4565b34801561065057600080fd5b5061025f61065f366004611ed6565b610c11565b34801561067057600080fd5b5061021361067f366004611c43565b610d10565b34801561069057600080fd5b50600b546102f1565b3480156106a557600080fd5b506102356106b4366004611c5e565b6001600160a01b039182166000908152600a6020908152604080832093909416825291909152205460ff1690565b6102136106f0366004611daa565b610da5565b34801561070157600080fd5b50610213610710366004611c43565b6110a8565b6000546001600160a01b031633146107485760405162461bcd60e51b815260040161073f90612059565b60405180910390fd5b6040516370a0823160e01b81523060048201526000906001600160a01b038316906370a082319060240160206040518083038186803b15801561078a57600080fd5b505afa15801561079e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107c29190611eef565b905080156107de576107de6001600160a01b0383163383611143565b5050565b60006301ffc9a760e01b6001600160e01b03198316148061081357506380ac58cd60e01b6001600160e01b03198316145b8061082e5750635b5e139f60e01b6001600160e01b03198316145b92915050565b606060058054610843906120e9565b80601f016020809104026020016040519081016040528092919081815260200182805461086f906120e9565b80156108bc5780601f10610891576101008083540402835291602001916108bc565b820191906000526020600020905b81548152906001019060200180831161089f57829003601f168201915b5050505050905090565b60006108d182611195565b6108ee576040516333d1c03960e21b815260040160405180910390fd5b506000908152600960205260409020546001600160a01b031690565b6000610915826111bd565b9050336001600160a01b0382161461094e5761093181336106b4565b61094e576040516367d9dca160e11b815260040160405180910390fd5b60008281526009602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b6109b5838383611225565b505050565b6109b583838360405180602001604052806000815250610b8a565b6000546001600160a01b031633146109ff5760405162461bcd60e51b815260040161073f90612059565b80516107de90600c906020840190611b18565b600061082e826111bd565b600081610a3d576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b031660009081526008602052604090205467ffffffffffffffff1690565b6000546001600160a01b03163314610a8d5760405162461bcd60e51b815260040161073f90612059565b610a9760006113d5565b565b606060068054610843906120e9565b6001600160a01b038216331415610ad25760405163b06307db60e01b815260040160405180910390fd5b336000818152600a602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6000546001600160a01b03163314610b685760405162461bcd60e51b815260040161073f90612059565b600280546001600160a01b0319166001600160a01b0392909216919091179055565b610b95848484611225565b6001600160a01b0383163b15610bce57610bb184848484611425565b610bce576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b6000546001600160a01b03163314610bfe5760405162461bcd60e51b815260040161073f90612059565b80516107de90600d906020840190611b18565b6060610c1c82611195565b610c3957604051630a14c4b560e41b815260040160405180910390fd5b6000600c8054610c48906120e9565b905011610cdf57600d8054610c5c906120e9565b80601f0160208091040260200160405190810160405280929190818152602001828054610c88906120e9565b8015610cd55780601f10610caa57610100808354040283529160200191610cd5565b820191906000526020600020905b815481529060010190602001808311610cb857829003601f168201915b505050505061082e565b600c610cea8361151d565b604051602001610cfb929190611f6c565b60405160208183030381529060405292915050565b6000546001600160a01b03163314610d3a5760405162461bcd60e51b815260040161073f90612059565b6001600160a01b038116610d835760405162461bcd60e51b815260206004820152601060248201526f30b2323932b9b99034b73b30b634b21760811b604482015260640161073f565b601080546001600160a01b0319166001600160a01b0392909216919091179055565b333214610de15760405162461bcd60e51b815260206004820152600a60248201526968756d616e206f6e6c7960b01b604482015260640161073f565b336000908152600e602090815260408083208c84529091529020548790610e08908a61156c565b1115610e465760405162461bcd60e51b815260206004820152600d60248201526c0eae6cae440dad2dce840dac2f609b1b604482015260640161073f565b600b54610e6089610e5a6004546003540390565b9061156c565b1115610e945760405162461bcd60e51b81526020600482015260036024820152620dac2f60eb1b604482015260640161073f565b85610ea689610e5a6004546003540390565b1115610ee05760405162461bcd60e51b81526020600482015260096024820152680e6e8c2ceca40dac2f60bb1b604482015260640161073f565b83421115610f1b5760405162461bcd60e51b815260206004820152600860248201526732bc3834b932b21760c11b604482015260640161073f565b610f2d8a8a8a8a8a8a8a8a8a8a611578565b610f675760405162461bcd60e51b815260206004820152600b60248201526a696e76616c69642073696760a81b604482015260640161073f565b84341015610fae5760405162461bcd60e51b81526020600482015260146024820152731c185e5b595b9d081a5b9cdd59999a58da595b9d60621b604482015260640161073f565b6000610fba34876116f8565b90508015610ff157604051339082156108fc029083906000818181858888f19350505050158015610fef573d6000803e3d6000fd5b505b6010546040516001600160a01b039091169087156108fc029088906000818181858888f1935050505015801561102b573d6000803e3d6000fd5b50611036338a611704565b336000908152600e602090815260408083208d845290915290205461105b908a61156c565b336000908152600e602090815260408083208e8452825280832093909355600f90522054611089908a61156c565b60009a8b52600f6020526040909a209990995550505050505050505050565b6000546001600160a01b031633146110d25760405162461bcd60e51b815260040161073f90612059565b6001600160a01b0381166111375760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161073f565b611140816113d5565b50565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b1790526109b590849061171e565b60006003548210801561082e575050600090815260076020526040902054600160e01b161590565b60008160035481101561120c57600081815260076020526040902054600160e01b811661120a575b806112035750600019016000818152600760205260409020546111e5565b9392505050565b505b604051636f96cda160e11b815260040160405180910390fd5b6000611230826111bd565b9050836001600160a01b0316816001600160a01b0316146112635760405162a1148160e81b815260040160405180910390fd5b6000828152600960205260408120546001600160a01b0390811691908616331480611293575061129386336106b4565b806112a657506001600160a01b03821633145b9050806112c657604051632ce44b5f60e11b815260040160405180910390fd5b846112e457604051633a954ecd60e21b815260040160405180910390fd5b811561130757600084815260096020526040902080546001600160a01b03191690555b6001600160a01b03868116600090815260086020908152604080832080546000190190559288168252828220805460010190558682526007905220600160e11b4260a01b87178117909155831661138c576001840160008181526007602052604090205461138a57600354811461138a5760008181526007602052604090208490555b505b83856001600160a01b0316876001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050505050565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a029061145a903390899088908890600401612013565b602060405180830381600087803b15801561147457600080fd5b505af19250505080156114a4575060408051601f3d908101601f191682019092526114a191810190611e70565b60015b6114ff573d8080156114d2576040519150601f19603f3d011682016040523d82523d6000602084013e6114d7565b606091505b5080516114f7576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b604080516080810191829052607f0190826030600a8206018353600a90045b801561155a57600183039250600a81066030018353600a900461153c565b50819003601f19909101908152919050565b6000611203828461208e565b604051600090839083908390611626906020017f7061796d656e7428616464726573732073656e6465722c75696e74323536207381527f746167652c75696e74323536206d696e74436f756e742c75696e74323536206d60208201527f6178436f756e742c75696e74323536207374616765436f756e742c75696e743260408201527f3536206d696e7450726963652c75696e743235362065787069726529000000006060820152607c0190565b604051602081830303815290604052805190602001208e8e8e8e8e8e8e6040516020016116949897969594939291909788526001600160a01b0396909616602088015260408701949094526060860192909252608085015260a084015260c083015260e08201526101000190565b60408051601f1981840301815291905280516020909101206002549091506001600160a01b03166116c7828986866117f0565b6001600160a01b031614156116e257600193505050506116ea565b600093505050505b9a9950505050505050505050565b600061120382846120a6565b6107de8282604051806020016040528060008152506118de565b6000611773826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661194b9092919063ffffffff16565b8051909150156109b557808060200190518101906117919190611e36565b6109b55760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840161073f565b60015460405161190160f01b6020820152602281019190915260428101859052600090819060620160408051601f198184030181528282528051602091820120600080855291840180845281905260ff89169284019290925260608301879052608083018690529092509060019060a0016020604051602081039080840390855afa158015611883573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166118d45760405162461bcd60e51b815260206004820152600b60248201526a494e56414c49445f53494760a81b604482015260640161073f565b9695505050505050565b6118e8838361195a565b6001600160a01b0383163b156109b5576003548281035b6119126000868380600101945086611425565b61192f576040516368d2bf6b60e11b815260040160405180910390fd5b8181106118ff57816003541461194457600080fd5b5050505050565b60606115158484600085611a2c565b6003548261197a57604051622e076360e81b815260040160405180910390fd5b816119985760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b03831660009081526008602090815260408083208054680100000000000000018702019055838352600790915281204260a01b85176001851460e11b1790555b60405160018201918301906001600160a01b038616906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a48281106119df57500160035550565b6060843b611a7c5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161073f565b600080866001600160a01b03168587604051611a989190611f50565b60006040518083038185875af1925050503d8060008114611ad5576040519150601f19603f3d011682016040523d82523d6000602084013e611ada565b606091505b50915091508115611aee5791506115159050565b805115611afe5780518082602001fd5b8360405162461bcd60e51b815260040161073f9190612046565b828054611b24906120e9565b90600052602060002090601f016020900481019282611b465760008555611b8c565b82601f10611b5f57805160ff1916838001178555611b8c565b82800160010185558215611b8c579182015b82811115611b8c578251825591602001919060010190611b71565b50611b98929150611b9c565b5090565b5b80821115611b985760008155600101611b9d565b600067ffffffffffffffff80841115611bcc57611bcc61213a565b604051601f8501601f19908116603f01168101908282118183101715611bf457611bf461213a565b81604052809350858152868686011115611c0d57600080fd5b858560208301376000602087830101525050509392505050565b80356001600160a01b0381168114611c3e57600080fd5b919050565b600060208284031215611c5557600080fd5b61120382611c27565b60008060408385031215611c7157600080fd5b611c7a83611c27565b9150611c8860208401611c27565b90509250929050565b600080600060608486031215611ca657600080fd5b611caf84611c27565b9250611cbd60208501611c27565b9150604084013590509250925092565b60008060008060808587031215611ce357600080fd5b611cec85611c27565b9350611cfa60208601611c27565b925060408501359150606085013567ffffffffffffffff811115611d1d57600080fd5b8501601f81018713611d2e57600080fd5b611d3d87823560208401611bb1565b91505092959194509250565b60008060408385031215611d5c57600080fd5b611d6583611c27565b91506020830135611d7581612150565b809150509250929050565b60008060408385031215611d9357600080fd5b611d9c83611c27565b946020939093013593505050565b6000806000806000806000806000806101408b8d031215611dca57600080fd5b611dd38b611c27565b995060208b0135985060408b0135975060608b0135965060808b0135955060a08b0135945060c08b0135935060e08b013560ff81168114611e1357600080fd5b809350506101008b013591506101208b013590509295989b9194979a5092959850565b600060208284031215611e4857600080fd5b815161120381612150565b600060208284031215611e6557600080fd5b81356112038161215e565b600060208284031215611e8257600080fd5b81516112038161215e565b600060208284031215611e9f57600080fd5b813567ffffffffffffffff811115611eb657600080fd5b8201601f81018413611ec757600080fd5b61151584823560208401611bb1565b600060208284031215611ee857600080fd5b5035919050565b600060208284031215611f0157600080fd5b5051919050565b60008151808452611f208160208601602086016120bd565b601f01601f19169290920160200192915050565b60008151611f468185602086016120bd565b9290920192915050565b60008251611f628184602087016120bd565b9190910192915050565b600080845481600182811c915080831680611f8857607f831692505b6020808410821415611fa857634e487b7160e01b86526022600452602486fd5b818015611fbc5760018114611fcd57611ffa565b60ff19861689528489019650611ffa565b60008b81526020902060005b86811015611ff25781548b820152908501908301611fd9565b505084890196505b50505050505061200a8185611f34565b95945050505050565b6001600160a01b03858116825284166020820152604081018390526080606082018190526000906118d490830184611f08565b6020815260006112036020830184611f08565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b600082198211156120a1576120a1612124565b500190565b6000828210156120b8576120b8612124565b500390565b60005b838110156120d85781810151838201526020016120c0565b83811115610bce5750506000910152565b600181811c908216806120fd57607f821691505b6020821081141561211e57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fd5b801515811461114057600080fd5b6001600160e01b03198116811461114057600080fdfea26469706673582212207a048e02dae2408cca8f7bde726cf0d90b814481fe9fce142c2da992dece087064736f6c6343000807003300000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000001e61000000000000000000000000f1ee046fa52a5f83a73cdcaac029616d239e4bd700000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000008417a756b694172740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008417a756b694172740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d64535a6d484363367a54574a7168543357676462344c7a4b70566a78684759436e34367050417635664c70360000000000000000000000

Deployed Bytecode

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

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

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000001e61000000000000000000000000f1ee046fa52a5f83a73cdcaac029616d239e4bd700000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000008417a756b694172740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008417a756b694172740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d64535a6d484363367a54574a7168543357676462344c7a4b70566a78684759436e34367050417635664c70360000000000000000000000

-----Decoded View---------------
Arg [0] : __name (string): AzukiArt
Arg [1] : __symbol (string): AzukiArt
Arg [2] : __maxSupply (uint256): 7777
Arg [3] : _verifyAddress (address): 0xf1Ee046FA52a5f83a73CDCAaC029616d239e4bd7
Arg [4] : __blindURI (string): ipfs://QmdSZmHCc6zTWJqhT3Wgdb4LzKpVjxhGYCn46pPAv5fLp6

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000001e61
Arg [3] : 000000000000000000000000f1ee046fa52a5f83a73cdcaac029616d239e4bd7
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [6] : 417a756b69417274000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [8] : 417a756b69417274000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [10] : 697066733a2f2f516d64535a6d484363367a54574a7168543357676462344c7a
Arg [11] : 4b70566a78684759436e34367050417635664c70360000000000000000000000

Deployed Bytecode Sourcemap

31794:31367:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36316:240;;;;;;;;;;-1:-1:-1;36316:240:0;;;;;:::i;:::-;;:::i;:::-;;39615:615;;;;;;;;;;-1:-1:-1;39615:615:0;;;;;:::i;:::-;;:::i;:::-;;;10309:14:1;;10302:22;10284:41;;10272:2;10257:18;39615:615:0;;;;;;;;44651:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46279:204::-;;;;;;;;;;-1:-1:-1;46279:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;9317:32:1;;;9299:51;;9287:2;9272:18;46279:204:0;9153:203:1;45798:415:0;;;;;;;;;;-1:-1:-1;45798:415:0;;;;;:::i;:::-;;:::i;34499:47::-;;;;;;;;;;-1:-1:-1;34499:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;10482:25:1;;;10470:2;10455:18;34499:47:0;10336:177:1;38575:315:0;;;;;;;;;;-1:-1:-1;38841:12:0;;38825:13;;:28;38575:315;;20992:251;;;;;;;;;;;;21051:185;;-1:-1:-1;;;21051:185:0;;;8372:28:1;-1:-1:-1;;;8416:12:1;;;8409:36;-1:-1:-1;;;8461:12:1;;;8454:39;-1:-1:-1;;;8509:12:1;;;8502:40;8572:27;8558:12;;;8551:49;-1:-1:-1;;;8616:12:1;;;8609:25;8650:12;;21051:185:0;;;;;;;;;;;;21033:210;;;;;;20992:251;;47165:170;;;;;;;;;;-1:-1:-1;47165:170:0;;;;;:::i;:::-;;:::i;21468:152::-;;;;;;;;;;-1:-1:-1;21593:9:0;21468:152;;21389:31;;;;;;;;;;;;;;;;34553:25;;;;;;;;;;-1:-1:-1;34553:25:0;;;;-1:-1:-1;;;;;34553:25:0;;;47406:185;;;;;;;;;;-1:-1:-1;47406:185:0;;;;;:::i;:::-;;:::i;36591:98::-;;;;;;;;;;-1:-1:-1;36591:98:0;;;;;:::i;:::-;;:::i;44440:144::-;;;;;;;;;;-1:-1:-1;44440:144:0;;;;;:::i;:::-;;:::i;21427:28::-;;;;;;;;;;-1:-1:-1;21427:28:0;;;;-1:-1:-1;;;;;21427:28:0;;;40294:234;;;;;;;;;;-1:-1:-1;40294:234:0;;;;;:::i;:::-;;:::i;20095:103::-;;;;;;;;;;;;;:::i;21258:62::-;;;;;;;;;;;;21296:24;21258:62;;19444:87;;;;;;;;;;-1:-1:-1;19490:7:0;19517:6;-1:-1:-1;;;;;19517:6:0;19444:87;;44820:104;;;;;;;;;;;;;:::i;46555:308::-;;;;;;;;;;-1:-1:-1;46555:308:0;;;;;:::i;:::-;;:::i;34423:69::-;;;;;;;;;;-1:-1:-1;34423:69:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;21327:55;;;;;;;;;;;;21368:14;21327:55;;36211:97;;;;;;;;;;-1:-1:-1;36211:97:0;;;;;:::i;:::-;;:::i;47662:396::-;;;;;;;;;;-1:-1:-1;47662:396:0;;;;;:::i;:::-;;:::i;36697:102::-;;;;;;;;;;-1:-1:-1;36697:102:0;;;;;:::i;:::-;;:::i;44995:279::-;;;;;;;;;;-1:-1:-1;44995:279:0;;;;;:::i;:::-;;:::i;36038:165::-;;;;;;;;;;-1:-1:-1;36038:165:0;;;;;:::i;:::-;;:::i;38898:86::-;;;;;;;;;;-1:-1:-1;38966:10:0;;38898:86;;46934:164;;;;;;;;;;-1:-1:-1;46934:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;47055:25:0;;;47031:4;47055:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;46934:164;36807:1150;;;;;;:::i;:::-;;:::i;20353:201::-;;;;;;;;;;-1:-1:-1;20353:201:0;;;;;:::i;:::-;;:::i;36316:240::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;;;;;;;;;36398:46:::1;::::0;-1:-1:-1;;;36398:46:0;;36438:4:::1;36398:46;::::0;::::1;9299:51:1::0;36381:14:0::1;::::0;-1:-1:-1;;;;;36398:31:0;::::1;::::0;::::1;::::0;9272:18:1;;36398:46:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;36381:63:::0;-1:-1:-1;36458:10:0;;36455:94:::1;;36484:53;-1:-1:-1::0;;;;;36484:34:0;::::1;36519:10;36530:6:::0;36484:34:::1;:53::i;:::-;36370:186;36316:240:::0;:::o;39615:615::-;39700:4;-1:-1:-1;;;;;;;;;40000:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;40077:25:0;;;40000:102;:179;;;-1:-1:-1;;;;;;;;;;40154:25:0;;;40000:179;39980:199;39615:615;-1:-1:-1;;39615:615:0:o;44651:100::-;44705:13;44738:5;44731:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44651:100;:::o;46279:204::-;46347:7;46372:16;46380:7;46372;:16::i;:::-;46367:64;;46397:34;;-1:-1:-1;;;46397:34:0;;;;;;;;;;;46367:64;-1:-1:-1;46451:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46451:24:0;;46279:204::o;45798:415::-;45871:13;45903:27;45922:7;45903:18;:27::i;:::-;45871:61;-1:-1:-1;18389:10:0;-1:-1:-1;;;;;45949:28:0;;;45945:175;;45997:44;46014:5;18389:10;46934:164;:::i;45997:44::-;45992:128;;46069:35;;-1:-1:-1;;;46069:35:0;;;;;;;;;;;45992:128;46132:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;46132:29:0;-1:-1:-1;;;;;46132:29:0;;;;;;;;;46177:28;;46132:24;;46177:28;;;;;;;45860:353;45798:415;;:::o;47165:170::-;47299:28;47309:4;47315:2;47319:7;47299:9;:28::i;:::-;47165:170;;;:::o;47406:185::-;47544:39;47561:4;47567:2;47571:7;47544:39;;;;;;;;;;;;:16;:39::i;36591:98::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;36662:19;;::::1;::::0;:8:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;44440:144::-:0;44504:7;44547:27;44566:7;44547:18;:27::i;40294:234::-;40358:7;40400:5;40378:70;;40420:28;;-1:-1:-1;;;40420:28:0;;;;;;;;;;;40378:70;-1:-1:-1;;;;;;40466:25:0;;;;;:18;:25;;;;;;32037:13;40466:54;;40294:234::o;20095:103::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;20160:30:::1;20187:1;20160:18;:30::i;:::-;20095:103::o:0;44820:104::-;44876:13;44909:7;44902:14;;;;;:::i;46555:308::-;-1:-1:-1;;;;;46654:31:0;;18389:10;46654:31;46650:61;;;46694:17;;-1:-1:-1;;;46694:17:0;;;;;;;;;;;46650:61;18389:10;46724:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;46724:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;46724:60:0;;;;;;;;;;46800:55;;10284:41:1;;;46724:49:0;;18389:10;46800:55;;10257:18:1;46800:55:0;;;;;;;46555:308;;:::o;36211:97::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;36279:13:::1;:21:::0;;-1:-1:-1;;;;;;36279:21:0::1;-1:-1:-1::0;;;;;36279:21:0;;;::::1;::::0;;;::::1;::::0;;36211:97::o;47662:396::-;47829:28;47839:4;47845:2;47849:7;47829:9;:28::i;:::-;-1:-1:-1;;;;;47872:14:0;;;:19;47868:183;;47911:56;47942:4;47948:2;47952:7;47961:5;47911:30;:56::i;:::-;47906:145;;47995:40;;-1:-1:-1;;;47995:40:0;;;;;;;;;;;47906:145;47662:396;;;;:::o;36697:102::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;36770:21;;::::1;::::0;:9:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;44995:279::-:0;45068:13;45099:16;45107:7;45099;:16::i;:::-;45094:59;;45124:29;;-1:-1:-1;;;45124:29:0;;;;;;;;;;;45094:59;45196:1;45177:8;45171:22;;;;;:::i;:::-;;;:26;:95;;45257:9;45171:95;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45224:8;45234:18;45244:7;45234:9;:18::i;:::-;45207:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;45164:102;44995:279;-1:-1:-1;;44995:279:0:o;36038:165::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;36117:23:0;::::1;36109:51;;;::::0;-1:-1:-1;;;36109:51:0;;12815:2:1;36109:51:0::1;::::0;::::1;12797:21:1::0;12854:2;12834:18;;;12827:30;-1:-1:-1;;;12873:18:1;;;12866:46;12929:18;;36109:51:0::1;12613:340:1::0;36109:51:0::1;36171:10;:24:::0;;-1:-1:-1;;;;;;36171:24:0::1;-1:-1:-1::0;;;;;36171:24:0;;;::::1;::::0;;;::::1;::::0;;36038:165::o;36807:1150::-;37001:10;37013:9;37001:21;36993:43;;;;-1:-1:-1;;;36993:43:0;;15565:2:1;36993:43:0;;;15547:21:1;15604:2;15584:18;;;15577:30;-1:-1:-1;;;15623:18:1;;;15616:40;15673:18;;36993:43:0;15363:334:1;36993:43:0;37075:10;37056:30;;;;:18;:30;;;;;;;;:37;;;;;;;;;37110:8;;37056:52;;37098:9;37056:41;:52::i;:::-;:62;;37048:87;;;;-1:-1:-1;;;37048:87:0;;14198:2:1;37048:87:0;;;14180:21:1;14237:2;14217:18;;;14210:30;-1:-1:-1;;;14256:18:1;;;14249:43;14309:18;;37048:87:0;13996:337:1;37048:87:0;37184:10;;37154:28;37172:9;37154:13;38841:12;;38825:13;;:28;;38575:315;37154:13;:17;;:28::i;:::-;:40;;37146:55;;;;-1:-1:-1;;;37146:55:0;;14876:2:1;37146:55:0;;;14858:21:1;14915:1;14895:18;;;14888:29;-1:-1:-1;;;14933:18:1;;;14926:33;14976:18;;37146:55:0;14674:326:1;37146:55:0;37251:10;37221:28;37239:9;37221:13;38841:12;;38825:13;;:28;;38575:315;37221:28;:40;;37213:61;;;;-1:-1:-1;;;37213:61:0;;13160:2:1;37213:61:0;;;13142:21:1;13199:1;13179:18;;;13172:29;-1:-1:-1;;;13217:18:1;;;13210:39;13266:18;;37213:61:0;12958:332:1;37213:61:0;37311:6;37294:15;:23;;37286:43;;;;-1:-1:-1;;;37286:43:0;;14540:2:1;37286:43:0;;;14522:21:1;14579:1;14559:18;;;14552:29;-1:-1:-1;;;14597:18:1;;;14590:38;14645:18;;37286:43:0;14338:331:1;37286:43:0;37348:79;37359:6;37366:5;37372:9;37382:8;37391:10;37402:9;37412:6;37419:1;37421:2;37424;37348:10;:79::i;:::-;37340:102;;;;-1:-1:-1;;;37340:102:0;;12068:2:1;37340:102:0;;;12050:21:1;12107:2;12087:18;;;12080:30;-1:-1:-1;;;12126:18:1;;;12119:41;12177:18;;37340:102:0;11866:335:1;37340:102:0;37474:9;37463;:20;;37455:52;;;;-1:-1:-1;;;37455:52:0;;16315:2:1;37455:52:0;;;16297:21:1;16354:2;16334:18;;;16327:30;-1:-1:-1;;;16373:18:1;;;16366:50;16433:18;;37455:52:0;16113:344:1;37455:52:0;37518:18;37539:24;:9;37553;37539:13;:24::i;:::-;37518:45;-1:-1:-1;37577:12:0;;37574:74;;37608:40;;37616:10;;37608:40;;;;;37637:10;;37608:40;;;;37637:10;37616;37608:40;;;;;;;;;;;;;;;;;;;;;37574:74;37667:10;;37659:39;;-1:-1:-1;;;;;37667:10:0;;;;37659:39;;;;;37688:9;;37667:10;37659:39;37667:10;37659:39;37688:9;37667:10;37659:39;;;;;;;;;;;;;;;;;;;;;37739:31;37749:10;37760:9;37739;:31::i;:::-;37841:10;37822:30;;;;:18;:30;;;;;;;;:37;;;;;;;;;:52;;37864:9;37822:41;:52::i;:::-;37800:10;37781:30;;;;:18;:30;;;;;;;;:37;;;;;;;;:93;;;;37913:14;:21;;;;:36;;37939:9;37913:25;:36::i;:::-;37889:21;;;;:14;:21;;;;;;:60;;;;-1:-1:-1;;;;;;;;;;36807:1150:0:o;20353:201::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;18389:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20442:22:0;::::1;20434:73;;;::::0;-1:-1:-1;;;20434:73:0;;12408:2:1;20434:73:0::1;::::0;::::1;12390:21:1::0;12447:2;12427:18;;;12420:30;12486:34;12466:18;;;12459:62;-1:-1:-1;;;12537:18:1;;;12530:36;12583:19;;20434:73:0::1;12206:402:1::0;20434:73:0::1;20518:28;20537:8;20518:18;:28::i;:::-;20353:201:::0;:::o;28220:177::-;28330:58;;;-1:-1:-1;;;;;10057:32:1;;28330:58:0;;;10039:51:1;10106:18;;;;10099:34;;;28330:58:0;;;;;;;;;;10012:18:1;;;;28330:58:0;;;;;;;;-1:-1:-1;;;;;28330:58:0;-1:-1:-1;;;28330:58:0;;;28303:86;;28323:5;;28303:19;:86::i;48313:273::-;48370:4;48460:13;;48450:7;:23;48407:152;;;;-1:-1:-1;;48511:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;48511:43:0;:48;;48313:273::o;41955:1129::-;42022:7;42057;42159:13;;42152:4;:20;42148:869;;;42197:14;42214:23;;;:17;:23;;;;;;-1:-1:-1;;;42303:23:0;;42299:699;;42822:113;42829:11;42822:113;;-1:-1:-1;;;42900:6:0;42882:25;;;;:17;:25;;;;;;42822:113;;;42968:6;41955:1129;-1:-1:-1;;;41955:1129:0:o;42299:699::-;42174:843;42148:869;43045:31;;-1:-1:-1;;;43045:31:0;;;;;;;;;;;51979:2654;52094:27;52124;52143:7;52124:18;:27::i;:::-;52094:57;;52209:4;-1:-1:-1;;;;;52168:45:0;52184:19;-1:-1:-1;;;;;52168:45:0;;52164:86;;52222:28;;-1:-1:-1;;;52222:28:0;;;;;;;;;;;52164:86;52263:23;52289:24;;;:15;:24;;;;;;-1:-1:-1;;;;;52289:24:0;;;;52263:23;52352:27;;18389:10;52352:27;;:87;;-1:-1:-1;52396:43:0;52413:4;18389:10;46934:164;:::i;52396:43::-;52352:142;;;-1:-1:-1;;;;;;52456:38:0;;18389:10;52456:38;52352:142;52326:169;;52513:17;52508:66;;52539:35;;-1:-1:-1;;;52539:35:0;;;;;;;;;;;52508:66;52607:2;52585:62;;52624:23;;-1:-1:-1;;;52624:23:0;;;;;;;;;;;52585:62;52791:15;52773:39;52769:103;;52836:24;;;;:15;:24;;;;;52829:31;;-1:-1:-1;;;;;;52829:31:0;;;52769:103;-1:-1:-1;;;;;53239:24:0;;;;;;;:18;:24;;;;;;;;53237:26;;-1:-1:-1;;53237:26:0;;;53308:22;;;;;;;;53306:24;;-1:-1:-1;53306:24:0;;;53601:26;;;:17;:26;;;-1:-1:-1;;;53689:15:0;32691:3;53689:41;53647:84;;:128;;53601:174;;;53895:46;;53891:626;;53999:1;53989:11;;53967:19;54122:30;;;:17;:30;;;;;;54118:384;;54260:13;;54245:11;:28;54241:242;;54407:30;;;;:17;:30;;;;;:52;;;54241:242;53948:569;53891:626;54564:7;54560:2;-1:-1:-1;;;;;54545:27:0;54554:4;-1:-1:-1;;;;;54545:27:0;;;;;;;;;;;52083:2550;;;51979:2654;;;:::o;20714:191::-;20788:16;20807:6;;-1:-1:-1;;;;;20824:17:0;;;-1:-1:-1;;;;;;20824:17:0;;;;;;20857:40;;20807:6;;;;;;;20857:40;;20788:16;20857:40;20777:128;20714:191;:::o;58456:716::-;58640:88;;-1:-1:-1;;;58640:88:0;;58619:4;;-1:-1:-1;;;;;58640:45:0;;;;;:88;;18389:10;;58707:4;;58713:7;;58722:5;;58640:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58640:88:0;;;;;;;;-1:-1:-1;;58640:88:0;;;;;;;;;;;;:::i;:::-;;;58636:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58923:13:0;;58919:235;;58969:40;;-1:-1:-1;;;58969:40:0;;;;;;;;;;;58919:235;59112:6;59106:13;59097:6;59093:2;59089:15;59082:38;58636:529;-1:-1:-1;;;;;;58799:64:0;-1:-1:-1;;;58799:64:0;;-1:-1:-1;58636:529:0;58456:716;;;;;;:::o;61198:1960::-;61667:4;61661:11;;61674:3;61657:21;;61752:17;;;;62448:11;;;62327:5;62580:2;62594;62584:13;;62576:22;62448:11;62563:36;62635:2;62625:13;;62219:697;62654:4;62219:697;;;62845:1;62840:3;62836:11;62829:18;;62896:2;62890:4;62886:13;62882:2;62878:22;62873:3;62865:36;62749:2;62739:13;;62219:697;;;-1:-1:-1;62946:13:0;;;-1:-1:-1;;63061:12:0;;;63121:19;;;63061:12;61198:1960;-1:-1:-1;61198:1960:0:o;2771:98::-;2829:7;2856:5;2860:1;2856;:5;:::i;35268:758::-;35625:144;;35457:4;;35493:2;;35527;;35457:4;;35625:144;;;;8887:34:1;8875:47;;8952:34;8947:2;8938:12;;8931:56;9017:34;9012:2;9003:12;;8996:56;9082:30;9077:2;9068:12;;9061:52;9138:3;9129:13;;8673:475;35625:144:0;;;;;;;;;;;;;35615:155;;;;;;35787:6;35794:5;35800:9;35810:8;35819:10;35830:9;35840:6;35588:273;;;;;;;;;;;;;;10861:25:1;;;-1:-1:-1;;;;;10922:32:1;;;;10917:2;10902:18;;10895:60;10986:2;10971:18;;10964:34;;;;11029:2;11014:18;;11007:34;;;;11072:3;11057:19;;11050:35;10942:3;11101:19;;11094:35;11160:3;11145:19;;11138:35;11204:3;11189:19;;11182:35;10848:3;10833:19;;10518:705;35588:273:0;;;;-1:-1:-1;;35588:273:0;;;;;;;;;35564:308;;35588:273;35564:308;;;;35914:13;;35564:308;;-1:-1:-1;;;;;;35914:13:0;35886:24;35564:308;35904:1;35906;35908;35886:12;:24::i;:::-;-1:-1:-1;;;;;35886:41:0;;35883:136;;;35950:4;35943:11;;;;;;;35883:136;36002:5;35995:12;;;;;35268:758;;;;;;;;;;;;;:::o;3152:98::-;3210:7;3237:5;3241:1;3237;:5;:::i;48670:104::-;48739:27;48749:2;48753:8;48739:27;;;;;;;;;;;;:9;:27::i;30525:761::-;30949:23;30975:69;31003:4;30975:69;;;;;;;;;;;;;;;;;30983:5;-1:-1:-1;;;;;30975:27:0;;;:69;;;;;:::i;:::-;31059:17;;30949:95;;-1:-1:-1;31059:21:0;31055:224;;31201:10;31190:30;;;;;;;;;;;;:::i;:::-;31182:85;;;;-1:-1:-1;;;31182:85:0;;15904:2:1;31182:85:0;;;15886:21:1;15943:2;15923:18;;;15916:30;15982:34;15962:18;;;15955:62;-1:-1:-1;;;16033:18:1;;;16026:40;16083:19;;31182:85:0;15702:406:1;21789:441:0;22011:16;;21982:52;;-1:-1:-1;;;21982:52:0;;;7526:27:1;7569:11;;;7562:27;;;;7605:12;;;7598:28;;;21924:7:0;;;;7642:12:1;;21982:52:0;;;-1:-1:-1;;21982:52:0;;;;;;;;;21972:63;;21982:52;21972:63;;;;22046:17;22066:26;;;;;;;;;11455:25:1;;;11528:4;11516:17;;11496:18;;;11489:45;;;;11550:18;;;11543:34;;;11593:18;;;11586:34;;;21972:63:0;;-1:-1:-1;22046:17:0;22066:26;;11427:19:1;;22066:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;22066:26:0;;-1:-1:-1;;22066:26:0;;;-1:-1:-1;;;;;;;22156:23:0;;22148:47;;;;-1:-1:-1;;;22148:47:0;;13497:2:1;22148:47:0;;;13479:21:1;13536:2;13516:18;;;13509:30;-1:-1:-1;;;13555:18:1;;;13548:41;13606:18;;22148:47:0;13295:335:1;22148:47:0;22213:9;21789:441;-1:-1:-1;;;;;;21789:441:0:o;49161:681::-;49284:19;49290:2;49294:8;49284:5;:19::i;:::-;-1:-1:-1;;;;;49345:14:0;;;:19;49341:483;;49399:13;;49447:14;;;49480:233;49511:62;49550:1;49554:2;49558:7;;;;;;49567:5;49511:30;:62::i;:::-;49506:167;;49609:40;;-1:-1:-1;;;49609:40:0;;;;;;;;;;;49506:167;49708:3;49700:5;:11;49480:233;;49795:3;49778:13;;:20;49774:34;;49800:8;;;49774:34;49366:458;;49161:681;;;:::o;25765:196::-;25868:12;25900:53;25923:6;25931:4;25937:1;25940:12;25900:22;:53::i;50115:1610::-;50203:13;;50249:2;50227:58;;50266:19;;-1:-1:-1;;;50266:19:0;;;;;;;;;;;50227:58;50300:13;50296:44;;50322:18;;-1:-1:-1;;;50322:18:0;;;;;;;;;;;50296:44;-1:-1:-1;;;;;50889:22:0;;;;;;:18;:22;;;;32174:2;50889:22;;;:70;;50927:31;50915:44;;50889:70;;;51202:31;;;:17;:31;;;;;51295:15;32691:3;51295:41;51253:84;;-1:-1:-1;51373:13:0;;32950:3;51358:56;51253:162;51202:213;;51461:119;51488:49;;51528:8;;;;51513:23;;;-1:-1:-1;;;;;51488:49:0;;;51505:1;;51488:49;;51505:1;;51488:49;51570:8;51561:6;:17;51461:119;;-1:-1:-1;51612:23:0;51596:13;:39;-1:-1:-1;47165:170:0:o;27142:979::-;27272:12;23214:20;;27297:60;;;;-1:-1:-1;;;27297:60:0;;15207:2:1;27297:60:0;;;15189:21:1;15246:2;15226:18;;;15219:30;15285:31;15265:18;;;15258:59;15334:18;;27297:60:0;15005:353:1;27297:60:0;27431:12;27445:23;27472:6;-1:-1:-1;;;;;27472:11:0;27492:8;27503:4;27472:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27430:78;;;;27523:7;27519:595;;;27554:10;-1:-1:-1;27547:17:0;;-1:-1:-1;27547:17:0;27519:595;27668:17;;:21;27664:439;;27931:10;27925:17;27992:15;27979:10;27975:2;27971:19;27964:44;27664:439;28074:12;28067:20;;-1:-1:-1;;;28067:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;747:70;650:173;;;:::o;828:186::-;887:6;940:2;928:9;919:7;915:23;911:32;908:52;;;956:1;953;946:12;908:52;979:29;998:9;979:29;:::i;1019:260::-;1087:6;1095;1148:2;1136:9;1127:7;1123:23;1119:32;1116:52;;;1164:1;1161;1154:12;1116:52;1187:29;1206:9;1187:29;:::i;:::-;1177:39;;1235:38;1269:2;1258:9;1254:18;1235:38;:::i;:::-;1225:48;;1019:260;;;;;:::o;1284:328::-;1361:6;1369;1377;1430:2;1418:9;1409:7;1405:23;1401:32;1398:52;;;1446:1;1443;1436:12;1398:52;1469:29;1488:9;1469:29;:::i;:::-;1459:39;;1517:38;1551:2;1540:9;1536:18;1517:38;:::i;:::-;1507:48;;1602:2;1591:9;1587:18;1574:32;1564:42;;1284:328;;;;;:::o;1617:666::-;1712:6;1720;1728;1736;1789:3;1777:9;1768:7;1764:23;1760:33;1757:53;;;1806:1;1803;1796:12;1757:53;1829:29;1848:9;1829:29;:::i;:::-;1819:39;;1877:38;1911:2;1900:9;1896:18;1877:38;:::i;:::-;1867:48;;1962:2;1951:9;1947:18;1934:32;1924:42;;2017:2;2006:9;2002:18;1989:32;2044:18;2036:6;2033:30;2030:50;;;2076:1;2073;2066:12;2030:50;2099:22;;2152:4;2144:13;;2140:27;-1:-1:-1;2130:55:1;;2181:1;2178;2171:12;2130:55;2204:73;2269:7;2264:2;2251:16;2246:2;2242;2238:11;2204:73;:::i;:::-;2194:83;;;1617:666;;;;;;;:::o;2288:315::-;2353:6;2361;2414:2;2402:9;2393:7;2389:23;2385:32;2382:52;;;2430:1;2427;2420:12;2382:52;2453:29;2472:9;2453:29;:::i;:::-;2443:39;;2532:2;2521:9;2517:18;2504:32;2545:28;2567:5;2545:28;:::i;:::-;2592:5;2582:15;;;2288:315;;;;;:::o;2608:254::-;2676:6;2684;2737:2;2725:9;2716:7;2712:23;2708:32;2705:52;;;2753:1;2750;2743:12;2705:52;2776:29;2795:9;2776:29;:::i;:::-;2766:39;2852:2;2837:18;;;;2824:32;;-1:-1:-1;;;2608:254:1:o;2867:894::-;3005:6;3013;3021;3029;3037;3045;3053;3061;3069;3077;3130:3;3118:9;3109:7;3105:23;3101:33;3098:53;;;3147:1;3144;3137:12;3098:53;3170:29;3189:9;3170:29;:::i;:::-;3160:39;;3246:2;3235:9;3231:18;3218:32;3208:42;;3297:2;3286:9;3282:18;3269:32;3259:42;;3348:2;3337:9;3333:18;3320:32;3310:42;;3399:3;3388:9;3384:19;3371:33;3361:43;;3451:3;3440:9;3436:19;3423:33;3413:43;;3503:3;3492:9;3488:19;3475:33;3465:43;;3558:3;3547:9;3543:19;3530:33;3603:4;3596:5;3592:16;3585:5;3582:27;3572:55;;3623:1;3620;3613:12;3572:55;3646:5;3636:15;;;3698:3;3687:9;3683:19;3670:33;3660:43;;3750:3;3739:9;3735:19;3722:33;3712:43;;2867:894;;;;;;;;;;;;;:::o;3766:245::-;3833:6;3886:2;3874:9;3865:7;3861:23;3857:32;3854:52;;;3902:1;3899;3892:12;3854:52;3934:9;3928:16;3953:28;3975:5;3953:28;:::i;4016:245::-;4074:6;4127:2;4115:9;4106:7;4102:23;4098:32;4095:52;;;4143:1;4140;4133:12;4095:52;4182:9;4169:23;4201:30;4225:5;4201:30;:::i;4266:249::-;4335:6;4388:2;4376:9;4367:7;4363:23;4359:32;4356:52;;;4404:1;4401;4394:12;4356:52;4436:9;4430:16;4455:30;4479:5;4455:30;:::i;4520:450::-;4589:6;4642:2;4630:9;4621:7;4617:23;4613:32;4610:52;;;4658:1;4655;4648:12;4610:52;4698:9;4685:23;4731:18;4723:6;4720:30;4717:50;;;4763:1;4760;4753:12;4717:50;4786:22;;4839:4;4831:13;;4827:27;-1:-1:-1;4817:55:1;;4868:1;4865;4858:12;4817:55;4891:73;4956:7;4951:2;4938:16;4933:2;4929;4925:11;4891:73;:::i;4975:180::-;5034:6;5087:2;5075:9;5066:7;5062:23;5058:32;5055:52;;;5103:1;5100;5093:12;5055:52;-1:-1:-1;5126:23:1;;4975:180;-1:-1:-1;4975:180:1:o;5160:184::-;5230:6;5283:2;5271:9;5262:7;5258:23;5254:32;5251:52;;;5299:1;5296;5289:12;5251:52;-1:-1:-1;5322:16:1;;5160:184;-1:-1:-1;5160:184:1:o;5349:268::-;5401:3;5439:5;5433:12;5466:6;5461:3;5454:19;5482:63;5538:6;5531:4;5526:3;5522:14;5515:4;5508:5;5504:16;5482:63;:::i;:::-;5599:2;5578:15;-1:-1:-1;;5574:29:1;5565:39;;;;5606:4;5561:50;;5349:268;-1:-1:-1;;5349:268:1:o;5622:184::-;5663:3;5701:5;5695:12;5716:52;5761:6;5756:3;5749:4;5742:5;5738:16;5716:52;:::i;:::-;5784:16;;;;;5622:184;-1:-1:-1;;5622:184:1:o;5811:274::-;5940:3;5978:6;5972:13;5994:53;6040:6;6035:3;6028:4;6020:6;6016:17;5994:53;:::i;:::-;6063:16;;;;;5811:274;-1:-1:-1;;5811:274:1:o;6090:1173::-;6266:3;6295:1;6328:6;6322:13;6358:3;6380:1;6408:9;6404:2;6400:18;6390:28;;6468:2;6457:9;6453:18;6490;6480:61;;6534:4;6526:6;6522:17;6512:27;;6480:61;6560:2;6608;6600:6;6597:14;6577:18;6574:38;6571:165;;;-1:-1:-1;;;6635:33:1;;6691:4;6688:1;6681:15;6721:4;6642:3;6709:17;6571:165;6752:18;6779:104;;;;6897:1;6892:320;;;;6745:467;;6779:104;-1:-1:-1;;6812:24:1;;6800:37;;6857:16;;;;-1:-1:-1;6779:104:1;;6892:320;16717:1;16710:14;;;16754:4;16741:18;;6987:1;7001:165;7015:6;7012:1;7009:13;7001:165;;;7093:14;;7080:11;;;7073:35;7136:16;;;;7030:10;;7001:165;;;7005:3;;7195:6;7190:3;7186:16;7179:23;;6745:467;;;;;;;7228:29;7253:3;7245:6;7228:29;:::i;:::-;7221:36;6090:1173;-1:-1:-1;;;;;6090:1173:1:o;9361:499::-;-1:-1:-1;;;;;9630:15:1;;;9612:34;;9682:15;;9677:2;9662:18;;9655:43;9729:2;9714:18;;9707:34;;;9777:3;9772:2;9757:18;;9750:31;;;9555:4;;9798:56;;9834:19;;9826:6;9798:56;:::i;11631:230::-;11780:2;11769:9;11762:21;11743:4;11800:55;11851:2;11840:9;11836:18;11828:6;11800:55;:::i;13635:356::-;13837:2;13819:21;;;13856:18;;;13849:30;13915:34;13910:2;13895:18;;13888:62;13982:2;13967:18;;13635:356::o;16770:128::-;16810:3;16841:1;16837:6;16834:1;16831:13;16828:39;;;16847:18;;:::i;:::-;-1:-1:-1;16883:9:1;;16770:128::o;16903:125::-;16943:4;16971:1;16968;16965:8;16962:34;;;16976:18;;:::i;:::-;-1:-1:-1;17013:9:1;;16903:125::o;17033:258::-;17105:1;17115:113;17129:6;17126:1;17123:13;17115:113;;;17205:11;;;17199:18;17186:11;;;17179:39;17151:2;17144:10;17115:113;;;17246:6;17243:1;17240:13;17237:48;;;-1:-1:-1;;17281:1:1;17263:16;;17256:27;17033:258::o;17296:380::-;17375:1;17371:12;;;;17418;;;17439:61;;17493:4;17485:6;17481:17;17471:27;;17439:61;17546:2;17538:6;17535:14;17515:18;17512:38;17509:161;;;17592:10;17587:3;17583:20;17580:1;17573:31;17627:4;17624:1;17617:15;17655:4;17652:1;17645:15;17509:161;;17296:380;;;:::o;17681:127::-;17742:10;17737:3;17733:20;17730:1;17723:31;17773:4;17770:1;17763:15;17797:4;17794:1;17787:15;17813:127;17874:10;17869:3;17865:20;17862:1;17855:31;17905:4;17902:1;17895:15;17929:4;17926:1;17919:15;17945:118;18031:5;18024:13;18017:21;18010:5;18007:32;17997:60;;18053:1;18050;18043:12;18068:131;-1:-1:-1;;;;;;18142:32:1;;18132:43;;18122:71;;18189:1;18186;18179:12

Swarm Source

ipfs://7a048e02dae2408cca8f7bde726cf0d90b814481fe9fce142c2da992dece0870

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