Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 verifyCallResult(
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• interface IERC1155Receiver is IERC165
•    - function onERC1155Received(
•    - function onERC1155BatchReceived(
• 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 IERC1155MetadataURI is IERC ...
•    - function uri(uint256 id)
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
• 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 _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract OwnableTokenAccessControl ...
•    - function _accessToIndex(bytes32 acces ...
•    - function _hasAccess(Access access, ad ...
•    - function hasAccess(bytes32 access, ad ...
•    - function grantAccess(bytes32 access, ...
•    - function revokeAccess(bytes32 access, ...
•    - function countOfAccess(bytes32 access ...
•    - function permanentlyDisableGrantingAc ...
•  contract ERC1155 is Context, ERC16 ...
•    - function supportsInterface(bytes4 int ...
•    - function uri(uint256)
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(address[] mem ...
•    - function balanceOfBatchIds(address ac ...
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(
•    - function _safeTransferFrom(
•    - function _safeBatchTransferFrom(
•    - function _safeMint(
•    - function _safeMintBatch(
•    - function burn(
•    - function burnBatch(
•    - function _burn(
•    - function _burnBatch(
•    - function _isApprovedForAllOrHasAccess ...
•    - function _setApprovalForAll(
•    - function _doSafeTransferAcceptanceChe ...
•    - function _doSafeBatchTransferAcceptan ...
•  contract Traits is ERC1155
•    - function name()
•    - function symbol()
•    - function setURI(string memory uriBase ...
•    - function setURIExtension(string memor ...
•    - function uri(uint256 tokenId)
•    - function mint(address to, uint256 id, ...
•    - function mintBatch(address to, uint25 ...
•  contract TraitsMint is Ownable *
•    - function claimMultiple(uint256[] call ...
•    - function claim(uint256[] calldata ids ...
•    - function isNonceClaimed(address accou ...
•    - function areNoncesClaimed(address acc ...
•    - function setSignerAddress(address sig ...
•    - function setClaimer(address claimer, ...
•    - function setClaimingEnabled(bool enab ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-05-14
*/

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


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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

    /**
     * @dev Returns an Ethereum Signed 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));
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: OwnableTokenAccessControl.sol



pragma solidity ^0.8.0;


/// @title OwnableTokenAccessControl
/// @notice Basic access control for utility tokens 
/// @author ponky
contract OwnableTokenAccessControl is Ownable {
    /// @dev Keeps track of how many accounts have been granted each type of access
    uint96 private _accessCounts;

    mapping (address => uint256) private _accessFlags;

    /// @dev Access types
    enum Access { Mint, Burn, Transfer, Claim }

    /// @dev Emitted when `account` is granted `access`.
    event AccessGranted(bytes32 indexed access, address indexed account);

    /// @dev Emitted when `account` is revoked `access`.
    event AccessRevoked(bytes32 indexed access, address indexed account);

    /// @dev Helper constants for fitting each access index into _accessCounts
    uint constant private _AC_BASE          = 4;
    uint constant private _AC_MASK_BITSIZE  = 1 << _AC_BASE;
    uint constant private _AC_DISABLED      = (1 << (_AC_MASK_BITSIZE - 1));
    uint constant private _AC_MASK_COUNT    = _AC_DISABLED - 1;

    /// @dev Convert the string `access` to an uint
    function _accessToIndex(bytes32 access) internal pure virtual returns (uint index) {
        if (access == 'MINT')       {return uint(Access.Mint);}
        if (access == 'BURN')       {return uint(Access.Burn);}
        if (access == 'TRANSFER')   {return uint(Access.Transfer);}
        if (access == 'CLAIM')      {return uint(Access.Claim);}
        revert("Access type does not exist");
    }

    function _hasAccess(Access access, address account) internal view returns (bool) {
        return (_accessFlags[account] & (1 << uint(access))) != 0;
    }

    function hasAccess(bytes32 access, address account) public view returns (bool) {
        uint256 flag = 1 << _accessToIndex(access);        
        return (_accessFlags[account] & flag) != 0;
    }

    function grantAccess(bytes32 access, address account) external onlyOwner {
        require(account.code.length > 0, "Can only grant access to a contract");

        uint index = _accessToIndex(access);
        uint256 flags = _accessFlags[account];
        uint256 newFlags = flags | (1 << index);
        require(flags != newFlags, "Account already has access");
        _accessFlags[account] = newFlags;

        uint shift = index << _AC_BASE;
        uint256 accessCount = _accessCounts >> shift;
        require((accessCount & _AC_DISABLED) == 0, "Granting this access is permanently disabled");
        require((accessCount & _AC_MASK_COUNT) < _AC_MASK_COUNT, "Access limit reached");
        unchecked {
            _accessCounts += uint96(1 << shift);
        }
        emit AccessGranted(access, account);
    }

    function revokeAccess(bytes32 access, address account) external onlyOwner {
        uint index = _accessToIndex(access);
        uint256 flags = _accessFlags[account];
        uint256 newFlags = flags & ~(1 << index);
        require(flags != newFlags, "Account does not have access");
        _accessFlags[account] = newFlags;

        uint shift = index << _AC_BASE;
        unchecked {
            _accessCounts -= uint96(1 << shift);
        }

        emit AccessRevoked(access, account);
    }

    /// @dev Returns the number of contracts that have `access`.
    function countOfAccess(bytes32 access) external view returns (uint256 accessCount) {
        uint index = _accessToIndex(access);

        uint shift = index << _AC_BASE;
        accessCount = (_accessCounts >> shift) & _AC_MASK_COUNT;
    }

    /// @dev `access` can still be revoked but not granted
    function permanentlyDisableGrantingAccess(bytes32 access) external onlyOwner {
        uint index = _accessToIndex(access);
        
        uint shift = index << _AC_BASE;
        uint256 flag = _AC_DISABLED << shift;
        uint256 accessCounts = _accessCounts;
        require((accessCounts & flag) == 0, "Granting this access is already disabled");
        _accessCounts = uint96(accessCounts | flag);
    }
}

// File: ERC1155.sol


// Adapted from OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;








/**
 * @dev Extended implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by OpenZeppelin: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/ERC1155.sol
 * and Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 *
 */

contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, OwnableTokenAccessControl {
    using Address for address;

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

    enum Approval {
        Unknown,
        NotApproved,
        Approved
    }

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


    constructor() {

    }

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

    /**
     * @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: balance query for the zero address");
        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;
    }

    /**
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOfBatchIds(address account, uint256[] memory ids)
        public
        view
        virtual
        returns (uint256[] memory)
    {
        require(account != address(0), "ERC1155: balance query for the zero address");

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

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

        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] == Approval.Approved;
    }

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || _isApprovedForAllOrHasAccess(from, _msgSender(), Access.Transfer),
            "ERC1155: caller is not owner nor 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() || _isApprovedForAllOrHasAccess(from, _msgSender(), Access.Transfer),
            "ERC1155: transfer caller is not owner nor 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 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);

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

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

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


    

    /**
     * @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 _safeMint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

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

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

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeMint}.
     *
     * 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 _safeMintBatch(
        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();

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

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

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



    function burn(
        address account,
        uint256 id,
        uint256 amount
    ) external {
        require(
            account == _msgSender() || _isApprovedForAllOrHasAccess(account, _msgSender(), Access.Burn),
            "ERC1155: caller is not owner nor approved"
        );

        _burn(account, id, amount);
    }

    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) external {
        require(
            account == _msgSender() || _isApprovedForAllOrHasAccess(account, _msgSender(), Access.Burn),
            "ERC1155: caller is not owner nor approved"
        );

        _burnBatch(account, ids, amounts);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * 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 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);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * 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();

        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);
    }


    function _isApprovedForAllOrHasAccess(
        address account,
        address operator,
        Access access
    ) internal virtual returns (bool) {
        Approval aproval = _operatorApprovals[account][operator];
        if (aproval == Approval.Approved) {
            return true;
        }
        if (aproval == Approval.NotApproved) {
            return false;
        }

        return _hasAccess(access, operator);
    }

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


    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");
            }
        }
    }
}

// File: Traits.sol


pragma solidity =0.8.13;



contract Traits is ERC1155 {
    constructor() ERC1155() {}

    string private _uriBase;
    string private _extension;

    function name() public pure returns (string memory) {
        return "TestTraits";
    }

    function symbol() public pure returns (string memory) {
        return "TRAIT";
    }

    function setURI(string memory uriBase) public onlyOwner {
        _uriBase = uriBase;
    }

    function setURIExtension(string memory extension) public onlyOwner {
        _extension = extension;
    }

    function uri(uint256 tokenId) override public view returns (string memory) {
        return string(abi.encodePacked(_uriBase, Strings.toString(tokenId), _extension));
    }

    function mint(address to, uint256 id, uint256 amount) external {
        require(_hasAccess(Access.Mint, _msgSender()), "Not allowed to mint");
        _safeMint(to, id, amount, "");
    }

    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts) external {
        require(_hasAccess(Access.Mint, _msgSender()), "Not allowed to mint");
        _safeMintBatch(to, ids, amounts, "");
    }
}

// File: TraitsMint.sol


pragma solidity =0.8.13;




contract TraitsMint is Ownable {
    address private _signerAddress;
    bool public isClaimingEnabled;
    mapping(address => bool) private _claimers;
    mapping(address => mapping(uint256 => uint256)) private _nonces;

    address private immutable _traitsContract;

    constructor(address traitsContract) {
        _traitsContract = traitsContract;
    }

    modifier canClaim() {
        require(isClaimingEnabled, "Claiming is disabled");
        _;
    }

    function claimMultiple(uint256[] calldata ids, uint256[] calldata amounts, address account, uint256[] calldata nonces, uint256 deadlineTimestamp, bytes32 signatureR, bytes32 signatureVS) external canClaim {
        require(msg.sender == account || _claimers[msg.sender], "Not allowed to claim");
        require(deadlineTimestamp == 0 || deadlineTimestamp > block.timestamp, "Deadline to claim has passed");

        {
            bytes32 hash = keccak256(abi.encode(ids, amounts, account, nonces, deadlineTimestamp));
            require(_signerAddress == ECDSA.recover(hash,  signatureR,  signatureVS), "Invalid signature");
        }

        unchecked {
            uint256 length = nonces.length;
            require(length > 0, "nonces array is empty");
            uint256 nonceIndex = nonces[0];
            uint256 mask = 1 << (nonceIndex & 0xff);
            nonceIndex >>= 8;            
            for (uint256 i=1; i<length; ++i) {
                uint256 nonce = nonces[i];
                uint256 i_nonceIndex = nonce >> 8;
                if (i_nonceIndex != nonceIndex) {
                    uint256 noncePacked = _nonces[account][nonceIndex];
                    require((noncePacked & mask) == 0, "Already claimed");
                    _nonces[account][nonceIndex] = noncePacked | mask;

                    nonceIndex = i_nonceIndex;
                    mask = 0;
                }
                mask |= (1 << (nonce & 0xff));
            }
            
            {
                uint256 noncePacked = _nonces[account][nonceIndex];
                require((noncePacked & mask) == 0, "Already claimed");
                _nonces[account][nonceIndex] = noncePacked | mask;
            }
        }
        
        Traits(_traitsContract).mintBatch(account, ids, amounts);
    }

    function claim(uint256[] calldata ids, uint256[] calldata amounts, address account, uint256 nonce, uint256 deadlineTimestamp, bytes32 signatureR, bytes32 signatureVS) external canClaim {
        require(msg.sender == account || _claimers[msg.sender], "Not allowed to claim");
        require(deadlineTimestamp == 0 || deadlineTimestamp > block.timestamp, "Deadline to claim has passed");

        {
            bytes32 hash = keccak256(abi.encode(ids, amounts, account, nonce, deadlineTimestamp));
            require(_signerAddress == ECDSA.recover(hash,  signatureR,  signatureVS), "Invalid signature");
        }
        
        uint256 nonceIndex = nonce >> 8;
        uint256 noncePacked = _nonces[account][nonceIndex];
        uint256 noncePackedNew = noncePacked | (1 << (nonce & 0xff));
        require(noncePacked != noncePackedNew, "Already claimed");
        _nonces[account][nonceIndex] = noncePackedNew;
        
        Traits(_traitsContract).mintBatch(account, ids, amounts);
    }


    function isNonceClaimed(address account, uint256 nonce) external view returns(bool) {
        uint256 nonceIndex = nonce >> 8;
        return (_nonces[account][nonceIndex] & (1 << (nonce & 0xff))) != 0;
    }

    function areNoncesClaimed(address account, uint256[] calldata nonces) external view returns(bool[] memory) {
        uint256 length = nonces.length;
        bool[] memory results = new bool[](length);
        unchecked {
            for (uint256 i=0; i<length; ++i) {
                uint256 nonce = nonces[i];
                uint256 nonceIndex = nonce >> 8;
                results[i] = (_nonces[account][nonceIndex] & (1 << (nonce & 0xff))) != 0;
            }
        }
        return results;
    }



    function setSignerAddress(address signerAddress) external onlyOwner {
        _signerAddress = signerAddress;
    }

    function setClaimer(address claimer, bool enabled) external onlyOwner {
        require(claimer != address(0), "Invalid claimer");
        _claimers[claimer] = enabled;
    }

    function setClaimingEnabled(bool enabled) external onlyOwner {
        isClaimingEnabled = enabled;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"traitsContract","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"nonces","type":"uint256[]"}],"name":"areNoncesClaimed","outputs":[{"internalType":"bool[]","name":"","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"deadlineTimestamp","type":"uint256"},{"internalType":"bytes32","name":"signatureR","type":"bytes32"},{"internalType":"bytes32","name":"signatureVS","type":"bytes32"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"nonces","type":"uint256[]"},{"internalType":"uint256","name":"deadlineTimestamp","type":"uint256"},{"internalType":"bytes32","name":"signatureR","type":"bytes32"},{"internalType":"bytes32","name":"signatureVS","type":"bytes32"}],"name":"claimMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isClaimingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"isNonceClaimed","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":"claimer","type":"address"},{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setClaimer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setClaimingEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"signerAddress","type":"address"}],"name":"setSignerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106100a95760003560e01c80638da5cb5b116100715780638da5cb5b1461013c578063b6c728881461015a578063e6cf165714610176578063e7c7d37314610194578063f2fde38b146101b0578063fec63bf1146101cc576100a9565b8063046dc166146100ae57806321f7775d146100ca5780633d4c415a146100fa5780633f2e2c7014610116578063715018a614610132575b600080fd5b6100c860048036038101906100c391906115e9565b6101fc565b005b6100e460048036038101906100df919061167b565b6102bc565b6040516100f191906117a5565b60405180910390f35b610114600480360381019061010f91906117f3565b6103e2565b005b610130600480360381019061012b919061189f565b610528565b005b61013a610abc565b005b610144610b44565b60405161015191906119b1565b60405180910390f35b610174600480360381019061016f91906119cc565b610b6d565b005b61017e610c06565b60405161018b9190611a08565b60405180910390f35b6101ae60048036038101906101a99190611a23565b610c19565b005b6101ca60048036038101906101c591906115e9565b610fed565b005b6101e660048036038101906101e19190611b05565b6110e4565b6040516101f39190611a08565b60405180910390f35b610204611155565b73ffffffffffffffffffffffffffffffffffffffff16610222610b44565b73ffffffffffffffffffffffffffffffffffffffff1614610278576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161026f90611ba2565b60405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6060600083839050905060008167ffffffffffffffff8111156102e2576102e1611bc2565b5b6040519080825280602002602001820160405280156103105781602001602082028036833780820191505090505b50905060005b828110156103d557600086868381811061033357610332611bf1565b5b9050602002013590506000600882901c9050600060ff83166001901b600360008c73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000848152602001908152602001600020541614158484815181106103b6576103b5611bf1565b5b6020026020010190151590811515815250505050806001019050610316565b5080925050509392505050565b6103ea611155565b73ffffffffffffffffffffffffffffffffffffffff16610408610b44565b73ffffffffffffffffffffffffffffffffffffffff161461045e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161045590611ba2565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16036104cd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104c490611c6c565b60405180910390fd5b80600260008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055505050565b600160149054906101000a900460ff16610577576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161056e90611cd8565b60405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614806105fa5750600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff165b610639576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161063090611d44565b60405180910390fd5b600083148061064757504283115b610686576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161067d90611db0565b60405180910390fd5b60008a8a8a8a8a8a8a8a6040516020016106a7989796959493929190611e60565b6040516020818303038152906040528051906020012090506106ca81848461115d565b73ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610759576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161075090611f1a565b60405180910390fd5b506000858590509050600081116107a5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161079c90611f86565b60405180910390fd5b6000868660008181106107bb576107ba611bf1565b5b905060200201359050600060ff82166001901b9050600882901c91506000600190505b838110156109275760008989838181106107fb576107fa611bf1565b5b9050602002013590506000600882901c905084811461090e576000600360008e73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008781526020019081526020016000205490506000858216146108ae576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108a590611ff2565b60405180910390fd5b848117600360008f73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008881526020019081526020016000208190555081955060009450505b60ff82166001901b8417935050508060010190506107de565b506000600360008b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008481526020019081526020016000205490506000828216146109c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109b990611ff2565b60405180910390fd5b818117600360008c73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600085815260200190815260200160002081905550505050507f000000000000000000000000d1606499804ff42b04ce7d9143adbe568bf50f1c73ffffffffffffffffffffffffffffffffffffffff1663d81d0a15878c8c8c8c6040518663ffffffff1660e01b8152600401610a7e959493929190612012565b600060405180830381600087803b158015610a9857600080fd5b505af1158015610aac573d6000803e3d6000fd5b5050505050505050505050505050565b610ac4611155565b73ffffffffffffffffffffffffffffffffffffffff16610ae2610b44565b73ffffffffffffffffffffffffffffffffffffffff1614610b38576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2f90611ba2565b60405180910390fd5b610b426000611186565b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b610b75611155565b73ffffffffffffffffffffffffffffffffffffffff16610b93610b44565b73ffffffffffffffffffffffffffffffffffffffff1614610be9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610be090611ba2565b60405180910390fd5b80600160146101000a81548160ff02191690831515021790555050565b600160149054906101000a900460ff1681565b600160149054906101000a900460ff16610c68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c5f90611cd8565b60405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161480610ceb5750600260003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff165b610d2a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d2190611d44565b60405180910390fd5b6000831480610d3857504283115b610d77576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d6e90611db0565b60405180910390fd5b600089898989898989604051602001610d96979695949392919061205b565b604051602081830303815290604052805190602001209050610db981848461115d565b73ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610e48576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e3f90611f1a565b60405180910390fd5b506000600885901c90506000600360008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000838152602001908152602001600020549050600060ff87166001901b82179050808203610ef7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eee90611ff2565b60405180910390fd5b80600360008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000858152602001908152602001600020819055507f000000000000000000000000d1606499804ff42b04ce7d9143adbe568bf50f1c73ffffffffffffffffffffffffffffffffffffffff1663d81d0a15898e8e8e8e6040518663ffffffff1660e01b8152600401610fad959493929190612012565b600060405180830381600087803b158015610fc757600080fd5b505af1158015610fdb573d6000803e3d6000fd5b50505050505050505050505050505050565b610ff5611155565b73ffffffffffffffffffffffffffffffffffffffff16611013610b44565b73ffffffffffffffffffffffffffffffffffffffff1614611069576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161106090611ba2565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16036110d8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110cf90612132565b60405180910390fd5b6110e181611186565b50565b600080600883901c9050600060ff84166001901b600360008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008481526020019081526020016000205416141591505092915050565b600033905090565b600080600061116d86868661124a565b9150915061117a816112a9565b81925050509392505050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b60008060007f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60001b841690506000601b60ff8660001c901c61128d9190612181565b905061129b87828885611475565b935093505050935093915050565b600060048111156112bd576112bc6121d7565b5b8160048111156112d0576112cf6121d7565b5b031561147257600160048111156112ea576112e96121d7565b5b8160048111156112fd576112fc6121d7565b5b0361133d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161133490612252565b60405180910390fd5b60026004811115611351576113506121d7565b5b816004811115611364576113636121d7565b5b036113a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161139b906122be565b60405180910390fd5b600360048111156113b8576113b76121d7565b5b8160048111156113cb576113ca6121d7565b5b0361140b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161140290612350565b60405180910390fd5b60048081111561141e5761141d6121d7565b5b816004811115611431576114306121d7565b5b03611471576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611468906123e2565b60405180910390fd5b5b50565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08360001c11156114b0576000600391509150611578565b601b8560ff16141580156114c85750601c8560ff1614155b156114da576000600491509150611578565b6000600187878787604051600081526020016040526040516114ff949392919061242d565b6020604051602081039080840390855afa158015611521573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361156f57600060019250925050611578565b80600092509250505b94509492505050565b600080fd5b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b60006115b68261158b565b9050919050565b6115c6816115ab565b81146115d157600080fd5b50565b6000813590506115e3816115bd565b92915050565b6000602082840312156115ff576115fe611581565b5b600061160d848285016115d4565b91505092915050565b600080fd5b600080fd5b600080fd5b60008083601f84011261163b5761163a611616565b5b8235905067ffffffffffffffff8111156116585761165761161b565b5b60208301915083602082028301111561167457611673611620565b5b9250929050565b60008060006040848603121561169457611693611581565b5b60006116a2868287016115d4565b935050602084013567ffffffffffffffff8111156116c3576116c2611586565b5b6116cf86828701611625565b92509250509250925092565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b60008115159050919050565b61171c81611707565b82525050565b600061172e8383611713565b60208301905092915050565b6000602082019050919050565b6000611752826116db565b61175c81856116e6565b9350611767836116f7565b8060005b8381101561179857815161177f8882611722565b975061178a8361173a565b92505060018101905061176b565b5085935050505092915050565b600060208201905081810360008301526117bf8184611747565b905092915050565b6117d081611707565b81146117db57600080fd5b50565b6000813590506117ed816117c7565b92915050565b6000806040838503121561180a57611809611581565b5b6000611818858286016115d4565b9250506020611829858286016117de565b9150509250929050565b6000819050919050565b61184681611833565b811461185157600080fd5b50565b6000813590506118638161183d565b92915050565b6000819050919050565b61187c81611869565b811461188757600080fd5b50565b60008135905061189981611873565b92915050565b60008060008060008060008060008060e08b8d0312156118c2576118c1611581565b5b60008b013567ffffffffffffffff8111156118e0576118df611586565b5b6118ec8d828e01611625565b9a509a505060208b013567ffffffffffffffff81111561190f5761190e611586565b5b61191b8d828e01611625565b9850985050604061192e8d828e016115d4565b96505060608b013567ffffffffffffffff81111561194f5761194e611586565b5b61195b8d828e01611625565b9550955050608061196e8d828e01611854565b93505060a061197f8d828e0161188a565b92505060c06119908d828e0161188a565b9150509295989b9194979a5092959850565b6119ab816115ab565b82525050565b60006020820190506119c660008301846119a2565b92915050565b6000602082840312156119e2576119e1611581565b5b60006119f0848285016117de565b91505092915050565b611a0281611707565b82525050565b6000602082019050611a1d60008301846119f9565b92915050565b600080600080600080600080600060e08a8c031215611a4557611a44611581565b5b60008a013567ffffffffffffffff811115611a6357611a62611586565b5b611a6f8c828d01611625565b995099505060208a013567ffffffffffffffff811115611a9257611a91611586565b5b611a9e8c828d01611625565b97509750506040611ab18c828d016115d4565b9550506060611ac28c828d01611854565b9450506080611ad38c828d01611854565b93505060a0611ae48c828d0161188a565b92505060c0611af58c828d0161188a565b9150509295985092959850929598565b60008060408385031215611b1c57611b1b611581565b5b6000611b2a858286016115d4565b9250506020611b3b85828601611854565b9150509250929050565b600082825260208201905092915050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b6000611b8c602083611b45565b9150611b9782611b56565b602082019050919050565b60006020820190508181036000830152611bbb81611b7f565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f496e76616c696420636c61696d65720000000000000000000000000000000000600082015250565b6000611c56600f83611b45565b9150611c6182611c20565b602082019050919050565b60006020820190508181036000830152611c8581611c49565b9050919050565b7f436c61696d696e672069732064697361626c6564000000000000000000000000600082015250565b6000611cc2601483611b45565b9150611ccd82611c8c565b602082019050919050565b60006020820190508181036000830152611cf181611cb5565b9050919050565b7f4e6f7420616c6c6f77656420746f20636c61696d000000000000000000000000600082015250565b6000611d2e601483611b45565b9150611d3982611cf8565b602082019050919050565b60006020820190508181036000830152611d5d81611d21565b9050919050565b7f446561646c696e6520746f20636c61696d206861732070617373656400000000600082015250565b6000611d9a601c83611b45565b9150611da582611d64565b602082019050919050565b60006020820190508181036000830152611dc981611d8d565b9050919050565b600082825260208201905092915050565b600080fd5b82818337600083830152505050565b6000611e018385611dd0565b93507f07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff831115611e3457611e33611de1565b5b602083029250611e45838584611de6565b82840190509392505050565b611e5a81611833565b82525050565b600060a0820190508181036000830152611e7b818a8c611df5565b90508181036020830152611e9081888a611df5565b9050611e9f60408301876119a2565b8181036060830152611eb2818587611df5565b9050611ec16080830184611e51565b9998505050505050505050565b7f496e76616c6964207369676e6174757265000000000000000000000000000000600082015250565b6000611f04601183611b45565b9150611f0f82611ece565b602082019050919050565b60006020820190508181036000830152611f3381611ef7565b9050919050565b7f6e6f6e63657320617272617920697320656d7074790000000000000000000000600082015250565b6000611f70601583611b45565b9150611f7b82611f3a565b602082019050919050565b60006020820190508181036000830152611f9f81611f63565b9050919050565b7f416c726561647920636c61696d65640000000000000000000000000000000000600082015250565b6000611fdc600f83611b45565b9150611fe782611fa6565b602082019050919050565b6000602082019050818103600083015261200b81611fcf565b9050919050565b600060608201905061202760008301886119a2565b818103602083015261203a818688611df5565b9050818103604083015261204f818486611df5565b90509695505050505050565b600060a082019050818103600083015261207681898b611df5565b9050818103602083015261208b818789611df5565b905061209a60408301866119a2565b6120a76060830185611e51565b6120b46080830184611e51565b98975050505050505050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b600061211c602683611b45565b9150612127826120c0565b604082019050919050565b6000602082019050818103600083015261214b8161210f565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061218c82611833565b915061219783611833565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156121cc576121cb612152565b5b828201905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f45434453413a20696e76616c6964207369676e61747572650000000000000000600082015250565b600061223c601883611b45565b915061224782612206565b602082019050919050565b6000602082019050818103600083015261226b8161222f565b9050919050565b7f45434453413a20696e76616c6964207369676e6174757265206c656e67746800600082015250565b60006122a8601f83611b45565b91506122b382612272565b602082019050919050565b600060208201905081810360008301526122d78161229b565b9050919050565b7f45434453413a20696e76616c6964207369676e6174757265202773272076616c60008201527f7565000000000000000000000000000000000000000000000000000000000000602082015250565b600061233a602283611b45565b9150612345826122de565b604082019050919050565b600060208201905081810360008301526123698161232d565b9050919050565b7f45434453413a20696e76616c6964207369676e6174757265202776272076616c60008201527f7565000000000000000000000000000000000000000000000000000000000000602082015250565b60006123cc602283611b45565b91506123d782612370565b604082019050919050565b600060208201905081810360008301526123fb816123bf565b9050919050565b61240b81611869565b82525050565b600060ff82169050919050565b61242781612411565b82525050565b60006080820190506124426000830187612402565b61244f602083018661241e565b61245c6040830185612402565b6124696060830184612402565b9594505050505056fea26469706673582212207bdef281a4eff71706bebad8b32f0e6185c2247438860f66e196579a0a11961b64736f6c634300080d0033

000000000000000000000000d1606499804ff42b04ce7d9143adbe568bf50f1c

-----Decoded View---------------
Arg [0] : traitsContract (address): 0xD1606499804Ff42B04CE7d9143ADBE568bF50F1c

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d1606499804ff42b04ce7d9143adbe568bf50f1c

53008:4522:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57110:117;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56584:514;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57235:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53494:1839;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;32197:103;;;:::i;:::-;;31546:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57420:107;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53083:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55341:1014;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;32455:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56365:211;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57110:117;31777:12;:10;:12::i;:::-;31766:23;;:7;:5;:7::i;:::-;:23;;;31758:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57206:13:::1;57189:14;;:30;;;;;;;;;;;;;;;;;;57110:117:::0;:::o;56584:514::-;56676:13;56702:14;56719:6;;:13;;56702:30;;56743:21;56778:6;56767:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56743:42;;56826:9;56821:234;56841:6;56839:1;:8;56821:234;;;56873:13;56889:6;;56896:1;56889:9;;;;;;;:::i;:::-;;;;;;;;56873:25;;56917:18;56947:1;56938:5;:10;;56917:31;;57038:1;57027:4;57019:5;:12;57013:1;:19;;56981:7;:16;56989:7;56981:16;;;;;;;;;;;;;;;:28;56998:10;56981:28;;;;;;;;;;;;:52;56980:59;;56967:7;56975:1;56967:10;;;;;;;;:::i;:::-;;;;;;;:72;;;;;;;;;;;56854:201;;56849:3;;;;;56821:234;;;;57083:7;57076:14;;;;56584:514;;;;;:::o;57235:177::-;31777:12;:10;:12::i;:::-;31766:23;;:7;:5;:7::i;:::-;:23;;;31758:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57343:1:::1;57324:21;;:7;:21;;::::0;57316:49:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;57397:7;57376:9;:18;57386:7;57376:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;;;;;;;;57235:177:::0;;:::o;53494:1839::-;53424:17;;;;;;;;;;;53416:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;53732:7:::1;53718:21;;:10;:21;;;:46;;;;53743:9;:21;53753:10;53743:21;;;;;;;;;;;;;;;;;;;;;;;;;53718:46;53710:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;53829:1;53808:17;:22;:61;;;;53854:15;53834:17;:35;53808:61;53800:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;53930:12;53966:3;;53971:7;;53980;53989:6;;53997:17;53955:60;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53945:71;;;;;;53930:86;;54057:46;54071:4;54078:10;54091:11;54057:13;:46::i;:::-;54039:64;;:14;;;;;;;;;;;:64;;;54031:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;53915:222;54174:14;54191:6;;:13;;54174:30;;54236:1;54227:6;:10;54219:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;54278:18;54299:6;;54306:1;54299:9;;;;;;;:::i;:::-;;;;;;;;54278:30;;54323:12;54357:4;54344:10;:17;54338:1;:24;;54323:39;;54392:1;54377:16;;;;;54425:9;54435:1;54425:11;;54420:565;54440:6;54438:1;:8;54420:565;;;54472:13;54488:6;;54495:1;54488:9;;;;;;;:::i;:::-;;;;;;;;54472:25;;54516:20;54548:1;54539:5;:10;;54516:33;;54588:10;54572:12;:26;54568:354;;54623:19;54645:7;:16;54653:7;54645:16;;;;;;;;;;;;;;;:28;54662:10;54645:28;;;;;;;;;;;;54623:50;;54728:1;54719:4;54705:11;:18;54704:25;54696:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;54817:4;54803:11;:18;54772:7;:16;54780:7;54772:16;;;;;;;;;;;;;;;:28;54789:10;54772:28;;;;;;;;;;;:49;;;;54859:12;54846:25;;54901:1;54894:8;;54600:322;54568:354;54963:4;54955:5;:12;54949:1;:19;;54940:29;;;;54453:532;;54448:3;;;;;54420:565;;;;55032:19;55054:7;:16;55062:7;55054:16;;;;;;;;;;;;;;;:28;55071:10;55054:28;;;;;;;;;;;;55032:50;;55133:1;55124:4;55110:11;:18;55109:25;55101:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;55218:4;55204:11;:18;55173:7;:16;55181:7;55173:16;;;;;;;;;;;;;;;:28;55190:10;55173:28;;;;;;;;;;;:49;;;;55013:225;54149:1100;;;55276:15;55269:33;;;55303:7;55312:3;;55317:7;;55269:56;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;53494:1839:::0;;;;;;;;;;:::o;32197:103::-;31777:12;:10;:12::i;:::-;31766:23;;:7;:5;:7::i;:::-;:23;;;31758:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;32262:30:::1;32289:1;32262:18;:30::i;:::-;32197:103::o:0;31546:87::-;31592:7;31619:6;;;;;;;;;;;31612:13;;31546:87;:::o;57420:107::-;31777:12;:10;:12::i;:::-;31766:23;;:7;:5;:7::i;:::-;:23;;;31758:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57512:7:::1;57492:17;;:27;;;;;;;;;;;;;;;;;;57420:107:::0;:::o;53083:29::-;;;;;;;;;;;;;:::o;55341:1014::-;53424:17;;;;;;;;;;;53416:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;55559:7:::1;55545:21;;:10;:21;;;:46;;;;55570:9;:21;55580:10;55570:21;;;;;;;;;;;;;;;;;;;;;;;;;55545:46;55537:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;55656:1;55635:17;:22;:61;;;;55681:15;55661:17;:35;55635:61;55627:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;55757:12;55793:3;;55798:7;;55807;55816:5;55823:17;55782:59;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55772:70;;;;;;55757:85;;55883:46;55897:4;55904:10;55917:11;55883:13;:46::i;:::-;55865:64;;:14;;;;;;;;;;;:64;;;55857:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;55742:221;55983:18;56013:1;56004:5;:10;;55983:31;;56025:19;56047:7;:16;56055:7;56047:16;;;;;;;;;;;;;;;:28;56064:10;56047:28;;;;;;;;;;;;56025:50;;56086:22;56140:4;56132:5;:12;56126:1;:19;;56111:11;:35;56086:60;;56180:14;56165:11;:29:::0;56157:57:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;56256:14;56225:7;:16;56233:7;56225:16;;;;;;;;;;;;;;;:28;56242:10;56225:28;;;;;;;;;;;:45;;;;56298:15;56291:33;;;56325:7;56334:3;;56339:7;;56291:56;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;55526:829;;;55341:1014:::0;;;;;;;;;:::o;32455:201::-;31777:12;:10;:12::i;:::-;31766:23;;:7;:5;:7::i;:::-;:23;;;31758:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;32564:1:::1;32544:22;;:8;:22;;::::0;32536:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;32620:28;32639:8;32620:18;:28::i;:::-;32455:201:::0;:::o;56365:211::-;56443:4;56460:18;56490:1;56481:5;:10;;56460:31;;56567:1;56556:4;56548:5;:12;56542:1;:19;;56510:7;:16;56518:7;56510:16;;;;;;;;;;;;;;;:28;56527:10;56510:28;;;;;;;;;;;;:52;56509:59;;56502:66;;;56365:211;;;;:::o;30270:98::-;30323:7;30350:10;30343:17;;30270:98;:::o;25484:260::-;25595:7;25616:17;25635:18;25657:23;25668:4;25674:1;25677:2;25657:10;:23::i;:::-;25615:65;;;;25691:18;25703:5;25691:11;:18::i;:::-;25727:9;25720:16;;;;25484:260;;;;;:::o;32816:191::-;32890:16;32909:6;;;;;;;;;;;32890:25;;32935:8;32926:6;;:17;;;;;;;;;;;;;;;;;;32990:8;32959:40;;32980:8;32959:40;;;;;;;;;;;;32879:128;32816:191;:::o;24968:344::-;25082:7;25091:12;25116:9;25141:66;25133:75;;25128:2;:80;25116:92;;25219:7;25258:2;25251:3;25244:2;25236:11;;:18;;25235:25;;;;:::i;:::-;25219:42;;25279:25;25290:4;25296:1;25299;25302;25279:10;:25::i;:::-;25272:32;;;;;;24968:344;;;;;;:::o;20635:643::-;20713:20;20704:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;20700:571;20750:7;20700:571;20811:29;20802:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;20798:473;;20857:34;;;;;;;;;;:::i;:::-;;;;;;;;20798:473;20922:35;20913:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;20909:362;;20974:41;;;;;;;;;;:::i;:::-;;;;;;;;20909:362;21046:30;21037:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;21033:238;;21093:44;;;;;;;;;;:::i;:::-;;;;;;;;21033:238;21168:30;21159:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;21155:116;;21215:44;;;;;;;;;;:::i;:::-;;;;;;;;21155:116;20635:643;;:::o;25926:1632::-;26057:7;26066:12;26991:66;26986:1;26978:10;;:79;26974:163;;;27090:1;27094:30;27074:51;;;;;;26974:163;27156:2;27151:1;:7;;;;:18;;;;;27167:2;27162:1;:7;;;;27151:18;27147:102;;;27202:1;27206:30;27186:51;;;;;;27147:102;27346:14;27363:24;27373:4;27379:1;27382;27385;27363:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27346:41;;27420:1;27402:20;;:6;:20;;;27398:103;;27455:1;27459:29;27439:50;;;;;;;27398:103;27521:6;27529:20;27513:37;;;;;25926:1632;;;;;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:117::-;1285:1;1282;1275:12;1299:117;1408:1;1405;1398:12;1422:117;1531:1;1528;1521:12;1562:568;1635:8;1645:6;1695:3;1688:4;1680:6;1676:17;1672:27;1662:122;;1703:79;;:::i;:::-;1662:122;1816:6;1803:20;1793:30;;1846:18;1838:6;1835:30;1832:117;;;1868:79;;:::i;:::-;1832:117;1982:4;1974:6;1970:17;1958:29;;2036:3;2028:4;2020:6;2016:17;2006:8;2002:32;1999:41;1996:128;;;2043:79;;:::i;:::-;1996:128;1562:568;;;;;:::o;2136:704::-;2231:6;2239;2247;2296:2;2284:9;2275:7;2271:23;2267:32;2264:119;;;2302:79;;:::i;:::-;2264:119;2422:1;2447:53;2492:7;2483:6;2472:9;2468:22;2447:53;:::i;:::-;2437:63;;2393:117;2577:2;2566:9;2562:18;2549:32;2608:18;2600:6;2597:30;2594:117;;;2630:79;;:::i;:::-;2594:117;2743:80;2815:7;2806:6;2795:9;2791:22;2743:80;:::i;:::-;2725:98;;;;2520:313;2136:704;;;;;:::o;2846:111::-;2910:6;2944:5;2938:12;2928:22;;2846:111;;;:::o;2963:181::-;3059:11;3093:6;3088:3;3081:19;3133:4;3128:3;3124:14;3109:29;;2963:181;;;;:::o;3150:129::-;3214:4;3237:3;3229:11;;3267:4;3262:3;3258:14;3250:22;;3150:129;;;:::o;3285:90::-;3319:7;3362:5;3355:13;3348:21;3337:32;;3285:90;;;:::o;3381:99::-;3452:21;3467:5;3452:21;:::i;:::-;3447:3;3440:34;3381:99;;:::o;3486:167::-;3549:10;3570:40;3606:3;3598:6;3570:40;:::i;:::-;3642:4;3637:3;3633:14;3619:28;;3486:167;;;;:::o;3659:110::-;3726:4;3758;3753:3;3749:14;3741:22;;3659:110;;;:::o;3799:708::-;3912:3;3941:51;3986:5;3941:51;:::i;:::-;4008:83;4084:6;4079:3;4008:83;:::i;:::-;4001:90;;4115:53;4162:5;4115:53;:::i;:::-;4191:7;4222:1;4207:275;4232:6;4229:1;4226:13;4207:275;;;4308:6;4302:13;4335:57;4388:3;4373:13;4335:57;:::i;:::-;4328:64;;4415:57;4465:6;4415:57;:::i;:::-;4405:67;;4267:215;4254:1;4251;4247:9;4242:14;;4207:275;;;4211:14;4498:3;4491:10;;3917:590;;;3799:708;;;;:::o;4513:361::-;4650:4;4688:2;4677:9;4673:18;4665:26;;4737:9;4731:4;4727:20;4723:1;4712:9;4708:17;4701:47;4765:102;4862:4;4853:6;4765:102;:::i;:::-;4757:110;;4513:361;;;;:::o;4880:116::-;4950:21;4965:5;4950:21;:::i;:::-;4943:5;4940:32;4930:60;;4986:1;4983;4976:12;4930:60;4880:116;:::o;5002:133::-;5045:5;5083:6;5070:20;5061:29;;5099:30;5123:5;5099:30;:::i;:::-;5002:133;;;;:::o;5141:468::-;5206:6;5214;5263:2;5251:9;5242:7;5238:23;5234:32;5231:119;;;5269:79;;:::i;:::-;5231:119;5389:1;5414:53;5459:7;5450:6;5439:9;5435:22;5414:53;:::i;:::-;5404:63;;5360:117;5516:2;5542:50;5584:7;5575:6;5564:9;5560:22;5542:50;:::i;:::-;5532:60;;5487:115;5141:468;;;;;:::o;5615:77::-;5652:7;5681:5;5670:16;;5615:77;;;:::o;5698:122::-;5771:24;5789:5;5771:24;:::i;:::-;5764:5;5761:35;5751:63;;5810:1;5807;5800:12;5751:63;5698:122;:::o;5826:139::-;5872:5;5910:6;5897:20;5888:29;;5926:33;5953:5;5926:33;:::i;:::-;5826:139;;;;:::o;5971:77::-;6008:7;6037:5;6026:16;;5971:77;;;:::o;6054:122::-;6127:24;6145:5;6127:24;:::i;:::-;6120:5;6117:35;6107:63;;6166:1;6163;6156:12;6107:63;6054:122;:::o;6182:139::-;6228:5;6266:6;6253:20;6244:29;;6282:33;6309:5;6282:33;:::i;:::-;6182:139;;;;:::o;6327:1893::-;6521:6;6529;6537;6545;6553;6561;6569;6577;6585;6593;6642:3;6630:9;6621:7;6617:23;6613:33;6610:120;;;6649:79;;:::i;:::-;6610:120;6797:1;6786:9;6782:17;6769:31;6827:18;6819:6;6816:30;6813:117;;;6849:79;;:::i;:::-;6813:117;6962:80;7034:7;7025:6;7014:9;7010:22;6962:80;:::i;:::-;6944:98;;;;6740:312;7119:2;7108:9;7104:18;7091:32;7150:18;7142:6;7139:30;7136:117;;;7172:79;;:::i;:::-;7136:117;7285:80;7357:7;7348:6;7337:9;7333:22;7285:80;:::i;:::-;7267:98;;;;7062:313;7414:2;7440:53;7485:7;7476:6;7465:9;7461:22;7440:53;:::i;:::-;7430:63;;7385:118;7570:2;7559:9;7555:18;7542:32;7601:18;7593:6;7590:30;7587:117;;;7623:79;;:::i;:::-;7587:117;7736:80;7808:7;7799:6;7788:9;7784:22;7736:80;:::i;:::-;7718:98;;;;7513:313;7865:3;7892:53;7937:7;7928:6;7917:9;7913:22;7892:53;:::i;:::-;7882:63;;7836:119;7994:3;8021:53;8066:7;8057:6;8046:9;8042:22;8021:53;:::i;:::-;8011:63;;7965:119;8123:3;8150:53;8195:7;8186:6;8175:9;8171:22;8150:53;:::i;:::-;8140:63;;8094:119;6327:1893;;;;;;;;;;;;;:::o;8226:118::-;8313:24;8331:5;8313:24;:::i;:::-;8308:3;8301:37;8226:118;;:::o;8350:222::-;8443:4;8481:2;8470:9;8466:18;8458:26;;8494:71;8562:1;8551:9;8547:17;8538:6;8494:71;:::i;:::-;8350:222;;;;:::o;8578:323::-;8634:6;8683:2;8671:9;8662:7;8658:23;8654:32;8651:119;;;8689:79;;:::i;:::-;8651:119;8809:1;8834:50;8876:7;8867:6;8856:9;8852:22;8834:50;:::i;:::-;8824:60;;8780:114;8578:323;;;;:::o;8907:109::-;8988:21;9003:5;8988:21;:::i;:::-;8983:3;8976:34;8907:109;;:::o;9022:210::-;9109:4;9147:2;9136:9;9132:18;9124:26;;9160:65;9222:1;9211:9;9207:17;9198:6;9160:65;:::i;:::-;9022:210;;;;:::o;9238:1663::-;9405:6;9413;9421;9429;9437;9445;9453;9461;9469;9518:3;9506:9;9497:7;9493:23;9489:33;9486:120;;;9525:79;;:::i;:::-;9486:120;9673:1;9662:9;9658:17;9645:31;9703:18;9695:6;9692:30;9689:117;;;9725:79;;:::i;:::-;9689:117;9838:80;9910:7;9901:6;9890:9;9886:22;9838:80;:::i;:::-;9820:98;;;;9616:312;9995:2;9984:9;9980:18;9967:32;10026:18;10018:6;10015:30;10012:117;;;10048:79;;:::i;:::-;10012:117;10161:80;10233:7;10224:6;10213:9;10209:22;10161:80;:::i;:::-;10143:98;;;;9938:313;10290:2;10316:53;10361:7;10352:6;10341:9;10337:22;10316:53;:::i;:::-;10306:63;;10261:118;10418:2;10444:53;10489:7;10480:6;10469:9;10465:22;10444:53;:::i;:::-;10434:63;;10389:118;10546:3;10573:53;10618:7;10609:6;10598:9;10594:22;10573:53;:::i;:::-;10563:63;;10517:119;10675:3;10702:53;10747:7;10738:6;10727:9;10723:22;10702:53;:::i;:::-;10692:63;;10646:119;10804:3;10831:53;10876:7;10867:6;10856:9;10852:22;10831:53;:::i;:::-;10821:63;;10775:119;9238:1663;;;;;;;;;;;:::o;10907:474::-;10975:6;10983;11032:2;11020:9;11011:7;11007:23;11003:32;11000:119;;;11038:79;;:::i;:::-;11000:119;11158:1;11183:53;11228:7;11219:6;11208:9;11204:22;11183:53;:::i;:::-;11173:63;;11129:117;11285:2;11311:53;11356:7;11347:6;11336:9;11332:22;11311:53;:::i;:::-;11301:63;;11256:118;10907:474;;;;;:::o;11387:169::-;11471:11;11505:6;11500:3;11493:19;11545:4;11540:3;11536:14;11521:29;;11387:169;;;;:::o;11562:182::-;11702:34;11698:1;11690:6;11686:14;11679:58;11562:182;:::o;11750:366::-;11892:3;11913:67;11977:2;11972:3;11913:67;:::i;:::-;11906:74;;11989:93;12078:3;11989:93;:::i;:::-;12107:2;12102:3;12098:12;12091:19;;11750:366;;;:::o;12122:419::-;12288:4;12326:2;12315:9;12311:18;12303:26;;12375:9;12369:4;12365:20;12361:1;12350:9;12346:17;12339:47;12403:131;12529:4;12403:131;:::i;:::-;12395:139;;12122:419;;;:::o;12547:180::-;12595:77;12592:1;12585:88;12692:4;12689:1;12682:15;12716:4;12713:1;12706:15;12733:180;12781:77;12778:1;12771:88;12878:4;12875:1;12868:15;12902:4;12899:1;12892:15;12919:165;13059:17;13055:1;13047:6;13043:14;13036:41;12919:165;:::o;13090:366::-;13232:3;13253:67;13317:2;13312:3;13253:67;:::i;:::-;13246:74;;13329:93;13418:3;13329:93;:::i;:::-;13447:2;13442:3;13438:12;13431:19;;13090:366;;;:::o;13462:419::-;13628:4;13666:2;13655:9;13651:18;13643:26;;13715:9;13709:4;13705:20;13701:1;13690:9;13686:17;13679:47;13743:131;13869:4;13743:131;:::i;:::-;13735:139;;13462:419;;;:::o;13887:170::-;14027:22;14023:1;14015:6;14011:14;14004:46;13887:170;:::o;14063:366::-;14205:3;14226:67;14290:2;14285:3;14226:67;:::i;:::-;14219:74;;14302:93;14391:3;14302:93;:::i;:::-;14420:2;14415:3;14411:12;14404:19;;14063:366;;;:::o;14435:419::-;14601:4;14639:2;14628:9;14624:18;14616:26;;14688:9;14682:4;14678:20;14674:1;14663:9;14659:17;14652:47;14716:131;14842:4;14716:131;:::i;:::-;14708:139;;14435:419;;;:::o;14860:170::-;15000:22;14996:1;14988:6;14984:14;14977:46;14860:170;:::o;15036:366::-;15178:3;15199:67;15263:2;15258:3;15199:67;:::i;:::-;15192:74;;15275:93;15364:3;15275:93;:::i;:::-;15393:2;15388:3;15384:12;15377:19;;15036:366;;;:::o;15408:419::-;15574:4;15612:2;15601:9;15597:18;15589:26;;15661:9;15655:4;15651:20;15647:1;15636:9;15632:17;15625:47;15689:131;15815:4;15689:131;:::i;:::-;15681:139;;15408:419;;;:::o;15833:178::-;15973:30;15969:1;15961:6;15957:14;15950:54;15833:178;:::o;16017:366::-;16159:3;16180:67;16244:2;16239:3;16180:67;:::i;:::-;16173:74;;16256:93;16345:3;16256:93;:::i;:::-;16374:2;16369:3;16365:12;16358:19;;16017:366;;;:::o;16389:419::-;16555:4;16593:2;16582:9;16578:18;16570:26;;16642:9;16636:4;16632:20;16628:1;16617:9;16613:17;16606:47;16670:131;16796:4;16670:131;:::i;:::-;16662:139;;16389:419;;;:::o;16814:184::-;16913:11;16947:6;16942:3;16935:19;16987:4;16982:3;16978:14;16963:29;;16814:184;;;;:::o;17004:117::-;17113:1;17110;17103:12;17127:154;17211:6;17206:3;17201;17188:30;17273:1;17264:6;17259:3;17255:16;17248:27;17127:154;;;:::o;17317:537::-;17445:3;17466:86;17545:6;17540:3;17466:86;:::i;:::-;17459:93;;17576:66;17568:6;17565:78;17562:165;;;17646:79;;:::i;:::-;17562:165;17758:4;17750:6;17746:17;17736:27;;17773:43;17809:6;17804:3;17797:5;17773:43;:::i;:::-;17841:6;17836:3;17832:16;17825:23;;17317:537;;;;;:::o;17860:118::-;17947:24;17965:5;17947:24;:::i;:::-;17942:3;17935:37;17860:118;;:::o;17984:1177::-;18369:4;18407:3;18396:9;18392:19;18384:27;;18457:9;18451:4;18447:20;18443:1;18432:9;18428:17;18421:47;18485:118;18598:4;18589:6;18581;18485:118;:::i;:::-;18477:126;;18650:9;18644:4;18640:20;18635:2;18624:9;18620:18;18613:48;18678:118;18791:4;18782:6;18774;18678:118;:::i;:::-;18670:126;;18806:72;18874:2;18863:9;18859:18;18850:6;18806:72;:::i;:::-;18925:9;18919:4;18915:20;18910:2;18899:9;18895:18;18888:48;18953:118;19066:4;19057:6;19049;18953:118;:::i;:::-;18945:126;;19081:73;19149:3;19138:9;19134:19;19125:6;19081:73;:::i;:::-;17984:1177;;;;;;;;;;;:::o;19167:167::-;19307:19;19303:1;19295:6;19291:14;19284:43;19167:167;:::o;19340:366::-;19482:3;19503:67;19567:2;19562:3;19503:67;:::i;:::-;19496:74;;19579:93;19668:3;19579:93;:::i;:::-;19697:2;19692:3;19688:12;19681:19;;19340:366;;;:::o;19712:419::-;19878:4;19916:2;19905:9;19901:18;19893:26;;19965:9;19959:4;19955:20;19951:1;19940:9;19936:17;19929:47;19993:131;20119:4;19993:131;:::i;:::-;19985:139;;19712:419;;;:::o;20137:171::-;20277:23;20273:1;20265:6;20261:14;20254:47;20137:171;:::o;20314:366::-;20456:3;20477:67;20541:2;20536:3;20477:67;:::i;:::-;20470:74;;20553:93;20642:3;20553:93;:::i;:::-;20671:2;20666:3;20662:12;20655:19;;20314:366;;;:::o;20686:419::-;20852:4;20890:2;20879:9;20875:18;20867:26;;20939:9;20933:4;20929:20;20925:1;20914:9;20910:17;20903:47;20967:131;21093:4;20967:131;:::i;:::-;20959:139;;20686:419;;;:::o;21111:165::-;21251:17;21247:1;21239:6;21235:14;21228:41;21111:165;:::o;21282:366::-;21424:3;21445:67;21509:2;21504:3;21445:67;:::i;:::-;21438:74;;21521:93;21610:3;21521:93;:::i;:::-;21639:2;21634:3;21630:12;21623:19;;21282:366;;;:::o;21654:419::-;21820:4;21858:2;21847:9;21843:18;21835:26;;21907:9;21901:4;21897:20;21893:1;21882:9;21878:17;21871:47;21935:131;22061:4;21935:131;:::i;:::-;21927:139;;21654:419;;;:::o;22079:784::-;22348:4;22386:2;22375:9;22371:18;22363:26;;22399:71;22467:1;22456:9;22452:17;22443:6;22399:71;:::i;:::-;22517:9;22511:4;22507:20;22502:2;22491:9;22487:18;22480:48;22545:118;22658:4;22649:6;22641;22545:118;:::i;:::-;22537:126;;22710:9;22704:4;22700:20;22695:2;22684:9;22680:18;22673:48;22738:118;22851:4;22842:6;22834;22738:118;:::i;:::-;22730:126;;22079:784;;;;;;;;:::o;22869:1006::-;23194:4;23232:3;23221:9;23217:19;23209:27;;23282:9;23276:4;23272:20;23268:1;23257:9;23253:17;23246:47;23310:118;23423:4;23414:6;23406;23310:118;:::i;:::-;23302:126;;23475:9;23469:4;23465:20;23460:2;23449:9;23445:18;23438:48;23503:118;23616:4;23607:6;23599;23503:118;:::i;:::-;23495:126;;23631:72;23699:2;23688:9;23684:18;23675:6;23631:72;:::i;:::-;23713;23781:2;23770:9;23766:18;23757:6;23713:72;:::i;:::-;23795:73;23863:3;23852:9;23848:19;23839:6;23795:73;:::i;:::-;22869:1006;;;;;;;;;;:::o;23881:225::-;24021:34;24017:1;24009:6;24005:14;23998:58;24090:8;24085:2;24077:6;24073:15;24066:33;23881:225;:::o;24112:366::-;24254:3;24275:67;24339:2;24334:3;24275:67;:::i;:::-;24268:74;;24351:93;24440:3;24351:93;:::i;:::-;24469:2;24464:3;24460:12;24453:19;;24112:366;;;:::o;24484:419::-;24650:4;24688:2;24677:9;24673:18;24665:26;;24737:9;24731:4;24727:20;24723:1;24712:9;24708:17;24701:47;24765:131;24891:4;24765:131;:::i;:::-;24757:139;;24484:419;;;:::o;24909:180::-;24957:77;24954:1;24947:88;25054:4;25051:1;25044:15;25078:4;25075:1;25068:15;25095:305;25135:3;25154:20;25172:1;25154:20;:::i;:::-;25149:25;;25188:20;25206:1;25188:20;:::i;:::-;25183:25;;25342:1;25274:66;25270:74;25267:1;25264:81;25261:107;;;25348:18;;:::i;:::-;25261:107;25392:1;25389;25385:9;25378:16;;25095:305;;;;:::o;25406:180::-;25454:77;25451:1;25444:88;25551:4;25548:1;25541:15;25575:4;25572:1;25565:15;25592:174;25732:26;25728:1;25720:6;25716:14;25709:50;25592:174;:::o;25772:366::-;25914:3;25935:67;25999:2;25994:3;25935:67;:::i;:::-;25928:74;;26011:93;26100:3;26011:93;:::i;:::-;26129:2;26124:3;26120:12;26113:19;;25772:366;;;:::o;26144:419::-;26310:4;26348:2;26337:9;26333:18;26325:26;;26397:9;26391:4;26387:20;26383:1;26372:9;26368:17;26361:47;26425:131;26551:4;26425:131;:::i;:::-;26417:139;;26144:419;;;:::o;26569:181::-;26709:33;26705:1;26697:6;26693:14;26686:57;26569:181;:::o;26756:366::-;26898:3;26919:67;26983:2;26978:3;26919:67;:::i;:::-;26912:74;;26995:93;27084:3;26995:93;:::i;:::-;27113:2;27108:3;27104:12;27097:19;;26756:366;;;:::o;27128:419::-;27294:4;27332:2;27321:9;27317:18;27309:26;;27381:9;27375:4;27371:20;27367:1;27356:9;27352:17;27345:47;27409:131;27535:4;27409:131;:::i;:::-;27401:139;;27128:419;;;:::o;27553:221::-;27693:34;27689:1;27681:6;27677:14;27670:58;27762:4;27757:2;27749:6;27745:15;27738:29;27553:221;:::o;27780:366::-;27922:3;27943:67;28007:2;28002:3;27943:67;:::i;:::-;27936:74;;28019:93;28108:3;28019:93;:::i;:::-;28137:2;28132:3;28128:12;28121:19;;27780:366;;;:::o;28152:419::-;28318:4;28356:2;28345:9;28341:18;28333:26;;28405:9;28399:4;28395:20;28391:1;28380:9;28376:17;28369:47;28433:131;28559:4;28433:131;:::i;:::-;28425:139;;28152:419;;;:::o;28577:221::-;28717:34;28713:1;28705:6;28701:14;28694:58;28786:4;28781:2;28773:6;28769:15;28762:29;28577:221;:::o;28804:366::-;28946:3;28967:67;29031:2;29026:3;28967:67;:::i;:::-;28960:74;;29043:93;29132:3;29043:93;:::i;:::-;29161:2;29156:3;29152:12;29145:19;;28804:366;;;:::o;29176:419::-;29342:4;29380:2;29369:9;29365:18;29357:26;;29429:9;29423:4;29419:20;29415:1;29404:9;29400:17;29393:47;29457:131;29583:4;29457:131;:::i;:::-;29449:139;;29176:419;;;:::o;29601:118::-;29688:24;29706:5;29688:24;:::i;:::-;29683:3;29676:37;29601:118;;:::o;29725:86::-;29760:7;29800:4;29793:5;29789:16;29778:27;;29725:86;;;:::o;29817:112::-;29900:22;29916:5;29900:22;:::i;:::-;29895:3;29888:35;29817:112;;:::o;29935:545::-;30108:4;30146:3;30135:9;30131:19;30123:27;;30160:71;30228:1;30217:9;30213:17;30204:6;30160:71;:::i;:::-;30241:68;30305:2;30294:9;30290:18;30281:6;30241:68;:::i;:::-;30319:72;30387:2;30376:9;30372:18;30363:6;30319:72;:::i;:::-;30401;30469:2;30458:9;30454:18;30445:6;30401:72;:::i;:::-;29935:545;;;;;;;:::o

ipfs://7bdef281a4eff71706bebad8b32f0e6185c2247438860f66e196579a0a11961b