Contract

/**
 *Submitted for verification at Etherscan.io on 2022-10-30
*/

pragma solidity >=0.8.0;

/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 indexed id);

    event Approval(address indexed owner, address indexed spender, uint256 indexed id);

    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /*//////////////////////////////////////////////////////////////
                         METADATA STORAGE/LOGIC
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    function tokenURI(uint256 id) public view virtual returns (string memory);

    /*//////////////////////////////////////////////////////////////
                      ERC721 BALANCE/OWNER STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) internal _ownerOf;

    mapping(address => uint256) internal _balanceOf;

    function ownerOf(uint256 id) public view virtual returns (address owner) {
        require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
    }

    function balanceOf(address owner) public view virtual returns (uint256) {
        require(owner != address(0), "ZERO_ADDRESS");

        return _balanceOf[owner];
    }

    /*//////////////////////////////////////////////////////////////
                         ERC721 APPROVAL STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) public getApproved;

    mapping(address => mapping(address => bool)) public isApprovedForAll;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
    }

    /*//////////////////////////////////////////////////////////////
                              ERC721 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 id) public virtual {
        address owner = _ownerOf[id];

        require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");

        getApproved[id] = spender;

        emit Approval(owner, spender, id);
    }

    function setApprovalForAll(address operator, bool approved) public virtual {
        isApprovedForAll[msg.sender][operator] = approved;

        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function transferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        require(from == _ownerOf[id], "WRONG_FROM");

        require(to != address(0), "INVALID_RECIPIENT");

        require(
            msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
            "NOT_AUTHORIZED"
        );

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        unchecked {
            _balanceOf[from]--;

            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        delete getApproved[id];

        emit Transfer(from, to, id);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    /*//////////////////////////////////////////////////////////////
                              ERC165 LOGIC
    //////////////////////////////////////////////////////////////*/

    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return
            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
            interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
            interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 id) internal virtual {
        require(to != address(0), "INVALID_RECIPIENT");

        require(_ownerOf[id] == address(0), "ALREADY_MINTED");

        // Counter overflow is incredibly unrealistic.
        unchecked {
            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        emit Transfer(address(0), to, id);
    }

    function _burn(uint256 id) internal virtual {
        address owner = _ownerOf[id];

        require(owner != address(0), "NOT_MINTED");

        // Ownership check above ensures no underflow.
        unchecked {
            _balanceOf[owner]--;
        }

        delete _ownerOf[id];

        delete getApproved[id];

        emit Transfer(owner, address(0), id);
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL SAFE MINT LOGIC
    //////////////////////////////////////////////////////////////*/

    function _safeMint(address to, uint256 id) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function _safeMint(
        address to,
        uint256 id,
        bytes memory data
    ) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }
}

/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721TokenReceiver.onERC721Received.selector;
    }
}

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

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

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

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

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

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

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

