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

pragma solidity ^0.8.20;

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

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }
}

// 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/ECDSA.sol)

pragma solidity ^0.8.20;

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

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

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

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

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

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

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

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

        return (signer, RecoverError.NoError, bytes32(0));
    }

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

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

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

pragma solidity ^0.8.20;

import {IERC1155} from "./IERC1155.sol";
import {IERC1155Receiver} from "./IERC1155Receiver.sol";
import {IERC1155MetadataURI} from "./extensions/IERC1155MetadataURI.sol";
import {Context} from "../../utils/Context.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {Arrays} from "../../utils/Arrays.sol";
import {IERC1155Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 */
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors {
    using Arrays for uint256[];
    using Arrays for address[];

    mapping(uint256 id => mapping(address account => uint256)) private _balances;

    mapping(address account => mapping(address operator => bool)) private _operatorApprovals;

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

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

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

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

    /**
     * @dev See {IERC1155-balanceOf}.
     */
    function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
        return _balances[id][account];
    }

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

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

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

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeTransferFrom(from, to, id, value, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeBatchTransferFrom(from, to, ids, values, data);
    }

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from`
     * (or `to`) is the zero address.
     *
     * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received}
     *   or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
     * - `ids` and `values` must have the same length.
     *
     * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead.
     */
    function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual {
        if (ids.length != values.length) {
            revert ERC1155InvalidArrayLength(ids.length, values.length);
        }

        address operator = _msgSender();

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids.unsafeMemoryAccess(i);
            uint256 value = values.unsafeMemoryAccess(i);

            if (from != address(0)) {
                uint256 fromBalance = _balances[id][from];
                if (fromBalance < value) {
                    revert ERC1155InsufficientBalance(from, fromBalance, value, id);
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance
                    _balances[id][from] = fromBalance - value;
                }
            }

            if (to != address(0)) {
                _balances[id][to] += value;
            }
        }

        if (ids.length == 1) {
            uint256 id = ids.unsafeMemoryAccess(0);
            uint256 value = values.unsafeMemoryAccess(0);
            emit TransferSingle(operator, from, to, id, value);
        } else {
            emit TransferBatch(operator, from, to, ids, values);
        }
    }

    /**
     * @dev Version of {_update} that performs the token acceptance check by calling
     * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it
     * contains code (eg. is a smart contract at the moment of execution).
     *
     * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any
     * update to the contract state after this function would break the check-effect-interaction pattern. Consider
     * overriding {_update} instead.
     */
    function _updateWithAcceptanceCheck(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal virtual {
        _update(from, to, ids, values);
        if (to != address(0)) {
            address operator = _msgSender();
            if (ids.length == 1) {
                uint256 id = ids.unsafeMemoryAccess(0);
                uint256 value = values.unsafeMemoryAccess(0);
                _doSafeTransferAcceptanceCheck(operator, from, to, id, value, data);
            } else {
                _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, values, data);
            }
        }
    }

    /**
     * @dev Transfers a `value` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     * - `ids` and `values` must have the same length.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

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

    /**
     * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

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

    /**
     * @dev Destroys a `value` amount of tokens of type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     */
    function _burn(address from, uint256 id, uint256 value) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     * - `ids` and `values` must have the same length.
     */
    function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

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

    /**
     * @dev Performs an acceptance check by calling {IERC1155-onERC1155Received} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Performs a batch acceptance check by calling {IERC1155-onERC1155BatchReceived} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Creates an array in memory with only one value for each of the elements provided.
     */
    function _asSingletonArrays(
        uint256 element1,
        uint256 element2
    ) private pure returns (uint256[] memory array1, uint256[] memory array2) {
        /// @solidity memory-safe-assembly
        assembly {
            // Load the free memory pointer
            array1 := mload(0x40)
            // Set array length to 1
            mstore(array1, 1)
            // Store the single element at the next word after the length (where content starts)
            mstore(add(array1, 0x20), element1)

            // Repeat for next array locating it right after the first array
            array2 := add(array1, 0x40)
            mstore(array2, 1)
            mstore(add(array2, 0x20), element2)

            // Update the free memory pointer by pointing after the second array
            mstore(0x40, add(array2, 0x40))
        }
    }
}

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

pragma solidity ^0.8.20;

import {ERC1155} from "../ERC1155.sol";

/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(address account, uint256 id, uint256 value) public virtual {
        if (account != _msgSender() && !isApprovedForAll(account, _msgSender())) {
            revert ERC1155MissingApprovalForAll(_msgSender(), account);
        }

        _burn(account, id, value);
    }

    function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual {
        if (account != _msgSender() && !isApprovedForAll(account, _msgSender())) {
            revert ERC1155MissingApprovalForAll(_msgSender(), account);
        }

        _burnBatch(account, ids, values);
    }
}

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

pragma solidity ^0.8.20;

import {ERC1155} from "../ERC1155.sol";

/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 *
 * NOTE: This contract implies a global limit of 2**256 - 1 to the number of tokens
 * that can be minted.
 *
 * CAUTION: This extension should not be added in an upgrade to an already deployed contract.
 */
abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 id => uint256) private _totalSupply;
    uint256 private _totalSupplyAll;

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

    /**
     * @dev Total value of tokens.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupplyAll;
    }

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

    /**
     * @dev See {ERC1155-_update}.
     */
    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal virtual override {
        super._update(from, to, ids, values);

        if (from == address(0)) {
            uint256 totalMintValue = 0;
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 value = values[i];
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
                _totalSupply[ids[i]] += value;
                totalMintValue += value;
            }
            // Overflow check required: The rest of the code assumes that totalSupplyAll never overflows
            _totalSupplyAll += totalMintValue;
        }

        if (to == address(0)) {
            uint256 totalBurnValue = 0;
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 value = values[i];

                unchecked {
                    // Overflow not possible: values[i] <= balanceOf(from, ids[i]) <= totalSupply(ids[i])
                    _totalSupply[ids[i]] -= value;
                    // Overflow not possible: sum_i(values[i]) <= sum_i(totalSupply(ids[i])) <= totalSupplyAll
                    totalBurnValue += value;
                }
            }
            unchecked {
                // Overflow not possible: totalBurnValue = sum_i(values[i]) <= sum_i(totalSupply(ids[i])) <= totalSupplyAll
                _totalSupplyAll -= totalBurnValue;
            }
        }
    }
}

// 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) (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/ERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {IERC721Enumerable} from "./IERC721Enumerable.sol";
import {IERC165} from "../../../utils/introspection/ERC165.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds enumerability
 * of all the token ids in the contract as well as all token ids owned by each account.
 *
 * CAUTION: `ERC721` extensions that implement custom `balanceOf` logic, such as `ERC721Consecutive`,
 * interfere with enumerability and should not be used together with `ERC721Enumerable`.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
    mapping(uint256 tokenId => uint256) private _ownedTokensIndex;

    uint256[] private _allTokens;
    mapping(uint256 tokenId => uint256) private _allTokensIndex;

    /**
     * @dev An `owner`'s token query was out of bounds for `index`.
     *
     * NOTE: The owner being `address(0)` indicates a global out of bounds index.
     */
    error ERC721OutOfBoundsIndex(address owner, uint256 index);

    /**
     * @dev Batch mint is not allowed.
     */
    error ERC721EnumerableForbiddenBatchMint();

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256) {
        if (index >= balanceOf(owner)) {
            revert ERC721OutOfBoundsIndex(owner, index);
        }
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual returns (uint256) {
        if (index >= totalSupply()) {
            revert ERC721OutOfBoundsIndex(address(0), index);
        }
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_update}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) {
        address previousOwner = super._update(to, tokenId, auth);

        if (previousOwner == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _removeTokenFromOwnerEnumeration(previousOwner, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }

        return previousOwner;
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = balanceOf(to) - 1;
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = balanceOf(from);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /**
     * See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch
     */
    function _increaseBalance(address account, uint128 amount) internal virtual override {
        if (amount > 0) {
            revert ERC721EnumerableForbiddenBatchMint();
        }
        super._increaseBalance(account, amount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

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

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

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

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

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

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

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

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

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

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

pragma solidity ^0.8.20;

import {IERC1155} from "../IERC1155.sol";

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

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

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

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

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

// 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) (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/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// 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/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
pragma solidity ^0.8.4;

/// @notice Library for generating pseudorandom numbers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibPRNG.sol)
/// @author LazyShuffler based on NextShuffler by aschlosberg (divergencearran)
/// (https://github.com/divergencetech/ethier/blob/main/contracts/random/NextShuffler.sol)
library LibPRNG_01 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The initial length must be greater than zero and less than `2**32 - 1`.
    error InvalidInitialLazyShufflerLength();

    /// @dev The new length must not be less than the current length.
    error InvalidNewLazyShufflerLength();

    /// @dev The lazy shuffler has not been initialized.
    error LazyShufflerNotInitialized();

    /// @dev Cannot double initialize the lazy shuffler.
    error LazyShufflerAlreadyInitialized();

    /// @dev The lazy shuffle has finished.
    error LazyShuffleFinished();

    /// @dev The queried index is out of bounds.
    error LazyShufflerGetOutOfBounds();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The scalar of ETH and most ERC20s.
    uint256 internal constant WAD = 1e18;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A pseudorandom number state in memory.
    struct PRNG {
        uint256 state;
    }

    /// @dev A lazy Fisher-Yates shuffler for a range `[0..n)` in storage.
    struct LazyShuffler {
        // Bits Layout:
        // - [0..31]    `numShuffled`
        // - [32..223]  `permutationSlot`
        // - [224..255] `length`
        uint256 _state;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Seeds the `prng` with `state`.
    function seed(PRNG memory prng, uint256 state) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(prng, state)
        }
    }

    /// @dev Returns the next pseudorandom uint256.
    /// All bits of the returned uint256 pass the NIST Statistical Test Suite.
    function next(PRNG memory prng) internal pure returns (uint256 result) {
        // We simply use `keccak256` for a great balance between
        // runtime gas costs, bytecode size, and statistical properties.
        //
        // A high-quality LCG with a 32-byte state
        // is only about 30% more gas efficient during runtime,
        // but requires a 32-byte multiplier, which can cause bytecode bloat
        // when this function is inlined.
        //
        // Using this method is about 2x more efficient than
        // `nextRandomness = uint256(keccak256(abi.encode(randomness)))`.
        /// @solidity memory-safe-assembly
        assembly {
            result := keccak256(prng, 0x20)
            mstore(prng, result)
        }
    }

    /// @dev Returns a pseudorandom uint256, uniformly distributed
    /// between 0 (inclusive) and `upper` (exclusive).
    /// If your modulus is big, this method is recommended
    /// for uniform sampling to avoid modulo bias.
    /// For uniform sampling across all uint256 values,
    /// or for small enough moduli such that the bias is neligible,
    /// use {next} instead.
    function uniform(
        PRNG memory prng,
        uint256 upper
    ) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {

            } 1 {

            } {
                result := keccak256(prng, 0x20)
                mstore(prng, result)
                if iszero(lt(result, mod(sub(0, upper), upper))) {
                    break
                }
            }
            result := mod(result, upper)
        }
    }

    /// @dev Shuffles the array in-place with Fisher-Yates shuffle.
    function shuffle(PRNG memory prng, uint256[] memory a) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(a)
            let w := not(0)
            let mask := shr(128, w)
            if n {
                for {
                    a := add(a, 0x20)
                } 1 {

                } {
                    // We can just directly use `keccak256`, cuz
                    // the other approaches don't save much.
                    let r := keccak256(prng, 0x20)
                    mstore(prng, r)

                    // Note that there will be a very tiny modulo bias
                    // if the length of the array is not a power of 2.
                    // For all practical purposes, it is negligible
                    // and will not be a fairness or security concern.
                    {
                        let j := add(a, shl(5, mod(shr(128, r), n)))
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let i := add(a, shl(5, n))
                        let t := mload(i)
                        mstore(i, mload(j))
                        mstore(j, t)
                    }

                    {
                        let j := add(a, shl(5, mod(and(r, mask), n)))
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let i := add(a, shl(5, n))
                        let t := mload(i)
                        mstore(i, mload(j))
                        mstore(j, t)
                    }
                }
            }
        }
    }

    /// @dev Shuffles the bytes in-place with Fisher-Yates shuffle.
    function shuffle(PRNG memory prng, bytes memory a) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(a)
            let w := not(0)
            let mask := shr(128, w)
            if n {
                let b := add(a, 0x01)
                for {
                    a := add(a, 0x20)
                } 1 {

                } {
                    // We can just directly use `keccak256`, cuz
                    // the other approaches don't save much.
                    let r := keccak256(prng, 0x20)
                    mstore(prng, r)

                    // Note that there will be a very tiny modulo bias
                    // if the length of the array is not a power of 2.
                    // For all practical purposes, it is negligible
                    // and will not be a fairness or security concern.
                    {
                        let o := mod(shr(128, r), n)
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let t := mload(add(b, n))
                        mstore8(add(a, n), mload(add(b, o)))
                        mstore8(add(a, o), t)
                    }

                    {
                        let o := mod(and(r, mask), n)
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let t := mload(add(b, n))
                        mstore8(add(a, n), mload(add(b, o)))
                        mstore8(add(a, o), t)
                    }
                }
            }
        }
    }

    /// @dev Returns a sample from the standard normal distribution denominated in `WAD`.
    function standardNormalWad(
        PRNG memory prng
    ) internal pure returns (int256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Technically, this is the Irwin-Hall distribution with 20 samples.
            // The chance of drawing a sample outside 10 σ from the standard normal distribution
            // is ≈ 0.000000000000000000000015, which is insignificant for most practical purposes.
            // Passes the Kolmogorov-Smirnov test for 200k samples. Uses about 322 gas.
            result := keccak256(prng, 0x20)
            mstore(prng, result)
            let
                n
            := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff43 // Prime.
            let a := 0x100000000000000000000000000000051 // Prime and a primitive root of `n`.
            let
                m
            := 0x1fffffffffffffff1fffffffffffffff1fffffffffffffff1fffffffffffffff
            let s := 0x1000000000000000100000000000000010000000000000001
            let r1 := mulmod(result, a, n)
            let r2 := mulmod(r1, a, n)
            let r3 := mulmod(r2, a, n)
            // forgefmt: disable-next-item
            result := sub(
                sar(
                    96,
                    mul(
                        26614938895861601847173011183,
                        add(
                            add(
                                shr(
                                    192,
                                    mul(s, add(and(m, result), and(m, r1)))
                                ),
                                shr(192, mul(s, add(and(m, r2), and(m, r3))))
                            ),
                            shr(192, mul(s, and(m, mulmod(r3, a, n))))
                        )
                    )
                ),
                7745966692414833770
            )
        }
    }

    /// @dev Returns a sample from the unit exponential distribution denominated in `WAD`.
    function exponentialWad(
        PRNG memory prng
    ) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Passes the Kolmogorov-Smirnov test for 200k samples.
            // Gas usage varies, starting from about 172+ gas.
            let r := keccak256(prng, 0x20)
            mstore(prng, r)
            let p := shl(129, r)
            let w := shl(1, r)
            if iszero(gt(w, p)) {
                let
                    n
                := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff43 // Prime.
                let a := 0x100000000000000000000000000000051 // Prime and a primitive root of `n`.
                for {

                } 1 {

                } {
                    r := mulmod(r, a, n)
                    if iszero(lt(shl(129, r), w)) {
                        r := mulmod(r, a, n)
                        result := add(1000000000000000000, result)
                        w := shl(1, r)
                        p := shl(129, r)
                        if iszero(lt(w, p)) {
                            break
                        }
                        continue
                    }
                    w := shl(1, r)
                    if iszero(lt(w, shl(129, r))) {
                        break
                    }
                }
            }
            result := add(div(p, shl(129, 170141183460469231732)), result)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*       STORAGE-BASED RANGE LAZY SHUFFLING OPERATIONS        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Initializes the state for lazy-shuffling the range `[0..n)`.
    /// Reverts if `n == 0 || n >= 2**32 - 1`.
    /// Reverts if `$` has already been initialized.
    /// If you need to reduce the length after initialization, just use a fresh new `$`.
    function initialize(LazyShuffler storage $, uint256 n) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(lt(sub(n, 1), 0xfffffffe)) {
                mstore(0x00, 0x83b53941) // `InvalidInitialLazyShufflerLength()`.
                revert(0x1c, 0x04)
            }
            if sload($.slot) {
                mstore(0x00, 0x0c9f11f2) // `LazyShufflerAlreadyInitialized()`.
                revert(0x1c, 0x04)
            }
            mstore(0x00, $.slot)
            sstore(
                $.slot,
                or(shl(224, n), shl(32, shr(64, keccak256(0x00, 0x20))))
            )
        }
    }

    /// @dev Increases the length of `$`.
    /// Reverts if `$` has not been initialized.
    function grow(LazyShuffler storage $, uint256 n) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot) // The packed value at `$`.
            // If the new length is smaller than the old length, revert.
            if lt(n, shr(224, state)) {
                mstore(0x00, 0xbed37c6e) // `InvalidNewLazyShufflerLength()`.
                revert(0x1c, 0x04)
            }
            if iszero(state) {
                mstore(0x00, 0x1ead2566) // `LazyShufflerNotInitialized()`.
                revert(0x1c, 0x04)
            }
            sstore($.slot, or(shl(224, n), shr(32, shl(32, state))))
        }
    }

    /// @dev Restarts the shuffler by setting `numShuffled` to zero,
    /// such that all elements can be drawn again.
    /// Restarting does NOT clear the internal permutation, nor changes the length.
    /// Even with the same sequence of randomness, reshuffling can yield different results.
    function restart(LazyShuffler storage $) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot)
            if iszero(state) {
                mstore(0x00, 0x1ead2566) // `LazyShufflerNotInitialized()`.
                revert(0x1c, 0x04)
            }
            sstore($.slot, shl(32, shr(32, state)))
        }
    }

    /// @dev Returns the number of elements that have been shuffled.
    function numShuffled(
        LazyShuffler storage $
    ) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := and(0xffffffff, sload($.slot))
        }
    }

    /// @dev Returns the length of `$`.
    /// Returns zero if `$` is not initialized, else a non-zero value less than `2**32 - 1`.
    function length(
        LazyShuffler storage $
    ) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := shr(224, sload($.slot))
        }
    }

    /// @dev Returns if `$` has been initialized.
    function initialized(
        LazyShuffler storage $
    ) internal view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := iszero(iszero(sload($.slot)))
        }
    }

    /// @dev Returns if there are any more elements left to shuffle.
    /// Reverts if `$` is not initialized.
    function finished(
        LazyShuffler storage $
    ) internal view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot) // The packed value at `$`.
            if iszero(state) {
                mstore(0x00, 0x1ead2566) // `LazyShufflerNotInitialized()`.
                revert(0x1c, 0x04)
            }
            result := eq(shr(224, state), and(0xffffffff, state))
        }
    }

    /// @dev Returns the current value stored at `index`, accounting for all historical shuffling.
    /// Reverts if `index` is greater than or equal to the `length` of `$`.
    function get(
        LazyShuffler storage $,
        uint256 index
    ) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot) // The packed value at `$`.
            let n := shr(224, state) // Length of `$`.
            if iszero(lt(index, n)) {
                mstore(0x00, 0x61367cc4) // `LazyShufflerGetOutOfBounds()`.
                revert(0x1c, 0x04)
            }
            let u32 := gt(n, 0xfffe)
            let s := add(shr(sub(4, u32), index), shr(64, shl(32, state))) // Bucket slot.
            let o := shl(add(4, u32), and(index, shr(u32, 15))) // Bucket slot offset (bits).
            let m := sub(shl(shl(u32, 16), 1), 1) // Value mask.
            result := and(m, shr(o, sload(s)))
            result := xor(
                index,
                mul(xor(index, sub(result, 1)), iszero(iszero(result)))
            )
        }
    }

    /// @dev Does a single Fisher-Yates shuffle step, increments the `numShuffled` in `$`,
    /// and returns the next value in the shuffled range.
    /// `randomness` can be taken from a good-enough source, or a higher quality source like VRF.
    /// Reverts if there are no more values to shuffle, which includes the case if `$` is not initialized.
    function next(
        LazyShuffler storage $,
        uint256 randomness
    ) internal returns (uint256 chosen) {
        /// @solidity memory-safe-assembly
        assembly {
            function _get(u32_, state_, i_) -> _value {
                let s_ := add(shr(sub(4, u32_), i_), shr(64, shl(32, state_))) // Bucket slot.
                let o_ := shl(add(4, u32_), and(i_, shr(u32_, 15))) // Bucket slot offset (bits).
                let m_ := sub(shl(shl(u32_, 16), 1), 1) // Value mask.
                _value := and(m_, shr(o_, sload(s_)))
                _value := xor(
                    i_,
                    mul(xor(i_, sub(_value, 1)), iszero(iszero(_value)))
                )
            }
            function _set(u32_, state_, i_, value_) {
                let s_ := add(shr(sub(4, u32_), i_), shr(64, shl(32, state_))) // Bucket slot.
                let o_ := shl(add(4, u32_), and(i_, shr(u32_, 15))) // Bucket slot offset (bits).
                let m_ := sub(shl(shl(u32_, 16), 1), 1) // Value mask.
                let v_ := sload(s_) // Bucket slot value.
                value_ := mul(iszero(eq(i_, value_)), add(value_, 1))
                sstore(s_, xor(v_, shl(o_, and(m_, xor(shr(o_, v_), value_)))))
            }
            let state := sload($.slot) // The packed value at `$`.
            let shuffled := and(0xffffffff, state) // Number of elements shuffled.
            let n := shr(224, state) // Length of `$`.
            let remainder := sub(n, shuffled) // Number of elements left to shuffle.
            if iszero(remainder) {
                mstore(0x00, 0x51065f79) // `LazyShuffleFinished()`.
                revert(0x1c, 0x04)
            }
            mstore(0x00, randomness) // (Re)hash the randomness so that we don't
            mstore(0x20, shuffled) // need to expect guarantees on its distribution.
            let index := add(mod(keccak256(0x00, 0x40), remainder), shuffled)
            chosen := _get(gt(n, 0xfffe), state, index)
            _set(
                gt(n, 0xfffe),
                state,
                index,
                _get(gt(n, 0xfffe), state, shuffled)
            )
            _set(gt(n, 0xfffe), state, shuffled, chosen)
            sstore($.slot, add(1, state)) // Increment the `numShuffled` by 1, and store it.
        }
    }
}

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";

contract LiberoERC1155_01 is ERC1155, ERC1155Burnable, Ownable, ERC1155Supply {
    string public name;
    string public symbol;

    constructor(
        string memory uri,
        string memory _name,
        string memory _symbol,
        address initialOwner
    )
        ERC1155(string(abi.encodePacked(uri, "{id}.json")))
        Ownable(initialOwner)
    {
        name = _name;
        symbol = _symbol;
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public onlyOwner {
        _mint(account, id, amount, data);
    }

    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public onlyOwner {
        _mintBatch(to, ids, amounts, data);
    }

    // The following functions are overrides required by Solidity.

    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal override(ERC1155, ERC1155Supply) {
        super._update(from, to, ids, values);
    }
}

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract LiberoERC721_01 is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
    string private _uri;

    constructor(
        string memory uri,
        string memory name,
        string memory symbol,
        address initialOwner
    ) ERC721(name, symbol) Ownable(initialOwner) {
        _uri = uri;
    }

    // The following functions are overrides required by Solidity.

    function tokenURI(
        uint256 tokenId
    ) public view override(ERC721) returns (string memory) {
        return
            string(abi.encodePacked(_uri, Strings.toString(tokenId), ".json"));
    }

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

    function _increaseBalance(
        address account,
        uint128 value
    ) internal override(ERC721, ERC721Enumerable) {
        super._increaseBalance(account, value);
    }

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

    function mintTo(address to, uint256 tokenId) public {
        _safeMint(to, tokenId);
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.24;

import "./LiberoERC721_01.sol";
import "./LiberoERC1155_01.sol";

contract LiberoMintFactory_01 {
    function deployLiberoERC721(
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        address initialOwner
    ) public returns (LiberoERC721_01 contractAddress) {
        LiberoERC721_01 erc721 = new LiberoERC721_01(
            mintUri,
            mintName,
            mintSymbol,
            initialOwner
        );
        return erc721;
    }

    function deployLiberoERC1155(
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        address initialOwner
    ) public returns (LiberoERC1155_01 contractAddress) {
        LiberoERC1155_01 erc1155 = new LiberoERC1155_01(
            mintUri,
            mintName,
            mintSymbol,
            initialOwner
        );
        return erc1155;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./LiberoERC721_01.sol";
import "./LiberoERC1155_01.sol";
import "./LiberoMintFactory_01.sol";
import "./LiberoReward_01.sol";
import "./LibPRNG_01.sol";
import "./Ticketing_01.sol";
import "./TicketingFactory_01.sol";



contract SoladyPRNG {
    LibPRNG_01.PRNG private state;

    constructor(uint256 _state) {
        state = LibPRNG_01.PRNG(_state);
    }

    // Generates a pseudo-random number between 0 and _upperBound (exclusive)
    function random(uint256 _upperBound) public view returns (uint256) {
        return LibPRNG_01.uniform(state, _upperBound);
    }
}

contract LiberoRaffle_01 is Ownable {
    event ERC721Deployed(address contractAddress);
    event ERC1155Deployed(address contractAddress);

    LiberoRewards_01.Raffle[] private _raffleInfo;
    LiberoRewards_01.RaffleExt[] private _raffleExt;
    uint32 private _raffleNr;
    address private _manager;
    LiberoMintFactory_01 private _liberoMintFactory;
    TicketingFactory_01 private _ticketingFactory;

    constructor(
        address manager,
        address liberoMintFactory,
        address ticketingFactory
    ) Ownable(msg.sender) {
        _liberoMintFactory = LiberoMintFactory_01(liberoMintFactory);
        _ticketingFactory = TicketingFactory_01(ticketingFactory);
        _manager = manager;
    }

    modifier onlyManager() {
        require(_manager == msg.sender, "CALLER_NOT_MANAGER");
        _;
    }

    function setManager(address manager) public onlyOwner {
        _manager = manager;
    }

    function newRaffle(
        uint32 id,
        uint256 payAmount,
        address organizer,
        uint32 totalTickets,
        uint32 totalPriorityTickets,
        uint32 maxTicketsPerWallet,
        uint32 maxRewardsPerWallet,
        uint32 availableRewards,
        uint8 rewardIf,
        address rewardContract,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        bool shouldDistributeRewards,
        bool shouldRefundNonWinning,
        uint256 startAt,
        uint256 endAt,
        uint256 raffleAt,
        uint256 sysTicketPrice,
        uint16 ownerFeePct,
        uint16 ownerTipPct,
        LiberoRewards_01.Requirement[] memory requirements,
        bytes memory signature
    ) public payable {
        address recoveredSigner = LiberoRewards_01
            .ext_newRaffleValidateAndCheckSignature(
                id,
                payAmount,
                organizer,
                totalTickets,
                totalPriorityTickets,
                maxTicketsPerWallet,
                maxRewardsPerWallet,
                availableRewards,
                rewardIf,
                rewardContract,
                mintUri,
                mintName,
                mintSymbol,
                shouldDistributeRewards,
                shouldRefundNonWinning,
                startAt,
                endAt,
                raffleAt,
                sysTicketPrice,
                ownerFeePct,
                ownerTipPct,
                requirements,
                signature
            );
        require(recoveredSigner == _manager, "RAFFLE_NEEDS_VALID_SIGNATURE");

        _raffleInfo.push();
        _raffleExt.push();
        _raffleNr = uint16(_raffleInfo.length) - 1;

        LiberoRewards_01.Raffle storage _newRaffle = _raffleInfo[_raffleNr];

        _newRaffle.availableRewards = availableRewards;
        _newRaffle.rewardIf = rewardIf;
        _newRaffle.organizer = organizer;
        _newRaffle.rewardContract = rewardContract;
        _newRaffle.availableRewards = availableRewards;
        _newRaffle.shouldDistributeRewards = shouldDistributeRewards;
        _newRaffle.shouldRefundNonWinning = shouldRefundNonWinning;
        _newRaffle.startAt = startAt;
        _newRaffle.endAt = endAt;
        _newRaffle.raffleAt = raffleAt;
        _newRaffle.sysTicketPrice = sysTicketPrice;

        if (rewardContract == address(0)) {
            require(
                shouldDistributeRewards && rewardIf != IF_NONE,
                "MINT_REQUIRES_DISTRIBUTION_OF_REWARDS"
            );
            require(bytes(mintSymbol).length > 0, "MINT_REQUIRESTOKEN_SYMBOL");
            require(bytes(mintName).length > 0, "MINT_REQUIRESTOKEN_NAME");
            if (rewardIf == IF_ERC721) {
                LiberoERC721_01 mintable = _liberoMintFactory
                    .deployLiberoERC721(
                        mintUri,
                        mintName,
                        mintSymbol,
                        address(this)
                    );
                emit ERC721Deployed(address(mintable));
                _newRaffle.mintContract = address(mintable);
            } else if (rewardIf == IF_ERC1155) {
                LiberoERC1155_01 mintable = _liberoMintFactory
                    .deployLiberoERC1155(
                        mintUri,
                        mintName,
                        mintSymbol,
                        address(this)
                    );
                emit ERC1155Deployed(address(mintable));
                _newRaffle.mintContract = address(mintable);
            }
        }

        _newRaffle.requirements = requirements;
        _newRaffle.tickets = _ticketingFactory.deployTicketing(
            address(this),
            totalTickets,
            totalPriorityTickets,
            maxTicketsPerWallet
        );
        _newRaffle.maxRewardsPerWallet = maxRewardsPerWallet;

        payable(owner()).transfer(payAmount);

        emit LiberoRewards_01.RaffleCreated(_raffleNr, id);
    }

    function addRewards(
        uint32 raffleNr,
        uint256 from,
        LiberoRewards_01.Reward[] memory rewards
    ) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        require(activeRaffle.rewards.length == from, "ADD_REWARDS_FROM_ERROR");
        require(
            rewards.length + activeRaffle.rewards.length <=
                activeRaffle.availableRewards,
            "ADD_REWARDS_TOO_MANY"
        );

        if (
            activeRaffle.shouldDistributeRewards &&
            activeRaffle.rewardContract != address(0)
        ) {
            LiberoRewards_01.ext_approveAwardInternal(
                activeRaffle.rewardIf,
                activeRaffle.rewardContract,
                activeRaffle.organizer,
                rewards
            );
        }

        for (uint256 i = 0; i < rewards.length; i++) {
            activeRaffle.rewards.push(rewards[i]);
        }

        activeRaffle.totalRewards = activeRaffle.rewards.length;
    }

    function getRaffleInfo(
        uint32 raffleNr
    ) public view onlyManager returns (LiberoRewards_01.Raffle memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        delete activeRaffle.rewards;
        delete activeRaffle.tickets;
        delete activeRaffle.winningTickets;

        return activeRaffle;
    }

    function getRaffleInfoCnt(
        uint32 raffleNr
    )
        public
        view
        onlyManager
        returns (
            uint256 rewardsLen,
            uint256 ticketsLen,
            uint256 ticketsValidPriorityLen,
            uint256 ticketsValidLen,
            uint256 winningTicketsLen,
            bool validated
        )
    {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        rewardsLen = activeRaffle.rewards.length;
        ticketsLen = activeRaffle.tickets.getAllTicketsLength();
        ticketsValidPriorityLen = activeRaffle.tickets.getValidTicketsLength(
            true
        );
        ticketsValidLen = activeRaffle.tickets.getValidTicketsLength(false);
        winningTicketsLen = activeRaffle.winningTickets.length;
        validated = activeRaffle.tickets.getTicketsValidated();
    }

    function getRaffleInfoRewards(
        uint32 raffleNr,
        uint256 fromIx,
        uint256 toIx
    ) public view onlyManager returns (LiberoRewards_01.Reward[] memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        LiberoRewards_01.Reward[] memory res = new LiberoRewards_01.Reward[](
            toIx - fromIx
        );
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.rewards[i];
        }

        return res;
    }

    function getRaffleInfoTickets(
        uint32 raffleNr,
        uint256 fromIx,
        uint256 toIx
    ) public view onlyManager returns (Ticketing_01.Ticket[] memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        Ticketing_01.Ticket[] memory res = new Ticketing_01.Ticket[](
            toIx - fromIx
        );
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.tickets.getTicketAt(i);
        }

        return res;
    }

    function getRaffleInfoValidTickets(
        uint32 raffleNr,
        bool isPriority,
        uint256 fromIx,
        uint256 toIx
    ) public view onlyManager returns (Ticketing_01.Ticket[] memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        Ticketing_01.Ticket[] memory res = new Ticketing_01.Ticket[](
            toIx - fromIx
        );
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.tickets.getValidTicketAtIx(
                isPriority,
                i
            );
        }

        return res;
    }

    function getRaffleInfoWinningTickets(
        uint32 raffleNr,
        uint256 fromIx,
        uint256 toIx
    )
        public
        view
        onlyManager
        returns (LiberoRewards_01.WinningTicket[] memory)
    {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        LiberoRewards_01.WinningTicket[]
            memory res = new LiberoRewards_01.WinningTicket[](toIx - fromIx);
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.winningTickets[i];
        }

        return res;
    }

    function getRaffleInfoRewardsPerWallet(
        uint32 raffleNr,
        address wallet
    ) public view onlyManager returns (uint32) {
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];
        return activeRaffleExt.rewardsPerWallet[wallet];
    }

    function getRaffleInfoWinningTicketKeys(
        uint32 raffleNr,
        Ticketing_01.Ticket memory ticket
    ) public view onlyManager returns (bool) {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];
        uint256 ticketKey = activeRaffle.tickets.getTicketKeyExt(ticket);
        return activeRaffleExt.winningTicketKeys[ticketKey];
    }

    function getRaffleInfoTicketKeyExt(
        uint32 raffleNr,
        Ticketing_01.Ticket memory ticket
    ) public view onlyManager returns (uint256) {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        return activeRaffle.tickets.getTicketKeyExt(ticket);
    }

    function getRaffleInfoTicketValidationInfo(
        uint32 raffleNr
    )
        public
        view
        returns (
            uint256 _validatedUntil,
            bool _validated,
            uint256 _totalTickets,
            uint256 _totalPriorityTickets,
            uint256 _maxTicketsPerWallet,
            uint256 _totalTicketsSold,
            uint256 _returnedTickets
        )
    {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        return activeRaffle.tickets.getTicketValidationInfo();
    }

    function buyTickets(
        uint32 raffleNr,
        Ticketing_01.Ticket[] calldata toBuy,
        Ticketing_01.Ticket[] calldata toReturn,
        uint256 tip,
        bytes memory signature
    ) public payable {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        (
            address recoveredSigner,
            uint256 netPayAmount,
            uint256 netRefundAmount
        ) = LiberoRewards_01.ext_buyTicketsValidateAndCheckSignature(
                raffleNr,
                activeRaffle,
                toBuy,
                toReturn,
                tip,
                signature
            );

        require(
            recoveredSigner == _manager,
            "BUY_TICKET_NEEDS_VALID_SIGNATURE"
        );

        if (toBuy.length > 0) activeRaffle.tickets.buyTickets(raffleNr, toBuy);
        if (toReturn.length > 0)
            activeRaffle.tickets.returnTickets(raffleNr, toReturn);

        payable(owner()).transfer(toBuy.length * activeRaffle.sysTicketPrice);
        if (netPayAmount > 0) {
            activeRaffle.fees += netPayAmount;
        } else {
            activeRaffle.fees -= netRefundAmount;
            payable(msg.sender).transfer(netRefundAmount);
        }
        activeRaffle.tips += tip;

        if (tip > 0 || netPayAmount > 0) {
            emit LiberoRewards_01.Payment(
                raffleNr,
                msg.sender,
                tip,
                netPayAmount,
                netRefundAmount > 0
            );
        }
    }

    function seedRaffle(uint32 raffleNr, uint256 seed) public {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        require(
            activeRaffle.availableRewards == activeRaffle.rewards.length,
            "REWARDS_NOT_ADDED"
        );

        require(
            (msg.sender == activeRaffle.organizer &&
                block.timestamp >= activeRaffle.raffleAt) ||
                (msg.sender == _manager &&
                    block.timestamp >= (activeRaffle.raffleAt + 1 hours)),
            "SEED_RAFFLE_NOT_AUTHORIZED"
        );

        require(!activeRaffle.prngInitialized, "PRNG_ALREADY_INITIALIZED");

        activeRaffle.prngState = uint256(
            keccak256(
                abi.encodePacked(
                    block.prevrandao,
                    block.timestamp,
                    msg.sender,
                    seed,
                    raffleNr
                )
            )
        );
        activeRaffle.prngInitialized = true;
    }

    function validateTickets(uint32 raffleNr, uint256 cnt) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        activeRaffle.tickets.validateTickets(cnt);

        if (activeRaffle.tickets.getTicketsValidated()) {
            activeRaffle.totalTickets =
                activeRaffle.tickets.getValidTicketsLength(true) +
                activeRaffle.tickets.getValidTicketsLength(false);
            if (activeRaffle.totalRewards > activeRaffle.totalTickets) {
                activeRaffle.totalRewards = activeRaffle.totalTickets;
            }
        }
    }

    function raffle(
        uint32 raffleNr,
        bool isPriority,
        uint256 cnt
    ) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        require(
            activeRaffle.tickets.getTicketsValidated(),
            "TICKETS_NOT_VALIDATED"
        );
        uint256 priorityTicketsLength = activeRaffle
            .tickets
            .getValidTicketsLength(true);
        require(
            activeRaffle.nextRewardIx < activeRaffle.totalRewards,
            "RAFFLE_FINISHED"
        );
        if (isPriority) {
            require(
                activeRaffle.pickedRewards < priorityTicketsLength,
                "RAFFLE_FINISHED_PRIORITY"
            );
        } else {
            require(
                activeRaffle.pickedRewards >= priorityTicketsLength,
                "RAFFLE_NOT_FINISHED_PRIORITY"
            );
            require(
                activeRaffle.nextRewardIx < activeRaffle.totalTickets,
                "RAFFLE_FINISHED_OTHER"
            );
        }

        SoladyPRNG prng = new SoladyPRNG(activeRaffle.prngState);
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];

        // how many tickets to draw from, accounting for round and already drawn tickets
        uint256 drawTotalTickets = isPriority
            ? priorityTicketsLength
            : activeRaffle.totalTickets;
        drawTotalTickets -= activeRaffle.pickedRewards;
        require(drawTotalTickets > 0, "RAFFLE_FINISHED_NO_MORE_TICKETS");

        uint256 drawRounds = drawTotalTickets;
        // limit #draws to available tickets
        if (drawRounds > drawTotalTickets) drawRounds = drawTotalTickets;
        // limit #draws to external rate limit
        if (drawRounds > cnt) drawRounds = cnt;

        for (uint256 i = 0; i < drawRounds; i++) {
            // if all rewards picked continue
            if (activeRaffle.nextRewardIx >= activeRaffle.totalRewards) {
                break;
            }

            uint256 winnerIx = prng.random(drawTotalTickets);
            Ticketing_01.Ticket memory winningTicket = activeRaffle
                .tickets
                .getValidTicketAtIx(isPriority, winnerIx);

            // move ticket from end to drawn place (unless already last), next draw will be from one less ticket
            if (winnerIx != drawTotalTickets - 1) {
                activeRaffle.tickets.swapValidTickets(
                    isPriority,
                    winnerIx,
                    drawTotalTickets - 1
                );
            }

            LiberoRewards_01.Reward memory reward = activeRaffle.rewards[
                activeRaffle.nextRewardIx
            ];
            uint32 rewardsPerWallet = activeRaffleExt.rewardsPerWallet[
                winningTicket.wallet
            ] + 1;
            activeRaffleExt.rewardsPerWallet[
                winningTicket.wallet
            ] = rewardsPerWallet;
            bool isSkipped = false;
            if (rewardsPerWallet > activeRaffle.maxRewardsPerWallet) {
                isSkipped = true;
            } else {
                activeRaffle.nextRewardIx++;
            }

            activeRaffle.winningTickets.push(
                LiberoRewards_01.WinningTicket(winningTicket, reward, isSkipped)
            );
            if (!isSkipped) {
                uint256 ticketKey = activeRaffle.tickets.getTicketKeyExt(
                    winningTicket
                );
                activeRaffleExt.winningTicketKeys[ticketKey] = true;
            }

            emit LiberoRewards_01.TicketPicked(
                raffleNr,
                uint32(activeRaffle.winningTickets.length),
                uint32(winnerIx),
                uint32(drawTotalTickets),
                isSkipped,
                isPriority,
                reward.tokenId,
                reward.tokenAmount,
                winningTicket.tokenId,
                winningTicket.wallet,
                winningTicket.ticketId,
                winningTicket.ticketNr,
                winningTicket.reqNr
            );

            drawTotalTickets -= 1;
            activeRaffle.pickedRewards += 1;
        }
    }

    bool private _distributingRewards;

    function _burnRewardIxInternal(
        uint32 raffleNr,
        uint32 ix
    ) private returns (bool success) {
        require(!_distributingRewards);
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        if (activeRaffle.shouldDistributeRewards) {
            _distributingRewards = true;
            success = LiberoRewards_01.ext_burnRewardIxInternal(
                raffleNr,
                activeRaffle.winningTickets[ix],
                activeRaffle.requirements
            );
            _distributingRewards = false;
        }
    }

    function _sendRewardIxInternal(
        uint32 raffleNr,
        uint32 ix
    ) private returns (bool success) {
        require(!_distributingRewards);
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        if (activeRaffle.shouldDistributeRewards) {
            _distributingRewards = true;
            success = LiberoRewards_01.ext_sendRewardIxInternal(
                raffleNr,
                activeRaffle.winningTickets[ix],
                activeRaffle.rewardIf,
                activeRaffle.rewardContract,
                activeRaffle.mintContract,
                activeRaffle.organizer
            );
            _distributingRewards = false;
        }
    }

    function _distributeRewardIxInternal(uint32 raffleNr, uint32 ix) private {
        bool success = _burnRewardIxInternal(raffleNr, ix);

        // only transfer reward if no burn errors
        if (success) {
            success = _sendRewardIxInternal(raffleNr, ix);
        }
    }

    function distributeRewards(uint32 raffleNr, uint32 cnt) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        require(
            (activeRaffle.totalRewards == (activeRaffle.nextRewardIx)) ||
                (activeRaffle.pickedRewards == activeRaffle.totalTickets),
            "REWARDS_NOT_PICKED"
        );

        uint256 finalCnt = activeRaffle.distributeNextIx + cnt;
        if (finalCnt > activeRaffle.winningTickets.length) {
            finalCnt = activeRaffle.winningTickets.length;
        }
        require(
            finalCnt > activeRaffle.distributeNextIx,
            "REWARDS_DISTRIBUTED"
        );

        for (uint256 i = activeRaffle.distributeNextIx; i < finalCnt; i++) {
            _distributeRewardIxInternal(raffleNr, uint32(i));
            activeRaffle.distributeNextIx++;
        }
    }

    function distributeRewardIx(uint32 raffleNr, uint32 ix) public onlyManager {
        // Raffle storage activeRaffle = _raffleInfo[raffleNr];
        // if (activeRaffle.shouldDistributeRewards) {
        //     require(
        //         activeRaffle.distributeNextIx ==
        //             activeRaffle.winningTickets.length,
        //         "REWARDS_NOT_DISTRIBUTED"
        //     );
        // }
        _distributeRewardIxInternal(raffleNr, ix);
    }

    function burnRewardIx(uint32 raffleNr, uint32 ix) public onlyManager {
        // Raffle storage activeRaffle = _raffleInfo[raffleNr];
        // if (activeRaffle.shouldDistributeRewards) {
        //     require(
        //         activeRaffle.distributeNextIx ==
        //             activeRaffle.winningTickets.length,
        //         "REWARDS_NOT_DISTRIBUTED"
        //     );
        // }
        _burnRewardIxInternal(raffleNr, ix);
    }

    function burnRaw(
        address collection,
        address owner,
        uint8 rewardIf,
        uint256 tokenId,
        uint256 tokenAmount
    ) public onlyManager {
        if (rewardIf == IF_ERC721) {
            ERC721Burnable burn721 = ERC721Burnable(collection);
            burn721.burn(tokenId);
        } else if (rewardIf == IF_ERC1155) {
            ERC1155Burnable burn1155 = ERC1155Burnable(collection);
            burn1155.burn(owner, tokenId, tokenAmount);
        } else if (rewardIf == IF_MANIFOLD1155) {
            ManifoldERC1155Burnable burn1155 = ManifoldERC1155Burnable(
                collection
            );
            uint256[] memory ids = new uint256[](1);
            uint256[] memory values = new uint256[](1);
            ids[0] = tokenId;
            values[0] = tokenAmount;
            burn1155.burn(owner, ids, values);
        }
    }

    function transferRaw(
        address collection,
        address owner,
        address recepient,
        uint8 rewardIf,
        uint256 tokenId,
        uint256 tokenAmount
    ) public onlyManager {
        if (rewardIf == IF_ERC721) {
            IERC721 burn721 = IERC721(collection);
            burn721.safeTransferFrom(owner, recepient, tokenId);
        } else if (rewardIf == IF_ERC1155) {
            IERC1155 burn1155 = IERC1155(collection);
            burn1155.safeTransferFrom(
                owner,
                recepient,
                tokenId,
                tokenAmount,
                ""
            );
        }
    }

    function sendRewardIx(uint32 raffleNr, uint32 ix) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        if (activeRaffle.shouldDistributeRewards) {
            require(
                activeRaffle.distributeNextIx ==
                    activeRaffle.winningTickets.length,
                "REWARDS_NOT_DISTRIBUTED"
            );
        }
        _sendRewardIxInternal(raffleNr, ix);
    }

    bool private _refundingNonWinning;

    function refundNonWinning(
        uint32 raffleNr,
        bool isPriority,
        uint32 cnt
    ) public onlyManager {
        require(!_refundingNonWinning, "REFUND_NON_WINNING_LOCKED");
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        require(
            (activeRaffle.totalRewards == (activeRaffle.nextRewardIx)) ||
                (activeRaffle.pickedRewards == activeRaffle.totalTickets),
            "REWARDS_NOT_PICKED"
        );
        if (activeRaffle.shouldDistributeRewards) {
            require(
                activeRaffle.distributeNextIx ==
                    activeRaffle.winningTickets.length,
                "REWARDS_NOT_DISTRIBUTED"
            );
        }
        require(
            activeRaffle.shouldRefundNonWinning,
            "SHOULD_REFUND_NON_WINNING"
        );
        uint256 refundedIx = isPriority
            ? activeRaffle.refundedPriorityIx
            : activeRaffle.refundedIx;
        uint256 refundTicketsLen = activeRaffle.tickets.getValidTicketsLength(
            isPriority
        );
        require(refundedIx < refundTicketsLen, "REFUND_NON_WINNING_FINISHED");

        _refundingNonWinning = true;
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];

        uint256 upToIx = refundedIx + cnt;
        if (upToIx > refundTicketsLen) upToIx = refundTicketsLen;

        for (uint256 i = refundedIx; i < upToIx; i++) {
            Ticketing_01.Ticket memory ticket = activeRaffle
                .tickets
                .getValidTicketAtIx(isPriority, i);
            uint256 ticketKey = activeRaffle.tickets.getTicketKeyExt(ticket);
            if (!activeRaffleExt.winningTicketKeys[ticketKey]) {
                uint8 reqNr = ticket.reqNr;
                require(
                    reqNr < activeRaffle.requirements.length,
                    "TICKET_REFUND_NO_REQ_IX"
                );
                uint256 price = activeRaffle.requirements[reqNr].ticketPrice;
                if (price > 0) {
                    bool success = false;
                    try
                        LiberoRewards_01.ext_payAny(ticket.wallet, price, 10000)
                    returns (bool sent) {
                        success = sent;
                    } catch {}
                    if (success) {
                        activeRaffle.fees -= price;
                    }
                    emit LiberoRewards_01.TicketRefundNonWinning(
                        raffleNr,
                        ticket.tokenId,
                        ticket.wallet,
                        ticket.ticketId,
                        ticket.ticketNr,
                        ticket.reqNr,
                        success,
                        price
                    );
                }
            }
        }

        if (isPriority) {
            activeRaffle.refundedPriorityIx = upToIx;
        } else {
            activeRaffle.refundedIx = upToIx;
        }
        _refundingNonWinning = false;
    }

    function _checkRaffleDone(
        LiberoRewards_01.Raffle memory activeRaffle
    ) public view {
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        if (activeRaffle.shouldDistributeRewards) {
            require(
                activeRaffle.distributeNextIx ==
                    activeRaffle.winningTickets.length,
                "REWARDS_NOT_DISTRIBUTED"
            );
        }
        require(
            !activeRaffle.shouldRefundNonWinning ||
                (activeRaffle.refundedPriorityIx ==
                    activeRaffle.tickets.getValidTicketsLength(true) &&
                    activeRaffle.refundedIx ==
                    activeRaffle.tickets.getValidTicketsLength(false)),
            "SHOULD_REFUND_NON_WINNING"
        );
    }

    function payoutFees(uint32 raffleNr) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        _checkRaffleDone(activeRaffle);

        uint256 ownerFee = (activeRaffle.fees * activeRaffle.ownerFeePct) / 100;
        uint256 ownerTip = (activeRaffle.tips * activeRaffle.ownerTipPct) / 100;

        payable(owner()).transfer(ownerFee + ownerTip);
        payable(activeRaffle.organizer).transfer(
            activeRaffle.fees + activeRaffle.tips - ownerFee - ownerTip
        );

        activeRaffle.fees = 0;
        activeRaffle.tips = 0;
    }

    function transferMintOwnership(uint32 raffleNr) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        // require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        // if (activeRaffle.shouldDistributeRewards) {
        //     require(
        //         activeRaffle.fees == 0 && activeRaffle.tips == 0,
        //         "FEES_NOT_PAID_OUT"
        //     );
        // }

        if (activeRaffle.mintContract != address(0)) {
            if (activeRaffle.rewardIf == IF_ERC721) {
                LiberoERC721_01(activeRaffle.mintContract).transferOwnership(
                    activeRaffle.organizer
                );
            } else if (activeRaffle.rewardIf == IF_ERC1155) {
                LiberoERC1155_01(activeRaffle.mintContract).transferOwnership(
                    activeRaffle.organizer
                );
            }
        }
    }

    function batchMintManager(
        uint32 raffleNr,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts
    ) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        LiberoRewards_01.ext_batchMint(
            activeRaffle.rewardIf,
            activeRaffle.mintContract,
            to,
            tokenIds,
            tokenAmounts
        );
    }

    function batchMintOwner(
        uint32 raffleNr,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts,
        bytes memory signature
    ) public {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        _checkRaffleDone(activeRaffle);
        address recoveredSigner = LiberoRewards_01.ext_batchMintCheckSignature(
            raffleNr,
            to,
            tokenIds,
            tokenAmounts,
            signature
        );
        require(
            recoveredSigner == _manager,
            "BATCH_MINT_NEEDS_VALID_SIGNATURE"
        );

        LiberoRewards_01.ext_batchMint(
            activeRaffle.rewardIf,
            activeRaffle.mintContract,
            to,
            tokenIds,
            tokenAmounts
        );
    }

    function withdraw(uint256 amount) public onlyOwner {
        payable(owner()).transfer(amount);
    }

    function fund() public payable {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "./LiberoERC721_01.sol";
import "./LiberoERC1155_01.sol";
import "./Ticketing_01.sol";
import "./ManifoldBurnable.sol";

uint constant IF_NONE = 0;
uint constant IF_ERC721 = 1;
uint constant IF_ERC1155 = 2;
uint constant IF_MANIFOLD1155 = 3;

uint256 constant NO_REWARD = uint256(int256(-1));

library LiberoRewards_01 {
    struct Raffle {
        address organizer;
        address rewardContract; // for transfer
        address mintContract; // for mint
        uint32 availableRewards; // rewards need to be supplied and checked before seedRaffle
        uint8 rewardIf;
        Reward[] rewards; // supplied later
        // all requirements have burn tokens, for no burn we use IF_NONE
        Requirement[] requirements;
        uint256 startAt;
        uint256 endAt;
        uint256 raffleAt;
        // fees
        uint256 sysTicketPrice;
        uint16 ownerFeePct;
        uint16 ownerTipPct;
        uint256 tips;
        uint256 fees;
        Ticketing_01 tickets;
        // pick
        bool prngInitialized;
        uint256 prngState;
        uint256 nextRewardIx; // does not include skipped
        uint256 totalTickets;
        uint256 totalRewards; // this takes into account # of tickets, can't be higher
        uint32 maxRewardsPerWallet;
        uint256 pickedRewards; // total picked counter
        WinningTicket[] winningTickets;
        // distribute rewards - only matters for awartTokenIds, for mint is myst always be set
        bool shouldDistributeRewards;
        uint256 distributeNextIx; // includes skipped
        // refund non wining tickets in rounds before payout
        bool shouldRefundNonWinning;
        uint256 refundedPriorityIx; // ix in validated priority tickets that are refunded (wining dont get a refund)
        uint256 refundedIx; // ix in validated normal tickets that are refunded (wining dont get a refund)
        bool finished;
    }

    // separate struct, not in raffle info as it cant be returned from info method
    struct RaffleExt {
        mapping(address => uint32) rewardsPerWallet;
        mapping(uint256 => bool) winningTicketKeys; // track winning tickets to prevent refunds
    }

    event RaffleCreated(uint32 raffleNr, uint32 id);

    event Payment(
        uint32 raffleNr,
        address wallet,
        uint256 tip,
        uint256 fee,
        bool refund
    );
    event TicketPicked(
        uint32 raffleNr,
        uint32 winSeqNr,
        uint32 drawIx,
        uint32 drawFrom,
        bool isSkipped,
        bool isPriority,
        uint256 rewardTokenId,
        uint16 rewardTokenAmount,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr
    );

    struct WinningTicket {
        Ticketing_01.Ticket ticket;
        Reward reward;
        bool skipped;
    }
    struct Reward {
        uint256 tokenId;
        uint16 tokenAmount; // for ERC1155
    }
    struct Requirement {
        uint8 burnIf;
        uint16 burnTokenAmount; // for ERC1155
        address burnContract;
        uint256 ticketPrice;
    }

    event RewardError(
        uint32 raffleNr,
        string error,
        string reason,
        uint256 rewardTokenId,
        uint16 rewardTokenAmount,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr
    );
    event RewardSuccessful(
        uint32 raffleNr,
        uint256 rewardTokenId,
        uint16 rewardTokenAmount,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr
    );
    event TicketRefundNonWinning(
        uint32 raffleNr,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr,
        bool success,
        uint256 amount
    );

    function _rewardError(
        uint32 raffleNr,
        string memory message,
        string memory reason,
        WinningTicket memory winningTicket
    ) private {
        emit RewardError(
            raffleNr,
            message,
            reason,
            winningTicket.reward.tokenId,
            winningTicket.reward.tokenAmount,
            winningTicket.ticket.tokenId,
            winningTicket.ticket.wallet,
            winningTicket.ticket.ticketId,
            winningTicket.ticket.ticketNr,
            winningTicket.ticket.reqNr
        );
    }

    function ext_newRaffleValidateAndCheckSignature(
        uint32 id,
        uint256 payAmount,
        address organizer,
        uint32 totalTickets,
        uint32 totalPriorityTickets,
        uint32 maxTicketsPerWallet,
        uint32 maxRewardsPerWallet,
        uint32 availableRewards,
        uint8 rewardIf,
        address rewardContract,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        bool shouldDistributeRewards,
        bool shouldRefundNonWinning,
        uint256 startAt,
        uint256 endAt,
        uint256 raffleAt,
        uint256 sysTicketPrice,
        uint16 ownerFeePct,
        uint16 ownerTipPct,
        LiberoRewards_01.Requirement[] memory requirements,
        bytes memory signature
    ) public returns (address recoveredSigner) {
        require(msg.value == payAmount, "MUST_PAY_EXACT_AMOUNT");
        require(
            (bytes(mintUri).length == 0 && rewardContract != address(0)) ||
                (bytes(mintUri).length > 0 && rewardContract == address(0)),
            "SET_EITHER_REWARD_OR_MINT"
        );
        require(availableRewards > 0, "MIN_1_REWARD");
        require(ownerFeePct >= 0 && ownerFeePct <= 100, "OWNER_FEE_INVALID");
        require(ownerTipPct >= 0 && ownerTipPct <= 100, "OWNER_TIP_INVALID");

        require(startAt > block.timestamp, "SHOULD_START_IN_FUTURE");
        require(endAt > startAt, "END_SHOULD_BE_AFTER_START");
        require(raffleAt >= endAt, "RAFFLE_SHOULD_BE_AFTER_END");

        // signature check
        bytes memory packed = abi.encodePacked(
            id,
            payAmount,
            organizer,
            totalTickets,
            totalPriorityTickets,
            maxTicketsPerWallet,
            maxRewardsPerWallet,
            availableRewards,
            rewardIf,
            rewardContract,
            mintUri,
            mintName,
            mintSymbol,
            shouldDistributeRewards,
            shouldRefundNonWinning,
            startAt,
            endAt,
            raffleAt,
            sysTicketPrice,
            ownerFeePct,
            ownerTipPct
        );
        for (uint256 i = 0; i < requirements.length; i++) {
            packed = abi.encodePacked(
                packed,
                requirements[i].burnIf,
                requirements[i].burnTokenAmount,
                requirements[i].burnContract,
                requirements[i].ticketPrice
            );
        }
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            packed
        );
        recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
    }

    function ext_buyTicketsValidateAndCheckSignature(
        uint32 raffleNr,
        Raffle storage activeRaffle,
        Ticketing_01.Ticket[] calldata toBuy,
        Ticketing_01.Ticket[] calldata toReturn,
        uint256 tip,
        bytes memory signature
    )
        public
        returns (
            address recoveredSigner,
            uint256 netPayAmount,
            uint256 netRefundAmount
        )
    {
        require(
            block.timestamp >= activeRaffle.startAt &&
                block.timestamp < activeRaffle.endAt,
            "TICKET_SALE_NOT_ACTIVE"
        );

        uint256 expectedPayAmount = 0;
        uint256 expectedRefundAmount = 0;
        netPayAmount = 0;
        netRefundAmount = 0;
        for (uint256 i = 0; i < toBuy.length; i++) {
            uint8 reqNr = toBuy[i].reqNr;
            require(
                reqNr < activeRaffle.requirements.length,
                "BUY_REQUIREMENT_IX_NOT_FOUND"
            );
            uint256 price = activeRaffle.requirements[reqNr].ticketPrice;
            expectedPayAmount += price;
        }
        for (uint256 i = 0; i < toReturn.length; i++) {
            uint8 reqNr = toReturn[i].reqNr;
            require(
                reqNr < activeRaffle.requirements.length,
                "RETURN_REQUIREMENT_IX_NOT_FOUND"
            );
            uint256 price = activeRaffle.requirements[reqNr].ticketPrice;
            expectedRefundAmount += price;
        }
        if (expectedPayAmount > expectedRefundAmount) {
            netPayAmount = expectedPayAmount - expectedRefundAmount;
        } else {
            netRefundAmount = expectedRefundAmount - expectedPayAmount;
        }

        require(
            msg.value ==
                netPayAmount +
                    (toBuy.length * activeRaffle.sysTicketPrice) +
                    tip,
            "INVALID_PAYMENT_FOR_TICKETS"
        );

        bytes memory packed = abi.encodePacked(raffleNr);
        for (uint256 i = 0; i < toBuy.length; i++) {
            require(
                msg.sender == address(toBuy[i].wallet),
                "MUST_BUY_TICKET_FOR_SELF"
            );
            require(toBuy[i].valid, "MUST_BUY_VALID_TICKET");
            packed = abi.encodePacked(
                packed,
                toBuy[i].tokenId,
                toBuy[i].wallet,
                toBuy[i].ticketId,
                toBuy[i].ticketNr,
                toBuy[i].reqNr,
                toBuy[i].isPriority,
                toBuy[i].valid
            );
        }
        for (uint256 i = 0; i < toReturn.length; i++) {
            require(
                msg.sender == address(toReturn[i].wallet),
                "MUST_RETURN_TICKET_FROM_SELF"
            );
            require(!toReturn[i].valid, "MUST_RETURN_NOT_VALID_TICKET");
            packed = abi.encodePacked(
                packed,
                toReturn[i].tokenId,
                toReturn[i].wallet,
                toReturn[i].ticketId,
                toReturn[i].ticketNr,
                toReturn[i].reqNr,
                toReturn[i].isPriority,
                toReturn[i].valid
            );
        }
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            packed
        );
        recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
    }

    function ext_burnRewardIxInternal(
        uint32 raffleNr,
        WinningTicket calldata winningTicket,
        Requirement[] calldata requirements
    ) public returns (bool success) {
        if (!winningTicket.skipped) {
            success = true;
            if (requirements.length > 0) {
                uint8 reqNr = winningTicket.ticket.reqNr;
                if (reqNr <= requirements.length) {
                    Requirement memory requirement = requirements[reqNr];

                    if (requirement.burnIf == IF_ERC721) {
                        if (winningTicket.ticket.reqNr >= requirements.length) {
                            success = false;
                            _rewardError(
                                raffleNr,
                                "burn.erc721.error",
                                "TICKET_BURN_TOKEN_NOT_FOUND",
                                winningTicket
                            );
                        } else {
                            ERC721Burnable burn721 = ERC721Burnable(
                                requirements[winningTicket.ticket.reqNr]
                                    .burnContract
                            );
                            try
                                burn721.burn(winningTicket.ticket.tokenId)
                            {} catch Error(string memory reason) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc721.error",
                                    reason,
                                    winningTicket
                                );
                            } catch (bytes memory lowLevelData) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc721.error.0",
                                    string(lowLevelData),
                                    winningTicket
                                );
                            }
                        }
                    } else if (requirement.burnIf == IF_ERC1155) {
                        if (winningTicket.ticket.reqNr >= requirements.length) {
                            success = false;
                            _rewardError(
                                raffleNr,
                                "burn.erc1155.error",
                                "TICKET_BURN_TOKEN_NOT_FOUND",
                                winningTicket
                            );
                        } else {
                            ERC1155Burnable burn1155 = ERC1155Burnable(
                                requirements[winningTicket.ticket.reqNr]
                                    .burnContract
                            );
                            try
                                burn1155.burn(
                                    address(winningTicket.ticket.wallet),
                                    winningTicket.ticket.tokenId,
                                    requirements[winningTicket.ticket.reqNr]
                                        .burnTokenAmount
                                )
                            {} catch Error(string memory reason) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc1155.error",
                                    reason,
                                    winningTicket
                                );
                            } catch (bytes memory lowLevelData) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc1155.error.0",
                                    string(lowLevelData),
                                    winningTicket
                                );
                            }
                        }
                    } else if (requirement.burnIf == IF_MANIFOLD1155) {
                        if (winningTicket.ticket.reqNr >= requirements.length) {
                            success = false;
                            _rewardError(
                                raffleNr,
                                "burn.erc1155.error",
                                "TICKET_BURN_TOKEN_NOT_FOUND",
                                winningTicket
                            );
                        } else {
                            ManifoldERC1155Burnable burn1155 = ManifoldERC1155Burnable(
                                    requirements[winningTicket.ticket.reqNr]
                                        .burnContract
                                );
                            uint256[] memory ids = new uint256[](1);
                            uint256[] memory values = new uint256[](1);
                            ids[0] = winningTicket.ticket.tokenId;
                            values[0] = requirements[winningTicket.ticket.reqNr]
                                .burnTokenAmount;
                            try
                                burn1155.burn(
                                    address(winningTicket.ticket.wallet),
                                    ids,
                                    values
                                )
                            {} catch Error(string memory reason) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.manifold1155.error",
                                    reason,
                                    winningTicket
                                );
                            } catch (bytes memory lowLevelData) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.manifold1155.error.0",
                                    string(lowLevelData),
                                    winningTicket
                                );
                            }
                        }
                    }
                } else {
                    success = false;
                    _rewardError(
                        raffleNr,
                        "burn.token.error",
                        "REQ_BURN_TOKEN_NOT_FOUND",
                        winningTicket
                    );
                }
            }
        }
    }

    function ext_sendRewardIxInternal(
        uint32 raffleNr,
        WinningTicket calldata winningTicket,
        uint8 rewardIf,
        address rewardContract,
        address mintContract,
        address organizer
    ) public returns (bool success) {
        if (!winningTicket.skipped) {
            success = true;
            // mint
            if (mintContract != address(0)) {
                if (rewardIf == IF_ERC721) {
                    LiberoERC721_01 mint721 = LiberoERC721_01(mintContract);
                    try
                        mint721.mintTo(
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint721.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint721.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                } else if (rewardIf == IF_ERC1155) {
                    LiberoERC1155_01 mint1155 = LiberoERC1155_01(mintContract);
                    try
                        mint1155.mint(
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId,
                            winningTicket.reward.tokenAmount,
                            ""
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint1155.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint1155.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                }
            } else if (rewardContract != address(0)) {
                // transfer reward
                if (rewardIf == IF_ERC721) {
                    IERC721 reward721 = IERC721(rewardContract);
                    try
                        reward721.safeTransferFrom(
                            organizer,
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer721.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer721.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                } else if (rewardIf == IF_ERC1155) {
                    IERC1155 reward1155 = IERC1155(rewardContract);
                    try
                        reward1155.safeTransferFrom(
                            organizer,
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId,
                            winningTicket.reward.tokenAmount,
                            ""
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer1155.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer1155.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                }
            }
            if (success) {
                emit LiberoRewards_01.RewardSuccessful(
                    raffleNr,
                    winningTicket.reward.tokenId,
                    winningTicket.reward.tokenAmount,
                    winningTicket.ticket.tokenId,
                    winningTicket.ticket.wallet,
                    winningTicket.ticket.ticketId,
                    winningTicket.ticket.ticketNr,
                    winningTicket.ticket.reqNr
                );
            }
        }
    }

    function ext_approveAwardInternal(
        uint8 rewardIf,
        address rewardContract,
        address organizer,
        Reward[] memory rewards
    ) public view {
        bool approved = false;
        // allow transfer of each token
        if (rewardIf == IF_ERC721) {
            IERC721 erc721 = IERC721(rewardContract);
            if (erc721.isApprovedForAll(organizer, address(this))) {
                approved = true;
            } else {
                for (uint256 i = 0; i < rewards.length; i++) {
                    if (
                        address(this) == erc721.getApproved(rewards[i].tokenId)
                    ) {
                        approved = true;
                    }
                }
            }
        } else if (rewardIf == IF_ERC1155) {
            IERC1155 erc1155 = IERC1155(rewardContract);
            if (erc1155.isApprovedForAll(organizer, address(this))) {
                approved = true;
            }
        }
        require(approved, "REWARD_NOT_APPROVED");
    }

    function ext_batchMint(
        uint8 rewardIf,
        address mintContract,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts
    ) public {
        require(to.length == tokenIds.length, "BATCH_MINT_L1");
        require(to.length == tokenAmounts.length, "BATCH_MINT_L2");
        if (mintContract != address(0)) {
            if (rewardIf == IF_ERC721) {
                LiberoERC721_01 mint721 = LiberoERC721_01(mintContract);
                for (uint256 i = 0; i < to.length; i++) {
                    mint721.mintTo(to[i], tokenIds[i]);
                }
            } else if (rewardIf == IF_ERC1155) {
                LiberoERC1155_01 mint1155 = LiberoERC1155_01(mintContract);
                for (uint256 i = 0; i < to.length; i++) {
                    mint1155.mint(to[i], tokenIds[i], tokenAmounts[i], "");
                }
            }
        }
    }

    function ext_batchMintCheckSignature(
        uint32 raffleNr,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts,
        bytes memory signature
    ) public pure returns (address recoveredSigner) {
        require(to.length == tokenIds.length, "BATCH_MINT_L1");
        require(to.length == tokenAmounts.length, "BATCH_MINT_L2");

        bytes memory packed = abi.encodePacked(raffleNr);

        for (uint256 i = 0; i < to.length; i++) {
            packed = abi.encodePacked(
                packed,
                to[i],
                tokenIds[i],
                tokenAmounts[i]
            );
        }

        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            packed
        );
        recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
    }

    function ext_payAny(
        address to,
        uint256 amount,
        uint32 gasLimit
    ) public returns (bool) {
        // payable(ticket.wallet).transfer(price);
        // return true;
        (bool sent, ) = payable(to).call{gas: gasLimit, value: amount}("");
        return sent;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

interface ManifoldERC1155Burnable {
    // burn (0x3db0f8ab)
    function burn(
        address account,
        uint256[] calldata tokenIds,
        uint256[] calldata amounts
    ) external;
}

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