Token

ClappedWolves (CP)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

6,969 CP

Holders

4,011

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x622eb38c3640d6b3f2886564f721e366daccf379

Filtered by Token Holder

0xc84ED2b8747aD9D87022e99C079C5221bA1c0eEa

Balance

1 CP

0xc84ED2b8747aD9D87022e99C079C5221bA1c0eEa

OVERVIEW

ClappedWolves are the most 6969 Clapped Wolves in town. We’re hunting these…grrr…juicy and thicc goblins…ClappedWolves will devour and swallow every globlin inch…grrr…nothing turns us on more…

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ClappedWolves

Compiler Version

v0.8.14+commit.80d49f37

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

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


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/interfaces/IERC2981.sol


// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// File: @openzeppelin/contracts/token/common/ERC2981.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `tokenId` must be already minted.
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: erc721a/contracts/IERC721A.sol


// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

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

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

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

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

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

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

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

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

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

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

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

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

// File: erc721a/contracts/ERC721A.sol


// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev ERC721 token receiver interface.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

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

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

    /**
     * @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 (owner == address(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 auxillary 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 auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        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();

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

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

    /**
     * @dev 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 (to == owner) revert ApprovalToCurrentOwner();

        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.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // 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 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

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

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

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // 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 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

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

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // 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));

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // 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)
        }
    }
}

// File: contracts/werewolves.sol



pragma solidity ^0.8.14;








error ErrorSaleNotOpen();
error ErrorInsufficientFund();
error ErrorExceedTransactionLimit();
error ErrorExceedWalletLimit();
error ErrorExceedMaxSupply();

contract ClappedWolves is ERC2981, ERC721A, Ownable {
    using Address for address payable;
    using ECDSA for bytes32;
    using Strings for uint256;

    uint256 public immutable mintPrice_;
    uint32 public immutable txLimit_;
    uint32 public immutable maxSupply_;
    uint32 public immutable walletLimit_;

    bool public open_;
    string public metadataURI_ = "";

    constructor(
        uint256 mintPrice,
        uint32 maxSupply,
        uint32 txLimit,
        uint32 walletLimit
    ) ERC721A("ClappedWolves", "CP") {
        mintPrice_ = mintPrice;
        maxSupply_ = maxSupply;
        txLimit_ = txLimit;
        walletLimit_ = walletLimit;

        _setDefaultRoyalty(owner(), 500);
    }

    function mint(uint32 amount) external payable {
        if (!open_) revert ErrorSaleNotOpen();
        if (amount + _totalMinted() > maxSupply_) revert ErrorExceedMaxSupply();
        if (amount > txLimit_) revert ErrorExceedTransactionLimit();

        uint256 requiredValue = amount * mintPrice_;
        uint64 userMinted = _getAux(msg.sender);
        if (userMinted == 0) requiredValue -= mintPrice_;

        userMinted += amount;
        _setAux(msg.sender, userMinted);
        if (userMinted > walletLimit_) revert ErrorExceedWalletLimit();

        if (msg.value < requiredValue) revert ErrorInsufficientFund();

        _safeMint(msg.sender, amount);
    }

    struct State {
        uint256 mintPrice;
        uint32 txLimit;
        uint32 walletLimit;
        uint32 maxSupply;
        uint32 totalMinted;
        uint32 userMinted;
        bool open;
    }

    function _state(address minter) external view returns (State memory) {
        return
            State({
                mintPrice: mintPrice_,
                txLimit: txLimit_,
                walletLimit: walletLimit_,
                maxSupply: maxSupply_,
                totalMinted: uint32(ERC721A._totalMinted()),
                userMinted: uint32(_getAux(minter)),
                open: open_
            });
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = metadataURI_;
        return string(abi.encodePacked(baseURI, tokenId.toString(), ".json"));
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
        return
            interfaceId == type(IERC2981).interfaceId ||
            interfaceId == type(IERC721A).interfaceId ||
            super.supportsInterface(interfaceId);
    }
 
    function setOpen(bool open) external onlyOwner {
        open_ = open;
    }

    function setmetadata(string memory uri) external onlyOwner {
        metadataURI_ = uri;
    }

    function withdraw() external onlyOwner {
        payable(msg.sender).sendValue(address(this).balance);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"mintPrice","type":"uint256"},{"internalType":"uint32","name":"maxSupply","type":"uint32"},{"internalType":"uint32","name":"txLimit","type":"uint32"},{"internalType":"uint32","name":"walletLimit","type":"uint32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"ErrorExceedMaxSupply","type":"error"},{"inputs":[],"name":"ErrorExceedTransactionLimit","type":"error"},{"inputs":[],"name":"ErrorExceedWalletLimit","type":"error"},{"inputs":[],"name":"ErrorInsufficientFund","type":"error"},{"inputs":[],"name":"ErrorSaleNotOpen","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":[{"internalType":"address","name":"minter","type":"address"}],"name":"_state","outputs":[{"components":[{"internalType":"uint256","name":"mintPrice","type":"uint256"},{"internalType":"uint32","name":"txLimit","type":"uint32"},{"internalType":"uint32","name":"walletLimit","type":"uint32"},{"internalType":"uint32","name":"maxSupply","type":"uint32"},{"internalType":"uint32","name":"totalMinted","type":"uint32"},{"internalType":"uint32","name":"userMinted","type":"uint32"},{"internalType":"bool","name":"open","type":"bool"}],"internalType":"struct ClappedWolves.State","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"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":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metadataURI_","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"amount","type":"uint32"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"open_","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"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":"bool","name":"open","type":"bool"}],"name":"setOpen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setmetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"txLimit_","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"walletLimit_","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x6080604052600436106101c25760003560e01c80636fdca5e0116100f7578063b1bc724a11610095578063c87b56dd11610064578063c87b56dd146105bb578063e985e9c5146105db578063f0a2f9d714610624578063f2fde38b1461065857600080fd5b8063b1bc724a14610532578063b6dd66ff14610552578063b7a1de9014610586578063b88d4fde1461059b57600080fd5b80638da5cb5b116100d15780638da5cb5b146104cc57806395d89b41146104ea578063a22cb465146104ff578063a71bbebe1461051f57600080fd5b80636fdca5e01461047757806370a0823114610497578063715018a6146104b757600080fd5b806323f0d517116101645780633ccfd60b1161013e5780633ccfd60b1461039857806342842e0e146103ad5780634df8bb45146103cd5780636352211e1461045757600080fd5b806323f0d517146103045780632a55205a146103255780632f396ce01461036457600080fd5b8063095ea7b3116101a0578063095ea7b314610256578063097284b21461027857806318160ddd146102c157806323b872dd146102e457600080fd5b806301ffc9a7146101c757806306fdde03146101fc578063081812fc1461021e575b600080fd5b3480156101d357600080fd5b506101e76101e2366004611905565b610678565b60405190151581526020015b60405180910390f35b34801561020857600080fd5b506102116106be565b6040516101f3919061197a565b34801561022a57600080fd5b5061023e61023936600461198d565b610750565b6040516001600160a01b0390911681526020016101f3565b34801561026257600080fd5b506102766102713660046119c2565b610794565b005b34801561028457600080fd5b506102ac7f0000000000000000000000000000000000000000000000000000000000001b3981565b60405163ffffffff90911681526020016101f3565b3480156102cd57600080fd5b50600354600254035b6040519081526020016101f3565b3480156102f057600080fd5b506102766102ff3660046119ec565b610866565b34801561031057600080fd5b50600a546101e790600160a01b900460ff1681565b34801561033157600080fd5b50610345610340366004611a28565b610876565b604080516001600160a01b0390931683526020830191909152016101f3565b34801561037057600080fd5b506102ac7f000000000000000000000000000000000000000000000000000000000000000a81565b3480156103a457600080fd5b50610276610922565b3480156103b957600080fd5b506102766103c83660046119ec565b610961565b3480156103d957600080fd5b506103ed6103e8366004611a4a565b61097c565b6040516101f39190600060e08201905082518252602083015163ffffffff80821660208501528060408601511660408501528060608601511660608501528060808601511660808501528060a08601511660a0850152505060c0830151151560c083015292915050565b34801561046357600080fd5b5061023e61047236600461198d565b610ac3565b34801561048357600080fd5b50610276610492366004611a75565b610ace565b3480156104a357600080fd5b506102d66104b2366004611a4a565b610b16565b3480156104c357600080fd5b50610276610b65565b3480156104d857600080fd5b50600a546001600160a01b031661023e565b3480156104f657600080fd5b50610211610b99565b34801561050b57600080fd5b5061027661051a366004611a90565b610ba8565b61027661052d366004611ac3565b610c3d565b34801561053e57600080fd5b5061027661054d366004611b75565b610e49565b34801561055e57600080fd5b506102d67f0000000000000000000000000000000000000000000000000018838370f3400081565b34801561059257600080fd5b50610211610e8a565b3480156105a757600080fd5b506102766105b6366004611bbe565b610f18565b3480156105c757600080fd5b506102116105d636600461198d565b610f62565b3480156105e757600080fd5b506101e76105f6366004611c3a565b6001600160a01b03918216600090815260096020908152604080832093909416825291909152205460ff1690565b34801561063057600080fd5b506102ac7f000000000000000000000000000000000000000000000000000000000000000a81565b34801561066457600080fd5b50610276610673366004611a4a565b61104b565b60006001600160e01b0319821663152a902d60e11b14806106a957506001600160e01b0319821663184371e560e31b145b806106b857506106b8826110e6565b92915050565b6060600480546106cd90611c64565b80601f01602080910402602001604051908101604052809291908181526020018280546106f990611c64565b80156107465780601f1061071b57610100808354040283529160200191610746565b820191906000526020600020905b81548152906001019060200180831161072957829003601f168201915b5050505050905090565b600061075b82611134565b610778576040516333d1c03960e21b815260040160405180910390fd5b506000908152600860205260409020546001600160a01b031690565b600061079f8261115c565b9050806001600160a01b0316836001600160a01b0316036107d35760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b0382161461080a576107ed81336105f6565b61080a576040516367d9dca160e11b815260040160405180910390fd5b60008281526008602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b6108718383836111ca565b505050565b60008281526001602090815260408083208151808301909252546001600160a01b038116808352600160a01b9091046001600160601b03169282019290925282916108eb5750604080518082019091526000546001600160a01b0381168252600160a01b90046001600160601b031660208201525b60208101516000906127109061090a906001600160601b031687611cb4565b6109149190611ce9565b915196919550909350505050565b600a546001600160a01b031633146109555760405162461bcd60e51b815260040161094c90611cfd565b60405180910390fd5b61095f3347611371565b565b61087183838360405180602001604052806000815250610f18565b6040805160e081018252600080825260208201819052918101829052606081018290526080810182905260a0810182905260c08101919091526040518060e001604052807f0000000000000000000000000000000000000000000000000018838370f3400081526020017f000000000000000000000000000000000000000000000000000000000000000a63ffffffff1681526020017f000000000000000000000000000000000000000000000000000000000000000a63ffffffff1681526020017f0000000000000000000000000000000000000000000000000000000000001b3963ffffffff168152602001610a7360025490565b63ffffffff168152602001610aa0846001600160a01b031660009081526007602052604090205460c01c90565b63ffffffff168152600a54600160a01b900460ff16151560209091015292915050565b60006106b88261115c565b600a546001600160a01b03163314610af85760405162461bcd60e51b815260040161094c90611cfd565b600a8054911515600160a01b0260ff60a01b19909216919091179055565b60006001600160a01b038216610b3f576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b031660009081526007602052604090205467ffffffffffffffff1690565b600a546001600160a01b03163314610b8f5760405162461bcd60e51b815260040161094c90611cfd565b61095f600061148a565b6060600580546106cd90611c64565b336001600160a01b03831603610bd15760405163b06307db60e01b815260040160405180910390fd5b3360008181526009602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b600a54600160a01b900460ff16610c6757604051638e456a5b60e01b815260040160405180910390fd5b7f0000000000000000000000000000000000000000000000000000000000001b3963ffffffff16610c9760025490565b610ca79063ffffffff8416611d32565b1115610cc657604051630af76cd360e31b815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000a63ffffffff168163ffffffff161115610d135760405163552d9c8360e01b815260040160405180910390fd5b6000610d457f0000000000000000000000000000000000000000000000000018838370f3400063ffffffff8416611cb4565b3360009081526007602052604081205491925060c09190911c90819003610d9357610d907f0000000000000000000000000000000000000000000000000018838370f3400083611d4a565b91505b610da363ffffffff841682611d61565b33600090815260076020526040902080546001600160c01b031660c083901b17905590507f000000000000000000000000000000000000000000000000000000000000000a63ffffffff168167ffffffffffffffff161115610e18576040516305c6e3a560e21b815260040160405180910390fd5b81341015610e395760405163272c430f60e21b815260040160405180910390fd5b610871338463ffffffff166114dc565b600a546001600160a01b03163314610e735760405162461bcd60e51b815260040161094c90611cfd565b8051610e8690600b906020840190611856565b5050565b600b8054610e9790611c64565b80601f0160208091040260200160405190810160405280929190818152602001828054610ec390611c64565b8015610f105780601f10610ee557610100808354040283529160200191610f10565b820191906000526020600020905b815481529060010190602001808311610ef357829003601f168201915b505050505081565b610f238484846111ca565b6001600160a01b0383163b15610f5c57610f3f848484846114f6565b610f5c576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b6060610f6d82611134565b610f8a57604051630a14c4b560e41b815260040160405180910390fd5b6000600b8054610f9990611c64565b80601f0160208091040260200160405190810160405280929190818152602001828054610fc590611c64565b80156110125780601f10610fe757610100808354040283529160200191611012565b820191906000526020600020905b815481529060010190602001808311610ff557829003601f168201915b5050505050905080611023846115e2565b604051602001611034929190611d8d565b604051602081830303815290604052915050919050565b600a546001600160a01b031633146110755760405162461bcd60e51b815260040161094c90611cfd565b6001600160a01b0381166110da5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161094c565b6110e38161148a565b50565b60006301ffc9a760e01b6001600160e01b03198316148061111757506380ac58cd60e01b6001600160e01b03198316145b806106b85750506001600160e01b031916635b5e139f60e01b1490565b6000600254821080156106b8575050600090815260066020526040902054600160e01b161590565b6000816002548110156111b15760008181526006602052604081205490600160e01b821690036111af575b806000036111a8575060001901600081815260066020526040902054611187565b9392505050565b505b604051636f96cda160e11b815260040160405180910390fd5b60006111d58261115c565b9050836001600160a01b0316816001600160a01b0316146112085760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b0386161480611226575061122685336105f6565b8061124157503361123684610750565b6001600160a01b0316145b90508061126157604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b03841661128857604051633a954ecd60e21b815260040160405180910390fd5b600083815260086020908152604080832080546001600160a01b03191690556001600160a01b038881168452600783528184208054600019019055871683528083208054600101905585835260069091528120600160e11b4260a01b8717811790915583169003611329576001830160008181526006602052604081205490036113275760025481146113275760008181526006602052604090208390555b505b82846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45050505050565b804710156113c15760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e6365000000604482015260640161094c565b6000826001600160a01b03168260405160006040518083038185875af1925050503d806000811461140e576040519150601f19603f3d011682016040523d82523d6000602084013e611413565b606091505b50509050806108715760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d61792068617665207265766572746564000000000000606482015260840161094c565b600a80546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b610e868282604051806020016040528060008152506116e3565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a029061152b903390899088908890600401611dcc565b6020604051808303816000875af1925050508015611566575060408051601f3d908101601f1916820190925261156391810190611e09565b60015b6115c4573d808015611594576040519150601f19603f3d011682016040523d82523d6000602084013e611599565b606091505b5080516000036115bc576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b6060816000036116095750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611633578061161d81611e26565b915061162c9050600a83611ce9565b915061160d565b60008167ffffffffffffffff81111561164e5761164e611ae9565b6040519080825280601f01601f191660200182016040528015611678576020820181803683370190505b5090505b84156115da5761168d600183611d4a565b915061169a600a86611e3f565b6116a5906030611d32565b60f81b8183815181106116ba576116ba611e53565b60200101906001600160f81b031916908160001a9053506116dc600a86611ce9565b945061167c565b6002546001600160a01b03841661170c57604051622e076360e81b815260040160405180910390fd5b8260000361172d5760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b03841660008181526007602090815260408083208054680100000000000000018902019055848352600690915290204260a01b86176001861460e11b1790558190818501903b15611802575b60405182906001600160a01b038816906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a46117cb60008784806001019550876114f6565b6117e8576040516368d2bf6b60e11b815260040160405180910390fd5b8082106117805782600254146117fd57600080fd5b611847565b5b6040516001830192906001600160a01b038816906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4808210611803575b50600255610f5c600085838684565b82805461186290611c64565b90600052602060002090601f01602090048101928261188457600085556118ca565b82601f1061189d57805160ff19168380011785556118ca565b828001600101855582156118ca579182015b828111156118ca5782518255916020019190600101906118af565b506118d69291506118da565b5090565b5b808211156118d657600081556001016118db565b6001600160e01b0319811681146110e357600080fd5b60006020828403121561191757600080fd5b81356111a8816118ef565b60005b8381101561193d578181015183820152602001611925565b83811115610f5c5750506000910152565b60008151808452611966816020860160208601611922565b601f01601f19169290920160200192915050565b6020815260006111a8602083018461194e565b60006020828403121561199f57600080fd5b5035919050565b80356001600160a01b03811681146119bd57600080fd5b919050565b600080604083850312156119d557600080fd5b6119de836119a6565b946020939093013593505050565b600080600060608486031215611a0157600080fd5b611a0a846119a6565b9250611a18602085016119a6565b9150604084013590509250925092565b60008060408385031215611a3b57600080fd5b50508035926020909101359150565b600060208284031215611a5c57600080fd5b6111a8826119a6565b803580151581146119bd57600080fd5b600060208284031215611a8757600080fd5b6111a882611a65565b60008060408385031215611aa357600080fd5b611aac836119a6565b9150611aba60208401611a65565b90509250929050565b600060208284031215611ad557600080fd5b813563ffffffff811681146111a857600080fd5b634e487b7160e01b600052604160045260246000fd5b600067ffffffffffffffff80841115611b1a57611b1a611ae9565b604051601f8501601f19908116603f01168101908282118183101715611b4257611b42611ae9565b81604052809350858152868686011115611b5b57600080fd5b858560208301376000602087830101525050509392505050565b600060208284031215611b8757600080fd5b813567ffffffffffffffff811115611b9e57600080fd5b8201601f81018413611baf57600080fd5b6115da84823560208401611aff565b60008060008060808587031215611bd457600080fd5b611bdd856119a6565b9350611beb602086016119a6565b925060408501359150606085013567ffffffffffffffff811115611c0e57600080fd5b8501601f81018713611c1f57600080fd5b611c2e87823560208401611aff565b91505092959194509250565b60008060408385031215611c4d57600080fd5b611c56836119a6565b9150611aba602084016119a6565b600181811c90821680611c7857607f821691505b602082108103611c9857634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b6000816000190483118215151615611cce57611cce611c9e565b500290565b634e487b7160e01b600052601260045260246000fd5b600082611cf857611cf8611cd3565b500490565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60008219821115611d4557611d45611c9e565b500190565b600082821015611d5c57611d5c611c9e565b500390565b600067ffffffffffffffff808316818516808303821115611d8457611d84611c9e565b01949350505050565b60008351611d9f818460208801611922565b835190830190611db3818360208801611922565b64173539b7b760d91b9101908152600501949350505050565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090611dff9083018461194e565b9695505050505050565b600060208284031215611e1b57600080fd5b81516111a8816118ef565b600060018201611e3857611e38611c9e565b5060010190565b600082611e4e57611e4e611cd3565b500690565b634e487b7160e01b600052603260045260246000fdfea2646970667358221220b65318cf96334f263804e46abcd3d41c83028c6ee22dc5418627352ef58dfc0464736f6c634300080e0033

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

0000000000000000000000000000000000000000000000000018838370f340000000000000000000000000000000000000000000000000000000000000001b39000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000a

-----Decoded View---------------
Arg [0] : mintPrice (uint256): 6900000000000000
Arg [1] : maxSupply (uint32): 6969
Arg [2] : txLimit (uint32): 10
Arg [3] : walletLimit (uint32): 10

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000018838370f34000
Arg [1] : 0000000000000000000000000000000000000000000000000000000000001b39
Arg [2] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000a

Deployed Bytecode Sourcemap

85773:3011:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88172:300;;;;;;;;;;-1:-1:-1;88172:300:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;88172:300:0;;;;;;;;65266:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;67334:204::-;;;;;;;;;;-1:-1:-1;67334:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;67334:204:0;1528:203:1;66794:474:0;;;;;;;;;;-1:-1:-1;66794:474:0;;;;;:::i;:::-;;:::i;:::-;;86017:34;;;;;;;;;;;;;;;;;;2347:10:1;2335:23;;;2317:42;;2305:2;2290:18;86017:34:0;2173:192:1;59307:315:0;;;;;;;;;;-1:-1:-1;59573:12:0;;59557:13;;:28;59307:315;;;2516:25:1;;;2504:2;2489:18;59307:315:0;2370:177:1;68220:170:0;;;;;;;;;;-1:-1:-1;68220:170:0;;;;;:::i;:::-;;:::i;86103:17::-;;;;;;;;;;-1:-1:-1;86103:17:0;;;;-1:-1:-1;;;86103:17:0;;;;;;13003:442;;;;;;;;;;-1:-1:-1;13003:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3330:32:1;;;3312:51;;3394:2;3379:18;;3372:34;;;;3285:18;13003:442:0;3138:274:1;85978:32:0;;;;;;;;;;;;;;;88671:110;;;;;;;;;;;;;:::i;68461:185::-;;;;;;;;;;-1:-1:-1;68461:185:0;;;;;:::i;:::-;;:::i;87425:436::-;;;;;;;;;;-1:-1:-1;87425:436:0;;;;;:::i;:::-;;:::i;:::-;;;;;;3746:4:1;3788:3;3777:9;3773:19;3765:27;;3825:6;3819:13;3808:9;3801:32;3880:4;3872:6;3868:17;3862:24;3905:10;3971:2;3957:12;3953:21;3946:4;3935:9;3931:20;3924:51;4043:2;4035:4;4027:6;4023:17;4017:24;4013:33;4006:4;3995:9;3991:20;3984:63;4115:2;4107:4;4099:6;4095:17;4089:24;4085:33;4078:4;4067:9;4063:20;4056:63;4187:2;4179:4;4171:6;4167:17;4161:24;4157:33;4150:4;4139:9;4135:20;4128:63;4259:2;4251:4;4243:6;4239:17;4233:24;4229:33;4222:4;4211:9;4207:20;4200:63;;;4333:4;4325:6;4321:17;4315:24;4308:32;4301:40;4294:4;4283:9;4279:20;4272:70;3608:740;;;;;65055:144:0;;;;;;;;;;-1:-1:-1;65055:144:0;;;;;:::i;:::-;;:::i;88481:78::-;;;;;;;;;;-1:-1:-1;88481:78:0;;;;;:::i;:::-;;:::i;60932:224::-;;;;;;;;;;-1:-1:-1;60932:224:0;;;;;:::i;:::-;;:::i;18150:103::-;;;;;;;;;;;;;:::i;17499:87::-;;;;;;;;;;-1:-1:-1;17572:6:0;;-1:-1:-1;;;;;17572:6:0;17499:87;;65435:104;;;;;;;;;;;;;:::i;67610:308::-;;;;;;;;;;-1:-1:-1;67610:308:0;;;;;:::i;:::-;;:::i;86519:683::-;;;;;;:::i;:::-;;:::i;88567:96::-;;;;;;;;;;-1:-1:-1;88567:96:0;;;;;:::i;:::-;;:::i;85936:35::-;;;;;;;;;;;;;;;86127:31;;;;;;;;;;;;;:::i;68717:396::-;;;;;;;;;;-1:-1:-1;68717:396:0;;;;;:::i;:::-;;:::i;87869:295::-;;;;;;;;;;-1:-1:-1;87869:295:0;;;;;:::i;:::-;;:::i;67989:164::-;;;;;;;;;;-1:-1:-1;67989:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;68110:25:0;;;68086:4;68110:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;67989:164;86058:36;;;;;;;;;;;;;;;18408:201;;;;;;;;;;-1:-1:-1;18408:201:0;;;;;:::i;:::-;;:::i;88172:300::-;88275:4;-1:-1:-1;;;;;;88312:41:0;;-1:-1:-1;;;88312:41:0;;:99;;-1:-1:-1;;;;;;;88370:41:0;;-1:-1:-1;;;88370:41:0;88312:99;:152;;;;88428:36;88452:11;88428:23;:36::i;:::-;88292:172;88172:300;-1:-1:-1;;88172:300:0:o;65266:100::-;65320:13;65353:5;65346:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65266:100;:::o;67334:204::-;67402:7;67427:16;67435:7;67427;:16::i;:::-;67422:64;;67452:34;;-1:-1:-1;;;67452:34:0;;;;;;;;;;;67422:64;-1:-1:-1;67506:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;67506:24:0;;67334:204::o;66794:474::-;66867:13;66899:27;66918:7;66899:18;:27::i;:::-;66867:61;;66949:5;-1:-1:-1;;;;;66943:11:0;:2;-1:-1:-1;;;;;66943:11:0;;66939:48;;66963:24;;-1:-1:-1;;;66963:24:0;;;;;;;;;;;66939:48;83437:10;-1:-1:-1;;;;;67004:28:0;;;67000:175;;67052:44;67069:5;83437:10;67989:164;:::i;67052:44::-;67047:128;;67124:35;;-1:-1:-1;;;67124:35:0;;;;;;;;;;;67047:128;67187:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;67187:29:0;-1:-1:-1;;;;;67187:29:0;;;;;;;;;67232:28;;67187:24;;67232:28;;;;;;;66856:412;66794:474;;:::o;68220:170::-;68354:28;68364:4;68370:2;68374:7;68354:9;:28::i;:::-;68220:170;;;:::o;13003:442::-;13100:7;13158:27;;;:17;:27;;;;;;;;13129:56;;;;;;;;;-1:-1:-1;;;;;13129:56:0;;;;;-1:-1:-1;;;13129:56:0;;;-1:-1:-1;;;;;13129:56:0;;;;;;;;13100:7;;13198:92;;-1:-1:-1;13249:29:0;;;;;;;;;-1:-1:-1;13249:29:0;-1:-1:-1;;;;;13249:29:0;;;;-1:-1:-1;;;13249:29:0;;-1:-1:-1;;;;;13249:29:0;;;;;13198:92;13340:23;;;;13302:21;;13811:5;;13327:36;;-1:-1:-1;;;;;13327:36:0;:10;:36;:::i;:::-;13326:58;;;;:::i;:::-;13405:16;;;;;-1:-1:-1;13003:442:0;;-1:-1:-1;;;;13003:442:0:o;88671:110::-;17572:6;;-1:-1:-1;;;;;17572:6:0;83437:10;17719:23;17711:68;;;;-1:-1:-1;;;17711:68:0;;;;;;;:::i;:::-;;;;;;;;;88721:52:::1;88729:10;88751:21;88721:29;:52::i;:::-;88671:110::o:0;68461:185::-;68599:39;68616:4;68622:2;68626:7;68599:39;;;;;;;;;;;;:16;:39::i;87425:436::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87525:328:0;;;;;;;;87561:10;87525:328;;;;87599:8;87525:328;;;;;;87639:12;87525:328;;;;;;87681:10;87525:328;;;;;;87730:22;59955:13;;;59720:285;87730:22;87525:328;;;;;;87791:15;87799:6;-1:-1:-1;;;;;61894:25:0;61861:6;61894:25;;;:18;:25;;;;;;56642:3;61894:39;;61806:136;87791:15;87525:328;;;;87832:5;;-1:-1:-1;;;87832:5:0;;;;87525:328;;;;;;;87505:348;;-1:-1:-1;;87425:436:0:o;65055:144::-;65119:7;65162:27;65181:7;65162:18;:27::i;88481:78::-;17572:6;;-1:-1:-1;;;;;17572:6:0;83437:10;17719:23;17711:68;;;;-1:-1:-1;;;17711:68:0;;;;;;;:::i;:::-;88539:5:::1;:12:::0;;;::::1;;-1:-1:-1::0;;;88539:12:0::1;-1:-1:-1::0;;;;88539:12:0;;::::1;::::0;;;::::1;::::0;;88481:78::o;60932:224::-;60996:7;-1:-1:-1;;;;;61020:19:0;;61016:60;;61048:28;;-1:-1:-1;;;61048:28:0;;;;;;;;;;;61016:60;-1:-1:-1;;;;;;61094:25:0;;;;;:18;:25;;;;;;56271:13;61094:54;;60932:224::o;18150:103::-;17572:6;;-1:-1:-1;;;;;17572:6:0;83437:10;17719:23;17711:68;;;;-1:-1:-1;;;17711:68:0;;;;;;;:::i;:::-;18215:30:::1;18242:1;18215:18;:30::i;65435:104::-:0;65491:13;65524:7;65517:14;;;;;:::i;67610:308::-;83437:10;-1:-1:-1;;;;;67709:31:0;;;67705:61;;67749:17;;-1:-1:-1;;;67749:17:0;;;;;;;;;;;67705:61;83437:10;67779:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;67779:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;67779:60:0;;;;;;;;;;67855:55;;540:41:1;;;67779:49:0;;83437:10;67855:55;;513:18:1;67855:55:0;;;;;;;67610:308;;:::o;86519:683::-;86581:5;;-1:-1:-1;;;86581:5:0;;;;86576:37;;86595:18;;-1:-1:-1;;;86595:18:0;;;;;;;;;;;86576:37;86654:10;86628:36;;86637:14;59955:13;;;59720:285;86637:14;86628:23;;;;;;:::i;:::-;:36;86624:71;;;86673:22;;-1:-1:-1;;;86673:22:0;;;;;;;;;;;86624:71;86719:8;86710:17;;:6;:17;;;86706:59;;;86736:29;;-1:-1:-1;;;86736:29:0;;;;;;;;;;;86706:59;86778:21;86802:19;86811:10;86802:19;;;;:::i;:::-;86860:10;86832:17;61894:25;;;:18;:25;;;;;;86778:43;;-1:-1:-1;56642:3:0;61894:39;;;;;86886:15;;;86882:48;;86903:27;86920:10;86903:27;;:::i;:::-;;;86882:48;86943:20;;;;;;:::i;:::-;86982:10;62194:14;62211:25;;;:18;:25;;;;;;;-1:-1:-1;;;;;62375:31:0;56642:3;62411:23;;;62374:61;62446:34;;62411:23;-1:-1:-1;87033:12:0;87020:25;;:10;:25;;;87016:62;;;87054:24;;-1:-1:-1;;;87054:24:0;;;;;;;;;;;87016:62;87107:13;87095:9;:25;87091:61;;;87129:23;;-1:-1:-1;;;87129:23:0;;;;;;;;;;;87091:61;87165:29;87175:10;87187:6;87165:29;;:9;:29::i;88567:96::-;17572:6;;-1:-1:-1;;;;;17572:6:0;83437:10;17719:23;17711:68;;;;-1:-1:-1;;;17711:68:0;;;;;;;:::i;:::-;88637:18;;::::1;::::0;:12:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;88567:96:::0;:::o;86127:31::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68717:396::-;68884:28;68894:4;68900:2;68904:7;68884:9;:28::i;:::-;-1:-1:-1;;;;;68927:14:0;;;:19;68923:183;;68966:56;68997:4;69003:2;69007:7;69016:5;68966:30;:56::i;:::-;68961:145;;69050:40;;-1:-1:-1;;;69050:40:0;;;;;;;;;;;68961:145;68717:396;;;;:::o;87869:295::-;87942:13;87973:16;87981:7;87973;:16::i;:::-;87968:59;;87998:29;;-1:-1:-1;;;87998:29:0;;;;;;;;;;;87968:59;88040:21;88064:12;88040:36;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88118:7;88127:18;:7;:16;:18::i;:::-;88101:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;88087:69;;;87869:295;;;:::o;18408:201::-;17572:6;;-1:-1:-1;;;;;17572:6:0;83437:10;17719:23;17711:68;;;;-1:-1:-1;;;17711:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18497:22:0;::::1;18489:73;;;::::0;-1:-1:-1;;;18489:73:0;;10061:2:1;18489:73:0::1;::::0;::::1;10043:21:1::0;10100:2;10080:18;;;10073:30;10139:34;10119:18;;;10112:62;-1:-1:-1;;;10190:18:1;;;10183:36;10236:19;;18489:73:0::1;9859:402:1::0;18489:73:0::1;18573:28;18592:8;18573:18;:28::i;:::-;18408:201:::0;:::o;60253:615::-;60338:4;-1:-1:-1;;;;;;;;;60638:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;60715:25:0;;;60638:102;:179;;;-1:-1:-1;;;;;;;;60792:25:0;-1:-1:-1;;;60792:25:0;;60253:615::o;69368:273::-;69425:4;69515:13;;69505:7;:23;69462:152;;;;-1:-1:-1;;69566:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;69566:43:0;:48;;69368:273::o;62570:1129::-;62637:7;62672;62774:13;;62767:4;:20;62763:869;;;62812:14;62829:23;;;:17;:23;;;;;;;-1:-1:-1;;;62918:23:0;;:28;;62914:699;;63437:113;63444:6;63454:1;63444:11;63437:113;;-1:-1:-1;;;63515:6:0;63497:25;;;;:17;:25;;;;;;63437:113;;;63583:6;62570:1129;-1:-1:-1;;;62570:1129:0:o;62914:699::-;62789:843;62763:869;63660:31;;-1:-1:-1;;;63660:31:0;;;;;;;;;;;74607:2515;74722:27;74752;74771:7;74752:18;:27::i;:::-;74722:57;;74837:4;-1:-1:-1;;;;;74796:45:0;74812:19;-1:-1:-1;;;;;74796:45:0;;74792:86;;74850:28;;-1:-1:-1;;;74850:28:0;;;;;;;;;;;74792:86;74891:22;83437:10;-1:-1:-1;;;;;74917:27:0;;;;:87;;-1:-1:-1;74961:43:0;74978:4;83437:10;67989:164;:::i;74961:43::-;74917:147;;;-1:-1:-1;83437:10:0;75021:20;75033:7;75021:11;:20::i;:::-;-1:-1:-1;;;;;75021:43:0;;74917:147;74891:174;;75083:17;75078:66;;75109:35;;-1:-1:-1;;;75109:35:0;;;;;;;;;;;75078:66;-1:-1:-1;;;;;75159:16:0;;75155:52;;75184:23;;-1:-1:-1;;;75184:23:0;;;;;;;;;;;75155:52;75336:24;;;;:15;:24;;;;;;;;75329:31;;-1:-1:-1;;;;;;75329:31:0;;;-1:-1:-1;;;;;75728:24:0;;;;;:18;:24;;;;;75726:26;;-1:-1:-1;;75726:26:0;;;75797:22;;;;;;;75795:24;;-1:-1:-1;75795:24:0;;;76090:26;;;:17;:26;;;;;-1:-1:-1;;;76178:15:0;56925:3;76178:41;76136:84;;:128;;76090:174;;;76384:46;;:51;;76380:626;;76488:1;76478:11;;76456:19;76611:30;;;:17;:30;;;;;;:35;;76607:384;;76749:13;;76734:11;:28;76730:242;;76896:30;;;;:17;:30;;;;;:52;;;76730:242;76437:569;76380:626;77053:7;77049:2;-1:-1:-1;;;;;77034:27:0;77043:4;-1:-1:-1;;;;;77034:27:0;;;;;;;;;;;74711:2411;;74607:2515;;;:::o;2494:317::-;2609:6;2584:21;:31;;2576:73;;;;-1:-1:-1;;;2576:73:0;;10468:2:1;2576:73:0;;;10450:21:1;10507:2;10487:18;;;10480:30;10546:31;10526:18;;;10519:59;10595:18;;2576:73:0;10266:353:1;2576:73:0;2663:12;2681:9;-1:-1:-1;;;;;2681:14:0;2703:6;2681:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2662:52;;;2733:7;2725:78;;;;-1:-1:-1;;;2725:78:0;;11036:2:1;2725:78:0;;;11018:21:1;11075:2;11055:18;;;11048:30;11114:34;11094:18;;;11087:62;11185:28;11165:18;;;11158:56;11231:19;;2725:78:0;10834:422:1;18769:191:0;18862:6;;;-1:-1:-1;;;;;18879:17:0;;;-1:-1:-1;;;;;;18879:17:0;;;;;;;18912:40;;18862:6;;;18879:17;18862:6;;18912:40;;18843:16;;18912:40;18832:128;18769:191;:::o;69725:104::-;69794:27;69804:2;69808:8;69794:27;;;;;;;;;;;;:9;:27::i;80819:716::-;81003:88;;-1:-1:-1;;;81003:88:0;;80982:4;;-1:-1:-1;;;;;81003:45:0;;;;;:88;;83437:10;;81070:4;;81076:7;;81085:5;;81003:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;81003:88:0;;;;;;;;-1:-1:-1;;81003:88:0;;;;;;;;;;;;:::i;:::-;;;80999:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81286:6;:13;81303:1;81286:18;81282:235;;81332:40;;-1:-1:-1;;;81332:40:0;;;;;;;;;;;81282:235;81475:6;81469:13;81460:6;81456:2;81452:15;81445:38;80999:529;-1:-1:-1;;;;;;81162:64:0;-1:-1:-1;;;81162:64:0;;-1:-1:-1;80999:529:0;80819:716;;;;;;:::o;35887:723::-;35943:13;36164:5;36173:1;36164:10;36160:53;;-1:-1:-1;;36191:10:0;;;;;;;;;;;;-1:-1:-1;;;36191:10:0;;;;;35887:723::o;36160:53::-;36238:5;36223:12;36279:78;36286:9;;36279:78;;36312:8;;;;:::i;:::-;;-1:-1:-1;36335:10:0;;-1:-1:-1;36343:2:0;36335:10;;:::i;:::-;;;36279:78;;;36367:19;36399:6;36389:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36389:17:0;;36367:39;;36417:154;36424:10;;36417:154;;36451:11;36461:1;36451:11;;:::i;:::-;;-1:-1:-1;36520:10:0;36528:2;36520:5;:10;:::i;:::-;36507:24;;:2;:24;:::i;:::-;36494:39;;36477:6;36484;36477:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;36477:56:0;;;;;;;;-1:-1:-1;36548:11:0;36557:2;36548:11;;:::i;:::-;;;36417:154;;70202:2236;70348:13;;-1:-1:-1;;;;;70376:16:0;;70372:48;;70401:19;;-1:-1:-1;;;70401:19:0;;;;;;;;;;;70372:48;70435:8;70447:1;70435:13;70431:44;;70457:18;;-1:-1:-1;;;70457:18:0;;;;;;;;;;;70431:44;-1:-1:-1;;;;;71024:22:0;;;;;;:18;:22;;;;56408:2;71024:22;;;:70;;71062:31;71050:44;;71024:70;;;71337:31;;;:17;:31;;;;;71430:15;56925:3;71430:41;71388:84;;-1:-1:-1;71508:13:0;;57188:3;71493:56;71388:162;71337:213;;:31;;71631:23;;;;71675:14;:19;71671:635;;71715:313;71746:38;;71771:12;;-1:-1:-1;;;;;71746:38:0;;;71763:1;;71746:38;;71763:1;;71746:38;71812:69;71851:1;71855:2;71859:14;;;;;;71875:5;71812:30;:69::i;:::-;71807:174;;71917:40;;-1:-1:-1;;;71917:40:0;;;;;;;;;;;71807:174;72023:3;72008:12;:18;71715:313;;72109:12;72092:13;;:29;72088:43;;72123:8;;;72088:43;71671:635;;;72172:119;72203:40;;72228:14;;;;;-1:-1:-1;;;;;72203:40:0;;;72220:1;;72203:40;;72220:1;;72203:40;72286:3;72271:12;:18;72172:119;;71671:635;-1:-1:-1;72320:13:0;:28;72370:60;72399:1;72403:2;72407:12;72421:8;72370:60;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2552:328::-;2629:6;2637;2645;2698:2;2686:9;2677:7;2673:23;2669:32;2666:52;;;2714:1;2711;2704:12;2666:52;2737:29;2756:9;2737:29;:::i;:::-;2727:39;;2785:38;2819:2;2808:9;2804:18;2785:38;:::i;:::-;2775:48;;2870:2;2859:9;2855:18;2842:32;2832:42;;2552:328;;;;;:::o;2885:248::-;2953:6;2961;3014:2;3002:9;2993:7;2989:23;2985:32;2982:52;;;3030:1;3027;3020:12;2982:52;-1:-1:-1;;3053:23:1;;;3123:2;3108:18;;;3095:32;;-1:-1:-1;2885:248:1:o;3417:186::-;3476:6;3529:2;3517:9;3508:7;3504:23;3500:32;3497:52;;;3545:1;3542;3535:12;3497:52;3568:29;3587:9;3568:29;:::i;4353:160::-;4418:20;;4474:13;;4467:21;4457:32;;4447:60;;4503:1;4500;4493:12;4518:180;4574:6;4627:2;4615:9;4606:7;4602:23;4598:32;4595:52;;;4643:1;4640;4633:12;4595:52;4666:26;4682:9;4666:26;:::i;4703:254::-;4768:6;4776;4829:2;4817:9;4808:7;4804:23;4800:32;4797:52;;;4845:1;4842;4835:12;4797:52;4868:29;4887:9;4868:29;:::i;:::-;4858:39;;4916:35;4947:2;4936:9;4932:18;4916:35;:::i;:::-;4906:45;;4703:254;;;;;:::o;4962:276::-;5020:6;5073:2;5061:9;5052:7;5048:23;5044:32;5041:52;;;5089:1;5086;5079:12;5041:52;5128:9;5115:23;5178:10;5171:5;5167:22;5160:5;5157:33;5147:61;;5204:1;5201;5194:12;5243:127;5304:10;5299:3;5295:20;5292:1;5285:31;5335:4;5332:1;5325:15;5359:4;5356:1;5349:15;5375:632;5440:5;5470:18;5511:2;5503:6;5500:14;5497:40;;;5517:18;;:::i;:::-;5592:2;5586:9;5560:2;5646:15;;-1:-1:-1;;5642:24:1;;;5668:2;5638:33;5634:42;5622:55;;;5692:18;;;5712:22;;;5689:46;5686:72;;;5738:18;;:::i;:::-;5778:10;5774:2;5767:22;5807:6;5798:15;;5837:6;5829;5822:22;5877:3;5868:6;5863:3;5859:16;5856:25;5853:45;;;5894:1;5891;5884:12;5853:45;5944:6;5939:3;5932:4;5924:6;5920:17;5907:44;5999:1;5992:4;5983:6;5975;5971:19;5967:30;5960:41;;;;5375:632;;;;;:::o;6012:451::-;6081:6;6134:2;6122:9;6113:7;6109:23;6105:32;6102:52;;;6150:1;6147;6140:12;6102:52;6190:9;6177:23;6223:18;6215:6;6212:30;6209:50;;;6255:1;6252;6245:12;6209:50;6278:22;;6331:4;6323:13;;6319:27;-1:-1:-1;6309:55:1;;6360:1;6357;6350:12;6309:55;6383:74;6449:7;6444:2;6431:16;6426:2;6422;6418:11;6383:74;:::i;6468:667::-;6563:6;6571;6579;6587;6640:3;6628:9;6619:7;6615:23;6611:33;6608:53;;;6657:1;6654;6647:12;6608:53;6680:29;6699:9;6680:29;:::i;:::-;6670:39;;6728:38;6762:2;6751:9;6747:18;6728:38;:::i;:::-;6718:48;;6813:2;6802:9;6798:18;6785:32;6775:42;;6868:2;6857:9;6853:18;6840:32;6895:18;6887:6;6884:30;6881:50;;;6927:1;6924;6917:12;6881:50;6950:22;;7003:4;6995:13;;6991:27;-1:-1:-1;6981:55:1;;7032:1;7029;7022:12;6981:55;7055:74;7121:7;7116:2;7103:16;7098:2;7094;7090:11;7055:74;:::i;:::-;7045:84;;;6468:667;;;;;;;:::o;7140:260::-;7208:6;7216;7269:2;7257:9;7248:7;7244:23;7240:32;7237:52;;;7285:1;7282;7275:12;7237:52;7308:29;7327:9;7308:29;:::i;:::-;7298:39;;7356:38;7390:2;7379:9;7375:18;7356:38;:::i;7405:380::-;7484:1;7480:12;;;;7527;;;7548:61;;7602:4;7594:6;7590:17;7580:27;;7548:61;7655:2;7647:6;7644:14;7624:18;7621:38;7618:161;;7701:10;7696:3;7692:20;7689:1;7682:31;7736:4;7733:1;7726:15;7764:4;7761:1;7754:15;7618:161;;7405:380;;;:::o;7790:127::-;7851:10;7846:3;7842:20;7839:1;7832:31;7882:4;7879:1;7872:15;7906:4;7903:1;7896:15;7922:168;7962:7;8028:1;8024;8020:6;8016:14;8013:1;8010:21;8005:1;7998:9;7991:17;7987:45;7984:71;;;8035:18;;:::i;:::-;-1:-1:-1;8075:9:1;;7922:168::o;8095:127::-;8156:10;8151:3;8147:20;8144:1;8137:31;8187:4;8184:1;8177:15;8211:4;8208:1;8201:15;8227:120;8267:1;8293;8283:35;;8298:18;;:::i;:::-;-1:-1:-1;8332:9:1;;8227:120::o;8352:356::-;8554:2;8536:21;;;8573:18;;;8566:30;8632:34;8627:2;8612:18;;8605:62;8699:2;8684:18;;8352:356::o;8713:128::-;8753:3;8784:1;8780:6;8777:1;8774:13;8771:39;;;8790:18;;:::i;:::-;-1:-1:-1;8826:9:1;;8713:128::o;8846:125::-;8886:4;8914:1;8911;8908:8;8905:34;;;8919:18;;:::i;:::-;-1:-1:-1;8956:9:1;;8846:125::o;8976:236::-;9015:3;9043:18;9088:2;9085:1;9081:10;9118:2;9115:1;9111:10;9149:3;9145:2;9141:12;9136:3;9133:21;9130:47;;;9157:18;;:::i;:::-;9193:13;;8976:236;-1:-1:-1;;;;8976:236:1:o;9217:637::-;9497:3;9535:6;9529:13;9551:53;9597:6;9592:3;9585:4;9577:6;9573:17;9551:53;:::i;:::-;9667:13;;9626:16;;;;9689:57;9667:13;9626:16;9723:4;9711:17;;9689:57;:::i;:::-;-1:-1:-1;;;9768:20:1;;9797:22;;;9846:1;9835:13;;9217:637;-1:-1:-1;;;;9217:637:1:o;11261:489::-;-1:-1:-1;;;;;11530:15:1;;;11512:34;;11582:15;;11577:2;11562:18;;11555:43;11629:2;11614:18;;11607:34;;;11677:3;11672:2;11657:18;;11650:31;;;11455:4;;11698:46;;11724:19;;11716:6;11698:46;:::i;:::-;11690:54;11261:489;-1:-1:-1;;;;;;11261:489:1:o;11755:249::-;11824:6;11877:2;11865:9;11856:7;11852:23;11848:32;11845:52;;;11893:1;11890;11883:12;11845:52;11925:9;11919:16;11944:30;11968:5;11944:30;:::i;12009:135::-;12048:3;12069:17;;;12066:43;;12089:18;;:::i;:::-;-1:-1:-1;12136:1:1;12125:13;;12009:135::o;12149:112::-;12181:1;12207;12197:35;;12212:18;;:::i;:::-;-1:-1:-1;12246:9:1;;12149:112::o;12266:127::-;12327:10;12322:3;12318:20;12315:1;12308:31;12358:4;12355:1;12348:15;12382:4;12379:1;12372:15

Swarm Source

ipfs://b65318cf96334f263804e46abcd3d41c83028c6ee22dc5418627352ef58dfc04

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