Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2022-03-17
*/

// Sources flattened with hardhat v2.8.3 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT

// 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/[email protected]

 
// 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/introspection/[email protected]

 
// 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/token/ERC721/[email protected]

 
// 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/[email protected]

 
// 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/token/ERC721/extensions/[email protected]

 
// 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/utils/[email protected]

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/[email protected]

 
// 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/introspection/[email protected]

 
// 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/[email protected]

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]

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

    /**
     * @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/[email protected]

 
// 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 @openzeppelin/contracts/utils/math/[email protected]

 
// OpenZeppelin Contracts v4.4.1 (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

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

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

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


// File @openzeppelin/contracts/utils/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File @openzeppelin/contracts/access/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


// File @openzeppelin/contracts/access/[email protected]

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

pragma solidity ^0.8.0;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File contracts/MinterControl.sol

 
pragma solidity 0.8.7;

abstract contract MinterControl is AccessControl {
    bytes32 public constant SHOGUN_OWNER_ROLE = keccak256("SHOGUN_OWNER_ROLE");
    bytes32 public constant SHOGUN_MINTER_ROLE = keccak256("SHOGUN_MINTER_ROLE");

    modifier onlyOwner() {
        require(hasRole(SHOGUN_OWNER_ROLE, _msgSender()), "MinterControl: not a SHOGUN_OWNER_ROLE");
        _;
    }

    modifier onlyMinter() {
        require(isMinter(_msgSender()), "MinterControl: not a SHOGUN_MINTER_ROLE");
        _;
    }

    constructor() {
        _setRoleAdmin(SHOGUN_OWNER_ROLE, SHOGUN_OWNER_ROLE);
        _setRoleAdmin(SHOGUN_MINTER_ROLE, SHOGUN_OWNER_ROLE);

        _setupRole(SHOGUN_OWNER_ROLE, _msgSender());
    }

    function grantMinter(address _minter) external {
        grantRole(SHOGUN_MINTER_ROLE, _minter);
    }

    function grantMinterMass(address[] memory minters) external {
      for(uint i = 0; i < minters.length; i++) {
          grantRole(SHOGUN_MINTER_ROLE, minters[i]);
      }
    }

    function removeMinter(address _minter) external {
      revokeRole(SHOGUN_MINTER_ROLE, _minter);
    }

    function isMinter(address _minter) public view returns (bool) {
        return hasRole(SHOGUN_MINTER_ROLE, _minter);
    }

    function grantOwner(address _owner) external {
        grantRole(SHOGUN_OWNER_ROLE, _owner);
    }

    function isOwner(address _owner) public view returns (bool) {
        return hasRole(SHOGUN_OWNER_ROLE, _owner);
    }
}


// File contracts/Shogun.sol

 
pragma solidity 0.8.7;





contract Shogun is MinterControl, ERC721Enumerable {
    using Strings for uint256;
    using Counters for Counters.Counter;

    uint256 private constant nftsNumber = 13422;
    uint256 private constant nftsWhitelistNumber = 10000;

    mapping(address => bool) internal wlMinted;

    mapping(uint256 => bool) internal frozenShogun;


    Counters.Counter private _tokenIdCounter;
    string public baseURI;

    event ShogunMint(address to, uint256 tokenId);

    constructor() ERC721("Shogun War", "Shogun") {
      _tokenIdCounter._value = 1;
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, AccessControl) returns (bool) {
        return ERC721Enumerable.supportsInterface(interfaceId) || AccessControl.supportsInterface(interfaceId);
    }

    function safeMint(address to) public onlyOwner {
        _mint(to);
    }

    function mintReserves(address to) public onlyOwner {
      for(uint i = 10000; i < 13423; i++) {
        _mintReserve(to, i);
      }
    }

    function mintReserve(address to, uint256 tokenId) public onlyOwner {
      require(tokenId > nftsWhitelistNumber, "Tokens number to mint must exceed number of public tokens");
      _mintReserve(to, tokenId);
    }

    function mint() external onlyMinter {
        require(wlMinted[msg.sender] == false, "You already used your whitelist mint pass");
        require(balanceOf(msg.sender) < 1, "You can only mint 1 NFT per whitelisted address");
        _mint(msg.sender);
        wlMinted[msg.sender] = true;
    }

    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        require(_exists(_tokenId), "Shogun: URI query for nonexistent token");
        return bytes(baseURI).length > 0 ?
            string(abi.encodePacked(
                baseURI,
                _tokenId.toString()
            ))
            : "";
    }

    function _mintReserve(address _to, uint256 _tokenId) internal {
        emit ShogunMint(_to, _tokenId);
        _safeMint(_to, _tokenId);
    }

    function _mint(address _to) internal {
        uint256 _tokenId;
        _tokenId = _tokenIdCounter.current();
        require(_tokenIdCounter.current() <= nftsWhitelistNumber, "Token number to mint exceeds number of whitelist tokens");
        _tokenIdCounter.increment();
        emit ShogunMint(_to, _tokenId);
        _safeMint(_to, _tokenId);
    }

    function freezeTransfer(uint256 _tokenId) external onlyOwner {
      frozenShogun[_tokenId] = true;
    }

    function unfreezeTransfer(uint256 _tokenId) external onlyOwner {
      frozenShogun[_tokenId] = false;
    }

    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256 _tokenId
    ) internal override {
        super._beforeTokenTransfer(_from, _to, _tokenId);
        require(frozenShogun[_tokenId] == false, "Shogun: Shogun is still busy, finish your assignment before transferring.");
    }

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

    // ADMIN


    function setBaseURI(string memory _baseURItoSet) external onlyOwner {
        baseURI = _baseURItoSet;
    }
}


// File contracts/TrainingGround.sol

 
pragma solidity 0.8.7;


contract TrainingGround is Ownable {

    // shogun training duration
    uint256 public constant trainingDuration = 30 days;

    // amount of shoguns training
    uint256 public shogunTraining;

    // shogun NFT
    Shogun public shogun;

    // training tracking
    mapping(uint256 => uint256) public timestampJoined;
    mapping(uint256 => uint256) public timestampFinished;

    // Shogun trained
    mapping(uint256 => bool) public shogunTrained;

    uint256[] public shogunsTrained;


    event JoinTraining(uint256 tokenId, uint256 timestampJoined, uint256 timestampFinished);
    event FinishTraining(uint256 tokenId);
    event ShogunSet(address shogun);

    modifier onlyShogunOwner(uint256 _tokenId) {
        require(shogun.ownerOf(_tokenId) == msg.sender, "Training: only owner can send to training");
        _;
    }

    modifier onlyUntrainedShogun(uint256 _tokenId) {
        require(shogunTrained[_tokenId] == false, "Training: Shogun already trained");
        _;
    }

    modifier atTraining(uint256 _tokenId, bool expectedAtTraining) {
        require(isAtTraining(_tokenId) == expectedAtTraining, "Training: wrong training attendance");
        _;
    }

    modifier updateTotalTraining(bool isJoining) {
        isJoining ? shogunTraining++ : shogunTraining--;
        _;
    }

    modifier isTrainingFinished(uint256 _tokenId) {
        require(block.timestamp > timestampFinished[_tokenId], "Training: Your shogun is not ready to leave training yet");
        _;
    }

    function totalTraining() public view returns (uint256) {
        return shogunTraining;
    }

    function trainingFinishedDate(uint256 _tokenId) public view returns (uint256) {
        return timestampFinished[_tokenId];
    }

    function isTrained(uint256 _tokenId) public view returns (bool) {
        return shogunTrained[_tokenId];
    }

    function isAtTraining(uint256 _tokenId) public view returns (bool) {
        return timestampJoined[_tokenId] > 0;
    }

    function getTrainedShoguns() public view returns (uint256[] memory) {
        return shogunsTrained;
    }

    function join(uint256 _tokenId)
        external
        onlyShogunOwner(_tokenId)
        atTraining(_tokenId, false)
        onlyUntrainedShogun(_tokenId)
        updateTotalTraining(true)
    {
        timestampJoined[_tokenId] = block.timestamp;
        timestampFinished[_tokenId] = block.timestamp + trainingDuration;
        shogun.freezeTransfer(_tokenId);
        emit JoinTraining(_tokenId, timestampJoined[_tokenId], timestampFinished[_tokenId]);
    }

    function drop(uint256 _tokenId)
        external
        onlyShogunOwner(_tokenId)
        atTraining(_tokenId, true)
        isTrainingFinished(_tokenId)
        updateTotalTraining(false)
    {
        shogun.unfreezeTransfer(_tokenId);
        shogunTrained[_tokenId] = true;
        timestampJoined[_tokenId] = 0;
        shogunsTrained.push(_tokenId);
        emit FinishTraining(_tokenId);
    }

    // ADMIN

    function setShogun(address _shogun) external onlyOwner {
        shogun = Shogun(_shogun);
        emit ShogunSet(_shogun);
    }

    function forceDrop(uint256 _tokenId)
        external
        onlyOwner
        updateTotalTraining(false)
    {
        shogun.unfreezeTransfer(_tokenId);
        shogunTrained[_tokenId] = true;
        timestampJoined[_tokenId] = 0;
        shogunsTrained.push(_tokenId);
        emit FinishTraining(_tokenId);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"FinishTraining","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestampJoined","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestampFinished","type":"uint256"}],"name":"JoinTraining","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"shogun","type":"address"}],"name":"ShogunSet","type":"event"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"drop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"forceDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getTrainedShoguns","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isAtTraining","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isTrained","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"join","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_shogun","type":"address"}],"name":"setShogun","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shogun","outputs":[{"internalType":"contract Shogun","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shogunTrained","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shogunTraining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shogunsTrained","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"timestampFinished","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"timestampJoined","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalTraining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"trainingDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"trainingFinishedDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

62952:3558:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65120:474;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63029:50;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63376:45;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65602:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63292:52;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64511:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63180:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2716:103;;;:::i;:::-;;66179:328;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2065:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64874:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63235:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63430:31;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63123:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65004:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64614:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2974:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66039:132;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64753:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65120:474;65195:8;63740:10;63712:38;;:6;;;;;;;;;;;:14;;;63727:8;63712:24;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:38;;;63704:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;65225:8:::1;65235:5;64095:18;64069:44;;:22;64082:8;64069:12;:22::i;:::-;:44;;;64061:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;65271:8:::2;63917:5;63890:32;;:13;:23;63904:8;63890:23;;;;;;;;;;;;;;;;;;;;;:32;;;63882:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;65310:4:::3;64237:9;:47;;64268:14;;:16;;;;;;;;;:::i;:::-;;;;;64237:47;;;64249:14;;:16;;;;;;;;;:::i;:::-;;;;;64237:47;;65360:15:::4;65332;:25;65348:8;65332:25;;;;;;;;;;;:43;;;;63072:7;65416:15;:34;;;;:::i;:::-;65386:17;:27;65404:8;65386:27;;;;;;;;;;;:64;;;;65461:6;;;;;;;;;;;:21;;;65483:8;65461:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::4;;;;;;;;;;;;::::0;::::4;;;;;;;;;65508:78;65521:8;65531:15;:25;65547:8;65531:25;;;;;;;;;;;;65558:17;:27;65576:8;65558:27;;;;;;;;;;;;65508:78;;;;;;;;:::i;:::-;;;;;;;;63970:1:::3;64164::::2;63807::::1;;65120:474:::0;;:::o;63029:50::-;63072:7;63029:50;:::o;63376:45::-;;;;;;;;;;;;;;;;;;;;;;:::o;65602:413::-;65677:8;63740:10;63712:38;;:6;;;;;;;;;;;:14;;;63727:8;63712:24;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:38;;;63704:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;65707:8:::1;65717:4;64095:18;64069:44;;:22;64082:8;64069:12;:22::i;:::-;:44;;;64061:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;65751:8:::2;64395:17;:27;64413:8;64395:27;;;;;;;;;;;;64377:15;:45;64369:114;;;;;;;;;;;;:::i;:::-;;;;;;;;;65790:5:::3;64237:9;:47;;64268:14;;:16;;;;;;;;;:::i;:::-;;;;;64237:47;;;64249:14;;:16;;;;;;;;;:::i;:::-;;;;;64237:47;;65813:6:::4;;;;;;;;;;;:23;;;65837:8;65813:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::4;;;;;;;;;;;;::::0;::::4;;;;;;;;;65883:4;65857:13;:23;65871:8;65857:23;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;65926:1;65898:15;:25;65914:8;65898:25;;;;;;;;;;;:29;;;;65938:14;65958:8;65938:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65983:24;65998:8;65983:24;;;;;;:::i;:::-;;;;;;;;64494:1:::3;64164::::2;63807::::1;;65602:413:::0;;:::o;63292:52::-;;;;;;;;;;;;;;;;;:::o;64511:95::-;64557:7;64584:14;;64577:21;;64511:95;:::o;63180:20::-;;;;;;;;;;;;;:::o;2716:103::-;2296:12;:10;:12::i;:::-;2285:23;;:7;:5;:7::i;:::-;:23;;;2277:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2781:30:::1;2808:1;2781:18;:30::i;:::-;2716:103::o:0;66179:328::-;2296:12;:10;:12::i;:::-;2285:23;;:7;:5;:7::i;:::-;:23;;;2277:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66282:5:::1;64237:9;:47;;64268:14;;:16;;;;;;;;;:::i;:::-;;;;;64237:47;;;64249:14;;:16;;;;;;;;;:::i;:::-;;;;;64237:47;;66305:6:::2;;;;;;;;;;;:23;;;66329:8;66305:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;66375:4;66349:13;:23;66363:8;66349:23;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;66418:1;66390:15;:25;66406:8;66390:25;;;;;;;;;;;:29;;;;66430:14;66450:8;66430:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66475:24;66490:8;66475:24;;;;;;:::i;:::-;;;;;;;;2356:1:::1;66179:328:::0;:::o;2065:87::-;2111:7;2138:6;;;;;;;;;;;2131:13;;2065:87;:::o;64874:122::-;64935:4;64987:1;64959:15;:25;64975:8;64959:25;;;;;;;;;;;;:29;64952:36;;64874:122;;;:::o;63235:50::-;;;;;;;;;;;;;;;;;:::o;63430:31::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;63123:29::-;;;;:::o;65004:108::-;65054:16;65090:14;65083:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65004:108;:::o;64614:131::-;64683:7;64710:17;:27;64728:8;64710:27;;;;;;;;;;;;64703:34;;64614:131;;;:::o;2974:201::-;2296:12;:10;:12::i;:::-;2285:23;;:7;:5;:7::i;:::-;:23;;;2277:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;3083:1:::1;3063:22;;:8;:22;;;;3055:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;3139:28;3158:8;3139:18;:28::i;:::-;2974:201:::0;:::o;66039:132::-;2296:12;:10;:12::i;:::-;2285:23;;:7;:5;:7::i;:::-;:23;;;2277:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66121:7:::1;66105:6;;:24;;;;;;;;;;;;;;;;;;66145:18;66155:7;66145:18;;;;;;:::i;:::-;;;;;;;;66039:132:::0;:::o;64753:113::-;64811:4;64835:13;:23;64849:8;64835:23;;;;;;;;;;;;;;;;;;;;;64828:30;;64753:113;;;:::o;782:98::-;835:7;862:10;855:17;;782:98;:::o;3335:191::-;3409:16;3428:6;;;;;;;;;;;3409:25;;3454:8;3445:6;;:17;;;;;;;;;;;;;;;;;;3509:8;3478:40;;3499:8;3478:40;;;;;;;;;;;;3398:128;3335:191;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:143::-;209:5;240:6;234:13;225:22;;256:33;283:5;256:33;:::i;:::-;152:143;;;;:::o;301:139::-;347:5;385:6;372:20;363:29;;401:33;428:5;401:33;:::i;:::-;301:139;;;;:::o;446:329::-;505:6;554:2;542:9;533:7;529:23;525:32;522:119;;;560:79;;:::i;:::-;522:119;680:1;705:53;750:7;741:6;730:9;726:22;705:53;:::i;:::-;695:63;;651:117;446:329;;;;:::o;781:351::-;851:6;900:2;888:9;879:7;875:23;871:32;868:119;;;906:79;;:::i;:::-;868:119;1026:1;1051:64;1107:7;1098:6;1087:9;1083:22;1051:64;:::i;:::-;1041:74;;997:128;781:351;;;;:::o;1138:329::-;1197:6;1246:2;1234:9;1225:7;1221:23;1217:32;1214:119;;;1252:79;;:::i;:::-;1214:119;1372:1;1397:53;1442:7;1433:6;1422:9;1418:22;1397:53;:::i;:::-;1387:63;;1343:117;1138:329;;;;:::o;1473:179::-;1542:10;1563:46;1605:3;1597:6;1563:46;:::i;:::-;1641:4;1636:3;1632:14;1618:28;;1473:179;;;;:::o;1658:118::-;1745:24;1763:5;1745:24;:::i;:::-;1740:3;1733:37;1658:118;;:::o;1812:732::-;1931:3;1960:54;2008:5;1960:54;:::i;:::-;2030:86;2109:6;2104:3;2030:86;:::i;:::-;2023:93;;2140:56;2190:5;2140:56;:::i;:::-;2219:7;2250:1;2235:284;2260:6;2257:1;2254:13;2235:284;;;2336:6;2330:13;2363:63;2422:3;2407:13;2363:63;:::i;:::-;2356:70;;2449:60;2502:6;2449:60;:::i;:::-;2439:70;;2295:224;2282:1;2279;2275:9;2270:14;;2235:284;;;2239:14;2535:3;2528:10;;1936:608;;;1812:732;;;;:::o;2550:109::-;2631:21;2646:5;2631:21;:::i;:::-;2626:3;2619:34;2550:109;;:::o;2665:161::-;2767:52;2813:5;2767:52;:::i;:::-;2762:3;2755:65;2665:161;;:::o;2832:366::-;2974:3;2995:67;3059:2;3054:3;2995:67;:::i;:::-;2988:74;;3071:93;3160:3;3071:93;:::i;:::-;3189:2;3184:3;3180:12;3173:19;;2832:366;;;:::o;3204:::-;3346:3;3367:67;3431:2;3426:3;3367:67;:::i;:::-;3360:74;;3443:93;3532:3;3443:93;:::i;:::-;3561:2;3556:3;3552:12;3545:19;;3204:366;;;:::o;3576:::-;3718:3;3739:67;3803:2;3798:3;3739:67;:::i;:::-;3732:74;;3815:93;3904:3;3815:93;:::i;:::-;3933:2;3928:3;3924:12;3917:19;;3576:366;;;:::o;3948:::-;4090:3;4111:67;4175:2;4170:3;4111:67;:::i;:::-;4104:74;;4187:93;4276:3;4187:93;:::i;:::-;4305:2;4300:3;4296:12;4289:19;;3948:366;;;:::o;4320:::-;4462:3;4483:67;4547:2;4542:3;4483:67;:::i;:::-;4476:74;;4559:93;4648:3;4559:93;:::i;:::-;4677:2;4672:3;4668:12;4661:19;;4320:366;;;:::o;4692:::-;4834:3;4855:67;4919:2;4914:3;4855:67;:::i;:::-;4848:74;;4931:93;5020:3;4931:93;:::i;:::-;5049:2;5044:3;5040:12;5033:19;;4692:366;;;:::o;5064:108::-;5141:24;5159:5;5141:24;:::i;:::-;5136:3;5129:37;5064:108;;:::o;5178:118::-;5265:24;5283:5;5265:24;:::i;:::-;5260:3;5253:37;5178:118;;:::o;5302:222::-;5395:4;5433:2;5422:9;5418:18;5410:26;;5446:71;5514:1;5503:9;5499:17;5490:6;5446:71;:::i;:::-;5302:222;;;;:::o;5530:373::-;5673:4;5711:2;5700:9;5696:18;5688:26;;5760:9;5754:4;5750:20;5746:1;5735:9;5731:17;5724:47;5788:108;5891:4;5882:6;5788:108;:::i;:::-;5780:116;;5530:373;;;;:::o;5909:210::-;5996:4;6034:2;6023:9;6019:18;6011:26;;6047:65;6109:1;6098:9;6094:17;6085:6;6047:65;:::i;:::-;5909:210;;;;:::o;6125:252::-;6233:4;6271:2;6260:9;6256:18;6248:26;;6284:86;6367:1;6356:9;6352:17;6343:6;6284:86;:::i;:::-;6125:252;;;;:::o;6383:419::-;6549:4;6587:2;6576:9;6572:18;6564:26;;6636:9;6630:4;6626:20;6622:1;6611:9;6607:17;6600:47;6664:131;6790:4;6664:131;:::i;:::-;6656:139;;6383:419;;;:::o;6808:::-;6974:4;7012:2;7001:9;6997:18;6989:26;;7061:9;7055:4;7051:20;7047:1;7036:9;7032:17;7025:47;7089:131;7215:4;7089:131;:::i;:::-;7081:139;;6808:419;;;:::o;7233:::-;7399:4;7437:2;7426:9;7422:18;7414:26;;7486:9;7480:4;7476:20;7472:1;7461:9;7457:17;7450:47;7514:131;7640:4;7514:131;:::i;:::-;7506:139;;7233:419;;;:::o;7658:::-;7824:4;7862:2;7851:9;7847:18;7839:26;;7911:9;7905:4;7901:20;7897:1;7886:9;7882:17;7875:47;7939:131;8065:4;7939:131;:::i;:::-;7931:139;;7658:419;;;:::o;8083:::-;8249:4;8287:2;8276:9;8272:18;8264:26;;8336:9;8330:4;8326:20;8322:1;8311:9;8307:17;8300:47;8364:131;8490:4;8364:131;:::i;:::-;8356:139;;8083:419;;;:::o;8508:::-;8674:4;8712:2;8701:9;8697:18;8689:26;;8761:9;8755:4;8751:20;8747:1;8736:9;8732:17;8725:47;8789:131;8915:4;8789:131;:::i;:::-;8781:139;;8508:419;;;:::o;8933:222::-;9026:4;9064:2;9053:9;9049:18;9041:26;;9077:71;9145:1;9134:9;9130:17;9121:6;9077:71;:::i;:::-;8933:222;;;;:::o;9161:442::-;9310:4;9348:2;9337:9;9333:18;9325:26;;9361:71;9429:1;9418:9;9414:17;9405:6;9361:71;:::i;:::-;9442:72;9510:2;9499:9;9495:18;9486:6;9442:72;:::i;:::-;9524;9592:2;9581:9;9577:18;9568:6;9524:72;:::i;:::-;9161:442;;;;;;:::o;9690:132::-;9757:4;9780:3;9772:11;;9810:4;9805:3;9801:14;9793:22;;9690:132;;;:::o;9828:114::-;9895:6;9929:5;9923:12;9913:22;;9828:114;;;:::o;9948:113::-;10018:4;10050;10045:3;10041:14;10033:22;;9948:113;;;:::o;10067:184::-;10166:11;10200:6;10195:3;10188:19;10240:4;10235:3;10231:14;10216:29;;10067:184;;;;:::o;10257:169::-;10341:11;10375:6;10370:3;10363:19;10415:4;10410:3;10406:14;10391:29;;10257:169;;;;:::o;10432:305::-;10472:3;10491:20;10509:1;10491:20;:::i;:::-;10486:25;;10525:20;10543:1;10525:20;:::i;:::-;10520:25;;10679:1;10611:66;10607:74;10604:1;10601:81;10598:107;;;10685:18;;:::i;:::-;10598:107;10729:1;10726;10722:9;10715:16;;10432:305;;;;:::o;10743:96::-;10780:7;10809:24;10827:5;10809:24;:::i;:::-;10798:35;;10743:96;;;:::o;10845:90::-;10879:7;10922:5;10915:13;10908:21;10897:32;;10845:90;;;:::o;10941:126::-;10978:7;11018:42;11011:5;11007:54;10996:65;;10941:126;;;:::o;11073:77::-;11110:7;11139:5;11128:16;;11073:77;;;:::o;11156:141::-;11221:9;11254:37;11285:5;11254:37;:::i;:::-;11241:50;;11156:141;;;:::o;11303:126::-;11353:9;11386:37;11417:5;11386:37;:::i;:::-;11373:50;;11303:126;;;:::o;11435:113::-;11485:9;11518:24;11536:5;11518:24;:::i;:::-;11505:37;;11435:113;;;:::o;11554:171::-;11593:3;11616:24;11634:5;11616:24;:::i;:::-;11607:33;;11662:4;11655:5;11652:15;11649:41;;;11670:18;;:::i;:::-;11649:41;11717:1;11710:5;11706:13;11699:20;;11554:171;;;:::o;11731:233::-;11770:3;11793:24;11811:5;11793:24;:::i;:::-;11784:33;;11839:66;11832:5;11829:77;11826:103;;;11909:18;;:::i;:::-;11826:103;11956:1;11949:5;11945:13;11938:20;;11731:233;;;:::o;11970:180::-;12018:77;12015:1;12008:88;12115:4;12112:1;12105:15;12139:4;12136:1;12129:15;12279:117;12388:1;12385;12378:12;12402:225;12542:34;12538:1;12530:6;12526:14;12519:58;12611:8;12606:2;12598:6;12594:15;12587:33;12402:225;:::o;12633:243::-;12773:34;12769:1;12761:6;12757:14;12750:58;12842:26;12837:2;12829:6;12825:15;12818:51;12633:243;:::o;12882:222::-;13022:34;13018:1;13010:6;13006:14;12999:58;13091:5;13086:2;13078:6;13074:15;13067:30;12882:222;:::o;13110:228::-;13250:34;13246:1;13238:6;13234:14;13227:58;13319:11;13314:2;13306:6;13302:15;13295:36;13110:228;:::o;13344:182::-;13484:34;13480:1;13472:6;13468:14;13461:58;13344:182;:::o;13532:::-;13672:34;13668:1;13660:6;13656:14;13649:58;13532:182;:::o;13720:122::-;13793:24;13811:5;13793:24;:::i;:::-;13786:5;13783:35;13773:63;;13832:1;13829;13822:12;13773:63;13720:122;:::o;13848:::-;13921:24;13939:5;13921:24;:::i;:::-;13914:5;13911:35;13901:63;;13960:1;13957;13950:12;13901:63;13848:122;:::o

ipfs://39416fd4521df1e510a0346fc5e67317639b850c8200b502c99a24cfbf02e7dd