OP Sepolia Testnet

Token

test (2024-mNFT)
ERC721

Overview

Max Total Supply

0 2024-mNFT

Holders

0

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-
Balance
0 2024-mNFT
0x0000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:
Test

Compiler Version
v0.8.22+commit.4fc1097e

Optimization Enabled:
Yes with 200 runs

Other Settings:
paris EvmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at sepolia-optimism.etherscan.io on 2024-01-12
*/

// SPDX-License-Identifier: MIT

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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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/utils/introspection/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 address zero.
     *
     * 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);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721.sol)

pragma solidity ^0.8.20;


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4906.sol)

pragma solidity ^0.8.20;


/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
    /// @dev This event emits when the metadata of a token is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFT.
    event MetadataUpdate(uint256 _tokenId);

    /// @dev This event emits when the metadata of a range of tokens is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFTs.
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

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

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

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


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

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


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;







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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

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

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

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

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Burnable.sol)

pragma solidity ^0.8.20;


/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        _update(address(0), tokenId, _msgSender());
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Pausable.sol)

pragma solidity ^0.8.20;


/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract pause mechanism of the contract unreachable, and thus unusable.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_update}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual override whenNotPaused returns (address) {
        return super._update(to, tokenId, auth);
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.20;




/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is IERC4906, ERC721 {
    using Strings for uint256;

    // Interface ID as defined in ERC-4906. This does not correspond to a traditional interface ID as ERC-4906 only
    // defines events and does not include any external function.
    bytes4 private constant ERC4906_INTERFACE_ID = bytes4(0x49064906);

    // Optional mapping for token URIs
    mapping(uint256 tokenId => string) private _tokenURIs;

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

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via string.concat).
        if (bytes(_tokenURI).length > 0) {
            return string.concat(base, _tokenURI);
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Emits {MetadataUpdate}.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        _tokenURIs[tokenId] = _tokenURI;
        emit MetadataUpdate(tokenId);
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}


// File hardhat/[email protected]

// Original license: SPDX_License_Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

library console {
    address constant CONSOLE_ADDRESS =
        0x000000000000000000636F6e736F6c652e6c6f67;

    function _sendLogPayloadImplementation(bytes memory payload) internal view {
        address consoleAddress = CONSOLE_ADDRESS;
        /// @solidity memory-safe-assembly
        assembly {
            pop(
                staticcall(
                    gas(),
                    consoleAddress,
                    add(payload, 32),
                    mload(payload),
                    0,
                    0
                )
            )
        }
    }

    function _castToPure(
      function(bytes memory) internal view fnIn
    ) internal pure returns (function(bytes memory) pure fnOut) {
        assembly {
            fnOut := fnIn
        }
    }

    function _sendLogPayload(bytes memory payload) internal pure {
        _castToPure(_sendLogPayloadImplementation)(payload);
    }

    function log() internal pure {
        _sendLogPayload(abi.encodeWithSignature("log()"));
    }
    function logInt(int256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    }

    function logUint(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

    function logString(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function logBool(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function logAddress(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function logBytes(bytes memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    }

    function logBytes1(bytes1 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    }

    function logBytes2(bytes2 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    }

    function logBytes3(bytes3 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    }

    function logBytes4(bytes4 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    }

    function logBytes5(bytes5 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    }

    function logBytes6(bytes6 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    }

    function logBytes7(bytes7 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    }

    function logBytes8(bytes8 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    }

    function logBytes9(bytes9 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    }

    function logBytes10(bytes10 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    }

    function logBytes11(bytes11 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    }

    function logBytes12(bytes12 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    }

    function logBytes13(bytes13 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    }

    function logBytes14(bytes14 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    }

    function logBytes15(bytes15 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    }

    function logBytes16(bytes16 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    }

    function logBytes17(bytes17 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    }

    function logBytes18(bytes18 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    }

    function logBytes19(bytes19 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    }

    function logBytes20(bytes20 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    }

    function logBytes21(bytes21 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    }

    function logBytes22(bytes22 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    }

    function logBytes23(bytes23 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    }

    function logBytes24(bytes24 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    }

    function logBytes25(bytes25 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    }

    function logBytes26(bytes26 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    }

    function logBytes27(bytes27 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    }

    function logBytes28(bytes28 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    }

    function logBytes29(bytes29 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    }

    function logBytes30(bytes30 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    }

    function logBytes31(bytes31 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    }

    function logBytes32(bytes32 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    }

    function log(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

    function log(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function log(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function log(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function log(uint256 p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
    }

    function log(uint256 p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
    }

    function log(uint256 p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
    }

    function log(uint256 p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
    }

    function log(string memory p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    }

    function log(string memory p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    }

    function log(string memory p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    }

    function log(string memory p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    }

    function log(bool p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
    }

    function log(bool p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    }

    function log(bool p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    }

    function log(bool p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    }

    function log(address p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
    }

    function log(address p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    }

    function log(address p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    }

    function log(address p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    }

    function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    }

    function log(string memory p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
    }

    function log(string memory p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    }

    function log(string memory p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    }

    function log(string memory p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    }

    function log(bool p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
    }

    function log(bool p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    }

    function log(bool p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    }

    function log(bool p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    }

    function log(bool p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
    }

    function log(bool p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    }

    function log(bool p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    }

    function log(bool p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
    }

    function log(address p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
    }

    function log(address p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    }

    function log(address p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    }

    function log(address p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    }

    function log(address p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
    }

    function log(address p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    }

    function log(address p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    }

    function log(address p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    }

    function log(address p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
    }

    function log(address p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    }

    function log(address p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    }

    function log(address p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    }

}


// File contracts/Test.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.20;








error PayableWrong();
error MaxTokensMinted();
error EmptyNotPossible();
error MaxMintNeedsToBeGreaterThanMintedNumber();

contract Test is ERC721, ERC721URIStorage, ERC721Pausable, Ownable, ERC721Burnable, ReentrancyGuard {
    uint256 private _nextTokenId;
    uint256 private _mintPayable;
    uint256 private _maxMint;
    string private _newBaseUri;
    string private _currentUri;
    string private _newName;
    address private _receivingAddress;

    constructor(address initialOwner) ERC721("test", "2024-mNFT") Ownable(initialOwner) {
        pause();
        _nextTokenId = 1;
        _receivingAddress = owner();
        _mintPayable = 1 ether;
    }

    //convenience and to save contracts calls, prize in 1000 gwei 1.000.000 = 1 eth
    function init(string memory uri, address splitAddress, uint256 maxMint, uint256 prize) public onlyOwner {
        setUri("", uri);
        setWithdrawAddress(splitAddress);
        setMaxMint(maxMint);
        setMintPayable(prize);
    }

    function _baseURI() internal view override returns (string memory) {
        if (bytes(_newBaseUri).length > 0) {
            console.log("no base set use default");
            return _newBaseUri;
        }
        console.log("no base set use default");
        return "ipfs://";
    }

    function setUri(string memory baseUri, string memory uri) public onlyOwner {
        if(bytes(baseUri).length > 0) {
            console.log("set base to: %s", baseUri);
            _newBaseUri = baseUri;
        }
        if(bytes(uri).length == 0) revert EmptyNotPossible();
        console.log("set uri  to: %s", uri);
        _currentUri = uri;
    }

    //it's there, not optimal ofc
    function updateUri() public onlyOwner  returns (uint256 updateNumber) {
        uint256 updated = 0;
        for(uint256 i=0;i<=_nextTokenId;i++){
            string memory turi = tokenURI(i);
            if(!Strings.equal(turi, _currentUri)) {
                _setTokenURI(i, _currentUri);
                updated++;
            }
        }
        return updated;
    }

    function newName(string memory name_new) public onlyOwner {
        _newName = name_new;
    }

    function name() public view override returns (string memory) {
        if(bytes(_newName).length > 0) {
            return _newName;
        }
        return super.name();
    }

    function setMaxMint(uint256 maxNo) public onlyOwner {
        if(_nextTokenId > maxNo) revert MaxMintNeedsToBeGreaterThanMintedNumber();
        _maxMint = maxNo;
    }

    function MaxMint() public view returns(uint256 maxno) {
        return _maxMint;
    }

    function setWithdrawAddress(address withdrawAddress) public onlyOwner returns (address) {
        _receivingAddress = withdrawAddress;
        return _receivingAddress;
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function safeMint(address to) public onlyOwner returns (uint256 id) {
        return safeMintInternal(to);
    }

     function safeMintInternal(address to) private returns (uint256 id) {
        uint256 tokenId = _nextTokenId++;
        if(tokenId > _maxMint) revert MaxTokensMinted();
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, _currentUri);
        console.log("tokenid: %s", tokenId);
        return tokenId;
    }

    function mintNumber() public view returns (uint256 number) {
        return _nextTokenId-1;
    }

    //amount in 1000 gwei, 1.000.000 = 1 eth
    function setMintPayable(uint256 amount) public onlyOwner {
        amount = 1 gwei * amount * 1000;
        console.log("amount: %s  %s", amount, 1 ether / 1000000);
        if(amount < (1 ether / 1000000)) revert PayableWrong();
        _mintPayable = amount;
    }

    function withdrawETH() external onlyOwner {
        uint256 amount = address(this).balance;
        address payable recipient;
        if(_receivingAddress != owner()) {
            recipient = payable(_receivingAddress);
        }else {
            recipient = payable( owner() );            
        }
        Address.sendValue(recipient, amount);
    }

    function mint() external payable nonReentrant returns (uint256 fromTokenId) {
        console.log("sent %s  mp %s",msg.value, _mintPayable);
        if (msg.value != _mintPayable) revert PayableWrong();
        address to = msg.sender;
        uint256 idx = safeMintInternal(to);
        return idx;
    }

    // The following functions are overrides required by Solidity.

    function _update(address to, uint256 tokenId, address auth)
        internal
        override(ERC721, ERC721Pausable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"initialOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[],"name":"EmptyNotPossible","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"MaxMintNeedsToBeGreaterThanMintedNumber","type":"error"},{"inputs":[],"name":"MaxTokensMinted","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"PayableWrong","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"MetadataUpdate","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"MaxMint","outputs":[{"internalType":"uint256","name":"maxno","type":"uint256"}],"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":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"},{"internalType":"address","name":"splitAddress","type":"address"},{"internalType":"uint256","name":"maxMint","type":"uint256"},{"internalType":"uint256","name":"prize","type":"uint256"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[{"internalType":"uint256","name":"fromTokenId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintNumber","outputs":[{"internalType":"uint256","name":"number","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name_new","type":"string"}],"name":"newName","outputs":[],"stateMutability":"nonpayable","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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"safeMint","outputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxNo","type":"uint256"}],"name":"setMaxMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setMintPayable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseUri","type":"string"},{"internalType":"string","name":"uri","type":"string"}],"name":"setUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"withdrawAddress","type":"address"}],"name":"setWithdrawAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[{"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":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"updateUri","outputs":[{"internalType":"uint256","name":"updateNumber","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

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

000000000000000000000000010e0dc4af75b1b5ae4a04601dfab3a7dd27bda5

-----Decoded View---------------
Arg [0] : initialOwner (address): 0x010E0Dc4aF75b1B5aE4a04601dfAB3A7DD27BDA5

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000010e0dc4af75b1b5ae4a04601dfab3a7dd27bda5


Deployed Bytecode Sourcemap

147711:5176:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;152672:212;;;;;;;;;;-1:-1:-1;152672:212:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;152672:212:0;;;;;;;;149809:182;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;45014:158::-;;;;;;;;;;-1:-1:-1;45014:158:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;45014:158:0;1533:203:1;44833:115:0;;;;;;;;;;-1:-1:-1;44833:115:0;;;;;:::i;:::-;;:::i;:::-;;151861:311;;;:::i;:::-;;;2324:25:1;;;2312:2;2297:18;151861:311:0;2178:177:1;45683:588:0;;;;;;;;;;-1:-1:-1;45683:588:0;;;;;:::i;:::-;;:::i;149316:381::-;;;;;;;;;;;;;:::i;150274:177::-;;;;;;;;;;-1:-1:-1;150274:177:0;;;;;:::i;:::-;;:::i;150528:65::-;;;;;;;;;;;;;:::i;150601:114::-;;;;;;;;;;-1:-1:-1;150601:114:0;;;;;:::i;:::-;;:::i;46342:134::-;;;;;;;;;;-1:-1:-1;46342:134:0;;;;;:::i;:::-;;:::i;60186:318::-;;;;;;;;;;-1:-1:-1;60186:318:0;;;;;:::i;:::-;;:::i;149999:171::-;;;;;;;;;;-1:-1:-1;149999:171:0;;;;;:::i;:::-;;:::i;62466:86::-;;;;;;;;;;-1:-1:-1;62537:7:0;;;;62466:86;;151210:271;;;;;;;;;;-1:-1:-1;151210:271:0;;;;;:::i;:::-;;:::i;43655:120::-;;;;;;;;;;-1:-1:-1;43655:120:0;;;;;:::i;:::-;;:::i;43380:213::-;;;;;;;;;;-1:-1:-1;43380:213:0;;;;;:::i;:::-;;:::i;3506:103::-;;;;;;;;;;;;;:::i;150459:61::-;;;;;;;;;;;;;:::i;151057:99::-;;;;;;;;;;;;;:::i;148911:362::-;;;;;;;;;;-1:-1:-1;148911:362:0;;;;;:::i;:::-;;:::i;2831:87::-;;;;;;;;;;-1:-1:-1;2904:6:0;;;;;-1:-1:-1;;;;;2904:6:0;2831:87;;150178:88;;;;;;;;;;-1:-1:-1;150250:8:0;;150178:88;;44002:95;;;;;;;;;;;;;:::i;149705:96::-;;;;;;;;;;-1:-1:-1;149705:96:0;;;;;:::i;:::-;;:::i;45244:146::-;;;;;;;;;;-1:-1:-1;45244:146:0;;;;;:::i;:::-;;:::i;46547:211::-;;;;;;;;;;-1:-1:-1;46547:211:0;;;;;:::i;:::-;;:::i;152468:196::-;;;;;;;;;;-1:-1:-1;152468:196:0;;;;;:::i;:::-;;:::i;148358:243::-;;;;;;;;;;-1:-1:-1;148358:243:0;;;;;:::i;:::-;;:::i;151489:364::-;;;;;;;;;;;;;:::i;45461:155::-;;;;;;;;;;-1:-1:-1;45461:155:0;;;;;:::i;:::-;;:::i;3764:220::-;;;;;;;;;;-1:-1:-1;3764:220:0;;;;;:::i;:::-;;:::i;152672:212::-;152811:4;152840:36;152864:11;152840:23;:36::i;:::-;152833:43;152672:212;-1:-1:-1;;152672:212:0:o;149809:182::-;149855:13;149909:1;149890:8;149884:22;;;;;:::i;:::-;;;:26;149881:73;;;149934:8;149927:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;149809:182;:::o;149881:73::-;149971:12;:10;:12::i;:::-;149964:19;;149809:182;:::o;45014:158::-;45081:7;45101:22;45115:7;45101:13;:22::i;:::-;-1:-1:-1;47590:7:0;47617:24;;;:15;:24;;;;;;-1:-1:-1;;;;;47617:24:0;45143:21;47520:129;44833:115;44905:35;44914:2;44918:7;865:10;44905:8;:35::i;:::-;44833:115;;:::o;151861:311::-;151916:19;75929:21;:19;:21::i;:::-;151948:53:::1;;;;;;;;;;;;;;-1:-1:-1::0;;;151948:53:0::1;;::::0;151977:9:::1;151988:12;;151948:11;:53::i;:::-;152029:12;;152016:9;:25;152012:52;;152050:14;;-1:-1:-1::0;;;152050:14:0::1;;;;;;;;;;;152012:52;152088:10;152075;152123:20;152088:10:::0;152123:16:::1;:20::i;:::-;152109:34:::0;-1:-1:-1;;;75973:20:0;75264:1;76515:7;:21;76332:212;75973:20;151861:311;:::o;45683:588::-;-1:-1:-1;;;;;45778:16:0;;45774:89;;45818:33;;-1:-1:-1;;;45818:33:0;;45848:1;45818:33;;;1679:51:1;1652:18;;45818:33:0;;;;;;;;45774:89;46084:21;46108:34;46116:2;46120:7;865:10;46108:7;:34::i;:::-;46084:58;;46174:4;-1:-1:-1;;;;;46157:21:0;:13;-1:-1:-1;;;;;46157:21:0;;46153:111;;46202:50;;-1:-1:-1;;;46202:50:0;;-1:-1:-1;;;;;7225:15:1;;;46202:50:0;;;7207:34:1;7257:18;;;7250:34;;;7320:15;;7300:18;;;7293:43;7142:18;;46202:50:0;6967:375:1;46153:111:0;45763:508;45683:588;;;:::o;149316:381::-;149364:20;2717:13;:11;:13::i;:::-;149397:15:::1;149431:9:::0;149427:238:::1;149446:12;;149443:1;:15;149427:238;;149478:18;149499:11;149508:1;149499:8;:11::i;:::-;149478:32;;149529;149543:4;149549:11;149529:32;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:13;:32::i;:::-;149525:129;;149582:28;149595:1;149598:11;149582:28;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:12;:28::i;:::-;149629:9:::0;::::1;::::0;::::1;:::i;:::-;;;;149525:129;-1:-1:-1::0;149459:3:0;::::1;::::0;::::1;:::i;:::-;;;;149427:238;;;-1:-1:-1::0;149682:7:0;-1:-1:-1;149316:381:0;:::o;150274:177::-;150353:7;2717:13;:11;:13::i;:::-;-1:-1:-1;150373:17:0::1;:35:::0;;-1:-1:-1;;;;;;150373:35:0::1;-1:-1:-1::0;;;;;150373:35:0;::::1;::::0;;::::1;::::0;;;2741:1:::1;150274:177:::0;;;:::o;150528:65::-;2717:13;:11;:13::i;:::-;150575:10:::1;:8;:10::i;:::-;150528:65::o:0;150601:114::-;150657:10;2717:13;:11;:13::i;:::-;150687:20:::1;150704:2;150687:16;:20::i;46342:134::-:0;46429:39;46446:4;46452:2;46456:7;46429:39;;;;;;;;;;;;:16;:39::i;:::-;46342:134;;;:::o;60186:318::-;60454:42;60470:1;60474:7;865:10;46108:7;:34::i;149999:171::-;2717:13;:11;:13::i;:::-;150080:5:::1;150065:12;;:20;150062:73;;;150094:41;;-1:-1:-1::0;;;150094:41:0::1;;;;;;;;;;;150062:73;150146:8;:16:::0;149999:171::o;151210:271::-;2717:13;:11;:13::i;:::-;151287:15:::1;151296:6:::0;151287::::1;:15;:::i;:::-;:22;::::0;151305:4:::1;151287:22;:::i;:::-;151278:31;;151320:56;;;;;;;;;;;;;;-1:-1:-1::0;;;151320:56:0::1;;::::0;151350:6:::1;151358:17;151320:11;:56::i;:::-;151400:17;151390:6;:28;151387:54;;;151427:14;;-1:-1:-1::0;;;151427:14:0::1;;;;;;;;;;;151387:54;151452:12;:21:::0;151210:271::o;43655:120::-;43718:7;43745:22;43759:7;43745:13;:22::i;43380:213::-;43443:7;-1:-1:-1;;;;;43467:19:0;;43463:89;;43510:30;;-1:-1:-1;;;43510:30:0;;43537:1;43510:30;;;1679:51:1;1652:18;;43510:30:0;1533:203:1;43463:89:0;-1:-1:-1;;;;;;43569:16:0;;;;;:9;:16;;;;;;;43380:213::o;3506:103::-;2717:13;:11;:13::i;:::-;3571:30:::1;3598:1;3571:18;:30::i;150459:61::-:0;2717:13;:11;:13::i;:::-;150504:8:::1;:6;:8::i;151057:99::-:0;151100:14;151147:1;151134:12;;:14;;;;:::i;148911:362::-;2717:13;:11;:13::i;:::-;149000:21;;:25;148997:132:::1;;149042:39;;;;;;;;;;;;;;-1:-1:-1::0;;;149042:39:0::1;;::::0;149073:7:::1;149042:11;:39::i;:::-;149096:11;:21;149110:7:::0;149096:11;:21:::1;:::i;:::-;;148997:132;149148:3;149142:17;149163:1;149142:22:::0;149139:52:::1;;149173:18;;-1:-1:-1::0;;;149173:18:0::1;;;;;;;;;;;149139:52;149202:35;;;;;;;;;;;;;;-1:-1:-1::0;;;149202:35:0::1;;::::0;149233:3:::1;149202:11;:35::i;:::-;149248:11;:17;149262:3:::0;149248:11;:17:::1;:::i;44002:95::-:0;44049:13;44082:7;44075:14;;;;;:::i;149705:96::-;2717:13;:11;:13::i;:::-;149774:8:::1;:19;149785:8:::0;149774;:19:::1;:::i;45244:146::-:0;45330:52;865:10;45363:8;45373;45330:18;:52::i;46547:211::-;46661:31;46674:4;46680:2;46684:7;46661:12;:31::i;:::-;46703:47;46726:4;46732:2;46736:7;46745:4;46703:22;:47::i;152468:196::-;152595:13;152633:23;152648:7;152633:14;:23::i;148358:243::-;2717:13;:11;:13::i;:::-;148473:15:::1;;;;;;;;;;;;::::0;148484:3:::1;148473:6;:15::i;:::-;148499:32;148518:12;148499:18;:32::i;:::-;;148542:19;148553:7;148542:10;:19::i;:::-;148572:21;148587:5;148572:14;:21::i;151489:364::-:0;2717:13;:11;:13::i;:::-;151559:21:::1;151542:14;151651:7;2904:6:::0;;-1:-1:-1;;;;;2904:6:0;;;;;;2831:87;151651:7:::1;151630:17;::::0;-1:-1:-1;;;;;151630:17:0;;::::1;:28:::0;::::1;;151627:172;;-1:-1:-1::0;151695:17:0::1;::::0;-1:-1:-1;;;;;151695:17:0::1;151627:172;;;2904:6:::0;;;;;-1:-1:-1;;;;;2904:6:0;151745:30:::1;;151627:172;151809:36;151827:9;151838:6;151809:17;:36::i;45461:155::-:0;-1:-1:-1;;;;;45573:25:0;;;45549:4;45573:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;45461:155::o;3764:220::-;2717:13;:11;:13::i;:::-;-1:-1:-1;;;;;3849:22:0;::::1;3845:93;;3895:31;::::0;-1:-1:-1;;;3895:31:0;;3923:1:::1;3895:31;::::0;::::1;1679:51:1::0;1652:18;;3895:31:0::1;1533:203:1::0;3845:93:0::1;3948:28;3967:8;3948:18;:28::i;:::-;3764:220:::0;:::o;65735:209::-;65837:4;-1:-1:-1;;;;;;65861:35:0;;-1:-1:-1;;;65861:35:0;;:75;;;65900:36;65924:11;65900:23;:36::i;43842:91::-;43887:13;43920:5;43913:12;;;;;:::i;57989:247::-;58052:7;47375:16;;;:7;:16;;;;;;-1:-1:-1;;;;;47375:16:0;;58116:90;;58163:31;;-1:-1:-1;;;58163:31:0;;;;;2324:25:1;;;2297:18;;58163:31:0;2178:177:1;56221:122:0;56302:33;56311:2;56315:7;56324:4;56330;56302:8;:33::i;76009:315::-;75307:1;76138:7;;:18;76134:88;;76180:30;;-1:-1:-1;;;76180:30:0;;;;;;;;;;;76134:88;75307:1;76299:7;:17;76009:315::o;88713:171::-;88793:83;88864:2;88868;88872;88809:66;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;88809:66:0;;;;;;;;;;;;;;-1:-1:-1;;;;;88809:66:0;-1:-1:-1;;;88809:66:0;;;88793:15;:83::i;150724:325::-;150820:12;:14;;150779:10;;;;150820:14;150779:10;150820:14;;;:::i;:::-;;;;;150802:32;;150858:8;;150848:7;:18;150845:47;;;150875:17;;-1:-1:-1;;;150875:17:0;;;;;;;;;;;150845:47;150903:22;150913:2;150917:7;150903:9;:22::i;:::-;150936:34;150949:7;150958:11;150936:34;;;;;:::i;:::-;150981:35;;;;;;;;;;;;;;-1:-1:-1;;;150981:35:0;;;151008:7;150981:11;:35::i;152250:210::-;152388:7;152420:32;152434:2;152438:7;152447:4;152420:13;:32::i;:::-;152413:39;152250:210;-1:-1:-1;;;;152250:210:0:o;2996:166::-;2904:6;;-1:-1:-1;;;;;2904:6:0;;;;;865:10;3056:23;3052:103;;3103:40;;-1:-1:-1;;;3103:40:0;;865:10;3103:40;;;1679:51:1;1652:18;;3103:40:0;1533:203:1;41519:184:0;41591:4;41640:1;41634:15;41621:1;41615:15;:34;:80;;;;;41692:1;41676:19;;;;;;41669:1;41653:19;;;;;;:42;41615:80;41608:87;41519:184;-1:-1:-1;;;41519:184:0:o;66750:170::-;66842:19;;;;:10;:19;;;;;:31;66864:9;66842:19;:31;:::i;:::-;-1:-1:-1;66889:23:0;;2324:25:1;;;66889:23:0;;2312:2:1;2297:18;66889:23:0;;;;;;;66750:170;;:::o;63367:120::-;62330:16;:14;:16::i;:::-;63426:7:::1;:15:::0;;-1:-1:-1;;63426:15:0::1;::::0;;63457:22:::1;865:10:::0;63466:12:::1;63457:22;::::0;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;63457:22:0::1;;;;;;;63367:120::o:0;4144:191::-;4237:6;;;-1:-1:-1;;;;;4254:17:0;;;4237:6;4254:17;;;-1:-1:-1;;;;;;4254:17:0;;;;;;4287:40;;4237:6;;;;;;;;4287:40;;4218:16;;4287:40;4207:128;4144:191;:::o;63108:118::-;62071:19;:17;:19::i;:::-;63168:7:::1;:14:::0;;-1:-1:-1;;63168:14:0::1;63178:4;63168:14;::::0;;63198:20:::1;63205:12;865:10:::0;;785:98;84299:152;84373:70;84435:2;84439;84389:53;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;84389:53:0;;;;;;;;;;;;;;-1:-1:-1;;;;;84389:53:0;-1:-1:-1;;;84389:53:0;;;84373:15;:70::i;57428:318::-;-1:-1:-1;;;;;57536:22:0;;57532:93;;57582:31;;-1:-1:-1;;;57582:31:0;;-1:-1:-1;;;;;1697:32:1;;57582:31:0;;;1679:51:1;1652:18;;57582:31:0;1533:203:1;57532:93:0;-1:-1:-1;;;;;57635:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;57635:46:0;;;;;;;;;;57697:41;;540::1;;;57697::0;;513:18:1;57697:41:0;;;;;;;57428:318;;;:::o;58786:799::-;-1:-1:-1;;;;;58903:14:0;;;:18;58899:679;;58942:71;;-1:-1:-1;;;58942:71:0;;-1:-1:-1;;;;;58942:36:0;;;;;:71;;865:10;;58993:4;;58999:7;;59008:4;;58942:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58942:71:0;;;;;;;;-1:-1:-1;;58942:71:0;;;;;;;;;;;;:::i;:::-;;;58938:629;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59256:6;:13;59273:1;59256:18;59252:300;;59306:25;;-1:-1:-1;;;59306:25:0;;-1:-1:-1;;;;;1697:32:1;;59306:25:0;;;1679:51:1;1652:18;;59306:25:0;1533:203:1;59252:300:0;59502:6;59496:13;59487:6;59483:2;59479:15;59472:38;58938:629;-1:-1:-1;;;;;;59061:51:0;;-1:-1:-1;;;59061:51:0;59057:132;;59144:25;;-1:-1:-1;;;59144:25:0;;-1:-1:-1;;;;;1697:32:1;;59144:25:0;;;1679:51:1;1652:18;;59144:25:0;1533:203:1;59057:132:0;59014:190;58786:799;;;;:::o;66015:609::-;66088:13;66114:22;66128:7;66114:13;:22::i;:::-;-1:-1:-1;66149:23:0;66175:19;;;:10;:19;;;;;66149:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66205:18;66226:10;:8;:10::i;:::-;66205:31;;66318:4;66312:18;66334:1;66312:23;66308:72;;-1:-1:-1;66359:9:0;66015:609;-1:-1:-1;;66015:609:0:o;66308:72::-;66481:23;;:27;66477:97;;66546:4;66552:9;66532:30;;;;;;;;;:::i;:::-;;;;;;;;;;;;;66525:37;;;;66015:609;;;:::o;66477:97::-;66593:23;66608:7;66593:14;:23::i;68578:340::-;68688:6;68664:21;:30;68660:111;;;68718:41;;-1:-1:-1;;;68718:41:0;;68753:4;68718:41;;;1679:51:1;1652:18;;68718:41:0;1533:203:1;68660:111:0;68784:12;68802:9;-1:-1:-1;;;;;68802:14:0;68824:6;68802:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68783:52;;;68851:7;68846:65;;68882:17;;-1:-1:-1;;;68882:17:0;;;;;;;;;;;43011:305;43113:4;-1:-1:-1;;;;;;43150:40:0;;-1:-1:-1;;;43150:40:0;;:105;;-1:-1:-1;;;;;;;43207:48:0;;-1:-1:-1;;;43207:48:0;43150:105;:158;;;-1:-1:-1;;;;;;;;;;21456:40:0;;;43272:36;21356:148;56531:678;56693:9;:31;;;-1:-1:-1;;;;;;56706:18:0;;;;56693:31;56689:471;;;56741:13;56757:22;56771:7;56757:13;:22::i;:::-;56741:38;-1:-1:-1;;;;;;56910:18:0;;;;;;:35;;;56941:4;-1:-1:-1;;;;;56932:13:0;:5;-1:-1:-1;;;;;56932:13:0;;;56910:35;:69;;;;;56950:29;56967:5;56974:4;56950:16;:29::i;:::-;56949:30;56910:69;56906:144;;;57007:27;;-1:-1:-1;;;57007:27:0;;-1:-1:-1;;;;;1697:32:1;;57007:27:0;;;1679:51:1;1652:18;;57007:27:0;1533:203:1;56906:144:0;57070:9;57066:83;;;57125:7;57121:2;-1:-1:-1;;;;;57105:28:0;57114:5;-1:-1:-1;;;;;57105:28:0;;;;;;;;;;;57066:83;56726:434;56689:471;-1:-1:-1;;57172:24:0;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;57172:29:0;-1:-1:-1;;;;;57172:29:0;;;;;;;;;;56531:678::o;77786:131::-;77858:51;77901:7;77870:29;77858:51::i;52340:102::-;52408:26;52418:2;52422:7;52408:26;;;;;;;;;;;;:9;:26::i;84144:147::-;84212:71;84275:2;84279;84228:54;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;84228:54:0;;;;;;;;;;;;;;-1:-1:-1;;;;;84228:54:0;-1:-1:-1;;;84228:54:0;;;84212:15;:71::i;64654:210::-;64797:7;62071:19;:17;:19::i;:::-;64824:32:::1;64838:2;64842:7;64851:4;64824:13;:32::i;62834:130::-:0;62537:7;;;;62893:64;;62930:15;;-1:-1:-1;;;62930:15:0;;;;;;;;;;;62625:132;62537:7;;;;62687:63;;;62723:15;;-1:-1:-1;;;62723:15:0;;;;;;;;;;;148609:294;148661:13;148719:1;148697:11;148691:25;;;;;:::i;:::-;;;:29;148687:133;;;148737:38;;;;;;;;;;;;;;-1:-1:-1;;;148737:38:0;;;:11;:38::i;:::-;148797:11;148790:18;;;;;:::i;148687:133::-;148830:38;;;;;;;;;;;;;;-1:-1:-1;;;148830:38:0;;;:11;:38::i;:::-;-1:-1:-1;148879:16:0;;;;;;;;;;;;-1:-1:-1;;;148879:16:0;;;;;148609:294::o;44168:260::-;44232:13;44258:22;44272:7;44258:13;:22::i;:::-;;44293:21;44317:10;:8;:10::i;:::-;44293:34;;44369:1;44351:7;44345:21;:25;:75;;;;;;;;;;;;;;;;;44387:7;44396:18;:7;:16;:18::i;:::-;44373:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44338:82;44168:260;-1:-1:-1;;;44168:260:0:o;77090:478::-;77176:22;77039:42;77176:40;;77515:1;77491;77460:7;77454:14;77428:2;77419:7;77415:16;77378:14;77350:5;77317:218;77295:255;77280:281;77090:478;:::o;52669:185::-;52764:18;52770:2;52774:7;52764:5;:18::i;:::-;52793:53;52824:1;52828:2;52832:7;52841:4;52793:22;:53::i;50482:824::-;50568:7;47375:16;;;:7;:16;;;;;;-1:-1:-1;;;;;47375:16:0;;;;50683:18;;;50679:88;;50718:37;50735:4;50741;50747:7;50718:16;:37::i;:::-;-1:-1:-1;;;;;50814:18:0;;;50810:263;;50932:48;50949:1;50953:7;50970:1;50974:5;50932:8;:48::i;:::-;-1:-1:-1;;;;;51026:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;51026:20:0;;;50810:263;-1:-1:-1;;;;;51089:16:0;;;51085:111;;-1:-1:-1;;;;;51151:13:0;;;;;;:9;:13;;;;;:18;;51168:1;51151:18;;;51085:111;51208:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;51208:21:0;-1:-1:-1;;;;;51208:21:0;;;;;;;;;51247:27;;51208:16;;51247:27;;;;;;;51294:4;50482:824;-1:-1:-1;;;;50482:824:0:o;83168:123::-;83224:59;83279:2;83240:42;;;;;;;;:::i;:::-;;;;-1:-1:-1;;83240:42:0;;;;;;;;;;;;;;-1:-1:-1;;;;;83240:42:0;-1:-1:-1;;;83240:42:0;;;83224:15;:59::i;39175:718::-;39231:13;39282:14;39299:17;39310:5;39299:10;:17::i;:::-;39319:1;39299:21;39282:38;;39335:20;39369:6;39358:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39358:18:0;-1:-1:-1;39335:41:0;-1:-1:-1;39500:28:0;;;39516:2;39500:28;39557:290;-1:-1:-1;;39589:5:0;-1:-1:-1;;;39726:2:0;39715:14;;39710:32;39589:5;39697:46;39789:2;39780:11;;;-1:-1:-1;39810:21:0;39557:290;39810:21;-1:-1:-1;39868:6:0;39175:718;-1:-1:-1;;;39175:718:0:o;51642:335::-;-1:-1:-1;;;;;51710:16:0;;51706:89;;51750:33;;-1:-1:-1;;;51750:33:0;;51780:1;51750:33;;;1679:51:1;1652:18;;51750:33:0;1533:203:1;51706:89:0;51805:21;51829:32;51837:2;51841:7;51858:1;51829:7;:32::i;:::-;51805:56;-1:-1:-1;;;;;;51876:27:0;;;51872:98;;51927:31;;-1:-1:-1;;;51927:31:0;;51955:1;51927:31;;;1679:51:1;1652:18;;51927:31:0;1533:203:1;48689:376:0;48802:38;48816:5;48823:7;48832;48802:13;:38::i;:::-;48797:261;;-1:-1:-1;;;;;48861:19:0;;48857:190;;48908:31;;-1:-1:-1;;;48908:31:0;;;;;2324:25:1;;;2297:18;;48908:31:0;2178:177:1;48857:190:0;48987:44;;-1:-1:-1;;;48987:44:0;;-1:-1:-1;;;;;12954:32:1;;48987:44:0;;;12936:51:1;13003:18;;;12996:34;;;12909:18;;48987:44:0;12762:274:1;34127:948:0;34180:7;;-1:-1:-1;;;34258:17:0;;34254:106;;-1:-1:-1;;;34296:17:0;;;-1:-1:-1;34342:2:0;34332:12;34254:106;34387:8;34378:5;:17;34374:106;;34425:8;34416:17;;;-1:-1:-1;34462:2:0;34452:12;34374:106;34507:8;34498:5;:17;34494:106;;34545:8;34536:17;;;-1:-1:-1;34582:2:0;34572:12;34494:106;34627:7;34618:5;:16;34614:103;;34664:7;34655:16;;;-1:-1:-1;34700:1:0;34690:11;34614:103;34744:7;34735:5;:16;34731:103;;34781:7;34772:16;;;-1:-1:-1;34817:1:0;34807:11;34731:103;34861:7;34852:5;:16;34848:103;;34898:7;34889:16;;;-1:-1:-1;34934:1:0;34924:11;34848:103;34978:7;34969:5;:16;34965:68;;35016:1;35006:11;35061:6;34127:948;-1:-1:-1;;34127:948:0:o;47969:276::-;48072:4;-1:-1:-1;;;;;48109:21:0;;;;;;:128;;;48157:7;-1:-1:-1;;;;;48148:16:0;:5;-1:-1:-1;;;;;48148:16:0;;:52;;;;48168:32;48185:5;48192:7;48168:16;:32::i;:::-;48148:88;;;-1:-1:-1;;47590:7:0;47617:24;;;:15;:24;;;;;;-1:-1:-1;;;;;47617:24:0;;;48204:32;;;;;-1:-1:-1;47969:276:0: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:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1919:254;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2360:328::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2545:29;2564:9;2545:29;:::i;:::-;2535:39;;2593:38;2627:2;2616:9;2612:18;2593:38;:::i;:::-;2583:48;;2678:2;2667:9;2663:18;2650:32;2640:42;;2360:328;;;;;:::o;2693:186::-;2752:6;2805:2;2793:9;2784:7;2780:23;2776:32;2773:52;;;2821:1;2818;2811:12;2773:52;2844:29;2863:9;2844:29;:::i;2884:127::-;2945:10;2940:3;2936:20;2933:1;2926:31;2976:4;2973:1;2966:15;3000:4;2997:1;2990:15;3016:632;3081:5;3111:18;3152:2;3144:6;3141:14;3138:40;;;3158:18;;:::i;:::-;3233:2;3227:9;3201:2;3287:15;;-1:-1:-1;;3283:24:1;;;3309:2;3279:33;3275:42;3263:55;;;3333:18;;;3353:22;;;3330:46;3327:72;;;3379:18;;:::i;:::-;3419:10;3415:2;3408:22;3448:6;3439:15;;3478:6;3470;3463:22;3518:3;3509:6;3504:3;3500:16;3497:25;3494:45;;;3535:1;3532;3525:12;3494:45;3585:6;3580:3;3573:4;3565:6;3561:17;3548:44;3640:1;3633:4;3624:6;3616;3612:19;3608:30;3601:41;;;;3016:632;;;;;:::o;3653:222::-;3696:5;3749:3;3742:4;3734:6;3730:17;3726:27;3716:55;;3767:1;3764;3757:12;3716:55;3789:80;3865:3;3856:6;3843:20;3836:4;3828:6;3824:17;3789:80;:::i;3880:543::-;3968:6;3976;4029:2;4017:9;4008:7;4004:23;4000:32;3997:52;;;4045:1;4042;4035:12;3997:52;4085:9;4072:23;4114:18;4155:2;4147:6;4144:14;4141:34;;;4171:1;4168;4161:12;4141:34;4194:50;4236:7;4227:6;4216:9;4212:22;4194:50;:::i;:::-;4184:60;;4297:2;4286:9;4282:18;4269:32;4253:48;;4326:2;4316:8;4313:16;4310:36;;;4342:1;4339;4332:12;4310:36;;4365:52;4409:7;4398:8;4387:9;4383:24;4365:52;:::i;:::-;4355:62;;;3880:543;;;;;:::o;4428:322::-;4497:6;4550:2;4538:9;4529:7;4525:23;4521:32;4518:52;;;4566:1;4563;4556:12;4518:52;4606:9;4593:23;4639:18;4631:6;4628:30;4625:50;;;4671:1;4668;4661:12;4625:50;4694;4736:7;4727:6;4716:9;4712:22;4694:50;:::i;4755:347::-;4820:6;4828;4881:2;4869:9;4860:7;4856:23;4852:32;4849:52;;;4897:1;4894;4887:12;4849:52;4920:29;4939:9;4920:29;:::i;:::-;4910:39;;4999:2;4988:9;4984:18;4971:32;5046:5;5039:13;5032:21;5025:5;5022:32;5012:60;;5068:1;5065;5058:12;5012:60;5091:5;5081:15;;;4755:347;;;;;:::o;5107:667::-;5202:6;5210;5218;5226;5279:3;5267:9;5258:7;5254:23;5250:33;5247:53;;;5296:1;5293;5286:12;5247:53;5319:29;5338:9;5319:29;:::i;:::-;5309:39;;5367:38;5401:2;5390:9;5386:18;5367:38;:::i;:::-;5357:48;;5452:2;5441:9;5437:18;5424:32;5414:42;;5507:2;5496:9;5492:18;5479:32;5534:18;5526:6;5523:30;5520:50;;;5566:1;5563;5556:12;5520:50;5589:22;;5642:4;5634:13;;5630:27;-1:-1:-1;5620:55:1;;5671:1;5668;5661:12;5620:55;5694:74;5760:7;5755:2;5742:16;5737:2;5733;5729:11;5694:74;:::i;:::-;5684:84;;;5107:667;;;;;;;:::o;5779:533::-;5875:6;5883;5891;5899;5952:3;5940:9;5931:7;5927:23;5923:33;5920:53;;;5969:1;5966;5959:12;5920:53;6009:9;5996:23;6042:18;6034:6;6031:30;6028:50;;;6074:1;6071;6064:12;6028:50;6097;6139:7;6130:6;6119:9;6115:22;6097:50;:::i;:::-;6087:60;;;6166:38;6200:2;6189:9;6185:18;6166:38;:::i;:::-;5779:533;;6156:48;;-1:-1:-1;;;;6251:2:1;6236:18;;6223:32;;6302:2;6287:18;6274:32;;5779:533::o;6317:260::-;6385:6;6393;6446:2;6434:9;6425:7;6421:23;6417:32;6414:52;;;6462:1;6459;6452:12;6414:52;6485:29;6504:9;6485:29;:::i;:::-;6475:39;;6533:38;6567:2;6556:9;6552:18;6533:38;:::i;:::-;6523:48;;6317:260;;;;;:::o;6582:380::-;6661:1;6657:12;;;;6704;;;6725:61;;6779:4;6771:6;6767:17;6757:27;;6725:61;6832:2;6824:6;6821:14;6801:18;6798:38;6795:161;;6878:10;6873:3;6869:20;6866:1;6859:31;6913:4;6910:1;6903:15;6941:4;6938:1;6931:15;6795:161;;6582:380;;;:::o;7347:127::-;7408:10;7403:3;7399:20;7396:1;7389:31;7439:4;7436:1;7429:15;7463:4;7460:1;7453:15;7479:135;7518:3;7539:17;;;7536:43;;7559:18;;:::i;:::-;-1:-1:-1;7606:1:1;7595:13;;7479:135::o;7619:168::-;7692:9;;;7723;;7740:15;;;7734:22;;7720:37;7710:71;;7761:18;;:::i;7792:128::-;7859:9;;;7880:11;;;7877:37;;;7894:18;;:::i;8051:543::-;8153:2;8148:3;8145:11;8142:446;;;8189:1;8213:5;8210:1;8203:16;8257:4;8254:1;8244:18;8327:2;8315:10;8311:19;8308:1;8304:27;8298:4;8294:38;8363:4;8351:10;8348:20;8345:47;;;-1:-1:-1;8386:4:1;8345:47;8441:2;8436:3;8432:12;8429:1;8425:20;8419:4;8415:31;8405:41;;8496:82;8514:2;8507:5;8504:13;8496:82;;;8559:17;;;8540:1;8529:13;8496:82;;;8500:3;;;8051:543;;;:::o;8770:1345::-;8896:3;8890:10;8923:18;8915:6;8912:30;8909:56;;;8945:18;;:::i;:::-;8974:97;9064:6;9024:38;9056:4;9050:11;9024:38;:::i;:::-;9018:4;8974:97;:::i;:::-;9126:4;;9183:2;9172:14;;9200:1;9195:663;;;;9902:1;9919:6;9916:89;;;-1:-1:-1;9971:19:1;;;9965:26;9916:89;-1:-1:-1;;8727:1:1;8723:11;;;8719:24;8715:29;8705:40;8751:1;8747:11;;;8702:57;10018:81;;9165:944;;9195:663;7998:1;7991:14;;;8035:4;8022:18;;-1:-1:-1;;9231:20:1;;;9349:236;9363:7;9360:1;9357:14;9349:236;;;9452:19;;;9446:26;9431:42;;9544:27;;;;9512:1;9500:14;;;;9379:19;;9349:236;;;9353:3;9613:6;9604:7;9601:19;9598:201;;;9674:19;;;9668:26;-1:-1:-1;;9757:1:1;9753:14;;;9769:3;9749:24;9745:37;9741:42;9726:58;9711:74;;9598:201;-1:-1:-1;;;;;9845:1:1;9829:14;;;9825:22;9812:36;;-1:-1:-1;8770:1345:1:o;10120:362::-;10325:2;10314:9;10307:21;10288:4;10345:45;10386:2;10375:9;10371:18;10363:6;10345:45;:::i;:::-;10421:2;10406:18;;10399:34;;;;-1:-1:-1;10464:2:1;10449:18;10442:34;10337:53;10120:362;-1:-1:-1;10120:362:1:o;10487:383::-;10684:2;10673:9;10666:21;10647:4;10710:45;10751:2;10740:9;10736:18;10728:6;10710:45;:::i;:::-;10803:9;10795:6;10791:22;10786:2;10775:9;10771:18;10764:50;10831:33;10857:6;10849;10831:33;:::i;:::-;10823:41;10487:383;-1:-1:-1;;;;;10487:383:1:o;10875:489::-;-1:-1:-1;;;;;11144:15:1;;;11126:34;;11196:15;;11191:2;11176:18;;11169:43;11243:2;11228:18;;11221:34;;;11291:3;11286:2;11271:18;;11264:31;;;11069:4;;11312:46;;11338:19;;11330:6;11312:46;:::i;:::-;11304:54;10875:489;-1:-1:-1;;;;;;10875:489:1:o;11369:249::-;11438:6;11491:2;11479:9;11470:7;11466:23;11462:32;11459:52;;;11507:1;11504;11497:12;11459:52;11539:9;11533:16;11558:30;11582:5;11558:30;:::i;11623:496::-;11802:3;11840:6;11834:13;11856:66;11915:6;11910:3;11903:4;11895:6;11891:17;11856:66;:::i;:::-;11985:13;;11944:16;;;;12007:70;11985:13;11944:16;12054:4;12042:17;;12007:70;:::i;:::-;12093:20;;11623:496;-1:-1:-1;;;;11623:496:1:o;12334:291::-;12511:2;12500:9;12493:21;12474:4;12531:45;12572:2;12561:9;12557:18;12549:6;12531:45;:::i;:::-;12523:53;;12612:6;12607:2;12596:9;12592:18;12585:34;12334:291;;;;;:::o

Swarm Source

ipfs://3abf46d63a7c8310c140c99f6c74de929d3b94653813756442625f4f04945b4b
[ Download: CSV Export  ]

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.