Token Filthy Rich Crypto Kids

 

Overview [ERC-721]

Max Total Supply:
1,700 FRCK

Holders:
539

Transfers:
-

 
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
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:
FilthyRichCryptoKids

Compiler Version
v0.8.12+commit.f00d7308

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-03-31
*/

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.4.1 (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 generally not needed starting with Solidity 0.8, since 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: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts v4.4.1 (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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

    /**
     * @dev 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 {
        _transferOwnership(address(0));
    }

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

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

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


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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


// OpenZeppelin Contracts v4.4.1 (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


// OpenZeppelin Contracts v4.4.1 (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


// OpenZeppelin Contracts v4.4.1 (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


// OpenZeppelin Contracts v4.4.1 (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/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

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


// OpenZeppelin Contracts v4.4.1 (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


// OpenZeppelin Contracts (last updated v4.5.0) (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 {
        _setApprovalForAll(_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);

        _afterTokenTransfer(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);

        _afterTokenTransfer(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 from incorrect owner");
        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);

        _afterTokenTransfer(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 Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @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` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * 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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: @chainlink/contracts/src/v0.8/VRFRequestIDBase.sol


pragma solidity ^0.8.0;

contract VRFRequestIDBase {
  /**
   * @notice returns the seed which is actually input to the VRF coordinator
   *
   * @dev To prevent repetition of VRF output due to repetition of the
   * @dev user-supplied seed, that seed is combined in a hash with the
   * @dev user-specific nonce, and the address of the consuming contract. The
   * @dev risk of repetition is mostly mitigated by inclusion of a blockhash in
   * @dev the final seed, but the nonce does protect against repetition in
   * @dev requests which are included in a single block.
   *
   * @param _userSeed VRF seed input provided by user
   * @param _requester Address of the requesting contract
   * @param _nonce User-specific nonce at the time of the request
   */
  function makeVRFInputSeed(
    bytes32 _keyHash,
    uint256 _userSeed,
    address _requester,
    uint256 _nonce
  ) internal pure returns (uint256) {
    return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
  }

  /**
   * @notice Returns the id for this request
   * @param _keyHash The serviceAgreement ID to be used for this request
   * @param _vRFInputSeed The seed to be passed directly to the VRF
   * @return The id for this request
   *
   * @dev Note that _vRFInputSeed is not the seed passed by the consuming
   * @dev contract, but the one generated by makeVRFInputSeed
   */
  function makeRequestId(bytes32 _keyHash, uint256 _vRFInputSeed) internal pure returns (bytes32) {
    return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
  }
}

// File: @chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol


pragma solidity ^0.8.0;

interface LinkTokenInterface {
  function allowance(address owner, address spender) external view returns (uint256 remaining);

  function approve(address spender, uint256 value) external returns (bool success);

  function balanceOf(address owner) external view returns (uint256 balance);

  function decimals() external view returns (uint8 decimalPlaces);

  function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);

  function increaseApproval(address spender, uint256 subtractedValue) external;

  function name() external view returns (string memory tokenName);

  function symbol() external view returns (string memory tokenSymbol);

  function totalSupply() external view returns (uint256 totalTokensIssued);

  function transfer(address to, uint256 value) external returns (bool success);

  function transferAndCall(
    address to,
    uint256 value,
    bytes calldata data
  ) external returns (bool success);

  function transferFrom(
    address from,
    address to,
    uint256 value
  ) external returns (bool success);
}

// File: @chainlink/contracts/src/v0.8/VRFConsumerBase.sol


pragma solidity ^0.8.0;



/** ****************************************************************************
 * @notice Interface for contracts using VRF randomness
 * *****************************************************************************
 * @dev PURPOSE
 *
 * @dev Reggie the Random Oracle (not his real job) wants to provide randomness
 * @dev to Vera the verifier in such a way that Vera can be sure he's not
 * @dev making his output up to suit himself. Reggie provides Vera a public key
 * @dev to which he knows the secret key. Each time Vera provides a seed to
 * @dev Reggie, he gives back a value which is computed completely
 * @dev deterministically from the seed and the secret key.
 *
 * @dev Reggie provides a proof by which Vera can verify that the output was
 * @dev correctly computed once Reggie tells it to her, but without that proof,
 * @dev the output is indistinguishable to her from a uniform random sample
 * @dev from the output space.
 *
 * @dev The purpose of this contract is to make it easy for unrelated contracts
 * @dev to talk to Vera the verifier about the work Reggie is doing, to provide
 * @dev simple access to a verifiable source of randomness.
 * *****************************************************************************
 * @dev USAGE
 *
 * @dev Calling contracts must inherit from VRFConsumerBase, and can
 * @dev initialize VRFConsumerBase's attributes in their constructor as
 * @dev shown:
 *
 * @dev   contract VRFConsumer {
 * @dev     constructor(<other arguments>, address _vrfCoordinator, address _link)
 * @dev       VRFConsumerBase(_vrfCoordinator, _link) public {
 * @dev         <initialization with other arguments goes here>
 * @dev       }
 * @dev   }
 *
 * @dev The oracle will have given you an ID for the VRF keypair they have
 * @dev committed to (let's call it keyHash), and have told you the minimum LINK
 * @dev price for VRF service. Make sure your contract has sufficient LINK, and
 * @dev call requestRandomness(keyHash, fee, seed), where seed is the input you
 * @dev want to generate randomness from.
 *
 * @dev Once the VRFCoordinator has received and validated the oracle's response
 * @dev to your request, it will call your contract's fulfillRandomness method.
 *
 * @dev The randomness argument to fulfillRandomness is the actual random value
 * @dev generated from your seed.
 *
 * @dev The requestId argument is generated from the keyHash and the seed by
 * @dev makeRequestId(keyHash, seed). If your contract could have concurrent
 * @dev requests open, you can use the requestId to track which seed is
 * @dev associated with which randomness. See VRFRequestIDBase.sol for more
 * @dev details. (See "SECURITY CONSIDERATIONS" for principles to keep in mind,
 * @dev if your contract could have multiple requests in flight simultaneously.)
 *
 * @dev Colliding `requestId`s are cryptographically impossible as long as seeds
 * @dev differ. (Which is critical to making unpredictable randomness! See the
 * @dev next section.)
 *
 * *****************************************************************************
 * @dev SECURITY CONSIDERATIONS
 *
 * @dev A method with the ability to call your fulfillRandomness method directly
 * @dev could spoof a VRF response with any random value, so it's critical that
 * @dev it cannot be directly called by anything other than this base contract
 * @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
 *
 * @dev For your users to trust that your contract's random behavior is free
 * @dev from malicious interference, it's best if you can write it so that all
 * @dev behaviors implied by a VRF response are executed *during* your
 * @dev fulfillRandomness method. If your contract must store the response (or
 * @dev anything derived from it) and use it later, you must ensure that any
 * @dev user-significant behavior which depends on that stored value cannot be
 * @dev manipulated by a subsequent VRF request.
 *
 * @dev Similarly, both miners and the VRF oracle itself have some influence
 * @dev over the order in which VRF responses appear on the blockchain, so if
 * @dev your contract could have multiple VRF requests in flight simultaneously,
 * @dev you must ensure that the order in which the VRF responses arrive cannot
 * @dev be used to manipulate your contract's user-significant behavior.
 *
 * @dev Since the ultimate input to the VRF is mixed with the block hash of the
 * @dev block in which the request is made, user-provided seeds have no impact
 * @dev on its economic security properties. They are only included for API
 * @dev compatability with previous versions of this contract.
 *
 * @dev Since the block hash of the block which contains the requestRandomness
 * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
 * @dev miner could, in principle, fork the blockchain to evict the block
 * @dev containing the request, forcing the request to be included in a
 * @dev different block with a different hash, and therefore a different input
 * @dev to the VRF. However, such an attack would incur a substantial economic
 * @dev cost. This cost scales with the number of blocks the VRF oracle waits
 * @dev until it calls responds to a request.
 */
