Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _nonReentrantBefore()    - function _nonReentrantAfter()    - function _reentrancyGuardEntered() interface IERC20Errors interface IERC721Errors interface IERC1155Errors library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function _msgSender()    - function _msgData()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC721Receiver    - function onERC721Received( interface IERC165    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(address fro ...    - function safeTransferFrom(address fro ...    - function transferFrom(address from, a ...    - function approve(address to, uint256 ...    - function setApprovalForAll(address op ...    - function getApproved(uint256 tokenId)    - function isApprovedForAll(address own ... interface IERC721Metadata is IERC721    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function supportsInterface(bytes4 int ...    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _baseURI()    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function transferFrom(address from, a ...    - function safeTransferFrom(address fro ...    - function safeTransferFrom(address fro ...    - function _ownerOf(uint256 tokenId)    - function _getApproved(uint256 tokenId ...    - function _isAuthorized(address owner, ...    - function _checkAuthorized(address own ...    - function _increaseBalance(address acc ...    - function _update(address to, uint256 ...    - function _mint(address to, uint256 to ...    - function _safeMint(address to, uint25 ...    - function _safeMint(address to, uint25 ...    - function _burn(uint256 tokenId)    - function _transfer(address from, addr ...    - function _safeTransfer(address from, ...    - function _safeTransfer(address from, ...    - function _approve(address to, uint256 ...    - function _approve(address to, uint256 ...    - function _setApprovalForAll(address o ...    - function _requireOwned(uint256 tokenI ...    - function _checkOnERC721Received(addre ...  contract GrokPunks is ERC721, Owna ... *    - function mint(uint8 _amount)    - function airdrop(address _address, ui ...    - function setMaxMintAmount(uint8 _maxM ...    - function _baseURI()    - function setBaseURI(string calldata b ...    - function togglePaused()    - function setCost(uint256 _newCost)    - function withdraw()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-11-30
*/

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

// 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: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// 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/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && 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 down.
     *
     * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


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

    /**
     * @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), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @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) {
        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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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);
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

    /**
     * @dev 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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// 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/IERC165.sol


// 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/utils/introspection/ERC165.sol


// 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/token/ERC721/IERC721.sol


// 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/token/ERC721/extensions/IERC721Metadata.sol


// 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/ERC721.sol


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

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

contract GrokPunks is ERC721, Ownable, ReentrancyGuard {
    using Strings for uint256;

    error MaxSupplyExceeded();
    error MaxPerWalletExceeded();
    error InsufficientValue();
    error saleNotActive();
    error NoContracts();

    uint256 public cost = 0.005 ether;
    uint256 public maxSupply = 3000;
    uint256 public tokenCount = 0;
    uint256 public maxMintAmount = 6;
    string private _baseTokenURI =
        "ipfs://Qme4n6LpUjJPSrqBgXMaGNxhprgdJi6rmhYX7pfQ8xHf8b/";
    bool public paused;

    mapping(address => uint256) public addressMintedBalance;

    constructor() ERC721("GrokPunks", "GrokPunks") {}

    modifier callerIsUser() {
        if (msg.sender != tx.origin) revert NoContracts();
        _;
    }

    function mint(uint8 _amount) external payable callerIsUser {
        if (!paused) revert saleNotActive();
        if (tokenCount + _amount > maxSupply) revert MaxSupplyExceeded();
        if (addressMintedBalance[msg.sender] + _amount > maxMintAmount)
            revert MaxPerWalletExceeded();

        if (addressMintedBalance[msg.sender] < 1) {
            if (msg.value != cost * (_amount - 1)) revert InsufficientValue();
        } else {
            if (msg.value != cost * _amount) revert InsufficientValue();
        }

        for (uint256 i = 1; i <= _amount; i++) {
            addressMintedBalance[msg.sender]++;
            _safeMint(msg.sender, ++tokenCount);
        }
    }

    function airdrop(address _address, uint256 _amount) external onlyOwner {
        if (tokenCount + _amount > maxSupply) revert MaxSupplyExceeded();
        for (uint256 i = 1; i <= _amount; i++) {
            addressMintedBalance[msg.sender]++;
            _safeMint(_address, ++tokenCount);
        }
    }

    function setMaxMintAmount(uint8 _maxMintAmount) external onlyOwner {
        maxMintAmount = _maxMintAmount;
    }

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

    function setBaseURI(string calldata baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    function togglePaused() external onlyOwner {
        paused = !paused;
    }

    function setCost(uint256 _newCost) external onlyOwner {
        cost = _newCost;
    }

    function withdraw() external onlyOwner nonReentrant {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":"InsufficientValue","type":"error"},{"inputs":[],"name":"MaxPerWalletExceeded","type":"error"},{"inputs":[],"name":"MaxSupplyExceeded","type":"error"},{"inputs":[],"name":"NoContracts","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"saleNotActive","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressMintedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"_amount","type":"uint8"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_maxMintAmount","type":"uint8"}],"name":"setMaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"togglePaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x6080604052600436106101ba575f3560e01c80636352211e116100f25780639f181b5e11610092578063d5abeb0111610062578063d5abeb01146104b2578063e985e9c5146104c7578063f2fde38b146104e6578063fd46d78714610505575f80fd5b80639f181b5e14610440578063a22cb46514610455578063b88d4fde14610474578063c87b56dd14610493575f80fd5b8063715018a6116100cd578063715018a6146103dc5780638ba4cc3c146103f05780638da5cb5b1461040f57806395d89b411461042c575f80fd5b80636352211e1461038b5780636ecd2306146103aa57806370a08231146103bd575f80fd5b806323b872dd1161015d57806342842e0e1161013857806342842e0e1461031557806344a0d68a1461033457806355f804b3146103535780635c975abb14610372575f80fd5b806323b872dd146102ce57806336566f06146102ed5780633ccfd60b14610301575f80fd5b8063095ea7b311610198578063095ea7b31461024a57806313faede61461026b57806318cae2691461028e578063239c70ae146102b9575f80fd5b806301ffc9a7146101be57806306fdde03146101f2578063081812fc14610213575b5f80fd5b3480156101c9575f80fd5b506101dd6101d83660046112ec565b610524565b60405190151581526020015b60405180910390f35b3480156101fd575f80fd5b50610206610575565b6040516101e99190611354565b34801561021e575f80fd5b5061023261022d366004611366565b610604565b6040516001600160a01b0390911681526020016101e9565b348015610255575f80fd5b50610269610264366004611398565b61062b565b005b348015610276575f80fd5b5061028060085481565b6040519081526020016101e9565b348015610299575f80fd5b506102806102a83660046113c0565b600e6020525f908152604090205481565b3480156102c4575f80fd5b50610280600b5481565b3480156102d9575f80fd5b506102696102e83660046113d9565b61063a565b3480156102f8575f80fd5b506102696106c8565b34801561030c575f80fd5b506102696106e4565b348015610320575f80fd5b5061026961032f3660046113d9565b61072e565b34801561033f575f80fd5b5061026961034e366004611366565b61074d565b34801561035e575f80fd5b5061026961036d366004611412565b61075a565b34801561037d575f80fd5b50600d546101dd9060ff1681565b348015610396575f80fd5b506102326103a5366004611366565b61076f565b6102696103b836600461147e565b610779565b3480156103c8575f80fd5b506102806103d73660046113c0565b61090e565b3480156103e7575f80fd5b50610269610953565b3480156103fb575f80fd5b5061026961040a366004611398565b610964565b34801561041a575f80fd5b506006546001600160a01b0316610232565b348015610437575f80fd5b506102066109e9565b34801561044b575f80fd5b50610280600a5481565b348015610460575f80fd5b5061026961046f36600461149e565b6109f8565b34801561047f575f80fd5b5061026961048e3660046114eb565b610a03565b34801561049e575f80fd5b506102066104ad366004611366565b610a1a565b3480156104bd575f80fd5b5061028060095481565b3480156104d2575f80fd5b506101dd6104e13660046115c0565b610a7f565b3480156104f1575f80fd5b506102696105003660046113c0565b610aac565b348015610510575f80fd5b5061026961051f36600461147e565b610b25565b5f6001600160e01b031982166380ac58cd60e01b148061055457506001600160e01b03198216635b5e139f60e01b145b8061056f57506301ffc9a760e01b6001600160e01b03198316145b92915050565b60605f8054610583906115f1565b80601f01602080910402602001604051908101604052809291908181526020018280546105af906115f1565b80156105fa5780601f106105d1576101008083540402835291602001916105fa565b820191905f5260205f20905b8154815290600101906020018083116105dd57829003601f168201915b5050505050905090565b5f61060e82610b35565b505f828152600460205260409020546001600160a01b031661056f565b610636828233610b6d565b5050565b6001600160a01b03821661066857604051633250574960e11b81525f60048201526024015b60405180910390fd5b5f610674838333610b7a565b9050836001600160a01b0316816001600160a01b0316146106c2576040516364283d7b60e01b81526001600160a01b038086166004830152602482018490528216604482015260640161065f565b50505050565b6106d0610c6c565b600d805460ff19811660ff90911615179055565b6106ec610c6c565b6106f4610cc6565b6040514790339082156108fc029083905f818181858888f19350505050158015610720573d5f803e3d5ffd5b505061072c6001600755565b565b61074883838360405180602001604052805f815250610a03565b505050565b610755610c6c565b600855565b610762610c6c565b600c61074882848361166d565b5f61056f82610b35565b3332146107995760405163875fdad760e01b815260040160405180910390fd5b600d5460ff166107bc5760405163309ad67f60e11b815260040160405180910390fd5b6009548160ff16600a546107d0919061173b565b11156107ef57604051638a164f6360e01b815260040160405180910390fd5b600b54335f908152600e602052604090205461080f9060ff84169061173b565b111561082e57604051637ab0312d60e11b815260040160405180910390fd5b335f908152600e6020526040902054600111156108845761085060018261174e565b60ff166008546108609190611767565b341461087f5760405163044044a560e21b815260040160405180910390fd5b6108b4565b8060ff166008546108959190611767565b34146108b45760405163044044a560e21b815260040160405180910390fd5b60015b8160ff16811161063657335f908152600e602052604081208054916108db8361177e565b91905055506108fc33600a5f81546108f29061177e565b9182905550610cf0565b806109068161177e565b9150506108b7565b5f6001600160a01b038216610938576040516322718ad960e21b81525f600482015260240161065f565b506001600160a01b03165f9081526003602052604090205490565b61095b610c6c565b61072c5f610d09565b61096c610c6c565b60095481600a5461097d919061173b565b111561099c57604051638a164f6360e01b815260040160405180910390fd5b60015b81811161074857335f908152600e602052604081208054916109c08361177e565b91905055506109d783600a5f81546108f29061177e565b806109e18161177e565b91505061099f565b606060018054610583906115f1565b610636338383610d5a565b610a0e84848461063a565b6106c284848484610df8565b6060610a2582610b35565b505f610a2f610f1e565b90505f815111610a4d5760405180602001604052805f815250610a78565b80610a5784610f2d565b604051602001610a68929190611796565b6040516020818303038152906040525b9392505050565b6001600160a01b039182165f90815260056020908152604080832093909416825291909152205460ff1690565b610ab4610c6c565b6001600160a01b038116610b195760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161065f565b610b2281610d09565b50565b610b2d610c6c565b60ff16600b55565b5f818152600260205260408120546001600160a01b03168061056f57604051637e27328960e01b81526004810184905260240161065f565b6107488383836001610fbd565b5f828152600260205260408120546001600160a01b0390811690831615610ba657610ba68184866110c1565b6001600160a01b03811615610be057610bc15f855f80610fbd565b6001600160a01b0381165f90815260036020526040902080545f190190555b6001600160a01b03851615610c0e576001600160a01b0385165f908152600360205260409020805460010190555b5f8481526002602052604080822080546001600160a01b0319166001600160a01b0389811691821790925591518793918516917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4949350505050565b6006546001600160a01b0316331461072c5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161065f565b600260075403610ce957604051633ee5aeb560e01b815260040160405180910390fd5b6002600755565b610636828260405180602001604052805f815250611125565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b6001600160a01b038216610d8c57604051630b61174360e31b81526001600160a01b038316600482015260240161065f565b6001600160a01b038381165f81815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6001600160a01b0383163b156106c257604051630a85bd0160e11b81526001600160a01b0384169063150b7a0290610e3a9033908890879087906004016117c4565b6020604051808303815f875af1925050508015610e74575060408051601f3d908101601f19168201909252610e7191810190611800565b60015b610edb573d808015610ea1576040519150601f19603f3d011682016040523d82523d5f602084013e610ea6565b606091505b5080515f03610ed357604051633250574960e11b81526001600160a01b038516600482015260240161065f565b805181602001fd5b6001600160e01b03198116630a85bd0160e11b14610f1757604051633250574960e11b81526001600160a01b038516600482015260240161065f565b5050505050565b6060600c8054610583906115f1565b60605f610f398361113b565b60010190505f8167ffffffffffffffff811115610f5857610f586114d7565b6040519080825280601f01601f191660200182016040528015610f82576020820181803683370190505b5090508181016020015b5f19016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a8504945084610f8c57509392505050565b8080610fd157506001600160a01b03821615155b15611092575f610fe084610b35565b90506001600160a01b0383161580159061100c5750826001600160a01b0316816001600160a01b031614155b801561101f575061101d8184610a7f565b155b156110485760405163a9fbf51f60e01b81526001600160a01b038416600482015260240161065f565b81156110905783856001600160a01b0316826001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45b505b50505f90815260046020526040902080546001600160a01b0319166001600160a01b0392909216919091179055565b6110cc838383611212565b610748576001600160a01b0383166110fa57604051637e27328960e01b81526004810182905260240161065f565b60405163177e802f60e01b81526001600160a01b03831660048201526024810182905260440161065f565b61112f8383611276565b6107485f848484610df8565b5f8072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106111795772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef810000000083106111a5576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc1000083106111c357662386f26fc10000830492506010015b6305f5e10083106111db576305f5e100830492506008015b61271083106111ef57612710830492506004015b60648310611201576064830492506002015b600a831061056f5760010192915050565b5f6001600160a01b0383161580159061126e5750826001600160a01b0316846001600160a01b0316148061124b575061124b8484610a7f565b8061126e57505f828152600460205260409020546001600160a01b038481169116145b949350505050565b6001600160a01b03821661129f57604051633250574960e11b81525f600482015260240161065f565b5f6112ab83835f610b7a565b90506001600160a01b03811615610748576040516339e3563760e11b81525f600482015260240161065f565b6001600160e01b031981168114610b22575f80fd5b5f602082840312156112fc575f80fd5b8135610a78816112d7565b5f5b83811015611321578181015183820152602001611309565b50505f910152565b5f8151808452611340816020860160208601611307565b601f01601f19169290920160200192915050565b602081525f610a786020830184611329565b5f60208284031215611376575f80fd5b5035919050565b80356001600160a01b0381168114611393575f80fd5b919050565b5f80604083850312156113a9575f80fd5b6113b28361137d565b946020939093013593505050565b5f602082840312156113d0575f80fd5b610a788261137d565b5f805f606084860312156113eb575f80fd5b6113f48461137d565b92506114026020850161137d565b9150604084013590509250925092565b5f8060208385031215611423575f80fd5b823567ffffffffffffffff8082111561143a575f80fd5b818501915085601f83011261144d575f80fd5b81358181111561145b575f80fd5b86602082850101111561146c575f80fd5b60209290920196919550909350505050565b5f6020828403121561148e575f80fd5b813560ff81168114610a78575f80fd5b5f80604083850312156114af575f80fd5b6114b88361137d565b9150602083013580151581146114cc575f80fd5b809150509250929050565b634e487b7160e01b5f52604160045260245ffd5b5f805f80608085870312156114fe575f80fd5b6115078561137d565b93506115156020860161137d565b925060408501359150606085013567ffffffffffffffff80821115611538575f80fd5b818701915087601f83011261154b575f80fd5b81358181111561155d5761155d6114d7565b604051601f8201601f19908116603f01168101908382118183101715611585576115856114d7565b816040528281528a602084870101111561159d575f80fd5b826020860160208301375f60208483010152809550505050505092959194509250565b5f80604083850312156115d1575f80fd5b6115da8361137d565b91506115e86020840161137d565b90509250929050565b600181811c9082168061160557607f821691505b60208210810361162357634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111561074857805f5260205f20601f840160051c8101602085101561164e5750805b601f840160051c820191505b81811015610f17575f815560010161165a565b67ffffffffffffffff831115611685576116856114d7565b6116998361169383546115f1565b83611629565b5f601f8411600181146116ca575f85156116b35750838201355b5f19600387901b1c1916600186901b178355610f17565b5f83815260208120601f198716915b828110156116f957868501358255602094850194600190920191016116d9565b5086821015611715575f1960f88860031b161c19848701351681555b505060018560011b0183555050505050565b634e487b7160e01b5f52601160045260245ffd5b8082018082111561056f5761056f611727565b60ff828116828216039081111561056f5761056f611727565b808202811582820484141761056f5761056f611727565b5f6001820161178f5761178f611727565b5060010190565b5f83516117a7818460208801611307565b8351908301906117bb818360208801611307565b01949350505050565b6001600160a01b03858116825284166020820152604081018390526080606082018190525f906117f690830184611329565b9695505050505050565b5f60208284031215611810575f80fd5b8151610a78816112d756fea26469706673582212202b3401632061527435f2eeccc14f5a3717e1acd662f4e8973b5e598970b7501e64736f6c63430008170033

55543:2503:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38901:305;;;;;;;;;;-1:-1:-1;38901:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;38901:305:0;;;;;;;;39732:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;40904:158::-;;;;;;;;;;-1:-1:-1;40904:158:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;40904:158:0;1533:203:1;40723:115:0;;;;;;;;;;-1:-1:-1;40723:115:0;;;;;:::i;:::-;;:::i;:::-;;55794:33;;;;;;;;;;;;;;;;;;;2324:25:1;;;2312:2;2297:18;55794:33:0;2178:177:1;56077:55:0;;;;;;;;;;-1:-1:-1;56077:55:0;;;;;:::i;:::-;;;;;;;;;;;;;;55908:32;;;;;;;;;;;;;;;;41573:588;;;;;;;;;;-1:-1:-1;41573:588:0;;;;;:::i;:::-;;:::i;57703:78::-;;;;;;;;;;;;;:::i;57885:158::-;;;;;;;;;;;;;:::i;42232:134::-;;;;;;;;;;-1:-1:-1;42232:134:0;;;;;:::i;:::-;;:::i;57789:88::-;;;;;;;;;;-1:-1:-1;57789:88:0;;;;;:::i;:::-;;:::i;57589:106::-;;;;;;;;;;-1:-1:-1;57589:106:0;;;;;:::i;:::-;;:::i;56050:18::-;;;;;;;;;;-1:-1:-1;56050:18:0;;;;;;;;39545:120;;;;;;;;;;-1:-1:-1;39545:120:0;;;;;:::i;:::-;;:::i;56310:705::-;;;;;;:::i;:::-;;:::i;39270:213::-;;;;;;;;;;-1:-1:-1;39270:213:0;;;;;:::i;:::-;;:::i;28060:103::-;;;;;;;;;;;;;:::i;57023:312::-;;;;;;;;;;-1:-1:-1;57023:312:0;;;;;:::i;:::-;;:::i;27412:87::-;;;;;;;;;;-1:-1:-1;27485:6:0;;-1:-1:-1;;;;;27485:6:0;27412:87;;39892:95;;;;;;;;;;;;;:::i;55872:29::-;;;;;;;;;;;;;;;;41134:146;;;;;;;;;;-1:-1:-1;41134:146:0;;;;;:::i;:::-;;:::i;42437:211::-;;;;;;;;;;-1:-1:-1;42437:211:0;;;;;:::i;:::-;;:::i;40058:260::-;;;;;;;;;;-1:-1:-1;40058:260:0;;;;;:::i;:::-;;:::i;55834:31::-;;;;;;;;;;;;;;;;41351:155;;;;;;;;;;-1:-1:-1;41351:155:0;;;;;:::i;:::-;;:::i;28318:201::-;;;;;;;;;;-1:-1:-1;28318:201:0;;;;;:::i;:::-;;:::i;57343:116::-;;;;;;;;;;-1:-1:-1;57343:116:0;;;;;:::i;:::-;;:::i;38901:305::-;39003:4;-1:-1:-1;;;;;;39040:40:0;;-1:-1:-1;;;39040:40:0;;:105;;-1:-1:-1;;;;;;;39097:48:0;;-1:-1:-1;;;39097:48:0;39040:105;:158;;;-1:-1:-1;;;;;;;;;;31754:40:0;;;39162:36;39020:178;38901:305;-1:-1:-1;;38901:305:0:o;39732:91::-;39777:13;39810:5;39803:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39732:91;:::o;40904:158::-;40971:7;40991:22;41005:7;40991:13;:22::i;:::-;-1:-1:-1;43480:7:0;43507:24;;;:15;:24;;;;;;-1:-1:-1;;;;;43507:24:0;41033:21;43410:129;40723:115;40795:35;40804:2;40808:7;26043:10;40795:8;:35::i;:::-;40723:115;;:::o;41573:588::-;-1:-1:-1;;;;;41668:16:0;;41664:89;;41708:33;;-1:-1:-1;;;41708:33:0;;41738:1;41708:33;;;1679:51:1;1652:18;;41708:33:0;;;;;;;;41664:89;41974:21;41998:34;42006:2;42010:7;26043:10;41998:7;:34::i;:::-;41974:58;;42064:4;-1:-1:-1;;;;;42047:21:0;:13;-1:-1:-1;;;;;42047:21:0;;42043:111;;42092:50;;-1:-1:-1;;;42092:50:0;;-1:-1:-1;;;;;6290:15:1;;;42092:50:0;;;6272:34:1;6322:18;;;6315:34;;;6385:15;;6365:18;;;6358:43;6207:18;;42092:50:0;6032:375:1;42043:111:0;41653:508;41573:588;;;:::o;57703:78::-;27298:13;:11;:13::i;:::-;57767:6:::1;::::0;;-1:-1:-1;;57757:16:0;::::1;57767:6;::::0;;::::1;57766:7;57757:16;::::0;;57703:78::o;57885:158::-;27298:13;:11;:13::i;:::-;2440:21:::1;:19;:21::i;:::-;57998:37:::2;::::0;57966:21:::2;::::0;58006:10:::2;::::0;57998:37;::::2;;;::::0;57966:21;;57948:15:::2;57998:37:::0;57948:15;57998:37;57966:21;58006:10;57998:37;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;57937:106;2484:20:::1;1775:1:::0;3026:7;:21;2843:212;2484:20:::1;57885:158::o:0;42232:134::-;42319:39;42336:4;42342:2;42346:7;42319:39;;;;;;;;;;;;:16;:39::i;:::-;42232:134;;;:::o;57789:88::-;27298:13;:11;:13::i;:::-;57854:4:::1;:15:::0;57789:88::o;57589:106::-;27298:13;:11;:13::i;:::-;57664::::1;:23;57680:7:::0;;57664:13;:23:::1;:::i;39545:120::-:0;39608:7;39635:22;39649:7;39635:13;:22::i;56310:705::-;56237:10;56251:9;56237:23;56233:49;;56269:13;;-1:-1:-1;;;56269:13:0;;;;;;;;;;;56233:49;56385:6:::1;::::0;::::1;;56380:35;;56400:15;;-1:-1:-1::0;;;56400:15:0::1;;;;;;;;;;;56380:35;56453:9;;56443:7;56430:20;;:10;;:20;;;;:::i;:::-;:32;56426:64;;;56471:19;;-1:-1:-1::0;;;56471:19:0::1;;;;;;;;;;;56426:64;56550:13;::::0;56526:10:::1;56505:32;::::0;;;:20:::1;:32;::::0;;;;;:42:::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;:58;56501:106;;;56585:22;;-1:-1:-1::0;;;56585:22:0::1;;;;;;;;;;;56501:106;56645:10;56624:32;::::0;;;:20:::1;:32;::::0;;;;;56659:1:::1;-1:-1:-1::0;56620:226:0::1;;;56702:11;56712:1;56702:7:::0;:11:::1;:::i;:::-;56694:20;;:4;;:20;;;;:::i;:::-;56681:9;:33;56677:65;;56723:19;;-1:-1:-1::0;;;56723:19:0::1;;;;;;;;;;;56677:65;56620:226;;;56799:7;56792:14;;:4;;:14;;;;:::i;:::-;56779:9;:27;56775:59;;56815:19;;-1:-1:-1::0;;;56815:19:0::1;;;;;;;;;;;56775:59;56875:1;56858:150;56883:7;56878:12;;:1;:12;56858:150;;56933:10;56912:32;::::0;;;:20:::1;:32;::::0;;;;:34;;;::::1;::::0;::::1;:::i;:::-;;;;;;56961:35;56971:10;56985;;56983:12;;;;;:::i;:::-;::::0;;;;-1:-1:-1;56961:9:0::1;:35::i;:::-;56892:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56858:150;;39270:213:::0;39333:7;-1:-1:-1;;;;;39357:19:0;;39353:89;;39400:30;;-1:-1:-1;;;39400:30:0;;39427:1;39400:30;;;1679:51:1;1652:18;;39400:30:0;1533:203:1;39353:89:0;-1:-1:-1;;;;;;39459:16:0;;;;;:9;:16;;;;;;;39270:213::o;28060:103::-;27298:13;:11;:13::i;:::-;28125:30:::1;28152:1;28125:18;:30::i;57023:312::-:0;27298:13;:11;:13::i;:::-;57132:9:::1;;57122:7;57109:10;;:20;;;;:::i;:::-;:32;57105:64;;;57150:19;;-1:-1:-1::0;;;57150:19:0::1;;;;;;;;;;;57105:64;57197:1;57180:148;57205:7;57200:1;:12;57180:148;;57255:10;57234:32;::::0;;;:20:::1;:32;::::0;;;;:34;;;::::1;::::0;::::1;:::i;:::-;;;;;;57283:33;57293:8;57305:10;;57303:12;;;;;:::i;57283:33::-;57214:3:::0;::::1;::::0;::::1;:::i;:::-;;;;57180:148;;39892:95:::0;39939:13;39972:7;39965:14;;;;;:::i;41134:146::-;41220:52;26043:10;41253:8;41263;41220:18;:52::i;42437:211::-;42551:31;42564:4;42570:2;42574:7;42551:12;:31::i;:::-;42593:47;42616:4;42622:2;42626:7;42635:4;42593:22;:47::i;40058:260::-;40122:13;40148:22;40162:7;40148:13;:22::i;:::-;;40183:21;40207:10;:8;:10::i;:::-;40183:34;;40259:1;40241:7;40235:21;:25;:75;;;;;;;;;;;;;;;;;40277:7;40286:18;:7;:16;:18::i;:::-;40263:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;40235:75;40228:82;40058:260;-1:-1:-1;;;40058:260:0:o;41351:155::-;-1:-1:-1;;;;;41463:25:0;;;41439:4;41463:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;41351:155::o;28318:201::-;27298:13;:11;:13::i;:::-;-1:-1:-1;;;;;28407:22:0;::::1;28399:73;;;::::0;-1:-1:-1;;;28399:73:0;;9869:2:1;28399:73:0::1;::::0;::::1;9851:21:1::0;9908:2;9888:18;;;9881:30;9947:34;9927:18;;;9920:62;-1:-1:-1;;;9998:18:1;;;9991:36;10044:19;;28399:73:0::1;9667:402:1::0;28399:73:0::1;28483:28;28502:8;28483:18;:28::i;:::-;28318:201:::0;:::o;57343:116::-;27298:13;:11;:13::i;:::-;57421:30:::1;;:13;:30:::0;57343:116::o;53879:247::-;53942:7;43265:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43265:16:0;;54006:90;;54053:31;;-1:-1:-1;;;54053:31:0;;;;;2324:25:1;;;2297:18;;54053:31:0;2178:177:1;52111:122:0;52192:33;52201:2;52205:7;52214:4;52220;52192:8;:33::i;46372:824::-;46458:7;43265:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43265:16:0;;;;46573:18;;;46569:88;;46608:37;46625:4;46631;46637:7;46608:16;:37::i;:::-;-1:-1:-1;;;;;46704:18:0;;;46700:263;;46822:48;46839:1;46843:7;46860:1;46864:5;46822:8;:48::i;:::-;-1:-1:-1;;;;;46916:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;46916:20:0;;;46700:263;-1:-1:-1;;;;;46979:16:0;;;46975:111;;-1:-1:-1;;;;;47041:13:0;;;;;;:9;:13;;;;;:18;;47058:1;47041:18;;;46975:111;47098:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;47098:21:0;-1:-1:-1;;;;;47098:21:0;;;;;;;;;47137:27;;47098:16;;47137:27;;;;;;;47184:4;46372:824;-1:-1:-1;;;;46372:824:0:o;27577:132::-;27485:6;;-1:-1:-1;;;;;27485:6:0;26043:10;27641:23;27633:68;;;;-1:-1:-1;;;27633:68:0;;10276:2:1;27633:68:0;;;10258:21:1;;;10295:18;;;10288:30;10354:34;10334:18;;;10327:62;10406:18;;27633:68:0;10074:356:1;2520:315:0;1818:1;2649:7;;:18;2645:88;;2691:30;;-1:-1:-1;;;2691:30:0;;;;;;;;;;;2645:88;1818:1;2810:7;:17;2520:315::o;48230:102::-;48298:26;48308:2;48312:7;48298:26;;;;;;;;;;;;:9;:26::i;28679:191::-;28772:6;;;-1:-1:-1;;;;;28789:17:0;;;-1:-1:-1;;;;;;28789:17:0;;;;;;;28822:40;;28772:6;;;28789:17;28772:6;;28822:40;;28753:16;;28822:40;28742:128;28679:191;:::o;53318:318::-;-1:-1:-1;;;;;53426:22:0;;53422:93;;53472:31;;-1:-1:-1;;;53472:31:0;;-1:-1:-1;;;;;1697:32:1;;53472:31:0;;;1679:51:1;1652:18;;53472:31:0;1533:203:1;53422:93:0;-1:-1:-1;;;;;53525:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;53525:46:0;;;;;;;;;;53587:41;;540::1;;;53587::0;;513:18:1;53587:41:0;;;;;;;53318:318;;;:::o;54676:799::-;-1:-1:-1;;;;;54793:14:0;;;:18;54789:679;;54832:71;;-1:-1:-1;;;54832:71:0;;-1:-1:-1;;;;;54832:36:0;;;;;:71;;26043:10;;54883:4;;54889:7;;54898:4;;54832:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54832:71:0;;;;;;;;-1:-1:-1;;54832:71:0;;;;;;;;;;;;:::i;:::-;;;54828:629;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55146:6;:13;55163:1;55146:18;55142:300;;55196:25;;-1:-1:-1;;;55196:25:0;;-1:-1:-1;;;;;1697:32:1;;55196:25:0;;;1679:51:1;1652:18;;55196:25:0;1533:203:1;55142:300:0;55392:6;55386:13;55377:6;55373:2;55369:15;55362:38;54828:629;-1:-1:-1;;;;;;54951:51:0;;-1:-1:-1;;;54951:51:0;54947:132;;55034:25;;-1:-1:-1;;;55034:25:0;;-1:-1:-1;;;;;1697:32:1;;55034:25:0;;;1679:51:1;1652:18;;55034:25:0;1533:203:1;54947:132:0;54904:190;54676:799;;;;:::o;57467:114::-;57527:13;57560;57553:20;;;;;:::i;23390:716::-;23446:13;23497:14;23514:17;23525:5;23514:10;:17::i;:::-;23534:1;23514:21;23497:38;;23550:20;23584:6;23573:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23573:18:0;-1:-1:-1;23550:41:0;-1:-1:-1;23715:28:0;;;23731:2;23715:28;23772:288;-1:-1:-1;;23804:5:0;-1:-1:-1;;;23941:2:0;23930:14;;23925:30;23804:5;23912:44;24002:2;23993:11;;;-1:-1:-1;24023:21:0;23772:288;24023:21;-1:-1:-1;24081:6:0;23390:716;-1:-1:-1;;;23390:716:0:o;52421:678::-;52583:9;:31;;;-1:-1:-1;;;;;;52596:18:0;;;;52583:31;52579:471;;;52631:13;52647:22;52661:7;52647:13;:22::i;:::-;52631:38;-1:-1:-1;;;;;;52800:18:0;;;;;;:35;;;52831:4;-1:-1:-1;;;;;52822:13:0;:5;-1:-1:-1;;;;;52822:13:0;;;52800:35;:69;;;;;52840:29;52857:5;52864:4;52840:16;:29::i;:::-;52839:30;52800:69;52796:144;;;52897:27;;-1:-1:-1;;;52897:27:0;;-1:-1:-1;;;;;1697:32:1;;52897:27:0;;;1679:51:1;1652:18;;52897:27:0;1533:203:1;52796:144:0;52960:9;52956:83;;;53015:7;53011:2;-1:-1:-1;;;;;52995:28:0;53004:5;-1:-1:-1;;;;;52995:28:0;;;;;;;;;;;52956:83;52616:434;52579:471;-1:-1:-1;;53062:24:0;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;53062:29:0;-1:-1:-1;;;;;53062:29:0;;;;;;;;;;52421:678::o;44579:376::-;44692:38;44706:5;44713:7;44722;44692:13;:38::i;:::-;44687:261;;-1:-1:-1;;;;;44751:19:0;;44747:190;;44798:31;;-1:-1:-1;;;44798:31:0;;;;;2324:25:1;;;2297:18;;44798:31:0;2178:177:1;44747:190:0;44877:44;;-1:-1:-1;;;44877:44:0;;-1:-1:-1;;;;;11507:32:1;;44877:44:0;;;11489:51:1;11556:18;;;11549:34;;;11462:18;;44877:44:0;11315:274:1;48559:185:0;48654:18;48660:2;48664:7;48654:5;:18::i;:::-;48683:53;48714:1;48718:2;48722:7;48731:4;48683:22;:53::i;20256:922::-;20309:7;;-1:-1:-1;;;20387:15:0;;20383:102;;-1:-1:-1;;;20423:15:0;;;-1:-1:-1;20467:2:0;20457:12;20383:102;20512:6;20503:5;:15;20499:102;;20548:6;20539:15;;;-1:-1:-1;20583:2:0;20573:12;20499:102;20628:6;20619:5;:15;20615:102;;20664:6;20655:15;;;-1:-1:-1;20699:2:0;20689:12;20615:102;20744:5;20735;:14;20731:99;;20779:5;20770:14;;;-1:-1:-1;20813:1:0;20803:11;20731:99;20857:5;20848;:14;20844:99;;20892:5;20883:14;;;-1:-1:-1;20926:1:0;20916:11;20844:99;20970:5;20961;:14;20957:99;;21005:5;20996:14;;;-1:-1:-1;21039:1:0;21029:11;20957:99;21083:5;21074;:14;21070:66;;21119:1;21109:11;21164:6;20256:922;-1:-1:-1;;20256:922:0:o;43859:276::-;43962:4;-1:-1:-1;;;;;43999:21:0;;;;;;:128;;;44047:7;-1:-1:-1;;;;;44038:16:0;:5;-1:-1:-1;;;;;44038:16:0;;:52;;;;44058:32;44075:5;44082:7;44058:16;:32::i;:::-;44038:88;;;-1:-1:-1;43480:7:0;43507:24;;;:15;:24;;;;;;-1:-1:-1;;;;;44094:32:0;;;43507:24;;44094:32;44038:88;43979:148;43859:276;-1:-1:-1;;;;43859:276:0:o;47532:335::-;-1:-1:-1;;;;;47600:16:0;;47596:89;;47640:33;;-1:-1:-1;;;47640:33:0;;47670:1;47640:33;;;1679:51:1;1652:18;;47640:33:0;1533:203:1;47596:89:0;47695:21;47719:32;47727:2;47731:7;47748:1;47719:7;:32::i;:::-;47695:56;-1:-1:-1;;;;;;47766:27:0;;;47762:98;;47817:31;;-1:-1:-1;;;47817:31:0;;47845:1;47817:31;;;1679:51:1;1652:18;;47817:31:0;1533:203:1;14:131;-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;1838:70;1741:173;;;:::o;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:186::-;2419:6;2472:2;2460:9;2451:7;2447:23;2443:32;2440:52;;;2488:1;2485;2478:12;2440:52;2511:29;2530:9;2511:29;:::i;2551:328::-;2628:6;2636;2644;2697:2;2685:9;2676:7;2672:23;2668:32;2665:52;;;2713:1;2710;2703:12;2665:52;2736:29;2755:9;2736:29;:::i;:::-;2726:39;;2784:38;2818:2;2807:9;2803:18;2784:38;:::i;:::-;2774:48;;2869:2;2858:9;2854:18;2841:32;2831:42;;2551:328;;;;;:::o;2884:592::-;2955:6;2963;3016:2;3004:9;2995:7;2991:23;2987:32;2984:52;;;3032:1;3029;3022:12;2984:52;3072:9;3059:23;3101:18;3142:2;3134:6;3131:14;3128:34;;;3158:1;3155;3148:12;3128:34;3196:6;3185:9;3181:22;3171:32;;3241:7;3234:4;3230:2;3226:13;3222:27;3212:55;;3263:1;3260;3253:12;3212:55;3303:2;3290:16;3329:2;3321:6;3318:14;3315:34;;;3345:1;3342;3335:12;3315:34;3390:7;3385:2;3376:6;3372:2;3368:15;3364:24;3361:37;3358:57;;;3411:1;3408;3401:12;3358:57;3442:2;3434:11;;;;;3464:6;;-1:-1:-1;2884:592:1;;-1:-1:-1;;;;2884:592:1:o;3481:269::-;3538:6;3591:2;3579:9;3570:7;3566:23;3562:32;3559:52;;;3607:1;3604;3597:12;3559:52;3646:9;3633:23;3696:4;3689:5;3685:16;3678:5;3675:27;3665:55;;3716:1;3713;3706:12;3755:347;3820:6;3828;3881:2;3869:9;3860:7;3856:23;3852:32;3849:52;;;3897:1;3894;3887:12;3849:52;3920:29;3939:9;3920:29;:::i;:::-;3910:39;;3999:2;3988:9;3984:18;3971:32;4046:5;4039:13;4032:21;4025:5;4022:32;4012:60;;4068:1;4065;4058:12;4012:60;4091:5;4081:15;;;3755:347;;;;;:::o;4107:127::-;4168:10;4163:3;4159:20;4156:1;4149:31;4199:4;4196:1;4189:15;4223:4;4220:1;4213:15;4239:1138;4334:6;4342;4350;4358;4411:3;4399:9;4390:7;4386:23;4382:33;4379:53;;;4428:1;4425;4418:12;4379:53;4451:29;4470:9;4451:29;:::i;:::-;4441:39;;4499:38;4533:2;4522:9;4518:18;4499:38;:::i;:::-;4489:48;;4584:2;4573:9;4569:18;4556:32;4546:42;;4639:2;4628:9;4624:18;4611:32;4662:18;4703:2;4695:6;4692:14;4689:34;;;4719:1;4716;4709:12;4689:34;4757:6;4746:9;4742:22;4732:32;;4802:7;4795:4;4791:2;4787:13;4783:27;4773:55;;4824:1;4821;4814:12;4773:55;4860:2;4847:16;4882:2;4878;4875:10;4872:36;;;4888:18;;:::i;:::-;4963:2;4957:9;4931:2;5017:13;;-1:-1:-1;;5013:22:1;;;5037:2;5009:31;5005:40;4993:53;;;5061:18;;;5081:22;;;5058:46;5055:72;;;5107:18;;:::i;:::-;5147:10;5143:2;5136:22;5182:2;5174:6;5167:18;5222:7;5217:2;5212;5208;5204:11;5200:20;5197:33;5194:53;;;5243:1;5240;5233:12;5194:53;5299:2;5294;5290;5286:11;5281:2;5273:6;5269:15;5256:46;5344:1;5339:2;5334;5326:6;5322:15;5318:24;5311:35;5365:6;5355:16;;;;;;;4239:1138;;;;;;;:::o;5382:260::-;5450:6;5458;5511:2;5499:9;5490:7;5486:23;5482:32;5479:52;;;5527:1;5524;5517:12;5479:52;5550:29;5569:9;5550:29;:::i;:::-;5540:39;;5598:38;5632:2;5621:9;5617:18;5598:38;:::i;:::-;5588:48;;5382:260;;;;;:::o;5647:380::-;5726:1;5722:12;;;;5769;;;5790:61;;5844:4;5836:6;5832:17;5822:27;;5790:61;5897:2;5889:6;5886:14;5866:18;5863:38;5860:161;;5943:10;5938:3;5934:20;5931:1;5924:31;5978:4;5975:1;5968:15;6006:4;6003:1;5996:15;5860:161;;5647:380;;;:::o;6538:518::-;6640:2;6635:3;6632:11;6629:421;;;6676:5;6673:1;6666:16;6720:4;6717:1;6707:18;6790:2;6778:10;6774:19;6771:1;6767:27;6761:4;6757:38;6826:4;6814:10;6811:20;6808:47;;;-1:-1:-1;6849:4:1;6808:47;6904:2;6899:3;6895:12;6892:1;6888:20;6882:4;6878:31;6868:41;;6959:81;6977:2;6970:5;6967:13;6959:81;;;7036:1;7022:16;;7003:1;6992:13;6959:81;;7232:1198;7356:18;7351:3;7348:27;7345:53;;;7378:18;;:::i;:::-;7407:94;7497:3;7457:38;7489:4;7483:11;7457:38;:::i;:::-;7451:4;7407:94;:::i;:::-;7527:1;7552:2;7547:3;7544:11;7569:1;7564:608;;;;8216:1;8233:3;8230:93;;;-1:-1:-1;8289:19:1;;;8276:33;8230:93;-1:-1:-1;;7189:1:1;7185:11;;;7181:24;7177:29;7167:40;7213:1;7209:11;;;7164:57;8336:78;;7537:887;;7564:608;6485:1;6478:14;;;6522:4;6509:18;;-1:-1:-1;;7600:17:1;;;7715:229;7729:7;7726:1;7723:14;7715:229;;;7818:19;;;7805:33;7790:49;;7925:4;7910:20;;;;7878:1;7866:14;;;;7745:12;7715:229;;;7719:3;7972;7963:7;7960:16;7957:159;;;8096:1;8092:6;8086:3;8080;8077:1;8073:11;8069:21;8065:34;8061:39;8048:9;8043:3;8039:19;8026:33;8022:79;8014:6;8007:95;7957:159;;;8159:1;8153:3;8150:1;8146:11;8142:19;8136:4;8129:33;7537:887;;7232:1198;;;:::o;8435:127::-;8496:10;8491:3;8487:20;8484:1;8477:31;8527:4;8524:1;8517:15;8551:4;8548:1;8541:15;8567:125;8632:9;;;8653:10;;;8650:36;;;8666:18;;:::i;8697:151::-;8787:4;8780:12;;;8766;;;8762:31;;8805:14;;8802:40;;;8822:18;;:::i;8853:168::-;8926:9;;;8957;;8974:15;;;8968:22;;8954:37;8944:71;;8995:18;;:::i;9026:135::-;9065:3;9086:17;;;9083:43;;9106:18;;:::i;:::-;-1:-1:-1;9153:1:1;9142:13;;9026:135::o;9166:496::-;9345:3;9383:6;9377:13;9399:66;9458:6;9453:3;9446:4;9438:6;9434:17;9399:66;:::i;:::-;9528:13;;9487:16;;;;9550:70;9528:13;9487:16;9597:4;9585:17;;9550:70;:::i;:::-;9636:20;;9166:496;-1:-1:-1;;;;9166:496:1:o;10435:489::-;-1:-1:-1;;;;;10704:15:1;;;10686:34;;10756:15;;10751:2;10736:18;;10729:43;10803:2;10788:18;;10781:34;;;10851:3;10846:2;10831:18;;10824:31;;;10629:4;;10872:46;;10898:19;;10890:6;10872:46;:::i;:::-;10864:54;10435:489;-1:-1:-1;;;;;;10435:489:1:o;10929:249::-;10998:6;11051:2;11039:9;11030:7;11026:23;11022:32;11019:52;;;11067:1;11064;11057:12;11019:52;11099:9;11093:16;11118:30;11142:5;11118:30;:::i

ipfs://2b3401632061527435f2eeccc14f5a3717e1acd662f4e8973b5e598970b7501e