contract Strategies is ERC721 {
    using Strings for uint256;

    struct Strategy {
        uint256 amount1;
        uint256 amount2;
        uint256 amount3;
    }

    mapping(uint256 => Strategy) public strategies;
    string public baseURI;
    uint256 tokenId;

    constructor() ERC721("Strats", "STRT") {
        baseURI = "https://ipfs.io/ipfs/bafybeichnqc4nsgq632q4lzkw7niefhhlkx6uyunjpqfipibuqk6fivuoe/";
    }

    function mint(address to, Strategy memory strategy) public returns (uint256) {
        _mint(to, ++tokenId);
        strategies[tokenId] = strategy;
        return tokenId;
    }

    function burn(uint256 _tokenId) public {
        _burn(_tokenId);
    }

    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        return string(abi.encodePacked(baseURI, _tokenId.toString()));
    }

    function getStrategy(uint256 chosenStrategy) public view returns (uint256[3] memory) {
        Strategy memory strategy;
        strategy = strategies[chosenStrategy];
        return [strategy.amount1, strategy.amount2, strategy.amount3];
    }
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"id","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":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chosenStrategy","type":"uint256"}],"name":"getStrategy","outputs":[{"internalType":"uint256[3]","name":"","type":"uint256[3]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"uint256","name":"amount2","type":"uint256"},{"internalType":"uint256","name":"amount3","type":"uint256"}],"internalType":"struct Strategies.Strategy","name":"strategy","type":"tuple"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","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":"id","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"strategies","outputs":[{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"uint256","name":"amount2","type":"uint256"},{"internalType":"uint256","name":"amount3","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

22585:1136:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4816:340;;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;4816:340:0;;;;;;;;876:18;;;:::i;:::-;;;;;;;:::i;1849:46::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;1849:46:0;;;;;;-1:-1:-1;;;;;1638:55:1;;;1620:74;;1608:2;1593:18;1849:46:0;1474:226:1;2475:290:0;;;;;;:::i;:::-;;:::i;:::-;;2988:768;;;;;;:::i;:::-;;:::i;3764:409::-;;;;;;:::i;:::-;;:::i;23220:73::-;;;;;;:::i;:::-;;:::i;1318:151::-;;;;;;:::i;:::-;;:::i;22819:21::-;;;:::i;1477:172::-;;;;;;:::i;:::-;;:::i;:::-;;;2835:25:1;;;2823:2;2808:18;1477:172:0;2689:177:1;903:20:0;;;:::i;2773:207::-;;;;;;:::i;:::-;;:::i;4181:441::-;;;;;;:::i;:::-;;:::i;23301:161::-;;;;;;:::i;:::-;;:::i;23470:248::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;22766:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4737:25:1;;;4793:2;4778:18;;4771:34;;;;4821:18;;;4814:34;4725:2;4710:18;22766:46:0;4535:319:1;23030:182:0;;;;;;:::i;:::-;;:::i;1904:68::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;4816:340;4892:4;4929:25;-1:-1:-1;;;;;;4929:25:0;;;;:101;;-1:-1:-1;5005:25:0;-1:-1:-1;;;;;;5005:25:0;;;4929:101;:177;;;-1:-1:-1;5081:25:0;-1:-1:-1;;;;;;5081:25:0;;;4929:177;4909:197;4816:340;-1:-1:-1;;4816:340:0:o;876:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2475:290::-;2547:13;2563:12;;;:8;:12;;;;;;-1:-1:-1;;;;;2563:12:0;2596:10;:19;;;:58;;-1:-1:-1;;;;;;2619:23:0;;;;;;:16;:23;;;;;;;;2643:10;2619:35;;;;;;;;;;2596:58;2588:85;;;;-1:-1:-1;;;2588:85:0;;6843:2:1;2588:85:0;;;6825:21:1;6882:2;6862:18;;;6855:30;6921:16;6901:18;;;6894:44;6955:18;;2588:85:0;;;;;;;;;2686:15;;;;:11;:15;;;;;;:25;;-1:-1:-1;;2686:25:0;-1:-1:-1;;;;;2686:25:0;;;;;;;;;2729:28;;2686:15;;2729:28;;;;;;;2536:229;2475:290;;:::o;2988:768::-;3124:12;;;;:8;:12;;;;;;-1:-1:-1;;;;;3116:20:0;;;3124:12;;3116:20;3108:43;;;;-1:-1:-1;;;3108:43:0;;7186:2:1;3108:43:0;;;7168:21:1;7225:2;7205:18;;;7198:30;7264:12;7244:18;;;7237:40;7294:18;;3108:43:0;6984:334:1;3108:43:0;-1:-1:-1;;;;;3172:16:0;;3164:46;;;;-1:-1:-1;;;3164:46:0;;7525:2:1;3164:46:0;;;7507:21:1;7564:2;7544:18;;;7537:30;7603:19;7583:18;;;7576:47;7640:18;;3164:46:0;7323:341:1;3164:46:0;3245:10;-1:-1:-1;;;;;3245:18:0;;;;:56;;-1:-1:-1;;;;;;3267:22:0;;;;;;:16;:22;;;;;;;;3290:10;3267:34;;;;;;;;;;3245:56;:89;;;-1:-1:-1;3319:15:0;;;;:11;:15;;;;;;-1:-1:-1;;;;;3319:15:0;3305:10;:29;3245:89;3223:153;;;;-1:-1:-1;;;3223:153:0;;6843:2:1;3223:153:0;;;6825:21:1;6882:2;6862:18;;;6855:30;6921:16;6901:18;;;6894:44;6955:18;;3223:153:0;6641:338:1;3223:153:0;-1:-1:-1;;;;;3581:16:0;;;;;;;:10;:16;;;;;;;;:18;;-1:-1:-1;;3581:18:0;;;3616:14;;;;;;;;;:16;;3581:18;3616:16;;;3656:12;;;:8;:12;;;;;:17;;-1:-1:-1;;3656:17:0;;;;;;;;3693:11;:15;;;;;;3686:22;;;;;;;;3726;;3665:2;;3616:14;3581:16;3726:22;;;2988:768;;;:::o;3764:409::-;3888:26;3901:4;3907:2;3911;3888:12;:26::i;:::-;-1:-1:-1;;;;;3949:14:0;;;:19;;:172;;-1:-1:-1;3989:66:0;;-1:-1:-1;;;3989:66:0;;;4030:10;3989:66;;;7997:34:1;-1:-1:-1;;;;;8067:15:1;;;8047:18;;;8040:43;8099:18;;;8092:34;;;8162:3;8142:18;;;8135:31;-1:-1:-1;8182:19:1;;;8175:30;4076:45:0;;3989:40;;;;4076:45;;8222:19:1;;3989:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;3989:132:0;;3949:172;3927:238;;;;-1:-1:-1;;;3927:238:0;;8708:2:1;3927:238:0;;;8690:21:1;8747:2;8727:18;;;8720:30;8786:18;8766;;;8759:46;8822:18;;3927:238:0;8506:340:1;3927:238:0;3764:409;;;:::o;23220:73::-;23270:15;23276:8;23270:5;:15::i;:::-;23220:73;:::o;1318:151::-;1376:13;1419:12;;;:8;:12;;;;;;-1:-1:-1;;;;;1419:12:0;;1402:59;;;;-1:-1:-1;;;1402:59:0;;9053:2:1;1402:59:0;;;9035:21:1;9092:2;9072:18;;;9065:30;-1:-1:-1;;;9111:18:1;;;9104:40;9161:18;;1402:59:0;8851:334:1;1402:59:0;1318:151;;;:::o;22819:21::-;;;;;;;:::i;1477:172::-;1540:7;-1:-1:-1;;;;;1568:19:0;;1560:44;;;;-1:-1:-1;;;1560:44:0;;9392:2:1;1560:44:0;;;9374:21:1;9431:2;9411:18;;;9404:30;9470:14;9450:18;;;9443:42;9502:18;;1560:44:0;9190:336:1;1560:44:0;-1:-1:-1;;;;;;1624:17:0;;;;;:10;:17;;;;;;;1477:172::o;903:20::-;;;;;;;:::i;2773:207::-;2876:10;2859:28;;;;:16;:28;;;;;;;;-1:-1:-1;;;;;2859:38:0;;;;;;;;;;;;:49;;-1:-1:-1;;2859:49:0;;;;;;;;;;2926:46;;586:41:1;;;2859:38:0;;2876:10;2926:46;;559:18:1;2926:46:0;;;;;;;2773:207;;:::o;4181:441::-;4335:26;4348:4;4354:2;4358;4335:12;:26::i;:::-;-1:-1:-1;;;;;4396:14:0;;;:19;;:174;;-1:-1:-1;4436:68:0;;-1:-1:-1;;;4436:68:0;;;4525:45;-1:-1:-1;;;;;4436:40:0;;;4525:45;;4436:68;;4477:10;;4489:4;;4495:2;;4499:4;;;;4436:68;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;4436:134:0;;4396:174;4374:240;;;;-1:-1:-1;;;4374:240:0;;8708:2:1;4374:240:0;;;8690:21:1;8747:2;8727:18;;;8720:30;8786:18;8766;;;8759:46;8822:18;;4374:240:0;8506:340:1;4374:240:0;4181:441;;;;;:::o;23301:161::-;23367:13;23424:7;23433:19;:8;:17;:19::i;:::-;23407:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23393:61;;23301:161;;;:::o;23470:248::-;23536:17;;:::i;:::-;23566:24;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;23566:24:0;-1:-1:-1;;23612:26:0;;;;:10;:26;;;;;;;;;23601:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23649:61;;;;;;;23657:16;;23649:61;;23675:16;;23649:61;;;;;;;23693:16;;23649:61;;;;;;;;23470:248::o;23030:182::-;23098:7;23118:20;23124:2;23130:7;;23128:9;;;;;:::i;:::-;;;;;-1:-1:-1;23118:5:0;:20::i;:::-;-1:-1:-1;23160:7:0;;;23149:19;;;;:10;:19;;;;;;;;;:30;;;;;;;;;;;;;;;;;;;;;23197:7;23030:182;;;;:::o;5748:386::-;5803:13;5819:12;;;:8;:12;;;;;;-1:-1:-1;;;;;5819:12:0;;5844:42;;;;-1:-1:-1;;;5844:42:0;;9053:2:1;5844:42:0;;;9035:21:1;9092:2;9072:18;;;9065:30;-1:-1:-1;;;9111:18:1;;;9104:40;9161:18;;5844:42:0;8851:334:1;5844:42:0;-1:-1:-1;;;;;5980:17:0;;;;;;:10;:17;;;;;;;;:19;;-1:-1:-1;;5980:19:0;;;6030:12;;;:8;:12;;;;;6023:19;;-1:-1:-1;;6023:19:0;;;;;;6062:11;:15;;;;;;6055:22;;;;;;;;6095:31;6039:2;;5980:17;6095:31;;5980:17;;6095:31;5792:342;5748:386;:::o;20691:716::-;20747:13;20798:14;20815:17;20826:5;20815:10;:17::i;:::-;20835:1;20815:21;20798:38;;20851:20;20885:6;20874:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20874:18:0;-1:-1:-1;20851:41:0;-1:-1:-1;21016:28:0;;;21032:2;21016:28;21073:288;-1:-1:-1;;21105:5:0;21247:8;21242:2;21231:14;;21226:30;21105:5;21213:44;21303:2;21294:11;;;-1:-1:-1;21324:21:0;21073:288;21324:21;-1:-1:-1;21382:6:0;20691:716;-1:-1:-1;;;20691:716:0:o;5356:384::-;-1:-1:-1;;;;;5431:16:0;;5423:46;;;;-1:-1:-1;;;5423:46:0;;7525:2:1;5423:46:0;;;7507:21:1;7564:2;7544:18;;;7537:30;7603:19;7583:18;;;7576:47;7640:18;;5423:46:0;7323:341:1;5423:46:0;5514:1;5490:12;;;:8;:12;;;;;;-1:-1:-1;;;;;5490:12:0;:26;5482:53;;;;-1:-1:-1;;;5482:53:0;;12487:2:1;5482:53:0;;;12469:21:1;12526:2;12506:18;;;12499:30;12565:16;12545:18;;;12538:44;12599:18;;5482:53:0;12285:338:1;5482:53:0;-1:-1:-1;;;;;5629:14:0;;;;;;:10;:14;;;;;;;;:16;;;;;;5669:12;;;:8;:12;;;;;;:17;;-1:-1:-1;;5669:17:0;;;;;5704:28;5678:2;;5629:14;;5704:28;;5629:14;;5704:28;5356:384;;:::o;17712:922::-;17765:7;;17852:6;17843:15;;17839:102;;17888:6;17879:15;;;-1:-1:-1;17923:2:0;17913:12;17839:102;17968:6;17959:5;:15;17955:102;;18004:6;17995:15;;;-1:-1:-1;18039:2:0;18029:12;17955:102;18084:6;18075:5;:15;18071:102;;18120:6;18111:15;;;-1:-1:-1;18155:2:0;18145:12;18071:102;18200:5;18191;:14;18187:99;;18235:5;18226:14;;;-1:-1:-1;18269:1:0;18259:11;18187:99;18313:5;18304;:14;18300:99;;18348:5;18339:14;;;-1:-1:-1;18382:1:0;18372:11;18300:99;18426:5;18417;:14;18413:99;;18461:5;18452:14;;;-1:-1:-1;18495:1:0;18485:11;18413:99;18539:5;18530;:14;18526:66;;18575:1;18565:11;18620:6;17712:922;-1:-1:-1;;17712:922:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:177:1:-;-1:-1:-1;;;;;;92:5:1;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;:::-;430:5;196:245;-1:-1:-1;;;196:245:1:o;638:258::-;710:1;720:113;734:6;731:1;728:13;720:113;;;810:11;;;804:18;791:11;;;784:39;756:2;749:10;720:113;;;851:6;848:1;845:13;842:48;;;886:1;877:6;872:3;868:16;861:27;842:48;;638:258;;;:::o;901:383::-;1050:2;1039:9;1032:21;1013:4;1082:6;1076:13;1125:6;1120:2;1109:9;1105:18;1098:34;1141:66;1200:6;1195:2;1184:9;1180:18;1175:2;1167:6;1163:15;1141:66;:::i;:::-;1268:2;1247:15;-1:-1:-1;;1243:29:1;1228:45;;;;1275:2;1224:54;;901:383;-1:-1:-1;;901:383:1:o;1289:180::-;1348:6;1401:2;1389:9;1380:7;1376:23;1372:32;1369:52;;;1417:1;1414;1407:12;1369:52;-1:-1:-1;1440:23:1;;1289:180;-1:-1:-1;1289:180:1:o;1705:196::-;1773:20;;-1:-1:-1;;;;;1822:54:1;;1812:65;;1802:93;;1891:1;1888;1881:12;1906:254;1974:6;1982;2035:2;2023:9;2014:7;2010:23;2006:32;2003:52;;;2051:1;2048;2041:12;2003:52;2074:29;2093:9;2074:29;:::i;:::-;2064:39;2150:2;2135:18;;;;2122:32;;-1:-1:-1;;;1906:254:1:o;2165:328::-;2242:6;2250;2258;2311:2;2299:9;2290:7;2286:23;2282:32;2279:52;;;2327:1;2324;2317:12;2279:52;2350:29;2369:9;2350:29;:::i;:::-;2340:39;;2398:38;2432:2;2421:9;2417:18;2398:38;:::i;:::-;2388:48;;2483:2;2472:9;2468:18;2455:32;2445:42;;2165:328;;;;;:::o;2498:186::-;2557:6;2610:2;2598:9;2589:7;2585:23;2581:32;2578:52;;;2626:1;2623;2616:12;2578:52;2649:29;2668:9;2649:29;:::i;2871:347::-;2936:6;2944;2997:2;2985:9;2976:7;2972:23;2968:32;2965:52;;;3013:1;3010;3003:12;2965:52;3036:29;3055:9;3036:29;:::i;:::-;3026:39;;3115:2;3104:9;3100:18;3087:32;3162:5;3155:13;3148:21;3141:5;3138:32;3128:60;;3184:1;3181;3174:12;3128:60;3207:5;3197:15;;;2871:347;;;;;:::o;3223:808::-;3320:6;3328;3336;3344;3352;3405:3;3393:9;3384:7;3380:23;3376:33;3373:53;;;3422:1;3419;3412:12;3373:53;3445:29;3464:9;3445:29;:::i;:::-;3435:39;;3493:38;3527:2;3516:9;3512:18;3493:38;:::i;:::-;3483:48;;3578:2;3567:9;3563:18;3550:32;3540:42;;3633:2;3622:9;3618:18;3605:32;3656:18;3697:2;3689:6;3686:14;3683:34;;;3713:1;3710;3703:12;3683:34;3751:6;3740:9;3736:22;3726:32;;3796:7;3789:4;3785:2;3781:13;3777:27;3767:55;;3818:1;3815;3808:12;3767:55;3858:2;3845:16;3884:2;3876:6;3873:14;3870:34;;;3900:1;3897;3890:12;3870:34;3945:7;3940:2;3931:6;3927:2;3923:15;3919:24;3916:37;3913:57;;;3966:1;3963;3956:12;3913:57;3223:808;;;;-1:-1:-1;3223:808:1;;-1:-1:-1;3997:2:1;3989:11;;4019:6;3223:808;-1:-1:-1;;;3223:808:1:o;4036:494::-;4216:2;4201:18;;4205:9;4296:6;4174:4;4330:194;4344:4;4341:1;4338:11;4330:194;;;4403:13;;4391:26;;4440:4;4464:12;;;;4499:15;;;;4364:1;4357:9;4330:194;;;4334:3;;;4036:494;;;;:::o;4859:184::-;-1:-1:-1;;;4908:1:1;4901:88;5008:4;5005:1;4998:15;5032:4;5029:1;5022:15;5048:881;5142:6;5150;5194:9;5185:7;5181:23;5224:3;5220:2;5216:12;5213:32;;;5241:1;5238;5231:12;5213:32;5264:29;5283:9;5264:29;:::i;:::-;5254:39;-1:-1:-1;5327:4:1;-1:-1:-1;;5309:16:1;;5305:27;5302:47;;;5345:1;5342;5335:12;5302:47;;5378:2;5372:9;5420:4;5412:6;5408:17;5491:6;5479:10;5476:22;5455:18;5443:10;5440:34;5437:62;5434:242;;;-1:-1:-1;;;5529:1:1;5522:88;5633:4;5630:1;5623:15;5661:4;5658:1;5651:15;5434:242;5696:10;5692:2;5685:22;;5759:2;5748:9;5744:18;5731:32;5723:6;5716:48;5825:2;5814:9;5810:18;5797:32;5792:2;5784:6;5780:15;5773:57;5891:4;5880:9;5876:20;5863:34;5858:2;5850:6;5846:15;5839:59;5917:6;5907:16;;;5048:881;;;;;:::o;5934:260::-;6002:6;6010;6063:2;6051:9;6042:7;6038:23;6034:32;6031:52;;;6079:1;6076;6069:12;6031:52;6102:29;6121:9;6102:29;:::i;:::-;6092:39;;6150:38;6184:2;6173:9;6169:18;6150:38;:::i;:::-;6140:48;;5934:260;;;;;:::o;6199:437::-;6278:1;6274:12;;;;6321;;;6342:61;;6396:4;6388:6;6384:17;6374:27;;6342:61;6449:2;6441:6;6438:14;6418:18;6415:38;6412:218;;-1:-1:-1;;;6483:1:1;6476:88;6587:4;6584:1;6577:15;6615:4;6612:1;6605:15;6412:218;;6199:437;;;:::o;8252:249::-;8321:6;8374:2;8362:9;8353:7;8349:23;8345:32;8342:52;;;8390:1;8387;8380:12;8342:52;8422:9;8416:16;8441:30;8465:5;8441:30;:::i;9531:685::-;9735:4;-1:-1:-1;;;;;9845:2:1;9837:6;9833:15;9822:9;9815:34;9897:2;9889:6;9885:15;9880:2;9869:9;9865:18;9858:43;;9937:6;9932:2;9921:9;9917:18;9910:34;9980:3;9975:2;9964:9;9960:18;9953:31;10021:6;10015:3;10004:9;10000:19;9993:35;10079:6;10071;10065:3;10054:9;10050:19;10037:49;10136:1;10130:3;10121:6;10110:9;10106:22;10102:32;10095:43;10206:3;10199:2;10195:7;10190:2;10182:6;10178:15;10174:29;10163:9;10159:45;10155:55;10147:63;;9531:685;;;;;;;;:::o;10347:185::-;10389:3;10427:5;10421:12;10442:52;10487:6;10482:3;10475:4;10468:5;10464:16;10442:52;:::i;:::-;10510:16;;;;;10347:185;-1:-1:-1;;10347:185:1:o;10537:1260::-;10713:3;10742:1;10775:6;10769:13;10805:3;10827:1;10855:9;10851:2;10847:18;10837:28;;10915:2;10904:9;10900:18;10937;10927:61;;10981:4;10973:6;10969:17;10959:27;;10927:61;11007:2;11055;11047:6;11044:14;11024:18;11021:38;11018:222;;-1:-1:-1;;;11089:3:1;11082:90;11195:4;11192:1;11185:15;11225:4;11220:3;11213:17;11018:222;11256:18;11283:133;;;;11430:1;11425:320;;;;11249:496;;11283:133;-1:-1:-1;;11316:24:1;;11304:37;;11389:14;;11382:22;11370:35;;11361:45;;;-1:-1:-1;11283:133:1;;11425:320;10294:1;10287:14;;;10331:4;10318:18;;11520:1;11534:165;11548:6;11545:1;11542:13;11534:165;;;11626:14;;11613:11;;;11606:35;11669:16;;;;11563:10;;11534:165;;;11538:3;;11728:6;11723:3;11719:16;11712:23;;11249:496;;;;;;;11761:30;11787:3;11779:6;11761:30;:::i;:::-;11754:37;10537:1260;-1:-1:-1;;;;;10537:1260:1:o;11802:289::-;11841:3;11862:17;;;11859:197;;-1:-1:-1;;;11909:1:1;11902:88;12013:4;12010:1;12003:15;12041:4;12038:1;12031:15;11859:197;-1:-1:-1;12083:1:1;12072:13;;11802:289::o

ipfs://8bf2c2f6fc485a14d6f65a5e0d27f8299631df7dd7d946132e2ddbe392d4c1e4