abstract contract VRFConsumerBase is VRFRequestIDBase {
  /**
   * @notice fulfillRandomness handles the VRF response. Your contract must
   * @notice implement it. See "SECURITY CONSIDERATIONS" above for important
   * @notice principles to keep in mind when implementing your fulfillRandomness
   * @notice method.
   *
   * @dev VRFConsumerBase expects its subcontracts to have a method with this
   * @dev signature, and will call it once it has verified the proof
   * @dev associated with the randomness. (It is triggered via a call to
   * @dev rawFulfillRandomness, below.)
   *
   * @param requestId The Id initially returned by requestRandomness
   * @param randomness the VRF output
   */
  function fulfillRandomness(bytes32 requestId, uint256 randomness) internal virtual;

  /**
   * @dev In order to keep backwards compatibility we have kept the user
   * seed field around. We remove the use of it because given that the blockhash
   * enters later, it overrides whatever randomness the used seed provides.
   * Given that it adds no security, and can easily lead to misunderstandings,
   * we have removed it from usage and can now provide a simpler API.
   */
  uint256 private constant USER_SEED_PLACEHOLDER = 0;

  /**
   * @notice requestRandomness initiates a request for VRF output given _seed
   *
   * @dev The fulfillRandomness method receives the output, once it's provided
   * @dev by the Oracle, and verified by the vrfCoordinator.
   *
   * @dev The _keyHash must already be registered with the VRFCoordinator, and
   * @dev the _fee must exceed the fee specified during registration of the
   * @dev _keyHash.
   *
   * @dev The _seed parameter is vestigial, and is kept only for API
   * @dev compatibility with older versions. It can't *hurt* to mix in some of
   * @dev your own randomness, here, but it's not necessary because the VRF
   * @dev oracle will mix the hash of the block containing your request into the
   * @dev VRF seed it ultimately uses.
   *
   * @param _keyHash ID of public key against which randomness is generated
   * @param _fee The amount of LINK to send with the request
   *
   * @return requestId unique ID for this request
   *
   * @dev The returned requestId can be used to distinguish responses to
   * @dev concurrent requests. It is passed as the first argument to
   * @dev fulfillRandomness.
   */
  function requestRandomness(bytes32 _keyHash, uint256 _fee) internal returns (bytes32 requestId) {
    LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
    // This is the seed passed to VRFCoordinator. The oracle will mix this with
    // the hash of the block containing this request to obtain the seed/input
    // which is finally passed to the VRF cryptographic machinery.
    uint256 vRFSeed = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
    // nonces[_keyHash] must stay in sync with
    // VRFCoordinator.nonces[_keyHash][this], which was incremented by the above
    // successful LINK.transferAndCall (in VRFCoordinator.randomnessRequest).
    // This provides protection against the user repeating their input seed,
    // which would result in a predictable/duplicate output, if multiple such
    // requests appeared in the same block.
    nonces[_keyHash] = nonces[_keyHash] + 1;
    return makeRequestId(_keyHash, vRFSeed);
  }

  LinkTokenInterface internal immutable LINK;
  address private immutable vrfCoordinator;

  // Nonces for each VRF key from which randomness has been requested.
  //
  // Must stay in sync with VRFCoordinator[_keyHash][this]
  mapping(bytes32 => uint256) /* keyHash */ /* nonce */
    private nonces;

  /**
   * @param _vrfCoordinator address of VRFCoordinator contract
   * @param _link address of LINK token contract
   *
   * @dev https://docs.chain.link/docs/link-token-contracts
   */
  constructor(address _vrfCoordinator, address _link) {
    vrfCoordinator = _vrfCoordinator;
    LINK = LinkTokenInterface(_link);
  }

  // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
  // proof. rawFulfillRandomness then calls fulfillRandomness, after validating
  // the origin of the call
  function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
    require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
    fulfillRandomness(requestId, randomness);
  }
}

// File: FRCK.sol



//SPDX-License-Identifier: Unlicense
pragma solidity 0.8.12;







interface IFRCKVaulables {
    function getState(uint tokenId) external view returns(string[] memory traits, uint[] memory types);
}

/**
    @title Filthy Rich Crypto Kids NFT Smart Contract
    @dev This contract is the NFT contract, mainting all ownership of FRCK tokens
 */
