Token

LANDS Clue # 1 (Clue # 1)

ERC-721

Overview

Max Total Supply

50 Clue # 1

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xe83bdd55095c428e3462651b578fd01c2c2b1bd4

Filtered by Token Holder

0x9374dE298A8712404CC6FF046D9150975f3f1471

Balance

1 Clue # 1

0x9374de298a8712404cc6ff046d9150975f3f1471

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TwoLandsFirstClue

Compiler Version

v0.8.20+commit.a1b79de6

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-01-10
*/

/**
TG: https://t.me/twolandstokenportal
Website: https://twolandstoken.com/
Author: @bLock_doctor
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
 
/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }
 
    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }
 
    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }
 
    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }
 
    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}
 
// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol
 
 
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
 
/**
 * @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/SignedMath.sol
 
 
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)
 
 
/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }
 
    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }
 
    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }
 
    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}
 
// File: @openzeppelin/contracts/utils/math/Math.sol
 
 
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
 
 
/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();
 
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }
 
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }
 
    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }
 
    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }
 
    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }
 
    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }
 
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }
 
    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
 
    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }
 
    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }
 
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }
 
    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }
 
            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }
 
            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }
 
            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////
 
            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)
 
                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }
 
            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
 
            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)
 
                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)
 
                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }
 
            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;
 
            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;
 
            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256
 
            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }
 
    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }
 
    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
 
        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);
 
        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }
 
    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }
 
    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }
 
    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }
 
    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }
 
    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }
 
    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }
 
    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }
 
    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}
 
// File: @openzeppelin/contracts/utils/Strings.sol
 
 
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)
 
 
 
 
/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;
 
    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);
 
    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }
 
    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }
 
    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }
 
    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }
 
    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }
 
    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}
 
// File: @openzeppelin/contracts/utils/Context.sol
 
 
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)
 
 
/**
 * @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/token/ERC721/IERC721Receiver.sol
 
 
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)
 
 
/**
 * @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)
 
 
/**
 * @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)
 
 
 
/**
 * @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)
 
 
 
/**
 * @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)
 
 
 
/**
 * @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)
 
 
/**
 * @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))
                    }
                }
            }
        }
    }
}
 
contract TwoLandsFirstClue is ERC721 {
 
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;
 
    uint256 private _mintPrice = 0.1 ether;
    uint256 public constant MAX_SUPPLY = 50;
 
    bool public mintingEnabled;
 
    address public ownerAddress;
    address public oldAddress = 0x63dC6842e43D1B6b601BD6Dd4300b02B5bA33CC4;
 
    mapping(address => bool) private _exchangedNFT;
 
    modifier onlyOwner {
        require(
            msg.sender == ownerAddress, "Caller not owner!");
        _;
    }
 
    event OwnerUpdatedMintPrice(uint256 indexed mintPrice);
 
    constructor() ERC721 ("LANDS Clue # 1", "Clue # 1") {
        ownerAddress = msg.sender;
    }
 
    function _doMint(
        address targetWallet
    ) private {
        require(_tokenIdCounter.current() < MAX_SUPPLY, "Minting Finished.");
        require(getAmountRemaining() >= 1, "Not enough supply left.");
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _mint(targetWallet, tokenId);
    }
 
    function _mintNFT() public payable {
        require(mintingEnabled, "Minting is not enabled!");
        require(msg.value >= _mintPrice, "Insufficient ETH.");
        _doMint(msg.sender);
    }
 
    function airdropNFT(
        address[] memory targetWallets
    ) public onlyOwner {
        for (uint256 i = 0; i < targetWallets.length; i++) {
            _doMint(targetWallets[i]);
        }
    }
 
    function ownerUpdateMintPrice(
        uint256 amountWei
    ) public onlyOwner {
        require(amountWei > 0, "Wei must be greater than zero.");
        _mintPrice = amountWei;
        emit OwnerUpdatedMintPrice(amountWei);
    }
 
    function tokenURI(
        uint256
    ) public pure override  returns (string memory) {
        return "https://gateway.pinata.cloud/ipfs/QmYgKedASRcDtcW6m6WCpxNttYW8H3UCQZ17cNrDYcWBH9";
    }
 
    function ownerWithdrawETH() public onlyOwner {
        (bool success, ) = payable(ownerAddress).call{value: address(this).balance}("");
        require(success, "Withdraw ETH failed.");
    }
 
    function ownerToggleMinting() public onlyOwner {
        mintingEnabled = !mintingEnabled;
    }
 
    function getAmountRemaining() public view returns (
        uint256
    ) {
        return totalSupply() - _tokenIdCounter.current();
    }
 
    function totalSupply() public view virtual returns (
        uint256
    ) {
        return MAX_SUPPLY;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"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"},{"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":"uint256","name":"mintPrice","type":"uint256"}],"name":"OwnerUpdatedMintPrice","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintNFT","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"targetWallets","type":"address[]"}],"name":"airdropNFT","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":"getAmountRemaining","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":"mintingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oldAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerAddress","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":"ownerToggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountWei","type":"uint256"}],"name":"ownerUpdateMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ownerWithdrawETH","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x60806040526004361061014a575f3560e01c80636352211e116100b5578063b6e4c3171161006e578063b6e4c31714610458578063b88d4fde14610480578063bb8435ec146104a8578063c87b56dd146104d2578063e70fff631461050e578063e985e9c5146105185761014a565b80636352211e1461033a57806370a08231146103765780638f84aa09146103b257806395d89b41146103dc5780639fd6db1214610406578063a22cb465146104305761014a565b806325bdc7f61161010757806325bdc7f61461026a57806327a910dc1461028057806332cb6b0c146102965780633c55516c146102c057806342842e0e146102ea5780635bc00f41146103125761014a565b806301ffc9a71461014e57806306fdde031461018a578063081812fc146101b4578063095ea7b3146101f057806318160ddd1461021857806323b872dd14610242575b5f80fd5b348015610159575f80fd5b50610174600480360381019061016f9190611b83565b610554565b6040516101819190611bc8565b60405180910390f35b348015610195575f80fd5b5061019e610635565b6040516101ab9190611c6b565b60405180910390f35b3480156101bf575f80fd5b506101da60048036038101906101d59190611cbe565b6106c4565b6040516101e79190611d28565b60405180910390f35b3480156101fb575f80fd5b5061021660048036038101906102119190611d6b565b6106df565b005b348015610223575f80fd5b5061022c6106f5565b6040516102399190611db8565b60405180910390f35b34801561024d575f80fd5b5061026860048036038101906102639190611dd1565b6106fd565b005b348015610275575f80fd5b5061027e6107fc565b005b34801561028b575f80fd5b506102946108b6565b005b3480156102a1575f80fd5b506102aa610a13565b6040516102b79190611db8565b60405180910390f35b3480156102cb575f80fd5b506102d4610a18565b6040516102e19190611db8565b60405180910390f35b3480156102f5575f80fd5b50610310600480360381019061030b9190611dd1565b610a3a565b005b34801561031d575f80fd5b5061033860048036038101906103339190611f61565b610a59565b005b348015610345575f80fd5b50610360600480360381019061035b9190611cbe565b610b2e565b60405161036d9190611d28565b60405180910390f35b348015610381575f80fd5b5061039c60048036038101906103979190611fa8565b610b3f565b6040516103a99190611db8565b60405180910390f35b3480156103bd575f80fd5b506103c6610bf5565b6040516103d39190611d28565b60405180910390f35b3480156103e7575f80fd5b506103f0610c1b565b6040516103fd9190611c6b565b60405180910390f35b348015610411575f80fd5b5061041a610cab565b6040516104279190611bc8565b60405180910390f35b34801561043b575f80fd5b5061045660048036038101906104519190611ffd565b610cbd565b005b348015610463575f80fd5b5061047e60048036038101906104799190611cbe565b610cd3565b005b34801561048b575f80fd5b506104a660048036038101906104a191906120eb565b610ddc565b005b3480156104b3575f80fd5b506104bc610df9565b6040516104c99190611d28565b60405180910390f35b3480156104dd575f80fd5b506104f860048036038101906104f39190611cbe565b610e1e565b6040516105059190611c6b565b60405180910390f35b610516610e40565b005b348015610523575f80fd5b5061053e6004803603810190610539919061216b565b610ede565b60405161054b9190611bc8565b60405180910390f35b5f7f80ac58cd000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916148061061e57507f5b5e139f000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b8061062e575061062d82610f6c565b5b9050919050565b60605f8054610643906121d6565b80601f016020809104026020016040519081016040528092919081815260200182805461066f906121d6565b80156106ba5780601f10610691576101008083540402835291602001916106ba565b820191905f5260205f20905b81548152906001019060200180831161069d57829003601f168201915b5050505050905090565b5f6106ce82610fd5565b506106d88261105b565b9050919050565b6106f182826106ec611094565b61109b565b5050565b5f6032905090565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160361076d575f6040517f64a0ae920000000000000000000000000000000000000000000000000000000081526004016107649190611d28565b60405180910390fd5b5f610780838361077b611094565b6110ad565b90508373ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146107f6578382826040517f64283d7b0000000000000000000000000000000000000000000000000000000081526004016107ed93929190612206565b60405180910390fd5b50505050565b600860019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461088c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161088390612285565b60405180910390fd5b60085f9054906101000a900460ff161560085f6101000a81548160ff021916908315150217905550565b600860019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610946576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161093d90612285565b60405180910390fd5b5f600860019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff164760405161098d906122d0565b5f6040518083038185875af1925050503d805f81146109c7576040519150601f19603f3d011682016040523d82523d5f602084013e6109cc565b606091505b5050905080610a10576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a079061232e565b60405180910390fd5b50565b603281565b5f610a2360066112b8565b610a2b6106f5565b610a359190612379565b905090565b610a5483838360405180602001604052805f815250610ddc565b505050565b600860019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ae9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ae090612285565b60405180910390fd5b5f5b8151811015610b2a57610b17828281518110610b0a57610b096123ac565b5b60200260200101516112c4565b8080610b22906123d9565b915050610aeb565b5050565b5f610b3882610fd5565b9050919050565b5f8073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610bb0575f6040517f89c62b64000000000000000000000000000000000000000000000000000000008152600401610ba79190611d28565b60405180910390fd5b60035f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b600860019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b606060018054610c2a906121d6565b80601f0160208091040260200160405190810160405280929190818152602001828054610c56906121d6565b8015610ca15780601f10610c7857610100808354040283529160200191610ca1565b820191905f5260205f20905b815481529060010190602001808311610c8457829003601f168201915b5050505050905090565b60085f9054906101000a900460ff1681565b610ccf610cc8611094565b8383611380565b5050565b600860019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610d63576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d5a90612285565b60405180910390fd5b5f8111610da5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d9c9061246a565b60405180910390fd5b80600781905550807f6fb2223e25e2a242768efeca7275b403aa1e0d08d504f3579da2d11427a9da3d60405160405180910390a250565b610de78484846106fd565b610df3848484846114e9565b50505050565b60095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b606060405180608001604052806050815260200161272b605091399050919050565b60085f9054906101000a900460ff16610e8e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e85906124d2565b60405180910390fd5b600754341015610ed3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eca9061253a565b60405180910390fd5b610edc336112c4565b565b5f60055f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff16905092915050565b5f7f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b5f80610fe08361169b565b90505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361105257826040517f7e2732890000000000000000000000000000000000000000000000000000000081526004016110499190611db8565b60405180910390fd5b80915050919050565b5f60045f8381526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b5f33905090565b6110a883838360016116d4565b505050565b5f806110b88461169b565b90505f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16146110f9576110f8818486611893565b5b5f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614611184576111385f855f806116d4565b600160035f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825403925050819055505b5f73ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff161461120357600160035f8773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825401925050819055505b8460025f8681526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550838573ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4809150509392505050565b5f815f01549050919050565b60326112d060066112b8565b10611310576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611307906125a2565b60405180910390fd5b600161131a610a18565b101561135b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113529061260a565b60405180910390fd5b5f61136660066112b8565b90506113726006611956565b61137c828261196a565b5050565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16036113f057816040517f5b08ba180000000000000000000000000000000000000000000000000000000081526004016113e79190611d28565b60405180910390fd5b8060055f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31836040516114dc9190611bc8565b60405180910390a3505050565b5f8373ffffffffffffffffffffffffffffffffffffffff163b1115611695578273ffffffffffffffffffffffffffffffffffffffff1663150b7a0261152c611094565b8685856040518563ffffffff1660e01b815260040161154e949392919061267a565b6020604051808303815f875af192505050801561158957506040513d601f19601f8201168201806040525081019061158691906126d8565b60015b61160a573d805f81146115b7576040519150601f19603f3d011682016040523d82523d5f602084013e6115bc565b606091505b505f81510361160257836040517f64a0ae920000000000000000000000000000000000000000000000000000000081526004016115f99190611d28565b60405180910390fd5b805181602001fd5b63150b7a0260e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19161461169357836040517f64a0ae9200000000000000000000000000000000000000000000000000000000815260040161168a9190611d28565b60405180910390fd5b505b50505050565b5f60025f8381526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b808061170c57505f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614155b1561183e575f61171b84610fd5565b90505f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415801561178557508273ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614155b801561179857506117968184610ede565b155b156117da57826040517fa9fbf51f0000000000000000000000000000000000000000000000000000000081526004016117d19190611d28565b60405180910390fd5b811561183c57838573ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45b505b8360045f8581526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050505050565b61189e838383611a5d565b611951575f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff160361191257806040517f7e2732890000000000000000000000000000000000000000000000000000000081526004016119099190611db8565b60405180910390fd5b81816040517f177e802f000000000000000000000000000000000000000000000000000000008152600401611948929190612703565b60405180910390fd5b505050565b6001815f015f828254019250508190555050565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16036119da575f6040517f64a0ae920000000000000000000000000000000000000000000000000000000081526004016119d19190611d28565b60405180910390fd5b5f6119e683835f6110ad565b90505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614611a58575f6040517f73c6ac6e000000000000000000000000000000000000000000000000000000008152600401611a4f9190611d28565b60405180910390fd5b505050565b5f8073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614158015611b1457508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161480611ad55750611ad48484610ede565b5b80611b1357508273ffffffffffffffffffffffffffffffffffffffff16611afb8361105b565b73ffffffffffffffffffffffffffffffffffffffff16145b5b90509392505050565b5f604051905090565b5f80fd5b5f80fd5b5f7fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b611b6281611b2e565b8114611b6c575f80fd5b50565b5f81359050611b7d81611b59565b92915050565b5f60208284031215611b9857611b97611b26565b5b5f611ba584828501611b6f565b91505092915050565b5f8115159050919050565b611bc281611bae565b82525050565b5f602082019050611bdb5f830184611bb9565b92915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b83811015611c18578082015181840152602081019050611bfd565b5f8484015250505050565b5f601f19601f8301169050919050565b5f611c3d82611be1565b611c478185611beb565b9350611c57818560208601611bfb565b611c6081611c23565b840191505092915050565b5f6020820190508181035f830152611c838184611c33565b905092915050565b5f819050919050565b611c9d81611c8b565b8114611ca7575f80fd5b50565b5f81359050611cb881611c94565b92915050565b5f60208284031215611cd357611cd2611b26565b5b5f611ce084828501611caa565b91505092915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f611d1282611ce9565b9050919050565b611d2281611d08565b82525050565b5f602082019050611d3b5f830184611d19565b92915050565b611d4a81611d08565b8114611d54575f80fd5b50565b5f81359050611d6581611d41565b92915050565b5f8060408385031215611d8157611d80611b26565b5b5f611d8e85828601611d57565b9250506020611d9f85828601611caa565b9150509250929050565b611db281611c8b565b82525050565b5f602082019050611dcb5f830184611da9565b92915050565b5f805f60608486031215611de857611de7611b26565b5b5f611df586828701611d57565b9350506020611e0686828701611d57565b9250506040611e1786828701611caa565b9150509250925092565b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b611e5b82611c23565b810181811067ffffffffffffffff82111715611e7a57611e79611e25565b5b80604052505050565b5f611e8c611b1d565b9050611e988282611e52565b919050565b5f67ffffffffffffffff821115611eb757611eb6611e25565b5b602082029050602081019050919050565b5f80fd5b5f611ede611ed984611e9d565b611e83565b90508083825260208201905060208402830185811115611f0157611f00611ec8565b5b835b81811015611f2a5780611f168882611d57565b845260208401935050602081019050611f03565b5050509392505050565b5f82601f830112611f4857611f47611e21565b5b8135611f58848260208601611ecc565b91505092915050565b5f60208284031215611f7657611f75611b26565b5b5f82013567ffffffffffffffff811115611f9357611f92611b2a565b5b611f9f84828501611f34565b91505092915050565b5f60208284031215611fbd57611fbc611b26565b5b5f611fca84828501611d57565b91505092915050565b611fdc81611bae565b8114611fe6575f80fd5b50565b5f81359050611ff781611fd3565b92915050565b5f806040838503121561201357612012611b26565b5b5f61202085828601611d57565b925050602061203185828601611fe9565b9150509250929050565b5f80fd5b5f67ffffffffffffffff82111561205957612058611e25565b5b61206282611c23565b9050602081019050919050565b828183375f83830152505050565b5f61208f61208a8461203f565b611e83565b9050828152602081018484840111156120ab576120aa61203b565b5b6120b684828561206f565b509392505050565b5f82601f8301126120d2576120d1611e21565b5b81356120e284826020860161207d565b91505092915050565b5f805f806080858703121561210357612102611b26565b5b5f61211087828801611d57565b945050602061212187828801611d57565b935050604061213287828801611caa565b925050606085013567ffffffffffffffff81111561215357612152611b2a565b5b61215f878288016120be565b91505092959194509250565b5f806040838503121561218157612180611b26565b5b5f61218e85828601611d57565b925050602061219f85828601611d57565b9150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f60028204905060018216806121ed57607f821691505b602082108103612200576121ff6121a9565b5b50919050565b5f6060820190506122195f830186611d19565b6122266020830185611da9565b6122336040830184611d19565b949350505050565b7f43616c6c6572206e6f74206f776e6572210000000000000000000000000000005f82015250565b5f61226f601183611beb565b915061227a8261223b565b602082019050919050565b5f6020820190508181035f83015261229c81612263565b9050919050565b5f81905092915050565b50565b5f6122bb5f836122a3565b91506122c6826122ad565b5f82019050919050565b5f6122da826122b0565b9150819050919050565b7f576974686472617720455448206661696c65642e0000000000000000000000005f82015250565b5f612318601483611beb565b9150612323826122e4565b602082019050919050565b5f6020820190508181035f8301526123458161230c565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61238382611c8b565b915061238e83611c8b565b92508282039050818111156123a6576123a561234c565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f6123e382611c8b565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036124155761241461234c565b5b600182019050919050565b7f576569206d7573742062652067726561746572207468616e207a65726f2e00005f82015250565b5f612454601e83611beb565b915061245f82612420565b602082019050919050565b5f6020820190508181035f83015261248181612448565b9050919050565b7f4d696e74696e67206973206e6f7420656e61626c6564210000000000000000005f82015250565b5f6124bc601783611beb565b91506124c782612488565b602082019050919050565b5f6020820190508181035f8301526124e9816124b0565b9050919050565b7f496e73756666696369656e74204554482e0000000000000000000000000000005f82015250565b5f612524601183611beb565b915061252f826124f0565b602082019050919050565b5f6020820190508181035f83015261255181612518565b9050919050565b7f4d696e74696e672046696e69736865642e0000000000000000000000000000005f82015250565b5f61258c601183611beb565b915061259782612558565b602082019050919050565b5f6020820190508181035f8301526125b981612580565b9050919050565b7f4e6f7420656e6f75676820737570706c79206c6566742e0000000000000000005f82015250565b5f6125f4601783611beb565b91506125ff826125c0565b602082019050919050565b5f6020820190508181035f830152612621816125e8565b9050919050565b5f81519050919050565b5f82825260208201905092915050565b5f61264c82612628565b6126568185612632565b9350612666818560208601611bfb565b61266f81611c23565b840191505092915050565b5f60808201905061268d5f830187611d19565b61269a6020830186611d19565b6126a76040830185611da9565b81810360608301526126b98184612642565b905095945050505050565b5f815190506126d281611b59565b92915050565b5f602082840312156126ed576126ec611b26565b5b5f6126fa848285016126c4565b91505092915050565b5f6040820190506127165f830185611d19565b6127236020830184611da9565b939250505056fe68747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d59674b65644153526344746357366d36574370784e747459573848335543515a3137634e7244596357424839a2646970667358221220c81516ac226734e5dcad7a2d29747e4794a5d4ca2d021fcecea92ff4393c644a64736f6c63430008140033

Deployed Bytecode Sourcemap

55674:2552:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39049:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39883:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41061:159;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40879:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58110:113;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41734:588;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57851:98;;;;;;;;;;;;;:::i;:::-;;57648:194;;;;;;;;;;;;;:::i;:::-;;55858:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57958:143;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42394:134;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56980:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39695:120;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39419:213;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55943:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40044:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55907:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41293:146;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57195:238;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42600:211;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55977:70;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57442:197;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56773:198;;;:::i;:::-;;41511:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39049:305;39151:4;39203:25;39188:40;;;:11;:40;;;;:105;;;;39260:33;39245:48;;;:11;:48;;;;39188:105;:158;;;;39310:36;39334:11;39310:23;:36::i;:::-;39188:158;39168:178;;39049:305;;;:::o;39883:91::-;39928:13;39961:5;39954:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39883:91;:::o;41061:159::-;41128:7;41148:22;41162:7;41148:13;:22::i;:::-;;41191:21;41204:7;41191:12;:21::i;:::-;41184:28;;41061:159;;;:::o;40879:115::-;40951:35;40960:2;40964:7;40973:12;:10;:12::i;:::-;40951:8;:35::i;:::-;40879:115;;:::o;58110:113::-;58172:7;55895:2;58198:17;;58110:113;:::o;41734:588::-;41843:1;41829:16;;:2;:16;;;41825:89;;41899:1;41869:33;;;;;;;;;;;:::i;:::-;;;;;;;;41825:89;42135:21;42159:34;42167:2;42171:7;42180:12;:10;:12::i;:::-;42159:7;:34::i;:::-;42135:58;;42225:4;42208:21;;:13;:21;;;42204:111;;42274:4;42280:7;42289:13;42253:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;42204:111;41814:508;41734:588;;;:::o;57851:98::-;56179:12;;;;;;;;;;;56165:26;;:10;:26;;;56143:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;57927:14:::1;;;;;;;;;;;57926:15;57909:14;;:32;;;;;;;;;;;;;;;;;;57851:98::o:0;57648:194::-;56179:12;;;;;;;;;;;56165:26;;:10;:26;;;56143:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;57705:12:::1;57731;;;;;;;;;;;57723:26;;57757:21;57723:60;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57704:79;;;57802:7;57794:40;;;;;;;;;;;;:::i;:::-;;;;;;;;;57693:149;57648:194::o:0;55858:39::-;55895:2;55858:39;:::o;57958:143::-;58019:7;58068:25;:15;:23;:25::i;:::-;58052:13;:11;:13::i;:::-;:41;;;;:::i;:::-;58045:48;;57958:143;:::o;42394:134::-;42481:39;42498:4;42504:2;42508:7;42481:39;;;;;;;;;;;;:16;:39::i;:::-;42394:134;;;:::o;56980:206::-;56179:12;;;;;;;;;;;56165:26;;:10;:26;;;56143:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;57081:9:::1;57076:103;57100:13;:20;57096:1;:24;57076:103;;;57142:25;57150:13;57164:1;57150:16;;;;;;;;:::i;:::-;;;;;;;;57142:7;:25::i;:::-;57122:3;;;;;:::i;:::-;;;;57076:103;;;;56980:206:::0;:::o;39695:120::-;39758:7;39785:22;39799:7;39785:13;:22::i;:::-;39778:29;;39695:120;;;:::o;39419:213::-;39482:7;39523:1;39506:19;;:5;:19;;;39502:89;;39576:1;39549:30;;;;;;;;;;;:::i;:::-;;;;;;;;39502:89;39608:9;:16;39618:5;39608:16;;;;;;;;;;;;;;;;39601:23;;39419:213;;;:::o;55943:27::-;;;;;;;;;;;;;:::o;40044:95::-;40091:13;40124:7;40117:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40044:95;:::o;55907:26::-;;;;;;;;;;;;;:::o;41293:146::-;41379:52;41398:12;:10;:12::i;:::-;41412:8;41422;41379:18;:52::i;:::-;41293:146;;:::o;57195:238::-;56179:12;;;;;;;;;;;56165:26;;:10;:26;;;56143:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;57308:1:::1;57296:9;:13;57288:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;57368:9;57355:10;:22;;;;57415:9;57393:32;;;;;;;;;;57195:238:::0;:::o;42600:211::-;42714:31;42727:4;42733:2;42737:7;42714:12;:31::i;:::-;42756:47;42779:4;42785:2;42789:7;42798:4;42756:22;:47::i;:::-;42600:211;;;;:::o;55977:70::-;;;;;;;;;;;;;:::o;57442:197::-;57516:13;57542:89;;;;;;;;;;;;;;;;;;;57442:197;;;:::o;56773:198::-;56827:14;;;;;;;;;;;56819:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;56901:10;;56888:9;:23;;56880:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;56944:19;56952:10;56944:7;:19::i;:::-;56773:198::o;41511:155::-;41599:4;41623:18;:25;41642:5;41623:25;;;;;;;;;;;;;;;:35;41649:8;41623:35;;;;;;;;;;;;;;;;;;;;;;;;;41616:42;;41511:155;;;;:::o;31844:148::-;31920:4;31959:25;31944:40;;;:11;:40;;;;31937:47;;31844:148;;;:::o;54069:247::-;54132:7;54152:13;54168:17;54177:7;54168:8;:17::i;:::-;54152:33;;54217:1;54200:19;;:5;:19;;;54196:90;;54266:7;54243:31;;;;;;;;;;;:::i;:::-;;;;;;;;54196:90;54303:5;54296:12;;;54069:247;;;:::o;43575:129::-;43645:7;43672:15;:24;43688:7;43672:24;;;;;;;;;;;;;;;;;;;;;43665:31;;43575:129;;;:::o;28914:98::-;28967:7;28994:10;28987:17;;28914:98;:::o;52295:122::-;52376:33;52385:2;52389:7;52398:4;52404;52376:8;:33::i;:::-;52295:122;;;:::o;46541:831::-;46627:7;46647:12;46662:17;46671:7;46662:8;:17::i;:::-;46647:32;;46759:1;46743:18;;:4;:18;;;46739:88;;46778:37;46795:4;46801;46807:7;46778:16;:37::i;:::-;46739:88;46891:1;46875:18;;:4;:18;;;46871:264;;46993:48;47010:1;47014:7;47031:1;47035:5;46993:8;:48::i;:::-;47107:1;47088:9;:15;47098:4;47088:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;46871:264;47166:1;47152:16;;:2;:16;;;47148:111;;47231:1;47214:9;:13;47224:2;47214:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;47148:111;47291:2;47272:7;:16;47280:7;47272:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;47331:7;47327:2;47312:27;;47321:4;47312:27;;;;;;;;;;;;47360:4;47353:11;;;46541:831;;;;;:::o;900:114::-;965:7;992;:14;;;985:21;;900:114;;;:::o;56411:353::-;55895:2;56493:25;:15;:23;:25::i;:::-;:38;56485:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56596:1;56572:20;:18;:20::i;:::-;:25;;56564:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;56636:15;56654:25;:15;:23;:25::i;:::-;56636:43;;56690:27;:15;:25;:27::i;:::-;56728:28;56734:12;56748:7;56728:5;:28::i;:::-;56474:290;56411:353;:::o;53507:318::-;53635:1;53615:22;;:8;:22;;;53611:93;;53683:8;53661:31;;;;;;;;;;;:::i;:::-;;;;;;;;53611:93;53752:8;53714:18;:25;53733:5;53714:25;;;;;;;;;;;;;;;:35;53740:8;53714:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;53798:8;53776:41;;53791:5;53776:41;;;53808:8;53776:41;;;;;;:::i;:::-;;;;;;;;53507:318;;;:::o;54867:799::-;55001:1;54984:2;:14;;;:18;54980:679;;;55039:2;55023:36;;;55060:12;:10;:12::i;:::-;55074:4;55080:7;55089:4;55023:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;55019:629;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55354:1;55337:6;:13;:18;55333:300;;55409:2;55387:25;;;;;;;;;;;:::i;:::-;;;;;;;;55333:300;55583:6;55577:13;55568:6;55564:2;55560:15;55553:38;55019:629;55152:41;;;55142:51;;;:6;:51;;;;55138:132;;55247:2;55225:25;;;;;;;;;;;:::i;:::-;;;;;;;;55138:132;55095:190;54980:679;54867:799;;;;:::o;43336:117::-;43402:7;43429;:16;43437:7;43429:16;;;;;;;;;;;;;;;;;;;;;43422:23;;43336:117;;;:::o;52606:681::-;52768:9;:31;;;;52797:1;52781:18;;:4;:18;;;;52768:31;52764:473;;;52816:13;52832:22;52846:7;52832:13;:22::i;:::-;52816:38;;53002:1;52986:18;;:4;:18;;;;:35;;;;;53017:4;53008:13;;:5;:13;;;;52986:35;:69;;;;;53026:29;53043:5;53050:4;53026:16;:29::i;:::-;53025:30;52986:69;52982:144;;;53105:4;53083:27;;;;;;;;;;;:::i;:::-;;;;;;;;52982:144;53147:9;53143:83;;;53202:7;53198:2;53182:28;;53191:5;53182:28;;;;;;;;;;;;53143:83;52801:436;52764:473;53277:2;53250:15;:24;53266:7;53250:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;52606:681;;;;:::o;44746:376::-;44859:38;44873:5;44880:7;44889;44859:13;:38::i;:::-;44854:261;;44935:1;44918:19;;:5;:19;;;44914:190;;44988:7;44965:31;;;;;;;;;;;:::i;:::-;;;;;;;;44914:190;45071:7;45080;45044:44;;;;;;;;;;;;:::i;:::-;;;;;;;;44854:261;44746:376;;;:::o;1023:127::-;1130:1;1112:7;:14;;;:19;;;;;;;;;;;1023:127;:::o;47709:335::-;47791:1;47777:16;;:2;:16;;;47773:89;;47847:1;47817:33;;;;;;;;;;;:::i;:::-;;;;;;;;47773:89;47872:21;47896:32;47904:2;47908:7;47925:1;47896:7;:32::i;:::-;47872:56;;47968:1;47943:27;;:13;:27;;;47939:98;;48022:1;47994:31;;;;;;;;;;;:::i;:::-;;;;;;;;47939:98;47762:282;47709:335;;:::o;44025:276::-;44128:4;44184:1;44165:21;;:7;:21;;;;:128;;;;;44213:7;44204:16;;:5;:16;;;:52;;;;44224:32;44241:5;44248:7;44224:16;:32::i;:::-;44204:52;:88;;;;44285:7;44260:32;;:21;44273:7;44260:12;:21::i;:::-;:32;;;44204:88;44165:128;44145:148;;44025:276;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:117::-;5976:1;5973;5966:12;5990:180;6038:77;6035:1;6028:88;6135:4;6132:1;6125:15;6159:4;6156:1;6149:15;6176:281;6259:27;6281:4;6259:27;:::i;:::-;6251:6;6247:40;6389:6;6377:10;6374:22;6353:18;6341:10;6338:34;6335:62;6332:88;;;6400:18;;:::i;:::-;6332:88;6440:10;6436:2;6429:22;6219:238;6176:281;;:::o;6463:129::-;6497:6;6524:20;;:::i;:::-;6514:30;;6553:33;6581:4;6573:6;6553:33;:::i;:::-;6463:129;;;:::o;6598:311::-;6675:4;6765:18;6757:6;6754:30;6751:56;;;6787:18;;:::i;:::-;6751:56;6837:4;6829:6;6825:17;6817:25;;6897:4;6891;6887:15;6879:23;;6598:311;;;:::o;6915:117::-;7024:1;7021;7014:12;7055:710;7151:5;7176:81;7192:64;7249:6;7192:64;:::i;:::-;7176:81;:::i;:::-;7167:90;;7277:5;7306:6;7299:5;7292:21;7340:4;7333:5;7329:16;7322:23;;7393:4;7385:6;7381:17;7373:6;7369:30;7422:3;7414:6;7411:15;7408:122;;;7441:79;;:::i;:::-;7408:122;7556:6;7539:220;7573:6;7568:3;7565:15;7539:220;;;7648:3;7677:37;7710:3;7698:10;7677:37;:::i;:::-;7672:3;7665:50;7744:4;7739:3;7735:14;7728:21;;7615:144;7599:4;7594:3;7590:14;7583:21;;7539:220;;;7543:21;7157:608;;7055:710;;;;;:::o;7788:370::-;7859:5;7908:3;7901:4;7893:6;7889:17;7885:27;7875:122;;7916:79;;:::i;:::-;7875:122;8033:6;8020:20;8058:94;8148:3;8140:6;8133:4;8125:6;8121:17;8058:94;:::i;:::-;8049:103;;7865:293;7788:370;;;;:::o;8164:539::-;8248:6;8297:2;8285:9;8276:7;8272:23;8268:32;8265:119;;;8303:79;;:::i;:::-;8265:119;8451:1;8440:9;8436:17;8423:31;8481:18;8473:6;8470:30;8467:117;;;8503:79;;:::i;:::-;8467:117;8608:78;8678:7;8669:6;8658:9;8654:22;8608:78;:::i;:::-;8598:88;;8394:302;8164:539;;;;:::o;8709:329::-;8768:6;8817:2;8805:9;8796:7;8792:23;8788:32;8785:119;;;8823:79;;:::i;:::-;8785:119;8943:1;8968:53;9013:7;9004:6;8993:9;8989:22;8968:53;:::i;:::-;8958:63;;8914:117;8709:329;;;;:::o;9044:116::-;9114:21;9129:5;9114:21;:::i;:::-;9107:5;9104:32;9094:60;;9150:1;9147;9140:12;9094:60;9044:116;:::o;9166:133::-;9209:5;9247:6;9234:20;9225:29;;9263:30;9287:5;9263:30;:::i;:::-;9166:133;;;;:::o;9305:468::-;9370:6;9378;9427:2;9415:9;9406:7;9402:23;9398:32;9395:119;;;9433:79;;:::i;:::-;9395:119;9553:1;9578:53;9623:7;9614:6;9603:9;9599:22;9578:53;:::i;:::-;9568:63;;9524:117;9680:2;9706:50;9748:7;9739:6;9728:9;9724:22;9706:50;:::i;:::-;9696:60;;9651:115;9305:468;;;;;:::o;9779:117::-;9888:1;9885;9878:12;9902:307;9963:4;10053:18;10045:6;10042:30;10039:56;;;10075:18;;:::i;:::-;10039:56;10113:29;10135:6;10113:29;:::i;:::-;10105:37;;10197:4;10191;10187:15;10179:23;;9902:307;;;:::o;10215:146::-;10312:6;10307:3;10302;10289:30;10353:1;10344:6;10339:3;10335:16;10328:27;10215:146;;;:::o;10367:423::-;10444:5;10469:65;10485:48;10526:6;10485:48;:::i;:::-;10469:65;:::i;:::-;10460:74;;10557:6;10550:5;10543:21;10595:4;10588:5;10584:16;10633:3;10624:6;10619:3;10615:16;10612:25;10609:112;;;10640:79;;:::i;:::-;10609:112;10730:54;10777:6;10772:3;10767;10730:54;:::i;:::-;10450:340;10367:423;;;;;:::o;10809:338::-;10864:5;10913:3;10906:4;10898:6;10894:17;10890:27;10880:122;;10921:79;;:::i;:::-;10880:122;11038:6;11025:20;11063:78;11137:3;11129:6;11122:4;11114:6;11110:17;11063:78;:::i;:::-;11054:87;;10870:277;10809:338;;;;:::o;11153:943::-;11248:6;11256;11264;11272;11321:3;11309:9;11300:7;11296:23;11292:33;11289:120;;;11328:79;;:::i;:::-;11289:120;11448:1;11473:53;11518:7;11509:6;11498:9;11494:22;11473:53;:::i;:::-;11463:63;;11419:117;11575:2;11601:53;11646:7;11637:6;11626:9;11622:22;11601:53;:::i;:::-;11591:63;;11546:118;11703:2;11729:53;11774:7;11765:6;11754:9;11750:22;11729:53;:::i;:::-;11719:63;;11674:118;11859:2;11848:9;11844:18;11831:32;11890:18;11882:6;11879:30;11876:117;;;11912:79;;:::i;:::-;11876:117;12017:62;12071:7;12062:6;12051:9;12047:22;12017:62;:::i;:::-;12007:72;;11802:287;11153:943;;;;;;;:::o;12102:474::-;12170:6;12178;12227:2;12215:9;12206:7;12202:23;12198:32;12195:119;;;12233:79;;:::i;:::-;12195:119;12353:1;12378:53;12423:7;12414:6;12403:9;12399:22;12378:53;:::i;:::-;12368:63;;12324:117;12480:2;12506:53;12551:7;12542:6;12531:9;12527:22;12506:53;:::i;:::-;12496:63;;12451:118;12102:474;;;;;:::o;12582:180::-;12630:77;12627:1;12620:88;12727:4;12724:1;12717:15;12751:4;12748:1;12741:15;12768:320;12812:6;12849:1;12843:4;12839:12;12829:22;;12896:1;12890:4;12886:12;12917:18;12907:81;;12973:4;12965:6;12961:17;12951:27;;12907:81;13035:2;13027:6;13024:14;13004:18;13001:38;12998:84;;13054:18;;:::i;:::-;12998:84;12819:269;12768:320;;;:::o;13094:442::-;13243:4;13281:2;13270:9;13266:18;13258:26;;13294:71;13362:1;13351:9;13347:17;13338:6;13294:71;:::i;:::-;13375:72;13443:2;13432:9;13428:18;13419:6;13375:72;:::i;:::-;13457;13525:2;13514:9;13510:18;13501:6;13457:72;:::i;:::-;13094:442;;;;;;:::o;13542:167::-;13682:19;13678:1;13670:6;13666:14;13659:43;13542:167;:::o;13715:366::-;13857:3;13878:67;13942:2;13937:3;13878:67;:::i;:::-;13871:74;;13954:93;14043:3;13954:93;:::i;:::-;14072:2;14067:3;14063:12;14056:19;;13715:366;;;:::o;14087:419::-;14253:4;14291:2;14280:9;14276:18;14268:26;;14340:9;14334:4;14330:20;14326:1;14315:9;14311:17;14304:47;14368:131;14494:4;14368:131;:::i;:::-;14360:139;;14087:419;;;:::o;14512:147::-;14613:11;14650:3;14635:18;;14512:147;;;;:::o;14665:114::-;;:::o;14785:398::-;14944:3;14965:83;15046:1;15041:3;14965:83;:::i;:::-;14958:90;;15057:93;15146:3;15057:93;:::i;:::-;15175:1;15170:3;15166:11;15159:18;;14785:398;;;:::o;15189:379::-;15373:3;15395:147;15538:3;15395:147;:::i;:::-;15388:154;;15559:3;15552:10;;15189:379;;;:::o;15574:170::-;15714:22;15710:1;15702:6;15698:14;15691:46;15574:170;:::o;15750:366::-;15892:3;15913:67;15977:2;15972:3;15913:67;:::i;:::-;15906:74;;15989:93;16078:3;15989:93;:::i;:::-;16107:2;16102:3;16098:12;16091:19;;15750:366;;;:::o;16122:419::-;16288:4;16326:2;16315:9;16311:18;16303:26;;16375:9;16369:4;16365:20;16361:1;16350:9;16346:17;16339:47;16403:131;16529:4;16403:131;:::i;:::-;16395:139;;16122:419;;;:::o;16547:180::-;16595:77;16592:1;16585:88;16692:4;16689:1;16682:15;16716:4;16713:1;16706:15;16733:194;16773:4;16793:20;16811:1;16793:20;:::i;:::-;16788:25;;16827:20;16845:1;16827:20;:::i;:::-;16822:25;;16871:1;16868;16864:9;16856:17;;16895:1;16889:4;16886:11;16883:37;;;16900:18;;:::i;:::-;16883:37;16733:194;;;;:::o;16933:180::-;16981:77;16978:1;16971:88;17078:4;17075:1;17068:15;17102:4;17099:1;17092:15;17119:233;17158:3;17181:24;17199:5;17181:24;:::i;:::-;17172:33;;17227:66;17220:5;17217:77;17214:103;;17297:18;;:::i;:::-;17214:103;17344:1;17337:5;17333:13;17326:20;;17119:233;;;:::o;17358:180::-;17498:32;17494:1;17486:6;17482:14;17475:56;17358:180;:::o;17544:366::-;17686:3;17707:67;17771:2;17766:3;17707:67;:::i;:::-;17700:74;;17783:93;17872:3;17783:93;:::i;:::-;17901:2;17896:3;17892:12;17885:19;;17544:366;;;:::o;17916:419::-;18082:4;18120:2;18109:9;18105:18;18097:26;;18169:9;18163:4;18159:20;18155:1;18144:9;18140:17;18133:47;18197:131;18323:4;18197:131;:::i;:::-;18189:139;;17916:419;;;:::o;18341:173::-;18481:25;18477:1;18469:6;18465:14;18458:49;18341:173;:::o;18520:366::-;18662:3;18683:67;18747:2;18742:3;18683:67;:::i;:::-;18676:74;;18759:93;18848:3;18759:93;:::i;:::-;18877:2;18872:3;18868:12;18861:19;;18520:366;;;:::o;18892:419::-;19058:4;19096:2;19085:9;19081:18;19073:26;;19145:9;19139:4;19135:20;19131:1;19120:9;19116:17;19109:47;19173:131;19299:4;19173:131;:::i;:::-;19165:139;;18892:419;;;:::o;19317:167::-;19457:19;19453:1;19445:6;19441:14;19434:43;19317:167;:::o;19490:366::-;19632:3;19653:67;19717:2;19712:3;19653:67;:::i;:::-;19646:74;;19729:93;19818:3;19729:93;:::i;:::-;19847:2;19842:3;19838:12;19831:19;;19490:366;;;:::o;19862:419::-;20028:4;20066:2;20055:9;20051:18;20043:26;;20115:9;20109:4;20105:20;20101:1;20090:9;20086:17;20079:47;20143:131;20269:4;20143:131;:::i;:::-;20135:139;;19862:419;;;:::o;20287:167::-;20427:19;20423:1;20415:6;20411:14;20404:43;20287:167;:::o;20460:366::-;20602:3;20623:67;20687:2;20682:3;20623:67;:::i;:::-;20616:74;;20699:93;20788:3;20699:93;:::i;:::-;20817:2;20812:3;20808:12;20801:19;;20460:366;;;:::o;20832:419::-;20998:4;21036:2;21025:9;21021:18;21013:26;;21085:9;21079:4;21075:20;21071:1;21060:9;21056:17;21049:47;21113:131;21239:4;21113:131;:::i;:::-;21105:139;;20832:419;;;:::o;21257:173::-;21397:25;21393:1;21385:6;21381:14;21374:49;21257:173;:::o;21436:366::-;21578:3;21599:67;21663:2;21658:3;21599:67;:::i;:::-;21592:74;;21675:93;21764:3;21675:93;:::i;:::-;21793:2;21788:3;21784:12;21777:19;;21436:366;;;:::o;21808:419::-;21974:4;22012:2;22001:9;21997:18;21989:26;;22061:9;22055:4;22051:20;22047:1;22036:9;22032:17;22025:47;22089:131;22215:4;22089:131;:::i;:::-;22081:139;;21808:419;;;:::o;22233:98::-;22284:6;22318:5;22312:12;22302:22;;22233:98;;;:::o;22337:168::-;22420:11;22454:6;22449:3;22442:19;22494:4;22489:3;22485:14;22470:29;;22337:168;;;;:::o;22511:373::-;22597:3;22625:38;22657:5;22625:38;:::i;:::-;22679:70;22742:6;22737:3;22679:70;:::i;:::-;22672:77;;22758:65;22816:6;22811:3;22804:4;22797:5;22793:16;22758:65;:::i;:::-;22848:29;22870:6;22848:29;:::i;:::-;22843:3;22839:39;22832:46;;22601:283;22511:373;;;;:::o;22890:640::-;23085:4;23123:3;23112:9;23108:19;23100:27;;23137:71;23205:1;23194:9;23190:17;23181:6;23137:71;:::i;:::-;23218:72;23286:2;23275:9;23271:18;23262:6;23218:72;:::i;:::-;23300;23368:2;23357:9;23353:18;23344:6;23300:72;:::i;:::-;23419:9;23413:4;23409:20;23404:2;23393:9;23389:18;23382:48;23447:76;23518:4;23509:6;23447:76;:::i;:::-;23439:84;;22890:640;;;;;;;:::o;23536:141::-;23592:5;23623:6;23617:13;23608:22;;23639:32;23665:5;23639:32;:::i;:::-;23536:141;;;;:::o;23683:349::-;23752:6;23801:2;23789:9;23780:7;23776:23;23772:32;23769:119;;;23807:79;;:::i;:::-;23769:119;23927:1;23952:63;24007:7;23998:6;23987:9;23983:22;23952:63;:::i;:::-;23942:73;;23898:127;23683:349;;;;:::o;24038:332::-;24159:4;24197:2;24186:9;24182:18;24174:26;;24210:71;24278:1;24267:9;24263:17;24254:6;24210:71;:::i;:::-;24291:72;24359:2;24348:9;24344:18;24335:6;24291:72;:::i;:::-;24038:332;;;;;:::o

Swarm Source

ipfs://c81516ac226734e5dcad7a2d29747e4794a5d4ca2d021fcecea92ff4393c644a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services