Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

contract ReneKeys is ERC721, ERC721Pausable, AccessControl, ERC721Burnable {

    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");

    uint256 private _nextTokenId = 1;
    uint256 public totalSupply = 1000;
    string public baseURI;

    enum MintStatus {
        Paused,
        Whitelisted,
        Public
    }
    MintStatus public status;

    bytes32 public merkleRoot;

    event MerkleRootUpdated(bytes32 indexed _oldMerkleRoot, bytes32 indexed _newMerkleRoot);
    event MintStatusUpdated(MintStatus status_);
    event BaseURIUpdated(string uri);

    constructor(string memory base)
        ERC721("The ReneVerse Founder's Keys", "RFK")
    {
        _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
        _grantRole(PAUSER_ROLE, _msgSender());
        _grantRole(MINTER_ROLE, _msgSender());
        _grantRole(OPERATOR_ROLE, _msgSender());
        baseURI = base;
    }

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

    function pause() public onlyRole(PAUSER_ROLE) {
        _pause();
    }

    function unpause() public onlyRole(PAUSER_ROLE) {
        _unpause();
    }

    function safeMint(address to, bytes32[] calldata _merkleProof)
        public
    {
        require(hasRole(MINTER_ROLE, _msgSender()), "ReneKeys: must have minter role to Mint NFT");
        require(totalSupply > 0, "ReneKeys: All NFTs are minted already.");
        require(status == MintStatus.Whitelisted || status == MintStatus.Public, "ReneKeys: Mint event is not live" );
        if(status == MintStatus.Whitelisted)
        {
            bytes32 leaf = keccak256(abi.encodePacked(to));
            require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "ReneKeys: Not whitelisted address.");
        }
        totalSupply--;
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
    }

    /// @dev Set Base Metadata URI
    /// @param _tokenURI token URI for metadata
    function setBaseURI(string memory _tokenURI) external {
        require(hasRole(OPERATOR_ROLE, _msgSender()), "ReneKeys: must have operator role to set Base URI");
        baseURI = _tokenURI;
        emit BaseURIUpdated(baseURI);
    }

    /// @dev Set Rene NFT Mint event status
    /// @param _status status if Token mint is live
    function setMintStatus(MintStatus _status) external {
        require(hasRole(OPERATOR_ROLE, _msgSender()), "ReneKeys: must have operator role to set NFT Drop status");
        status = _status;
        emit MintStatusUpdated(status);
    }

    /// @dev Update Merkel Root
    /// @param _merkleRoot new merkel rool
    function updateMerkleRoot(bytes32 _merkleRoot) external onlyRole(OPERATOR_ROLE) {
        bytes32 oldMerkleRoot = merkleRoot;
        merkleRoot = _merkleRoot;
        emit MerkleRootUpdated(oldMerkleRoot, _merkleRoot);
    }

    /// @dev Get current merkle root
    /// @return Documents the current merkle root
    function getMerkleRoot() public view returns (bytes32) {
        return merkleRoot;
    }

    // The following functions are overrides required by Solidity.


    function _update(address to, uint256 tokenId, address auth)
        internal
        override(ERC721, ERC721Pausable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }

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

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

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {ERC165} from "../utils/introspection/ERC165.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:
 *
 * ```solidity
 * 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}:
 *
 * ```solidity
 * 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. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

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

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @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 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.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual 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.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual 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 `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @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 Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @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.
     */
    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 `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Receiver} from "./IERC721Receiver.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.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}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => 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 returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(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 {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * 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 {
        _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);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard 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 like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - 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) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. 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
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Burnable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {Context} from "../../../utils/Context.sol";