contract FilthyRichCryptoKids is ERC721Enumerable, Ownable, VRFConsumerBase{

    using SafeMath for uint256;

    /**
     * Variables used for Chainlink VRF RNG
     */
    uint256 internal link_fee = 2 * 10 ** 18 wei; // 2 LINK (Mainnet)
    address internal _link = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
    address internal _vrfCoordinator = 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952;
    bytes32 internal keyHash = 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445;

    uint maxSupply;
    uint maxVipSupply;
    // Index for regular mints
    uint minted;
    // Index fo VIP mints
    uint public vipMinted = 0;

    string private _customBaseURI = "";

    mapping(address => bool) public isSaleContract;

    address public valuablesContract;

    uint public randomness;
    bool public randomnessRequested = false;
    bool public tradingEnabled = false;

    constructor(string memory name, string memory symbol, uint256 maxVipSupply_, uint256 maxSupply_) 
        ERC721(name, symbol) 
        VRFConsumerBase(_vrfCoordinator, _link) {
        
        maxVipSupply = maxVipSupply_;
        maxSupply = maxSupply_;
        minted = maxVipSupply;
    }

    modifier onlySeller () {
        require(isSaleContract[address(msg.sender)], "FRCK: Caller is not a seller");
        _;
    }

    /** 
        @notice Uses Link fund stored in this contract to request randomness from Chainlink VRF
        @dev This is only called by the owner wallet, and can only be called once
     */
    function getRandomNumber() public onlyOwner {
        require(LINK.balanceOf(address(this)) >= link_fee, "FRCK: Not enough LINK");
        require(randomnessRequested == false, "FRCK: Randomness has already been called");
        requestRandomness(keyHash, link_fee);
        randomnessRequested = true;
    }

    /** 
        @notice Function to handle return of Chainlink VRF, sets the global randomneess
        @dev This function is not called directly but outside by Chainlink VRF
     */
    function fulfillRandomness(bytes32 _requestId, uint256 _randomness) internal override {
        randomness = _randomness;
    }

    /**
        @notice Function used to returning token URI, after randomisation the index of non VIP tokens is shifted
     */
    function tokenURI(uint256 tokenId) public view override returns (string memory){
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        string memory baseURI = _baseURI();
        if(tokenId < maxVipSupply){
            return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, Strings.toString(tokenId))) : "";
        }
        else {
            uint tokenId_ = tokenId.sub(maxVipSupply);
            uint n = maxSupply.sub(maxVipSupply);
            uint offset = randomness & 0xffffffffffffffffffffffffffffffff;
            tokenId_ = tokenId_.add(offset).mod(n);
            tokenId_ = tokenId_.add(maxVipSupply);
            return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, Strings.toString(tokenId_))) : ""; 
        }   
    }

    /**
        @dev Overrides virtual _baseURI() used in ERC721 _tokenURI() to use custom value
     */
    function _baseURI() internal view override returns (string memory) {
        return _customBaseURI;
    }

    /**
        @notice returns the current supply, the amount of NFTs minted in the collection
     */
    function totalSupply() public view override returns (uint256){
        return (minted.sub(maxVipSupply)).add(vipMinted);
    }

    /**
        @dev Sets the baseURI to a string value
     */
    function setBaseURI(string memory baseURI) external onlyOwner {
        _customBaseURI = baseURI;
    }

    /**
        @dev Trading of the NFT tokens is intially disabled, it will be enabled after which it will remain enabled
     */
    function enableTrading() public onlyOwner {
        tradingEnabled = true;
    }

    /**
        @dev Function for adding a contract used to conduct the sale
     */
    function addSaleContract(address saleContract) external onlyOwner {
        isSaleContract[saleContract] = true;
    }

    /**
        @dev Function used for removing a contract used to conduct the sale
     */
    function removeSaleContract(address saleContract) external onlyOwner {
        isSaleContract[saleContract] = false;
    }

    /**
        @dev Function used to set the randomised random items contract
     */
    function setValuablesContract(address _valuablesContract) external onlyOwner {
        valuablesContract = _valuablesContract;
    }

    /**
        @notice Function used to see what valuable items a particular token has, see contract @valuablesContract for details
     */
    function getValuables(uint tokenId) external view returns(string[] memory traits, uint[] memory types) {
        return IFRCKVaulables(valuablesContract).getState(tokenId);
    }

    /**
        @notice Function used to determine if a token is a VIP token
     */
    function isVIP(uint tokenId) external view returns (bool) {
        return tokenId < maxVipSupply;
    }
 
    /**
        @notice Function used to batch mint standard tokens, only callable from the sale contract
     */
    function batchMint(uint _amount, address _recipient) external onlySeller {
        require(minted.add(_amount) <= maxSupply, "FRCK: Purchase would exceed max supply");
         for(uint i = 0; i < _amount; i++) {
            if (minted < maxSupply) {
                _safeMint(_recipient, minted);
                minted = minted.add(1);
            }
        }
    }

    /**
        @notice Function used to batch mint VIP tokens, only callable from the sale contract
     */
    function mintVip(uint _amount, address _recipient) external onlySeller {
        require(vipMinted.add(_amount) <= maxVipSupply, "FRCK: Purchase would exceed max vip supply");
         for(uint i = 0; i < _amount; i++) {
            if (vipMinted < maxVipSupply) {
                _safeMint(_recipient, vipMinted);
                vipMinted = vipMinted.add(1);
            }
        }
    }

    /**
        @dev Overiddes the transfer function to limit trading until enabled
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override {
        require(tradingEnabled, "FRCK: transfers are not yet enabled");
        ERC721._transfer(from, to, tokenId);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"maxVipSupply_","type":"uint256"},{"internalType":"uint256","name":"maxSupply_","type":"uint256"}],"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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"saleContract","type":"address"}],"name":"addSaleContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_recipient","type":"address"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRandomNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getValuables","outputs":[{"internalType":"string[]","name":"traits","type":"string[]"},{"internalType":"uint256[]","name":"types","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":[{"internalType":"address","name":"","type":"address"}],"name":"isSaleContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isVIP","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_recipient","type":"address"}],"name":"mintVip","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":"randomness","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"randomnessRequested","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"},{"internalType":"uint256","name":"randomness","type":"uint256"}],"name":"rawFulfillRandomness","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"saleContract","type":"address"}],"name":"removeSaleContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_valuablesContract","type":"address"}],"name":"setValuablesContract","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"valuablesContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vipMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000003e80000000000000000000000000000000000000000000000000000000000002710000000000000000000000000000000000000000000000000000000000000001746696c74687920526963682043727970746f204b69647300000000000000000000000000000000000000000000000000000000000000000000000000000000044652434b00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Filthy Rich Crypto Kids
Arg [1] : symbol (string): FRCK
Arg [2] : maxVipSupply_ (uint256): 1000
Arg [3] : maxSupply_ (uint256): 10000

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [3] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000017
Arg [5] : 46696c74687920526963682043727970746f204b696473000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 4652434b00000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

65687:6612:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46341:224;;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;46341:224:0;;;;;;;;33161:100;;;:::i;:::-;;;;;;;:::i;34720:221::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1797:55:1;;;1779:74;;1767:2;1752:18;34720:221:0;1633:226:1;34243:411:0;;;;;;:::i;:::-;;:::i;:::-;;69192:128;;;:::i;:::-;;;2470:25:1;;;2458:2;2443:18;69192:128:0;2324:177:1;35470:339:0;;;;;;:::i;:::-;;:::i;46649:256::-;;;;;;:::i;:::-;;:::i;66495:22::-;;;;;;71554:398;;;;;;:::i;:::-;;:::i;35880:185::-;;;;;;:::i;:::-;;:::i;66570:34::-;;;;;;;;;;;;47171:233;;;;;;:::i;:::-;;:::i;69395:105::-;;;;;;:::i;:::-;;:::i;69820:120::-;;;;;;:::i;:::-;;:::i;66399:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;32855:239;;;;;;:::i;:::-;;:::i;70043:124::-;;;;;;:::i;:::-;;:::i;70551:180::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;32585:208::-;;;;;;:::i;:::-;;:::i;11757:103::-;;;:::i;69642:82::-;;;:::i;11106:87::-;11179:6;;-1:-1:-1;;;;;11179:6:0;11106:87;;66322:25;;;;;;65082:210;;;;;;:::i;:::-;;:::i;33330:104::-;;;:::i;35013:155::-;;;;;;:::i;:::-;;:::i;70265:134::-;;;;;;:::i;:::-;;:::i;36136:328::-;;;;;;:::i;:::-;;:::i;71059:375::-;;;;;;:::i;:::-;;:::i;68037:817::-;;;;;;:::i;:::-;;:::i;66454:32::-;;;;;-1:-1:-1;;;;;66454:32:0;;;67258:314;;;:::i;70827:106::-;;;;;;:::i;:::-;70913:12;;-1:-1:-1;70903:22:0;70827:106;66524:39;;;;;;;;;35239:164;;;;;;:::i;:::-;-1:-1:-1;;;;;35360:25:0;;;35336:4;35360:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;35239:164;12015:201;;;;;;:::i;:::-;;:::i;46341:224::-;46443:4;46467:50;;;46482:35;46467:50;;:90;;;46521:36;46545:11;46521:23;:36::i;:::-;46460:97;46341:224;-1:-1:-1;;46341:224:0:o;33161:100::-;33215:13;33248:5;33241:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33161:100;:::o;34720:221::-;34796:7;38063:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38063:16:0;34816:73;;;;-1:-1:-1;;;34816:73:0;;8540:2:1;34816:73:0;;;8522:21:1;8579:2;8559:18;;;8552:30;8618:34;8598:18;;;8591:62;8689:14;8669:18;;;8662:42;8721:19;;34816:73:0;;;;;;;;;-1:-1:-1;34909:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;34909:24:0;;34720:221::o;34243:411::-;34324:13;34340:23;34355:7;34340:14;:23::i;:::-;34324:39;;34388:5;-1:-1:-1;;;;;34382:11:0;:2;-1:-1:-1;;;;;34382:11:0;;;34374:57;;;;-1:-1:-1;;;34374:57:0;;8953:2:1;34374:57:0;;;8935:21:1;8992:2;8972:18;;;8965:30;9031:34;9011:18;;;9004:62;9102:3;9082:18;;;9075:31;9123:19;;34374:57:0;8751:397:1;34374:57:0;9910:10;-1:-1:-1;;;;;34466:21:0;;;;:62;;-1:-1:-1;34491:37:0;34508:5;9910:10;35239:164;:::i;34491:37::-;34444:168;;;;-1:-1:-1;;;34444:168:0;;9355:2:1;34444:168:0;;;9337:21:1;9394:2;9374:18;;;9367:30;9433:34;9413:18;;;9406:62;9504:26;9484:18;;;9477:54;9548:19;;34444:168:0;9153:420:1;34444:168:0;34625:21;34634:2;34638:7;34625:8;:21::i;:::-;34313:341;34243:411;;:::o;69192:128::-;69245:7;69271:41;69302:9;;69272:24;69283:12;;69272:6;;:10;;:24;;;;:::i;:::-;69271:30;;:41::i;:::-;69264:48;;69192:128;:::o;35470:339::-;35665:41;9910:10;35698:7;35665:18;:41::i;:::-;35657:103;;;;-1:-1:-1;;;35657:103:0;;9780:2:1;35657:103:0;;;9762:21:1;9819:2;9799:18;;;9792:30;9858:34;9838:18;;;9831:62;9929:19;9909:18;;;9902:47;9966:19;;35657:103:0;9578:413:1;35657:103:0;35773:28;35783:4;35789:2;35793:7;35773:9;:28::i;46649:256::-;46746:7;46782:23;46799:5;46782:16;:23::i;:::-;46774:5;:31;46766:87;;;;-1:-1:-1;;;46766:87:0;;10198:2:1;46766:87:0;;;10180:21:1;10237:2;10217:18;;;10210:30;10276:34;10256:18;;;10249:62;10347:13;10327:18;;;10320:41;10378:19;;46766:87:0;9996:407:1;46766:87:0;-1:-1:-1;;;;;;46871:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;46649:256::o;71554:398::-;66986:10;66963:35;;;;:14;:35;;;;;;;;66955:76;;;;-1:-1:-1;;;66955:76:0;;10610:2:1;66955:76:0;;;10592:21:1;10649:2;10629:18;;;10622:30;10688;10668:18;;;10661:58;10736:18;;66955:76:0;10408:352:1;66955:76:0;71670:12:::1;::::0;71644:9:::1;::::0;:22:::1;::::0;71658:7;71644:13:::1;:22::i;:::-;:38;;71636:93;;;::::0;-1:-1:-1;;;71636:93:0;;10967:2:1;71636:93:0::1;::::0;::::1;10949:21:1::0;11006:2;10986:18;;;10979:30;11045:34;11025:18;;;11018:62;11116:12;11096:18;;;11089:40;11146:19;;71636:93:0::1;10765:406:1::0;71636:93:0::1;71745:6;71741:204;71761:7;71757:1;:11;71741:204;;;71806:12;;71794:9;;:24;71790:144;;;71839:32;71849:10;71861:9;;71839;:32::i;:::-;71902:9;::::0;:16:::1;::::0;71916:1:::1;71902:13;:16::i;:::-;71890:9;:28:::0;71790:144:::1;71770:3:::0;::::1;::::0;::::1;:::i;:::-;;;;71741:204;;35880:185:::0;36018:39;36035:4;36041:2;36045:7;36018:39;;;;;;;;;;;;:16;:39::i;47171:233::-;47246:7;47282:30;47069:10;:17;;46981:113;47282:30;47274:5;:38;47266:95;;;;-1:-1:-1;;;47266:95:0;;11767:2:1;47266:95:0;;;11749:21:1;11806:2;11786:18;;;11779:30;11845:34;11825:18;;;11818:62;11916:14;11896:18;;;11889:42;11948:19;;47266:95:0;11565:408:1;47266:95:0;47379:10;47390:5;47379:17;;;;;;;;:::i;:::-;;;;;;;;;47372:24;;47171:233;;;:::o;69395:105::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;69468:24;;::::1;::::0;:14:::1;::::0;:24:::1;::::0;::::1;::::0;::::1;:::i;:::-;;69395:105:::0;:::o;69820:120::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;-1:-1:-1;;;;;69897:28:0::1;;::::0;;;:14:::1;:28;::::0;;;;:35;;;::::1;69928:4;69897:35;::::0;;69820:120::o;32855:239::-;32927:7;32963:16;;;:7;:16;;;;;;-1:-1:-1;;;;;32963:16:0;32998:19;32990:73;;;;-1:-1:-1;;;32990:73:0;;12730:2:1;32990:73:0;;;12712:21:1;12769:2;12749:18;;;12742:30;12808:34;12788:18;;;12781:62;12879:11;12859:18;;;12852:39;12908:19;;32990:73:0;12528:405:1;70043:124:0;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;-1:-1:-1;;;;;70123:28:0::1;70154:5;70123:28:::0;;;:14:::1;:28;::::0;;;;:36;;;::::1;::::0;;70043:124::o;70551:180::-;70687:17;;70672:51;;;;;;;;2470:25:1;;;70609:22:0;;;;-1:-1:-1;;;;;70687:17:0;;;;70672:42;;2443:18:1;;70672:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70665:58;;;;70551:180;;;:::o;32585:208::-;32657:7;-1:-1:-1;;;;;32685:19:0;;32677:74;;;;-1:-1:-1;;;32677:74:0;;15849:2:1;32677:74:0;;;15831:21:1;15888:2;15868:18;;;15861:30;15927:34;15907:18;;;15900:62;15998:12;15978:18;;;15971:40;16028:19;;32677:74:0;15647:406:1;32677:74:0;-1:-1:-1;;;;;;32769:16:0;;;;;:9;:16;;;;;;;32585:208::o;11757:103::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;11822:30:::1;11849:1;11822:18;:30::i;:::-;11757:103::o:0;69642:82::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;69695:14:::1;:21:::0;;;::::1;;;::::0;;69642:82::o;65082:210::-;65175:10;-1:-1:-1;;;;;65189:14:0;65175:28;;65167:72;;;;-1:-1:-1;;;65167:72:0;;16260:2:1;65167:72:0;;;16242:21:1;16299:2;16279:18;;;16272:30;16338:33;16318:18;;;16311:61;16389:18;;65167:72:0;16058:355:1;65167:72:0;67865:10;:24;-1:-1:-1;69395:105:0:o;33330:104::-;33386:13;33419:7;33412:14;;;;;:::i;35013:155::-;35108:52;9910:10;35141:8;35151;35108:18;:52::i;70265:134::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;70353:17:::1;:38:::0;;;::::1;-1:-1:-1::0;;;;;70353:38:0;;;::::1;::::0;;;::::1;::::0;;70265:134::o;36136:328::-;36311:41;9910:10;36344:7;36311:18;:41::i;:::-;36303:103;;;;-1:-1:-1;;;36303:103:0;;9780:2:1;36303:103:0;;;9762:21:1;9819:2;9799:18;;;9792:30;9858:34;9838:18;;;9831:62;9929:19;9909:18;;;9902:47;9966:19;;36303:103:0;9578:413:1;36303:103:0;36417:39;36431:4;36437:2;36441:7;36450:5;36417:13;:39::i;:::-;36136:328;;;;:::o;71059:375::-;66986:10;66963:35;;;;:14;:35;;;;;;;;66955:76;;;;-1:-1:-1;;;66955:76:0;;10610:2:1;66955:76:0;;;10592:21:1;10649:2;10629:18;;;10622:30;10688;10668:18;;;10661:58;10736:18;;66955:76:0;10408:352:1;66955:76:0;71174:9:::1;::::0;71151:6:::1;::::0;:19:::1;::::0;71162:7;71151:10:::1;:19::i;:::-;:32;;71143:83;;;::::0;-1:-1:-1;;;71143:83:0;;16620:2:1;71143:83:0::1;::::0;::::1;16602:21:1::0;16659:2;16639:18;;;16632:30;16698:34;16678:18;;;16671:62;16769:8;16749:18;;;16742:36;16795:19;;71143:83:0::1;16418:402:1::0;71143:83:0::1;71242:6;71238:189;71258:7;71254:1;:11;71238:189;;;71300:9;;71291:6;;:18;71287:129;;;71330:29;71340:10;71352:6;;71330:9;:29::i;:::-;71387:6;::::0;:13:::1;::::0;71398:1:::1;71387:10;:13::i;:::-;71378:6;:22:::0;71287:129:::1;71267:3:::0;::::1;::::0;::::1;:::i;:::-;;;;71238:189;;68037:817:::0;38039:4;38063:16;;;:7;:16;;;;;;68102:13;;-1:-1:-1;;;;;38063:16:0;68127:76;;;;-1:-1:-1;;;68127:76:0;;17027:2:1;68127:76:0;;;17009:21:1;17066:2;17046:18;;;17039:30;17105:34;17085:18;;;17078:62;17176:17;17156:18;;;17149:45;17211:19;;68127:76:0;16825:411:1;68127:76:0;68214:21;68238:10;:8;:10::i;:::-;68214:34;;68272:12;;68262:7;:22;68259:585;;;68331:1;68313:7;68307:21;:25;:93;;;;;;;;;;;;;;;;;68359:7;68368:25;68385:7;68368:16;:25::i;:::-;68342:52;;;;;;;;;:::i;:::-;;;;;;;;;;;;;68307:93;68300:100;68037:817;-1:-1:-1;;;68037:817:0:o;68259:585::-;68442:13;68458:25;68470:12;;68458:7;:11;;:25;;;;:::i;:::-;68442:41;;68498:6;68507:27;68521:12;;68507:9;;:13;;:27;;;;:::i;:::-;68563:10;;68498:36;;-1:-1:-1;68576:34:0;68563:47;68636:27;68498:36;68636:20;:8;68563:47;68636:12;:20::i;:::-;:24;;:27::i;:::-;68625:38;;68689:26;68702:12;;68689:8;:12;;:26;;;;:::i;:::-;68678:37;;68761:1;68743:7;68737:21;:25;:94;;;;;;;;;;;;;;;;;68789:7;68798:26;68815:8;68798:16;:26::i;:::-;68772:53;;;;;;;;;:::i;:::-;;;;;;;;;;;;;68737:94;68730:101;68037:817;-1:-1:-1;;;;;;68037:817:0:o;68259:585::-;68116:738;68037:817;;;:::o;67258:314::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;67354:8:::1;::::0;67321:29:::1;::::0;;;;67344:4:::1;67321:29;::::0;::::1;1779:74:1::0;67321:4:0::1;-1:-1:-1::0;;;;;67321:14:0::1;::::0;::::1;::::0;1752:18:1;;67321:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:41;;67313:75;;;::::0;-1:-1:-1;;;67313:75:0;;18107:2:1;67313:75:0::1;::::0;::::1;18089:21:1::0;18146:2;18126:18;;;18119:30;18185:23;18165:18;;;18158:51;18226:18;;67313:75:0::1;17905:345:1::0;67313:75:0::1;67407:19;::::0;::::1;;:28;67399:81;;;::::0;-1:-1:-1;;;67399:81:0;;18457:2:1;67399:81:0::1;::::0;::::1;18439:21:1::0;18496:2;18476:18;;;18469:30;18535:34;18515:18;;;18508:62;18606:10;18586:18;;;18579:38;18634:19;;67399:81:0::1;18255:404:1::0;67399:81:0::1;67491:36;67509:7;;67518:8;;67491:17;:36::i;:::-;-1:-1:-1::0;67538:19:0::1;:26:::0;;;::::1;67560:4;67538:26;::::0;;67258:314::o;12015:201::-;11179:6;;-1:-1:-1;;;;;11179:6:0;9910:10;11326:23;11318:68;;;;-1:-1:-1;;;11318:68:0;;12369:2:1;11318:68:0;;;12351:21:1;;;12388:18;;;12381:30;12447:34;12427:18;;;12420:62;12499:18;;11318:68:0;12167:356:1;11318:68:0;-1:-1:-1;;;;;12104:22:0;::::1;12096:73;;;::::0;-1:-1:-1;;;12096:73:0;;18866:2:1;12096:73:0::1;::::0;::::1;18848:21:1::0;18905:2;18885:18;;;18878:30;18944:34;18924:18;;;18917:62;19015:8;18995:18;;;18988:36;19041:19;;12096:73:0::1;18664:402:1::0;12096:73:0::1;12180:28;12199:8;12180:18;:28::i;:::-;12015:201:::0;:::o;32216:305::-;32318:4;32355:40;;;32370:25;32355:40;;:105;;-1:-1:-1;32412:48:0;;;32427:33;32412:48;32355:105;:158;;;-1:-1:-1;24014:25:0;23999:40;;;;32477:36;23890:157;42120:174;42195:24;;;;:15;:24;;;;;:29;;;;-1:-1:-1;;;;;42195:29:0;;;;;;;;:24;;42249:23;42195:24;42249:14;:23::i;:::-;-1:-1:-1;;;;;42240:46:0;;;;;;;;;;;42120:174;;:::o;3243:98::-;3301:7;3328:5;3332:1;3328;:5;:::i;2862:98::-;2920:7;2947:5;2951:1;2947;:5;:::i;38268:348::-;38361:4;38063:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38063:16:0;38378:73;;;;-1:-1:-1;;;38378:73:0;;19536:2:1;38378:73:0;;;19518:21:1;19575:2;19555:18;;;19548:30;19614:34;19594:18;;;19587:62;19685:14;19665:18;;;19658:42;19717:19;;38378:73:0;19334:408:1;38378:73:0;38462:13;38478:23;38493:7;38478:14;:23::i;:::-;38462:39;;38531:5;-1:-1:-1;;;;;38520:16:0;:7;-1:-1:-1;;;;;38520:16:0;;:51;;;;38564:7;-1:-1:-1;;;;;38540:31:0;:20;38552:7;38540:11;:20::i;:::-;-1:-1:-1;;;;;38540:31:0;;38520:51;:87;;;-1:-1:-1;;;;;;35360:25:0;;;35336:4;35360:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;38575:32;38512:96;38268:348;-1:-1:-1;;;;38268:348:0:o;72055:241::-;72188:14;;;;;;;72180:62;;;;-1:-1:-1;;;72180:62:0;;19949:2:1;72180:62:0;;;19931:21:1;19988:2;19968:18;;;19961:30;20027:34;20007:18;;;20000:62;20098:5;20078:18;;;20071:33;20121:19;;72180:62:0;19747:399:1;72180:62:0;72253:35;72270:4;72276:2;72280:7;72253:16;:35::i;38958:110::-;39034:26;39044:2;39048:7;39034:26;;;;;;;;;;;;:9;:26::i;12376:191::-;12469:6;;;-1:-1:-1;;;;;12486:17:0;;;;;;;;;;;12519:40;;12469:6;;;12486:17;12469:6;;12519:40;;12450:16;;12519:40;12439:128;12376:191;:::o;42436:315::-;42591:8;-1:-1:-1;;;;;42582:17:0;:5;-1:-1:-1;;;;;42582:17:0;;;42574:55;;;;-1:-1:-1;;;42574:55:0;;20353:2:1;42574:55:0;;;20335:21:1;20392:2;20372:18;;;20365:30;20431:27;20411:18;;;20404:55;20476:18;;42574:55:0;20151:349:1;42574:55:0;-1:-1:-1;;;;;42640:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;42702:41;;586::1;;;42702::0;;559:18:1;42702:41:0;;;;;;;42436:315;;;:::o;37346:::-;37503:28;37513:4;37519:2;37523:7;37503:9;:28::i;:::-;37550:48;37573:4;37579:2;37583:7;37592:5;37550:22;:48::i;:::-;37542:111;;;;-1:-1:-1;;;37542:111:0;;20707:2:1;37542:111:0;;;20689:21:1;20746:2;20726:18;;;20719:30;20785:34;20765:18;;;20758:62;20856:20;20836:18;;;20829:48;20894:19;;37542:111:0;20505:414:1;68970:107:0;69022:13;69055:14;69048:21;;;;;:::i;7392:723::-;7448:13;7669:10;7665:53;;-1:-1:-1;;7696:10:0;;;;;;;;;;;;;;;;;;7392:723::o;7665:53::-;7743:5;7728:12;7784:78;7791:9;;7784:78;;7817:8;;;;:::i;:::-;;-1:-1:-1;7840:10:0;;-1:-1:-1;7848:2:0;7840:10;;:::i;:::-;;;7784:78;;;7872:19;7904:6;7894:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7894:17:0;;7872:39;;7922:154;7929:10;;7922:154;;7956:11;7966:1;7956:11;;:::i;:::-;;-1:-1:-1;8025:10:0;8033:2;8025:5;:10;:::i;:::-;8012:24;;:2;:24;:::i;:::-;7999:39;;7982:6;7989;7982:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;8053:11:0;8062:2;8053:11;;:::i;:::-;;;7922:154;;4564:98;4622:7;4649:5;4653:1;4649;:5;:::i;63199:1034::-;63276:17;63302:4;-1:-1:-1;;;;;63302:20:0;;63323:14;63339:4;63356:8;62029:1;63345:43;;;;;;;;21529:25:1;;;21585:2;21570:18;;21563:34;21517:2;21502:18;;21355:248;63345:43:0;;;;;;;;;;;;;63302:87;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;63624:15:0;63707:16;;;:6;:16;;;;;;;;;53523:51;;;;;24085:25:1;;;24126:18;;;24119:34;;;63700:4:0;24169:18:1;;;24162:83;24261:18;;;;24254:34;;;53523:51:0;;;;;;;;;;24057:19:1;;;;53523:51:0;;;53513:62;;;;;;;;;64161:16;;;;;;;:20;;64180:1;64161:20;:::i;:::-;64142:16;;;;:6;:16;;;;;:39;64195:32;64149:8;64219:7;54093:41;;;;;;;24456:19:1;;;;24491:12;;;24484:28;;;;54093:41:0;;;;;;;;;24528:12:1;;;;54093:41:0;;54083:52;;;;;;53973:168;41377:625;41536:4;-1:-1:-1;;;;;41509:31:0;:23;41524:7;41509:14;:23::i;:::-;-1:-1:-1;;;;;41509:31:0;;41501:81;;;;-1:-1:-1;;;41501:81:0;;22474:2:1;41501:81:0;;;22456:21:1;22513:2;22493:18;;;22486:30;22552:34;22532:18;;;22525:62;22623:7;22603:18;;;22596:35;22648:19;;41501:81:0;22272:401:1;41501:81:0;-1:-1:-1;;;;;41601:16:0;;41593:65;;;;-1:-1:-1;;;41593:65:0;;22880:2:1;41593:65:0;;;22862:21:1;22919:2;22899:18;;;22892:30;22958:34;22938:18;;;22931:62;23029:6;23009:18;;;23002:34;23053:19;;41593:65:0;22678:400:1;41593:65:0;41671:39;41692:4;41698:2;41702:7;41671:20;:39::i;:::-;41775:29;41792:1;41796:7;41775:8;:29::i;:::-;-1:-1:-1;;;;;41817:15:0;;;;;;:9;:15;;;;;:20;;41836:1;;41817:15;:20;;41836:1;;41817:20;:::i;:::-;;;;-1:-1:-1;;;;;;;41848:13:0;;;;;;:9;:13;;;;;:18;;41865:1;;41848:13;:18;;41865:1;;41848:18;:::i;:::-;;;;-1:-1:-1;;41877:16:0;;;;:7;:16;;;;;;:21;;;;-1:-1:-1;;;;;41877:21:0;;;;;;;;;41916:27;;41877:16;;41916:27;;;;;;;34313:341;34243:411;;:::o;39295:321::-;39425:18;39431:2;39435:7;39425:5;:18::i;:::-;39476:54;39507:1;39511:2;39515:7;39524:5;39476:22;:54::i;:::-;39454:154;;;;-1:-1:-1;;;39454:154:0;;20707:2:1;39454:154:0;;;20689:21:1;20746:2;20726:18;;;20719:30;20785:34;20765:18;;;20758:62;20856:20;20836:18;;;20829:48;20894:19;;39454:154:0;20505:414:1;43316:799:0;43471:4;-1:-1:-1;;;;;43492:13:0;;14102:19;:23;43488:620;;43528:72;;;;;-1:-1:-1;;;;;43528:36:0;;;;;:72;;9910:10;;43579:4;;43585:7;;43594:5;;43528:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43528:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;43524:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43770:13:0;;43766:272;;43813:60;;-1:-1:-1;;;43813:60:0;;20707:2:1;43813:60:0;;;20689:21:1;20746:2;20726:18;;;20719:30;20785:34;20765:18;;;20758:62;20856:20;20836:18;;;20829:48;20894:19;;43813:60:0;20505:414:1;43766:272:0;43988:6;43982:13;43973:6;43969:2;43965:15;43958:38;43524:529;43651:51;;43661:41;43651:51;;-1:-1:-1;43644:58:0;;43488:620;-1:-1:-1;44092:4:0;43316:799;;;;;;:::o;48017:589::-;-1:-1:-1;;;;;48223:18:0;;48219:187;;48258:40;48290:7;49433:10;:17;;49406:24;;;;:15;:24;;;;;:44;;;49461:24;;;;;;;;;;;;49329:164;48258:40;48219:187;;;48328:2;-1:-1:-1;;;;;48320:10:0;:4;-1:-1:-1;;;;;48320:10:0;;48316:90;;48347:47;48380:4;48386:7;48347:32;:47::i;:::-;-1:-1:-1;;;;;48420:16:0;;48416:183;;48453:45;48490:7;48453:36;:45::i;48416:183::-;48526:4;-1:-1:-1;;;;;48520:10:0;:2;-1:-1:-1;;;;;48520:10:0;;48516:83;;48547:40;48575:2;48579:7;48547:27;:40::i;39952:439::-;-1:-1:-1;;;;;40032:16:0;;40024:61;;;;-1:-1:-1;;;40024:61:0;;24753:2:1;40024:61:0;;;24735:21:1;;;24772:18;;;24765:30;24831:34;24811:18;;;24804:62;24883:18;;40024:61:0;24551:356:1;40024:61:0;38039:4;38063:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38063:16:0;:30;40096:58;;;;-1:-1:-1;;;40096:58:0;;25114:2:1;40096:58:0;;;25096:21:1;25153:2;25133:18;;;25126:30;25192;25172:18;;;25165:58;25240:18;;40096:58:0;24912:352:1;40096:58:0;40167:45;40196:1;40200:2;40204:7;40167:20;:45::i;:::-;-1:-1:-1;;;;;40225:13:0;;;;;;:9;:13;;;;;:18;;40242:1;;40225:13;:18;;40242:1;;40225:18;:::i;:::-;;;;-1:-1:-1;;40254:16:0;;;;:7;:16;;;;;;:21;;;;-1:-1:-1;;;;;40254:21:0;;;;;;;;40293:33;;40254:16;;;40293:33;;40254:16;;40293:33;69468:24:::1;69395:105:::0;:::o;50120:988::-;50386:22;50436:1;50411:22;50428:4;50411:16;:22::i;:::-;:26;;;;:::i;:::-;50448:18;50469:26;;;:17;:26;;;;;;50386:51;;-1:-1:-1;50602:28:0;;;50598:328;;-1:-1:-1;;;;;50669:18:0;;50647:19;50669:18;;;:12;:18;;;;;;;;:34;;;;;;;;;50720:30;;;;;;:44;;;50837:30;;:17;:30;;;;;:43;;;50598:328;-1:-1:-1;51022:26:0;;;;:17;:26;;;;;;;;51015:33;;;-1:-1:-1;;;;;51066:18:0;;;;;:12;:18;;;;;:34;;;;;;;51059:41;50120:988::o;51403:1079::-;51681:10;:17;51656:22;;51681:21;;51701:1;;51681:21;:::i;:::-;51713:18;51734:24;;;:15;:24;;;;;;52107:10;:26;;51656:46;;-1:-1:-1;51734:24:0;;51656:46;;52107:26;;;;;;:::i;:::-;;;;;;;;;52085:48;;52171:11;52146:10;52157;52146:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;52251:28;;;:15;:28;;;;;;;:41;;;52423:24;;;;;52416:31;52458:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;51474:1008;;;51403:1079;:::o;48907:221::-;48992:14;49009:20;49026:2;49009:16;:20::i;:::-;-1:-1:-1;;;;;49040:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;49085:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;48907:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:177:1;99:66;92:5;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;638:258::-;710:1;720:113;734:6;731:1;728:13;720:113;;;810:11;;;804:18;791:11;;;784:39;756:2;749:10;720:113;;;851:6;848:1;845:13;842:48;;;-1:-1:-1;;886:1:1;868:16;;861:27;638:258::o;901:317::-;943:3;981:5;975:12;1008:6;1003:3;996:19;1024:63;1080:6;1073:4;1068:3;1064:14;1057:4;1050:5;1046:16;1024:63;:::i;:::-;1132:2;1120:15;1137:66;1116:88;1107:98;;;;1207:4;1103:109;;901:317;-1:-1:-1;;901:317:1:o;1223:220::-;1372:2;1361:9;1354:21;1335:4;1392:45;1433:2;1422:9;1418:18;1410:6;1392:45;:::i;1448:180::-;1507:6;1560:2;1548:9;1539:7;1535:23;1531:32;1528:52;;;1576:1;1573;1566:12;1528:52;-1:-1:-1;1599:23:1;;1448:180;-1:-1:-1;1448:180:1:o;1864:196::-;1932:20;;-1:-1:-1;;;;;1981:54:1;;1971:65;;1961:93;;2050:1;2047;2040:12;1961:93;1864:196;;;:::o;2065:254::-;2133:6;2141;2194:2;2182:9;2173:7;2169:23;2165:32;2162:52;;;2210:1;2207;2200:12;2162:52;2233:29;2252:9;2233:29;:::i;:::-;2223:39;2309:2;2294:18;;;;2281:32;;-1:-1:-1;;;2065:254:1:o;2506:328::-;2583:6;2591;2599;2652:2;2640:9;2631:7;2627:23;2623:32;2620:52;;;2668:1;2665;2658:12;2620:52;2691:29;2710:9;2691:29;:::i;:::-;2681:39;;2739:38;2773:2;2762:9;2758:18;2739:38;:::i;:::-;2729:48;;2824:2;2813:9;2809:18;2796:32;2786:42;;2506:328;;;;;:::o;2839:254::-;2907:6;2915;2968:2;2956:9;2947:7;2943:23;2939:32;2936:52;;;2984:1;2981;2974:12;2936:52;3020:9;3007:23;2997:33;;3049:38;3083:2;3072:9;3068:18;3049:38;:::i;:::-;3039:48;;2839:254;;;;;:::o;3098:184::-;3150:77;3147:1;3140:88;3247:4;3244:1;3237:15;3271:4;3268:1;3261:15;3287:334;3358:2;3352:9;3414:2;3404:13;;3419:66;3400:86;3388:99;;3517:18;3502:34;;3538:22;;;3499:62;3496:88;;;3564:18;;:::i;:::-;3600:2;3593:22;3287:334;;-1:-1:-1;3287:334:1:o;3626:246::-;3675:4;3708:18;3700:6;3697:30;3694:56;;;3730:18;;:::i;:::-;-1:-1:-1;3787:2:1;3775:15;3792:66;3771:88;3861:4;3767:99;;3626:246::o;3877:338::-;3942:5;3971:53;3987:36;4016:6;3987:36;:::i;:::-;3971:53;:::i;:::-;3962:62;;4047:6;4040:5;4033:21;4087:3;4078:6;4073:3;4069:16;4066:25;4063:45;;;4104:1;4101;4094:12;4063:45;4153:6;4148:3;4141:4;4134:5;4130:16;4117:43;4207:1;4200:4;4191:6;4184:5;4180:18;4176:29;4169:40;3877:338;;;;;:::o;4220:451::-;4289:6;4342:2;4330:9;4321:7;4317:23;4313:32;4310:52;;;4358:1;4355;4348:12;4310:52;4398:9;4385:23;4431:18;4423:6;4420:30;4417:50;;;4463:1;4460;4453:12;4417:50;4486:22;;4539:4;4531:13;;4527:27;-1:-1:-1;4517:55:1;;4568:1;4565;4558:12;4517:55;4591:74;4657:7;4652:2;4639:16;4634:2;4630;4626:11;4591:74;:::i;4676:186::-;4735:6;4788:2;4776:9;4767:7;4763:23;4759:32;4756:52;;;4804:1;4801;4794:12;4756:52;4827:29;4846:9;4827:29;:::i;4867:1391::-;5107:4;5155:2;5144:9;5140:18;5185:2;5174:9;5167:21;5208:6;5243;5237:13;5274:6;5266;5259:22;5312:2;5301:9;5297:18;5290:25;;5374:2;5364:6;5361:1;5357:14;5346:9;5342:30;5338:39;5324:53;;5396:4;5435:2;5427:6;5423:15;5456:1;5466:314;5480:6;5477:1;5474:13;5466:314;;;5569:66;5557:9;5549:6;5545:22;5541:95;5536:3;5529:108;5660:40;5693:6;5684;5678:13;5660:40;:::i;:::-;5650:50;-1:-1:-1;5758:12:1;;;;5723:15;;;;5502:1;5495:9;5466:314;;;-1:-1:-1;;5816:22:1;;;5796:18;;;5789:50;5892:13;;5914:24;;;5996:15;;;;5956;;;-1:-1:-1;5892:13:1;-1:-1:-1;6031:1:1;6041:189;6057:8;6052:3;6049:17;6041:189;;;6126:15;;6112:30;;6203:17;;;;6164:14;;;;6085:1;6076:11;6041:189;;;-1:-1:-1;6247:5:1;;4867:1391;-1:-1:-1;;;;;;;4867:1391:1:o;6263:248::-;6331:6;6339;6392:2;6380:9;6371:7;6367:23;6363:32;6360:52;;;6408:1;6405;6398:12;6360:52;-1:-1:-1;;6431:23:1;;;6501:2;6486:18;;;6473:32;;-1:-1:-1;6263:248:1:o;6516:118::-;6602:5;6595:13;6588:21;6581:5;6578:32;6568:60;;6624:1;6621;6614:12;6639:315;6704:6;6712;6765:2;6753:9;6744:7;6740:23;6736:32;6733:52;;;6781:1;6778;6771:12;6733:52;6804:29;6823:9;6804:29;:::i;:::-;6794:39;;6883:2;6872:9;6868:18;6855:32;6896:28;6918:5;6896:28;:::i;:::-;6943:5;6933:15;;;6639:315;;;;;:::o;6959:667::-;7054:6;7062;7070;7078;7131:3;7119:9;7110:7;7106:23;7102:33;7099:53;;;7148:1;7145;7138:12;7099:53;7171:29;7190:9;7171:29;:::i;:::-;7161:39;;7219:38;7253:2;7242:9;7238:18;7219:38;:::i;:::-;7209:48;;7304:2;7293:9;7289:18;7276:32;7266:42;;7359:2;7348:9;7344:18;7331:32;7386:18;7378:6;7375:30;7372:50;;;7418:1;7415;7408:12;7372:50;7441:22;;7494:4;7486:13;;7482:27;-1:-1:-1;7472:55:1;;7523:1;7520;7513:12;7472:55;7546:74;7612:7;7607:2;7594:16;7589:2;7585;7581:11;7546:74;:::i;:::-;7536:84;;;6959:667;;;;;;;:::o;7631:260::-;7699:6;7707;7760:2;7748:9;7739:7;7735:23;7731:32;7728:52;;;7776:1;7773;7766:12;7728:52;7799:29;7818:9;7799:29;:::i;:::-;7789:39;;7847:38;7881:2;7870:9;7866:18;7847:38;:::i;7896:437::-;7975:1;7971:12;;;;8018;;;8039:61;;8093:4;8085:6;8081:17;8071:27;;8039:61;8146:2;8138:6;8135:14;8115:18;8112:38;8109:218;;;8183:77;8180:1;8173:88;8284:4;8281:1;8274:15;8312:4;8309:1;8302:15;11176:184;11228:77;11225:1;11218:88;11325:4;11322:1;11315:15;11349:4;11346:1;11339:15;11365:195;11404:3;11435:66;11428:5;11425:77;11422:103;;;11505:18;;:::i;:::-;-1:-1:-1;11552:1:1;11541:13;;11365:195::o;11978:184::-;12030:77;12027:1;12020:88;12127:4;12124:1;12117:15;12151:4;12148:1;12141:15;12938:182;12997:4;13030:18;13022:6;13019:30;13016:56;;;13052:18;;:::i;:::-;-1:-1:-1;13097:1:1;13093:14;13109:4;13089:25;;12938:182::o;13125:658::-;13190:5;13243:3;13236:4;13228:6;13224:17;13220:27;13210:55;;13261:1;13258;13251:12;13210:55;13290:6;13284:13;13316:4;13340:59;13356:42;13395:2;13356:42;:::i;13340:59::-;13433:15;;;13519:1;13515:10;;;;13503:23;;13499:32;;;13464:12;;;;13543:15;;;13540:35;;;13571:1;13568;13561:12;13540:35;13607:2;13599:6;13595:15;13619:135;13635:6;13630:3;13627:15;13619:135;;;13701:10;;13689:23;;13732:12;;;;13652;;13619:135;;;-1:-1:-1;13772:5:1;13125:658;-1:-1:-1;;;;;;13125:658:1:o;13788:1854::-;13927:6;13935;13966:2;14009;13997:9;13988:7;13984:23;13980:32;13977:52;;;14025:1;14022;14015:12;13977:52;14058:9;14052:16;14087:18;14128:2;14120:6;14117:14;14114:34;;;14144:1;14141;14134:12;14114:34;14182:6;14171:9;14167:22;14157:32;;14227:7;14220:4;14216:2;14212:13;14208:27;14198:55;;14249:1;14246;14239:12;14198:55;14278:2;14272:9;14300:4;14324:59;14340:42;14379:2;14340:42;:::i;14324:59::-;14417:15;;;14499:1;14495:10;;;;14487:19;;14483:28;;;14448:12;;;;14523:19;;;14520:39;;;14555:1;14552;14545:12;14520:39;14587:2;14583;14579:11;14599:825;14615:6;14610:3;14607:15;14599:825;;;14694:3;14688:10;14730:2;14717:11;14714:19;14711:109;;;14774:1;14803:2;14799;14792:14;14711:109;14843:20;;14898:2;14890:11;;14886:25;-1:-1:-1;14876:123:1;;14953:1;14982:2;14978;14971:14;14876:123;15036:2;15032;15028:11;15022:18;15066:49;15082:32;15111:2;15082:32;:::i;15066:49::-;15142:2;15135:5;15128:17;15186:7;15181:2;15176;15172;15168:11;15164:20;15161:33;15158:126;;;15236:1;15266:3;15261;15254:16;15158:126;15297:54;15348:2;15343;15336:5;15332:14;15327:2;15323;15319:11;15297:54;:::i;:::-;15364:18;;-1:-1:-1;;15402:12:1;;;;14632;;14599:825;;;-1:-1:-1;15479:18:1;;;15473:25;15443:5;;-1:-1:-1;15473:25:1;;-1:-1:-1;;;15510:16:1;;;15507:36;;;15539:1;15536;15529:12;15507:36;;;15562:74;15628:7;15617:8;15606:9;15602:24;15562:74;:::i;:::-;15552:84;;;13788:1854;;;;;:::o;17241:470::-;17420:3;17458:6;17452:13;17474:53;17520:6;17515:3;17508:4;17500:6;17496:17;17474:53;:::i;:::-;17590:13;;17549:16;;;;17612:57;17590:13;17549:16;17646:4;17634:17;;17612:57;:::i;:::-;17685:20;;17241:470;-1:-1:-1;;;;17241:470:1:o;17716:184::-;17786:6;17839:2;17827:9;17818:7;17814:23;17810:32;17807:52;;;17855:1;17852;17845:12;17807:52;-1:-1:-1;17878:16:1;;17716:184;-1:-1:-1;17716:184:1:o;19071:125::-;19111:4;19139:1;19136;19133:8;19130:34;;;19144:18;;:::i;:::-;-1:-1:-1;19181:9:1;;19071:125::o;19201:128::-;19241:3;19272:1;19268:6;19265:1;19262:13;19259:39;;;19278:18;;:::i;:::-;-1:-1:-1;19314:9:1;;19201:128::o;20924:184::-;20976:77;20973:1;20966:88;21073:4;21070:1;21063:15;21097:4;21094:1;21087:15;21113:120;21153:1;21179;21169:35;;21184:18;;:::i;:::-;-1:-1:-1;21218:9:1;;21113:120::o;21238:112::-;21270:1;21296;21286:35;;21301:18;;:::i;:::-;-1:-1:-1;21335:9:1;;21238:112::o;21608:409::-;-1:-1:-1;;;;;21815:6:1;21811:55;21800:9;21793:74;21903:6;21898:2;21887:9;21883:18;21876:34;21946:2;21941;21930:9;21926:18;21919:30;21774:4;21966:45;22007:2;21996:9;21992:18;21984:6;21966:45;:::i;:::-;21958:53;21608:409;-1:-1:-1;;;;;21608:409:1:o;22022:245::-;22089:6;22142:2;22130:9;22121:7;22117:23;22113:32;22110:52;;;22158:1;22155;22148:12;22110:52;22190:9;22184:16;22209:28;22231:5;22209:28;:::i;23083:512::-;23277:4;-1:-1:-1;;;;;23387:2:1;23379:6;23375:15;23364:9;23357:34;23439:2;23431:6;23427:15;23422:2;23411:9;23407:18;23400:43;;23479:6;23474:2;23463:9;23459:18;23452:34;23522:3;23517:2;23506:9;23502:18;23495:31;23543:46;23584:3;23573:9;23569:19;23561:6;23543:46;:::i;23600:249::-;23669:6;23722:2;23710:9;23701:7;23697:23;23693:32;23690:52;;;23738:1;23735;23728:12;23690:52;23770:9;23764:16;23789:30;23813:5;23789:30;:::i;25269:184::-;25321:77;25318:1;25311:88;25418:4;25415:1;25408:15;25442:4;25439:1;25432:15

Swarm Source

ipfs://68c1fcce1db43ac653baa1c807152e82e4827e5a90a031b58511b3b9b135ede6

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.