Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC1155 is IERC165
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(address[] cal ...
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(
• interface IERC1155Receiver is IERC165
•    - function onERC1155Received(
•    - function onERC1155BatchReceived(
• interface IERC1155MetadataURI is IERC ...
•    - function uri(uint256 id)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
•    - function _msgSender()
•    - function _msgData()
•    - function supportsInterface(bytes4 int ...
•  contract ERC1155 is Context, ERC16 ...
•    - function supportsInterface(bytes4 int ...
•    - function uri(uint256)
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(address[] mem ...
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(
•    - function _safeTransferFrom(
•    - function _safeBatchTransferFrom(
•    - function _setURI(string memory newuri ...
•    - function _mint(
•    - function _mintBatch(
•    - function _burn(
•    - function _burnBatch(
•    - function _setApprovalForAll(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function _doSafeTransferAcceptanceChe ...
•    - function _doSafeBatchTransferAcceptan ...
•    - function _asSingletonArray(uint256 el ...
•    - function totalSupply(uint256 id)
•    - function exists(uint256 id)
•    - function _beforeTokenTransfer(
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract Passphrase is ERC1155Supp ... *
•    - function changeSigner(address _newSig ...
•    - function setGameCreationAccess(
•    - function createGame(
•    - function buyGame(uint256 _gameId)
•    - function claimReward(
•    - function withdrawCreatorEarning(uint2 ...
•    - function withdrawTreasuryEarning(
•    - function withdrawUnclaimedRewards(
•    - function setURI(string calldata _newu ...
•    - function setApprovalForAll(address, b ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-06-20
*/

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/extensions/ERC1155Supply.sol)




// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC1155/ERC1155.sol)




// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)




// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)



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


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)





/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)





/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}


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



/**
 * @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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


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



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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)





/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * 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;
    }
}


/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: address zero is not a valid owner");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `ids` and `amounts` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}


/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 */
abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 => uint256) private _totalSupply;

    /**
     * @dev Total amount of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return ERC1155Supply.totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] += amounts[i];
            }
        }

        if (to == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 id = ids[i];
                uint256 amount = amounts[i];
                uint256 supply = _totalSupply[id];
                require(supply >= amount, "ERC1155: burn amount exceeds totalSupply");
                unchecked {
                    _totalSupply[id] = supply - amount;
                }
            }
        }
    }
}


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)




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




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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)





/**
 * @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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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);
    }
}


contract Passphrase is ERC1155Supply, Ownable {
    using ECDSA for bytes32;

    /*//////////////////////////////////////////////////////////////
                            STATE VARIABLES
    //////////////////////////////////////////////////////////////*/

    struct Game {
        address gameCreator; // Creator of the game.
        bool creatorEarningsCollected; // Whether creator earnings have been claimed.
        bool treasuryEarningsCollected; // Whether treasury earnings have been claimed.
        uint64 gameStartTime; // Start time of the game.
        uint56 maxPlayers; // Maximum number of players that can participate in the game.
        uint128 gamePrice; // Price to buy a game.
        uint256 totalRewardsClaimed; // Keeps track of the accumulated rewards claimed for the game.
    }

    /// @notice Address linked to the private key utilized for signing the message.
    address public signer;

    /// @notice This tracks the overall count of games that have been created up to this point.
    uint256 public totalGamesCreated;

    // @notice Percentage of the total game price that the game creator (game creation fee) and the contract owner (treasury fee) are entitled to take.
    uint256 public constant CREATOR_AND_TREASURY_FEE = 1000; //10%

    // @notice Maximum percentage of the reward that a player can claim in the game.
    uint256 public constant MAX_PLAYER_REWARD_PCT = 8000; //80%

    /// @notice Utilized to calculate fees and is measured in basis points.
    uint256 public constant PERCENTAGE_CALCULATION = 10000; // 100%

    /// @notice Stores the number of days that must elapse after the game starts before an admin can claim unclaimed rewards for the game.
    uint256 public constant GRACE_PERIOD = 90 days;

    /// @notice Stores the maximum number of players that can participate in a game.
    uint256 public constant MAX_PLAYERS = 1000;

    /// @notice Tracks message hashes that have been used, to prevent message replay.
    mapping(bytes32 => bool) public messageHashUsed;

    /// @notice Tracks the eligibility of an address to create a game.
    mapping(address => bool) public isWhitelisted;

    /// @notice Tracks all the game's details associated with its ID.
    mapping(uint256 => Game) public gameDetails;

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/

    event GameCreated(
        address indexed gameCreator,
        uint256 gameId,
        uint256 indexed totalPlayers,
        uint256 indexed gamePrice
    );
    event GameBought(
        address indexed player,
        uint256 indexed gameId,
        uint256 totalGamesCreatedSoFar
    );

    event RewardsClaimed(
        address indexed player,
        uint256 indexed gameId,
        uint256 indexed rank,
        uint256 rewardAmount
    );

    event SignerChanged(address oldSigner, address newSigner);
    event GameCreationAccessSet(address indexed authorized, bool access);
    event CreatorEarningsWithdrawn(uint256 gameId);
    event TreasuryEarningsWithdrawn(address indexed recipient, uint256 gameId);
    event UnclaimedRewardsWithdrawn(
        uint256 gameId,
        address indexed recipient,
        uint256 indexed unclaimedRewards,
        uint256 indexed creatorEarnings
    );
    event URIChanged(string newURI);

    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/

    error AlreadyOwnOne();
    error AlreadyWithdrawn();
    error AlreadyUsedMessageHash();
    error CantBeTransferred();
    error CantClaimBeforeGracePeriod();
    error DoesnotOwnThisGame();
    error ExceedsMaxPlayersCap();
    error GameDoesnotExists();
    error GameNotStartedYet();
    error GameNotFullySoldOut();
    error NotGameCreator();
    error NotWhitelisted();
    error RewardAmountTooHigh();
    error RewardAlreadyDistributed();
    error SignerCantBuyGame();
    error SlotsFull();
    error TransferFailed();
    error WrongEthSent();
    error WrongSigner();
    error ZeroAddress();
    error ZeroAmount();

    /*//////////////////////////////////////////////////////////////
                               MODIFIER
    //////////////////////////////////////////////////////////////*/

    /// @notice Reverts if the caller is not eligible to create a game.
    modifier onlyWhitelisted() {
        if (!isWhitelisted[msg.sender]) {
            revert NotWhitelisted();
        }
        _;
    }

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

    /// @notice Sets the signer address.
    /// @param _uri URI of all tokens.
    /// @param _signer Address of the signer.
    constructor(string memory _uri, address _signer) ERC1155(_uri) {
        if (_signer == address(0)) {
            revert ZeroAddress();
        }
        signer = _signer;
        emit SignerChanged(address(0), _signer);
    }

    /*//////////////////////////////////////////////////////////////
                            SETTER FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Changes the signer address. Can only be called by the owner of this contract.
    /// @param _newSigner Address of the new signer.
    function changeSigner(address _newSigner) external onlyOwner {
        if (_newSigner == address(0)) {
            revert ZeroAddress();
        }

        emit SignerChanged(signer, _newSigner);

        // Overwrites the old signer address
        signer = _newSigner;
    }

    /// @notice Whitelists or dewhitelists an address for creating games. Can only be called by the owner of this contract.
    /// @param _address Address to give or revoke access of creating games.
    /// @param _access true to give access, false otherwise.
    function setGameCreationAccess(
        address _address,
        bool _access
    ) external onlyOwner {
        if (_address == address(0)) {
            revert ZeroAddress();
        }

        // Overwrites the access previously granted.
        isWhitelisted[_address] = _access;

        emit GameCreationAccessSet(_address, _access);
    }

    /*//////////////////////////////////////////////////////////////
                        GAME RELATED LOGIC
    //////////////////////////////////////////////////////////////*/

    /// @notice Creates a new game. Can only be called by whitelisted addresses.
    /// @param _maxPlayers Maximum slots available/ maximum players that can participate.
    /// @param _gamePrice Price to buy one slot.
    function createGame(
        uint56 _maxPlayers,
        uint128 _gamePrice
    ) external onlyWhitelisted {
        // Revert if either max players/ participants or game price is zero.
        if (_maxPlayers == 0 || _gamePrice == 0) {
            revert ZeroAmount();
        }

        if (_maxPlayers > MAX_PLAYERS) {
            revert ExceedsMaxPlayersCap();
        }

        // Increment total games created counter.
        /// @dev Game id of the first game would be 1.
        uint256 _gameId = ++totalGamesCreated;

        // Creating a new game/ setting game details.
        Game storage _game = gameDetails[_gameId];
        _game.gameCreator = msg.sender;
        _game.maxPlayers = _maxPlayers;
        _game.gamePrice = _gamePrice;

        emit GameCreated(msg.sender, _gameId, _maxPlayers, _gamePrice);
    }

    /// @notice Purchase a game or reserve a slot for a game.
    /// @param _gameId ID of the game for which to reserve a slot.
    function buyGame(uint256 _gameId) external payable {
        // Revert if signer address is trying to buy a game.
        if (msg.sender == signer) {
            revert SignerCantBuyGame();
        }

        // Reading or writing directly from the storage is more gas-efficient than loading it into memory first.
        Game storage game = gameDetails[_gameId];

        // Revert if a game is not created with the provided gameId.
        if (game.gameCreator == address(0)) {
            revert GameDoesnotExists();
        }

        // Revert if all the slots of the game are full.
        if (game.gameStartTime != 0) {
            revert SlotsFull();
        }

        // Token cannot be transferred or burnt so the check is sufficient.
        if (balanceOf(msg.sender, _gameId) != 0) {
            revert AlreadyOwnOne();
        }

        // Revert if eth received is more or less than game price.
        if (msg.value != game.gamePrice) {
            revert WrongEthSent();
        }

        // Commence the game 24 hours after all slots are full.
        if (totalSupply(_gameId) + 1 == game.maxPlayers) {
            game.gameStartTime = uint64(block.timestamp) + 24 hours;
        }

        // Only mint one copy of an ERC-1155 token to the caller
        /// @dev Token ID would be equal to game ID.
        _mint(msg.sender, _gameId, 1, "");

        // The last logged parameter represents the total slots filled.
        emit GameBought(msg.sender, _gameId, totalSupply(_gameId));
    }

    /// @notice Redeem the game's prize.
    /// @param _gameId ID of the game for which to claim a reward.
    /// @param _rank Attained rank within the game.
    /// @param _rewardAmount The prize earned from the game.
    /// @param _signature Signed message by the admin.
    function claimReward(
        uint256 _gameId,
        uint256 _rank,
        uint256 _rewardAmount,
        bytes calldata _signature
    ) external {
        // Reading or writing directly from the storage is more gas-efficient than loading it into memory first.
        Game storage _game = gameDetails[_gameId];

        // Revert if game id is invalid.
        if (_game.gameCreator == address(0)) {
            revert GameDoesnotExists();
        }

        // Revert if caller does not own the Token required to play the game.
        if (balanceOf(msg.sender, _gameId) == 0) {
            revert DoesnotOwnThisGame();
        }

        // Revert if all slots are not filled or if the game start time has not passed.
        if (_game.gameStartTime == 0 || block.timestamp < _game.gameStartTime) {
            revert GameNotStartedYet();
        }

        // Maximum amount of rewards that can be claimed for the game. (i.e. 80% of the total game price pool)
        uint256 _totalClaimableRewards = ((_game.gamePrice * _game.maxPlayers) *
            MAX_PLAYER_REWARD_PCT) / PERCENTAGE_CALCULATION;

        // Revert incase if the reward amount is more than 80% of the total game price pool.
        if (_rewardAmount > _totalClaimableRewards)
            revert RewardAmountTooHigh();

        // Revert if all rewards allocated for the game have been claimed.
        if (_totalClaimableRewards == _game.totalRewardsClaimed) {
            revert RewardAlreadyDistributed();
        }

        // Generating hash of the message.
        bytes32 messageHash = keccak256(
            abi.encodePacked(
                msg.sender,
                _gameId,
                _rank,
                _rewardAmount,
                block.chainid,
                address(this)
            )
        );

        // Revert if the generated message hash has been used already.
        if (messageHashUsed[messageHash]) {
            revert AlreadyUsedMessageHash();
        }

        // Signing message hash.
        bytes32 signedMessageHash = messageHash.toEthSignedMessageHash();

        // Recover address used to sign the message.
        address recoveredAddress = signedMessageHash.recover(_signature);

        // Revert if the message was signed with an address other than the signer address.
        if (recoveredAddress != signer) {
            revert WrongSigner();
        }

        messageHashUsed[messageHash] = true;

        _game.totalRewardsClaimed += _rewardAmount;

        // Transfer reward to the player
        (bool success, ) = msg.sender.call{value: _rewardAmount}("");

        if (!success) {
            revert TransferFailed();
        }

        emit RewardsClaimed(msg.sender, _gameId, _rank, _rewardAmount);
    }

    /*//////////////////////////////////////////////////////////////
                          WITHDRAW FEES LOGIC
    //////////////////////////////////////////////////////////////*/

    /// @notice Withdraw game creation earnings. Can only be called by the creator of the game.
    /// @param _gameId ID of the game for which to withdraw game creation earning.
    function withdrawCreatorEarning(uint256 _gameId) external {
        // Reading or writing directly from the storage is more gas-efficient than loading it into memory first.
        Game storage _game = gameDetails[_gameId];

        // Revert if game id is invalid or if caller is not the creator of the game.
        if (msg.sender != _game.gameCreator) {
            revert NotGameCreator();
        }

        // Revert if game creator is trying to withdraw creator earnings before all the slots are filled.
        if (_game.gameStartTime == 0) {
            revert GameNotFullySoldOut();
        }

        // Revert if creator earnings have already been collected by the game creator.
        if (_game.creatorEarningsCollected) {
            revert AlreadyWithdrawn();
        }

        _game.creatorEarningsCollected = true;

        // Using msg.sender instead of gameCreator to save same gas.
        // Transferring 10% of the total game price pool to the creator of the game.
        (bool success, ) = msg.sender.call{
            value: ((_game.gamePrice * _game.maxPlayers) *
                CREATOR_AND_TREASURY_FEE) / PERCENTAGE_CALCULATION
        }("");

        if (!success) {
            revert TransferFailed();
        }

        emit CreatorEarningsWithdrawn(_gameId);
    }

    /// @notice Withdraw game treasury earnings. Can only be called by the owner of this contract.
    /// @param _recipient Address of the recipient of the game treasury earnings.
    /// @param _gameId ID of the game for which to withdraw game treasury earning.
    function withdrawTreasuryEarning(
        address _recipient,
        uint256 _gameId
    ) external onlyOwner {
        if (_recipient == address(0)) {
            revert ZeroAddress();
        }

        // Reading or writing directly from the storage is more gas-efficient than loading it into memory first.
        Game storage _game = gameDetails[_gameId];

        // Revert if game id is invalid.
        if (_game.gameCreator == address(0)) {
            revert GameDoesnotExists();
        }

        // Revert if owner is trying to withdraw treasury earnings before all the slots are filled.
        if (_game.gameStartTime == 0) {
            revert GameNotFullySoldOut();
        }

        // Revert if treasury earnings have already been collected by the owner.
        if (_game.treasuryEarningsCollected) {
            revert AlreadyWithdrawn();
        }

        _game.treasuryEarningsCollected = true;

        // Transferring 10% of the total game price pool to the recipient.
        (bool success, ) = _recipient.call{
            value: ((_game.gamePrice * _game.maxPlayers) *
                CREATOR_AND_TREASURY_FEE) / PERCENTAGE_CALCULATION
        }("");

        if (!success) {
            revert TransferFailed();
        }

        emit TreasuryEarningsWithdrawn(_recipient, _gameId);
    }

    /// @notice Claim unclaimed rewards & creator earnings for a game if 90 days have passed since the game start time. Can only be called by the owner of this contract.
    /// @param _recipient The address of the recipient who will receive the unclaimed rewards & creator earnings.
    /// @param _gameId The ID of the game for which unclaimed rewards are being claimed.
    function withdrawUnclaimedRewards(
        address _recipient,
        uint256 _gameId
    ) external onlyOwner {
        if (_recipient == address(0)) {
            revert ZeroAddress();
        }

        // Reading or writing directly from the storage is more gas-efficient than loading it into memory first.
        Game storage _game = gameDetails[_gameId];

        // Revert if game id is invalid.
        if (_game.gameCreator == address(0)) {
            revert GameDoesnotExists();
        }

        // Revert if the owner tries to claim unclaimed rewards before all the slots are filled.
        if (_game.gameStartTime == 0) {
            revert GameNotFullySoldOut();
        }

        // Reverts if the owner tries to withdraw unclaimed rewards before the grace period of 90 days since the game start time has passed.
        if (_game.gameStartTime + GRACE_PERIOD > block.timestamp) {
            revert CantClaimBeforeGracePeriod();
        }

        // Maximum amount of rewards that can be claimed for the game. (i.e. 80% of the total game price pool)
        uint256 _totalClaimableRewards = ((_game.gamePrice * _game.maxPlayers) *
            MAX_PLAYER_REWARD_PCT) / PERCENTAGE_CALCULATION;

        uint256 _gameCreatorEarnings;

        // If the creator's earnings have not been collected by the game creator.
        if (!_game.creatorEarningsCollected) {
            // 10% of the total game price pool (allocated for game creator).
            _gameCreatorEarnings =
                ((_game.gamePrice * _game.maxPlayers) *
                    CREATOR_AND_TREASURY_FEE) /
                PERCENTAGE_CALCULATION;

            _game.creatorEarningsCollected = true;
        }

        uint256 _unclaimedGameRewards = _totalClaimableRewards -
            _game.totalRewardsClaimed;

        // Revert if all rewards of the game and creator earnings have been collected.
        if (_unclaimedGameRewards == 0 && _gameCreatorEarnings == 0) {
            revert RewardAlreadyDistributed();
        }

        // Only accumulate rewards if there are any unclaimed rewards.
        if (_unclaimedGameRewards != 0) {
            _game.totalRewardsClaimed += _unclaimedGameRewards;
        }

        // Transfer unclaimed rewards and creator earnings of the game to the recipient.
        (bool success, ) = _recipient.call{
            value: _unclaimedGameRewards + _gameCreatorEarnings
        }("");

        if (!success) {
            revert TransferFailed();
        }

        emit UnclaimedRewardsWithdrawn(
            _gameId,
            _recipient,
            _unclaimedGameRewards,
            _gameCreatorEarnings
        );
    }

    /*//////////////////////////////////////////////////////////////
                          ERC1155 FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Sets a new URI for all token types. Can only be called by the owner of this contract.
    /// @param _newuri URL of the new URI.
    function setURI(string calldata _newuri) external onlyOwner {
        // Overwrites old uri.
        _setURI(_newuri);

        emit URIChanged(_newuri);
    }

    function setApprovalForAll(address, bool) public virtual override {
        revert CantBeTransferred();
    }

    function safeTransferFrom(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override {
        revert CantBeTransferred();
    }

    function safeBatchTransferFrom(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override {
        revert CantBeTransferred();
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_uri","type":"string"},{"internalType":"address","name":"_signer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyOwnOne","type":"error"},{"inputs":[],"name":"AlreadyUsedMessageHash","type":"error"},{"inputs":[],"name":"AlreadyWithdrawn","type":"error"},{"inputs":[],"name":"CantBeTransferred","type":"error"},{"inputs":[],"name":"CantClaimBeforeGracePeriod","type":"error"},{"inputs":[],"name":"DoesnotOwnThisGame","type":"error"},{"inputs":[],"name":"ExceedsMaxPlayersCap","type":"error"},{"inputs":[],"name":"GameDoesnotExists","type":"error"},{"inputs":[],"name":"GameNotFullySoldOut","type":"error"},{"inputs":[],"name":"GameNotStartedYet","type":"error"},{"inputs":[],"name":"NotGameCreator","type":"error"},{"inputs":[],"name":"NotWhitelisted","type":"error"},{"inputs":[],"name":"RewardAlreadyDistributed","type":"error"},{"inputs":[],"name":"RewardAmountTooHigh","type":"error"},{"inputs":[],"name":"SignerCantBuyGame","type":"error"},{"inputs":[],"name":"SlotsFull","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"WrongEthSent","type":"error"},{"inputs":[],"name":"WrongSigner","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"}],"name":"CreatorEarningsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"},{"indexed":true,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalGamesCreatedSoFar","type":"uint256"}],"name":"GameBought","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"gameCreator","type":"address"},{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"totalPlayers","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"gamePrice","type":"uint256"}],"name":"GameCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authorized","type":"address"},{"indexed":false,"internalType":"bool","name":"access","type":"bool"}],"name":"GameCreationAccessSet","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":"player","type":"address"},{"indexed":true,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"rank","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldSigner","type":"address"},{"indexed":false,"internalType":"address","name":"newSigner","type":"address"}],"name":"SignerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"}],"name":"TreasuryEarningsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"newURI","type":"string"}],"name":"URIChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"uint256","name":"unclaimedRewards","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"creatorEarnings","type":"uint256"}],"name":"UnclaimedRewardsWithdrawn","type":"event"},{"inputs":[],"name":"CREATOR_AND_TREASURY_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GRACE_PERIOD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PLAYERS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PLAYER_REWARD_PCT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENTAGE_CALCULATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"buyGame","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_newSigner","type":"address"}],"name":"changeSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gameId","type":"uint256"},{"internalType":"uint256","name":"_rank","type":"uint256"},{"internalType":"uint256","name":"_rewardAmount","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint56","name":"_maxPlayers","type":"uint56"},{"internalType":"uint128","name":"_gamePrice","type":"uint128"}],"name":"createGame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"gameDetails","outputs":[{"internalType":"address","name":"gameCreator","type":"address"},{"internalType":"bool","name":"creatorEarningsCollected","type":"bool"},{"internalType":"bool","name":"treasuryEarningsCollected","type":"bool"},{"internalType":"uint64","name":"gameStartTime","type":"uint64"},{"internalType":"uint56","name":"maxPlayers","type":"uint56"},{"internalType":"uint128","name":"gamePrice","type":"uint128"},{"internalType":"uint256","name":"totalRewardsClaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","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":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"messageHashUsed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bool","name":"","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_access","type":"bool"}],"name":"setGameCreationAccess","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalGamesCreated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"withdrawCreatorEarning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"withdrawTreasuryEarning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_gameId","type":"uint256"}],"name":"withdrawUnclaimedRewards","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b5060405162002dfa38038062002dfa83398101604081905262000034916200016c565b816200004081620000d5565b506200004c33620000e7565b6001600160a01b038116620000745760405163d92e233d60e01b815260040160405180910390fd5b600580546001600160a01b0319166001600160a01b038316908117909155604080516000815260208101929092527feeb293e1f8f3a9db91ade748726387ed1352ca78f5430c5f06fe3d1e1ad50579910160405180910390a15050620003af565b6002620000e38282620002e3565b5050565b600480546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b634e487b7160e01b600052604160045260246000fd5b80516001600160a01b03811681146200016757600080fd5b919050565b600080604083850312156200018057600080fd5b82516001600160401b03808211156200019857600080fd5b818501915085601f830112620001ad57600080fd5b815181811115620001c257620001c262000139565b604051601f8201601f19908116603f01168101908382118183101715620001ed57620001ed62000139565b816040528281526020935088848487010111156200020a57600080fd5b600091505b828210156200022e57848201840151818301850152908301906200020f565b6000848483010152809650505050620002498186016200014f565b925050509250929050565b600181811c908216806200026957607f821691505b6020821081036200028a57634e487b7160e01b600052602260045260246000fd5b50919050565b601f821115620002de57600081815260208120601f850160051c81016020861015620002b95750805b601f850160051c820191505b81811015620002da57828155600101620002c5565b5050505b505050565b81516001600160401b03811115620002ff57620002ff62000139565b620003178162000310845462000254565b8462000290565b602080601f8311600181146200034f5760008415620003365750858301515b600019600386901b1c1916600185901b178555620002da565b600085815260208120601f198616915b8281101562000380578886015182559484019460019091019084016200035f565b50858210156200039f5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b612a3b80620003bf6000396000f3fe6080604052600436106101e25760003560e01c80636aa0936311610102578063ac52328e11610095578063e985e9c511610064578063e985e9c514610660578063f242432a146106a9578063f2fde38b146106c4578063f7760517146106e457600080fd5b8063ac52328e146105cc578063bd85b039146105fc578063bdf297b514610629578063c1a287e21461064957600080fd5b80638dbb15bb116100d15780638dbb15bb1461055b578063a22cb46514610571578063aad2b7231461058c578063ab36b736146105ac57600080fd5b80636aa093631461041f578063715018a61461050857806384a7e7881461051d5780638da5cb5b1461053d57600080fd5b80632eb2c2d61161017a5780634e1273f4116101495780634e1273f41461038d5780634f558e79146103ba5780636209deb4146103e95780636568e0581461040957600080fd5b80632eb2c2d6146103275780633af32abf1461034757806341654700146103775780634411b3eb1461031157600080fd5b806313270744116101b657806313270744146102995780631eeb57f0146102b9578063238ac933146102d9578063264c70701461031157600080fd5b8062fdd58e146101e757806301ffc9a71461021a57806302fe53051461024a5780630e89341c1461026c575b600080fd5b3480156101f357600080fd5b50610207610202366004612093565b6106f7565b6040519081526020015b60405180910390f35b34801561022657600080fd5b5061023a6102353660046120d3565b610790565b6040519015158152602001610211565b34801561025657600080fd5b5061026a610265366004612138565b6107e0565b005b34801561027857600080fd5b5061028c610287366004612179565b610864565b60405161021191906121d8565b3480156102a557600080fd5b5061026a6102b43660046121eb565b6108f8565b3480156102c557600080fd5b5061026a6102d436600461223c565b610a45565b3480156102e557600080fd5b506005546102f9906001600160a01b031681565b6040516001600160a01b039091168152602001610211565b34801561031d57600080fd5b506102076103e881565b34801561033357600080fd5b5061026a6103423660046123b6565b610ad3565b34801561035357600080fd5b5061023a61036236600461245f565b60086020526000908152604090205460ff1681565b34801561038357600080fd5b5061020761271081565b34801561039957600080fd5b506103ad6103a836600461247a565b610aec565b6040516102119190612544565b3480156103c657600080fd5b5061023a6103d5366004612179565b600090815260036020526040902054151590565b3480156103f557600080fd5b5061026a610404366004612588565b610c15565b34801561041557600080fd5b50610207611f4081565b34801561042b57600080fd5b506104aa61043a366004612179565b6009602052600090815260409020805460018201546002909201546001600160a01b03821692600160a01b830460ff90811693600160a81b810490911692600160b01b9091046001600160401b03169166ffffffffffffff811691600160381b9091046001600160801b03169087565b604080516001600160a01b0390981688529515156020880152931515948601949094526001600160401b03909116606085015266ffffffffffffff1660808401526001600160801b0390911660a083015260c082015260e001610211565b34801561051457600080fd5b5061026a610fa7565b34801561052957600080fd5b5061026a610538366004612179565b610fbb565b34801561054957600080fd5b506004546001600160a01b03166102f9565b34801561056757600080fd5b5061020760065481565b34801561057d57600080fd5b5061026a61034236600461223c565b34801561059857600080fd5b5061026a6105a736600461245f565b61114f565b3480156105b857600080fd5b5061026a6105c7366004612093565b6111e7565b3480156105d857600080fd5b5061023a6105e7366004612179565b60076020526000908152604090205460ff1681565b34801561060857600080fd5b50610207610617366004612179565b60009081526003602052604090205490565b34801561063557600080fd5b5061026a610644366004612093565b6114ad565b34801561065557600080fd5b506102076276a70081565b34801561066c57600080fd5b5061023a61067b3660046125e8565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205460ff1690565b3480156106b557600080fd5b5061026a61034236600461261b565b3480156106d057600080fd5b5061026a6106df36600461245f565b611688565b61026a6106f2366004612179565b611701565b60006001600160a01b0383166107675760405162461bcd60e51b815260206004820152602a60248201527f455243313135353a2061646472657373207a65726f206973206e6f742061207660448201526930b634b21037bbb732b960b11b60648201526084015b60405180910390fd5b506000818152602081815260408083206001600160a01b03861684529091529020545b92915050565b60006001600160e01b03198216636cdb3d1360e11b14806107c157506001600160e01b031982166303a24d0760e21b145b8061078a57506301ffc9a760e01b6001600160e01b031983161461078a565b6107e86118c1565b61082782828080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061191b92505050565b7fbd06d92759c326896ec0f7c3a981e801ae4644e020f89b2a198909b692df0ddd828260405161085892919061267f565b60405180910390a15050565b606060028054610873906126ae565b80601f016020809104026020016040519081016040528092919081815260200182805461089f906126ae565b80156108ec5780601f106108c1576101008083540402835291602001916108ec565b820191906000526020600020905b8154815290600101906020018083116108cf57829003601f168201915b50505050509050919050565b3360009081526008602052604090205460ff1661092857604051630b094f2760e31b815260040160405180910390fd5b66ffffffffffffff8216158061094557506001600160801b038116155b1561096357604051631f2a200560e01b815260040160405180910390fd5b6103e88266ffffffffffffff16111561098f5760405163552a554960e11b815260040160405180910390fd5b60006006600081546109a0906126fe565b91829055506000818152600960205260409081902080546001600160a01b0319163390811782556001820180546001600160801b038816600160381b81026001600160b81b031990921666ffffffffffffff8b1690811792909217909255935194955091939192917f9d7c1b2906659a849d82e8238d5f8ea4a5a716c8659d026a0debcf547a4d487190610a379087815260200190565b60405180910390a450505050565b610a4d6118c1565b6001600160a01b038216610a745760405163d92e233d60e01b815260040160405180910390fd5b6001600160a01b038216600081815260086020908152604091829020805460ff191685151590811790915591519182527fc3546ff396abb820783528d59cf4ea2ffef19c75056e6f56696701eb9e2c7a5a910160405180910390a25050565b604051630c720e5960e11b815260040160405180910390fd5b60608151835114610b515760405162461bcd60e51b815260206004820152602960248201527f455243313135353a206163636f756e747320616e6420696473206c656e677468604482015268040dad2e6dac2e8c6d60bb1b606482015260840161075e565b600083516001600160401b03811115610b6c57610b6c61226d565b604051908082528060200260200182016040528015610b95578160200160208202803683370190505b50905060005b8451811015610c0d57610be0858281518110610bb957610bb9612717565b6020026020010151858381518110610bd357610bd3612717565b60200260200101516106f7565b828281518110610bf257610bf2612717565b6020908102919091010152610c06816126fe565b9050610b9b565b509392505050565b600085815260096020526040902080546001600160a01b0316610c4b57604051635cb6cfdd60e01b815260040160405180910390fd5b610c5533876106f7565b600003610c7557604051633ec8ca4d60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b03161580610ca357508054600160b01b90046001600160401b031642105b15610cc15760405163201b9ddb60e11b815260040160405180910390fd5b600181015460009061271090611f4090610cf59066ffffffffffffff811690600160381b90046001600160801b031661272d565b6001600160801b0316610d089190612758565b610d12919061276f565b905080851115610d3557604051637825ae5b60e01b815260040160405180910390fd5b81600201548103610d5957604051634506832760e11b815260040160405180910390fd5b6040516bffffffffffffffffffffffff1933606090811b82166020840152603483018a9052605483018990526074830188905246609484015230901b1660b482015260009060c80160408051601f1981840301815291815281516020928301206000818152600790935291205490915060ff1615610dea57604051637d930c5160e01b815260040160405180910390fd5b6000610e43826040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c8101829052600090605c01604051602081830303815290604052805190602001209050919050565b90506000610e8987878080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250869392505061192b9050565b6005549091506001600160a01b03808316911614610eba576040516353c9973560e11b815260040160405180910390fd5b6000838152600760205260408120805460ff191660011790556002860180548a9290610ee7908490612791565b909155505060405160009033908a908381818185875af1925050503d8060008114610f2e576040519150601f19603f3d011682016040523d82523d6000602084013e610f33565b606091505b5050905080610f55576040516312171d8360e31b815260040160405180910390fd5b898b336001600160a01b03167f56253d287efacdb2c4cd76dd03624a4821c1ce721d1152e8f5f5718f6087c9bf8c604051610f9291815260200190565b60405180910390a45050505050505050505050565b610faf6118c1565b610fb96000611947565b565b600081815260096020526040902080546001600160a01b03163314610ff357604051631b32bab160e31b815260040160405180910390fd5b8054600160b01b90046001600160401b031660000361102557604051631123326560e31b815260040160405180910390fd5b8054600160a01b900460ff161561104f57604051636507689f60e01b815260040160405180910390fd5b805460ff60a01b1916600160a01b17815560018101546000903390612710906103e8906110979066ffffffffffffff8116906001600160801b03600160381b9091041661272d565b6001600160801b03166110aa9190612758565b6110b4919061276f565b604051600081818185875af1925050503d80600081146110f0576040519150601f19603f3d011682016040523d82523d6000602084013e6110f5565b606091505b5050905080611117576040516312171d8360e31b815260040160405180910390fd5b6040518381527fa8d363038fe6a30670da0501e8a8fc04534db6129e94dba897fdfe6276a05e8a9060200160405180910390a1505050565b6111576118c1565b6001600160a01b03811661117e5760405163d92e233d60e01b815260040160405180910390fd5b600554604080516001600160a01b03928316815291831660208301527feeb293e1f8f3a9db91ade748726387ed1352ca78f5430c5f06fe3d1e1ad50579910160405180910390a1600580546001600160a01b0319166001600160a01b0392909216919091179055565b6111ef6118c1565b6001600160a01b0382166112165760405163d92e233d60e01b815260040160405180910390fd5b600081815260096020526040902080546001600160a01b031661124c57604051635cb6cfdd60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b031660000361127e57604051631123326560e31b815260040160405180910390fd5b805442906112a0906276a70090600160b01b90046001600160401b0316612791565b11156112bf57604051631b8867c960e21b815260040160405180910390fd5b600181015460009061271090611f40906112f39066ffffffffffffff811690600160381b90046001600160801b031661272d565b6001600160801b03166113069190612758565b611310919061276f565b8254909150600090600160a01b900460ff16611388576001830154612710906103e8906113579066ffffffffffffff811690600160381b90046001600160801b031661272d565b6001600160801b031661136a9190612758565b611374919061276f565b835460ff60a01b1916600160a01b17845590505b600083600201548361139a91906127a4565b9050801580156113a8575081155b156113c657604051634506832760e11b815260040160405180910390fd5b80156113e657808460020160008282546113e09190612791565b90915550505b60006001600160a01b0387166113fc8484612791565b604051600081818185875af1925050503d8060008114611438576040519150601f19603f3d011682016040523d82523d6000602084013e61143d565b606091505b505090508061145f576040516312171d8360e31b815260040160405180910390fd5b8282886001600160a01b03167f6acc4904650e5fea98be9fcdba4d5d4dd5ea247b4805f307e2ae8f0f0c053f5a8960405161149c91815260200190565b60405180910390a450505050505050565b6114b56118c1565b6001600160a01b0382166114dc5760405163d92e233d60e01b815260040160405180910390fd5b600081815260096020526040902080546001600160a01b031661151257604051635cb6cfdd60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b031660000361154457604051631123326560e31b815260040160405180910390fd5b8054600160a81b900460ff161561156e57604051636507689f60e01b815260040160405180910390fd5b805460ff60a81b1916600160a81b17815560018101546000906001600160a01b03851690612710906103e8906115bf9066ffffffffffffff8116906001600160801b03600160381b9091041661272d565b6001600160801b03166115d29190612758565b6115dc919061276f565b604051600081818185875af1925050503d8060008114611618576040519150601f19603f3d011682016040523d82523d6000602084013e61161d565b606091505b505090508061163f576040516312171d8360e31b815260040160405180910390fd5b836001600160a01b03167fcbc4d588d41c6eb36eab1f36c5414cc5f64778fc599803abd57f0c6fe017ddec8460405161167a91815260200190565b60405180910390a250505050565b6116906118c1565b6001600160a01b0381166116f55760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161075e565b6116fe81611947565b50565b6005546001600160a01b0316330361172c576040516312dd36a360e11b815260040160405180910390fd5b600081815260096020526040902080546001600160a01b031661176257604051635cb6cfdd60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b0316156117925760405163848084dd60e01b815260040160405180910390fd5b61179c33836106f7565b156117ba5760405163f367f5f160e01b815260040160405180910390fd5b6001810154600160381b90046001600160801b031634146117ee576040516315df163f60e31b815260040160405180910390fd5b600181015466ffffffffffffff166118128360009081526003602052604090205490565b61181d906001612791565b036118575761182f42620151806127b7565b81546001600160401b0391909116600160b01b0267ffffffffffffffff60b01b199091161781555b6118733383600160405180602001604052806000815250611999565b81337f2f10445408f98037db3b8cb9284971437981c6b22fcbc65520c84657e003eb496118ac8360009081526003602052604090205490565b60405190815260200160405180910390a35050565b6004546001600160a01b03163314610fb95760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161075e565b60026119278282612829565b5050565b600080600061193a8585611abc565b91509150610c0d81611b01565b600480546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6001600160a01b0384166119f95760405162461bcd60e51b815260206004820152602160248201527f455243313135353a206d696e7420746f20746865207a65726f206164647265736044820152607360f81b606482015260840161075e565b336000611a0585611c4b565b90506000611a1285611c4b565b9050611a2383600089858589611c96565b6000868152602081815260408083206001600160a01b038b16845290915281208054879290611a53908490612791565b909155505060408051878152602081018790526001600160a01b03808a1692600092918716917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a4611ab383600089898989611e17565b50505050505050565b6000808251604103611af25760208301516040840151606085015160001a611ae687828585611fb3565b94509450505050611afa565b506000905060025b9250929050565b6000816004811115611b1557611b156128e8565b03611b1d5750565b6001816004811115611b3157611b316128e8565b03611b7e5760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e61747572650000000000000000604482015260640161075e565b6002816004811115611b9257611b926128e8565b03611bdf5760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e67746800604482015260640161075e565b6003816004811115611bf357611bf36128e8565b036116fe5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b606482015260840161075e565b60408051600180825281830190925260609160009190602080830190803683370190505090508281600081518110611c8557611c85612717565b602090810291909101015292915050565b6001600160a01b038516611d1d5760005b8351811015611d1b57828181518110611cc257611cc2612717565b602002602001015160036000868481518110611ce057611ce0612717565b602002602001015181526020019081526020016000206000828254611d059190612791565b90915550611d149050816126fe565b9050611ca7565b505b6001600160a01b038416611e0f5760005b8351811015611ab3576000848281518110611d4b57611d4b612717565b602002602001015190506000848381518110611d6957611d69612717565b6020026020010151905060006003600084815260200190815260200160002054905081811015611dec5760405162461bcd60e51b815260206004820152602860248201527f455243313135353a206275726e20616d6f756e74206578636565647320746f74604482015267616c537570706c7960c01b606482015260840161075e565b60009283526003602052604090922091039055611e08816126fe565b9050611d2e565b505050505050565b6001600160a01b0384163b15611e0f5760405163f23a6e6160e01b81526001600160a01b0385169063f23a6e6190611e5b90899089908890889088906004016128fe565b6020604051808303816000875af1925050508015611e96575060408051601f3d908101601f19168201909252611e9391810190612943565b60015b611f4257611ea2612960565b806308c379a003611edb5750611eb661297c565b80611ec15750611edd565b8060405162461bcd60e51b815260040161075e91906121d8565b505b60405162461bcd60e51b815260206004820152603460248201527f455243313135353a207472616e7366657220746f206e6f6e2d455243313135356044820152732932b1b2b4bb32b91034b6b83632b6b2b73a32b960611b606482015260840161075e565b6001600160e01b0319811663f23a6e6160e01b14611ab35760405162461bcd60e51b815260206004820152602860248201527f455243313135353a204552433131353552656365697665722072656a656374656044820152676420746f6b656e7360c01b606482015260840161075e565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611fea575060009050600361206e565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa15801561203e573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166120675760006001925092505061206e565b9150600090505b94509492505050565b80356001600160a01b038116811461208e57600080fd5b919050565b600080604083850312156120a657600080fd5b6120af83612077565b946020939093013593505050565b6001600160e01b0319811681146116fe57600080fd5b6000602082840312156120e557600080fd5b81356120f0816120bd565b9392505050565b60008083601f84011261210957600080fd5b5081356001600160401b0381111561212057600080fd5b602083019150836020828501011115611afa57600080fd5b6000806020838503121561214b57600080fd5b82356001600160401b0381111561216157600080fd5b61216d858286016120f7565b90969095509350505050565b60006020828403121561218b57600080fd5b5035919050565b6000815180845260005b818110156121b85760208185018101518683018201520161219c565b506000602082860101526020601f19601f83011685010191505092915050565b6020815260006120f06020830184612192565b600080604083850312156121fe57600080fd5b823566ffffffffffffff8116811461221557600080fd5b915060208301356001600160801b038116811461223157600080fd5b809150509250929050565b6000806040838503121561224f57600080fd5b61225883612077565b91506020830135801515811461223157600080fd5b634e487b7160e01b600052604160045260246000fd5b601f8201601f191681016001600160401b03811182821017156122a8576122a861226d565b6040525050565b60006001600160401b038211156122c8576122c861226d565b5060051b60200190565b600082601f8301126122e357600080fd5b813560206122f0826122af565b6040516122fd8282612283565b83815260059390931b850182019282810191508684111561231d57600080fd5b8286015b848110156123385780358352918301918301612321565b509695505050505050565b600082601f83011261235457600080fd5b81356001600160401b0381111561236d5761236d61226d565b604051612384601f8301601f191660200182612283565b81815284602083860101111561239957600080fd5b816020850160208301376000918101602001919091529392505050565b600080600080600060a086880312156123ce57600080fd5b6123d786612077565b94506123e560208701612077565b935060408601356001600160401b038082111561240157600080fd5b61240d89838a016122d2565b9450606088013591508082111561242357600080fd5b61242f89838a016122d2565b9350608088013591508082111561244557600080fd5b5061245288828901612343565b9150509295509295909350565b60006020828403121561247157600080fd5b6120f082612077565b6000806040838503121561248d57600080fd5b82356001600160401b03808211156124a457600080fd5b818501915085601f8301126124b857600080fd5b813560206124c5826122af565b6040516124d28282612283565b83815260059390931b85018201928281019150898411156124f257600080fd5b948201945b838610156125175761250886612077565b825294820194908201906124f7565b9650508601359250508082111561252d57600080fd5b5061253a858286016122d2565b9150509250929050565b6020808252825182820181905260009190848201906040850190845b8181101561257c57835183529284019291840191600101612560565b50909695505050505050565b6000806000806000608086880312156125a057600080fd5b85359450602086013593506040860135925060608601356001600160401b038111156125cb57600080fd5b6125d7888289016120f7565b969995985093965092949392505050565b600080604083850312156125fb57600080fd5b61260483612077565b915061261260208401612077565b90509250929050565b600080600080600060a0868803121561263357600080fd5b61263c86612077565b945061264a60208701612077565b9350604086013592506060860135915060808601356001600160401b0381111561267357600080fd5b61245288828901612343565b60208152816020820152818360408301376000818301604090810191909152601f909201601f19160101919050565b600181811c908216806126c257607f821691505b6020821081036126e257634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b600060018201612710576127106126e8565b5060010190565b634e487b7160e01b600052603260045260246000fd5b6001600160801b03818116838216028082169190828114612750576127506126e8565b505092915050565b808202811582820484141761078a5761078a6126e8565b60008261278c57634e487b7160e01b600052601260045260246000fd5b500490565b8082018082111561078a5761078a6126e8565b8181038181111561078a5761078a6126e8565b6001600160401b038181168382160190808211156127d7576127d76126e8565b5092915050565b601f82111561282457600081815260208120601f850160051c810160208610156128055750805b601f850160051c820191505b81811015611e0f57828155600101612811565b505050565b81516001600160401b038111156128425761284261226d565b6128568161285084546126ae565b846127de565b602080601f83116001811461288b57600084156128735750858301515b600019600386901b1c1916600185901b178555611e0f565b600085815260208120601f198616915b828110156128ba5788860151825594840194600190910190840161289b565b50858210156128d85787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b600052602160045260246000fd5b6001600160a01b03868116825285166020820152604081018490526060810183905260a06080820181905260009061293890830184612192565b979650505050505050565b60006020828403121561295557600080fd5b81516120f0816120bd565b600060033d11156129795760046000803e5060005160e01c5b90565b600060443d101561298a5790565b6040516003193d81016004833e81513d6001600160401b0381602484011181841117156129b957505050505090565b82850191508151818111156129d15750505050505090565b843d87010160208285010111156129eb5750505050505090565b6129fa60208286010187612283565b50909594505050505056fea264697066735822122004833a06cd4aead9511d567f07af67b14d4699308548f3ee0952df511ece447564736f6c6343000811003300000000000000000000000000000000000000000000000000000000000000400000000000000000000000001ef5e3c23bb482b3f34e137c88e59d20083be836000000000000000000000000000000000000000000000000000000000000002f68747470733a2f2f7777772e706173737068726173652e6c6976652f6e6674732f506c6179506173734f472e6769660000000000000000000000000000000000

0x6080604052600436106101e25760003560e01c80636aa0936311610102578063ac52328e11610095578063e985e9c511610064578063e985e9c514610660578063f242432a146106a9578063f2fde38b146106c4578063f7760517146106e457600080fd5b8063ac52328e146105cc578063bd85b039146105fc578063bdf297b514610629578063c1a287e21461064957600080fd5b80638dbb15bb116100d15780638dbb15bb1461055b578063a22cb46514610571578063aad2b7231461058c578063ab36b736146105ac57600080fd5b80636aa093631461041f578063715018a61461050857806384a7e7881461051d5780638da5cb5b1461053d57600080fd5b80632eb2c2d61161017a5780634e1273f4116101495780634e1273f41461038d5780634f558e79146103ba5780636209deb4146103e95780636568e0581461040957600080fd5b80632eb2c2d6146103275780633af32abf1461034757806341654700146103775780634411b3eb1461031157600080fd5b806313270744116101b657806313270744146102995780631eeb57f0146102b9578063238ac933146102d9578063264c70701461031157600080fd5b8062fdd58e146101e757806301ffc9a71461021a57806302fe53051461024a5780630e89341c1461026c575b600080fd5b3480156101f357600080fd5b50610207610202366004612093565b6106f7565b6040519081526020015b60405180910390f35b34801561022657600080fd5b5061023a6102353660046120d3565b610790565b6040519015158152602001610211565b34801561025657600080fd5b5061026a610265366004612138565b6107e0565b005b34801561027857600080fd5b5061028c610287366004612179565b610864565b60405161021191906121d8565b3480156102a557600080fd5b5061026a6102b43660046121eb565b6108f8565b3480156102c557600080fd5b5061026a6102d436600461223c565b610a45565b3480156102e557600080fd5b506005546102f9906001600160a01b031681565b6040516001600160a01b039091168152602001610211565b34801561031d57600080fd5b506102076103e881565b34801561033357600080fd5b5061026a6103423660046123b6565b610ad3565b34801561035357600080fd5b5061023a61036236600461245f565b60086020526000908152604090205460ff1681565b34801561038357600080fd5b5061020761271081565b34801561039957600080fd5b506103ad6103a836600461247a565b610aec565b6040516102119190612544565b3480156103c657600080fd5b5061023a6103d5366004612179565b600090815260036020526040902054151590565b3480156103f557600080fd5b5061026a610404366004612588565b610c15565b34801561041557600080fd5b50610207611f4081565b34801561042b57600080fd5b506104aa61043a366004612179565b6009602052600090815260409020805460018201546002909201546001600160a01b03821692600160a01b830460ff90811693600160a81b810490911692600160b01b9091046001600160401b03169166ffffffffffffff811691600160381b9091046001600160801b03169087565b604080516001600160a01b0390981688529515156020880152931515948601949094526001600160401b03909116606085015266ffffffffffffff1660808401526001600160801b0390911660a083015260c082015260e001610211565b34801561051457600080fd5b5061026a610fa7565b34801561052957600080fd5b5061026a610538366004612179565b610fbb565b34801561054957600080fd5b506004546001600160a01b03166102f9565b34801561056757600080fd5b5061020760065481565b34801561057d57600080fd5b5061026a61034236600461223c565b34801561059857600080fd5b5061026a6105a736600461245f565b61114f565b3480156105b857600080fd5b5061026a6105c7366004612093565b6111e7565b3480156105d857600080fd5b5061023a6105e7366004612179565b60076020526000908152604090205460ff1681565b34801561060857600080fd5b50610207610617366004612179565b60009081526003602052604090205490565b34801561063557600080fd5b5061026a610644366004612093565b6114ad565b34801561065557600080fd5b506102076276a70081565b34801561066c57600080fd5b5061023a61067b3660046125e8565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205460ff1690565b3480156106b557600080fd5b5061026a61034236600461261b565b3480156106d057600080fd5b5061026a6106df36600461245f565b611688565b61026a6106f2366004612179565b611701565b60006001600160a01b0383166107675760405162461bcd60e51b815260206004820152602a60248201527f455243313135353a2061646472657373207a65726f206973206e6f742061207660448201526930b634b21037bbb732b960b11b60648201526084015b60405180910390fd5b506000818152602081815260408083206001600160a01b03861684529091529020545b92915050565b60006001600160e01b03198216636cdb3d1360e11b14806107c157506001600160e01b031982166303a24d0760e21b145b8061078a57506301ffc9a760e01b6001600160e01b031983161461078a565b6107e86118c1565b61082782828080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061191b92505050565b7fbd06d92759c326896ec0f7c3a981e801ae4644e020f89b2a198909b692df0ddd828260405161085892919061267f565b60405180910390a15050565b606060028054610873906126ae565b80601f016020809104026020016040519081016040528092919081815260200182805461089f906126ae565b80156108ec5780601f106108c1576101008083540402835291602001916108ec565b820191906000526020600020905b8154815290600101906020018083116108cf57829003601f168201915b50505050509050919050565b3360009081526008602052604090205460ff1661092857604051630b094f2760e31b815260040160405180910390fd5b66ffffffffffffff8216158061094557506001600160801b038116155b1561096357604051631f2a200560e01b815260040160405180910390fd5b6103e88266ffffffffffffff16111561098f5760405163552a554960e11b815260040160405180910390fd5b60006006600081546109a0906126fe565b91829055506000818152600960205260409081902080546001600160a01b0319163390811782556001820180546001600160801b038816600160381b81026001600160b81b031990921666ffffffffffffff8b1690811792909217909255935194955091939192917f9d7c1b2906659a849d82e8238d5f8ea4a5a716c8659d026a0debcf547a4d487190610a379087815260200190565b60405180910390a450505050565b610a4d6118c1565b6001600160a01b038216610a745760405163d92e233d60e01b815260040160405180910390fd5b6001600160a01b038216600081815260086020908152604091829020805460ff191685151590811790915591519182527fc3546ff396abb820783528d59cf4ea2ffef19c75056e6f56696701eb9e2c7a5a910160405180910390a25050565b604051630c720e5960e11b815260040160405180910390fd5b60608151835114610b515760405162461bcd60e51b815260206004820152602960248201527f455243313135353a206163636f756e747320616e6420696473206c656e677468604482015268040dad2e6dac2e8c6d60bb1b606482015260840161075e565b600083516001600160401b03811115610b6c57610b6c61226d565b604051908082528060200260200182016040528015610b95578160200160208202803683370190505b50905060005b8451811015610c0d57610be0858281518110610bb957610bb9612717565b6020026020010151858381518110610bd357610bd3612717565b60200260200101516106f7565b828281518110610bf257610bf2612717565b6020908102919091010152610c06816126fe565b9050610b9b565b509392505050565b600085815260096020526040902080546001600160a01b0316610c4b57604051635cb6cfdd60e01b815260040160405180910390fd5b610c5533876106f7565b600003610c7557604051633ec8ca4d60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b03161580610ca357508054600160b01b90046001600160401b031642105b15610cc15760405163201b9ddb60e11b815260040160405180910390fd5b600181015460009061271090611f4090610cf59066ffffffffffffff811690600160381b90046001600160801b031661272d565b6001600160801b0316610d089190612758565b610d12919061276f565b905080851115610d3557604051637825ae5b60e01b815260040160405180910390fd5b81600201548103610d5957604051634506832760e11b815260040160405180910390fd5b6040516bffffffffffffffffffffffff1933606090811b82166020840152603483018a9052605483018990526074830188905246609484015230901b1660b482015260009060c80160408051601f1981840301815291815281516020928301206000818152600790935291205490915060ff1615610dea57604051637d930c5160e01b815260040160405180910390fd5b6000610e43826040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c8101829052600090605c01604051602081830303815290604052805190602001209050919050565b90506000610e8987878080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250869392505061192b9050565b6005549091506001600160a01b03808316911614610eba576040516353c9973560e11b815260040160405180910390fd5b6000838152600760205260408120805460ff191660011790556002860180548a9290610ee7908490612791565b909155505060405160009033908a908381818185875af1925050503d8060008114610f2e576040519150601f19603f3d011682016040523d82523d6000602084013e610f33565b606091505b5050905080610f55576040516312171d8360e31b815260040160405180910390fd5b898b336001600160a01b03167f56253d287efacdb2c4cd76dd03624a4821c1ce721d1152e8f5f5718f6087c9bf8c604051610f9291815260200190565b60405180910390a45050505050505050505050565b610faf6118c1565b610fb96000611947565b565b600081815260096020526040902080546001600160a01b03163314610ff357604051631b32bab160e31b815260040160405180910390fd5b8054600160b01b90046001600160401b031660000361102557604051631123326560e31b815260040160405180910390fd5b8054600160a01b900460ff161561104f57604051636507689f60e01b815260040160405180910390fd5b805460ff60a01b1916600160a01b17815560018101546000903390612710906103e8906110979066ffffffffffffff8116906001600160801b03600160381b9091041661272d565b6001600160801b03166110aa9190612758565b6110b4919061276f565b604051600081818185875af1925050503d80600081146110f0576040519150601f19603f3d011682016040523d82523d6000602084013e6110f5565b606091505b5050905080611117576040516312171d8360e31b815260040160405180910390fd5b6040518381527fa8d363038fe6a30670da0501e8a8fc04534db6129e94dba897fdfe6276a05e8a9060200160405180910390a1505050565b6111576118c1565b6001600160a01b03811661117e5760405163d92e233d60e01b815260040160405180910390fd5b600554604080516001600160a01b03928316815291831660208301527feeb293e1f8f3a9db91ade748726387ed1352ca78f5430c5f06fe3d1e1ad50579910160405180910390a1600580546001600160a01b0319166001600160a01b0392909216919091179055565b6111ef6118c1565b6001600160a01b0382166112165760405163d92e233d60e01b815260040160405180910390fd5b600081815260096020526040902080546001600160a01b031661124c57604051635cb6cfdd60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b031660000361127e57604051631123326560e31b815260040160405180910390fd5b805442906112a0906276a70090600160b01b90046001600160401b0316612791565b11156112bf57604051631b8867c960e21b815260040160405180910390fd5b600181015460009061271090611f40906112f39066ffffffffffffff811690600160381b90046001600160801b031661272d565b6001600160801b03166113069190612758565b611310919061276f565b8254909150600090600160a01b900460ff16611388576001830154612710906103e8906113579066ffffffffffffff811690600160381b90046001600160801b031661272d565b6001600160801b031661136a9190612758565b611374919061276f565b835460ff60a01b1916600160a01b17845590505b600083600201548361139a91906127a4565b9050801580156113a8575081155b156113c657604051634506832760e11b815260040160405180910390fd5b80156113e657808460020160008282546113e09190612791565b90915550505b60006001600160a01b0387166113fc8484612791565b604051600081818185875af1925050503d8060008114611438576040519150601f19603f3d011682016040523d82523d6000602084013e61143d565b606091505b505090508061145f576040516312171d8360e31b815260040160405180910390fd5b8282886001600160a01b03167f6acc4904650e5fea98be9fcdba4d5d4dd5ea247b4805f307e2ae8f0f0c053f5a8960405161149c91815260200190565b60405180910390a450505050505050565b6114b56118c1565b6001600160a01b0382166114dc5760405163d92e233d60e01b815260040160405180910390fd5b600081815260096020526040902080546001600160a01b031661151257604051635cb6cfdd60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b031660000361154457604051631123326560e31b815260040160405180910390fd5b8054600160a81b900460ff161561156e57604051636507689f60e01b815260040160405180910390fd5b805460ff60a81b1916600160a81b17815560018101546000906001600160a01b03851690612710906103e8906115bf9066ffffffffffffff8116906001600160801b03600160381b9091041661272d565b6001600160801b03166115d29190612758565b6115dc919061276f565b604051600081818185875af1925050503d8060008114611618576040519150601f19603f3d011682016040523d82523d6000602084013e61161d565b606091505b505090508061163f576040516312171d8360e31b815260040160405180910390fd5b836001600160a01b03167fcbc4d588d41c6eb36eab1f36c5414cc5f64778fc599803abd57f0c6fe017ddec8460405161167a91815260200190565b60405180910390a250505050565b6116906118c1565b6001600160a01b0381166116f55760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161075e565b6116fe81611947565b50565b6005546001600160a01b0316330361172c576040516312dd36a360e11b815260040160405180910390fd5b600081815260096020526040902080546001600160a01b031661176257604051635cb6cfdd60e01b815260040160405180910390fd5b8054600160b01b90046001600160401b0316156117925760405163848084dd60e01b815260040160405180910390fd5b61179c33836106f7565b156117ba5760405163f367f5f160e01b815260040160405180910390fd5b6001810154600160381b90046001600160801b031634146117ee576040516315df163f60e31b815260040160405180910390fd5b600181015466ffffffffffffff166118128360009081526003602052604090205490565b61181d906001612791565b036118575761182f42620151806127b7565b81546001600160401b0391909116600160b01b0267ffffffffffffffff60b01b199091161781555b6118733383600160405180602001604052806000815250611999565b81337f2f10445408f98037db3b8cb9284971437981c6b22fcbc65520c84657e003eb496118ac8360009081526003602052604090205490565b60405190815260200160405180910390a35050565b6004546001600160a01b03163314610fb95760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161075e565b60026119278282612829565b5050565b600080600061193a8585611abc565b91509150610c0d81611b01565b600480546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6001600160a01b0384166119f95760405162461bcd60e51b815260206004820152602160248201527f455243313135353a206d696e7420746f20746865207a65726f206164647265736044820152607360f81b606482015260840161075e565b336000611a0585611c4b565b90506000611a1285611c4b565b9050611a2383600089858589611c96565b6000868152602081815260408083206001600160a01b038b16845290915281208054879290611a53908490612791565b909155505060408051878152602081018790526001600160a01b03808a1692600092918716917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a4611ab383600089898989611e17565b50505050505050565b6000808251604103611af25760208301516040840151606085015160001a611ae687828585611fb3565b94509450505050611afa565b506000905060025b9250929050565b6000816004811115611b1557611b156128e8565b03611b1d5750565b6001816004811115611b3157611b316128e8565b03611b7e5760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e61747572650000000000000000604482015260640161075e565b6002816004811115611b9257611b926128e8565b03611bdf5760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e67746800604482015260640161075e565b6003816004811115611bf357611bf36128e8565b036116fe5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b606482015260840161075e565b60408051600180825281830190925260609160009190602080830190803683370190505090508281600081518110611c8557611c85612717565b602090810291909101015292915050565b6001600160a01b038516611d1d5760005b8351811015611d1b57828181518110611cc257611cc2612717565b602002602001015160036000868481518110611ce057611ce0612717565b602002602001015181526020019081526020016000206000828254611d059190612791565b90915550611d149050816126fe565b9050611ca7565b505b6001600160a01b038416611e0f5760005b8351811015611ab3576000848281518110611d4b57611d4b612717565b602002602001015190506000848381518110611d6957611d69612717565b6020026020010151905060006003600084815260200190815260200160002054905081811015611dec5760405162461bcd60e51b815260206004820152602860248201527f455243313135353a206275726e20616d6f756e74206578636565647320746f74604482015267616c537570706c7960c01b606482015260840161075e565b60009283526003602052604090922091039055611e08816126fe565b9050611d2e565b505050505050565b6001600160a01b0384163b15611e0f5760405163f23a6e6160e01b81526001600160a01b0385169063f23a6e6190611e5b90899089908890889088906004016128fe565b6020604051808303816000875af1925050508015611e96575060408051601f3d908101601f19168201909252611e9391810190612943565b60015b611f4257611ea2612960565b806308c379a003611edb5750611eb661297c565b80611ec15750611edd565b8060405162461bcd60e51b815260040161075e91906121d8565b505b60405162461bcd60e51b815260206004820152603460248201527f455243313135353a207472616e7366657220746f206e6f6e2d455243313135356044820152732932b1b2b4bb32b91034b6b83632b6b2b73a32b960611b606482015260840161075e565b6001600160e01b0319811663f23a6e6160e01b14611ab35760405162461bcd60e51b815260206004820152602860248201527f455243313135353a204552433131353552656365697665722072656a656374656044820152676420746f6b656e7360c01b606482015260840161075e565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611fea575060009050600361206e565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa15801561203e573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166120675760006001925092505061206e565b9150600090505b94509492505050565b80356001600160a01b038116811461208e57600080fd5b919050565b600080604083850312156120a657600080fd5b6120af83612077565b946020939093013593505050565b6001600160e01b0319811681146116fe57600080fd5b6000602082840312156120e557600080fd5b81356120f0816120bd565b9392505050565b60008083601f84011261210957600080fd5b5081356001600160401b0381111561212057600080fd5b602083019150836020828501011115611afa57600080fd5b6000806020838503121561214b57600080fd5b82356001600160401b0381111561216157600080fd5b61216d858286016120f7565b90969095509350505050565b60006020828403121561218b57600080fd5b5035919050565b6000815180845260005b818110156121b85760208185018101518683018201520161219c565b506000602082860101526020601f19601f83011685010191505092915050565b6020815260006120f06020830184612192565b600080604083850312156121fe57600080fd5b823566ffffffffffffff8116811461221557600080fd5b915060208301356001600160801b038116811461223157600080fd5b809150509250929050565b6000806040838503121561224f57600080fd5b61225883612077565b91506020830135801515811461223157600080fd5b634e487b7160e01b600052604160045260246000fd5b601f8201601f191681016001600160401b03811182821017156122a8576122a861226d565b6040525050565b60006001600160401b038211156122c8576122c861226d565b5060051b60200190565b600082601f8301126122e357600080fd5b813560206122f0826122af565b6040516122fd8282612283565b83815260059390931b850182019282810191508684111561231d57600080fd5b8286015b848110156123385780358352918301918301612321565b509695505050505050565b600082601f83011261235457600080fd5b81356001600160401b0381111561236d5761236d61226d565b604051612384601f8301601f191660200182612283565b81815284602083860101111561239957600080fd5b816020850160208301376000918101602001919091529392505050565b600080600080600060a086880312156123ce57600080fd5b6123d786612077565b94506123e560208701612077565b935060408601356001600160401b038082111561240157600080fd5b61240d89838a016122d2565b9450606088013591508082111561242357600080fd5b61242f89838a016122d2565b9350608088013591508082111561244557600080fd5b5061245288828901612343565b9150509295509295909350565b60006020828403121561247157600080fd5b6120f082612077565b6000806040838503121561248d57600080fd5b82356001600160401b03808211156124a457600080fd5b818501915085601f8301126124b857600080fd5b813560206124c5826122af565b6040516124d28282612283565b83815260059390931b85018201928281019150898411156124f257600080fd5b948201945b838610156125175761250886612077565b825294820194908201906124f7565b9650508601359250508082111561252d57600080fd5b5061253a858286016122d2565b9150509250929050565b6020808252825182820181905260009190848201906040850190845b8181101561257c57835183529284019291840191600101612560565b50909695505050505050565b6000806000806000608086880312156125a057600080fd5b85359450602086013593506040860135925060608601356001600160401b038111156125cb57600080fd5b6125d7888289016120f7565b969995985093965092949392505050565b600080604083850312156125fb57600080fd5b61260483612077565b915061261260208401612077565b90509250929050565b600080600080600060a0868803121561263357600080fd5b61263c86612077565b945061264a60208701612077565b9350604086013592506060860135915060808601356001600160401b0381111561267357600080fd5b61245288828901612343565b60208152816020820152818360408301376000818301604090810191909152601f909201601f19160101919050565b600181811c908216806126c257607f821691505b6020821081036126e257634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b600060018201612710576127106126e8565b5060010190565b634e487b7160e01b600052603260045260246000fd5b6001600160801b03818116838216028082169190828114612750576127506126e8565b505092915050565b808202811582820484141761078a5761078a6126e8565b60008261278c57634e487b7160e01b600052601260045260246000fd5b500490565b8082018082111561078a5761078a6126e8565b8181038181111561078a5761078a6126e8565b6001600160401b038181168382160190808211156127d7576127d76126e8565b5092915050565b601f82111561282457600081815260208120601f850160051c810160208610156128055750805b601f850160051c820191505b81811015611e0f57828155600101612811565b505050565b81516001600160401b038111156128425761284261226d565b6128568161285084546126ae565b846127de565b602080601f83116001811461288b57600084156128735750858301515b600019600386901b1c1916600185901b178555611e0f565b600085815260208120601f198616915b828110156128ba5788860151825594840194600190910190840161289b565b50858210156128d85787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b600052602160045260246000fd5b6001600160a01b03868116825285166020820152604081018490526060810183905260a06080820181905260009061293890830184612192565b979650505050505050565b60006020828403121561295557600080fd5b81516120f0816120bd565b600060033d11156129795760046000803e5060005160e01c5b90565b600060443d101561298a5790565b6040516003193d81016004833e81513d6001600160401b0381602484011181841117156129b957505050505090565b82850191508151818111156129d15750505050505090565b843d87010160208285010111156129eb5750505050505090565b6129fa60208286010187612283565b50909594505050505056fea264697066735822122004833a06cd4aead9511d567f07af67b14d4699308548f3ee0952df511ece447564736f6c63430008110033

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000001ef5e3c23bb482b3f34e137c88e59d20083be836000000000000000000000000000000000000000000000000000000000000002f68747470733a2f2f7777772e706173737068726173652e6c6976652f6e6674732f506c6179506173734f472e6769660000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _uri (string): https://www.passphrase.live/nfts/PlayPassOG.gif
Arg [1] : _signer (address): 0x1ef5E3c23bB482B3f34e137c88E59D20083Be836

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000001ef5e3c23bb482b3f34e137c88e59d20083be836
Arg [2] : 000000000000000000000000000000000000000000000000000000000000002f
Arg [3] : 68747470733a2f2f7777772e706173737068726173652e6c6976652f6e667473
Arg [4] : 2f506c6179506173734f472e6769660000000000000000000000000000000000

64998:20149:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21249:230;;;;;;;;;;-1:-1:-1;21249:230:0;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;21249:230:0;;;;;;;;20272:310;;;;;;;;;;-1:-1:-1;20272:310:0;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;20272:310:0;1019:187:1;84428:164:0;;;;;;;;;;-1:-1:-1;84428:164:0;;;;;:::i;:::-;;:::i;:::-;;20993:105;;;;;;;;;;-1:-1:-1;20993:105:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;71957:854::-;;;;;;;;;;-1:-1:-1;71957:854:0;;;;;:::i;:::-;;:::i;71182:358::-;;;;;;;;;;-1:-1:-1;71182:358:0;;;;;:::i;:::-;;:::i;65916:21::-;;;;;;;;;;-1:-1:-1;65916:21:0;;;;-1:-1:-1;;;;;65916:21:0;;;;;;-1:-1:-1;;;;;3818:32:1;;;3800:51;;3788:2;3773:18;65916:21:0;3654:203:1;66237:55:0;;;;;;;;;;;;66288:4;66237:55;;84924:220;;;;;;;;;;-1:-1:-1;84924:220:0;;;;;:::i;:::-;;:::i;67155:45::-;;;;;;;;;;-1:-1:-1;67155:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;66537:54;;;;;;;;;;;;66586:5;66537:54;;21645:524;;;;;;;;;;-1:-1:-1;21645:524:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;37521:122::-;;;;;;;;;;-1:-1:-1;37521:122:0;;;;;:::i;:::-;37578:4;37399:16;;;:12;:16;;;;;;-1:-1:-1;;;37521:122:0;74789:2829;;;;;;;;;;-1:-1:-1;74789:2829:0;;;;;:::i;:::-;;:::i;66393:52::-;;;;;;;;;;;;66441:4;66393:52;;67280:43;;;;;;;;;;-1:-1:-1;67280:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;67280:43:0;;;-1:-1:-1;;;67280:43:0;;;;;;;-1:-1:-1;;;67280:43:0;;;;;;-1:-1:-1;;;67280:43:0;;;-1:-1:-1;;;;;67280:43:0;;;;;;-1:-1:-1;;;67280:43:0;;;-1:-1:-1;;;;;67280:43:0;;;;;;;;-1:-1:-1;;;;;9651:32:1;;;9633:51;;9727:14;;9720:22;9715:2;9700:18;;9693:50;9786:14;;9779:22;9759:18;;;9752:50;;;;-1:-1:-1;;;;;9838:31:1;;;9833:2;9818:18;;9811:59;9919:16;9907:29;9901:3;9886:19;;9879:58;-1:-1:-1;;;;;9974:47:1;;;9671:3;9953:19;;9946:76;10053:3;10038:19;;10031:35;9620:3;9605:19;67280:43:0;9334:738:1;64179:103:0;;;;;;;;;;;;;:::i;77996:1333::-;;;;;;;;;;-1:-1:-1;77996:1333:0;;;;;:::i;:::-;;:::i;63531:87::-;;;;;;;;;;-1:-1:-1;63604:6:0;;-1:-1:-1;;;;;63604:6:0;63531:87;;66043:32;;;;;;;;;;;;;;;;84600:111;;;;;;;;;;-1:-1:-1;84600:111:0;;;;;:::i;70625:285::-;;;;;;;;;;-1:-1:-1;70625:285:0;;;;;:::i;:::-;;:::i;81348:2738::-;;;;;;;;;;-1:-1:-1;81348:2738:0;;;;;:::i;:::-;;:::i;67027:47::-;;;;;;;;;;-1:-1:-1;67027:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;37310:113;;;;;;;;;;-1:-1:-1;37310:113:0;;;;;:::i;:::-;37372:7;37399:16;;;:12;:16;;;;;;;37310:113;79604:1360;;;;;;;;;;-1:-1:-1;79604:1360:0;;;;;:::i;:::-;;:::i;66748:46::-;;;;;;;;;;;;66787:7;66748:46;;22469:168;;;;;;;;;;-1:-1:-1;22469:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;22592:27:0;;;22568:4;22592:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;22469:168;84719:197;;;;;;;;;;-1:-1:-1;84719:197:0;;;;;:::i;64437:201::-;;;;;;;;;;-1:-1:-1;64437:201:0;;;;;:::i;:::-;;:::i;72950:1550::-;;;;;;:::i;:::-;;:::i;21249:230::-;21335:7;-1:-1:-1;;;;;21363:21:0;;21355:76;;;;-1:-1:-1;;;21355:76:0;;11340:2:1;21355:76:0;;;11322:21:1;11379:2;11359:18;;;11352:30;11418:34;11398:18;;;11391:62;-1:-1:-1;;;11469:18:1;;;11462:40;11519:19;;21355:76:0;;;;;;;;;-1:-1:-1;21449:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;21449:22:0;;;;;;;;;;21249:230;;;;;:::o;20272:310::-;20374:4;-1:-1:-1;;;;;;20411:41:0;;-1:-1:-1;;;20411:41:0;;:110;;-1:-1:-1;;;;;;;20469:52:0;;-1:-1:-1;;;20469:52:0;20411:110;:163;;;-1:-1:-1;;;;;;;;;;19305:40:0;;;20538:36;19196:157;84428:164;63417:13;:11;:13::i;:::-;84531:16:::1;84539:7;;84531:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;84531:7:0::1;::::0;-1:-1:-1;;;84531:16:0:i:1;:::-;84565:19;84576:7;;84565:19;;;;;;;:::i;:::-;;;;;;;;84428:164:::0;;:::o;20993:105::-;21053:13;21086:4;21079:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20993:105;;;:::o;71957:854::-;69643:10;69629:25;;;;:13;:25;;;;;;;;69624:82;;69678:16;;-1:-1:-1;;;69678:16:0;;;;;;;;;;;69624:82;72160:16:::1;::::0;::::1;::::0;;:35:::1;;-1:-1:-1::0;;;;;;72180:15:0;::::1;::::0;72160:35:::1;72156:87;;;72219:12;;-1:-1:-1::0;;;72219:12:0::1;;;;;;;;;;;72156:87;66927:4;72259:11;:25;;;72255:87;;;72308:22;;-1:-1:-1::0;;;72308:22:0::1;;;;;;;;;;;72255:87;72461:15;72481:17;;72479:19;;;;;:::i;:::-;::::0;;;;-1:-1:-1;72566:18:0::1;72587:20:::0;;;:11:::1;:20;::::0;;;;;;72618:30;;-1:-1:-1;;;;;;72618:30:0::1;72638:10;72618:30:::0;;::::1;::::0;;;72659:16;::::1;:30:::0;;-1:-1:-1;;;;;72700:28:0;::::1;-1:-1:-1::0;;;72700:28:0;::::1;-1:-1:-1::0;;;;;;72700:28:0;;;72659:30:::1;::::0;::::1;72700:28:::0;;;;;;::::1;::::0;;;72746:57;;72479:19;;-1:-1:-1;72587:20:0;;72700:28;;72659:30;72746:57:::1;::::0;::::1;::::0;72479:19;597:25:1;;585:2;570:18;;451:177;72746:57:0::1;;;;;;;;72067:744;;71957:854:::0;;:::o;71182:358::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;71304:22:0;::::1;71300:75;;71350:13;;-1:-1:-1::0;;;71350:13:0::1;;;;;;;;;;;71300:75;-1:-1:-1::0;;;;;71441:23:0;::::1;;::::0;;;:13:::1;:23;::::0;;;;;;;;:33;;-1:-1:-1;;71441:33:0::1;::::0;::::1;;::::0;;::::1;::::0;;;71492:40;;1159:41:1;;;71492:40:0::1;::::0;1132:18:1;71492:40:0::1;;;;;;;71182:358:::0;;:::o;84924:220::-;85117:19;;-1:-1:-1;;;85117:19:0;;;;;;;;;;;21645:524;21801:16;21862:3;:10;21843:8;:15;:29;21835:83;;;;-1:-1:-1;;;21835:83:0;;12803:2:1;21835:83:0;;;12785:21:1;12842:2;12822:18;;;12815:30;12881:34;12861:18;;;12854:62;-1:-1:-1;;;12932:18:1;;;12925:39;12981:19;;21835:83:0;12601:405:1;21835:83:0;21931:30;21978:8;:15;-1:-1:-1;;;;;21964:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21964:30:0;;21931:63;;22012:9;22007:122;22031:8;:15;22027:1;:19;22007:122;;;22087:30;22097:8;22106:1;22097:11;;;;;;;;:::i;:::-;;;;;;;22110:3;22114:1;22110:6;;;;;;;;:::i;:::-;;;;;;;22087:9;:30::i;:::-;22068:13;22082:1;22068:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;22048:3;;;:::i;:::-;;;22007:122;;;-1:-1:-1;22148:13:0;21645:524;-1:-1:-1;;;21645:524:0:o;74789:2829::-;75069:18;75090:20;;;:11;:20;;;;;75169:17;;-1:-1:-1;;;;;75169:17:0;75165:90;;75224:19;;-1:-1:-1;;;75224:19:0;;;;;;;;;;;75165:90;75350:30;75360:10;75372:7;75350:9;:30::i;:::-;75384:1;75350:35;75346:95;;75409:20;;-1:-1:-1;;;75409:20:0;;;;;;;;;;;75346:95;75546:19;;-1:-1:-1;;;75546:19:0;;-1:-1:-1;;;;;75546:19:0;:24;;:65;;-1:-1:-1;75592:19:0;;-1:-1:-1;;;75592:19:0;;-1:-1:-1;;;;;75592:19:0;75574:15;:37;75546:65;75542:124;;;75635:19;;-1:-1:-1;;;75635:19:0;;;;;;;;;;;75542:124;75843:16;;;;75790:30;;66586:5;;66441:4;;75825:34;;75843:16;;;;-1:-1:-1;;;75825:15:0;;-1:-1:-1;;;;;75825:15:0;:34;:::i;:::-;-1:-1:-1;;;;;75824:73:0;;;;;:::i;:::-;75823:100;;;;:::i;:::-;75790:133;;76050:22;76034:13;:38;76030:85;;;76094:21;;-1:-1:-1;;;76094:21:0;;;;;;;;;;;76030:85;76234:5;:25;;;76208:22;:51;76204:117;;76283:26;;-1:-1:-1;;;76283:26:0;;;;;;;;;;;76204:117;76423:206;;-1:-1:-1;;76458:10:0;14156:2:1;14152:15;;;14148:24;;76423:206:0;;;14136:37:1;14189:12;;;14182:28;;;14226:12;;;14219:28;;;14263:12;;;14256:28;;;76569:13:0;14300::1;;;14293:29;76609:4:0;14357:15:1;;14353:24;14338:13;;;14331:47;76377:19:0;;14394:13:1;;76423:206:0;;;-1:-1:-1;;76423:206:0;;;;;;;;;76399:241;;76423:206;76399:241;;;;76729:28;;;;:15;:28;;;;;;76399:241;;-1:-1:-1;76729:28:0;;76725:92;;;76781:24;;-1:-1:-1;;;76781:24:0;;;;;;;;;;;76725:92;76863:25;76891:36;:11;61259:58;;18599:66:1;61259:58:0;;;18587:79:1;18682:12;;;18675:28;;;61126:7:0;;18719:12:1;;61259:58:0;;;;;;;;;;;;61249:69;;;;;;61242:76;;61057:269;;;;76891:36;76863:64;;76994:24;77021:37;77047:10;;77021:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77021:17:0;;:37;-1:-1:-1;;77021:25:0;:37;-1:-1:-1;77021:37:0:i;:::-;77187:6;;76994:64;;-1:-1:-1;;;;;;77167:26:0;;;77187:6;;77167:26;77163:79;;77217:13;;-1:-1:-1;;;77217:13:0;;;;;;;;;;;77163:79;77254:28;;;;:15;:28;;;;;:35;;-1:-1:-1;;77254:35:0;77285:4;77254:35;;;77302:25;;;:42;;77331:13;;77254:28;77302:42;;77331:13;;77302:42;:::i;:::-;;;;-1:-1:-1;;77418:41:0;;77400:12;;77418:10;;77441:13;;77400:12;77418:41;77400:12;77418:41;77441:13;77418:10;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77399:60;;;77477:7;77472:64;;77508:16;;-1:-1:-1;;;77508:16:0;;;;;;;;;;;77472:64;77589:5;77580:7;77568:10;-1:-1:-1;;;;;77553:57:0;;77596:13;77553:57;;;;597:25:1;;585:2;570:18;;451:177;77553:57:0;;;;;;;;74944:2674;;;;;;74789:2829;;;;;:::o;64179:103::-;63417:13;:11;:13::i;:::-;64244:30:::1;64271:1;64244:18;:30::i;:::-;64179:103::o:0;77996:1333::-;78179:18;78200:20;;;:11;:20;;;;;78337:17;;-1:-1:-1;;;;;78337:17:0;78323:10;:31;78319:87;;78378:16;;-1:-1:-1;;;78378:16:0;;;;;;;;;;;78319:87;78529:19;;-1:-1:-1;;;78529:19:0;;-1:-1:-1;;;;;78529:19:0;;:24;78525:85;;78577:21;;-1:-1:-1;;;78577:21:0;;;;;;;;;;;78525:85;78714:30;;-1:-1:-1;;;78714:30:0;;;;78710:88;;;78768:18;;-1:-1:-1;;;78768:18:0;;;;;;;;;;;78710:88;78810:37;;-1:-1:-1;;;;78810:37:0;-1:-1:-1;;;78810:37:0;;;78843:4;79092:16;;;78810:30;;79035:10;;66586:5;;66288:4;;79074:34;;79092:16;;;;-1:-1:-1;;;;;;;;79074:15:0;;;;:34;:::i;:::-;-1:-1:-1;;;;;79073:80:0;;;;;:::i;:::-;79072:107;;;;:::i;:::-;79035:159;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79016:178;;;79212:7;79207:64;;79243:16;;-1:-1:-1;;;79243:16:0;;;;;;;;;;;79207:64;79288:33;;597:25:1;;;79288:33:0;;585:2:1;570:18;79288:33:0;;;;;;;78054:1275;;77996:1333;:::o;70625:285::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;70701:24:0;::::1;70697:77;;70749:13;;-1:-1:-1::0;;;70749:13:0::1;;;;;;;;;;;70697:77;70805:6;::::0;70791:33:::1;::::0;;-1:-1:-1;;;;;70805:6:0;;::::1;14970:34:1::0;;15040:15;;;15035:2;15020:18;;15013:43;70791:33:0::1;::::0;14905:18:1;70791:33:0::1;;;;;;;70883:6;:19:::0;;-1:-1:-1;;;;;;70883:19:0::1;-1:-1:-1::0;;;;;70883:19:0;;;::::1;::::0;;;::::1;::::0;;70625:285::o;81348:2738::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;81478:24:0;::::1;81474:77;;81526:13;;-1:-1:-1::0;;;81526:13:0::1;;;;;;;;;;;81474:77;81677:18;81698:20:::0;;;:11:::1;:20;::::0;;;;81777:17;;-1:-1:-1;;;;;81777:17:0::1;81773:90;;81832:19;;-1:-1:-1::0;;;81832:19:0::1;;;;;;;;;;;81773:90;81977:19:::0;;-1:-1:-1;;;81977:19:0;::::1;-1:-1:-1::0;;;;;81977:19:0::1;;:24:::0;81973:85:::1;;82025:21;;-1:-1:-1::0;;;82025:21:0::1;;;;;;;;;;;81973:85;82216:19:::0;;82253:15:::1;::::0;82216:34:::1;::::0;66787:7:::1;::::0;-1:-1:-1;;;82216:19:0;::::1;-1:-1:-1::0;;;;;82216:19:0::1;:34;:::i;:::-;:52;82212:120;;;82292:28;;-1:-1:-1::0;;;82292:28:0::1;;;;;;;;;;;82212:120;82509:16;::::0;::::1;::::0;82456:30:::1;::::0;66586:5:::1;::::0;66441:4:::1;::::0;82491:34:::1;::::0;82509:16:::1;::::0;::::1;::::0;-1:-1:-1;;;82491:15:0;::::1;-1:-1:-1::0;;;;;82491:15:0::1;:34;:::i;:::-;-1:-1:-1::0;;;;;82490:73:0::1;;;;;:::i;:::-;82489:100;;;;:::i;:::-;82731:30:::0;;82456:133;;-1:-1:-1;82602:28:0::1;::::0;-1:-1:-1;;;82731:30:0;::::1;;;82726:365;;82917:16;::::0;::::1;::::0;66586:5:::1;::::0;66288:4:::1;::::0;82899:34:::1;::::0;82917:16:::1;::::0;::::1;::::0;-1:-1:-1;;;82899:15:0;::::1;-1:-1:-1::0;;;;;82899:15:0::1;:34;:::i;:::-;-1:-1:-1::0;;;;;82898:84:0::1;;;;;:::i;:::-;82897:128;;;;:::i;:::-;83042:37:::0;;-1:-1:-1;;;;83042:37:0::1;-1:-1:-1::0;;;83042:37:0::1;::::0;;82857:168;-1:-1:-1;82726:365:0::1;83103:29;83173:5;:25;;;83135:22;:63;;;;:::i;:::-;83103:95:::0;-1:-1:-1;83303:26:0;;:55;::::1;;;-1:-1:-1::0;83333:25:0;;83303:55:::1;83299:121;;;83382:26;;-1:-1:-1::0;;;83382:26:0::1;;;;;;;;;;;83299:121;83508:26:::0;;83504:109:::1;;83580:21;83551:5;:25;;;:50;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;83504:109:0::1;83716:12;-1:-1:-1::0;;;;;83734:15:0;::::1;83771:44;83795:20:::0;83771:21;:44:::1;:::i;:::-;83734:96;::::0;::::1;::::0;;;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83715:115;;;83848:7;83843:64;;83879:16;;-1:-1:-1::0;;;83879:16:0::1;;;;;;;;;;;83843:64;84047:20;84011:21;83986:10;-1:-1:-1::0;;;;;83924:154:0::1;;83964:7;83924:154;;;;597:25:1::0;;585:2;570:18;;451:177;83924:154:0::1;;;;;;;;81463:2623;;;;;81348:2738:::0;;:::o;79604:1360::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;79733:24:0;::::1;79729:77;;79781:13;;-1:-1:-1::0;;;79781:13:0::1;;;;;;;;;;;79729:77;79932:18;79953:20:::0;;;:11:::1;:20;::::0;;;;80032:17;;-1:-1:-1;;;;;80032:17:0::1;80028:90;;80087:19;;-1:-1:-1::0;;;80087:19:0::1;;;;;;;;;;;80028:90;80235:19:::0;;-1:-1:-1;;;80235:19:0;::::1;-1:-1:-1::0;;;;;80235:19:0::1;;:24:::0;80231:85:::1;;80283:21;;-1:-1:-1::0;;;80283:21:0::1;;;;;;;;;;;80231:85;80414:31:::0;;-1:-1:-1;;;80414:31:0;::::1;;;80410:89;;;80469:18;;-1:-1:-1::0;;;80469:18:0::1;;;;;;;;;;;80410:89;80511:38:::0;;-1:-1:-1;;;;80511:38:0::1;-1:-1:-1::0;;;80511:38:0::1;::::0;;80545:4:::1;80714:16:::0;::::1;::::0;80511:31:::1;::::0;-1:-1:-1;;;;;80657:15:0;::::1;::::0;66586:5:::1;::::0;66288:4:::1;::::0;80696:34:::1;::::0;80714:16:::1;::::0;::::1;::::0;-1:-1:-1;;;;;;;;80696:15:0;;::::1;;:34;:::i;:::-;-1:-1:-1::0;;;;;80695:80:0::1;;;;;:::i;:::-;80694:107;;;;:::i;:::-;80657:159;::::0;::::1;::::0;;;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80638:178;;;80834:7;80829:64;;80865:16;;-1:-1:-1::0;;;80865:16:0::1;;;;;;;;;;;80829:64;80936:10;-1:-1:-1::0;;;;;80910:46:0::1;;80948:7;80910:46;;;;597:25:1::0;;585:2;570:18;;451:177;80910:46:0::1;;;;;;;;79718:1246;;79604:1360:::0;;:::o;64437:201::-;63417:13;:11;:13::i;:::-;-1:-1:-1;;;;;64526:22:0;::::1;64518:73;;;::::0;-1:-1:-1;;;64518:73:0;;15402:2:1;64518:73:0::1;::::0;::::1;15384:21:1::0;15441:2;15421:18;;;15414:30;15480:34;15460:18;;;15453:62;-1:-1:-1;;;15531:18:1;;;15524:36;15577:19;;64518:73:0::1;15200:402:1::0;64518:73:0::1;64602:28;64621:8;64602:18;:28::i;:::-;64437:201:::0;:::o;72950:1550::-;73092:6;;-1:-1:-1;;;;;73092:6:0;73078:10;:20;73074:79;;73122:19;;-1:-1:-1;;;73122:19:0;;;;;;;;;;;73074:79;73279:17;73299:20;;;:11;:20;;;;;73406:16;;-1:-1:-1;;;;;73406:16:0;73402:89;;73460:19;;-1:-1:-1;;;73460:19:0;;;;;;;;;;;73402:89;73565:18;;-1:-1:-1;;;73565:18:0;;-1:-1:-1;;;;;73565:18:0;:23;73561:74;;73612:11;;-1:-1:-1;;;73612:11:0;;;;;;;;;;;73561:74;73728:30;73738:10;73750:7;73728:9;:30::i;:::-;:35;73724:90;;73787:15;;-1:-1:-1;;;73787:15:0;;;;;;;;;;;73724:90;73911:14;;;;-1:-1:-1;;;73911:14:0;;-1:-1:-1;;;;;73911:14:0;73898:9;:27;73894:81;;73949:14;;-1:-1:-1;;;73949:14:0;;;;;;;;;;;73894:81;74084:15;;;;;;74056:20;74068:7;37372;37399:16;;;:12;:16;;;;;;;37310:113;74056:20;:24;;74079:1;74056:24;:::i;:::-;:43;74052:131;;74137:34;74144:15;74163:8;74137:34;:::i;:::-;74116:55;;-1:-1:-1;;;;;74116:55:0;;;;-1:-1:-1;;;74116:55:0;-1:-1:-1;;;;74116:55:0;;;;;;74052:131;74315:33;74321:10;74333:7;74342:1;74315:33;;;;;;;;;;;;:5;:33::i;:::-;74462:7;74450:10;74439:53;74471:20;74462:7;37372;37399:16;;;:12;:16;;;;;;;37310:113;74471:20;74439:53;;597:25:1;;;585:2;570:18;74439:53:0;;;;;;;73001:1499;72950:1550;:::o;63696:132::-;63604:6;;-1:-1:-1;;;;;63604:6:0;18285:10;63760:23;63752:68;;;;-1:-1:-1;;;63752:68:0;;15994:2:1;63752:68:0;;;15976:21:1;;;16013:18;;;16006:30;16072:34;16052:18;;;16045:62;16124:18;;63752:68:0;15792:356:1;27416:88:0;27483:4;:13;27490:6;27483:4;:13;:::i;:::-;;27416:88;:::o;57367:231::-;57445:7;57466:17;57485:18;57507:27;57518:4;57524:9;57507:10;:27::i;:::-;57465:69;;;;57545:18;57557:5;57545:11;:18::i;64798:191::-;64891:6;;;-1:-1:-1;;;;;64908:17:0;;;-1:-1:-1;;;;;;64908:17:0;;;;;;;64941:40;;64891:6;;;64908:17;64891:6;;64941:40;;64872:16;;64941:40;64861:128;64798:191;:::o;27890:729::-;-1:-1:-1;;;;;28043:16:0;;28035:62;;;;-1:-1:-1;;;28035:62:0;;18944:2:1;28035:62:0;;;18926:21:1;18983:2;18963:18;;;18956:30;19022:34;19002:18;;;18995:62;-1:-1:-1;;;19073:18:1;;;19066:31;19114:19;;28035:62:0;18742:397:1;28035:62:0;18285:10;28110:16;28175:21;28193:2;28175:17;:21::i;:::-;28152:44;;28207:24;28234:25;28252:6;28234:17;:25::i;:::-;28207:52;;28272:66;28293:8;28311:1;28315:2;28319:3;28324:7;28333:4;28272:20;:66::i;:::-;28351:9;:13;;;;;;;;;;;-1:-1:-1;;;;;28351:17:0;;;;;;;;;:27;;28372:6;;28351:9;:27;;28372:6;;28351:27;:::i;:::-;;;;-1:-1:-1;;28394:52:0;;;19318:25:1;;;19374:2;19359:18;;19352:34;;;-1:-1:-1;;;;;28394:52:0;;;;28427:1;;28394:52;;;;;;19291:18:1;28394:52:0;;;;;;;28537:74;28568:8;28586:1;28590:2;28594;28598:6;28606:4;28537:30;:74::i;:::-;28024:595;;;27890:729;;;;:::o;55818:747::-;55899:7;55908:12;55937:9;:16;55957:2;55937:22;55933:625;;56281:4;56266:20;;56260:27;56331:4;56316:20;;56310:27;56389:4;56374:20;;56368:27;55976:9;56360:36;56432:25;56443:4;56360:36;56260:27;56310;56432:10;:25::i;:::-;56425:32;;;;;;;;;55933:625;-1:-1:-1;56506:1:0;;-1:-1:-1;56510:35:0;55933:625;55818:747;;;;;:::o;54211:521::-;54289:20;54280:5;:29;;;;;;;;:::i;:::-;;54276:449;;54211:521;:::o;54276:449::-;54387:29;54378:5;:38;;;;;;;;:::i;:::-;;54374:351;;54433:34;;-1:-1:-1;;;54433:34:0;;19731:2:1;54433:34:0;;;19713:21:1;19770:2;19750:18;;;19743:30;19809:26;19789:18;;;19782:54;19853:18;;54433:34:0;19529:348:1;54374:351:0;54498:35;54489:5;:44;;;;;;;;:::i;:::-;;54485:240;;54550:41;;-1:-1:-1;;;54550:41:0;;20084:2:1;54550:41:0;;;20066:21:1;20123:2;20103:18;;;20096:30;20162:33;20142:18;;;20135:61;20213:18;;54550:41:0;19882:355:1;54485:240:0;54622:30;54613:5;:39;;;;;;;;:::i;:::-;;54609:116;;54669:44;;-1:-1:-1;;;54669:44:0;;20444:2:1;54669:44:0;;;20426:21:1;20483:2;20463:18;;;20456:30;20522:34;20502:18;;;20495:62;-1:-1:-1;;;20573:18:1;;;20566:32;20615:19;;54669:44:0;20242:398:1;36569:198:0;36689:16;;;36703:1;36689:16;;;;;;;;;36635;;36664:22;;36689:16;;;;;;;;;;;;-1:-1:-1;36689:16:0;36664:41;;36727:7;36716:5;36722:1;36716:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;36754:5;36569:198;-1:-1:-1;;36569:198:0:o;37718:931::-;-1:-1:-1;;;;;38040:18:0;;38036:160;;38080:9;38075:110;38099:3;:10;38095:1;:14;38075:110;;;38159:7;38167:1;38159:10;;;;;;;;:::i;:::-;;;;;;;38135:12;:20;38148:3;38152:1;38148:6;;;;;;;;:::i;:::-;;;;;;;38135:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;38111:3:0;;-1:-1:-1;38111:3:0;;:::i;:::-;;;38075:110;;;;38036:160;-1:-1:-1;;;;;38212:16:0;;38208:434;;38250:9;38245:386;38269:3;:10;38265:1;:14;38245:386;;;38305:10;38318:3;38322:1;38318:6;;;;;;;;:::i;:::-;;;;;;;38305:19;;38343:14;38360:7;38368:1;38360:10;;;;;;;;:::i;:::-;;;;;;;38343:27;;38389:14;38406:12;:16;38419:2;38406:16;;;;;;;;;;;;38389:33;;38459:6;38449;:16;;38441:69;;;;-1:-1:-1;;;38441:69:0;;20847:2:1;38441:69:0;;;20829:21:1;20886:2;20866:18;;;20859:30;20925:34;20905:18;;;20898:62;-1:-1:-1;;;20976:18:1;;;20969:38;21024:19;;38441:69:0;20645:404:1;38441:69:0;38562:16;;;;:12;:16;;;;;;38581:15;;38562:34;;38281:3;;;:::i;:::-;;;38245:386;;38208:434;37718:931;;;;;;:::o;34996:744::-;-1:-1:-1;;;;;35211:13:0;;9703:19;:23;35207:526;;35247:72;;-1:-1:-1;;;35247:72:0;;-1:-1:-1;;;;;35247:38:0;;;;;:72;;35286:8;;35296:4;;35302:2;;35306:6;;35314:4;;35247:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35247:72:0;;;;;;;;-1:-1:-1;;35247:72:0;;;;;;;;;;;;:::i;:::-;;;35243:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;35595:6;35588:14;;-1:-1:-1;;;35588:14:0;;;;;;;;:::i;35243:479::-;;;35644:62;;-1:-1:-1;;;35644:62:0;;22936:2:1;35644:62:0;;;22918:21:1;22975:2;22955:18;;;22948:30;23014:34;22994:18;;;22987:62;-1:-1:-1;;;23065:18:1;;;23058:50;23125:19;;35644:62:0;22734:416:1;35243:479:0;-1:-1:-1;;;;;;35369:55:0;;-1:-1:-1;;;35369:55:0;35365:154;;35449:50;;-1:-1:-1;;;35449:50:0;;23357:2:1;35449:50:0;;;23339:21:1;23396:2;23376:18;;;23369:30;23435:34;23415:18;;;23408:62;-1:-1:-1;;;23486:18:1;;;23479:38;23534:19;;35449:50:0;23155:404:1;58819:1520:0;58950:7;;59884:66;59871:79;;59867:163;;;-1:-1:-1;59983:1:0;;-1:-1:-1;59987:30:0;59967:51;;59867:163;60144:24;;;60127:14;60144:24;;;;;;;;;23791:25:1;;;23864:4;23852:17;;23832:18;;;23825:45;;;;23886:18;;;23879:34;;;23929:18;;;23922:34;;;60144:24:0;;23763:19:1;;60144:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;60144:24:0;;-1:-1:-1;;60144:24:0;;;-1:-1:-1;;;;;;;60183:20:0;;60179:103;;60236:1;60240:29;60220:50;;;;;;;60179:103;60302:6;-1:-1:-1;60310:20:0;;-1:-1:-1;58819:1520:0;;;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;633:131::-;-1:-1:-1;;;;;;707:32:1;;697:43;;687:71;;754:1;751;744:12;769:245;827:6;880:2;868:9;859:7;855:23;851:32;848:52;;;896:1;893;886:12;848:52;935:9;922:23;954:30;978:5;954:30;:::i;:::-;1003:5;769:245;-1:-1:-1;;;769:245:1:o;1211:348::-;1263:8;1273:6;1327:3;1320:4;1312:6;1308:17;1304:27;1294:55;;1345:1;1342;1335:12;1294:55;-1:-1:-1;1368:20:1;;-1:-1:-1;;;;;1400:30:1;;1397:50;;;1443:1;1440;1433:12;1397:50;1480:4;1472:6;1468:17;1456:29;;1532:3;1525:4;1516:6;1508;1504:19;1500:30;1497:39;1494:59;;;1549:1;1546;1539:12;1564:411;1635:6;1643;1696:2;1684:9;1675:7;1671:23;1667:32;1664:52;;;1712:1;1709;1702:12;1664:52;1752:9;1739:23;-1:-1:-1;;;;;1777:6:1;1774:30;1771:50;;;1817:1;1814;1807:12;1771:50;1856:59;1907:7;1898:6;1887:9;1883:22;1856:59;:::i;:::-;1934:8;;1830:85;;-1:-1:-1;1564:411:1;-1:-1:-1;;;;1564:411:1:o;1980:180::-;2039:6;2092:2;2080:9;2071:7;2067:23;2063:32;2060:52;;;2108:1;2105;2098:12;2060:52;-1:-1:-1;2131:23:1;;1980:180;-1:-1:-1;1980:180:1:o;2165:423::-;2207:3;2245:5;2239:12;2272:6;2267:3;2260:19;2297:1;2307:162;2321:6;2318:1;2315:13;2307:162;;;2383:4;2439:13;;;2435:22;;2429:29;2411:11;;;2407:20;;2400:59;2336:12;2307:162;;;2311:3;2514:1;2507:4;2498:6;2493:3;2489:16;2485:27;2478:38;2577:4;2570:2;2566:7;2561:2;2553:6;2549:15;2545:29;2540:3;2536:39;2532:50;2525:57;;;2165:423;;;;:::o;2593:220::-;2742:2;2731:9;2724:21;2705:4;2762:45;2803:2;2792:9;2788:18;2780:6;2762:45;:::i;2818:479::-;2885:6;2893;2946:2;2934:9;2925:7;2921:23;2917:32;2914:52;;;2962:1;2959;2952:12;2914:52;3001:9;2988:23;3051:16;3044:5;3040:28;3033:5;3030:39;3020:67;;3083:1;3080;3073:12;3020:67;3106:5;-1:-1:-1;3163:2:1;3148:18;;3135:32;-1:-1:-1;;;;;3198:48:1;;3186:61;;3176:89;;3261:1;3258;3251:12;3176:89;3284:7;3274:17;;;2818:479;;;;;:::o;3302:347::-;3367:6;3375;3428:2;3416:9;3407:7;3403:23;3399:32;3396:52;;;3444:1;3441;3434:12;3396:52;3467:29;3486:9;3467:29;:::i;:::-;3457:39;;3546:2;3535:9;3531:18;3518:32;3593:5;3586:13;3579:21;3572:5;3569:32;3559:60;;3615:1;3612;3605:12;3862:127;3923:10;3918:3;3914:20;3911:1;3904:31;3954:4;3951:1;3944:15;3978:4;3975:1;3968:15;3994:249;4104:2;4085:13;;-1:-1:-1;;4081:27:1;4069:40;;-1:-1:-1;;;;;4124:34:1;;4160:22;;;4121:62;4118:88;;;4186:18;;:::i;:::-;4222:2;4215:22;-1:-1:-1;;3994:249:1:o;4248:183::-;4308:4;-1:-1:-1;;;;;4333:6:1;4330:30;4327:56;;;4363:18;;:::i;:::-;-1:-1:-1;4408:1:1;4404:14;4420:4;4400:25;;4248:183::o;4436:724::-;4490:5;4543:3;4536:4;4528:6;4524:17;4520:27;4510:55;;4561:1;4558;4551:12;4510:55;4597:6;4584:20;4623:4;4646:43;4686:2;4646:43;:::i;:::-;4718:2;4712:9;4730:31;4758:2;4750:6;4730:31;:::i;:::-;4796:18;;;4888:1;4884:10;;;;4872:23;;4868:32;;;4830:15;;;;-1:-1:-1;4912:15:1;;;4909:35;;;4940:1;4937;4930:12;4909:35;4976:2;4968:6;4964:15;4988:142;5004:6;4999:3;4996:15;4988:142;;;5070:17;;5058:30;;5108:12;;;;5021;;4988:142;;;-1:-1:-1;5148:6:1;4436:724;-1:-1:-1;;;;;;4436:724:1:o;5165:555::-;5207:5;5260:3;5253:4;5245:6;5241:17;5237:27;5227:55;;5278:1;5275;5268:12;5227:55;5314:6;5301:20;-1:-1:-1;;;;;5336:2:1;5333:26;5330:52;;;5362:18;;:::i;:::-;5411:2;5405:9;5423:67;5478:2;5459:13;;-1:-1:-1;;5455:27:1;5484:4;5451:38;5405:9;5423:67;:::i;:::-;5514:2;5506:6;5499:18;5560:3;5553:4;5548:2;5540:6;5536:15;5532:26;5529:35;5526:55;;;5577:1;5574;5567:12;5526:55;5641:2;5634:4;5626:6;5622:17;5615:4;5607:6;5603:17;5590:54;5688:1;5664:15;;;5681:4;5660:26;5653:37;;;;5668:6;5165:555;-1:-1:-1;;;5165:555:1:o;5725:943::-;5879:6;5887;5895;5903;5911;5964:3;5952:9;5943:7;5939:23;5935:33;5932:53;;;5981:1;5978;5971:12;5932:53;6004:29;6023:9;6004:29;:::i;:::-;5994:39;;6052:38;6086:2;6075:9;6071:18;6052:38;:::i;:::-;6042:48;;6141:2;6130:9;6126:18;6113:32;-1:-1:-1;;;;;6205:2:1;6197:6;6194:14;6191:34;;;6221:1;6218;6211:12;6191:34;6244:61;6297:7;6288:6;6277:9;6273:22;6244:61;:::i;:::-;6234:71;;6358:2;6347:9;6343:18;6330:32;6314:48;;6387:2;6377:8;6374:16;6371:36;;;6403:1;6400;6393:12;6371:36;6426:63;6481:7;6470:8;6459:9;6455:24;6426:63;:::i;:::-;6416:73;;6542:3;6531:9;6527:19;6514:33;6498:49;;6572:2;6562:8;6559:16;6556:36;;;6588:1;6585;6578:12;6556:36;;6611:51;6654:7;6643:8;6632:9;6628:24;6611:51;:::i;:::-;6601:61;;;5725:943;;;;;;;;:::o;6673:186::-;6732:6;6785:2;6773:9;6764:7;6760:23;6756:32;6753:52;;;6801:1;6798;6791:12;6753:52;6824:29;6843:9;6824:29;:::i;6864:1208::-;6982:6;6990;7043:2;7031:9;7022:7;7018:23;7014:32;7011:52;;;7059:1;7056;7049:12;7011:52;7099:9;7086:23;-1:-1:-1;;;;;7169:2:1;7161:6;7158:14;7155:34;;;7185:1;7182;7175:12;7155:34;7223:6;7212:9;7208:22;7198:32;;7268:7;7261:4;7257:2;7253:13;7249:27;7239:55;;7290:1;7287;7280:12;7239:55;7326:2;7313:16;7348:4;7371:43;7411:2;7371:43;:::i;:::-;7443:2;7437:9;7455:31;7483:2;7475:6;7455:31;:::i;:::-;7521:18;;;7609:1;7605:10;;;;7597:19;;7593:28;;;7555:15;;;;-1:-1:-1;7633:19:1;;;7630:39;;;7665:1;7662;7655:12;7630:39;7689:11;;;;7709:148;7725:6;7720:3;7717:15;7709:148;;;7791:23;7810:3;7791:23;:::i;:::-;7779:36;;7742:12;;;;7835;;;;7709:148;;;7876:6;-1:-1:-1;;7920:18:1;;7907:32;;-1:-1:-1;;7951:16:1;;;7948:36;;;7980:1;7977;7970:12;7948:36;;8003:63;8058:7;8047:8;8036:9;8032:24;8003:63;:::i;:::-;7993:73;;;6864:1208;;;;;:::o;8077:632::-;8248:2;8300:21;;;8370:13;;8273:18;;;8392:22;;;8219:4;;8248:2;8471:15;;;;8445:2;8430:18;;;8219:4;8514:169;8528:6;8525:1;8522:13;8514:169;;;8589:13;;8577:26;;8658:15;;;;8623:12;;;;8550:1;8543:9;8514:169;;;-1:-1:-1;8700:3:1;;8077:632;-1:-1:-1;;;;;;8077:632:1:o;8714:615::-;8811:6;8819;8827;8835;8843;8896:3;8884:9;8875:7;8871:23;8867:33;8864:53;;;8913:1;8910;8903:12;8864:53;8949:9;8936:23;8926:33;;9006:2;8995:9;8991:18;8978:32;8968:42;;9057:2;9046:9;9042:18;9029:32;9019:42;;9112:2;9101:9;9097:18;9084:32;-1:-1:-1;;;;;9131:6:1;9128:30;9125:50;;;9171:1;9168;9161:12;9125:50;9210:59;9261:7;9252:6;9241:9;9237:22;9210:59;:::i;:::-;8714:615;;;;-1:-1:-1;8714:615:1;;-1:-1:-1;9288:8:1;;9184:85;8714:615;-1:-1:-1;;;8714:615:1:o;10262:260::-;10330:6;10338;10391:2;10379:9;10370:7;10366:23;10362:32;10359:52;;;10407:1;10404;10397:12;10359:52;10430:29;10449:9;10430:29;:::i;:::-;10420:39;;10478:38;10512:2;10501:9;10497:18;10478:38;:::i;:::-;10468:48;;10262:260;;;;;:::o;10527:606::-;10631:6;10639;10647;10655;10663;10716:3;10704:9;10695:7;10691:23;10687:33;10684:53;;;10733:1;10730;10723:12;10684:53;10756:29;10775:9;10756:29;:::i;:::-;10746:39;;10804:38;10838:2;10827:9;10823:18;10804:38;:::i;:::-;10794:48;;10889:2;10878:9;10874:18;10861:32;10851:42;;10940:2;10929:9;10925:18;10912:32;10902:42;;10995:3;10984:9;10980:19;10967:33;-1:-1:-1;;;;;11015:6:1;11012:30;11009:50;;;11055:1;11052;11045:12;11009:50;11078:49;11119:7;11110:6;11099:9;11095:22;11078:49;:::i;11549:390::-;11708:2;11697:9;11690:21;11747:6;11742:2;11731:9;11727:18;11720:34;11804:6;11796;11791:2;11780:9;11776:18;11763:48;11860:1;11831:22;;;11855:2;11827:31;;;11820:42;;;;11923:2;11902:15;;;-1:-1:-1;;11898:29:1;11883:45;11879:54;;11549:390;-1:-1:-1;11549:390:1:o;11944:380::-;12023:1;12019:12;;;;12066;;;12087:61;;12141:4;12133:6;12129:17;12119:27;;12087:61;12194:2;12186:6;12183:14;12163:18;12160:38;12157:161;;12240:10;12235:3;12231:20;12228:1;12221:31;12275:4;12272:1;12265:15;12303:4;12300:1;12293:15;12157:161;;11944:380;;;:::o;12329:127::-;12390:10;12385:3;12381:20;12378:1;12371:31;12421:4;12418:1;12411:15;12445:4;12442:1;12435:15;12461:135;12500:3;12521:17;;;12518:43;;12541:18;;:::i;:::-;-1:-1:-1;12588:1:1;12577:13;;12461:135::o;13011:127::-;13072:10;13067:3;13063:20;13060:1;13053:31;13103:4;13100:1;13093:15;13127:4;13124:1;13117:15;13143:274;-1:-1:-1;;;;;13281:10:1;;;13293;;;13277:27;13324:20;;;;13215:34;13363:24;;;13353:58;;13391:18;;:::i;:::-;13353:58;;13143:274;;;;:::o;13422:168::-;13495:9;;;13526;;13543:15;;;13537:22;;13523:37;13513:71;;13564:18;;:::i;13595:217::-;13635:1;13661;13651:132;;13705:10;13700:3;13696:20;13693:1;13686:31;13740:4;13737:1;13730:15;13768:4;13765:1;13758:15;13651:132;-1:-1:-1;13797:9:1;;13595:217::o;14418:125::-;14483:9;;;14504:10;;;14501:36;;;14517:18;;:::i;15067:128::-;15134:9;;;15155:11;;;15152:37;;;15169:18;;:::i;15607:180::-;-1:-1:-1;;;;;15712:10:1;;;15724;;;15708:27;;15747:11;;;15744:37;;;15761:18;;:::i;:::-;15744:37;15607:180;;;;:::o;16279:545::-;16381:2;16376:3;16373:11;16370:448;;;16417:1;16442:5;16438:2;16431:17;16487:4;16483:2;16473:19;16557:2;16545:10;16541:19;16538:1;16534:27;16528:4;16524:38;16593:4;16581:10;16578:20;16575:47;;;-1:-1:-1;16616:4:1;16575:47;16671:2;16666:3;16662:12;16659:1;16655:20;16649:4;16645:31;16635:41;;16726:82;16744:2;16737:5;16734:13;16726:82;;;16789:17;;;16770:1;16759:13;16726:82;;16370:448;16279:545;;;:::o;17000:1352::-;17126:3;17120:10;-1:-1:-1;;;;;17145:6:1;17142:30;17139:56;;;17175:18;;:::i;:::-;17204:97;17294:6;17254:38;17286:4;17280:11;17254:38;:::i;:::-;17248:4;17204:97;:::i;:::-;17356:4;;17420:2;17409:14;;17437:1;17432:663;;;;18139:1;18156:6;18153:89;;;-1:-1:-1;18208:19:1;;;18202:26;18153:89;-1:-1:-1;;16957:1:1;16953:11;;;16949:24;16945:29;16935:40;16981:1;16977:11;;;16932:57;18255:81;;17402:944;;17432:663;16226:1;16219:14;;;16263:4;16250:18;;-1:-1:-1;;17468:20:1;;;17586:236;17600:7;17597:1;17594:14;17586:236;;;17689:19;;;17683:26;17668:42;;17781:27;;;;17749:1;17737:14;;;;17616:19;;17586:236;;;17590:3;17850:6;17841:7;17838:19;17835:201;;;17911:19;;;17905:26;-1:-1:-1;;17994:1:1;17990:14;;;18006:3;17986:24;17982:37;17978:42;17963:58;17948:74;;17835:201;-1:-1:-1;;;;;18082:1:1;18066:14;;;18062:22;18049:36;;-1:-1:-1;17000:1352:1:o;19397:127::-;19458:10;19453:3;19449:20;19446:1;19439:31;19489:4;19486:1;19479:15;19513:4;19510:1;19503:15;21054:561;-1:-1:-1;;;;;21351:15:1;;;21333:34;;21403:15;;21398:2;21383:18;;21376:43;21450:2;21435:18;;21428:34;;;21493:2;21478:18;;21471:34;;;21313:3;21536;21521:19;;21514:32;;;21276:4;;21563:46;;21589:19;;21581:6;21563:46;:::i;:::-;21555:54;21054:561;-1:-1:-1;;;;;;;21054:561:1:o;21620:249::-;21689:6;21742:2;21730:9;21721:7;21717:23;21713:32;21710:52;;;21758:1;21755;21748:12;21710:52;21790:9;21784:16;21809:30;21833:5;21809:30;:::i;21874:179::-;21909:3;21951:1;21933:16;21930:23;21927:120;;;21997:1;21994;21991;21976:23;-1:-1:-1;22034:1:1;22028:8;22023:3;22019:18;21927:120;21874:179;:::o;22058:671::-;22097:3;22139:4;22121:16;22118:26;22115:39;;;22058:671;:::o;22115:39::-;22181:2;22175:9;-1:-1:-1;;22246:16:1;22242:25;;22239:1;22175:9;22218:50;22297:4;22291:11;22321:16;-1:-1:-1;;;;;22427:2:1;22420:4;22412:6;22408:17;22405:25;22400:2;22392:6;22389:14;22386:45;22383:58;;;22434:5;;;;;22058:671;:::o;22383:58::-;22471:6;22465:4;22461:17;22450:28;;22507:3;22501:10;22534:2;22526:6;22523:14;22520:27;;;22540:5;;;;;;22058:671;:::o;22520:27::-;22624:2;22605:16;22599:4;22595:27;22591:36;22584:4;22575:6;22570:3;22566:16;22562:27;22559:69;22556:82;;;22631:5;;;;;;22058:671;:::o;22556:82::-;22647:57;22698:4;22689:6;22681;22677:19;22673:30;22667:4;22647:57;:::i;:::-;-1:-1:-1;22720:3:1;;22058:671;-1:-1:-1;;;;;22058:671:1:o

ipfs://04833a06cd4aead9511d567f07af67b14d4699308548f3ee0952df511ece4475