/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        _update(address(0), tokenId, _msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Pausable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {Pausable} from "../../../utils/Pausable.sol";

/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract pause mechanism of the contract unreachable, and thus unusable.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_update}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual override whenNotPaused returns (address) {
        return super._update(to, tokenId, auth);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../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 (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 address zero.
     *
     * 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 v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @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 (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * 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.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @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 Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(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.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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 (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

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

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

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

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"base","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"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":"string","name":"uri","type":"string"}],"name":"BaseURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"_oldMerkleRoot","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"_newMerkleRoot","type":"bytes32"}],"name":"MerkleRootUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"enum ReneKeys.MintStatus","name":"status_","type":"uint8"}],"name":"MintStatusUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"safeMint","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":"_tokenURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum ReneKeys.MintStatus","name":"_status","type":"uint8"}],"name":"setMintStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"status","outputs":[{"internalType":"enum ReneKeys.MintStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"updateMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d547044785339665a79364e6d6972754d4a3150384a566f6e37685639443747555641647745634d5838624a712f00000000000000000000

-----Decoded View---------------
Arg [0] : base (string): ipfs://QmTpDxS9fZy6NmiruMJ1P8JVon7hV9D7GUVAdwEcMX8bJq/

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [2] : 697066733a2f2f516d547044785339665a79364e6d6972754d4a3150384a566f
Arg [3] : 6e37685639443747555641647745634d5838624a712f00000000000000000000

448:3667:17:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3911:202;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2365:89:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3497:154;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3323:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;777:33:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;924:24;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4143:578:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3810:120:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;955:25:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4226:136:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1754:717:17;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5328:245:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1673:75:17;;;:::i;:::-;;4787:132:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;561:314:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3219:225:17;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3537:89;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2560:236;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1850:84:10;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2185:118:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;816:21:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1920:208:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2898:240:17;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1596:71;;;:::i;:::-;;2854:136:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2518:93:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2187:49:0;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3718:144:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4985:208;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2677:255;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;598:62:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4642:138:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;530:62:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3928:153:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;666:66:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3911:202;4043:4;4070:36;4094:11;4070:23;:36::i;:::-;4063:43;;3911:202;;;:::o;2365:89:3:-;2410:13;2442:5;2435:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2365:89;:::o;3497:154::-;3564:7;3583:22;3597:7;3583:13;:22::i;:::-;;3623:21;3636:7;3623:12;:21::i;:::-;3616:28;;3497:154;;;:::o;3323:113::-;3394:35;3403:2;3407:7;3416:12;:10;:12::i;:::-;3394:8;:35::i;:::-;3323:113;;:::o;777:33:17:-;;;;:::o;924:24::-;;;;;;;;;;;;;:::o;4143:578:3:-;4251:1;4237:16;;:2;:16;;;4233:87;;4306:1;4276:33;;;;;;;;;;;:::i;:::-;;;;;;;;4233:87;4538:21;4562:34;4570:2;4574:7;4583:12;:10;:12::i;:::-;4562:7;:34::i;:::-;4538:58;;4627:4;4610:21;;:13;:21;;;4606:109;;4675:4;4681:7;4690:13;4654:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;4606:109;4223:498;4143:578;;;:::o;3810:120:0:-;3875:7;3901:6;:12;3908:4;3901:12;;;;;;;;;;;:22;;;3894:29;;3810:120;;;:::o;955:25:17:-;;;;:::o;4226:136:0:-;4300:18;4313:4;4300:12;:18::i;:::-;2464:16;2475:4;2464:10;:16::i;:::-;4330:25:::1;4341:4;4347:7;4330:10;:25::i;:::-;;4226:136:::0;;;:::o;1754:717:17:-;1854:34;636:24;1875:12;:10;:12::i;:::-;1854:7;:34::i;:::-;1846:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;1968:1;1954:11;;:15;1946:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;2040:22;2030:32;;;;;;;;:::i;:::-;;:6;;;;;;;;;;;:32;;;;;;;;:::i;:::-;;;:63;;;;2076:17;2066:27;;;;;;;;:::i;:::-;;:6;;;;;;;;;;;:27;;;;;;;;:::i;:::-;;;2030:63;2022:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;2154:22;2144:32;;;;;;;;:::i;:::-;;:6;;;;;;;;;;;:32;;;;;;;;:::i;:::-;;;2141:227;;2200:12;2242:2;2225:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;2215:31;;;;;;2200:46;;2268:50;2287:12;;2268:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2301:10;;2313:4;2268:18;:50::i;:::-;2260:97;;;;;;;;;;;;:::i;:::-;;;;;;;;;2186:182;2141:227;2377:11;;:13;;;;;;;;;:::i;:::-;;;;;;2400:15;2418:12;;:14;;;;;;;;;:::i;:::-;;;;;2400:32;;2442:22;2452:2;2456:7;2442:9;:22::i;:::-;1836:635;1754:717;;;:::o;5328:245:0:-;5443:12;:10;:12::i;:::-;5421:34;;:18;:34;;;5417:102;;5478:30;;;;;;;;;;;;;;5417:102;5529:37;5541:4;5547:18;5529:11;:37::i;:::-;;5328:245;;:::o;1673:75:17:-;568:24;2464:16:0;2475:4;2464:10;:16::i;:::-;1731:10:17::1;:8;:10::i;:::-;1673:75:::0;:::o;4787:132:3:-;4873:39;4890:4;4896:2;4900:7;4873:39;;;;;;;;;;;;:16;:39::i;:::-;4787:132;;;:::o;561:314:6:-;826:42;842:1;846:7;855:12;:10;:12::i;:::-;826:7;:42::i;:::-;;561:314;:::o;3219:225:17:-;706:26;2464:16:0;2475:4;2464:10;:16::i;:::-;3309:21:17::1;3333:10;;3309:34;;3366:11;3353:10;:24;;;;3425:11;3410:13;3392:45;;;;;;;;;;3299:145;3219:225:::0;;:::o;3537:89::-;3583:7;3609:10;;3602:17;;3537:89;:::o;2560:236::-;2632:36;706:26;2655:12;:10;:12::i;:::-;2632:7;:36::i;:::-;2624:98;;;;;;;;;;;;:::i;:::-;;;;;;;;;2742:9;2732:7;:19;;;;;;:::i;:::-;;2766:23;2781:7;2766:23;;;;;;:::i;:::-;;;;;;;;2560:236;:::o;1850:84:10:-;1897:4;1920:7;;;;;;;;;;;1913:14;;1850:84;:::o;2185:118:3:-;2248:7;2274:22;2288:7;2274:13;:22::i;:::-;2267:29;;2185:118;;;:::o;816:21:17:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1920:208:3:-;1983:7;2023:1;2006:19;;:5;:19;;;2002:87;;2075:1;2048:30;;;;;;;;;;;:::i;:::-;;;;;;;;2002:87;2105:9;:16;2115:5;2105:16;;;;;;;;;;;;;;;;2098:23;;1920:208;;;:::o;2898:240:17:-;2968:36;706:26;2991:12;:10;:12::i;:::-;2968:7;:36::i;:::-;2960:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;3084:7;3075:6;;:16;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;3106:25;3124:6;;;;;;;;;;;3106:25;;;;;;:::i;:::-;;;;;;;;2898:240;:::o;1596:71::-;568:24;2464:16:0;2475:4;2464:10;:16::i;:::-;1652:8:17::1;:6;:8::i;:::-;1596:71:::0;:::o;2854:136:0:-;2931:4;2954:6;:12;2961:4;2954:12;;;;;;;;;;;:20;;:29;2975:7;2954:29;;;;;;;;;;;;;;;;;;;;;;;;;2947:36;;2854:136;;;;:::o;2518:93:3:-;2565:13;2597:7;2590:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2518:93;:::o;2187:49:0:-;2232:4;2187:49;;;:::o;3718:144:3:-;3803:52;3822:12;:10;:12::i;:::-;3836:8;3846;3803:18;:52::i;:::-;3718:144;;:::o;4985:208::-;5098:31;5111:4;5117:2;5121:7;5098:12;:31::i;:::-;5139:47;5162:4;5168:2;5172:7;5181:4;5139:22;:47::i;:::-;4985:208;;;;:::o;2677:255::-;2741:13;2766:22;2780:7;2766:13;:22::i;:::-;;2799:21;2823:10;:8;:10::i;:::-;2799:34;;2874:1;2856:7;2850:21;:25;:75;;;;;;;;;;;;;;;;;2892:7;2901:18;:7;:16;:18::i;:::-;2878:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2850:75;2843:82;;;2677:255;;;:::o;598:62:17:-;636:24;598:62;:::o;4642:138:0:-;4717:18;4730:4;4717:12;:18::i;:::-;2464:16;2475:4;2464:10;:16::i;:::-;4747:26:::1;4759:4;4765:7;4747:11;:26::i;:::-;;4642:138:::0;;;:::o;530:62:17:-;568:24;530:62;:::o;3928:153:3:-;4016:4;4039:18;:25;4058:5;4039:25;;;;;;;;;;;;;;;:35;4065:8;4039:35;;;;;;;;;;;;;;;;;;;;;;;;;4032:42;;3928:153;;;;:::o;666:66:17:-;706:26;666:66;:::o;2565:202:0:-;2650:4;2688:32;2673:47;;;:11;:47;;;;:87;;;;2724:36;2748:11;2724:23;:36::i;:::-;2673:87;2666:94;;2565:202;;;:::o;16138:241:3:-;16201:7;16220:13;16236:17;16245:7;16236:8;:17::i;:::-;16220:33;;16284:1;16267:19;;:5;:19;;;16263:88;;16332:7;16309:31;;;;;;;;;;;:::i;:::-;;;;;;;;16263:88;16367:5;16360:12;;;16138:241;;;:::o;5938:127::-;6008:7;6034:15;:24;6050:7;6034:24;;;;;;;;;;;;;;;;;;;;;6027:31;;5938:127;;;:::o;656:96:9:-;709:7;735:10;728:17;;656:96;:::o;14418:120:3:-;14498:33;14507:2;14511:7;14520:4;14526;14498:8;:33::i;:::-;14418:120;;;:::o;3701:204:17:-;3836:7;3866:32;3880:2;3884:7;3893:4;3866:13;:32::i;:::-;3859:39;;3701:204;;;;;:::o;3199:103:0:-;3265:30;3276:4;3282:12;:10;:12::i;:::-;3265:10;:30::i;:::-;3199:103;:::o;6179:316::-;6256:4;6277:22;6285:4;6291:7;6277;:22::i;:::-;6272:217;;6347:4;6315:6;:12;6322:4;6315:12;;;;;;;;;;;:20;;:29;6336:7;6315:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;6397:12;:10;:12::i;:::-;6370:40;;6388:7;6370:40;;6382:4;6370:40;;;;;;;;;;6431:4;6424:11;;;;6272:217;6473:5;6466:12;;6179:316;;;;;:::o;1265:154:12:-;1356:4;1408;1379:25;1392:5;1399:4;1379:12;:25::i;:::-;:33;1372:40;;1265:154;;;;;:::o;10633:100:3:-;10700:26;10710:2;10714:7;10700:26;;;;;;;;;;;;:9;:26::i;:::-;10633:100;;:::o;6730:317:0:-;6808:4;6828:22;6836:4;6842:7;6828;:22::i;:::-;6824:217;;;6898:5;6866:6;:12;6873:4;6866:12;;;;;;;;;;;:20;;:29;6887:7;6866:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;6949:12;:10;:12::i;:::-;6922:40;;6940:7;6922:40;;6934:4;6922:40;;;;;;;;;;6983:4;6976:11;;;;6824:217;7025:5;7018:12;;6730:317;;;;;:::o;2710:117:10:-;1721:16;:14;:16::i;:::-;2778:5:::1;2768:7;;:15;;;;;;;;;;;;;;;;;;2798:22;2807:12;:10;:12::i;:::-;2798:22;;;;;;:::i;:::-;;;;;;;;2710:117::o:0;2463:115::-;1474:19;:17;:19::i;:::-;2532:4:::1;2522:7;;:14;;;;;;;;;;;;;;;;;;2551:20;2558:12;:10;:12::i;:::-;2551:20;;;;;;:::i;:::-;;;;;;;;2463:115::o:0;15591:312:3:-;15718:1;15698:22;;:8;:22;;;15694:91;;15765:8;15743:31;;;;;;;;;;;:::i;:::-;;;;;;;;15694:91;15832:8;15794:18;:25;15813:5;15794:25;;;;;;;;;;;;;;;:35;15820:8;15794:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;15877:8;15855:41;;15870:5;15855:41;;;15887:8;15855:41;;;;;;:::i;:::-;;;;;;;;15591:312;;;:::o;16918:782::-;17051:1;17034:2;:14;;;:18;17030:664;;;17088:2;17072:36;;;17109:12;:10;:12::i;:::-;17123:4;17129:7;17138:4;17072:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;17068:616;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17398:1;17381:6;:13;:18;17377:293;;17452:2;17430:25;;;;;;;;;;;:::i;:::-;;;;;;;;17377:293;17622:6;17616:13;17607:6;17603:2;17599:15;17592:38;17068:616;17200:41;;;17190:51;;;:6;:51;;;;17186:130;;17294:2;17272:25;;;;;;;;;;;:::i;:::-;;;;;;;;17186:130;17144:186;17030:664;16918:782;;;;:::o;1492:98:17:-;1544:13;1576:7;1569:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1492:98;:::o;637:698:11:-;693:13;742:14;779:1;759:17;770:5;759:10;:17::i;:::-;:21;742:38;;794:20;828:6;817:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;794:41;;849:11;975:6;971:2;967:15;959:6;955:28;948:35;;1010:282;1017:4;1010:282;;;1041:5;;;;;;;;1180:10;1175:2;1168:5;1164:14;1159:32;1154:3;1146:46;1236:2;1227:11;;;;;;:::i;:::-;;;;;1269:1;1260:5;:10;1010:282;1256:21;1010:282;1312:6;1305:13;;;;;637:698;;;:::o;1561:300:3:-;1663:4;1713:25;1698:40;;;:11;:40;;;;:104;;;;1769:33;1754:48;;;:11;:48;;;;1698:104;:156;;;;1818:36;1842:11;1818:23;:36::i;:::-;1698:156;1679:175;;1561:300;;;:::o;5707:115::-;5773:7;5799;:16;5807:7;5799:16;;;;;;;;;;;;;;;;;;;;;5792:23;;5707:115;;;:::o;14720:662::-;14880:9;:31;;;;14909:1;14893:18;;:4;:18;;;;14880:31;14876:460;;;14927:13;14943:22;14957:7;14943:13;:22::i;:::-;14927:38;;15109:1;15093:18;;:4;:18;;;;:35;;;;;15124:4;15115:13;;:5;:13;;;;15093:35;:69;;;;;15133:29;15150:5;15157:4;15133:16;:29::i;:::-;15132:30;15093:69;15089:142;;;15211:4;15189:27;;;;;;;;;;;:::i;:::-;;;;;;;;15089:142;15249:9;15245:81;;;15303:7;15299:2;15283:28;;15292:5;15283:28;;;;;;;;;;;;15245:81;14913:423;14876:460;15373:2;15346:15;:24;15362:7;15346:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;14720:662;;;;:::o;1120:204:7:-;1259:7;1474:19:10;:17;:19::i;:::-;1285:32:7::1;1299:2;1303:7;1312:4;1285:13;:32::i;:::-;1278:39;;1120:204:::0;;;;;:::o;3432:197:0:-;3520:22;3528:4;3534:7;3520;:22::i;:::-;3515:108;;3598:7;3607:4;3565:47;;;;;;;;;;;;:::i;:::-;;;;;;;;3515:108;3432:197;;:::o;1967:290:12:-;2050:7;2069:20;2092:4;2069:27;;2111:9;2106:116;2130:5;:12;2126:1;:16;2106:116;;;2178:33;2188:12;2202:5;2208:1;2202:8;;;;;;;;:::i;:::-;;;;;;;;2178:9;:33::i;:::-;2163:48;;2144:3;;;;;:::i;:::-;;;;2106:116;;;;2238:12;2231:19;;;1967:290;;;;:::o;10954:182:3:-;11048:18;11054:2;11058:7;11048:5;:18::i;:::-;11076:53;11107:1;11111:2;11115:7;11124:4;11076:22;:53::i;:::-;10954:182;;;:::o;2202:126:10:-;2265:8;:6;:8::i;:::-;2260:62;;2296:15;;;;;;;;;;;;;;2260:62;2202:126::o;2002:128::-;2067:8;:6;:8::i;:::-;2063:61;;;2098:15;;;;;;;;;;;;;;2063:61;2002:128::o;12214:916:15:-;12267:7;12286:14;12303:1;12286:18;;12351:8;12342:5;:17;12338:103;;12388:8;12379:17;;;;;;:::i;:::-;;;;;12424:2;12414:12;;;;12338:103;12467:8;12458:5;:17;12454:103;;12504:8;12495:17;;;;;;:::i;:::-;;;;;12540:2;12530:12;;;;12454:103;12583:8;12574:5;:17;12570:103;;12620:8;12611:17;;;;;;:::i;:::-;;;;;12656:2;12646:12;;;;12570:103;12699:7;12690:5;:16;12686:100;;12735:7;12726:16;;;;;;:::i;:::-;;;;;12770:1;12760:11;;;;12686:100;12812:7;12803:5;:16;12799:100;;12848:7;12839:16;;;;;;:::i;:::-;;;;;12883:1;12873:11;;;;12799:100;12925:7;12916:5;:16;12912:100;;12961:7;12952:16;;;;;;:::i;:::-;;;;;12996:1;12986:11;;;;12912:100;13038:7;13029:5;:16;13025:66;;13075:1;13065:11;;;;13025:66;13117:6;13110:13;;;12214:916;;;:::o;762:146:13:-;838:4;876:25;861:40;;;:11;:40;;;;854:47;;762:146;;;:::o;8838:795:3:-;8924:7;8943:12;8958:17;8967:7;8958:8;:17::i;:::-;8943:32;;9051:1;9035:18;;:4;:18;;;9031:86;;9069:37;9086:4;9092;9098:7;9069:16;:37::i;:::-;9031:86;9177:1;9161:18;;:4;:18;;;9157:256;;9277:48;9294:1;9298:7;9315:1;9319:5;9277:8;:48::i;:::-;9387:1;9368:9;:15;9378:4;9368:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;9157:256;9441:1;9427:16;;:2;:16;;;9423:107;;9504:1;9487:9;:13;9497:2;9487:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;9423:107;9559:2;9540:7;:16;9548:7;9540:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;9596:7;9592:2;9577:27;;9586:4;9577:27;;;;;;;;;;;;9622:4;9615:11;;;8838:795;;;;;:::o;9229:147:12:-;9292:7;9322:1;9318;:5;:51;;9349:20;9364:1;9367;9349:14;:20::i;:::-;9318:51;;;9326:20;9341:1;9344;9326:14;:20::i;:::-;9318:51;9311:58;;9229:147;;;;:::o;9955:327:3:-;10036:1;10022:16;;:2;:16;;;10018:87;;10091:1;10061:33;;;;;;;;;;;:::i;:::-;;;;;;;;10018:87;10114:21;10138:32;10146:2;10150:7;10167:1;10138:7;:32::i;:::-;10114:56;;10209:1;10184:27;;:13;:27;;;10180:96;;10262:1;10234:31;;;;;;;;;;;:::i;:::-;;;;;;;;10180:96;10008:274;9955:327;;:::o;7082:368::-;7194:38;7208:5;7215:7;7224;7194:13;:38::i;:::-;7189:255;;7269:1;7252:19;;:5;:19;;;7248:186;;7321:7;7298:31;;;;;;;;;;;:::i;:::-;;;;;;;;7248:186;7402:7;7411;7375:44;;;;;;;;;;;;:::i;:::-;;;;;;;;7189:255;7082:368;;;:::o;9496:261:12:-;9564:13;9668:1;9662:4;9655:15;9696:1;9690:4;9683:15;9736:4;9730;9720:21;9711:30;;9496:261;;;;:::o;6376:272:3:-;6479:4;6533:1;6514:21;;:7;:21;;;;:127;;;;;6561:7;6552:16;;:5;:16;;;:52;;;;6572:32;6589:5;6596:7;6572:16;:32::i;:::-;6552:52;:88;;;;6633:7;6608:32;;:21;6621:7;6608:12;:21::i;:::-;:32;;;6552:88;6514:127;6495:146;;6376:272;;;;;:::o;7:75:18:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:180::-;5290:77;5287:1;5280:88;5387:4;5384:1;5377:15;5411:4;5408:1;5401:15;5428:120;5516:1;5509:5;5506:12;5496:46;;5522:18;;:::i;:::-;5496:46;5428:120;:::o;5554:141::-;5606:7;5635:5;5624:16;;5641:48;5683:5;5641:48;:::i;:::-;5554:141;;;:::o;5701:::-;5764:9;5797:39;5830:5;5797:39;:::i;:::-;5784:52;;5701:141;;;:::o;5848:157::-;5948:50;5992:5;5948:50;:::i;:::-;5943:3;5936:63;5848:157;;:::o;6011:248::-;6117:4;6155:2;6144:9;6140:18;6132:26;;6168:84;6249:1;6238:9;6234:17;6225:6;6168:84;:::i;:::-;6011:248;;;;:::o;6265:619::-;6342:6;6350;6358;6407:2;6395:9;6386:7;6382:23;6378:32;6375:119;;;6413:79;;:::i;:::-;6375:119;6533:1;6558:53;6603:7;6594:6;6583:9;6579:22;6558:53;:::i;:::-;6548:63;;6504:117;6660:2;6686:53;6731:7;6722:6;6711:9;6707:22;6686:53;:::i;:::-;6676:63;;6631:118;6788:2;6814:53;6859:7;6850:6;6839:9;6835:22;6814:53;:::i;:::-;6804:63;;6759:118;6265:619;;;;;:::o;6890:77::-;6927:7;6956:5;6945:16;;6890:77;;;:::o;6973:122::-;7046:24;7064:5;7046:24;:::i;:::-;7039:5;7036:35;7026:63;;7085:1;7082;7075:12;7026:63;6973:122;:::o;7101:139::-;7147:5;7185:6;7172:20;7163:29;;7201:33;7228:5;7201:33;:::i;:::-;7101:139;;;;:::o;7246:329::-;7305:6;7354:2;7342:9;7333:7;7329:23;7325:32;7322:119;;;7360:79;;:::i;:::-;7322:119;7480:1;7505:53;7550:7;7541:6;7530:9;7526:22;7505:53;:::i;:::-;7495:63;;7451:117;7246:329;;;;:::o;7581:118::-;7668:24;7686:5;7668:24;:::i;:::-;7663:3;7656:37;7581:118;;:::o;7705:222::-;7798:4;7836:2;7825:9;7821:18;7813:26;;7849:71;7917:1;7906:9;7902:17;7893:6;7849:71;:::i;:::-;7705:222;;;;:::o;7933:474::-;8001:6;8009;8058:2;8046:9;8037:7;8033:23;8029:32;8026:119;;;8064:79;;:::i;:::-;8026:119;8184:1;8209:53;8254:7;8245:6;8234:9;8230:22;8209:53;:::i;:::-;8199:63;;8155:117;8311:2;8337:53;8382:7;8373:6;8362:9;8358:22;8337:53;:::i;:::-;8327:63;;8282:118;7933:474;;;;;:::o;8413:117::-;8522:1;8519;8512:12;8536:117;8645:1;8642;8635:12;8659:117;8768:1;8765;8758:12;8799:568;8872:8;8882:6;8932:3;8925:4;8917:6;8913:17;8909:27;8899:122;;8940:79;;:::i;:::-;8899:122;9053:6;9040:20;9030:30;;9083:18;9075:6;9072:30;9069:117;;;9105:79;;:::i;:::-;9069:117;9219:4;9211:6;9207:17;9195:29;;9273:3;9265:4;9257:6;9253:17;9243:8;9239:32;9236:41;9233:128;;;9280:79;;:::i;:::-;9233:128;8799:568;;;;;:::o;9373:704::-;9468:6;9476;9484;9533:2;9521:9;9512:7;9508:23;9504:32;9501:119;;;9539:79;;:::i;:::-;9501:119;9659:1;9684:53;9729:7;9720:6;9709:9;9705:22;9684:53;:::i;:::-;9674:63;;9630:117;9814:2;9803:9;9799:18;9786:32;9845:18;9837:6;9834:30;9831:117;;;9867:79;;:::i;:::-;9831:117;9980:80;10052:7;10043:6;10032:9;10028:22;9980:80;:::i;:::-;9962:98;;;;9757:313;9373:704;;;;;:::o;10083:117::-;10192:1;10189;10182:12;10206:180;10254:77;10251:1;10244:88;10351:4;10348:1;10341:15;10375:4;10372:1;10365:15;10392:281;10475:27;10497:4;10475:27;:::i;:::-;10467:6;10463:40;10605:6;10593:10;10590:22;10569:18;10557:10;10554:34;10551:62;10548:88;;;10616:18;;:::i;:::-;10548:88;10656:10;10652:2;10645:22;10435:238;10392:281;;:::o;10679:129::-;10713:6;10740:20;;:::i;:::-;10730:30;;10769:33;10797:4;10789:6;10769:33;:::i;:::-;10679:129;;;:::o;10814:308::-;10876:4;10966:18;10958:6;10955:30;10952:56;;;10988:18;;:::i;:::-;10952:56;11026:29;11048:6;11026:29;:::i;:::-;11018:37;;11110:4;11104;11100:15;11092:23;;10814:308;;;:::o;11128:146::-;11225:6;11220:3;11215;11202:30;11266:1;11257:6;11252:3;11248:16;11241:27;11128:146;;;:::o;11280:425::-;11358:5;11383:66;11399:49;11441:6;11399:49;:::i;:::-;11383:66;:::i;:::-;11374:75;;11472:6;11465:5;11458:21;11510:4;11503:5;11499:16;11548:3;11539:6;11534:3;11530:16;11527:25;11524:112;;;11555:79;;:::i;:::-;11524:112;11645:54;11692:6;11687:3;11682;11645:54;:::i;:::-;11364:341;11280:425;;;;;:::o;11725:340::-;11781:5;11830:3;11823:4;11815:6;11811:17;11807:27;11797:122;;11838:79;;:::i;:::-;11797:122;11955:6;11942:20;11980:79;12055:3;12047:6;12040:4;12032:6;12028:17;11980:79;:::i;:::-;11971:88;;11787:278;11725:340;;;;:::o;12071:509::-;12140:6;12189:2;12177:9;12168:7;12164:23;12160:32;12157:119;;;12195:79;;:::i;:::-;12157:119;12343:1;12332:9;12328:17;12315:31;12373:18;12365:6;12362:30;12359:117;;;12395:79;;:::i;:::-;12359:117;12500:63;12555:7;12546:6;12535:9;12531:22;12500:63;:::i;:::-;12490:73;;12286:287;12071:509;;;;:::o;12586:329::-;12645:6;12694:2;12682:9;12673:7;12669:23;12665:32;12662:119;;;12700:79;;:::i;:::-;12662:119;12820:1;12845:53;12890:7;12881:6;12870:9;12866:22;12845:53;:::i;:::-;12835:63;;12791:117;12586:329;;;;:::o;12921:114::-;13009:1;13002:5;12999:12;12989:40;;13025:1;13022;13015:12;12989:40;12921:114;:::o;13041:169::-;13102:5;13140:6;13127:20;13118:29;;13156:48;13198:5;13156:48;:::i;:::-;13041:169;;;;:::o;13216:359::-;13290:6;13339:2;13327:9;13318:7;13314:23;13310:32;13307:119;;;13345:79;;:::i;:::-;13307:119;13465:1;13490:68;13550:7;13541:6;13530:9;13526:22;13490:68;:::i;:::-;13480:78;;13436:132;13216:359;;;;:::o;13581:116::-;13651:21;13666:5;13651:21;:::i;:::-;13644:5;13641:32;13631:60;;13687:1;13684;13677:12;13631:60;13581:116;:::o;13703:133::-;13746:5;13784:6;13771:20;13762:29;;13800:30;13824:5;13800:30;:::i;:::-;13703:133;;;;:::o;13842:468::-;13907:6;13915;13964:2;13952:9;13943:7;13939:23;13935:32;13932:119;;;13970:79;;:::i;:::-;13932:119;14090:1;14115:53;14160:7;14151:6;14140:9;14136:22;14115:53;:::i;:::-;14105:63;;14061:117;14217:2;14243:50;14285:7;14276:6;14265:9;14261:22;14243:50;:::i;:::-;14233:60;;14188:115;13842:468;;;;;:::o;14316:307::-;14377:4;14467:18;14459:6;14456:30;14453:56;;;14489:18;;:::i;:::-;14453:56;14527:29;14549:6;14527:29;:::i;:::-;14519:37;;14611:4;14605;14601:15;14593:23;;14316:307;;;:::o;14629:423::-;14706:5;14731:65;14747:48;14788:6;14747:48;:::i;:::-;14731:65;:::i;:::-;14722:74;;14819:6;14812:5;14805:21;14857:4;14850:5;14846:16;14895:3;14886:6;14881:3;14877:16;14874:25;14871:112;;;14902:79;;:::i;:::-;14871:112;14992:54;15039:6;15034:3;15029;14992:54;:::i;:::-;14712:340;14629:423;;;;;:::o;15071:338::-;15126:5;15175:3;15168:4;15160:6;15156:17;15152:27;15142:122;;15183:79;;:::i;:::-;15142:122;15300:6;15287:20;15325:78;15399:3;15391:6;15384:4;15376:6;15372:17;15325:78;:::i;:::-;15316:87;;15132:277;15071:338;;;;:::o;15415:943::-;15510:6;15518;15526;15534;15583:3;15571:9;15562:7;15558:23;15554:33;15551:120;;;15590:79;;:::i;:::-;15551:120;15710:1;15735:53;15780:7;15771:6;15760:9;15756:22;15735:53;:::i;:::-;15725:63;;15681:117;15837:2;15863:53;15908:7;15899:6;15888:9;15884:22;15863:53;:::i;:::-;15853:63;;15808:118;15965:2;15991:53;16036:7;16027:6;16016:9;16012:22;15991:53;:::i;:::-;15981:63;;15936:118;16121:2;16110:9;16106:18;16093:32;16152:18;16144:6;16141:30;16138:117;;;16174:79;;:::i;:::-;16138:117;16279:62;16333:7;16324:6;16313:9;16309:22;16279:62;:::i;:::-;16269:72;;16064:287;15415:943;;;;;;;:::o;16364:474::-;16432:6;16440;16489:2;16477:9;16468:7;16464:23;16460:32;16457:119;;;16495:79;;:::i;:::-;16457:119;16615:1;16640:53;16685:7;16676:6;16665:9;16661:22;16640:53;:::i;:::-;16630:63;;16586:117;16742:2;16768:53;16813:7;16804:6;16793:9;16789:22;16768:53;:::i;:::-;16758:63;;16713:118;16364:474;;;;;:::o;16844:180::-;16892:77;16889:1;16882:88;16989:4;16986:1;16979:15;17013:4;17010:1;17003:15;17030:320;17074:6;17111:1;17105:4;17101:12;17091:22;;17158:1;17152:4;17148:12;17179:18;17169:81;;17235:4;17227:6;17223:17;17213:27;;17169:81;17297:2;17289:6;17286:14;17266:18;17263:38;17260:84;;17316:18;;:::i;:::-;17260:84;17081:269;17030:320;;;:::o;17356:442::-;17505:4;17543:2;17532:9;17528:18;17520:26;;17556:71;17624:1;17613:9;17609:17;17600:6;17556:71;:::i;:::-;17637:72;17705:2;17694:9;17690:18;17681:6;17637:72;:::i;:::-;17719;17787:2;17776:9;17772:18;17763:6;17719:72;:::i;:::-;17356:442;;;;;;:::o;17804:230::-;17944:34;17940:1;17932:6;17928:14;17921:58;18013:13;18008:2;18000:6;17996:15;17989:38;17804:230;:::o;18040:366::-;18182:3;18203:67;18267:2;18262:3;18203:67;:::i;:::-;18196:74;;18279:93;18368:3;18279:93;:::i;:::-;18397:2;18392:3;18388:12;18381:19;;18040:366;;;:::o;18412:419::-;18578:4;18616:2;18605:9;18601:18;18593:26;;18665:9;18659:4;18655:20;18651:1;18640:9;18636:17;18629:47;18693:131;18819:4;18693:131;:::i;:::-;18685:139;;18412:419;;;:::o;18837:225::-;18977:34;18973:1;18965:6;18961:14;18954:58;19046:8;19041:2;19033:6;19029:15;19022:33;18837:225;:::o;19068:366::-;19210:3;19231:67;19295:2;19290:3;19231:67;:::i;:::-;19224:74;;19307:93;19396:3;19307:93;:::i;:::-;19425:2;19420:3;19416:12;19409:19;;19068:366;;;:::o;19440:419::-;19606:4;19644:2;19633:9;19629:18;19621:26;;19693:9;19687:4;19683:20;19679:1;19668:9;19664:17;19657:47;19721:131;19847:4;19721:131;:::i;:::-;19713:139;;19440:419;;;:::o;19865:182::-;20005:34;20001:1;19993:6;19989:14;19982:58;19865:182;:::o;20053:366::-;20195:3;20216:67;20280:2;20275:3;20216:67;:::i;:::-;20209:74;;20292:93;20381:3;20292:93;:::i;:::-;20410:2;20405:3;20401:12;20394:19;;20053:366;;;:::o;20425:419::-;20591:4;20629:2;20618:9;20614:18;20606:26;;20678:9;20672:4;20668:20;20664:1;20653:9;20649:17;20642:47;20706:131;20832:4;20706:131;:::i;:::-;20698:139;;20425:419;;;:::o;20850:94::-;20883:8;20931:5;20927:2;20923:14;20902:35;;20850:94;;;:::o;20950:::-;20989:7;21018:20;21032:5;21018:20;:::i;:::-;21007:31;;20950:94;;;:::o;21050:100::-;21089:7;21118:26;21138:5;21118:26;:::i;:::-;21107:37;;21050:100;;;:::o;21156:157::-;21261:45;21281:24;21299:5;21281:24;:::i;:::-;21261:45;:::i;:::-;21256:3;21249:58;21156:157;;:::o;21319:256::-;21431:3;21446:75;21517:3;21508:6;21446:75;:::i;:::-;21546:2;21541:3;21537:12;21530:19;;21566:3;21559:10;;21319:256;;;;:::o;21581:221::-;21721:34;21717:1;21709:6;21705:14;21698:58;21790:4;21785:2;21777:6;21773:15;21766:29;21581:221;:::o;21808:366::-;21950:3;21971:67;22035:2;22030:3;21971:67;:::i;:::-;21964:74;;22047:93;22136:3;22047:93;:::i;:::-;22165:2;22160:3;22156:12;22149:19;;21808:366;;;:::o;22180:419::-;22346:4;22384:2;22373:9;22369:18;22361:26;;22433:9;22427:4;22423:20;22419:1;22408:9;22404:17;22397:47;22461:131;22587:4;22461:131;:::i;:::-;22453:139;;22180:419;;;:::o;22605:180::-;22653:77;22650:1;22643:88;22750:4;22747:1;22740:15;22774:4;22771:1;22764:15;22791:171;22830:3;22853:24;22871:5;22853:24;:::i;:::-;22844:33;;22899:4;22892:5;22889:15;22886:41;;22907:18;;:::i;:::-;22886:41;22954:1;22947:5;22943:13;22936:20;;22791:171;;;:::o;22968:233::-;23007:3;23030:24;23048:5;23030:24;:::i;:::-;23021:33;;23076:66;23069:5;23066:77;23063:103;;23146:18;;:::i;:::-;23063:103;23193:1;23186:5;23182:13;23175:20;;22968:233;;;:::o;23207:236::-;23347:34;23343:1;23335:6;23331:14;23324:58;23416:19;23411:2;23403:6;23399:15;23392:44;23207:236;:::o;23449:366::-;23591:3;23612:67;23676:2;23671:3;23612:67;:::i;:::-;23605:74;;23688:93;23777:3;23688:93;:::i;:::-;23806:2;23801:3;23797:12;23790:19;;23449:366;;;:::o;23821:419::-;23987:4;24025:2;24014:9;24010:18;24002:26;;24074:9;24068:4;24064:20;24060:1;24049:9;24045:17;24038:47;24102:131;24228:4;24102:131;:::i;:::-;24094:139;;23821:419;;;:::o;24246:141::-;24295:4;24318:3;24310:11;;24341:3;24338:1;24331:14;24375:4;24372:1;24362:18;24354:26;;24246:141;;;:::o;24393:93::-;24430:6;24477:2;24472;24465:5;24461:14;24457:23;24447:33;;24393:93;;;:::o;24492:107::-;24536:8;24586:5;24580:4;24576:16;24555:37;;24492:107;;;;:::o;24605:393::-;24674:6;24724:1;24712:10;24708:18;24747:97;24777:66;24766:9;24747:97;:::i;:::-;24865:39;24895:8;24884:9;24865:39;:::i;:::-;24853:51;;24937:4;24933:9;24926:5;24922:21;24913:30;;24986:4;24976:8;24972:19;24965:5;24962:30;24952:40;;24681:317;;24605:393;;;;;:::o;25004:60::-;25032:3;25053:5;25046:12;;25004:60;;;:::o;25070:142::-;25120:9;25153:53;25171:34;25180:24;25198:5;25180:24;:::i;:::-;25171:34;:::i;:::-;25153:53;:::i;:::-;25140:66;;25070:142;;;:::o;25218:75::-;25261:3;25282:5;25275:12;;25218:75;;;:::o;25299:269::-;25409:39;25440:7;25409:39;:::i;:::-;25470:91;25519:41;25543:16;25519:41;:::i;:::-;25511:6;25504:4;25498:11;25470:91;:::i;:::-;25464:4;25457:105;25375:193;25299:269;;;:::o;25574:73::-;25619:3;25574:73;:::o;25653:189::-;25730:32;;:::i;:::-;25771:65;25829:6;25821;25815:4;25771:65;:::i;:::-;25706:136;25653:189;;:::o;25848:186::-;25908:120;25925:3;25918:5;25915:14;25908:120;;;25979:39;26016:1;26009:5;25979:39;:::i;:::-;25952:1;25945:5;25941:13;25932:22;;25908:120;;;25848:186;;:::o;26040:543::-;26141:2;26136:3;26133:11;26130:446;;;26175:38;26207:5;26175:38;:::i;:::-;26259:29;26277:10;26259:29;:::i;:::-;26249:8;26245:44;26442:2;26430:10;26427:18;26424:49;;;26463:8;26448:23;;26424:49;26486:80;26542:22;26560:3;26542:22;:::i;:::-;26532:8;26528:37;26515:11;26486:80;:::i;:::-;26145:431;;26130:446;26040:543;;;:::o;26589:117::-;26643:8;26693:5;26687:4;26683:16;26662:37;;26589:117;;;;:::o;26712:169::-;26756:6;26789:51;26837:1;26833:6;26825:5;26822:1;26818:13;26789:51;:::i;:::-;26785:56;26870:4;26864;26860:15;26850:25;;26763:118;26712:169;;;;:::o;26886:295::-;26962:4;27108:29;27133:3;27127:4;27108:29;:::i;:::-;27100:37;;27170:3;27167:1;27163:11;27157:4;27154:21;27146:29;;26886:295;;;;:::o;27186:1395::-;27303:37;27336:3;27303:37;:::i;:::-;27405:18;27397:6;27394:30;27391:56;;;27427:18;;:::i;:::-;27391:56;27471:38;27503:4;27497:11;27471:38;:::i;:::-;27556:67;27616:6;27608;27602:4;27556:67;:::i;:::-;27650:1;27674:4;27661:17;;27706:2;27698:6;27695:14;27723:1;27718:618;;;;28380:1;28397:6;28394:77;;;28446:9;28441:3;28437:19;28431:26;28422:35;;28394:77;28497:67;28557:6;28550:5;28497:67;:::i;:::-;28491:4;28484:81;28353:222;27688:887;;27718:618;27770:4;27766:9;27758:6;27754:22;27804:37;27836:4;27804:37;:::i;:::-;27863:1;27877:208;27891:7;27888:1;27885:14;27877:208;;;27970:9;27965:3;27961:19;27955:26;27947:6;27940:42;28021:1;28013:6;28009:14;27999:24;;28068:2;28057:9;28053:18;28040:31;;27914:4;27911:1;27907:12;27902:17;;27877:208;;;28113:6;28104:7;28101:19;28098:179;;;28171:9;28166:3;28162:19;28156:26;28214:48;28256:4;28248:6;28244:17;28233:9;28214:48;:::i;:::-;28206:6;28199:64;28121:156;28098:179;28323:1;28319;28311:6;28307:14;28303:22;28297:4;28290:36;27725:611;;;27688:887;;27278:1303;;;27186:1395;;:::o;28611:831::-;28696:3;28733:5;28727:12;28762:36;28788:9;28762:36;:::i;:::-;28814:71;28878:6;28873:3;28814:71;:::i;:::-;28807:78;;28916:1;28905:9;28901:17;28932:1;28927:164;;;;29105:1;29100:336;;;;28894:542;;28927:164;29011:4;29007:9;28996;28992:25;28987:3;28980:38;29071:6;29064:14;29057:22;29051:4;29047:33;29042:3;29038:43;29031:50;;28927:164;;29100:336;29167:38;29199:5;29167:38;:::i;:::-;29227:1;29241:154;29255:6;29252:1;29249:13;29241:154;;;29329:7;29323:14;29319:1;29314:3;29310:11;29303:35;29379:1;29370:7;29366:15;29355:26;;29277:4;29274:1;29270:12;29265:17;;29241:154;;;29424:1;29419:3;29415:11;29408:18;;29107:329;;28894:542;;28700:742;;28611:831;;;;:::o;29448:307::-;29558:4;29596:2;29585:9;29581:18;29573:26;;29645:9;29639:4;29635:20;29631:1;29620:9;29616:17;29609:47;29673:75;29743:4;29734:6;29673:75;:::i;:::-;29665:83;;29448:307;;;;:::o;29761:243::-;29901:34;29897:1;29889:6;29885:14;29878:58;29970:26;29965:2;29957:6;29953:15;29946:51;29761:243;:::o;30010:366::-;30152:3;30173:67;30237:2;30232:3;30173:67;:::i;:::-;30166:74;;30249:93;30338:3;30249:93;:::i;:::-;30367:2;30362:3;30358:12;30351:19;;30010:366;;;:::o;30382:419::-;30548:4;30586:2;30575:9;30571:18;30563:26;;30635:9;30629:4;30625:20;30621:1;30610:9;30606:17;30599:47;30663:131;30789:4;30663:131;:::i;:::-;30655:139;;30382:419;;;:::o;30807:148::-;30909:11;30946:3;30931:18;;30807:148;;;;:::o;30961:390::-;31067:3;31095:39;31128:5;31095:39;:::i;:::-;31150:89;31232:6;31227:3;31150:89;:::i;:::-;31143:96;;31248:65;31306:6;31301:3;31294:4;31287:5;31283:16;31248:65;:::i;:::-;31338:6;31333:3;31329:16;31322:23;;31071:280;30961:390;;;;:::o;31357:435::-;31537:3;31559:95;31650:3;31641:6;31559:95;:::i;:::-;31552:102;;31671:95;31762:3;31753:6;31671:95;:::i;:::-;31664:102;;31783:3;31776:10;;31357:435;;;;;:::o;31798:98::-;31849:6;31883:5;31877:12;31867:22;;31798:98;;;:::o;31902:168::-;31985:11;32019:6;32014:3;32007:19;32059:4;32054:3;32050:14;32035:29;;31902:168;;;;:::o;32076:373::-;32162:3;32190:38;32222:5;32190:38;:::i;:::-;32244:70;32307:6;32302:3;32244:70;:::i;:::-;32237:77;;32323:65;32381:6;32376:3;32369:4;32362:5;32358:16;32323:65;:::i;:::-;32413:29;32435:6;32413:29;:::i;:::-;32408:3;32404:39;32397:46;;32166:283;32076:373;;;;:::o;32455:640::-;32650:4;32688:3;32677:9;32673:19;32665:27;;32702:71;32770:1;32759:9;32755:17;32746:6;32702:71;:::i;:::-;32783:72;32851:2;32840:9;32836:18;32827:6;32783:72;:::i;:::-;32865;32933:2;32922:9;32918:18;32909:6;32865:72;:::i;:::-;32984:9;32978:4;32974:20;32969:2;32958:9;32954:18;32947:48;33012:76;33083:4;33074:6;33012:76;:::i;:::-;33004:84;;32455:640;;;;;;;:::o;33101:141::-;33157:5;33188:6;33182:13;33173:22;;33204:32;33230:5;33204:32;:::i;:::-;33101:141;;;;:::o;33248:349::-;33317:6;33366:2;33354:9;33345:7;33341:23;33337:32;33334:119;;;33372:79;;:::i;:::-;33334:119;33492:1;33517:63;33572:7;33563:6;33552:9;33548:22;33517:63;:::i;:::-;33507:73;;33463:127;33248:349;;;;:::o;33603:180::-;33651:77;33648:1;33641:88;33748:4;33745:1;33738:15;33772:4;33769:1;33762:15;33789:332;33910:4;33948:2;33937:9;33933:18;33925:26;;33961:71;34029:1;34018:9;34014:17;34005:6;33961:71;:::i;:::-;34042:72;34110:2;34099:9;34095:18;34086:6;34042:72;:::i;:::-;33789:332;;;;;:::o;34127:180::-;34175:77;34172:1;34165:88;34272:4;34269:1;34262:15;34296:4;34293:1;34286:15;34313:332;34434:4;34472:2;34461:9;34457:18;34449:26;;34485:71;34553:1;34542:9;34538:17;34529:6;34485:71;:::i;:::-;34566:72;34634:2;34623:9;34619:18;34610:6;34566:72;:::i;:::-;34313:332;;;;;:::o

ipfs://1246b2256792e795c4f322f85e895ee57f17df004c8b016f9dc8e23c1d4b0013