Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";

import "./IAccessControlled.sol";
import "../Roles.sol";
import "../IACL.sol";

/// @notice Modifier provider for contracts that want to interact with the ACL contract.
abstract contract AccessControlledUpgradeable is IAccessControlled, ContextUpgradeable {
    bytes32 private constant _ACL_SLOT = bytes32(uint256(keccak256("zee-game.acl.slot")) - 1);

    modifier onlyRole(bytes32 role) {
        _getAcl().checkRole(role, _msgSender());
        _;
    }

    /// @dev Modifier to make a function callable by the admin account.
    modifier onlyAdmin() {
        _getAcl().checkRole(Roles.ADMIN, _msgSender());
        _;
    }

    /// @dev Modifier to make a function callable by a supervisor account.
    modifier onlyMaintainer() {
        _getAcl().checkRole(Roles.MAINTAINER, _msgSender());
        _;
    }

    function __AccessControlled_init(address acl) internal onlyInitializing {
        // solhint-disable-previous-line func-name-mixedcase
        // TODO check ACL interface
        StorageSlot.getAddressSlot(_ACL_SLOT).value = acl;
    }

    /// @inheritdoc IAccessControlled
    function getACL() external view returns (address) {
        // solhint-disable-previous-line ordering
        return address(_getAcl());
    }

    /// @dev return the IACL address
    function _getAcl() internal view returns (IACL) {
        return IACL(StorageSlot.getAddressSlot(_ACL_SLOT).value);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

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

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

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

/// @notice Access Control List contract interface.
interface IAccessControlled {
    /// @notice Get the ACL contract address.
    /// @return The ACL contract address.
    function getACL() external view returns (address);
}

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

/// @notice Different role definitions used by the ACL contract.
library Roles {
    /// @dev This maps directly to the OpenZeppelins AccessControl DEFAULT_ADMIN
    bytes32 public constant ADMIN = 0x00;

    /// @dev The Maintainer role. Can execute Maintainer-only tasks.
    bytes32 public constant MAINTAINER = keccak256("MAINTAINER_ROLE");

    /// @dev The NFT owner role. Can execute NFT-only tasks.
    bytes32 public constant NFT_OWNER = keccak256("NFT_OWNER");

    /// @dev The auxiliary contracts that can perform cross-calls with one another.
    // TODO: segregate these into a smaller roles.
    bytes32 public constant AUXILIARY_CONTRACTS = keccak256("AUXILIARY_CONTRACTS");

    /// @dev The Fragment mini-game burn permission
    bytes32 public constant FRAGMENT_MINI_GAME_BURN = keccak256("FRAGMENT_MINI_GAME_BURN");

    /// @dev The Zee NFT mint permission
    bytes32 public constant ZEE_NFT_MINT = keccak256("ZEE_NFT_MINT");

    /// @dev The Zee NFT burn permission
    bytes32 public constant ZEE_NFT_BURN = keccak256("ZEE_NFT_BURN");
}

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

import "@openzeppelin/contracts-upgradeable/access/IAccessControlEnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol";

/// @notice Access Control List contract interface.
interface IACL is IAccessControlEnumerableUpgradeable {
    error RolesContractIncorrectlyConfigured();
    error CannotHaveMoreThanOneAddressInRole();
    error CannotRemoveLastAdmin();

    /// @notice revert if the `account` does not have the specified role.
    /// @param role the role specifier.
    /// @param account the address to check the role for.
    function checkRole(bytes32 role, address account) external view;

    /// @notice Get the admin role describing bytes.
    /// @return role bytes.
    function getAdminRole() external pure returns (bytes32);

    /// @notice Get the maintainer role describing bytes.
    /// @return role bytes.
    function getMaintainerRole() external pure returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
     */
    modifier initializer() {
        bool isTopLevelCall = _setInitializedVersion(1);
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
     * initialization step. This is essential to configure modules that are added through upgrades and that require
     * initialization.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     */
    modifier reinitializer(uint8 version) {
        bool isTopLevelCall = _setInitializedVersion(version);
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(version);
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     */
    function _disableInitializers() internal virtual {
        _setInitializedVersion(type(uint8).max);
    }

    function _setInitializedVersion(uint8 version) private returns (bool) {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, and for the lowest level
        // of initializers, because in other contexts the contract may have been reentered.
        if (_initializing) {
            require(
                version == 1 && !AddressUpgradeable.isContract(address(this)),
                "Initializable: contract is already initialized"
            );
            return false;
        } else {
            require(_initialized < version, "Initializable: contract is already initialized");
            _initialized = version;
            return true;
        }
    }
}

// SPDX-License-Identifier: MIT
// 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 AddressUpgradeable {
    /**
     * @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 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);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)

pragma solidity ^0.8.0;

import "./IAccessControlUpgradeable.sol";

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerableUpgradeable is IAccessControlUpgradeable {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// 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 IERC165Upgradeable {
    /**
     * @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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableMapUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155BurnableUpgradeable.sol";

import "../acl/access-controlled/AccessControlledUpgradeable.sol";
import "../common/BlockAware.sol";
import "./IFragmentMiniGame.sol";
import "./FragmentMiniGameStorage.sol";
import "./FragmentMiniGameUtils.sol";

contract FragmentMiniGame is
    IFragmentMiniGame,
    ERC1155Upgradeable,
    ERC1155BurnableUpgradeable,
    UUPSUpgradeable,
    AccessControlledUpgradeable,
    BlockAware,
    FragmentMiniGameStorage
{
    using EnumerableMapUpgradeable for EnumerableMapUpgradeable.Bytes32ToBytes32Map;
    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;
    using FragmentMiniGameUtils for FragmentGroup;
    using FragmentMiniGameUtils for bytes16;
    using FragmentMiniGameUtils for string;
    using FragmentMiniGameUtils for uint256;
    using FragmentMiniGameUtils for bytes32;
    using StringsUpgradeable for uint256;

    /// @dev Modifier for making sure that the group does not exist.
    modifier whenGroupDoesNotExist(string memory groupName) {
        bytes16 groupId = groupName.toGroupId();
        _checkGroupDoesNotExist(groupId);

        _;
    }

    /// @dev Modifier for making sure that the fragment group exists.
    modifier whenFragmentGroupExists(string memory groupName) {
        bytes16 groupId = groupName.toGroupId();
        _checkFragmentGroupExists(groupId);

        _;
    }

    /// @dev Modifier for making sure that the object group exists.
    modifier whenObjectGroupExists(string memory groupName) {
        bytes16 groupId = groupName.toGroupId();
        _checkObjectGroupExists(groupId);

        _;
    }

    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializer {
        // solhint-disable-previous-line no-empty-blocks
    }

    // solhint-disable-next-line comprehensive-interface
    function initialize(
        address acl,
        string calldata baseUri,
        string calldata name_,
        string calldata symbol_
    ) external initializer {
        __BlockAware_init();
        __UUPSUpgradeable_init();
        __AccessControlled_init(acl);
        __ERC1155_init(baseUri);

        // Set metadata
        _name = name_;
        _symbol = symbol_;

        // Set the base URI
        _setBaseURI(baseUri);
    }

    /// @inheritdoc IFragmentMiniGame
    function setBaseURI(string calldata baseUri) external override onlyMaintainer {
        _setBaseURI(baseUri);
    }

    /// @inheritdoc IFragmentMiniGame
    function registerFragmentGroup(
        string calldata groupName,
        uint128[] calldata fragmentSupply,
        bytes32 secretHash,
        uint128 accountCap
    ) external override onlyMaintainer whenGroupDoesNotExist(groupName) {
        // Construct the real group ID
        bytes16 groupId = groupName.toGroupId();

        // Make sure that neither a fragment group nor an object group is registered under the same group id!
        if (accountCap == 0) revert AccountCapCannotBeZero();

        // Make sure that the group secret hash is unique
        FragmentGroup storage fragmentGroup = _fragmentGroups[groupId];
        if (_fragmentGroupIds[secretHash] != bytes16(0)) revert FragmentSecretAlreadyRegistered();

        // Associate the secret with the group id
        _fragmentGroupIds[secretHash] = groupId;

        // Associate the the group id with the group type
        _registeredGroups[groupId] = GroupType.Fragment;

        // Instantiate the fragment groups
        fragmentGroup.secretHash = secretHash;
        fragmentGroup.accountCap = accountCap;
        fragmentGroup.size = uint128(fragmentSupply.length);
        for (uint128 index = 0; index < fragmentSupply.length; index++) {
            if (fragmentSupply[index] == 0) revert FragmentSupplyMustBeGreaterThanZero();
            fragmentGroup.supply[index] = FragmentMiniGameUtils.toFragmentSupply(
                fragmentSupply[index],
                fragmentSupply[index]
            );
        }

        emit FragmentGroupRegistered(groupId);
    }

    /// @inheritdoc IFragmentMiniGame
    /// @dev Never post the `mintingRequirements` with duplicate tokenIds! That will result in undefined behaviour!
    function registerObjectGroup(string calldata groupName, MintRequirement[] calldata mintingRequirements)
        external
        override
        onlyMaintainer
        whenGroupDoesNotExist(groupName)
    {
        // Construct the real group ID
        bytes16 groupId = groupName.toGroupId();

        // Associate the the group id with the group type
        _registeredGroups[groupId] = GroupType.Object;

        // Instantiate the object group
        ObjectGroup storage objectGroup = _objectGroups[groupId];
        for (uint256 index = 0; index < mintingRequirements.length; index++) {
            uint256 tokenId = mintingRequirements[index].tokenId;
            (bytes16 dependantGroupId, uint128 tokenIndex) = parseTokenId(tokenId);

            // Make sure that the dependant groups token id is valid
            GroupType gt = _registeredGroups[dependantGroupId];

            // Depends on a fragment group.
            if (gt == GroupType.Fragment) {
                _checkFragmentGroupExists(dependantGroupId);
                _fragmentGroups[dependantGroupId].canProvideToken(
                    dependantGroupId,
                    tokenIndex,
                    mintingRequirements[index].necessaryTokenCount
                );
            }
            // Depends on an object group.
            else if (gt == GroupType.Object) {
                if (tokenIndex != 0) revert UnsupportedTokenIndex(dependantGroupId, tokenIndex);
                _checkObjectGroupExists(dependantGroupId);
            }
            // Group type is not supported.
            else {
                revert GroupDoesNotExist(dependantGroupId);
            }

            bytes32 necessaryNumber = bytes32(uint256(mintingRequirements[index].necessaryTokenCount));
            bytes32 tokenIdKey = bytes32(tokenId);
            objectGroup.mintingRequirements.set(tokenIdKey, necessaryNumber);
        }

        emit ObjectGroupRegistered(groupId);
    }

    /// @inheritdoc IFragmentMiniGame
    function deregisterGroup(string calldata groupName) external override onlyMaintainer {
        // Construct the real group ID
        bytes16 groupId = groupName.toGroupId();

        // Make sure that the dependant groups token id is valid
        GroupType gt = _registeredGroups[groupId];

        // We need to clear up a fragment group.
        if (gt == GroupType.Fragment) {
            FragmentGroup storage fg = _fragmentGroups[groupId];

            for (uint128 index = 0; index < fg.size; index++) {
                delete fg.supply[index];
                // NOTE: not clearing `fragmentCount` because we don't know the keys!
            }
            delete _fragmentGroupIds[fg.secretHash];
            delete _fragmentGroups[groupId];
        }
        // We need to clear up an object group
        else if (gt == GroupType.Object) {
            delete _objectGroups[groupId];
        } else {
            revert GroupDoesNotExist(groupId);
        }

        _registeredGroups[groupId] = GroupType.Unregistered;
        emit GroupDeregistered(groupId);
    }

    /// @inheritdoc IFragmentMiniGame
    function discover(string calldata fragmentSecret) external override {
        bytes32 secret = keccak256(abi.encodePacked(fragmentSecret));

        // Retrieve the group id from the secret
        bytes16 groupId = _fragmentGroupIds[secret];
        _checkFragmentGroupExists(groupId);
        FragmentGroup storage fg = _fragmentGroups[groupId];

        // Assert that the account can still mint
        if (fg.fragmentCount[msg.sender] >= fg.accountCap) revert MintingCapReached(msg.sender, groupId, fg.accountCap);

        // Determine which token index to mint
        uint256 sourceOfRandomness = uint256(
            keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp, msg.sender))
        );
        uint128 index = uint128(sourceOfRandomness % fg.size);

        for (uint128 i = 0; i < fg.size; i++) {
            index = (index + 1) % fg.size;

            // Assert that there's still supply left to be minted.
            (uint128 supplyLeft, uint128 totalSupply) = fg.supply[index].deconstructFragmentSupply();
            if (supplyLeft == 0) continue;

            // Update the contracts mint state.
            fg.supply[index] = FragmentMiniGameUtils.toFragmentSupply(supplyLeft - 1, totalSupply);
            fg.fragmentCount[msg.sender] += 1;

            // Mint the Fragment NFT.
            uint256 tokenId = groupId.toFragmentTokenId(index);
            _mint(msg.sender, tokenId, 1, new bytes(0));

            emit FragmentMinted(msg.sender, tokenId);
            return; // Early return if we have minted the token
        }

        // Revert in a case where we cannot mint any token.
        revert AllItemsDiscovered(groupId);
    }

    /// @inheritdoc IFragmentMiniGame
    function collect(string calldata groupName) external override whenObjectGroupExists(groupName) {
        bytes16 groupId = groupName.toGroupId();

        ObjectGroup storage og = _objectGroups[groupId];
        bytes32[] memory childTokenIds = og.mintingRequirements._keys.values();

        // iterate over all token ids and check if the user has enough of them
        for (uint256 index = 0; index < childTokenIds.length; index++) {
            bytes32 tokenIdKey = childTokenIds[index];
            uint256 amountToBurn = uint256(og.mintingRequirements.get(tokenIdKey));

            // NOTE: the balance is already checked in the `_burn` function
            _burn(msg.sender, uint256(tokenIdKey), amountToBurn);
        }

        // Mint the object NFT
        uint256 objectTokenId = groupId.toObjectTokenId();
        _mint(msg.sender, objectTokenId, 1, new bytes(0));

        emit ObjectMinted(msg.sender, objectTokenId);
    }

    /// @inheritdoc IFragmentMiniGame
    function canCollect(address account, string calldata groupName)
        external
        view
        override
        whenObjectGroupExists(groupName)
        returns (bool)
    {
        bytes16 groupId = groupName.toGroupId();

        // Retrieve the object group
        ObjectGroup storage og = _objectGroups[groupId];
        bytes32[] memory childTokenIds = og.mintingRequirements._keys.values();

        // iterate over all token ids and check if the user has enough of them
        for (uint256 index = 0; index < childTokenIds.length; index++) {
            bytes32 tokenIdKey = childTokenIds[index];
            uint256 amountToBurn = uint256(og.mintingRequirements.get(tokenIdKey));

            if (balanceOf(account, uint256(tokenIdKey)) < amountToBurn) return false;
        }

        return true;
    }

    /// @inheritdoc IFragmentMiniGame
    function getFragmentGroup(string calldata groupName)
        external
        view
        override
        whenFragmentGroupExists(groupName)
        returns (
            bytes16 groupId,
            bytes32 secretHash,
            uint256[] memory tokenIds,
            uint128[] memory supplyLeft,
            uint128[] memory totalSupply
        )
    {
        // Retrieve the fragment group
        groupId = groupName.toGroupId();
        FragmentGroup storage fg = _fragmentGroups[groupId];

        // Populate the response
        secretHash = fg.secretHash;
        tokenIds = new uint256[](fg.size);
        supplyLeft = new uint128[](fg.size);
        totalSupply = new uint128[](fg.size);
        for (uint128 index = 0; index < fg.size; index++) {
            uint256 tokenId = groupId.toFragmentTokenId(index);
            (uint128 iSupplyLeft, uint128 iTotalSupply) = fg.supply[index].deconstructFragmentSupply();

            tokenIds[index] = tokenId;
            supplyLeft[index] = iSupplyLeft;
            totalSupply[index] = iTotalSupply;
        }
    }

    /// @inheritdoc IFragmentMiniGame
    function name() external view override returns (string memory) {
        return _name;
    }

    /// @inheritdoc IFragmentMiniGame
    function symbol() external view override returns (string memory) {
        return _symbol;
    }

    /// @inheritdoc IFragmentMiniGame
    function owner() external view override returns (address) {
        return _getAcl().getRoleMember(Roles.NFT_OWNER, 0);
    }

    /// @inheritdoc IFragmentMiniGame
    function getMintedFragmentsCount(string calldata groupName, address account)
        external
        view
        override
        whenFragmentGroupExists(groupName)
        returns (uint256)
    {
        // Retrieve the group
        bytes16 groupId = groupName.toGroupId();
        FragmentGroup storage fg = _fragmentGroups[groupId];

        // Return the response
        return fg.fragmentCount[account];
    }

    /// @inheritdoc IFragmentMiniGame
    function getObjectGroup(string calldata groupName)
        external
        view
        override
        whenObjectGroupExists(groupName)
        returns (
            bytes16 groupId,
            uint256 tokenId,
            MintRequirement[] memory mintingRequirements
        )
    {
        // Retrieve the group
        groupId = groupName.toGroupId();
        ObjectGroup storage og = _objectGroups[groupId];

        // Get all token dependencies
        bytes32[] memory childTokenIds = og.mintingRequirements._keys.values();

        // Populate the response
        tokenId = groupId.toObjectTokenId();
        mintingRequirements = new MintRequirement[](childTokenIds.length);

        // Iterate over all of the keys (token Ids) and retrieve the necessary token count
        for (uint256 index = 0; index < childTokenIds.length; index++) {
            uint128 necessaryTokenCount = uint128(uint256(og.mintingRequirements.get(childTokenIds[index])));
            mintingRequirements[index] = MintRequirement({
                tokenId: uint256(childTokenIds[index]),
                necessaryTokenCount: necessaryTokenCount
            });
        }
    }

    /// @inheritdoc IFragmentMiniGame
    function constructTokenId(string calldata groupName, uint128 tokenIndex) external pure override returns (uint256) {
        return groupName.toGroupId().toFragmentTokenId(tokenIndex);
    }

    /// @inheritdoc IFragmentMiniGame
    function constructGroupId(string calldata groupName) external pure override returns (bytes16) {
        return groupName.toGroupId();
    }

    /// @inheritdoc IFragmentMiniGame
    function burn(
        address from,
        uint256 tokenId,
        uint256 amount
    ) public override(ERC1155BurnableUpgradeable, IFragmentMiniGame) onlyRole(Roles.FRAGMENT_MINI_GAME_BURN) {
        ERC1155BurnableUpgradeable.burn(from, tokenId, amount);
    }

    /// @inheritdoc IFragmentMiniGame
    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory values
    ) public override(ERC1155BurnableUpgradeable, IFragmentMiniGame) onlyRole(Roles.FRAGMENT_MINI_GAME_BURN) {
        ERC1155BurnableUpgradeable.burnBatch(account, ids, values);
    }

    /// @inheritdoc ERC1155Upgradeable
    function uri(uint256 tokenId) public view override returns (string memory) {
        return string(abi.encodePacked(super.uri(tokenId), tokenId.toString()));
    }

    /// @inheritdoc ERC165Upgradeable
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IFragmentMiniGame).interfaceId || super.supportsInterface(interfaceId);
    }

    /// @inheritdoc IFragmentMiniGame
    function parseTokenId(uint256 tokenId) public pure override returns (bytes16 groupId, uint128 tokenIndex) {
        // when converting bytes32 to bytes16, the first 16 bytes get saved, the last 16 get dropped
        groupId = bytes16(bytes32(tokenId));
        // when converting uint256 to uint128, the first 16 bytes get dropped, the last 16 get saved
        tokenIndex = uint128(tokenId);
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyAdmin {
        // solhint-disable-previous-line no-empty-blocks
    }

    /// @dev set the base URI and emit an event.
    function _setBaseURI(string calldata baseUri) internal {
        _setURI(baseUri);

        emit UriSet(baseUri);
    }

    /// @notice Assert that an group does not exist with a given groupId.
    /// @param groupId The group ID that we want to query.
    function _checkGroupDoesNotExist(bytes16 groupId) internal view {
        if (_registeredGroups[groupId] != GroupType.Unregistered) revert GroupShouldNotExist(groupId);
    }

    /// @notice Assert that an fragment group either exists with the provided groupId.
    /// @param groupId The group ID that we want to query.
    function _checkFragmentGroupExists(bytes16 groupId) internal view {
        if (_registeredGroups[groupId] != GroupType.Fragment) revert FragmentGroupShouldExist(groupId);
    }

    /// @notice Assert that an object group either exists with the provided groupId.
    /// @param groupId The group ID that we want to query.
    function _checkObjectGroupExists(bytes16 groupId) internal view {
        if (_registeredGroups[groupId] != GroupType.Object) revert ObjectGroupShouldExist(groupId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import "./Initializable.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 *
 * _Available since v4.1._
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
    address private immutable __self = address(this);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        require(_getImplementation() == __self, "Function must be called through active proxy");
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
        _;
    }

    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate that the this implementation remains valid after an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
        return _IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     */
    function upgradeTo(address newImplementation) external virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeTo} and {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal override onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/EnumerableMap.sol)

pragma solidity ^0.8.0;

import "./EnumerableSetUpgradeable.sol";

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * The following map types are supported:
 *
 * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
 * - `address -> uint256` (`AddressToUintMap`) since v4.6.0
 * - `bytes32 -> bytes32` (`Bytes32ToBytes32`) since v4.6.0
 */
library EnumerableMapUpgradeable {
    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;

    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct Bytes32ToBytes32Map {
        // Storage of keys
        EnumerableSetUpgradeable.Bytes32Set _keys;
        mapping(bytes32 => bytes32) _values;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        Bytes32ToBytes32Map storage map,
        bytes32 key,
        bytes32 value
    ) internal returns (bool) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
        delete map._values[key];
        return map._keys.remove(key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
        return map._keys.contains(key);
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
        return map._keys.length();
    }

    /**
     * @dev Returns the key-value pair stored at position `index` in the map. O(1).
     *
     * Note that there are no guarantees on the ordering of entries inside the
     * array, and it may change when more entries are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
        bytes32 key = map._keys.at(index);
        return (key, map._values[key]);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key");
        return value;
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function get(
        Bytes32ToBytes32Map storage map,
        bytes32 key,
        string memory errorMessage
    ) internal view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || contains(map, key), errorMessage);
        return value;
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        UintToAddressMap storage map,
        uint256 key,
        address value
    ) internal returns (bool) {
        return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the set. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(
        UintToAddressMap storage map,
        uint256 key,
        string memory errorMessage
    ) internal view returns (address) {
        return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage))));
    }

    // AddressToUintMap

    struct AddressToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        AddressToUintMap storage map,
        address key,
        uint256 value
    ) internal returns (bool) {
        return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(AddressToUintMap storage map, address key) internal returns (bool) {
        return remove(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
        return contains(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(AddressToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the set. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (address(uint160(uint256(key))), uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(
        AddressToUintMap storage map,
        address key,
        string memory errorMessage
    ) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSetUpgradeable {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;

import "./IERC1155Upgradeable.sol";
import "./IERC1155ReceiverUpgradeable.sol";
import "./extensions/IERC1155MetadataURIUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
    using AddressUpgradeable for address;

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

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

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

    /**
     * @dev See {_setURI}.
     */
    function __ERC1155_init(string memory uri_) internal onlyInitializing {
        __ERC1155_init_unchained(uri_);
    }

    function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
        _setURI(uri_);
    }

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

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

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: 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;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not 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() || isApprovedForAll(from, _msgSender()),
            "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[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits 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;
        emit ApprovalForAll(owner, operator, approved);
    }

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

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

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155ReceiverUpgradeable.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 IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

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

        return array;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[47] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Burnable.sol)

pragma solidity ^0.8.0;

import "../ERC1155Upgradeable.sol";
import "../../../proxy/utils/Initializable.sol";

/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 *
 * _Available since v3.1._
 */
abstract contract ERC1155BurnableUpgradeable is Initializable, ERC1155Upgradeable {
    function __ERC1155Burnable_init() internal onlyInitializing {
    }

    function __ERC1155Burnable_init_unchained() internal onlyInitializing {
    }
    function burn(
        address account,
        uint256 id,
        uint256 value
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        _burn(account, id, value);
    }

    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory values
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        _burnBatch(account, ids, values);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "./IBlockAware.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

/// @notice The implementer contract will always know at which block it was created.
abstract contract BlockAware is IBlockAware, Initializable {
    bytes32 private constant _DEPLOYMENT_BLOCK_NUMBER_SLOT =
        bytes32(uint256(keccak256("zee-game.block-aware.deployment-block")) - 1);

    // solhint-disable-next-line func-name-mixedcase
    function __BlockAware_init() internal onlyInitializing {
        StorageSlot.getUint256Slot(_DEPLOYMENT_BLOCK_NUMBER_SLOT).value = block.number;
    }

    /// @inheritdoc IBlockAware
    function getDeploymentBlockNumber() external view returns (uint256) {
        // solhint-disable-previous-line ordering
        return StorageSlot.getUint256Slot(_DEPLOYMENT_BLOCK_NUMBER_SLOT).value;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

interface IFragmentMiniGame {
    /// @notice Emitted when a fragment group has been registered.
    event FragmentGroupRegistered(bytes16 groupId);

    /// @notice Emitted when an object group has been registered.
    event ObjectGroupRegistered(bytes16 groupId);

    /// @notice Emitted when a group has been deregistered.
    event GroupDeregistered(bytes16 groupId);

    /// @notice Emitted when the base URI has been set.
    event UriSet(string newUri);

    /// @notice Emitted when a fragment group has been minted.
    event FragmentMinted(address account, uint256 tokenId);

    /// @notice Emitted when an object group has been minted.
    event ObjectMinted(address account, uint256 tokenId);

    /// @notice Thrown when the Object group at a given groupId does not exist.
    error ObjectGroupShouldExist(bytes16 groupId);

    /// @notice Thrown when attempting to perform operations on a group that is not registered.
    error GroupDoesNotExist(bytes16 groupId);

    /// @notice Thrown when the group at a given groupId exists but it shouldn't.
    error GroupShouldNotExist(bytes16 groupId);

    /// @notice Thrown when the Fragment group at a given groupId does not exist.
    error FragmentGroupShouldExist(bytes16 groupId);

    /// @notice Thrown when expecting the group to have support for the tokenIndex but it does not support it.
    error UnsupportedTokenIndex(bytes16 groupId, uint128 tokenIndex);

    /// @notice Thrown when the max supply cannot be met for a given tokenId.
    error ImpossibleExpectedSupply(uint256 tokenId, uint256 necessarySupply);

    /// @notice Thrown when the fragment secret is already used for another fragment group.
    error FragmentSecretAlreadyRegistered();

    /// @notice Thrown when the supply of a fragment is larger than 0.
    error FragmentSupplyMustBeGreaterThanZero();

    /// @notice Thrown when the fragment groups account cap is specified at 0.
    error AccountCapCannotBeZero();

    /// @notice Thrown when all fragments have been already minted.
    error AllItemsDiscovered(bytes16 groupId);

    /// @notice Thrown when a user has minted the allowed amount of fragments in his a group.
    error MintingCapReached(address account, bytes16 groupId, uint256 accountCap);

    /// @notice Mint requirements are defined for object groups, they define the dependant
    ///         tokenIds and their corresponding amounts to be able to mint a given object NFT.
    struct MintRequirement {
        uint256 tokenId; // key
        uint128 necessaryTokenCount; // value
    }

    /// @notice Register a new Fragment group that can be discovered with a secret phrase.
    /// @param groupName A unique name for the group.
    /// @param fragmentSupply The amount of fragments that can be minted. The index of the item determines the token ID.
    /// @param secretHash The keccak256 hash of the secret that is used to discover the fragments.
    /// @param accountCap The maximum amount of fragments that can be minted by a single account.
    function registerFragmentGroup(
        string calldata groupName,
        uint128[] calldata fragmentSupply,
        bytes32 secretHash,
        uint128 accountCap
    ) external;

    /// @notice Register a new Object group that can created by owning all of the required tokenIds.
    /// @param groupName A unique name for the group.
    /// @param mintingRequirements The minting requirements for the group.
    function registerObjectGroup(string calldata groupName, MintRequirement[] calldata mintingRequirements) external;

    /// @notice Deregister a group.
    /// @param groupName The name of the group that already has been registered.
    function deregisterGroup(string calldata groupName) external;

    /// @notice Try to mint a new fragment NFT by providing a secret.
    /// @param fragmentSecret The secret phrase that is used to discover the fragments.
    function discover(string calldata fragmentSecret) external;

    /// @notice Combine all of the necessary fragments or subgroup NFTs to create an object NFT.
    /// @param groupName The name of the group for which we need to check the requirements and attempt to mint.
    function collect(string calldata groupName) external;

    /// @notice Set the base URI for the tokens.
    /// @param baseURI The base URI for the tokens.
    function setBaseURI(string calldata baseURI) external;

    /// @notice Get the name of the contract
    /// @return The name of the contract.
    function name() external view returns (string memory);

    /// @notice Get the symbol of the contract
    /// @return The symbol of the contract.
    function symbol() external view returns (string memory);

    /// @notice Get the owner of the contract.
    /// @return The owner of the contract.
    function owner() external view returns (address);

    /// @notice Check if the given account is able to mint the given object group.
    /// @param account The account that is trying to mint the object group.
    /// @param groupName The name of the group that is being minted.
    /// @return True if the NFT can be minted.
    function canCollect(address account, string calldata groupName) external view returns (bool);

    /// @notice Burn an arbitrary token.
    /// @param from Address of the account for which we want to burn the tokens.
    /// @param tokenId The tokenId of the token to burn.
    /// @param amount The amount of tokens that we want to burn.
    function burn(
        address from,
        uint256 tokenId,
        uint256 amount
    ) external;

    /// @notice Burn multiples of arbitrary tokens.
    /// @param account Address of the account for which we want to burn the tokens.
    /// @param ids The tokenIds of the tokens to burn.
    /// @param values The amounts of tokens that we want to burn, index corresponds to `ids`.
    function burnBatch(
        address account,
        uint256[] calldata ids,
        uint256[] calldata values
    ) external;

    /// @notice Retrieve information about a fragment group
    /// @param groupName The name of the group that we want to query.
    /// @return groupId The unique group identifier.
    /// @return secretHash The hash of the secret used for discovering items fom the group.
    /// @return tokenIds The tokenIds of the fragments in the group.
    /// @return supplyLeft The amount of fragments left to mint, index corresponds to `tokenIds`.
    /// @return totalSupply The total amount of fragments that can be minted, index corresponds to `tokenIds`.
    function getFragmentGroup(string calldata groupName)
        external
        view
        returns (
            bytes16 groupId,
            bytes32 secretHash,
            uint256[] memory tokenIds,
            uint128[] memory supplyLeft,
            uint128[] memory totalSupply
        );

    /// @notice Get the number of minted fragments for a given user account.
    /// @param groupName The name of the group that we want to query.
    /// @param account The address of the account for which we want to query the number of minted fragments.
    /// @return number The number of minted fragments for the given user account.
    function getMintedFragmentsCount(string calldata groupName, address account) external view returns (uint256);

    /// @notice Retrieve information about an Object group.
    /// @param groupName The name of the group that we want to query.
    /// @return groupId The unique group identifier.
    /// @return tokenId The tokenId that can be minted by the object group.
    /// @return mintingRequirements The minting requirements for the object group.
    function getObjectGroup(string calldata groupName)
        external
        view
        returns (
            bytes16 groupId,
            uint256 tokenId,
            MintRequirement[] calldata mintingRequirements
        );

    /// @notice construct the token id for a given group.
    /// @param groupName The name of the group that we want to query.
    /// @param tokenIndex The index of the token in the group.
    /// @return tokenId The tokenId of the token at the given index for the group.
    /// @dev if the group refers to an object group, the tokenIndex is `0`.
    function constructTokenId(string calldata groupName, uint128 tokenIndex) external pure returns (uint256);

    /// @notice construct the group id for a given group.
    /// @param groupName The name of the group that we want to query.
    /// @return groupId The groupId of the group.
    function constructGroupId(string calldata groupName) external pure returns (bytes16);

    /// @notice Deconstruct a token id into its sub-components.
    /// @param tokenId The tokenId that we want to deconstruct.
    /// @return groupId The groupId of the group retrieved from the tokenId.
    /// @return tokenIndex The index of the token retrieved from the tokenId.
    function parseTokenId(uint256 tokenId) external pure returns (bytes16 groupId, uint128 tokenIndex);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableMapUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";

abstract contract FragmentMiniGameStorage {
    using EnumerableMapUpgradeable for EnumerableMapUpgradeable.Bytes32ToBytes32Map;

    /// @dev represents a group of fragments
    struct FragmentGroup {
        bytes32 secretHash;
        uint128 accountCap;
        uint128 size;
        // Token Index => bytes32(uint128(supplyLeft), uint128(totalSupply))
        mapping(uint128 => bytes32) supply;
        // Account => already minted number of tokens
        mapping(address => uint256) fragmentCount;
    }

    /// @dev represents a single object group NFT
    struct ObjectGroup {
        // TokenID => amount of items needed to mint
        EnumerableMapUpgradeable.Bytes32ToBytes32Map mintingRequirements;
    }

    /// @dev represents the possible type of a group.
    enum GroupType {
        Unregistered,
        Fragment,
        Object
    }

    // Contract name
    string internal _name;
    // Contract symbol
    string internal _symbol;

    // Secret hash to group id (only for fragment groups)
    mapping(bytes32 => bytes16) internal _fragmentGroupIds;
    // Group id to fragment group
    mapping(bytes16 => FragmentGroup) internal _fragmentGroups;
    // Group id to object group
    mapping(bytes16 => ObjectGroup) internal _objectGroups;
    // Group id to group type
    mapping(bytes16 => GroupType) internal _registeredGroups;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "./IFragmentMiniGame.sol";
import "./FragmentMiniGameStorage.sol";

library FragmentMiniGameUtils {
    /// @dev Make sure that the given fragment group can provide the token at the desired token index.
    function canProvideToken(
        FragmentMiniGameStorage.FragmentGroup storage fg,
        bytes16 groupId,
        uint128 desiredTokenIndex,
        uint128 necessaryTokenCount
    ) internal view {
        (, uint128 totalSupply) = deconstructFragmentSupply(fg.supply[desiredTokenIndex]);

        // We're checking a case where the expected token desiredTokenIndex is not supported by the fragment group.
        if (fg.size <= desiredTokenIndex) revert IFragmentMiniGame.UnsupportedTokenIndex(groupId, desiredTokenIndex);
        if (totalSupply < necessaryTokenCount)
            revert IFragmentMiniGame.ImpossibleExpectedSupply(
                toFragmentTokenId(groupId, desiredTokenIndex),
                necessaryTokenCount
            );
    }

    function toGroupId(string memory group) internal pure returns (bytes16) {
        return bytes16(keccak256(bytes(group)));
    }

    function toFragmentTokenId(bytes16 groupId, uint128 tokenIndex) internal pure returns (uint256 tokenId) {
        return _constructTokenId(groupId, tokenIndex);
    }

    /// @dev Object groups will always use the index `0`
    function toObjectTokenId(bytes16 groupId) internal pure returns (uint256 tokenId) {
        return _constructTokenId(groupId, 0);
    }

    function toFragmentSupply(uint128 supplyLeft, uint128 totalSupply) internal pure returns (bytes32) {
        return bytes32((uint256(supplyLeft) << 128) + uint256(totalSupply));
    }

    function deconstructFragmentSupply(bytes32 fragmentSupply)
        internal
        pure
        returns (uint128 supplyLeft, uint128 totalSupply)
    {
        supplyLeft = uint128(uint256(fragmentSupply) >> 128);
        totalSupply = uint128(uint256(fragmentSupply));
    }

    function _constructTokenId(bytes16 groupId, uint128 tokenIndex) private pure returns (uint256 tokenId) {
        // when converting bytes16 to bytes32, the bytes get padded with zeros on the right side.
        tokenId += uint256(bytes32(groupId));
        // when converting uint128 to uint256, the number gets padded with zeros on the left side.
        tokenId += uint256(tokenIndex);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822ProxiableUpgradeable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeaconUpgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import "../utils/Initializable.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967UpgradeUpgradeable is Initializable {
    function __ERC1967Upgrade_init() internal onlyInitializing {
    }

    function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
    }
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            _functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
        }
    }

    /**
     * @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) private returns (bytes memory) {
        require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeaconUpgradeable {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlotUpgradeable {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165Upgradeable.sol";

/**
 * @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 IERC1155Upgradeable is IERC165Upgradeable {
    /**
     * @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;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
    /**
     * @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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

import "../IERC1155Upgradeable.sol";

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
    /**
     * @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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

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

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

/// @notice The implementer contract will always know at which block it was created.
interface IBlockAware {
    /// @notice Get deployment block number.
    function getDeploymentBlockNumber() external view returns (uint256);
}

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

import "../mini-game/FragmentMiniGame.sol";

/// @notice mock FragmentMiniGame implementation for testing purposes
contract TestFragmentMiniGameV2 is FragmentMiniGame {
    // solhint-disable-next-line comprehensive-interface
    function version() external pure returns (string memory) {
        return "V2";
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)

pragma solidity ^0.8.0;

import "./IAccessControlEnumerableUpgradeable.sol";
import "./AccessControlUpgradeable.sol";
import "../utils/structs/EnumerableSetUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerableUpgradeable, AccessControlUpgradeable {
    function __AccessControlEnumerable_init() internal onlyInitializing {
    }

    function __AccessControlEnumerable_init_unchained() internal onlyInitializing {
    }
    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;

    mapping(bytes32 => EnumerableSetUpgradeable.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";

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

    function __AccessControl_init_unchained() internal onlyInitializing {
    }
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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

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

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

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

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

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

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

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

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

        _revokeRole(role, account);
    }

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

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

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

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "../acl/IACL.sol";
import "../mini-game/IFragmentMiniGame.sol";

contract InterfacePrinter {
    function acl() external pure returns (bytes4) {
        // solhint-disable-previous-line comprehensive-interface
        return bytes4(type(IACL).interfaceId);
    }

    function fragmentMiniGame() external pure returns (bytes4) {
        // solhint-disable-previous-line comprehensive-interface
        return bytes4(type(IFragmentMiniGame).interfaceId);
    }
}

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

import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

import "./IACL.sol";
import "./Roles.sol";
import "../common/BlockAware.sol";

/// @title Access Control List contract
contract ACL is IACL, AccessControlEnumerableUpgradeable, UUPSUpgradeable, BlockAware {
    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializer {
        if (Roles.ADMIN != DEFAULT_ADMIN_ROLE) revert RolesContractIncorrectlyConfigured();
    }

    function initialize(address admin) external initializer {
        // solhint-disable-previous-line comprehensive-interface
        __UUPSUpgradeable_init();
        __AccessControlEnumerable_init();
        __BlockAware_init();

        // Set up roles
        _grantRole(Roles.ADMIN, admin);
    }

    /// @inheritdoc IACL
    function checkRole(bytes32 role, address account) external view override {
        _checkRole(role, account);
    }

    /// @inheritdoc IACL
    function getAdminRole() external pure override returns (bytes32) {
        return Roles.ADMIN;
    }

    /// @inheritdoc IACL
    function getMaintainerRole() external pure override returns (bytes32) {
        return Roles.MAINTAINER;
    }

    /// @inheritdoc AccessControlEnumerableUpgradeable
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // Explicitly declare which super-class to use
        return interfaceId == type(IACL).interfaceId || super.supportsInterface(interfaceId);
    }

    /// @inheritdoc AccessControlEnumerableUpgradeable
    function _grantRole(bytes32 role, address account) internal virtual override {
        if (role == Roles.NFT_OWNER && getRoleMemberCount(role) > 0) revert CannotHaveMoreThanOneAddressInRole();

        super._grantRole(role, account);
    }

    /// @inheritdoc AccessControlEnumerableUpgradeable
    function _revokeRole(bytes32 role, address account) internal virtual override {
        if (role == Roles.ADMIN && getRoleMemberCount(role) == 1) revert CannotRemoveLastAdmin();

        super._revokeRole(role, account);
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyRole(DEFAULT_ADMIN_ROLE) {
        // solhint-disable-previous-line no-empty-blocks
    }
}

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

import "../acl/ACL.sol";

/// @notice mock ACL implementation for testing purposes
contract TestACLV2 is ACL {
    // solhint-disable-next-line comprehensive-interface
    function version() external pure returns (string memory) {
        return "V2";
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol";
import "erc721a-upgradeable/contracts/extensions/ERC721ABurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

import "../acl/access-controlled/AccessControlledUpgradeable.sol";
import "../common/BlockAware.sol";
import "./IZeeNFT.sol";

contract ZeeNFT is
    IZeeNFT,
    UUPSUpgradeable,
    ERC721ABurnableUpgradeable,
    ERC721AQueryableUpgradeable,
    AccessControlledUpgradeable,
    BlockAware
{
    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializerERC721A {
        // solhint-disable-previous-line no-empty-blocks
    }

    // solhint-disable-next-line comprehensive-interface
    function initialize(address acl) external initializer initializerERC721A {
        __ERC721A_init("Zee NFT", "Zee");
        __BlockAware_init();
        __ERC721ABurnable_init();
        __ERC721AQueryable_init();
        __AccessControlled_init(acl);
    }

    function mint(address receiver, uint256 quantity) external override onlyRole(Roles.ZEE_NFT_MINT) {
        _safeMint(receiver, quantity);
    }

    function burn(uint256 tokenId) public override(ERC721ABurnableUpgradeable, IZeeNFT) onlyRole(Roles.ZEE_NFT_BURN) {
        _burn(tokenId);
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyAdmin {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import './IERC721AQueryableUpgradeable.sol';
import '../ERC721AUpgradeable.sol';
import '../ERC721A__Initializable.sol';

/**
 * @title ERC721A Queryable
 * @dev ERC721A subclass with convenience query functions.
 */
abstract contract ERC721AQueryableUpgradeable is
    ERC721A__Initializable,
    ERC721AUpgradeable,
    IERC721AQueryableUpgradeable
{
    function __ERC721AQueryable_init() internal onlyInitializingERC721A {
        __ERC721AQueryable_init_unchained();
    }

    function __ERC721AQueryable_init_unchained() internal onlyInitializingERC721A {}

    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *   - `addr` = `address(0)`
     *   - `startTimestamp` = `0`
     *   - `burned` = `false`
     *
     * If the `tokenId` is burned:
     *   - `addr` = `<Address of owner before token was burned>`
     *   - `startTimestamp` = `<Timestamp when token was burned>`
     *   - `burned = `true`
     *
     * Otherwise:
     *   - `addr` = `<Address of owner>`
     *   - `startTimestamp` = `<Timestamp of start of ownership>`
     *   - `burned = `false`
     */
    function explicitOwnershipOf(uint256 tokenId) public view override returns (TokenOwnership memory) {
        TokenOwnership memory ownership;
        if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
            return ownership;
        }
        ownership = _ownershipAt(tokenId);
        if (ownership.burned) {
            return ownership;
        }
        return _ownershipOf(tokenId);
    }

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds) external view override returns (TokenOwnership[] memory) {
        unchecked {
            uint256 tokenIdsLength = tokenIds.length;
            TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
            for (uint256 i; i != tokenIdsLength; ++i) {
                ownerships[i] = explicitOwnershipOf(tokenIds[i]);
            }
            return ownerships;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start` < `stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view override returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();
            uint256 tokenIdsIdx;
            uint256 stopLimit = _nextTokenId();
            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }
            // Set `stop = min(stop, stopLimit)`.
            if (stop > stopLimit) {
                stop = stopLimit;
            }
            uint256 tokenIdsMaxLength = balanceOf(owner);
            // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
            // to cater for cases where `balanceOf(owner)` is too big.
            if (start < stop) {
                uint256 rangeLength = stop - start;
                if (rangeLength < tokenIdsMaxLength) {
                    tokenIdsMaxLength = rangeLength;
                }
            } else {
                tokenIdsMaxLength = 0;
            }
            uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
            if (tokenIdsMaxLength == 0) {
                return tokenIds;
            }
            // We need to call `explicitOwnershipOf(start)`,
            // because the slot at `start` may not be initialized.
            TokenOwnership memory ownership = explicitOwnershipOf(start);
            address currOwnershipAddr;
            // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
            // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
            if (!ownership.burned) {
                currOwnershipAddr = ownership.addr;
            }
            for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            // Downsize the array to fit.
            assembly {
                mstore(tokenIds, tokenIdsIdx)
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(totalSupply) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K pfp collections should be fine).
     */
    function tokensOfOwner(address owner) external view override returns (uint256[] memory) {
        unchecked {
            uint256 tokenIdsIdx;
            address currOwnershipAddr;
            uint256 tokenIdsLength = balanceOf(owner);
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);
            TokenOwnership memory ownership;
            for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import './IERC721ABurnableUpgradeable.sol';
import '../ERC721AUpgradeable.sol';
import '../ERC721A__Initializable.sol';

/**
 * @title ERC721A Burnable Token
 * @dev ERC721A Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721ABurnableUpgradeable is
    ERC721A__Initializable,
    ERC721AUpgradeable,
    IERC721ABurnableUpgradeable
{
    function __ERC721ABurnable_init() internal onlyInitializingERC721A {
        __ERC721ABurnable_init_unchained();
    }

    function __ERC721ABurnable_init_unchained() internal onlyInitializingERC721A {}

    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual override {
        _burn(tokenId, true);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Multicall.sol)

pragma solidity ^0.8.0;

import "./AddressUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 *
 * _Available since v4.1._
 */
abstract contract MulticallUpgradeable is Initializable {
    function __Multicall_init() internal onlyInitializing {
    }

    function __Multicall_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Receives and executes a batch of function calls on this contract.
     */
    function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i = 0; i < data.length; i++) {
            results[i] = _functionDelegateCall(address(this), data[i]);
        }
        return results;
    }

    /**
     * @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) private returns (bytes memory) {
        require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

interface IZeeNFT {
    /// @notice Mint specific amount of tokens for a user.
    function mint(address receiver, uint256 quantity) external;

    /// @notice Burn a specific token ID.
    function burn(uint256 tokenId) external;
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import '../IERC721AUpgradeable.sol';

/**
 * @dev Interface of an ERC721AQueryable compliant contract.
 */
interface IERC721AQueryableUpgradeable is IERC721AUpgradeable {
    /**
     * Invalid query range (`start` >= `stop`).
     */
    error InvalidQueryRange();

    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *   - `addr` = `address(0)`
     *   - `startTimestamp` = `0`
     *   - `burned` = `false`
     *
     * If the `tokenId` is burned:
     *   - `addr` = `<Address of owner before token was burned>`
     *   - `startTimestamp` = `<Timestamp when token was burned>`
     *   - `burned = `true`
     *
     * Otherwise:
     *   - `addr` = `<Address of owner>`
     *   - `startTimestamp` = `<Timestamp of start of ownership>`
     *   - `burned = `false`
     */
    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start` < `stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view returns (uint256[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(totalSupply) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K pfp collections should be fine).
     */
    function tokensOfOwner(address owner) external view returns (uint256[] memory);
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import './IERC721AUpgradeable.sol';
import {ERC721AStorage} from './ERC721AStorage.sol';
import './ERC721A__Initializable.sol';

/**
 * @dev ERC721 token receiver interface.
 */
interface ERC721A__IERC721ReceiverUpgradeable {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721AUpgradeable is ERC721A__Initializable, IERC721AUpgradeable {
    using ERC721AStorage for ERC721AStorage.Layout;
    // Mask of an entry in packed address data.
    uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;

    function __ERC721A_init(string memory name_, string memory symbol_) internal onlyInitializingERC721A {
        __ERC721A_init_unchained(name_, symbol_);
    }

    function __ERC721A_init_unchained(string memory name_, string memory symbol_) internal onlyInitializingERC721A {
        ERC721AStorage.layout()._name = name_;
        ERC721AStorage.layout()._symbol = symbol_;
        ERC721AStorage.layout()._currentIndex = _startTokenId();
    }

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view returns (uint256) {
        return ERC721AStorage.layout()._currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see `_totalMinted`.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return ERC721AStorage.layout()._currentIndex - ERC721AStorage.layout()._burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to `_startTokenId()`
        unchecked {
            return ERC721AStorage.layout()._currentIndex - _startTokenId();
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view returns (uint256) {
        return ERC721AStorage.layout()._burnCounter;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes of the XOR of
        // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165
        // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (_addressToUint256(owner) == 0) revert BalanceQueryForZeroAddress();
        return ERC721AStorage.layout()._packedAddressData[owner] & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (ERC721AStorage.layout()._packedAddressData[owner] >> BITPOS_NUMBER_MINTED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return (ERC721AStorage.layout()._packedAddressData[owner] >> BITPOS_NUMBER_BURNED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return uint64(ERC721AStorage.layout()._packedAddressData[owner] >> BITPOS_AUX);
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        uint256 packed = ERC721AStorage.layout()._packedAddressData[owner];
        uint256 auxCasted;
        assembly {
            // Cast aux without masking.
            auxCasted := aux
        }
        packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX);
        ERC721AStorage.layout()._packedAddressData[owner] = packed;
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < ERC721AStorage.layout()._currentIndex) {
                    uint256 packed = ERC721AStorage.layout()._packedOwnerships[curr];
                    // If not burned.
                    if (packed & BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an ownership that has an address and is not burned
                        // before an ownership that does not have an address and is not burned.
                        // Hence, curr will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed is zero.
                        while (packed == 0) {
                            packed = ERC721AStorage.layout()._packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP);
        ownership.burned = packed & BITMASK_BURNED != 0;
    }

    /**
     * Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
        return _unpackedOwnership(ERC721AStorage.layout()._packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal {
        if (ERC721AStorage.layout()._packedOwnerships[index] == 0) {
            ERC721AStorage.layout()._packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return address(uint160(_packedOwnershipOf(tokenId)));
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev Casts the address to uint256 without masking.
     */
    function _addressToUint256(address value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev Casts the boolean to uint256 without branching.
     */
    function _boolToUint256(bool value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = address(uint160(_packedOwnershipOf(tokenId)));
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

        ERC721AStorage.layout()._tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return ERC721AStorage.layout()._tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSenderERC721A()) revert ApproveToCaller();

        ERC721AStorage.layout()._operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
    }

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < ERC721AStorage.layout()._currentIndex && // If within bounds,
            ERC721AStorage.layout()._packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned.
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement
     *   {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = ERC721AStorage.layout()._currentIndex;
        if (_addressToUint256(to) == 0) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            ERC721AStorage.layout()._packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (to.code.length != 0) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex < end);
                // Reentrancy protection
                if (ERC721AStorage.layout()._currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex < end);
            }
            ERC721AStorage.layout()._currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 quantity) internal {
        uint256 startTokenId = ERC721AStorage.layout()._currentIndex;
        if (_addressToUint256(to) == 0) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            ERC721AStorage.layout()._packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex < end);

            ERC721AStorage.layout()._currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        address approvedAddress = ERC721AStorage.layout()._tokenApprovals[tokenId];

        bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
            isApprovedForAll(from, _msgSenderERC721A()) ||
            approvedAddress == _msgSenderERC721A());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (_addressToUint256(to) == 0) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        if (_addressToUint256(approvedAddress) != 0) {
            delete ERC721AStorage.layout()._tokenApprovals[tokenId];
        }

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // We can directly increment and decrement the balances.
            --ERC721AStorage.layout()._packedAddressData[from]; // Updates: `balance -= 1`.
            ++ERC721AStorage.layout()._packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            ERC721AStorage.layout()._packedOwnerships[tokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_NEXT_INITIALIZED;

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != ERC721AStorage.layout()._currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        ERC721AStorage.layout()._packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = address(uint160(prevOwnershipPacked));
        address approvedAddress = ERC721AStorage.layout()._tokenApprovals[tokenId];

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
                isApprovedForAll(from, _msgSenderERC721A()) ||
                approvedAddress == _msgSenderERC721A());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner.
        if (_addressToUint256(approvedAddress) != 0) {
            delete ERC721AStorage.layout()._tokenApprovals[tokenId];
        }

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`.
            ERC721AStorage.layout()._packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            ERC721AStorage.layout()._packedOwnerships[tokenId] =
                _addressToUint256(from) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_BURNED |
                BITMASK_NEXT_INITIALIZED;

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != ERC721AStorage.layout()._currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        ERC721AStorage.layout()._packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            ERC721AStorage.layout()._burnCounter++;
        }
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try
            ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data)
        returns (bytes4 retval) {
            return retval == ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function _toString(uint256 value) internal pure returns (string memory ptr) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit),
            // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged.
            // We will need 1 32-byte word to store the length,
            // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128.
            ptr := add(mload(0x40), 128)
            // Update the free memory pointer to allocate.
            mstore(0x40, ptr)

            // Cache the end of the memory to calculate the length later.
            let end := ptr

            // We write the string from the rightmost digit to the leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // Costs a bit more than early returning for the zero case,
            // but cheaper in terms of deployment and overall runtime costs.
            for {
                // Initialize and perform the first pass without check.
                let temp := value
                // Move the pointer 1 byte leftwards to point to an empty character slot.
                ptr := sub(ptr, 1)
                // Write the character to the pointer. 48 is the ASCII index of '0'.
                mstore8(ptr, add(48, mod(temp, 10)))
                temp := div(temp, 10)
            } temp {
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
            } {
                // Body of the for loop.
                ptr := sub(ptr, 1)
                mstore8(ptr, add(48, mod(temp, 10)))
            }

            let length := sub(end, ptr)
            // Move the pointer 32 bytes leftwards to make room for the length.
            ptr := sub(ptr, 32)
            // Store the length.
            mstore(ptr, length)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @dev This is a base contract to aid in writing upgradeable diamond facet contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */

import {ERC721A__InitializableStorage} from './ERC721A__InitializableStorage.sol';

abstract contract ERC721A__Initializable {
    using ERC721A__InitializableStorage for ERC721A__InitializableStorage.Layout;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializerERC721A() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(
            ERC721A__InitializableStorage.layout()._initializing
                ? _isConstructor()
                : !ERC721A__InitializableStorage.layout()._initialized,
            'ERC721A__Initializable: contract is already initialized'
        );

        bool isTopLevelCall = !ERC721A__InitializableStorage.layout()._initializing;
        if (isTopLevelCall) {
            ERC721A__InitializableStorage.layout()._initializing = true;
            ERC721A__InitializableStorage.layout()._initialized = true;
        }

        _;

        if (isTopLevelCall) {
            ERC721A__InitializableStorage.layout()._initializing = false;
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} modifier, directly or indirectly.
     */
    modifier onlyInitializingERC721A() {
        require(
            ERC721A__InitializableStorage.layout()._initializing,
            'ERC721A__Initializable: contract is not initializing'
        );
        _;
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        assembly {
            cs := extcodesize(self)
        }
        return cs == 0;
    }
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721AUpgradeable {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);

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

    // ==============================
    //            IERC721
    // ==============================

    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

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

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

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

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

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

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    // ==============================
    //        IERC721Metadata
    // ==============================

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import {ERC721AUpgradeable} from './ERC721AUpgradeable.sol';

library ERC721AStorage {
    struct Layout {
        // The tokenId of the next token to be minted.
        uint256 _currentIndex;
        // The number of tokens burned.
        uint256 _burnCounter;
        // Token name
        string _name;
        // Token symbol
        string _symbol;
        // Mapping from token ID to ownership details
        // An empty struct value does not necessarily mean the token is unowned.
        // See `_packedOwnershipOf` implementation for details.
        //
        // Bits Layout:
        // - [0..159]   `addr`
        // - [160..223] `startTimestamp`
        // - [224]      `burned`
        // - [225]      `nextInitialized`
        mapping(uint256 => uint256) _packedOwnerships;
        // Mapping owner address to address data.
        //
        // Bits Layout:
        // - [0..63]    `balance`
        // - [64..127]  `numberMinted`
        // - [128..191] `numberBurned`
        // - [192..255] `aux`
        mapping(address => uint256) _packedAddressData;
        // Mapping from token ID to approved address.
        mapping(uint256 => address) _tokenApprovals;
        // Mapping from owner to operator approvals
        mapping(address => mapping(address => bool)) _operatorApprovals;
    }

    bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.ERC721A');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This is a base storage for the  initialization function for upgradeable diamond facet contracts
 **/

library ERC721A__InitializableStorage {
    struct Layout {
        /*
         * Indicates that the contract has been initialized.
         */
        bool _initialized;
        /*
         * Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.initializable.facet');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import '../IERC721AUpgradeable.sol';

/**
 * @dev Interface of an ERC721ABurnable compliant contract.
 */
interface IERC721ABurnableUpgradeable is IERC721AUpgradeable {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";

import "../../../acl/access-controlled/AccessControlledUpgradeable.sol";
import "../configuration/ConfigurationControlled.sol";
import "../whitelist/IWhitelistManager.sol";
import "../tiers/ITierPricingManager.sol";
import "../../../common/BlockAware.sol";
import "../configuration/Features.sol";
import "./ISaleManager.sol";
import "../../IZeeNFT.sol";

contract SaleManager is
    ISaleManager,
    UUPSUpgradeable,
    ConfigurationControlled,
    AccessControlledUpgradeable,
    BlockAware
{
    // TODO move state variables to a storage contract
    address internal _vault;
    IZeeNFT internal _zeeNFT;
    IWhitelistManager internal _whitelistManager;
    ITierPricingManager internal _tierManager;
    uint64 internal _tokensBoughtViaPublicMint;
    mapping(address => uint256) internal _tokensBoughtViaPublicMintPerUser;

    modifier saleIsActive() {
        ITierPricingManager.Tier memory tier = _tierManager.getLastTier();
        if (_tokensBoughtViaPublicMint >= tier.threshold) revert MintingLimitReached();
        _;
    }

    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializer {
        // solhint-disable-previous-line no-empty-blocks
    }

    // solhint-disable-next-line comprehensive-interface
    function initialize(
        address configuration,
        address acl,
        address whitelistManager,
        address tierManager,
        address zeeNft,
        address vault
    ) external initializer {
        // TODO: check that the whitelist manager is actually a whitelist manager
        // TODO: check that the tier manager is actually a tier manager
        // TODO: check that the zeeNft is actually a zeeNft

        __BlockAware_init();
        __ConfigurationControlled_init(configuration);
        __AccessControlled_init(acl);
        _vault = vault;
        _zeeNFT = IZeeNFT(zeeNft);
        _whitelistManager = IWhitelistManager(whitelistManager);
        _tierManager = ITierPricingManager(tierManager);
    }

    /// @inheritdoc ISaleManager
    receive() external payable override {
        // solhint-disable-previous-line ordering
        bytes32[] memory proof = new bytes32[](0);

        (ITierPricingManager.Tier memory tier, uint256 tierIndex, uint256 totalTiers) = _tierManager.getCurrentTier();
        uint256 price = tier.price;
        if (msg.value < price || msg.value % price != 0) revert InvalidFundsSent();

        uint256 count = msg.value / price;
        _transferAndMint(proof, uint64(count), tier, tierIndex, totalTiers);
    }

    function buy(bytes32[] calldata whitelistProof, uint64 count) external payable override {
        (ITierPricingManager.Tier memory tier, uint256 tierIndex, uint256 totalTiers) = _tierManager.getCurrentTier();
        _transferAndMint(whitelistProof, count, tier, tierIndex, totalTiers);
    }

    /// @notice transfer ETH to the vault account, mint a new token
    /// @dev will revert if current purchase count exceeds the current tier
    /// @dev will revert if ETH amount is not exactly equal to the token price
    /// @dev will revert if the user has reached his personal mint limit
    /// @dev will revert if the public token sale limit has been reached
    /// @dev manages the public sale token tracker
    // solhint-disable-next-line code-complexity
    function _transferAndMint(
        bytes32[] memory whitelistProof,
        uint64 count,
        ITierPricingManager.Tier memory tier,
        uint256 currentTierIndex,
        uint256 totalTiers
    ) internal whenEnabled(Features._MINTING) saleIsActive {
        if (!_whitelistManager.isUserWhitelisted(msg.sender, whitelistProof)) revert NotWhitelisted();

        uint64 newPublicMintCount = _tokensBoughtViaPublicMint + count;
        if (count == 0) revert CannotPurchaseZeroTokens();
        if (newPublicMintCount > tier.threshold) revert PurchaseExceedsCurrentTier();
        if (tier.capPerUser <= _tokensBoughtViaPublicMintPerUser[msg.sender]) revert UserPurchasingCapReached();
        if (msg.value != (tier.price * count)) revert InsufficientFunds();

        // Shift the tier index
        if (
            // Only if the currently minted tokens exceed the current threshold
            (newPublicMintCount >= tier.threshold) &&
            // Only if it is not the very last threshold
            (currentTierIndex < totalTiers - 1)
        ) {
            _tierManager.bumpTier();
        }

        // Buy tokens
        _tokensBoughtViaPublicMint = newPublicMintCount;
        _tokensBoughtViaPublicMintPerUser[msg.sender] += count;

        // Mint the actual tokens
        _zeeNFT.mint(msg.sender, count);

        AddressUpgradeable.sendValue(payable(_vault), msg.value);
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyAdmin {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts/utils/StorageSlot.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

import "./IConfiguration.sol";

abstract contract ConfigurationControlled is Initializable {
    error FeatureEnabled(uint8 feature);
    error FeatureDisabled(uint8 feature);

    bytes32 private constant _CONFIGURATION_SLOT = bytes32(uint256(keccak256("zee-game.configuration.slot")) - 1);

    modifier whenEnabled(uint8 feature) {
        if (!_getFeature(feature)) revert FeatureDisabled(feature);
        _;
    }

    modifier whenDisabled(uint8 feature) {
        if (_getFeature(feature)) revert FeatureEnabled(feature);
        _;
    }

    // solhint-disable-next-line func-name-mixedcase
    function __ConfigurationControlled_init(address configuration) internal onlyInitializing {
        // TODO interface check
        StorageSlot.getAddressSlot(_CONFIGURATION_SLOT).value = configuration;
    }

    function _enableFeature(uint8 feature) internal {
        return _getConfiguration().setFeature(feature, true);
    }

    function _disableFeature(uint8 feature) internal {
        return _getConfiguration().setFeature(feature, false);
    }

    function _getConfiguration() internal view returns (IConfiguration) {
        return IConfiguration(StorageSlot.getAddressSlot(_CONFIGURATION_SLOT).value);
    }

    function _getFeature(uint8 feature) internal view returns (bool) {
        return _getConfiguration().getFeature(feature);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

/// @notice Interface that public whitelist interaction.
interface IWhitelistManager {
    /// @notice Thrown when attempting to enable the the merkle root validation without setting the merkle root prior..
    error MerkleRootNotSet();

    /// @notice Thrown when attempting to call a whitelist-protected method, whilst a user has not been whitelisted..
    error NotWhitelisted();

    /// @notice Emitted when the merkle root has been set.
    event MerkleRootSet(bytes32 merkleRoot);

    /// @notice Emitted when a user has been added to the whitelist manually.
    event AddedToWhitelist(address account);

    /// @notice Emitted when a user has been removed from the whitelist.
    event RemovedFromWhitelist(address account);

    struct WhitelistOverride {
        bool blocked;
        bool whitelisted;
    }

    /// @notice Set the merkle root for Whitelist validation.
    /// @param merkleRoot The merkle root.
    function setWhitelistMerkleRoot(bytes32 merkleRoot) external;

    /// @notice Enable whitelist merkle root validation.
    /// @dev The whitelist merkle root needs to be set to enable this.
    function enableWhitelist() external;

    /// @notice Disables the whitelist merkle root validation.
    /// @dev The whitelist validation features needs to be enabled to call this.
    function disableWhitelist() external;

    /// @notice Check if the user has been whitelisted either through Merkle Root or manually.
    function isUserWhitelisted(address account, bytes32[] memory proof) external returns (bool);

    /// @notice Add user to the whitelist manually.
    function addUserToWhitelist(address account) external;

    /// @notice Remove user from the whitelist manually.
    function removeUserFromWhitelist(address account) external;

    /// @notice Get the Whitelist specific merkle root.
    /// @return bytes32 merkle root
    function getWhitelistMerkleRoot() external returns (bytes32);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

interface ITierPricingManager {
    /// @notice Emitted when the current tier index has been shifted.
    event CurrentTierSet(Tier newCurrentTier);

    /// @notice Emitted when a new set of tiers has been set.
    event TiersUpdated(Tier[] tiers);

    /// @notice Emitted when the public token mint limit has been set.
    event PublicTokenLimitSet(uint256 publicMintTokenLimit);

    /// @notice Thrown when the supplied tier size is not.
    error TierMustContainAtLeastOneEntry();

    /// @notice Thrown when the tier threshold is smaller than the previous tier.
    error InvalidTierThresholdSupplied(uint256 tierIndex);

    /// @notice Thrown when the user-cap is smaller than the previous tier.
    error InvalidTierCapPerUser(uint256 tierIndex);

    /// @notice Thrown when user cap is larger than the tier threshold.
    error TierCapLargerThanThreshold(uint256 tierIndex, uint256 cap, uint256 threshold);

    struct Tier {
        /// @dev The price for a single item
        uint256 price;
        /// @dev Total amount of total tokens that can be minted
        uint64 threshold;
        /// @dev Total amount of tokens that can be bought by a single user
        uint64 capPerUser;
    }

    /// @notice Set tiers.
    /// @param tiers An array of token-sale describing tiers. The order of the tiers in the array is important.
    ///        price - The price for a single NFT.
    ///        threshold - Total amount of total tokens that can be minted. Each subsequent threshold needs to be larger then the previous one.
    ///        capPerUser - Total amount of tokens that can be bought by a single user. Each subsequent cap needs to be larger or equal than the previous one.
    function setTiers(Tier[] calldata tiers) external;

    /// @notice Bump the tier index.
    function bumpTier() external;

    /// @notice Get currently stored tier settings.
    /// @return tiers An array of token-sale describing tiers.
    function getTiers() external view returns (Tier[] memory tiers);

    /// @notice Get information regarding the current tier.
    /// @return currentTier The current tier structure.
    /// @return currentTierIndex The index of the current tier withing the `tiers` array.
    /// @return totalTiers The total number of tiers.
    function getCurrentTier()
        external
        returns (
            Tier memory currentTier,
            uint256 currentTierIndex,
            uint256 totalTiers
        );

    /// @notice Get information about the very last tier.
    function getLastTier() external returns (Tier memory lastTier);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

library Features {
    uint8 internal constant _CONFIGURING = 0;
    uint8 internal constant _MINTING = 1;
    uint8 internal constant _REVEALING = 2;
    uint8 internal constant _WHITELIST = 3;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

interface ISaleManager {
    /// @notice Thrown when attempting to call a whitelist-protected method, whilst a user has not been whitelisted..
    error NotWhitelisted();

    /// @notice thrown when minting limit has been reached.
    error MintingLimitReached();

    /// @notice Thrown when a user send invalid amount of funds to perform a token purchase.
    error InvalidFundsSent();

    /// @notice Thrown when a user attempts to purchase 0 tokens.
    error CannotPurchaseZeroTokens();

    /// @notice Thrown when a user is attempting to purchase tokens that overlap with the existing.
    error PurchaseExceedsCurrentTier();

    /// @notice Thrown when a user is attempting to purchase more tokens than the user cap allows on the current tier.
    error UserPurchasingCapReached();

    /// @notice thrown when not enough (or too much) ETH has been sent when performing a purchase.
    error InsufficientFunds();

    /// @notice Mint new token by paying the token price
    receive() external payable;

    /// @notice Mint new token by paying the token price.
    /// @param whitelistProof Optional whitelist proof. Used for validating the merkle root.
    ///        If Whitelist feature has been disabled, then this can be an empty array.
    /// @param count The amount of tokens to purchase in a single transaction.
    function buy(bytes32[] calldata whitelistProof, uint64 count) external payable;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

interface IConfiguration {
    /// @notice Emitted when the feature changes it's state.
    event FeatureChanged(uint8 indexed feature, bool value);

    function setFeature(uint8 feature, bool value) external;

    function getFeatures() external view returns (uint256);

    function getFeature(uint8 feature) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

import "../../../acl/access-controlled/AccessControlledUpgradeable.sol";
import "../configuration/ConfigurationControlled.sol";
import "../../../common/BlockAware.sol";
import "../configuration/Features.sol";
import "./IWhitelistManager.sol";

contract WhitelistManager is
    IWhitelistManager,
    UUPSUpgradeable,
    ConfigurationControlled,
    AccessControlledUpgradeable,
    BlockAware
{
    bytes32 private constant _WHITELIST_MERKLE_ROOT_SLOT =
        bytes32(uint256(keccak256("zee-game.whitelist.merkle-root")) - 1);
    mapping(address => WhitelistOverride) private _whitelistOverrides;

    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializer {
        // solhint-disable-previous-line no-empty-blocks
    }

    // solhint-disable-next-line comprehensive-interface
    function initialize(address configuration, address acl) external initializer {
        __BlockAware_init();
        __UUPSUpgradeable_init();
        __ConfigurationControlled_init(configuration);
        __AccessControlled_init(acl);
    }

    /// @inheritdoc IWhitelistManager
    function addUserToWhitelist(address account) external override whenEnabled(Features._WHITELIST) onlyMaintainer {
        _whitelistOverrides[account] = WhitelistOverride({blocked: false, whitelisted: true});

        emit AddedToWhitelist(account);
    }

    /// @inheritdoc IWhitelistManager
    function removeUserFromWhitelist(address account) external override onlyMaintainer {
        _whitelistOverrides[account] = WhitelistOverride({blocked: true, whitelisted: false});

        emit RemovedFromWhitelist(account);
    }

    /// @inheritdoc IWhitelistManager
    function setWhitelistMerkleRoot(bytes32 merkleRoot)
        external
        override
        onlyMaintainer
        whenEnabled(Features._CONFIGURING)
    {
        StorageSlot.getBytes32Slot(_WHITELIST_MERKLE_ROOT_SLOT).value = merkleRoot;

        emit MerkleRootSet(merkleRoot);
    }

    /// @inheritdoc IWhitelistManager
    function enableWhitelist() external override onlyMaintainer whenDisabled(Features._WHITELIST) {
        if (_getWhitelistMerkleRoot() == bytes32(0)) revert MerkleRootNotSet();
        _enableFeature(Features._WHITELIST);
    }

    /// @inheritdoc IWhitelistManager
    function disableWhitelist() external override onlyMaintainer whenEnabled(Features._WHITELIST) {
        _disableFeature(Features._WHITELIST);
    }

    /// @inheritdoc IWhitelistManager
    function isUserWhitelisted(address account, bytes32[] memory whitelistProof) external view override returns (bool) {
        return _isUserWhitelisted(account, whitelistProof);
    }

    /// @inheritdoc IWhitelistManager
    function getWhitelistMerkleRoot() external view override returns (bytes32) {
        return _getWhitelistMerkleRoot();
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyAdmin {
        // solhint-disable-previous-line no-empty-blocks
    }

    /// @dev Verify if the merkle proof is valid.
    function _isValidMerkleProof(address account, bytes32[] memory proof) internal view returns (bool) {
        return MerkleProof.verify(proof, _getWhitelistMerkleRoot(), _constructHash(account));
    }

    /// @dev Construct the hash used for merkle root validation.
    function _constructHash(address account) internal view returns (bytes32) {
        return keccak256(abi.encodePacked(address(this), account, block.chainid));
    }

    /// @dev Return the merkle root.
    function _getWhitelistMerkleRoot() internal view virtual returns (bytes32) {
        return StorageSlot.getBytes32Slot(_WHITELIST_MERKLE_ROOT_SLOT).value;
    }

    /// @dev Make sure that the user has been whitelisted.
    /// @dev if the user has been manually whitelisted, the `whitelistProof` can be an empty array.
    function _isUserWhitelisted(address account, bytes32[] memory whitelistProof) internal view returns (bool) {
        // Everyone is whitelisted while the whitelist is disabled.
        if (_getFeature(Features._WHITELIST)) {
            return
                !_whitelistOverrides[account].blocked &&
                (_whitelistOverrides[account].whitelisted || _isValidMerkleProof(account, whitelistProof));
        }
        return true;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = _efficientHash(computedHash, proofElement);
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = _efficientHash(proofElement, computedHash);
            }
        }
        return computedHash;
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "./ITierPricingManager.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";

import "../../../acl/access-controlled/AccessControlledUpgradeable.sol";
import "../configuration/ConfigurationControlled.sol";
import "../../../common/BlockAware.sol";
import "../configuration/Features.sol";

contract TierPricingManager is
    ITierPricingManager,
    UUPSUpgradeable,
    ConfigurationControlled,
    AccessControlledUpgradeable,
    BlockAware
{
    // TODO move storage variables to a storage contract
    uint256 internal _currentTierIndex;
    Tier[] internal _tiers;

    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializer {
        // solhint-disable-previous-line no-empty-blocks
    }

    // solhint-disable-next-line comprehensive-interface
    function initialize(address configuration, address acl) external initializer {
        __BlockAware_init();
        __UUPSUpgradeable_init();
        __ConfigurationControlled_init(configuration);
        __AccessControlled_init(acl);
    }

    /// @inheritdoc ITierPricingManager
    function setTiers(Tier[] calldata tiers) external override onlyMaintainer whenEnabled(Features._CONFIGURING) {
        delete _tiers;
        if (tiers.length == 0) revert TierMustContainAtLeastOneEntry();

        // TODO can we use a do-while loop here?
        _checkValidCap(0, tiers[0]);
        _tiers.push(tiers[0]);

        for (uint256 i = 1; i < tiers.length; i++) {
            // Validate that each threshold is strictly larger to the previous
            if (tiers[i - 1].threshold >= tiers[i].threshold) revert InvalidTierThresholdSupplied(i);

            // Validate that each user-specific token cap is larger or equal to the previous
            if (tiers[i - 1].capPerUser > tiers[i].capPerUser) revert InvalidTierCapPerUser(i);

            _checkValidCap(i, tiers[i]);
            _tiers.push(tiers[i]);
        }

        uint64 publicMintTokenLimit = tiers[tiers.length - 1].threshold;

        emit TiersUpdated(tiers);
        emit CurrentTierSet(tiers[0]);
        emit PublicTokenLimitSet(publicMintTokenLimit);
    }

    /// @inheritdoc ITierPricingManager
    function bumpTier() external override {
        _currentTierIndex += 1;

        emit CurrentTierSet(_tiers[_currentTierIndex]);
    }

    /// @inheritdoc ITierPricingManager
    function getTiers() external view override returns (Tier[] memory tiers) {
        tiers = _tiers;
    }

    /// @inheritdoc ITierPricingManager
    function getCurrentTier()
        external
        view
        override
        returns (
            Tier memory currentTier,
            uint256 currentTierIndex,
            uint256 totalTiers
        )
    {
        currentTier = _tiers[_currentTierIndex];
        currentTierIndex = _currentTierIndex;
        totalTiers = _tiers.length;
    }

    /// @inheritdoc ITierPricingManager
    function getLastTier() external view override returns (Tier memory lastTier) {
        lastTier = _tiers[_tiers.length - 1];
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyAdmin {
        // solhint-disable-previous-line no-empty-blocks
    }

    function _checkValidCap(uint256 index, Tier memory tier) internal pure {
        if (tier.capPerUser > tier.threshold) revert TierCapLargerThanThreshold(index, tier.capPerUser, tier.threshold);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967Upgrade {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// 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);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

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

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

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

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

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

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

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

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

        _afterTokenTransfer(address(0), to, tokenId);
    }

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

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

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

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

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

        _afterTokenTransfer(owner, address(0), tokenId);
    }

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

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

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

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

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

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

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// 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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../ERC721.sol";
import "./IERC721Enumerable.sol";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

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

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

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

pragma solidity ^0.8.14;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "./abstract/Whitelist.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract ZeeMasks is ERC721, ERC721Enumerable, Ownable, Whitelist {
    /// @notice Emitted when the merkle root has been set.
    event MerkleRootSet(bytes32 merkleRoot);

    bool public mintIsActive = false;
    string private _baseURIextended;
    bytes32 internal _whitelistMerkleRoot;
    uint256 private publiclyMinted = 0;

    uint256 private fireClass = 0;
    uint256 private waterClass = 0;
    uint256 private grassClass = 0;

    uint256 public constant MAX_SUPPLY = 3333;
    uint256 public constant MAX_PUBLIC_MINT = 3000;

    mapping(address => bool) private minters;

    constructor() ERC721("Mask of ZEE", "MoZ") {
    }

    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function setBaseURI(string memory baseURI_) external onlyOwner() {
        _baseURIextended = baseURI_;
    }

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

    function reserve(uint256 n) external onlyOwner {
        uint supply = totalSupply();
        uint i;
        for (i = 0; i < n; i++) {
            _safeMint(msg.sender, supply + i);
        }
    }

    function setMintState(bool newState) external onlyOwner {
        mintIsActive = newState;
    }

    function canMint(address account) external view returns(bool) {
        return minters[account] == false;
    }

    function mint(bytes32[] memory whitelistProof) external {
        uint256 ts = totalSupply();
        require(minters[msg.sender] == false, "Only single item can be minted per wallet");
        require(mintIsActive, "Minting not yet activated");
        require(ts < MAX_SUPPLY, "Mint would exceed max tokens");
        require(publiclyMinted < MAX_PUBLIC_MINT, "All tokens minted");
        require(_isValidMerkleProof(msg.sender, whitelistProof), "Wallet not whitelisted");

        minters[msg.sender] = true;
        _safeMint(msg.sender, ts);
        publiclyMinted++;
    }

    function withdraw() external onlyOwner {
        uint balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    /// @inheritdoc IWhitelist
    function setWhitelistMerkleRoot(bytes32 merkleRoot)
    external
    override
    onlyOwner
    {
        _whitelistMerkleRoot = merkleRoot;

        emit MerkleRootSet(merkleRoot);
    }

    /// @inheritdoc IWhitelist
    function getWhitelistMerkleRoot() external view override returns (bytes32) {
        return _getWhitelistMerkleRoot();
    }

    /// @inheritdoc Whitelist
    function _getWhitelistMerkleRoot() internal view override returns (bytes32) {
        return _whitelistMerkleRoot;
    }

    /// @inheritdoc IWhitelist
    function isUserWhitelisted(address account, bytes32[] memory whitelistProof)
    external
    view
    override
    returns (bool)
    {
        return _isValidMerkleProof(account, whitelistProof);
    }

    function publiclyMintedTokens() external view returns (uint256)
    {
        return publiclyMinted;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();

        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, Strings.toString(tokenId))) : "";
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

import "./IWhitelist.sol";

/// @notice Abstract Whitelist provider contract.
/// Encapuslates merkle root validation with proofs + hash construction.
abstract contract Whitelist is IWhitelist {
    /// @dev Verify if the merkle proof is valid.
    function _isValidMerkleProof(address account, bytes32[] memory proof) internal view returns (bool) {
        return MerkleProof.verify(proof, _getWhitelistMerkleRoot(), _constructHash(account));
    }

    /// @dev Construct the hash used for merkle root validation.
    function _constructHash(address account) internal view returns (bytes32) {
        return keccak256(abi.encodePacked(address(this), account, block.chainid));
    }

    /// @dev Return the merkle root.
    function _getWhitelistMerkleRoot() internal view virtual returns (bytes32);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

/// @notice Interface that public whitelist interaction.
interface IWhitelist {
    /// @notice Set the merkle root for Whitelist validation.
    /// @param merkleRoot The merkle root.
    function setWhitelistMerkleRoot(bytes32 merkleRoot) external;

    /// @notice Check if the user has been whitelisted either through Merkle Root or manually.
    function isUserWhitelisted(address account, bytes32[] memory proof) external returns (bool);

    /// @notice Get the Whitelist specific merkle root.
    /// @return bytes32 merkle root
    function getWhitelistMerkleRoot() external returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)

pragma solidity ^0.8.0;

import "../Proxy.sol";
import "./ERC1967Upgrade.sol";

/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 */
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
    /**
     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
     *
     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
     * function call, and allows initializating the storage of the proxy like a Solidity constructor.
     */
    constructor(address _logic, bytes memory _data) payable {
        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
        _upgradeToAndCall(_logic, _data, false);
    }

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation() internal view virtual override returns (address impl) {
        return ERC1967Upgrade._getImplementation();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)

pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    /**
     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive() external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overridden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

// Importing `ERC1967Proxy` so we can access it from our deploy scripts
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";

// SPDX-License-Identifier: MIT

pragma solidity 0.8.14;

import "@openzeppelin/contracts-upgradeable/utils/structs/BitMapsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

import "../../../acl/access-controlled/AccessControlledUpgradeable.sol";
import "../../../common/BlockAware.sol";
import "./IConfiguration.sol";

contract Configuration is IConfiguration, UUPSUpgradeable, AccessControlledUpgradeable, BlockAware {
    using BitMapsUpgradeable for BitMapsUpgradeable.BitMap;
    BitMapsUpgradeable.BitMap internal _features;

    /// @dev Constructor that gets called for the implementation contract.
    constructor() initializer {
        // solhint-disable-previous-line no-empty-blocks
    }

    function initialize(address acl) external initializer {
        // solhint-disable-previous-line comprehensive-interface
        __BlockAware_init();
        __UUPSUpgradeable_init();
        __AccessControlled_init(acl);
    }

    /// @inheritdoc IConfiguration
    function setFeature(uint8 feature, bool value) external override onlyRole(Roles.AUXILIARY_CONTRACTS) {
        _features.setTo(feature, value);

        emit FeatureChanged(feature, value);
    }

    /// @inheritdoc IConfiguration
    function getFeature(uint8 feature) external view override returns (bool) {
        return _featureIsEnabled(feature);
    }

    /// @inheritdoc IConfiguration
    function getFeatures() external view override returns (uint256) {
        return _features._data[0];
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address) internal override onlyAdmin {
        // solhint-disable-previous-line no-empty-blocks
    }

    function _featureIsEnabled(uint8 feature) internal view returns (bool) {
        return _features.get(feature);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/structs/BitMaps.sol)
pragma solidity ^0.8.0;

/**
 * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
 * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
 */
library BitMapsUpgradeable {
    struct BitMap {
        mapping(uint256 => uint256) _data;
    }

    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
        uint256 bucket = index >> 8;
        uint256 mask = 1 << (index & 0xff);
        return bitmap._data[bucket] & mask != 0;
    }

    /**
     * @dev Sets the bit at `index` to the boolean `value`.
     */
    function setTo(
        BitMap storage bitmap,
        uint256 index,
        bool value
    ) internal {
        if (value) {
            set(bitmap, index);
        } else {
            unset(bitmap, index);
        }
    }

    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = 1 << (index & 0xff);
        bitmap._data[bucket] |= mask;
    }

    /**
     * @dev Unsets the bit at `index`.
     */
    function unset(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = 1 << (index & 0xff);
        bitmap._data[bucket] &= ~mask;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"MerkleRootSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_PUBLIC_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"canMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWhitelistMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32[]","name":"whitelistProof","type":"bytes32[]"}],"name":"isUserWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"whitelistProof","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publiclyMintedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"n","type":"uint256"}],"name":"reserve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newState","type":"bool"}],"name":"setMintState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"setWhitelistMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

304:3636:70:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1136:177;;;;;;:::i;:::-;;:::i;:::-;;;565:14:82;;558:22;540:41;;528:2;513:18;1136:177:70;;;;;;;;2488:98:30;;;:::i;:::-;;;;;;;:::i;4000:217::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:82;;;1674:51;;1662:2;1647:18;4000:217:30;1528:203:82;3538:401:30;;;;;;:::i;:::-;;:::i;:::-;;1615:111:33;1702:10;:17;1615:111;;;2319:25:82;;;2307:2;2292:18;1615:111:33;2173:177:82;4727:330:30;;;;;;:::i;:::-;;:::i;1759:96:70:-;;;;;;:::i;:::-;;:::i;1291:253:33:-;;;;;;:::i;:::-;;:::i;748:41:70:-;;785:4;748:41;;2563:139;;;:::i;5123:179:30:-;;;;;;:::i;:::-;;:::i;481:32:70:-;;;;;-1:-1:-1;;;481:32:70;;;;;;1798:230:33;;;;;;:::i;:::-;;:::i;3280:203:70:-;;;;;;:::i;:::-;;:::i;1319:109::-;;;;;;:::i;:::-;;:::i;2191:235:30:-;;;;;;:::i;:::-;;:::i;795:46:70:-;;837:4;795:46;;1929:205:30;;;;;;:::i;:::-;;:::i;1668:101:24:-;;;:::i;1555:198:70:-;;;;;;:::i;:::-;;:::i;1036:85:24:-;1108:6;;-1:-1:-1;;;;;1108:6:24;1036:85;;2650:102:30;;;:::i;4284:153::-;;;;;;:::i;:::-;;:::i;1978:579:70:-;;;;;;:::i;:::-;;:::i;5368:320:30:-;;;;;;:::i;:::-;;:::i;2739:187:70:-;;;;;;:::i;:::-;;:::i;1861:111::-;;;;;;:::i;:::-;-1:-1:-1;;;;;1940:16:70;1917:4;1940:16;;;:7;:16;;;;;;;;:25;;1861:111;3601:337;;;;;;:::i;:::-;;:::i;4503:162:30:-;;;;;;:::i;:::-;-1:-1:-1;;;;;4623:25:30;;;4600:4;4623:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4503:162;3489:106:70;3574:14;;3489:106;;2963:124;;;:::i;1918:198:24:-;;;;;;:::i;:::-;;:::i;1136:177:70:-;1247:4;1270:36;1294:11;1270:23;:36::i;:::-;1263:43;1136:177;-1:-1:-1;;1136:177:70:o;2488:98:30:-;2542:13;2574:5;2567:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2488:98;:::o;4000:217::-;4076:7;7248:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7248:16:30;4095:73;;;;-1:-1:-1;;;4095:73:30;;8156:2:82;4095:73:30;;;8138:21:82;8195:2;8175:18;;;8168:30;8234:34;8214:18;;;8207:62;-1:-1:-1;;;8285:18:82;;;8278:42;8337:19;;4095:73:30;;;;;;;;;-1:-1:-1;4186:24:30;;;;:15;:24;;;;;;-1:-1:-1;;;;;4186:24:30;;4000:217::o;3538:401::-;3618:13;3634:23;3649:7;3634:14;:23::i;:::-;3618:39;;3681:5;-1:-1:-1;;;;;3675:11:30;:2;-1:-1:-1;;;;;3675:11:30;;3667:57;;;;-1:-1:-1;;;3667:57:30;;8569:2:82;3667:57:30;;;8551:21:82;8608:2;8588:18;;;8581:30;8647:34;8627:18;;;8620:62;-1:-1:-1;;;8698:18:82;;;8691:31;8739:19;;3667:57:30;8367:397:82;3667:57:30;719:10:37;-1:-1:-1;;;;;3756:21:30;;;;:62;;-1:-1:-1;3781:37:30;3798:5;719:10:37;4503:162:30;:::i;3781:37::-;3735:165;;;;-1:-1:-1;;;3735:165:30;;8971:2:82;3735:165:30;;;8953:21:82;9010:2;8990:18;;;8983:30;9049:34;9029:18;;;9022:62;9120:26;9100:18;;;9093:54;9164:19;;3735:165:30;8769:420:82;3735:165:30;3911:21;3920:2;3924:7;3911:8;:21::i;:::-;3608:331;3538:401;;:::o;4727:330::-;4916:41;719:10:37;4949:7:30;4916:18;:41::i;:::-;4908:103;;;;-1:-1:-1;;;4908:103:30;;;;;;;:::i;:::-;5022:28;5032:4;5038:2;5042:7;5022:9;:28::i;1759:96:70:-;1108:6:24;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;1825:12:70::1;:23:::0;;;::::1;;-1:-1:-1::0;;;1825:23:70::1;-1:-1:-1::0;;;;1825:23:70;;::::1;::::0;;;::::1;::::0;;1759:96::o;1291:253:33:-;1388:7;1423:23;1440:5;1423:16;:23::i;:::-;1415:5;:31;1407:87;;;;-1:-1:-1;;;1407:87:33;;10175:2:82;1407:87:33;;;10157:21:82;10214:2;10194:18;;;10187:30;10253:34;10233:18;;;10226:62;-1:-1:-1;;;10304:18:82;;;10297:41;10355:19;;1407:87:33;9973:407:82;1407:87:33;-1:-1:-1;;;;;;1511:19:33;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;1291:253::o;2563:139:70:-;1108:6:24;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;2658:37:70::1;::::0;2627:21:::1;::::0;2666:10:::1;::::0;2658:37;::::1;;;::::0;2627:21;;2612:12:::1;2658:37:::0;2612:12;2658:37;2627:21;2666:10;2658:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;2602:100;2563:139::o:0;5123:179:30:-;5256:39;5273:4;5279:2;5283:7;5256:39;;;;;;;;;;;;:16;:39::i;1798:230:33:-;1873:7;1908:30;1702:10;:17;;1615:111;1908:30;1900:5;:38;1892:95;;;;-1:-1:-1;;;1892:95:33;;10587:2:82;1892:95:33;;;10569:21:82;10626:2;10606:18;;;10599:30;10665:34;10645:18;;;10638:62;-1:-1:-1;;;10716:18:82;;;10709:42;10768:19;;1892:95:33;10385:408:82;1892:95:33;2004:10;2015:5;2004:17;;;;;;;;:::i;:::-;;;;;;;;;1997:24;;1798:230;;;:::o;3280:203:70:-;3405:4;3432:44;3452:7;3461:14;3432:19;:44::i;:::-;3425:51;3280:203;-1:-1:-1;;;3280:203:70:o;1319:109::-;1108:6:24;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;1394:27:70;;::::1;::::0;:16:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;2191:235:30:-:0;2263:7;2298:16;;;:7;:16;;;;;;-1:-1:-1;;;;;2298:16:30;;2324:73;;;;-1:-1:-1;;;2324:73:30;;11132:2:82;2324:73:30;;;11114:21:82;11171:2;11151:18;;;11144:30;11210:34;11190:18;;;11183:62;-1:-1:-1;;;11261:18:82;;;11254:39;11310:19;;2324:73:30;10930:405:82;1929:205:30;2001:7;-1:-1:-1;;;;;2028:19:30;;2020:74;;;;-1:-1:-1;;;2020:74:30;;11542:2:82;2020:74:30;;;11524:21:82;11581:2;11561:18;;;11554:30;11620:34;11600:18;;;11593:62;-1:-1:-1;;;11671:18:82;;;11664:40;11721:19;;2020:74:30;11340:406:82;2020:74:30;-1:-1:-1;;;;;;2111:16:30;;;;;:9;:16;;;;;;;1929:205::o;1668:101:24:-;1108:6;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;1732:30:::1;1759:1;1732:18;:30::i;:::-;1668:101::o:0;1555:198:70:-;1108:6:24;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;1612:11:70::1;1626:13;1702:10:33::0;:17;;1615:111;1626:13:70::1;1612:27;;1649:6;1665:82;1681:1;1677;:5;1665:82;;;1703:33;1713:10;1725;1734:1:::0;1725:6;:10:::1;:::i;:::-;1703:9;:33::i;:::-;1684:3:::0;::::1;::::0;::::1;:::i;:::-;;;;1665:82;;2650:102:30::0;2706:13;2738:7;2731:14;;;;;:::i;4284:153::-;4378:52;719:10:37;4411:8:30;4421;4378:18;:52::i;1978:579:70:-;2044:10;2057:13;1702:10:33;:17;;1615:111;2057:13:70;2096:10;2088:19;;;;:7;:19;;;;;;2044:26;;-1:-1:-1;2088:19:70;;:28;2080:82;;;;-1:-1:-1;;;2080:82:70;;12358:2:82;2080:82:70;;;12340:21:82;12397:2;12377:18;;;12370:30;12436:34;12416:18;;;12409:62;-1:-1:-1;;;12487:18:82;;;12480:39;12536:19;;2080:82:70;12156:405:82;2080:82:70;2180:12;;-1:-1:-1;;;2180:12:70;;;;2172:50;;;;-1:-1:-1;;;2172:50:70;;12768:2:82;2172:50:70;;;12750:21:82;12807:2;12787:18;;;12780:30;12846:27;12826:18;;;12819:55;12891:18;;2172:50:70;12566:349:82;2172:50:70;785:4;2240:2;:15;2232:56;;;;-1:-1:-1;;;2232:56:70;;13122:2:82;2232:56:70;;;13104:21:82;13161:2;13141:18;;;13134:30;13200;13180:18;;;13173:58;13248:18;;2232:56:70;12920:352:82;2232:56:70;837:4;2306:14;;:32;2298:62;;;;-1:-1:-1;;;2298:62:70;;13479:2:82;2298:62:70;;;13461:21:82;13518:2;13498:18;;;13491:30;-1:-1:-1;;;13537:18:82;;;13530:47;13594:18;;2298:62:70;13277:341:82;2298:62:70;2378:47;2398:10;2410:14;2378:19;:47::i;:::-;2370:82;;;;-1:-1:-1;;;2370:82:70;;13825:2:82;2370:82:70;;;13807:21:82;13864:2;13844:18;;;13837:30;-1:-1:-1;;;13883:18:82;;;13876:52;13945:18;;2370:82:70;13623:346:82;2370:82:70;2471:10;2463:19;;;;:7;:19;;;;;:26;;-1:-1:-1;;2463:26:70;2485:4;2463:26;;;2499:25;;2521:2;2499:9;:25::i;:::-;2534:14;:16;;;:14;:16;;;:::i;:::-;;;;;;2034:523;1978:579;:::o;5368:320:30:-;5537:41;719:10:37;5570:7:30;5537:18;:41::i;:::-;5529:103;;;;-1:-1:-1;;;5529:103:30;;;;;;;:::i;:::-;5642:39;5656:4;5662:2;5666:7;5675:5;5642:13;:39::i;:::-;5368:320;;;;:::o;2739:187:70:-;1108:6:24;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;2845:20:70::1;:33:::0;;;2894:25:::1;::::0;2319::82;;;2894::70::1;::::0;2307:2:82;2292:18;2894:25:70::1;;;;;;;2739:187:::0;:::o;3601:337::-;7225:4:30;7248:16;;;:7;:16;;;;;;3674:13:70;;-1:-1:-1;;;;;7248:16:30;3699:76:70;;;;-1:-1:-1;;;3699:76:70;;14176:2:82;3699:76:70;;;14158:21:82;14215:2;14195:18;;;14188:30;14254:34;14234:18;;;14227:62;-1:-1:-1;;;14305:18:82;;;14298:45;14360:19;;3699:76:70;13974:411:82;3699:76:70;3786:21;3810:10;:8;:10::i;:::-;3786:34;;3862:1;3844:7;3838:21;:25;:93;;;;;;;;;;;;;;;;;3890:7;3899:25;3916:7;3899:16;:25::i;:::-;3873:52;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3831:100;3601:337;-1:-1:-1;;;3601:337:70:o;2963:124::-;3029:7;3055:25;3216:20;;;3123:120;3055:25;3048:32;;2963:124;:::o;1918:198:24:-;1108:6;;-1:-1:-1;;;;;1108:6:24;719:10:37;1248:23:24;1240:68;;;;-1:-1:-1;;;1240:68:24;;;;;;;:::i;:::-;-1:-1:-1;;;;;2006:22:24;::::1;1998:73;;;::::0;-1:-1:-1;;;1998:73:24;;15067:2:82;1998:73:24::1;::::0;::::1;15049:21:82::0;15106:2;15086:18;;;15079:30;15145:34;15125:18;;;15118:62;-1:-1:-1;;;15196:18:82;;;15189:36;15242:19;;1998:73:24::1;14865:402:82::0;1998:73:24::1;2081:28;2100:8;2081:18;:28::i;:::-;1918:198:::0;:::o;990:222:33:-;1092:4;-1:-1:-1;;;;;;1115:50:33;;-1:-1:-1;;;1115:50:33;;:90;;;1169:36;1193:11;1169:23;:36::i;11169:171:30:-;11243:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;11243:29:30;-1:-1:-1;;;;;11243:29:30;;;;;;;;:24;;11296:23;11243:24;11296:14;:23::i;:::-;-1:-1:-1;;;;;11287:46:30;;;;;;;;;;;11169:171;;:::o;7443:344::-;7536:4;7248:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7248:16:30;7552:73;;;;-1:-1:-1;;;7552:73:30;;15474:2:82;7552:73:30;;;15456:21:82;15513:2;15493:18;;;15486:30;15552:34;15532:18;;;15525:62;-1:-1:-1;;;15603:18:82;;;15596:42;15655:19;;7552:73:30;15272:408:82;7552:73:30;7635:13;7651:23;7666:7;7651:14;:23::i;:::-;7635:39;;7703:5;-1:-1:-1;;;;;7692:16:30;:7;-1:-1:-1;;;;;7692:16:30;;:52;;;-1:-1:-1;;;;;;4623:25:30;;;4600:4;4623:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;7712:32;7692:87;;;;7772:7;-1:-1:-1;;;;;7748:31:30;:20;7760:7;7748:11;:20::i;:::-;-1:-1:-1;;;;;7748:31:30;;7692:87;7684:96;7443:344;-1:-1:-1;;;;7443:344:30:o;10453:605::-;10607:4;-1:-1:-1;;;;;10580:31:30;:23;10595:7;10580:14;:23::i;:::-;-1:-1:-1;;;;;10580:31:30;;10572:81;;;;-1:-1:-1;;;10572:81:30;;15887:2:82;10572:81:30;;;15869:21:82;15926:2;15906:18;;;15899:30;15965:34;15945:18;;;15938:62;-1:-1:-1;;;16016:18:82;;;16009:35;16061:19;;10572:81:30;15685:401:82;10572:81:30;-1:-1:-1;;;;;10671:16:30;;10663:65;;;;-1:-1:-1;;;10663:65:30;;16293:2:82;10663:65:30;;;16275:21:82;16332:2;16312:18;;;16305:30;16371:34;16351:18;;;16344:62;-1:-1:-1;;;16422:18:82;;;16415:34;16466:19;;10663:65:30;16091:400:82;10663:65:30;10739:39;10760:4;10766:2;10770:7;10739:20;:39::i;:::-;10840:29;10857:1;10861:7;10840:8;:29::i;:::-;-1:-1:-1;;;;;10880:15:30;;;;;;:9;:15;;;;;:20;;10899:1;;10880:15;:20;;10899:1;;10880:20;:::i;:::-;;;;-1:-1:-1;;;;;;;10910:13:30;;;;;;:9;:13;;;;;:18;;10927:1;;10910:13;:18;;10927:1;;10910:18;:::i;:::-;;;;-1:-1:-1;;10938:16:30;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;10938:21:30;-1:-1:-1;;;;;10938:21:30;;;;;;;;;10975:27;;10938:16;;10975:27;;;;;;;3608:331;3538:401;;:::o;377:200:72:-;470:4;493:77;512:5;519:25;3216:20:70;;;3123:120;519:25:72;546:23;561:7;748:55;;-1:-1:-1;;773:4:72;18028:2:82;18024:15;;;18020:24;;748:55:72;;;18008:37:82;18079:15;;;18075:24;18061:12;;;18054:46;789:13:72;18116:12:82;;;18109:28;712:7:72;;18153:12:82;;748:55:72;;;;;;;;;;;;738:66;;;;;;731:73;;648:163;;;;546:23;493:18;:77::i;2270:187:24:-;2362:6;;;-1:-1:-1;;;;;2378:17:24;;;-1:-1:-1;;;;;;2378:17:24;;;;;;;2410:40;;2362:6;;;2378:17;2362:6;;2410:40;;2343:16;;2410:40;2333:124;2270:187;:::o;8117:108:30:-;8192:26;8202:2;8206:7;8192:26;;;;;;;;;;;;:9;:26::i;11475:307::-;11625:8;-1:-1:-1;;;;;11616:17:30;:5;-1:-1:-1;;;;;11616:17:30;;11608:55;;;;-1:-1:-1;;;11608:55:30;;16828:2:82;11608:55:30;;;16810:21:82;16867:2;16847:18;;;16840:30;16906:27;16886:18;;;16879:55;16951:18;;11608:55:30;16626:349:82;11608:55:30;-1:-1:-1;;;;;11673:25:30;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;11673:46:30;;;;;;;;;;11734:41;;540::82;;;11734::30;;513:18:82;11734:41:30;;;;;;;11475:307;;;:::o;6550:::-;6701:28;6711:4;6717:2;6721:7;6701:9;:28::i;:::-;6747:48;6770:4;6776:2;6780:7;6789:5;6747:22;:48::i;:::-;6739:111;;;;-1:-1:-1;;;6739:111:30;;;;;;;:::i;1434:115:70:-;1494:13;1526:16;1519:23;;;;;:::i;328:703:39:-;384:13;601:5;610:1;601:10;597:51;;-1:-1:-1;;627:10:39;;;;;;;;;;;;-1:-1:-1;;;627:10:39;;;;;328:703::o;597:51::-;672:5;657:12;711:75;718:9;;711:75;;743:8;;;;:::i;:::-;;-1:-1:-1;765:10:39;;-1:-1:-1;773:2:39;765:10;;:::i;:::-;;;711:75;;;795:19;827:6;817:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;817:17:39;;795:39;;844:150;851:10;;844:150;;877:11;887:1;877:11;;:::i;:::-;;-1:-1:-1;945:10:39;953:2;945:5;:10;:::i;:::-;932:24;;:2;:24;:::i;:::-;919:39;;902:6;909;902:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;902:56:39;;;;;;;;-1:-1:-1;972:11:39;981:2;972:11;;:::i;:::-;;;844:150;;1570:300:30;1672:4;-1:-1:-1;;;;;;1707:40:30;;-1:-1:-1;;;1707:40:30;;:104;;-1:-1:-1;;;;;;;1763:48:30;;-1:-1:-1;;;1763:48:30;1707:104;:156;;;-1:-1:-1;;;;;;;;;;937:40:41;;;1827:36:30;829:155:41;951:179:70;1078:45;1105:4;1111:2;1115:7;1078:26;:45::i;1154:184:40:-;1275:4;1327;1298:25;1311:5;1318:4;1298:12;:25::i;:::-;:33;;1154:184;-1:-1:-1;;;;1154:184:40:o;8446:311:30:-;8571:18;8577:2;8581:7;8571:5;:18::i;:::-;8620:54;8651:1;8655:2;8659:7;8668:5;8620:22;:54::i;:::-;8599:151;;;;-1:-1:-1;;;8599:151:30;;;;;;;:::i;12335:778::-;12485:4;-1:-1:-1;;;;;12505:13:30;;1465:19:36;:23;12501:606:30;;12540:72;;-1:-1:-1;;;12540:72:30;;-1:-1:-1;;;;;12540:36:30;;;;;:72;;719:10:37;;12591:4:30;;12597:7;;12606:5;;12540:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12540:72:30;;;;;;;;-1:-1:-1;;12540:72:30;;;;;;;;;;;;:::i;:::-;;;12536:519;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12779:6;:13;12796:1;12779:18;12775:266;;12821:60;;-1:-1:-1;;;12821:60:30;;;;;;;:::i;12775:266::-;12993:6;12987:13;12978:6;12974:2;12970:15;12963:38;12536:519;-1:-1:-1;;;;;;12662:51:30;-1:-1:-1;;;12662:51:30;;-1:-1:-1;12655:58:30;;12501:606;-1:-1:-1;13092:4:30;12335:778;;;;;;:::o;2624:572:33:-;-1:-1:-1;;;;;2823:18:33;;2819:183;;2857:40;2889:7;4005:10;:17;;3978:24;;;;:15;:24;;;;;:44;;;4032:24;;;;;;;;;;;;3902:161;2857:40;2819:183;;;2926:2;-1:-1:-1;;;;;2918:10:33;:4;-1:-1:-1;;;;;2918:10:33;;2914:88;;2944:47;2977:4;2983:7;2944:32;:47::i;:::-;-1:-1:-1;;;;;3015:16:33;;3011:179;;3047:45;3084:7;3047:36;:45::i;3011:179::-;3119:4;-1:-1:-1;;;;;3113:10:33;:2;-1:-1:-1;;;;;3113:10:33;;3109:81;;3139:40;3167:2;3171:7;3139:27;:40::i;1689:662:40:-;1772:7;1814:4;1772:7;1828:488;1852:5;:12;1848:1;:16;1828:488;;;1885:20;1908:5;1914:1;1908:8;;;;;;;;:::i;:::-;;;;;;;1885:31;;1950:12;1934;:28;1930:376;;2425:13;2473:15;;;2508:4;2501:15;;;2554:4;2538:21;;2060:57;;1930:376;;;2425:13;2473:15;;;2508:4;2501:15;;;2554:4;2538:21;;2234:57;;1930:376;-1:-1:-1;1866:3:40;;;;:::i;:::-;;;;1828:488;;;-1:-1:-1;2332:12:40;1689:662;-1:-1:-1;;;1689:662:40:o;9079:427:30:-;-1:-1:-1;;;;;9158:16:30;;9150:61;;;;-1:-1:-1;;;9150:61:30;;19126:2:82;9150:61:30;;;19108:21:82;;;19145:18;;;19138:30;19204:34;19184:18;;;19177:62;19256:18;;9150:61:30;18924:356:82;9150:61:30;7225:4;7248:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7248:16:30;:30;9221:58;;;;-1:-1:-1;;;9221:58:30;;19487:2:82;9221:58:30;;;19469:21:82;19526:2;19506:18;;;19499:30;19565;19545:18;;;19538:58;19613:18;;9221:58:30;19285:352:82;9221:58:30;9290:45;9319:1;9323:2;9327:7;9290:20;:45::i;:::-;-1:-1:-1;;;;;9346:13:30;;;;;;:9;:13;;;;;:18;;9363:1;;9346:13;:18;;9363:1;;9346:18;:::i;:::-;;;;-1:-1:-1;;9374:16:30;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9374:21:30;-1:-1:-1;;;;;9374:21:30;;;;;;;;9411:33;;9374:16;;;9411:33;;9374:16;;9411:33;2658:37:70::1;2602:100;2563:139::o:0;4680:970:33:-;4942:22;4992:1;4967:22;4984:4;4967:16;:22::i;:::-;:26;;;;:::i;:::-;5003:18;5024:26;;;:17;:26;;;;;;4942:51;;-1:-1:-1;5154:28:33;;;5150:323;;-1:-1:-1;;;;;5220:18:33;;5198:19;5220:18;;;:12;:18;;;;;;;;:34;;;;;;;;;5269:30;;;;;;:44;;;5385:30;;:17;:30;;;;;:43;;;5150:323;-1:-1:-1;5566:26:33;;;;:17;:26;;;;;;;;5559:33;;;-1:-1:-1;;;;;5609:18:33;;;;;:12;:18;;;;;:34;;;;;;;5602:41;4680:970::o;5938:1061::-;6212:10;:17;6187:22;;6212:21;;6232:1;;6212:21;:::i;:::-;6243:18;6264:24;;;:15;:24;;;;;;6632:10;:26;;6187:46;;-1:-1:-1;6264:24:33;;6187:46;;6632:26;;;;;;:::i;:::-;;;;;;;;;6610:48;;6694:11;6669:10;6680;6669:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;6773:28;;;:15;:28;;;;;;;:41;;;6942:24;;;;;6935:31;6976:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;6009:990;;;5938:1061;:::o;3490:217::-;3574:14;3591:20;3608:2;3591:16;:20::i;:::-;-1:-1:-1;;;;;3621:16:33;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;3665:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;3490:217:33:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:82;-1:-1:-1;;;;;;88:32:82;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:82;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:82;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:82:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:82;;1343:180;-1:-1:-1;1343:180:82:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:82;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:82:o;2355:328::-;2432:6;2440;2448;2501:2;2489:9;2480:7;2476:23;2472:32;2469:52;;;2517:1;2514;2507:12;2469:52;2540:29;2559:9;2540:29;:::i;:::-;2530:39;;2588:38;2622:2;2611:9;2607:18;2588:38;:::i;:::-;2578:48;;2673:2;2662:9;2658:18;2645:32;2635:42;;2355:328;;;;;:::o;2688:160::-;2753:20;;2809:13;;2802:21;2792:32;;2782:60;;2838:1;2835;2828:12;2853:180;2909:6;2962:2;2950:9;2941:7;2937:23;2933:32;2930:52;;;2978:1;2975;2968:12;2930:52;3001:26;3017:9;3001:26;:::i;3038:127::-;3099:10;3094:3;3090:20;3087:1;3080:31;3130:4;3127:1;3120:15;3154:4;3151:1;3144:15;3170:275;3241:2;3235:9;3306:2;3287:13;;-1:-1:-1;;3283:27:82;3271:40;;3341:18;3326:34;;3362:22;;;3323:62;3320:88;;;3388:18;;:::i;:::-;3424:2;3417:22;3170:275;;-1:-1:-1;3170:275:82:o;3450:712::-;3504:5;3557:3;3550:4;3542:6;3538:17;3534:27;3524:55;;3575:1;3572;3565:12;3524:55;3611:6;3598:20;3637:4;3660:18;3656:2;3653:26;3650:52;;;3682:18;;:::i;:::-;3728:2;3725:1;3721:10;3751:28;3775:2;3771;3767:11;3751:28;:::i;:::-;3813:15;;;3883;;;3879:24;;;3844:12;;;;3915:15;;;3912:35;;;3943:1;3940;3933:12;3912:35;3979:2;3971:6;3967:15;3956:26;;3991:142;4007:6;4002:3;3999:15;3991:142;;;4073:17;;4061:30;;4024:12;;;;4111;;;;3991:142;;;4151:5;3450:712;-1:-1:-1;;;;;;;3450:712:82:o;4167:422::-;4260:6;4268;4321:2;4309:9;4300:7;4296:23;4292:32;4289:52;;;4337:1;4334;4327:12;4289:52;4360:29;4379:9;4360:29;:::i;:::-;4350:39;;4440:2;4429:9;4425:18;4412:32;4467:18;4459:6;4456:30;4453:50;;;4499:1;4496;4489:12;4453:50;4522:61;4575:7;4566:6;4555:9;4551:22;4522:61;:::i;:::-;4512:71;;;4167:422;;;;;:::o;4594:407::-;4659:5;4693:18;4685:6;4682:30;4679:56;;;4715:18;;:::i;:::-;4753:57;4798:2;4777:15;;-1:-1:-1;;4773:29:82;4804:4;4769:40;4753:57;:::i;:::-;4744:66;;4833:6;4826:5;4819:21;4873:3;4864:6;4859:3;4855:16;4852:25;4849:45;;;4890:1;4887;4880:12;4849:45;4939:6;4934:3;4927:4;4920:5;4916:16;4903:43;4993:1;4986:4;4977:6;4970:5;4966:18;4962:29;4955:40;4594:407;;;;;:::o;5006:451::-;5075:6;5128:2;5116:9;5107:7;5103:23;5099:32;5096:52;;;5144:1;5141;5134:12;5096:52;5184:9;5171:23;5217:18;5209:6;5206:30;5203:50;;;5249:1;5246;5239:12;5203:50;5272:22;;5325:4;5317:13;;5313:27;-1:-1:-1;5303:55:82;;5354:1;5351;5344:12;5303:55;5377:74;5443:7;5438:2;5425:16;5420:2;5416;5412:11;5377:74;:::i;5462:186::-;5521:6;5574:2;5562:9;5553:7;5549:23;5545:32;5542:52;;;5590:1;5587;5580:12;5542:52;5613:29;5632:9;5613:29;:::i;5653:254::-;5718:6;5726;5779:2;5767:9;5758:7;5754:23;5750:32;5747:52;;;5795:1;5792;5785:12;5747:52;5818:29;5837:9;5818:29;:::i;:::-;5808:39;;5866:35;5897:2;5886:9;5882:18;5866:35;:::i;:::-;5856:45;;5653:254;;;;;:::o;5912:348::-;5996:6;6049:2;6037:9;6028:7;6024:23;6020:32;6017:52;;;6065:1;6062;6055:12;6017:52;6105:9;6092:23;6138:18;6130:6;6127:30;6124:50;;;6170:1;6167;6160:12;6124:50;6193:61;6246:7;6237:6;6226:9;6222:22;6193:61;:::i;6265:667::-;6360:6;6368;6376;6384;6437:3;6425:9;6416:7;6412:23;6408:33;6405:53;;;6454:1;6451;6444:12;6405:53;6477:29;6496:9;6477:29;:::i;:::-;6467:39;;6525:38;6559:2;6548:9;6544:18;6525:38;:::i;:::-;6515:48;;6610:2;6599:9;6595:18;6582:32;6572:42;;6665:2;6654:9;6650:18;6637:32;6692:18;6684:6;6681:30;6678:50;;;6724:1;6721;6714:12;6678:50;6747:22;;6800:4;6792:13;;6788:27;-1:-1:-1;6778:55:82;;6829:1;6826;6819:12;6778:55;6852:74;6918:7;6913:2;6900:16;6895:2;6891;6887:11;6852:74;:::i;:::-;6842:84;;;6265:667;;;;;;;:::o;7122:260::-;7190:6;7198;7251:2;7239:9;7230:7;7226:23;7222:32;7219:52;;;7267:1;7264;7257:12;7219:52;7290:29;7309:9;7290:29;:::i;:::-;7280:39;;7338:38;7372:2;7361:9;7357:18;7338:38;:::i;7569:380::-;7648:1;7644:12;;;;7691;;;7712:61;;7766:4;7758:6;7754:17;7744:27;;7712:61;7819:2;7811:6;7808:14;7788:18;7785:38;7782:161;;7865:10;7860:3;7856:20;7853:1;7846:31;7900:4;7897:1;7890:15;7928:4;7925:1;7918:15;7782:161;;7569:380;;;:::o;9194:413::-;9396:2;9378:21;;;9435:2;9415:18;;;9408:30;9474:34;9469:2;9454:18;;9447:62;-1:-1:-1;;;9540:2:82;9525:18;;9518:47;9597:3;9582:19;;9194:413::o;9612:356::-;9814:2;9796:21;;;9833:18;;;9826:30;9892:34;9887:2;9872:18;;9865:62;9959:2;9944:18;;9612:356::o;10798:127::-;10859:10;10854:3;10850:20;10847:1;10840:31;10890:4;10887:1;10880:15;10914:4;10911:1;10904:15;11751:127;11812:10;11807:3;11803:20;11800:1;11793:31;11843:4;11840:1;11833:15;11867:4;11864:1;11857:15;11883:128;11923:3;11954:1;11950:6;11947:1;11944:13;11941:39;;;11960:18;;:::i;:::-;-1:-1:-1;11996:9:82;;11883:128::o;12016:135::-;12055:3;12076:17;;;12073:43;;12096:18;;:::i;:::-;-1:-1:-1;12143:1:82;12132:13;;12016:135::o;14390:470::-;14569:3;14607:6;14601:13;14623:53;14669:6;14664:3;14657:4;14649:6;14645:17;14623:53;:::i;:::-;14739:13;;14698:16;;;;14761:57;14739:13;14698:16;14795:4;14783:17;;14761:57;:::i;:::-;14834:20;;14390:470;-1:-1:-1;;;;14390:470:82:o;16496:125::-;16536:4;16564:1;16561;16558:8;16555:34;;;16569:18;;:::i;:::-;-1:-1:-1;16606:9:82;;16496:125::o;16980:414::-;17182:2;17164:21;;;17221:2;17201:18;;;17194:30;17260:34;17255:2;17240:18;;17233:62;-1:-1:-1;;;17326:2:82;17311:18;;17304:48;17384:3;17369:19;;16980:414::o;17399:127::-;17460:10;17455:3;17451:20;17448:1;17441:31;17491:4;17488:1;17481:15;17515:4;17512:1;17505:15;17531:120;17571:1;17597;17587:35;;17602:18;;:::i;:::-;-1:-1:-1;17636:9:82;;17531:120::o;17656:112::-;17688:1;17714;17704:35;;17719:18;;:::i;:::-;-1:-1:-1;17753:9:82;;17656:112::o;18176:489::-;-1:-1:-1;;;;;18445:15:82;;;18427:34;;18497:15;;18492:2;18477:18;;18470:43;18544:2;18529:18;;18522:34;;;18592:3;18587:2;18572:18;;18565:31;;;18370:4;;18613:46;;18639:19;;18631:6;18613:46;:::i;:::-;18605:54;18176:489;-1:-1:-1;;;;;;18176:489:82:o;18670:249::-;18739:6;18792:2;18780:9;18771:7;18767:23;18763:32;18760:52;;;18808:1;18805;18798:12;18760:52;18840:9;18834:16;18859:30;18883:5;18859:30;:::i;19642:127::-;19703:10;19698:3;19694:20;19691:1;19684:31;19734:4;19731:1;19724:15;19758:4;19755:1;19748:15

ipfs://f996246cdd1aec30230a5aadf424675feeb82c40e5230faba3446518bfa106ad