Token Lifestory Planets

 

Overview

TokenID:
350

Transfers:
-

 
Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
LifePlanetNFT

Compiler Version
v0.8.7+commit.e28d00a7

Optimization Enabled:
Yes with 1500 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-06-02
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

// File: contracts/common/meta-transactions/Initializable.sol



pragma solidity ^0.8.0;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}
// File: contracts/common/meta-transactions/EIP712Base.sol



pragma solidity ^0.8.0;


contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    // Lifestory : edit bytes32 salt to uint32 : for easly use
    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,uint32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                uint32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}
// File: contracts/common/meta-transactions/ContentMixin.sol



pragma solidity ^0.8.0;

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}
// File: @openzeppelin/contracts/utils/math/SafeMath.sol



pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    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 substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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 addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: contracts/common/meta-transactions/NativeMetaTransaction.sol



pragma solidity ^0.8.0;



contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}
// File: @openzeppelin/contracts/utils/Counters.sol



pragma solidity ^0.8.0;

/**
 * @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/utils/Strings.sol



pragma solidity ^0.8.0;

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

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

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

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

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

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



pragma solidity ^0.8.0;

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

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

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



pragma solidity ^0.8.0;


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

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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



pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



pragma solidity ^0.8.0;

/**
 * @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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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



pragma solidity ^0.8.0;

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

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



pragma solidity ^0.8.0;


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

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



pragma solidity ^0.8.0;


/**
 * @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`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol



pragma solidity ^0.8.0;


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



pragma solidity ^0.8.0;








/**
 * @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}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @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 override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - 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,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * 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 virtual {
        _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);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @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 virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), 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 virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * 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
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

// File: contracts/ERC721Tradable.sol



pragma solidity ^0.8.0;








contract OwnableDelegateProxy {}

/**
 * Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
 */
contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

/**
 * @title ERC721Tradable
 * ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
 */
abstract contract ERC721Tradable is ERC721, ContextMixin, NativeMetaTransaction, Ownable {
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    //We rely on the OZ Counter util to keep track of the next available ID.
    //We track the nextTokenId instead of the currentTokenId to save users on gas costs. 
    //Read more about it here: https://shiny.mirror.xyz/OUampBbIz9ebEicfGnQf5At_ReMHlZy0tB4glb9xQ0E
    //Lifestory: internal variable to make visible in derived contracts. 
    Counters.Counter internal _nextTokenId;
    address proxyRegistryAddress;

    constructor(
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress
    ) ERC721(_name, _symbol) {
        proxyRegistryAddress = _proxyRegistryAddress;
        // nextTokenId is initialized to 1, since starting at 0 leads to higher gas cost for the first minter
        _nextTokenId.increment();
        _initializeEIP712(_name);
    }

    /**
     * @dev Mints a token to an address with a tokenURI.
     * @dev Lifestory: virtual function to be able to override 
     * @param _to address of the future owner of the token
     */
    function mintTo(address _to) public virtual onlyOwner {
        uint256 currentTokenId = _nextTokenId.current();
        _nextTokenId.increment();
        _safeMint(_to, currentTokenId);
    }

    /**
        @dev Returns the total tokens minted so far.
        1 is always subtracted from the Counter since it tracks the next available tokenId.
     */
    function totalSupply() public view returns (uint256) {
        return _nextTokenId.current() - 1;
    }

    /**
     * @dev Lifestory: set this methode to view to edit this after deploy
     * @dev Lifestory: need for revealing the planets
     */
    function baseTokenURI() virtual public view returns (string memory);

    /**
     * @dev Lifestory: set this methode to view to edit this after deploy
     * @dev Lifestory: need for revealing the planets
     */
    function tokenURI(uint256 _tokenId) override public view returns (string memory) {
        return string(abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId)));
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
     */
    function isApprovedForAll(address owner, address operator)
        override
        public
        view
        returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(owner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
        internal
        override
        view
        returns (address sender)
    {
        return ContextMixin.msgSender();
    }
}
// File: contracts/common/EIP2981/specs/IEIP2981.sol



pragma solidity ^0.8.0;

/**
 * EIP-2981
 */
interface IEIP2981 {
    /**
     * bytes4(keccak256("royaltyInfo(uint256,uint256)")) == 0x2a55205a
     *
     * => 0x2a55205a = 0x2a55205a
     */
    function royaltyInfo(uint256 tokenId, uint256 value) external view returns (address, uint256);
}
// File: contracts/common/EIP2981/IERC721TradableWithRoyalty.sol



pragma solidity ^0.8.0;

/// @author: lifetimeapp.io && manifold.xyz

/**
 * Simple EIP2981 reference override implementation
 */
interface IEIP2981RoyaltyOverride  {

    function setTokenRoyalty(uint256 tokenId, address recipient, uint16 bps) external;

    function setDefaultRoyalty(address recipient, uint16 bps) external;

}
// File: contracts/ERC721TradableWithRoyalty.sol



pragma solidity ^0.8.0;

/// @author: manifold.xyz
/// @author: Abderrahmane Bouali




/**
 * Simple EIP2981 reference override implementation
 */
abstract contract ERC721TradableWithRoyalty is IEIP2981, IEIP2981RoyaltyOverride, ERC721Tradable {

    event TokenRoyaltySet(uint256 tokenId, address recipient, uint16 bps);
    event DefaultRoyaltySet(address recipient, uint16 bps);

    struct TokenRoyalty {
        address recipient;
        uint16 bps;
    }

    TokenRoyalty public defaultRoyalty;
    mapping(uint256 => TokenRoyalty) private _tokenRoyalties;

    constructor(
        string memory _name,
        string memory _symbol,
        address _royaltyRecipient,
        uint16 _royaltyBPS,
        address _proxyRegistryOpenseaAddress
    )
        ERC721Tradable(
            _name,
            _symbol,
            _proxyRegistryOpenseaAddress
        )
    {
      defaultRoyalty = TokenRoyalty(_royaltyRecipient, _royaltyBPS);
    }

    function setTokenRoyalty(uint256 tokenId, address recipient, uint16 bps) public override onlyOwner {
        _tokenRoyalties[tokenId] = TokenRoyalty(recipient, bps);
        emit TokenRoyaltySet(tokenId, recipient, bps);
    }

    function setDefaultRoyalty(address recipient, uint16 bps) public override onlyOwner {
        defaultRoyalty = TokenRoyalty(recipient, bps);
        emit DefaultRoyaltySet(recipient, bps);
    }
    
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
        return interfaceId == type(IEIP2981).interfaceId || interfaceId == type(IEIP2981RoyaltyOverride).interfaceId || super.supportsInterface(interfaceId);
    }

    function royaltyInfo(uint256 tokenId, uint256 value) public override view returns (address, uint256) {
        if (_tokenRoyalties[tokenId].recipient != address(0)) {
            return (_tokenRoyalties[tokenId].recipient, value*_tokenRoyalties[tokenId].bps/10000);
        }
        if (defaultRoyalty.recipient != address(0) && defaultRoyalty.bps != 0) {
            return (defaultRoyalty.recipient, value*defaultRoyalty.bps/10000);
        }
        return (address(0), 0);
    }
}
// File: contracts/LifePlanetNFT.sol



pragma solidity ^0.8.0;



// @author: Abderrahmane Bouali for Lifestory

/**
 * @title LifePlanetNFT
 * LifePlanetNFT - a contract for Life nft.
 */
contract LifePlanetNFT is ERC721TradableWithRoyalty {
    using Counters for Counters.Counter;
    using ECDSA for bytes32;

    uint256 public cost = 0.27 ether; 
    uint256 public maxSupply = 5555;
    uint256 public maxOwnWhitelist = 2;
    uint256 public maxSupplyWhitelist = 200;
    uint256 public whitelistNumber = 0;
    mapping(uint256 => mapping(address => uint256)) public balanceWhitelist;
    
    string URIToken = "https://gateway.pinata.cloud/ipfs/QmU7EX2UTrgN8ykZdsYfmEeyHePgUSJwHJnwtwgzrvncY9?";
    string URIContract = "https://gateway.pinata.cloud/ipfs/Qme7ZBXFpJcjMSDTcFFQpYF9Y9jT7cN1yfpRaYF2UsPi4q";

    address payable private payments;


    // The key used to sign whitelist signatures.
    // We will check to ensure that the key that signed the signature
    // is the one that we expect.
    address public whitelistSigningKey = address(0xf11Ef1920a393A6d9C437B85e1c797be7F50A883);

    // The typehash for the data type specified in the structured data
    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md#rationale-for-typehash
    bytes32 public constant MINTER_TYPEHASH =
        keccak256("Minter(address wallet)");
    
    // Event called when the cost changes
    event ChangedCost(uint256 _cost);

    /**
     * @dev Modifier to check if the sender is in the whitelist 
     * @param signature signature make by whitelistSigningKey
     */
    modifier requiresWhitelist(bytes calldata signature) {
        require(whitelistSigningKey != address(0), "LIFV: Whitelist not enabled");
        // Verify EIP-712 signature by recreating the data structure
        // that we signed on the client side, and then using that to recover
        // the address that signed the signature for this data.
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                EIP712Base.getDomainSeperator(),
                keccak256(abi.encode(MINTER_TYPEHASH, msg.sender))
            )
        );
        // Use the recover method to see what address was used to create
        // the signature on this data.
        // Note that if the digest doesn't exactly match what was signed we'll
        // get a random recovered address.
        address recoveredAddress = digest.recover(signature);
        require(recoveredAddress == whitelistSigningKey, "Invalid Signature");
        _;
    }

    /**
     * @dev constructor of LifePlanetNFT 
     * @param _proxyRegistryOpenseaAddress address of the proxy contract of opensea
     * @param _royaltyBPS RoyaltyBPS
     * @param _payments Lifestory address 
     */
    constructor(address _proxyRegistryOpenseaAddress, address _payments, uint16 _royaltyBPS)
        ERC721TradableWithRoyalty(
            "Lifestory Planets",
            "LIFV",
            _payments,
            _royaltyBPS,
            _proxyRegistryOpenseaAddress
        )
    {
        payments = payable(_payments);
    }
    
    /**
     * @dev function to edit the address to verifiy signature for the whitelist 
     * @param newSigningKey public address on the new signer
     */
    function setWhitelistSigningAddress(address newSigningKey) public onlyOwner {
        whitelistSigningKey = newSigningKey;
    }

    /**
     * @dev Function mint for whitelisted
     * @dev Use the requiresWhitelist modifier to reject the call if a valid signature is not provided 
     * @param signature signature of whitelistSigningKey
     * @param _mintAmount mint amount 
     */
    function mintForWhitelisted(bytes calldata signature, uint256 _mintAmount) public payable requiresWhitelist(signature) {
        require(ERC721Tradable.totalSupply() + _mintAmount <= maxSupply, "LIFV: maximum supply of tokens has been exceeded");
        require(msg.value >= cost * _mintAmount,"LIFV: The amount sent is too low.");

        require(balanceWhitelist[whitelistNumber][msg.sender] + _mintAmount <= maxOwnWhitelist , "LIFV: You exceeded the maximum amount of tokens allowed for this whitelist.");
        require(ERC721Tradable.totalSupply() + _mintAmount <= maxSupplyWhitelist , "LIFV: maximum supply of tokens has been exceeded for this whitelist.");

        /// @notice Safely mint the NFTs
        for (uint256 i = 0; i < _mintAmount; i++) {
            uint256 currentTokenId = _nextTokenId.current();
            _nextTokenId.increment();
            _safeMint(msg.sender, currentTokenId);
            balanceWhitelist[whitelistNumber][msg.sender]++;
        }
    }

    /**
     * @dev Function mint
     * @param _mintAmount mint amount
     */
    function mint(uint256 _mintAmount) public payable {
        require(ERC721Tradable.totalSupply() + _mintAmount <= maxSupply, "LIFV: maximum supply of tokens has been exceeded");
        require(msg.value >= cost * _mintAmount,"LIFV: the amount sent is too low.");
        require(whitelistSigningKey == address(0), "LIFV: whitelist enabled");

        /// @notice Safely mint the NFTs
        for (uint256 i = 0; i < _mintAmount; i++) {
            uint256 currentTokenId = _nextTokenId.current();
            _nextTokenId.increment();
            _safeMint(msg.sender, currentTokenId);
        }
    }

    /**
     * @dev Lifestory : Override function mintTo from Opensea contract ERC721Tradable.sol to avoid overtaking .
     * @dev Mints a token to an address with a tokenURI.
     * @param _to address of the future owner of the token
     */
    function mintTo(address _to) override public onlyOwner {
        require(ERC721Tradable.totalSupply() <= maxSupply, "LIFV: maximum supply of tokens has been exceeded");
        return ERC721Tradable.mintTo(_to);
    }

    /**
     * @dev Mints multiple tokens to an address with a tokenURI.
     * @dev Only the owner can run this function
     * @param _to address of the future owner of the token
     */
    function mintTo(address _to, uint256 _mintAmount) public onlyOwner {
        require(ERC721Tradable.totalSupply() + _mintAmount <= maxSupply, "LIFV: maximum supply of tokens has been exceeded");
        
        for (uint256 i = 0; i < _mintAmount; i++) {
            uint256 currentTokenId = _nextTokenId.current();
            _nextTokenId.increment();
            _safeMint(_to, currentTokenId);
        }
    }
    
    /// @notice Withdraw proceeds from contract address to LIFESTORY address
    function withdraw() public payable onlyOwner {
        require(payable(payments).send(address(this).balance));
    }
    
    /** @notice Reset mint balance for whitelist
     */
    function changeWhitelist() public onlyOwner {
       whitelistNumber++;
    }

    /** @notice Overload function to change whitelist with new cost, new maxSupplyWhitelist and new maxOwnWhitelist
     *  @param _newCost New cost per NFT in Wei
     *  @param _newMaxSupplyWhitelist New maximum supply value for whitelist
     *  @param _newMaxOwnWhitelist New maximum value to own
     */
    function changeWhitelist(uint256 _newCost, uint256 _newMaxSupplyWhitelist, uint256 _newMaxOwnWhitelist) public onlyOwner {
        cost = _newCost;
        maxSupplyWhitelist = _newMaxSupplyWhitelist;
        maxOwnWhitelist = _newMaxOwnWhitelist;
        changeWhitelist();
        emit ChangedCost(cost);
    }

    /** @notice Update the maximum supply when enabling next whitelist
     *  @param _newMaxSupplyWhitelist New maximum supply value for whitelist
     */
    function setMaxSupplyWhitelist(uint256 _newMaxSupplyWhitelist) public onlyOwner {
        maxSupplyWhitelist = _newMaxSupplyWhitelist;
    }
    
    /** @notice Update the maximum you can own when whitelist is enabled
     *  @param _newMaxOwnWhitelist New maximum value to own
     */
    function setMaxOwnWhitelist(uint256 _newMaxOwnWhitelist) public onlyOwner {
        maxOwnWhitelist = _newMaxOwnWhitelist;
    }

    /** @notice Update COST
     *  @param _newCost New cost per NFT in Wei
     */
    function setCost(uint256 _newCost) public onlyOwner {
        cost = _newCost;
        emit ChangedCost(cost);
    }

    /** @notice Update URIToken
     *  @param _newURIToken New URI for the metadatas of NFTs
     */
    function setURIToken(string memory _newURIToken) public onlyOwner {
        URIToken = _newURIToken;
    }

    /** @notice Update URIContract
     *  @param _newURIContract New URI for the metadata of the contract
     */
    function setURIContract(string memory _newURIContract) public onlyOwner {
        URIContract = _newURIContract;
    }

    /** @notice Update payments address
     *  @param _newPayments New address to receive the recipe 
     */
    function setPayments(address _newPayments) public onlyOwner {
        payments = payable(_newPayments);
    }

    /** @notice Get base token uri for metadatas
     */
    function baseTokenURI() override public view returns (string memory) {
        return URIToken;
    }

    /** @notice Get contract metadatas uri 
     */
    function contractURI() public view returns (string memory) {
        return URIContract;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_proxyRegistryOpenseaAddress","type":"address"},{"internalType":"address","name":"_payments","type":"address"},{"internalType":"uint16","name":"_royaltyBPS","type":"uint16"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"ChangedCost","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint16","name":"bps","type":"uint16"}],"name":"DefaultRoyaltySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint16","name":"bps","type":"uint16"}],"name":"TokenRoyaltySet","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":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"balanceWhitelist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"},{"internalType":"uint256","name":"_newMaxSupplyWhitelist","type":"uint256"},{"internalType":"uint256","name":"_newMaxOwnWhitelist","type":"uint256"}],"name":"changeWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"changeWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultRoyalty","outputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint16","name":"bps","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"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":"maxOwnWhitelist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupplyWhitelist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintForWhitelisted","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"mintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint16","name":"bps","type":"uint16"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMaxOwnWhitelist","type":"uint256"}],"name":"setMaxOwnWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMaxSupplyWhitelist","type":"uint256"}],"name":"setMaxSupplyWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newPayments","type":"address"}],"name":"setPayments","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint16","name":"bps","type":"uint16"}],"name":"setTokenRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURIContract","type":"string"}],"name":"setURIContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURIToken","type":"string"}],"name":"setURIToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newSigningKey","type":"address"}],"name":"setWhitelistSigningAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelistNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistSigningKey","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

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

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

000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1000000000000000000000000f4104bf8fdd7a7c4d2e1aa7a27158020d2dd86f300000000000000000000000000000000000000000000000000000000000001f4

-----Decoded View---------------
Arg [0] : _proxyRegistryOpenseaAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1
Arg [1] : _payments (address): 0xF4104Bf8FDD7a7c4d2e1aa7A27158020d2Dd86f3
Arg [2] : _royaltyBPS (uint16): 500

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1
Arg [1] : 000000000000000000000000f4104bf8fdd7a7c4d2e1aa7a27158020d2dd86f3
Arg [2] : 00000000000000000000000000000000000000000000000000000000000001f4


Deployed ByteCode Sourcemap

65747:9220:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64773:266;;;;;;;;;;-1:-1:-1;64773:266:0;;;;;:::i;:::-;;:::i;:::-;;;11934:14:1;;11927:22;11909:41;;11897:2;11882:18;64773:266:0;;;;;;;;47700:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;73592:130::-;;;;;;;;;;-1:-1:-1;73592:130:0;;;;;:::i;:::-;;:::i;:::-;;49259:221;;;;;;;;;;-1:-1:-1;49259:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;10112:55:1;;;10094:74;;10082:2;10067:18;49259:221:0;9948:226:1;48782:411:0;;;;;;;;;;-1:-1:-1;48782:411:0;;;;;:::i;:::-;;:::i;20239:1151::-;;;;;;:::i;:::-;;:::i;9591:43::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65880:32;;;;;;;;;;;;;;;;;;;12107:25:1;;;12095:2;12080:18;65880:32:0;11961:177:1;60940:105:0;;;;;;;;;;;;;:::i;10662:101::-;;;;;;;;;;-1:-1:-1;10740:15:0;;10662:101;;50149:339;;;;;;;;;;-1:-1:-1;50149:339:0;;;;;:::i;:::-;;:::i;65047:491::-;;;;;;;;;;-1:-1:-1;65047:491:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;11659:55:1;;;11641:74;;11746:2;11731:18;;11724:34;;;;11614:18;65047:491:0;11467:297:1;73294:142:0;;;;;;;;;;-1:-1:-1;73294:142:0;;;;;:::i;:::-;;:::i;21816:107::-;;;;;;;;;;-1:-1:-1;21816:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;21903:12:0;21869:13;21903:12;;;:6;:12;;;;;;;21816:107;10771:161;;;;;;;;;;-1:-1:-1;10885:9:0;10771:161;;74049:108;;;;;;;;;;-1:-1:-1;74049:108:0;;;;;:::i;:::-;;:::i;66086:71::-;;;;;;;;;;-1:-1:-1;66086:71:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;72219:118;;;:::i;72809:318::-;;;;;;;;;;-1:-1:-1;72809:318:0;;;;;:::i;:::-;;:::i;74283:120::-;;;;;;;;;;-1:-1:-1;74283:120:0;;;;;:::i;:::-;;:::i;50559:185::-;;;;;;;;;;-1:-1:-1;50559:185:0;;;;;:::i;:::-;;:::i;64564:197::-;;;;;;;;;;-1:-1:-1;64564:197:0;;;;;:::i;:::-;;:::i;71707:422::-;;;;;;;;;;-1:-1:-1;71707:422:0;;;;;:::i;:::-;;:::i;73817:119::-;;;;;;;;;;-1:-1:-1;73817:119:0;;;;;:::i;:::-;;:::i;65999:39::-;;;;;;;;;;;;;;;;66590:88;;;;;;;;;;-1:-1:-1;66590:88:0;;;;-1:-1:-1;;;;;66590:88:0;;;47394:239;;;;;;;;;;-1:-1:-1;47394:239:0;;;;;:::i;:::-;;:::i;47124:208::-;;;;;;;;;;-1:-1:-1;47124:208:0;;;;;:::i;:::-;;:::i;28390:94::-;;;;;;;;;;;;;:::i;71285:220::-;;;;;;;;;;-1:-1:-1;71285:220:0;;;;;:::i;:::-;;:::i;65958:34::-;;;;;;;;;;;;;;;;63817;;;;;;;;;;-1:-1:-1;63817:34:0;;;;-1:-1:-1;;;;;63817:34:0;;;-1:-1:-1;;;63817:34:0;;;;;;;;;;-1:-1:-1;;;;;11344:55:1;;;11326:74;;11448:6;11436:19;;;11431:2;11416:18;;11409:47;11299:18;63817:34:0;11154:308:1;64327:229:0;;;;;;;;;;-1:-1:-1;64327:229:0;;;;;:::i;:::-;;:::i;69322:1001::-;;;;;;:::i;:::-;;:::i;27739:87::-;;;;;;;;;;-1:-1:-1;27812:6:0;;-1:-1:-1;;;;;27812:6:0;27739:87;;47869:104;;;;;;;;;;;;;:::i;70415:613::-;;;;;;:::i;:::-;;:::i;49552:295::-;;;;;;;;;;-1:-1:-1;49552:295:0;;;;;:::i;:::-;;:::i;74525:111::-;;;;;;;;;;-1:-1:-1;74525:111:0;;;;;:::i;:::-;;:::i;50815:328::-;;;;;;;;;;-1:-1:-1;50815:328:0;;;;;:::i;:::-;;:::i;61425:175::-;;;;;;;;;;-1:-1:-1;61425:175:0;;;;;:::i;:::-;;:::i;66045:34::-;;;;;;;;;;;;;;;;68920:130;;;;;;;;;;-1:-1:-1;68920:130:0;;;;;:::i;:::-;;:::i;74703:103::-;;;;;;;;;;;;;:::i;65920:31::-;;;;;;;;;;;;;;;;74868:96;;;;;;;;;;;;;:::i;61732:445::-;;;;;;;;;;-1:-1:-1;61732:445:0;;;;;:::i;:::-;;:::i;28639:192::-;;;;;;;;;;-1:-1:-1;28639:192:0;;;;;:::i;:::-;;:::i;72408:79::-;;;;;;;;;;;;;:::i;66851:86::-;;;;;;;;;;;;66902:35;66851:86;;64773:266;64866:4;-1:-1:-1;;;;;;64890:41:0;;64905:26;64890:41;;:101;;-1:-1:-1;;;;;;;64935:56:0;;64950:41;64935:56;64890:101;:141;;;;64995:36;65019:11;64995:23;:36::i;:::-;64883:148;64773:266;-1:-1:-1;;64773:266:0:o;47700:100::-;47754:13;47787:5;47780:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47700:100;:::o;73592:130::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;;;;;;;;;73677:15:::1;:37:::0;73592:130::o;49259:221::-;49335:7;52742:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52742:16:0;49355:73;;;;-1:-1:-1;;;49355:73:0;;22367:2:1;49355:73:0;;;22349:21:1;22406:2;22386:18;;;22379:30;22445:34;22425:18;;;22418:62;22516:14;22496:18;;;22489:42;22548:19;;49355:73:0;22165:408:1;49355:73:0;-1:-1:-1;49448:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49448:24:0;;49259:221::o;48782:411::-;48863:13;48879:23;48894:7;48879:14;:23::i;:::-;48863:39;;48927:5;-1:-1:-1;;;;;48921:11:0;:2;-1:-1:-1;;;;;48921:11:0;;;48913:57;;;;-1:-1:-1;;;48913:57:0;;24655:2:1;48913:57:0;;;24637:21:1;24694:2;24674:18;;;24667:30;24733:34;24713:18;;;24706:62;24804:3;24784:18;;;24777:31;24825:19;;48913:57:0;24453:397:1;48913:57:0;49021:5;-1:-1:-1;;;;;49005:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;49005:21:0;;:62;;;;49030:37;49047:5;49054:12;:10;:12::i;49030:37::-;48983:168;;;;-1:-1:-1;;;48983:168:0;;19880:2:1;48983:168:0;;;19862:21:1;19919:2;19899:18;;;19892:30;19958:34;19938:18;;;19931:62;20029:26;20009:18;;;20002:54;20073:19;;48983:168:0;19678:420:1;48983:168:0;49164:21;49173:2;49177:7;49164:8;:21::i;:::-;48852:341;48782:411;;:::o;20239:1151::-;20497:152;;;20440:12;20497:152;;;;;-1:-1:-1;;;;;20535:19:0;;20465:29;20535:19;;;:6;:19;;;;;;;;;20497:152;;;;;;;;;;;20684:45;20542:11;20497:152;20712:4;20718;20724;20684:6;:45::i;:::-;20662:128;;;;-1:-1:-1;;;20662:128:0;;23897:2:1;20662:128:0;;;23879:21:1;23936:2;23916:18;;;23909:30;23975:34;23955:18;;;23948:62;24046:3;24026:18;;;24019:31;24067:19;;20662:128:0;23695:397:1;20662:128:0;-1:-1:-1;;;;;20879:19:0;;;;;;:6;:19;;;;;;:26;;20903:1;20879:23;:26::i;:::-;-1:-1:-1;;;;;20857:19:0;;;;;;:6;:19;;;;;;;:48;;;;20923:126;;;;;20864:11;;20995:10;;21021:17;;20923:126;:::i;:::-;;;;;;;;21160:12;21174:23;21209:4;-1:-1:-1;;;;;21201:18:0;21251:17;21270:11;21234:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;21234:48:0;;;;;;;;;;21201:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21159:134;;;;21312:7;21304:48;;;;-1:-1:-1;;;21304:48:0;;16299:2:1;21304:48:0;;;16281:21:1;16338:2;16318:18;;;16311:30;16377;16357:18;;;16350:58;16425:18;;21304:48:0;16097:352:1;21304:48:0;21372:10;20239:1151;-1:-1:-1;;;;;;;;20239:1151:0:o;60940:105::-;60984:7;61036:1;61011:22;:12;23331:14;;23239:114;61011:22;:26;;;;:::i;:::-;61004:33;;60940:105;:::o;50149:339::-;50344:41;50363:12;:10;:12::i;:::-;50377:7;50344:18;:41::i;:::-;50336:103;;;;-1:-1:-1;;;50336:103:0;;25057:2:1;50336:103:0;;;25039:21:1;25096:2;25076:18;;;25069:30;25135:34;25115:18;;;25108:62;25206:19;25186:18;;;25179:47;25243:19;;50336:103:0;24855:413:1;50336:103:0;50452:28;50462:4;50468:2;50472:7;50452:9;:28::i;65047:491::-;65130:7;65163:24;;;:15;:24;;;;;:34;65130:7;;-1:-1:-1;;;;;65163:34:0;:48;65159:166;;65236:24;;;;:15;:24;;;;;:34;-1:-1:-1;;;;;65236:34:0;;;65307:5;;65272:34;;-1:-1:-1;;;65278:28:0;;;;65272:5;:34;:::i;:::-;:40;;;;:::i;:::-;65228:85;;;;;;65159:166;65339:14;:24;-1:-1:-1;;;;;65339:24:0;:38;;;;:65;;-1:-1:-1;65381:14:0;:18;-1:-1:-1;;;65381:18:0;;;;:23;;65339:65;65335:163;;;65429:14;:24;-1:-1:-1;;;;;65429:24:0;;;65480:5;;65455:24;;-1:-1:-1;;;65461:18:0;;;;65455:5;:24;:::i;65335:163::-;-1:-1:-1;65524:1:0;;-1:-1:-1;65524:1:0;65047:491;;;;;;:::o;73294:142::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;73385:18:::1;:43:::0;73294:142::o;74049:108::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;74126:23;;::::1;::::0;:8:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;:::-;;74049:108:::0;:::o;72219:118::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;72291:8:::1;::::0;72283:45:::1;::::0;-1:-1:-1;;;;;72291:8:0;;::::1;::::0;72306:21:::1;72283:45:::0;::::1;;;::::0;72291:8:::1;72283:45:::0;72291:8;72283:45;72306:21;72291:8;72283:45;::::1;;;;;;72275:54;;;::::0;::::1;;72219:118::o:0;72809:318::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;72941:4:::1;:15:::0;;;72967:18:::1;:43:::0;;;73021:15:::1;:37:::0;;;73069:17:::1;:15;:17::i;:::-;73102;73114:4;;73102:17;;;;12107:25:1::0;;12095:2;12080:18;;11961:177;73102:17:0::1;;;;;;;;72809:318:::0;;;:::o;74283:120::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;74366:29;;::::1;::::0;:11:::1;::::0;:29:::1;::::0;::::1;::::0;::::1;:::i;50559:185::-:0;50697:39;50714:4;50720:2;50724:7;50697:39;;;;;;;;;;;;:16;:39::i;64564:197::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;64676:28:::1;::::0;;;;::::1;::::0;;-1:-1:-1;;;;;64676:28:0;::::1;::::0;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;64659:14:::1;:45:::0;;;;;;-1:-1:-1;;;64659:45:0;::::1;;::::0;;64720:33;;11326:74:1;;;11416:18;;;11409:47;;;;64720:33:0::1;::::0;11299:18:1;64720:33:0::1;;;;;;;64564:197:::0;;:::o;71707:422::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;71839:9:::1;;71824:11;71793:28;:26;:28::i;:::-;:42;;;;:::i;:::-;:55;;71785:116;;;::::0;-1:-1:-1;;;71785:116:0;;14294:2:1;71785:116:0::1;::::0;::::1;14276:21:1::0;14333:2;14313:18;;;14306:30;14372:34;14352:18;;;14345:62;-1:-1:-1;;;14423:18:1;;;14416:46;14479:19;;71785:116:0::1;14092:412:1::0;71785:116:0::1;71927:9;71922:200;71946:11;71942:1;:15;71922:200;;;71979:22;72004;:12;23331:14:::0;;23239:114;72004:22:::1;71979:47;;72041:24;:12;23450:19:::0;;23468:1;23450:19;;;23361:127;72041:24:::1;72080:30;72090:3;72095:14;72080:9;:30::i;:::-;-1:-1:-1::0;71959:3:0;::::1;::::0;::::1;:::i;:::-;;;;71922:200;;73817:119:::0;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;73880:4:::1;:15:::0;;;73911:17:::1;::::0;12107:25:1;;;73911:17:0::1;::::0;12095:2:1;12080:18;73911:17:0::1;;;;;;;73817:119:::0;:::o;47394:239::-;47466:7;47502:16;;;:7;:16;;;;;;-1:-1:-1;;;;;47502:16:0;47537:19;47529:73;;;;-1:-1:-1;;;47529:73:0;;20716:2:1;47529:73:0;;;20698:21:1;20755:2;20735:18;;;20728:30;20794:34;20774:18;;;20767:62;20865:11;20845:18;;;20838:39;20894:19;;47529:73:0;20514:405:1;47124:208:0;47196:7;-1:-1:-1;;;;;47224:19:0;;47216:74;;;;-1:-1:-1;;;47216:74:0;;20305:2:1;47216:74:0;;;20287:21:1;20344:2;20324:18;;;20317:30;20383:34;20363:18;;;20356:62;20454:12;20434:18;;;20427:40;20484:19;;47216:74:0;20103:406:1;47216:74:0;-1:-1:-1;;;;;;47308:16:0;;;;;:9;:16;;;;;;;47124:208::o;28390:94::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;28455:21:::1;28473:1;28455:9;:21::i;71285:220::-:0;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;71391:9:::1;;71359:28;:26;:28::i;:::-;:41;;71351:102;;;::::0;-1:-1:-1;;;71351:102:0;;14294:2:1;71351:102:0::1;::::0;::::1;14276:21:1::0;14333:2;14313:18;;;14306:30;14372:34;14352:18;;;14345:62;-1:-1:-1;;;14423:18:1;;;14416:46;14479:19;;71351:102:0::1;14092:412:1::0;71351:102:0::1;71471:26;71493:3;71471:21;:26::i;:::-;71285:220:::0;:::o;64327:229::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;64464:28:::1;::::0;;;;::::1;::::0;;-1:-1:-1;;;;;64464:28:0;;::::1;::::0;;;::::1;::::0;;::::1;;::::0;;::::1;::::0;;;-1:-1:-1;64437:24:0;;;:15:::1;:24:::0;;;;;:55;;;;;;;::::1;::::0;;;;;-1:-1:-1;;;64437:55:0;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;;64508:40;;26007:25:1;;;26048:18;;;26041:83;26140:18;;;26133:47;64508:40:0::1;::::0;25995:2:1;25980:18;64508:40:0::1;25807:379:1::0;69322:1001:0;67253:19;;69430:9;;;;-1:-1:-1;;;;;67253:19:0;67245:73;;;;-1:-1:-1;;;67245:73:0;;24299:2:1;67245:73:0;;;24281:21:1;24338:2;24318:18;;;24311:30;24377:29;24357:18;;;24350:57;24424:18;;67245:73:0;24097:351:1;67245:73:0;67542:14;67647:31;10740:15;;;10662:101;67647:31;67707:39;;;66902:35;67707:39;;;12317:25:1;67735:10:0;12358:18:1;;;12351:83;;;;12290:18;;67707:39:0;;;;;;;;;;;;67697:50;;;;;;67583:179;;;;;;;;-1:-1:-1;;;9757:79:1;;9861:1;9852:11;;9845:27;;;;9897:2;9888:12;;9881:28;9934:2;9925:12;;9499:444;67583:179:0;;;;;;;;;;;;;67559:214;;;;;;67542:231;;68022:24;68049:25;68064:9;;68049:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68049:6:0;;:25;-1:-1:-1;;68049:14:0;:25;-1:-1:-1;68049:25:0:i;:::-;68113:19;;68022:52;;-1:-1:-1;;;;;;68093:39:0;;;68113:19;;68093:39;68085:69;;;;-1:-1:-1;;;68085:69:0;;22780:2:1;68085:69:0;;;22762:21:1;22819:2;22799:18;;;22792:30;22858:19;22838:18;;;22831:47;22895:18;;68085:69:0;22578:341:1;68085:69:0;69506:9:::1;;69491:11;69460:28;:26;:28::i;:::-;:42;;;;:::i;:::-;:55;;69452:116;;;::::0;-1:-1:-1;;;69452:116:0;;14294:2:1;69452:116:0::1;::::0;::::1;14276:21:1::0;14333:2;14313:18;;;14306:30;14372:34;14352:18;;;14345:62;-1:-1:-1;;;14423:18:1;;;14416:46;14479:19;;69452:116:0::1;14092:412:1::0;69452:116:0::1;69607:11;69600:4;;:18;;;;:::i;:::-;69587:9;:31;;69579:76;;;::::0;-1:-1:-1;;;69579:76:0;;18256:2:1;69579:76:0::1;::::0;::::1;18238:21:1::0;18295:2;18275:18;;;18268:30;18334:34;18314:18;;;18307:62;-1:-1:-1;;;18385:18:1;;;18378:31;18426:19;;69579:76:0::1;18054:397:1::0;69579:76:0::1;69739:15;::::0;69693::::1;::::0;69676:33:::1;::::0;;;:16:::1;:33;::::0;;;;;;;69710:10:::1;69676:45:::0;;;;;;;;:59:::1;::::0;69724:11;;69676:59:::1;:::i;:::-;:78;;69668:167;;;::::0;-1:-1:-1;;;69668:167:0;;17772:2:1;69668:167:0::1;::::0;::::1;17754:21:1::0;17811:2;17791:18;;;17784:30;17850:34;17830:18;;;17823:62;17921:34;17901:18;;;17894:62;17993:13;17972:19;;;17965:42;18024:19;;69668:167:0::1;17570:479:1::0;69668:167:0::1;69900:18;;69885:11;69854:28;:26;:28::i;:::-;:42;;;;:::i;:::-;:64;;69846:146;;;::::0;-1:-1:-1;;;69846:146:0;;21126:2:1;69846:146:0::1;::::0;::::1;21108:21:1::0;21165:2;21145:18;;;21138:30;;;21204:34;21184:18;;;21177:62;21275:34;21255:18;;;21248:62;21347:6;21326:19;;;21319:35;21371:19;;69846:146:0::1;20924:472:1::0;69846:146:0::1;70052:9;70047:269;70071:11;70067:1;:15;70047:269;;;70104:22;70129;:12;23331:14:::0;;23239:114;70129:22:::1;70104:47;;70166:24;:12;23450:19:::0;;23468:1;23450:19;;;23361:127;70166:24:::1;70205:37;70215:10;70227:14;70205:9;:37::i;:::-;70274:15;::::0;70257:33:::1;::::0;;;:16:::1;:33;::::0;;;;;;;70291:10:::1;70257:45:::0;;;;;;;:47;;;::::1;::::0;::::1;:::i;:::-;;;;;;70089:227;70084:3;;;;;:::i;:::-;;;;70047:269;;;;67234:940:::0;;69322:1001;;;;;:::o;47869:104::-;47925:13;47958:7;47951:14;;;;;:::i;70415:613::-;70530:9;;70515:11;70484:28;:26;:28::i;:::-;:42;;;;:::i;:::-;:55;;70476:116;;;;-1:-1:-1;;;70476:116:0;;14294:2:1;70476:116:0;;;14276:21:1;14333:2;14313:18;;;14306:30;14372:34;14352:18;;;14345:62;-1:-1:-1;;;14423:18:1;;;14416:46;14479:19;;70476:116:0;14092:412:1;70476:116:0;70631:11;70624:4;;:18;;;;:::i;:::-;70611:9;:31;;70603:76;;;;-1:-1:-1;;;70603:76:0;;14711:2:1;70603:76:0;;;14693:21:1;14750:2;14730:18;;;14723:30;14789:34;14769:18;;;14762:62;-1:-1:-1;;;14840:18:1;;;14833:31;14881:19;;70603:76:0;14509:397:1;70603:76:0;70698:19;;-1:-1:-1;;;;;70698:19:0;:33;70690:69;;;;-1:-1:-1;;;70690:69:0;;25475:2:1;70690:69:0;;;25457:21:1;25514:2;25494:18;;;25487:30;25553:25;25533:18;;;25526:53;25596:18;;70690:69:0;25273:347:1;70690:69:0;70819:9;70814:207;70838:11;70834:1;:15;70814:207;;;70871:22;70896;:12;23331:14;;23239:114;70896:22;70871:47;;70933:24;:12;23450:19;;23468:1;23450:19;;;23361:127;70933:24;70972:37;70982:10;70994:14;70972:9;:37::i;:::-;-1:-1:-1;70851:3:0;;;;:::i;:::-;;;;70814:207;;49552:295;49667:12;:10;:12::i;:::-;-1:-1:-1;;;;;49655:24:0;:8;-1:-1:-1;;;;;49655:24:0;;;49647:62;;;;-1:-1:-1;;;49647:62:0;;17418:2:1;49647:62:0;;;17400:21:1;17457:2;17437:18;;;17430:30;17496:27;17476:18;;;17469:55;17541:18;;49647:62:0;17216:349:1;49647:62:0;49767:8;49722:18;:32;49741:12;:10;:12::i;:::-;-1:-1:-1;;;;;49722:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;49722:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;49722:53:0;;;;;;;;;;;49806:12;:10;:12::i;:::-;-1:-1:-1;;;;;49791:48:0;;49830:8;49791:48;;;;11934:14:1;11927:22;11909:41;;11897:2;11882:18;;11769:187;49791:48:0;;;;;;;;49552:295;;:::o;74525:111::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;74596:8:::1;:32:::0;;-1:-1:-1;;74596:32:0::1;-1:-1:-1::0;;;;;74596:32:0;;;::::1;::::0;;;::::1;::::0;;74525:111::o;50815:328::-;50990:41;51009:12;:10;:12::i;:::-;51023:7;50990:18;:41::i;:::-;50982:103;;;;-1:-1:-1;;;50982:103:0;;25057:2:1;50982:103:0;;;25039:21:1;25096:2;25076:18;;;25069:30;25135:34;25115:18;;;25108:62;25206:19;25186:18;;;25179:47;25243:19;;50982:103:0;24855:413:1;50982:103:0;51096:39;51110:4;51116:2;51120:7;51129:5;51096:13;:39::i;:::-;50815:328;;;;:::o;61425:175::-;61491:13;61548:14;:12;:14::i;:::-;61564:26;61581:8;61564:16;:26::i;:::-;61531:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;61517:75;;61425:175;;;:::o;68920:130::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;69007:19:::1;:35:::0;;-1:-1:-1;;69007:35:0::1;-1:-1:-1::0;;;;;69007:35:0;;;::::1;::::0;;;::::1;::::0;;68920:130::o;74703:103::-;74757:13;74790:8;74783:15;;;;;:::i;74868:96::-;74912:13;74945:11;74938:18;;;;;:::i;61732:445::-;61986:20;;62030:28;;;;;-1:-1:-1;;;;;10112:55:1;;;62030:28:0;;;10094:74:1;61857:4:0;;61986:20;;;62022:49;;;;61986:20;;62030:21;;10067:18:1;;62030:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;62022:49:0;;62018:93;;;62095:4;62088:11;;;;;62018:93;-1:-1:-1;;;;;50039:25:0;;;50015:4;50039:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;62130:39;62123:46;61732:445;-1:-1:-1;;;;61732:445:0:o;28639:192::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;-1:-1:-1;;;;;28728:22:0;::::1;28720:73;;;::::0;-1:-1:-1;;;28720:73:0;;15892:2:1;28720:73:0::1;::::0;::::1;15874:21:1::0;15931:2;15911:18;;;15904:30;15970:34;15950:18;;;15943:62;16041:8;16021:18;;;16014:36;16067:19;;28720:73:0::1;15690:402:1::0;28720:73:0::1;28804:19;28814:8;28804:9;:19::i;72408:79::-:0;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;72462:15:::1;:17:::0;;;:15:::1;:17;::::0;::::1;:::i;:::-;;;;;;72408:79::o:0;23361:127::-;23450:19;;23468:1;23450:19;;;23361:127::o;11697:650::-;11768:22;11812:10;11834:4;11812:27;11808:508;;;11856:18;11877:8;;11856:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;11916:8:0;12127:17;12121:24;-1:-1:-1;;;;;12095:134:0;;-1:-1:-1;11808:508:0;;-1:-1:-1;11808:508:0;;-1:-1:-1;12293:10:0;11808:508;11697:650;:::o;46755:305::-;46857:4;-1:-1:-1;;;;;;46894:40:0;;46909:25;46894:40;;:105;;-1:-1:-1;;;;;;;46951:48:0;;46966:33;46951:48;46894:105;:158;;;-1:-1:-1;39849:25:0;-1:-1:-1;;;;;;39834:40:0;;;47016:36;39725:157;62321:161;62411:14;62450:24;:22;:24::i;56635:174::-;56710:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;56710:29:0;-1:-1:-1;;;;;56710:29:0;;;;;;;;:24;;56764:23;56710:24;56764:14;:23::i;:::-;-1:-1:-1;;;;;56755:46:0;;;;;;;;;;;56635:174;;:::o;21931:486::-;22109:4;-1:-1:-1;;;;;22134:20:0;;22126:70;;;;-1:-1:-1;;;22126:70:0;;19474:2:1;22126:70:0;;;19456:21:1;19513:2;19493:18;;;19486:30;19552:34;19532:18;;;19525:62;19623:7;19603:18;;;19596:35;19648:19;;22126:70:0;19272:401:1;22126:70:0;22250:159;22278:47;22297:27;22317:6;22297:19;:27::i;:::-;22278:18;:47::i;:::-;22250:159;;;;;;;;;;;;13117:25:1;;;;13190:4;13178:17;;13158:18;;;13151:45;13212:18;;;13205:34;;;13255:18;;;13248:34;;;13089:19;;22250:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22227:182:0;:6;-1:-1:-1;;;;;22227:182:0;;22207:202;;21931:486;;;;;;;:::o;15144:98::-;15202:7;15229:5;15233:1;15229;:5;:::i;:::-;15222:12;15144:98;-1:-1:-1;;;15144:98:0:o;52947:348::-;53040:4;52742:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52742:16:0;53057:73;;;;-1:-1:-1;;;53057:73:0;;19061:2:1;53057:73:0;;;19043:21:1;19100:2;19080:18;;;19073:30;19139:34;19119:18;;;19112:62;19210:14;19190:18;;;19183:42;19242:19;;53057:73:0;18859:408:1;53057:73:0;53141:13;53157:23;53172:7;53157:14;:23::i;:::-;53141:39;;53210:5;-1:-1:-1;;;;;53199:16:0;:7;-1:-1:-1;;;;;53199:16:0;;:51;;;;53243:7;-1:-1:-1;;;;;53219:31:0;:20;53231:7;53219:11;:20::i;:::-;-1:-1:-1;;;;;53219:31:0;;53199:51;:87;;;;53254:32;53271:5;53278:7;53254:16;:32::i;55939:578::-;56098:4;-1:-1:-1;;;;;56071:31:0;:23;56086:7;56071:14;:23::i;:::-;-1:-1:-1;;;;;56071:31:0;;56063:85;;;;-1:-1:-1;;;56063:85:0;;23487:2:1;56063:85:0;;;23469:21:1;23526:2;23506:18;;;23499:30;23565:34;23545:18;;;23538:62;23636:11;23616:18;;;23609:39;23665:19;;56063:85:0;23285:405:1;56063:85:0;-1:-1:-1;;;;;56167:16:0;;56159:65;;;;-1:-1:-1;;;56159:65:0;;17013:2:1;56159:65:0;;;16995:21:1;17052:2;17032:18;;;17025:30;17091:34;17071:18;;;17064:62;17162:6;17142:18;;;17135:34;17186:19;;56159:65:0;16811:400:1;56159:65:0;56341:29;56358:1;56362:7;56341:8;:29::i;:::-;-1:-1:-1;;;;;56383:15:0;;;;;;:9;:15;;;;;:20;;56402:1;;56383:15;:20;;56402:1;;56383:20;:::i;:::-;;;;-1:-1:-1;;;;;;;56414:13:0;;;;;;:9;:13;;;;;:18;;56431:1;;56414:13;:18;;56431:1;;56414:18;:::i;:::-;;;;-1:-1:-1;;56443:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;56443:21:0;-1:-1:-1;;;;;56443:21:0;;;;;;;;;56482:27;;56443:16;;56482:27;;;;;;;55939:578;;;:::o;53637:110::-;53713:26;53723:2;53727:7;53713:26;;;;;;;;;;;;:9;:26::i;28839:173::-;28914:6;;;-1:-1:-1;;;;;28931:17:0;;;-1:-1:-1;;28931:17:0;;;;;;;28964:40;;28914:6;;;28931:17;28914:6;;28964:40;;28895:16;;28964:40;28884:128;28839:173;:::o;60571:196::-;27970:12;:10;:12::i;:::-;-1:-1:-1;;;;;27959:23:0;:7;27812:6;;-1:-1:-1;;;;;27812:6:0;;27739:87;27959:7;-1:-1:-1;;;;;27959:23:0;;27951:68;;;;-1:-1:-1;;;27951:68:0;;23126:2:1;27951:68:0;;;23108:21:1;;;23145:18;;;23138:30;-1:-1:-1;;;;;;;;;;;23184:18:1;;;23177:62;23256:18;;27951:68:0;22924:356:1;27951:68:0;60636:22:::1;60661;:12;23331:14:::0;;23239:114;60661:22:::1;60636:47;;60694:24;:12;23450:19:::0;;23468:1;23450:19;;;23361:127;60694:24:::1;60729:30;60739:3;60744:14;60729:9;:30::i;4368:231::-:0;4446:7;4467:17;4486:18;4508:27;4519:4;4525:9;4508:10;:27::i;:::-;4466:69;;;;4546:18;4558:5;4546:11;:18::i;:::-;-1:-1:-1;4582:9:0;4368:231;-1:-1:-1;;;4368:231:0:o;52025:315::-;52182:28;52192:4;52198:2;52202:7;52182:9;:28::i;:::-;52229:48;52252:4;52258:2;52262:7;52271:5;52229:22;:48::i;:::-;52221:111;;;;-1:-1:-1;;;52221:111:0;;15473:2:1;52221:111:0;;;15455:21:1;15512:2;15492:18;;;15485:30;15551:34;15531:18;;;15524:62;15622:20;15602:18;;;15595:48;15660:19;;52221:111:0;15271:414:1;24143:723:0;24199:13;24420:10;24416:53;;-1:-1:-1;;24447:10:0;;;;;;;;;;;;;;;;;;24143:723::o;24416:53::-;24494:5;24479:12;24535:78;24542:9;;24535:78;;24568:8;;;;:::i;:::-;;-1:-1:-1;24591:10:0;;-1:-1:-1;24599:2:0;24591:10;;:::i;:::-;;;24535:78;;;24623:19;24655:6;24645:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24645:17:0;;24623:39;;24673:154;24680:10;;24673:154;;24707:11;24717:1;24707:11;;:::i;:::-;;-1:-1:-1;24776:10:0;24784:2;24776:5;:10;:::i;:::-;24763:24;;:2;:24;:::i;:::-;24750:39;;24733:6;24740;24733:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;24804:11:0;24813:2;24804:11;;:::i;:::-;;;24673:154;;21398:410;21508:7;19575:100;;;;;;;;;;;;;;;;;19555:127;;;;;;;21662:12;;21697:11;;;;21741:24;;;;;21731:35;;;;;;21581:204;;;;;12676:25:1;;;12732:2;12717:18;;12710:34;;;;-1:-1:-1;;;;;12780:55:1;12775:2;12760:18;;12753:83;12867:2;12852:18;;12845:34;12663:3;12648:19;;12445:440;21581:204:0;;;;;;;;;;;;;21553:247;;;;;;21533:267;;21398:410;;;:::o;11301:258::-;11400:7;11502:20;10740:15;;;10662:101;11502:20;11473:63;;-1:-1:-1;;;11473:63:0;;;9757:79:1;9852:11;;;9845:27;;;;9888:12;;;9881:28;;;9925:12;;11473:63:0;9499:444:1;53974:321:0;54104:18;54110:2;54114:7;54104:5;:18::i;:::-;54155:54;54186:1;54190:2;54194:7;54203:5;54155:22;:54::i;:::-;54133:154;;;;-1:-1:-1;;;54133:154:0;;15473:2:1;54133:154:0;;;15455:21:1;15512:2;15492:18;;;15485:30;15551:34;15531:18;;;15524:62;15622:20;15602:18;;;15595:48;15660:19;;54133:154:0;15271:414:1;2258:1308:0;2339:7;2348:12;2573:9;:16;2593:2;2573:22;2569:990;;;2869:4;2854:20;;2848:27;2919:4;2904:20;;2898:27;2977:4;2962:20;;2956:27;2612:9;2948:36;3020:25;3031:4;2948:36;2848:27;2898;3020:10;:25::i;:::-;3013:32;;;;;;;;;2569:990;3067:9;:16;3087:2;3067:22;3063:496;;;3342:4;3327:20;;3321:27;3393:4;3378:20;;3372:27;3435:23;3446:4;3321:27;3372;3435:10;:23::i;:::-;3428:30;;;;;;;;3063:496;-1:-1:-1;3507:1:0;;-1:-1:-1;3511:35:0;3491:56;;529:643;607:20;598:5;:29;;;;;;;;:::i;:::-;;594:571;;;529:643;:::o;594:571::-;705:29;696:5;:38;;;;;;;;:::i;:::-;;692:473;;;751:34;;-1:-1:-1;;;751:34:0;;13941:2:1;751:34:0;;;13923:21:1;13980:2;13960:18;;;13953:30;14019:26;13999:18;;;13992:54;14063:18;;751:34:0;13739:348:1;692:473:0;816:35;807:5;:44;;;;;;;;:::i;:::-;;803:362;;;868:41;;-1:-1:-1;;;868:41:0;;15113:2:1;868:41:0;;;15095:21:1;15152:2;15132:18;;;15125:30;15191:33;15171:18;;;15164:61;15242:18;;868:41:0;14911:355:1;803:362:0;940:30;931:5;:39;;;;;;;;:::i;:::-;;927:238;;;987:44;;-1:-1:-1;;;987:44:0;;18658:2:1;987:44:0;;;18640:21:1;18697:2;18677:18;;;18670:30;18736:34;18716:18;;;18709:62;-1:-1:-1;;;18787:18:1;;;18780:32;18829:19;;987:44:0;18456:398:1;927:238:0;1062:30;1053:5;:39;;;;;;;;:::i;:::-;;1049:116;;;1109:44;;-1:-1:-1;;;1109:44:0;;21603:2:1;1109:44:0;;;21585:21:1;21642:2;21622:18;;;21615:30;21681:34;21661:18;;;21654:62;-1:-1:-1;;;21732:18:1;;;21725:32;21774:19;;1109:44:0;21401:398:1;57374:799:0;57529:4;-1:-1:-1;;;;;57550:13:0;;30108:20;30156:8;57546:620;;57602:2;-1:-1:-1;;;;;57586:36:0;;57623:12;:10;:12::i;:::-;57637:4;57643:7;57652:5;57586:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57586:72:0;;;;;;;;-1:-1:-1;;57586:72:0;;;;;;;;;;;;:::i;:::-;;;57582:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57828:13:0;;57824:272;;57871:60;;-1:-1:-1;;;57871:60:0;;15473:2:1;57871:60:0;;;15455:21:1;15512:2;15492:18;;;15485:30;15551:34;15531:18;;;15524:62;15622:20;15602:18;;;15595:48;15660:19;;57871:60:0;15271:414:1;57824:272:0;58046:6;58040:13;58031:6;58027:2;58023:15;58016:38;57582:529;-1:-1:-1;;;;;;57709:51:0;57719:41;57709:51;;-1:-1:-1;57702:58:0;;57546:620;-1:-1:-1;58150:4:0;57374:799;;;;;;:::o;54631:382::-;-1:-1:-1;;;;;54711:16:0;;54703:61;;;;-1:-1:-1;;;54703:61:0;;22006:2:1;54703:61:0;;;21988:21:1;;;22025:18;;;22018:30;22084:34;22064:18;;;22057:62;22136:18;;54703:61:0;21804:356:1;54703:61:0;52718:4;52742:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52742:16:0;:30;54775:58;;;;-1:-1:-1;;;54775:58:0;;16656:2:1;54775:58:0;;;16638:21:1;16695:2;16675:18;;;16668:30;16734;16714:18;;;16707:58;16782:18;;54775:58:0;16454:352:1;54775:58:0;-1:-1:-1;;;;;54904:13:0;;;;;;:9;:13;;;;;:18;;54921:1;;54904:13;:18;;54921:1;;54904:18;:::i;:::-;;;;-1:-1:-1;;54933:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;54933:21:0;-1:-1:-1;;;;;54933:21:0;;;;;;;;54972:33;;54933:16;;;54972:33;;54933:16;;54972:33;54631:382;;:::o;5867:1632::-;5998:7;;6932:66;6919:79;;6915:163;;;-1:-1:-1;7031:1:0;;-1:-1:-1;7035:30:0;7015:51;;6915:163;7092:1;:7;;7097:2;7092:7;;:18;;;;;7103:1;:7;;7108:2;7103:7;;7092:18;7088:102;;;-1:-1:-1;7143:1:0;;-1:-1:-1;7147:30:0;7127:51;;7088:102;7304:24;;;7287:14;7304:24;;;;;;;;;13117:25:1;;;13190:4;13178:17;;13158:18;;;13151:45;;;;13212:18;;;13205:34;;;13255:18;;;13248:34;;;7304:24:0;;13089:19:1;;7304:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7304:24:0;;-1:-1:-1;;7304:24:0;;;-1:-1:-1;;;;;;;7343:20:0;;7339:103;;7396:1;7400:29;7380:50;;;;;;;7339:103;7462:6;-1:-1:-1;7470:20:0;;-1:-1:-1;5867:1632:0;;;;;;;;:::o;4862:391::-;4976:7;;5085:66;5077:75;;5179:3;5175:12;;;5189:2;5171:21;5220:25;5231:4;5171:21;5240:1;5077:75;5220:10;:25::i;:::-;5213:32;;;;;;4862:391;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:220::-;692:5;745:3;738:4;730:6;726:17;722:27;712:55;;763:1;760;753:12;712:55;785:79;860:3;851:6;838:20;831:4;823:6;819:17;785:79;:::i;875:159::-;942:20;;1002:6;991:18;;981:29;;971:57;;1024:1;1021;1014:12;971:57;875:159;;;:::o;1039:247::-;1098:6;1151:2;1139:9;1130:7;1126:23;1122:32;1119:52;;;1167:1;1164;1157:12;1119:52;1206:9;1193:23;1225:31;1250:5;1225:31;:::i;1291:388::-;1359:6;1367;1420:2;1408:9;1399:7;1395:23;1391:32;1388:52;;;1436:1;1433;1426:12;1388:52;1475:9;1462:23;1494:31;1519:5;1494:31;:::i;:::-;1544:5;-1:-1:-1;1601:2:1;1586:18;;1573:32;1614:33;1573:32;1614:33;:::i;:::-;1666:7;1656:17;;;1291:388;;;;;:::o;1684:456::-;1761:6;1769;1777;1830:2;1818:9;1809:7;1805:23;1801:32;1798:52;;;1846:1;1843;1836:12;1798:52;1885:9;1872:23;1904:31;1929:5;1904:31;:::i;:::-;1954:5;-1:-1:-1;2011:2:1;1996:18;;1983:32;2024:33;1983:32;2024:33;:::i;:::-;1684:456;;2076:7;;-1:-1:-1;;;2130:2:1;2115:18;;;;2102:32;;1684:456::o;2145:665::-;2240:6;2248;2256;2264;2317:3;2305:9;2296:7;2292:23;2288:33;2285:53;;;2334:1;2331;2324:12;2285:53;2373:9;2360:23;2392:31;2417:5;2392:31;:::i;:::-;2442:5;-1:-1:-1;2499:2:1;2484:18;;2471:32;2512:33;2471:32;2512:33;:::i;:::-;2564:7;-1:-1:-1;2618:2:1;2603:18;;2590:32;;-1:-1:-1;2673:2:1;2658:18;;2645:32;2700:18;2689:30;;2686:50;;;2732:1;2729;2722:12;2686:50;2755:49;2796:7;2787:6;2776:9;2772:22;2755:49;:::i;:::-;2745:59;;;2145:665;;;;;;;:::o;2815:416::-;2880:6;2888;2941:2;2929:9;2920:7;2916:23;2912:32;2909:52;;;2957:1;2954;2947:12;2909:52;2996:9;2983:23;3015:31;3040:5;3015:31;:::i;:::-;3065:5;-1:-1:-1;3122:2:1;3107:18;;3094:32;3164:15;;3157:23;3145:36;;3135:64;;3195:1;3192;3185:12;3236:758;3338:6;3346;3354;3362;3370;3423:3;3411:9;3402:7;3398:23;3394:33;3391:53;;;3440:1;3437;3430:12;3391:53;3479:9;3466:23;3498:31;3523:5;3498:31;:::i;:::-;3548:5;-1:-1:-1;3604:2:1;3589:18;;3576:32;3631:18;3620:30;;3617:50;;;3663:1;3660;3653:12;3617:50;3686:49;3727:7;3718:6;3707:9;3703:22;3686:49;:::i;:::-;3676:59;;;3782:2;3771:9;3767:18;3754:32;3744:42;;3833:2;3822:9;3818:18;3805:32;3795:42;;3889:3;3878:9;3874:19;3861:33;3938:4;3929:7;3925:18;3916:7;3913:31;3903:59;;3958:1;3955;3948:12;3903:59;3981:7;3971:17;;;3236:758;;;;;;;;:::o;3999:319::-;4066:6;4074;4127:2;4115:9;4106:7;4102:23;4098:32;4095:52;;;4143:1;4140;4133:12;4095:52;4182:9;4169:23;4201:31;4226:5;4201:31;:::i;:::-;4251:5;-1:-1:-1;4275:37:1;4308:2;4293:18;;4275:37;:::i;:::-;4265:47;;3999:319;;;;;:::o;4323:315::-;4391:6;4399;4452:2;4440:9;4431:7;4427:23;4423:32;4420:52;;;4468:1;4465;4458:12;4420:52;4507:9;4494:23;4526:31;4551:5;4526:31;:::i;:::-;4576:5;4628:2;4613:18;;;;4600:32;;-1:-1:-1;;;4323:315:1:o;4643:245::-;4701:6;4754:2;4742:9;4733:7;4729:23;4725:32;4722:52;;;4770:1;4767;4760:12;4722:52;4809:9;4796:23;4828:30;4852:5;4828:30;:::i;4893:249::-;4962:6;5015:2;5003:9;4994:7;4990:23;4986:32;4983:52;;;5031:1;5028;5021:12;4983:52;5063:9;5057:16;5082:30;5106:5;5082:30;:::i;5147:665::-;5226:6;5234;5242;5295:2;5283:9;5274:7;5270:23;5266:32;5263:52;;;5311:1;5308;5301:12;5263:52;5351:9;5338:23;5380:18;5421:2;5413:6;5410:14;5407:34;;;5437:1;5434;5427:12;5407:34;5475:6;5464:9;5460:22;5450:32;;5520:7;5513:4;5509:2;5505:13;5501:27;5491:55;;5542:1;5539;5532:12;5491:55;5582:2;5569:16;5608:2;5600:6;5597:14;5594:34;;;5624:1;5621;5614:12;5594:34;5671:7;5664:4;5655:6;5651:2;5647:15;5643:26;5640:39;5637:59;;;5692:1;5689;5682:12;5637:59;5723:4;5715:13;;;;5747:6;;-1:-1:-1;5785:20:1;;;;5772:34;;5147:665;-1:-1:-1;;;;5147:665:1:o;5817:280::-;5916:6;5969:2;5957:9;5948:7;5944:23;5940:32;5937:52;;;5985:1;5982;5975:12;5937:52;6017:9;6011:16;6036:31;6061:5;6036:31;:::i;6102:450::-;6171:6;6224:2;6212:9;6203:7;6199:23;6195:32;6192:52;;;6240:1;6237;6230:12;6192:52;6280:9;6267:23;6313:18;6305:6;6302:30;6299:50;;;6345:1;6342;6335:12;6299:50;6368:22;;6421:4;6413:13;;6409:27;-1:-1:-1;6399:55:1;;6450:1;6447;6440:12;6399:55;6473:73;6538:7;6533:2;6520:16;6515:2;6511;6507:11;6473:73;:::i;6557:180::-;6616:6;6669:2;6657:9;6648:7;6644:23;6640:32;6637:52;;;6685:1;6682;6675:12;6637:52;-1:-1:-1;6708:23:1;;6557:180;-1:-1:-1;6557:180:1:o;6742:315::-;6810:6;6818;6871:2;6859:9;6850:7;6846:23;6842:32;6839:52;;;6887:1;6884;6877:12;6839:52;6923:9;6910:23;6900:33;;6983:2;6972:9;6968:18;6955:32;6996:31;7021:5;6996:31;:::i;7062:387::-;7138:6;7146;7154;7207:2;7195:9;7186:7;7182:23;7178:32;7175:52;;;7223:1;7220;7213:12;7175:52;7259:9;7246:23;7236:33;;7319:2;7308:9;7304:18;7291:32;7332:31;7357:5;7332:31;:::i;:::-;7382:5;-1:-1:-1;7406:37:1;7439:2;7424:18;;7406:37;:::i;:::-;7396:47;;7062:387;;;;;:::o;7454:248::-;7522:6;7530;7583:2;7571:9;7562:7;7558:23;7554:32;7551:52;;;7599:1;7596;7589:12;7551:52;-1:-1:-1;;7622:23:1;;;7692:2;7677:18;;;7664:32;;-1:-1:-1;7454:248:1:o;7707:316::-;7784:6;7792;7800;7853:2;7841:9;7832:7;7828:23;7824:32;7821:52;;;7869:1;7866;7859:12;7821:52;-1:-1:-1;;7892:23:1;;;7962:2;7947:18;;7934:32;;-1:-1:-1;8013:2:1;7998:18;;;7985:32;;7707:316;-1:-1:-1;7707:316:1:o;8028:257::-;8069:3;8107:5;8101:12;8134:6;8129:3;8122:19;8150:63;8206:6;8199:4;8194:3;8190:14;8183:4;8176:5;8172:16;8150:63;:::i;:::-;8267:2;8246:15;-1:-1:-1;;8242:29:1;8233:39;;;;8274:4;8229:50;;8028:257;-1:-1:-1;;8028:257:1:o;8290:274::-;8419:3;8457:6;8451:13;8473:53;8519:6;8514:3;8507:4;8499:6;8495:17;8473:53;:::i;:::-;8542:16;;;;;8290:274;-1:-1:-1;;8290:274:1:o;8569:450::-;8726:3;8764:6;8758:13;8780:53;8826:6;8821:3;8814:4;8806:6;8802:17;8780:53;:::i;:::-;8902:2;8898:15;;;;8915:66;8894:88;8855:16;;;;8880:103;;;9010:2;8999:14;;8569:450;-1:-1:-1;;8569:450:1:o;9024:470::-;9203:3;9241:6;9235:13;9257:53;9303:6;9298:3;9291:4;9283:6;9279:17;9257:53;:::i;:::-;9373:13;;9332:16;;;;9395:57;9373:13;9332:16;9429:4;9417:17;;9395:57;:::i;:::-;9468:20;;9024:470;-1:-1:-1;;;;9024:470:1:o;10179:454::-;10361:4;-1:-1:-1;;;;;10471:2:1;10463:6;10459:15;10448:9;10441:34;10523:2;10515:6;10511:15;10506:2;10495:9;10491:18;10484:43;;10563:2;10558;10547:9;10543:18;10536:30;10583:44;10623:2;10612:9;10608:18;10600:6;10583:44;:::i;:::-;10575:52;10179:454;-1:-1:-1;;;;;10179:454:1:o;10638:511::-;10832:4;-1:-1:-1;;;;;10942:2:1;10934:6;10930:15;10919:9;10912:34;10994:2;10986:6;10982:15;10977:2;10966:9;10962:18;10955:43;;11034:6;11029:2;11018:9;11014:18;11007:34;11077:3;11072:2;11061:9;11057:18;11050:31;11098:45;11138:3;11127:9;11123:19;11115:6;11098:45;:::i;:::-;11090:53;10638:511;-1:-1:-1;;;;;;10638:511:1:o;13293:217::-;13440:2;13429:9;13422:21;13403:4;13460:44;13500:2;13489:9;13485:18;13477:6;13460:44;:::i;26191:128::-;26231:3;26262:1;26258:6;26255:1;26252:13;26249:39;;;26268:18;;:::i;:::-;-1:-1:-1;26304:9:1;;26191:128::o;26324:120::-;26364:1;26390;26380:35;;26395:18;;:::i;:::-;-1:-1:-1;26429:9:1;;26324:120::o;26449:168::-;26489:7;26555:1;26551;26547:6;26543:14;26540:1;26537:21;26532:1;26525:9;26518:17;26514:45;26511:71;;;26562:18;;:::i;:::-;-1:-1:-1;26602:9:1;;26449:168::o;26622:125::-;26662:4;26690:1;26687;26684:8;26681:34;;;26695:18;;:::i;:::-;-1:-1:-1;26732:9:1;;26622:125::o;26752:258::-;26824:1;26834:113;26848:6;26845:1;26842:13;26834:113;;;26924:11;;;26918:18;26905:11;;;26898:39;26870:2;26863:10;26834:113;;;26965:6;26962:1;26959:13;26956:48;;;-1:-1:-1;;27000:1:1;26982:16;;26975:27;26752:258::o;27015:437::-;27094:1;27090:12;;;;27137;;;27158:61;;27212:4;27204:6;27200:17;27190:27;;27158:61;27265:2;27257:6;27254:14;27234:18;27231:38;27228:218;;;-1:-1:-1;;;27299:1:1;27292:88;27403:4;27400:1;27393:15;27431:4;27428:1;27421:15;27228:218;;27015:437;;;:::o;27457:135::-;27496:3;-1:-1:-1;;27517:17:1;;27514:43;;;27537:18;;:::i;:::-;-1:-1:-1;27584:1:1;27573:13;;27457:135::o;27597:112::-;27629:1;27655;27645:35;;27660:18;;:::i;:::-;-1:-1:-1;27694:9:1;;27597:112::o;27714:184::-;-1:-1:-1;;;27763:1:1;27756:88;27863:4;27860:1;27853:15;27887:4;27884:1;27877:15;27903:184;-1:-1:-1;;;27952:1:1;27945:88;28052:4;28049:1;28042:15;28076:4;28073:1;28066:15;28092:184;-1:-1:-1;;;28141:1:1;28134:88;28241:4;28238:1;28231:15;28265:4;28262:1;28255:15;28281:184;-1:-1:-1;;;28330:1:1;28323:88;28430:4;28427:1;28420:15;28454:4;28451:1;28444:15;28470:184;-1:-1:-1;;;28519:1:1;28512:88;28619:4;28616:1;28609:15;28643:4;28640:1;28633:15;28659:154;-1:-1:-1;;;;;28738:5:1;28734:54;28727:5;28724:65;28714:93;;28803:1;28800;28793:12;28818:177;-1:-1:-1;;;;;;28896:5:1;28892:78;28885:5;28882:89;28872:117;;28985:1;28982;28975:12

Swarm Source

ipfs://28027b598a27ae49aa9c3c345dd12a475cad948c15aa2380922405ed7806750e

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.