Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• interface IERC20Errors
• interface IERC721Errors
• interface IERC1155Errors
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• library Strings
•    - function toString(uint256 value)
•    - function toStringSigned(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library StorageSlot
•    - function getAddressSlot(bytes32 slot)
•    - function getBooleanSlot(bytes32 slot)
•    - function getBytes32Slot(bytes32 slot)
•    - function getUint256Slot(bytes32 slot)
•    - function getStringSlot(bytes32 slot)
•    - function getStringSlot(string storage ...
•    - function getBytesSlot(bytes32 slot)
•    - function getBytesSlot(bytes storage s ...
• library Arrays
•    - function findUpperBound(uint256[] sto ...
•    - function unsafeAccess(address[] stora ...
•    - function unsafeAccess(bytes32[] stora ...
•    - function unsafeAccess(uint256[] stora ...
•    - function unsafeMemoryAccess(uint256[] ...
•    - function unsafeMemoryAccess(address[] ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• interface IERC1155Receiver is IERC165
•    - function onERC1155Received(
•    - function onERC1155BatchReceived(
• interface IERC1155 is IERC165
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(address fro ...
•    - function safeBatchTransferFrom(
• interface IERC1155MetadataURI is IERC ...
•    - function uri(uint256 id)
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function supportsInterface(bytes4 int ...
•    - function uri(uint256 /* id */)
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(address fro ...
•    - function safeBatchTransferFrom(
•    - function _update(address from, addres ...
•    - function _updateWithAcceptanceCheck(
•    - function _safeTransferFrom(address fr ...
•    - function _safeBatchTransferFrom(
•    - function _setURI(string memory newuri ...
•    - function _mint(address to, uint256 id ...
•    - function _mintBatch(address to, uint2 ...
•    - function _burn(address from, uint256 ...
•    - function _burnBatch(address from, uin ...
•    - function _setApprovalForAll(address o ...
•    - function _doSafeTransferAcceptanceChe ...
•    - function _doSafeBatchTransferAcceptan ...
•    - function _asSingletonArrays(
•    - function totalSupply(uint256 id)
•    - function totalSupply()
•    - function exists(uint256 id)
•    - function _update(
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract ERC1155HeartsToken is Own ... *
•    - function mintTokens(uint256 count)
•    - function closeMinting()
•    - function setMetadataUriPrefix(string ...
•    - function uri(uint256 identifier)

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2024-01-08
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/math/SignedMath.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

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

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

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

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

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/math/Math.sol

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)

// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

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

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

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

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

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol)

pragma solidity ^0.8.20;

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

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

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.20;

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

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

// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.20;

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

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

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.20;

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.20;

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// File: contracts/ERC1155HeartsToken.sol

pragma solidity ^0.8.20;

/**
 * @title ERC1155HeartsToken
 * @dev ERC1155 token contract for Serduszka of WOSP 2024.
 */
contract ERC1155HeartsToken is Ownable, ERC1155Supply {
    using Strings for uint256;
    using Strings for uint8;

    address private _wallet;
    string private _metadataUriPrefix;
    uint256 public currentIndex = 1;
    bool public canMint = true;

    /**
     * @dev The wallet is invalid (zero address).
     */
    error ERC1155HeartsTokenInvalidWallet();

    /**
     * @dev The token count is invalid (cannot be zero).
     */
    error ERC1155HeartsTokenInvalidTokenCount();

    /**
     * @dev Token identified by `identifier` does not exist.
     */
    error ERC1155HeartsTokenIdentifierDoesNotExist(uint256 identifier);

    /**
     * @dev Value is the same as current one.
     */
    error ERC1155HeartsTokenTheSameValue();

    /**
     * @dev Tokens minting was already finished.
     */
    error ERC1155HeartsTokenMintingAlreadyFinished();

    /**
     * @dev Requires that minting is still possible.
     */
    modifier onlyWhenCanMint {
        if (!canMint) {
            revert ERC1155HeartsTokenMintingAlreadyFinished();
        }
        _;
    }

    /**
     * @dev Creates token instance with URI prefix set to `metadataUriPrefix` and minted to `_wallet`.
     */
    constructor(address wallet, string memory metadataUriPrefix) ERC1155("") Ownable(_msgSender()) {
        if (wallet == address(0)) {
            revert ERC1155HeartsTokenInvalidWallet();
        }

        _wallet = wallet;
        _metadataUriPrefix = metadataUriPrefix;
    }

    /**
     * @dev Mints `count` tokens to `_wallet`.
     */
    function mintTokens(uint256 count) external onlyOwner onlyWhenCanMint {
        if (count == 0) {
            revert ERC1155HeartsTokenInvalidTokenCount();
        }

        uint256[] memory identifiers = new uint256[](count);
        uint256[] memory counts = new uint256[](count);

        for (uint256 i = 0; i < count; ++i) {
            identifiers[i] = currentIndex + i;
            counts[i] = 1;
        }

        currentIndex += count;

        _mintBatch(_wallet, identifiers, counts, "");
    }

    /**
     * @dev Closes minting.
     */
    function closeMinting() external onlyOwner onlyWhenCanMint {
        canMint = false;
    }

    /**
     * @dev Sets metadata URI prefix to `metadataUriPrefix`.
     */
    function setMetadataUriPrefix(string calldata metadataUriPrefix) external onlyOwner {
        if (keccak256(abi.encodePacked(_metadataUriPrefix)) == keccak256(abi.encodePacked(metadataUriPrefix))) {
            revert ERC1155HeartsTokenTheSameValue();
        }

        _metadataUriPrefix = metadataUriPrefix;
    }

    /**
     * @dev Returns metadata URI for given `identifier`.
     */
    function uri(uint256 identifier) public view override returns (string memory) {
        if (!exists(identifier)) {
            revert ERC1155HeartsTokenIdentifierDoesNotExist(identifier);
        }

        return string(abi.encodePacked(_metadataUriPrefix, identifier.toString(), ".json"));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"string","name":"metadataUriPrefix","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"identifier","type":"uint256"}],"name":"ERC1155HeartsTokenIdentifierDoesNotExist","type":"error"},{"inputs":[],"name":"ERC1155HeartsTokenInvalidTokenCount","type":"error"},{"inputs":[],"name":"ERC1155HeartsTokenInvalidWallet","type":"error"},{"inputs":[],"name":"ERC1155HeartsTokenMintingAlreadyFinished","type":"error"},{"inputs":[],"name":"ERC1155HeartsTokenTheSameValue","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"closeMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mintTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"metadataUriPrefix","type":"string"}],"name":"setMetadataUriPrefix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"identifier","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000008015ff8aa47e853c654363693d9c5845d78aa9360000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003368747470733a2f2f73746f726167652e676f6f676c65617069732e636f6d2f696e666c752d6e66742d776f73702f33322f682f00000000000000000000000000

-----Decoded View---------------
Arg [0] : wallet (address): 0x8015Ff8aA47E853C654363693d9c5845D78AA936
Arg [1] : metadataUriPrefix (string): https://storage.googleapis.com/influ-nft-wosp/32/h/

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000008015ff8aa47e853c654363693d9c5845d78aa936
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000033
Arg [3] : 68747470733a2f2f73746f726167652e676f6f676c65617069732e636f6d2f69
Arg [4] : 6e666c752d6e66742d776f73702f33322f682f00000000000000000000000000

70302:3081:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48764:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47873:310;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73077:303;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65020:102;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70497:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50587:441;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49064:567;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65220:108;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69293:103;;;:::i;:::-;;72490:93;;;:::i;:::-;;68618:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71912:523;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49704:146;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72671:322;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64845:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70535:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49922:159;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50153:357;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69551:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48764:134;48841:7;48868:9;:13;48878:2;48868:13;;;;;;;;;;;:22;48882:7;48868:22;;;;;;;;;;;;;;;;48861:29;;48764:134;;;;:::o;47873:310::-;47975:4;48027:26;48012:41;;;:11;:41;;;;:110;;;;48085:37;48070:52;;;:11;:52;;;;48012:110;:163;;;;48139:36;48163:11;48139:23;:36::i;:::-;48012:163;47992:183;;47873:310;;;:::o;73077:303::-;73140:13;73171:18;73178:10;73171:6;:18::i;:::-;73166:111;;73254:10;73213:52;;;;;;;;;;;:::i;:::-;;;;;;;;73166:111;73320:18;73340:21;:10;:19;:21::i;:::-;73303:68;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73289:83;;73077:303;;;:::o;65020:102::-;65072:7;65099:15;;65092:22;;65020:102;:::o;70497:31::-;;;;:::o;50587:441::-;50788:14;50805:12;:10;:12::i;:::-;50788:29;;50840:6;50832:14;;:4;:14;;;;:49;;;;;50851:30;50868:4;50874:6;50851:16;:30::i;:::-;50850:31;50832:49;50828:131;;;50934:6;50942:4;50905:42;;;;;;;;;;;;:::i;:::-;;;;;;;;50828:131;50969:51;50992:4;50998:2;51002:3;51007:6;51015:4;50969:22;:51::i;:::-;50777:251;50587:441;;;;;:::o;49064:567::-;49191:16;49243:3;:10;49224:8;:15;:29;49220:123;;49303:3;:10;49315:8;:15;49277:54;;;;;;;;;;;;:::i;:::-;;;;;;;;49220:123;49355:30;49402:8;:15;49388:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49355:63;;49436:9;49431:160;49455:8;:15;49451:1;:19;49431:160;;;49511:68;49521:30;49549:1;49521:8;:27;;:30;;;;:::i;:::-;49553:25;49576:1;49553:3;:22;;:25;;;;:::i;:::-;49511:9;:68::i;:::-;49492:13;49506:1;49492:16;;;;;;;;:::i;:::-;;;;;;;:87;;;;;49472:3;;;;;49431:160;;;;49610:13;49603:20;;;49064:567;;;;:::o;65220:108::-;65277:4;65319:1;65301:15;65313:2;65301:11;:15::i;:::-;:19;65294:26;;65220:108;;;:::o;69293:103::-;68504:13;:11;:13::i;:::-;69358:30:::1;69385:1;69358:18;:30::i;:::-;69293:103::o:0;72490:93::-;68504:13;:11;:13::i;:::-;71320:7:::1;;;;;;;;;;;71315:90;;71351:42;;;;;;;;;;;;;;71315:90;72570:5:::2;72560:7;;:15;;;;;;;;;;;;;;;;;;72490:93::o:0;68618:87::-;68664:7;68691:6;;;;;;;;;;;68684:13;;68618:87;:::o;71912:523::-;68504:13;:11;:13::i;:::-;71320:7:::1;;;;;;;;;;;71315:90;;71351:42;;;;;;;;;;;;;;71315:90;72006:1:::2;71997:5;:10:::0;71993:87:::2;;72031:37;;;;;;;;;;;;;;71993:87;72092:28;72137:5;72123:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72092:51;;72154:23;72194:5;72180:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72154:46;;72218:9;72213:124;72237:5;72233:1;:9;72213:124;;;72296:1;72281:12;;:16;;;;:::i;:::-;72264:11;72276:1;72264:14;;;;;;;;:::i;:::-;;;;;;;:33;;;::::0;::::2;72324:1;72312:6;72319:1;72312:9;;;;;;;;:::i;:::-;;;;;;;:13;;;::::0;::::2;72244:3;;;;;72213:124;;;;72365:5;72349:12;;:21;;;;;;;:::i;:::-;;;;;;;;72383:44;72394:7;;;;;;;;;;;72403:11;72416:6;72383:44;;;;;;;;;;;::::0;:10:::2;:44::i;:::-;71982:453;;71912:523:::0;:::o;49704:146::-;49790:52;49809:12;:10;:12::i;:::-;49823:8;49833;49790:18;:52::i;:::-;49704:146;;:::o;72671:322::-;68504:13;:11;:13::i;:::-;72848:17:::1;;72831:35;;;;;;;;;:::i;:::-;;;;;;;;;;;;;72821:46;;;;;;72797:18;72780:36;;;;;;;;:::i;:::-;;;;;;;;;;;;;72770:47;;;;;;:97:::0;72766:169:::1;;72891:32;;;;;;;;;;;;;;72766:169;72968:17;;72947:18;:38;;;;;;;:::i;:::-;;72671:322:::0;;:::o;64845:113::-;64907:7;64934:12;:16;64947:2;64934:16;;;;;;;;;;;;64927:23;;64845:113;;;:::o;70535:26::-;;;;;;;;;;;;;:::o;49922:159::-;50012:4;50036:18;:27;50055:7;50036:27;;;;;;;;;;;;;;;:37;50064:8;50036:37;;;;;;;;;;;;;;;;;;;;;;;;;50029:44;;49922:159;;;;:::o;50153:357::-;50277:14;50294:12;:10;:12::i;:::-;50277:29;;50329:6;50321:14;;:4;:14;;;;:49;;;;;50340:30;50357:4;50363:6;50340:16;:30::i;:::-;50339:31;50321:49;50317:131;;;50423:6;50431:4;50394:42;;;;;;;;;;;;:::i;:::-;;;;;;;;50317:131;50458:44;50476:4;50482:2;50486;50490:5;50497:4;50458:17;:44::i;:::-;50266:244;50153:357;;;;;:::o;69551:220::-;68504:13;:11;:13::i;:::-;69656:1:::1;69636:22;;:8;:22;;::::0;69632:93:::1;;69710:1;69682:31;;;;;;;;;;;:::i;:::-;;;;;;;;69632:93;69735:28;69754:8;69735:18;:28::i;:::-;69551:220:::0;:::o;37451:148::-;37527:4;37566:25;37551:40;;;:11;:40;;;;37544:47;;37451:148;;;:::o;24250:718::-;24306:13;24357:14;24394:1;24374:17;24385:5;24374:10;:17::i;:::-;:21;24357:38;;24410:20;24444:6;24433:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24410:41;;24466:11;24595:6;24591:2;24587:15;24579:6;24575:28;24568:35;;24632:290;24639:4;24632:290;;;24664:5;;;;;;;;24806:10;24801:2;24794:5;24790:14;24785:32;24780:3;24772:46;24864:2;24855:11;;;;;;:::i;:::-;;;;;24898:1;24889:5;:10;24632:290;24885:21;24632:290;24943:6;24936:13;;;;;24250:718;;;:::o;46519:98::-;46572:7;46599:10;46592:17;;46519:98;:::o;55715:459::-;55929:1;55915:16;;:2;:16;;;55911:90;;55986:1;55955:34;;;;;;;;;;;:::i;:::-;;;;;;;;55911:90;56031:1;56015:18;;:4;:18;;;56011:90;;56086:1;56057:32;;;;;;;;;;;:::i;:::-;;;;;;;;56011:90;56111:55;56138:4;56144:2;56148:3;56153:6;56161:4;56111:26;:55::i;:::-;55715:459;;;;;:::o;35535:201::-;35621:11;35711:4;35706:3;35702:14;35695:4;35690:3;35686:14;35682:35;35676:42;35669:49;;35535:201;;;;:::o;35125:::-;35211:11;35301:4;35296:3;35292:14;35285:4;35280:3;35276:14;35272:35;35266:42;35259:49;;35125:201;;;;:::o;68783:166::-;68854:12;:10;:12::i;:::-;68843:23;;:7;:5;:7::i;:::-;:23;;;68839:103;;68917:12;:10;:12::i;:::-;68890:40;;;;;;;;;;;:::i;:::-;;;;;;;;68839:103;68783:166::o;69931:191::-;70005:16;70024:6;;;;;;;;;;;70005:25;;70050:8;70041:6;;:17;;;;;;;;;;;;;;;;;;70105:8;70074:40;;70095:8;70074:40;;;;;;;;;;;;69994:128;69931:191;:::o;58293:287::-;58429:1;58415:16;;:2;:16;;;58411:90;;58486:1;58455:34;;;;;;;;;;;:::i;:::-;;;;;;;;58411:90;58511:61;58546:1;58550:2;58554:3;58559:6;58567:4;58511:26;:61::i;:::-;58293:287;;;;:::o;60090:321::-;60218:1;60198:22;;:8;:22;;;60194:96;;60275:1;60244:34;;;;;;;;;;;:::i;:::-;;;;;;;;60194:96;60338:8;60300:18;:25;60319:5;60300:25;;;;;;;;;;;;;;;:35;60326:8;60300:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;60384:8;60362:41;;60377:5;60362:41;;;60394:8;60362:41;;;;;;:::i;:::-;;;;;;;;60090:321;;;:::o;54829:472::-;54966:1;54952:16;;:2;:16;;;54948:90;;55023:1;54992:34;;;;;;;;;;;:::i;:::-;;;;;;;;54948:90;55068:1;55052:18;;:4;:18;;;55048:90;;55123:1;55094:32;;;;;;;;;;;:::i;:::-;;;;;;;;55048:90;55149:20;55171:23;55198:29;55217:2;55221:5;55198:18;:29::i;:::-;55148:79;;;;55238:55;55265:4;55271:2;55275:3;55280:6;55288:4;55238:26;:55::i;:::-;54937:364;;54829:472;;;;;:::o;20660:948::-;20713:7;20733:14;20750:1;20733:18;;20800:8;20791:5;:17;20787:106;;20838:8;20829:17;;;;;;:::i;:::-;;;;;20875:2;20865:12;;;;20787:106;20920:8;20911:5;:17;20907:106;;20958:8;20949:17;;;;;;:::i;:::-;;;;;20995:2;20985:12;;;;20907:106;21040:8;21031:5;:17;21027:106;;21078:8;21069:17;;;;;;:::i;:::-;;;;;21115:2;21105:12;;;;21027:106;21160:7;21151:5;:16;21147:103;;21197:7;21188:16;;;;;;:::i;:::-;;;;;21233:1;21223:11;;;;21147:103;21277:7;21268:5;:16;21264:103;;21314:7;21305:16;;;;;;:::i;:::-;;;;;21350:1;21340:11;;;;21264:103;21394:7;21385:5;:16;21381:103;;21431:7;21422:16;;;;;;:::i;:::-;;;;;21467:1;21457:11;;;;21381:103;21511:7;21502:5;:16;21498:68;;21549:1;21539:11;;;;21498:68;21594:6;21587:13;;;20660:948;;;:::o;53650:708::-;53858:30;53866:4;53872:2;53876:3;53881:6;53858:7;:30::i;:::-;53917:1;53903:16;;:2;:16;;;53899:452;;53936:16;53955:12;:10;:12::i;:::-;53936:31;;54000:1;53986:3;:10;:15;53982:358;;54022:10;54035:25;54058:1;54035:3;:22;;:25;;;;:::i;:::-;54022:38;;54079:13;54095:28;54121:1;54095:6;:25;;:28;;;;:::i;:::-;54079:44;;54142:67;54173:8;54183:4;54189:2;54193;54197:5;54204:4;54142:30;:67::i;:::-;54003:222;;53982:358;;;54250:74;54286:8;54296:4;54302:2;54306:3;54311:6;54319:4;54250:35;:74::i;:::-;53982:358;53921:430;53899:452;53650:708;;;;;:::o;62979:870::-;63090:23;63115;63280:4;63274:11;63264:21;;63352:1;63344:6;63337:17;63492:8;63485:4;63477:6;63473:17;63466:35;63617:4;63609:6;63605:17;63595:27;;63651:1;63643:6;63636:17;63693:8;63686:4;63678:6;63674:17;63667:35;63825:4;63817:6;63813:17;63807:4;63800:31;62979:870;;;;;:::o;65390:1555::-;65560:36;65574:4;65580:2;65584:3;65589:6;65560:13;:36::i;:::-;65629:1;65613:18;;:4;:18;;;65609:543;;65648:22;65694:9;65689:298;65713:3;:10;65709:1;:14;65689:298;;;65749:13;65765:6;65772:1;65765:9;;;;;;;;:::i;:::-;;;;;;;;65749:25;;65924:5;65900:12;:20;65913:3;65917:1;65913:6;;;;;;;;:::i;:::-;;;;;;;;65900:20;;;;;;;;;;;;:29;;;;;;;:::i;:::-;;;;;;;;65966:5;65948:23;;;;;:::i;:::-;;;65730:257;65725:3;;;;;65689:298;;;;66126:14;66107:15;;:33;;;;;;;:::i;:::-;;;;;;;;65633:519;65609:543;66182:1;66168:16;;:2;:16;;;66164:774;;66201:22;66247:9;66242:468;66266:3;:10;66262:1;:14;66242:468;;;66302:13;66318:6;66325:1;66318:9;;;;;;;;:::i;:::-;;;;;;;;66302:25;;66512:5;66488:12;:20;66501:3;66505:1;66501:6;;;;;;;;:::i;:::-;;;;;;;;66488:20;;;;;;;;;;;;:29;;;;;;;;;;;66670:5;66652:23;;;;66283:427;66278:3;;;;;66242:468;;;;66897:14;66878:15;;:33;;;;;;;;;;;66186:752;66164:774;65390:1555;;;;:::o;60595:1000::-;60826:1;60809:2;:14;;;:18;60805:783;;;60865:2;60848:38;;;60887:8;60897:4;60903:2;60907:5;60914:4;60848:71;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;60844:733;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61226:1;61209:6;:13;:18;61205:357;;61338:2;61315:26;;;;;;;;;;;:::i;:::-;;;;;;;;61205:357;61512:6;61506:13;61497:6;61493:2;61489:15;61482:38;60844:733;60981:43;;;60969:55;;;:8;:55;;;;60965:177;;61119:2;61096:26;;;;;;;;;;;:::i;:::-;;;;;;;;60965:177;60920:237;60805:783;60595:1000;;;;;;:::o;61789:1069::-;62045:1;62028:2;:14;;;:18;62024:827;;;62084:2;62067:43;;;62111:8;62121:4;62127:3;62132:6;62140:4;62067:78;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;62063:777;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62489:1;62472:6;:13;:18;62468:357;;62601:2;62578:26;;;;;;;;;;;:::i;:::-;;;;;;;;62468:357;62775:6;62769:13;62760:6;62756:2;62752:15;62745:38;62063:777;62239:48;;;62227:60;;;:8;:60;;;;62223:182;;62382:2;62359:26;;;;;;;;;;;:::i;:::-;;;;;;;;62223:182;62146:274;62024:827;61789:1069;;;;;;:::o;51745:1315::-;51881:6;:13;51867:3;:10;:27;51863:119;;51944:3;:10;51956:6;:13;51918:52;;;;;;;;;;;;:::i;:::-;;;;;;;;51863:119;51994:16;52013:12;:10;:12::i;:::-;51994:31;;52043:9;52038:709;52062:3;:10;52058:1;:14;52038:709;;;52094:10;52107:25;52130:1;52107:3;:22;;:25;;;;:::i;:::-;52094:38;;52147:13;52163:28;52189:1;52163:6;:25;;:28;;;;:::i;:::-;52147:44;;52228:1;52212:18;;:4;:18;;;52208:429;;52251:19;52273:9;:13;52283:2;52273:13;;;;;;;;;;;:19;52287:4;52273:19;;;;;;;;;;;;;;;;52251:41;;52329:5;52315:11;:19;52311:131;;;52393:4;52399:11;52412:5;52419:2;52366:56;;;;;;;;;;;;;;:::i;:::-;;;;;;;;52311:131;52597:5;52583:11;:19;52561:9;:13;52571:2;52561:13;;;;;;;;;;;:19;52575:4;52561:19;;;;;;;;;;;;;;;:41;;;;52232:405;52208:429;52671:1;52657:16;;:2;:16;;;52653:83;;52715:5;52694:9;:13;52704:2;52694:13;;;;;;;;;;;:17;52708:2;52694:17;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;52653:83;52079:668;;52074:3;;;;;52038:709;;;;52777:1;52763:3;:10;:15;52759:294;;52795:10;52808:25;52831:1;52808:3;:22;;:25;;;;:::i;:::-;52795:38;;52848:13;52864:28;52890:1;52864:6;:25;;:28;;;;:::i;:::-;52848:44;;52943:2;52912:45;;52937:4;52912:45;;52927:8;52912:45;;;52947:2;52951:5;52912:45;;;;;;;:::i;:::-;;;;;;;;52780:189;;52759:294;;;53025:2;52995:46;;53019:4;52995:46;;53009:8;52995:46;;;53029:3;53034:6;52995:46;;;;;;;:::i;:::-;;;;;;;;52759:294;51852:1208;51745:1315;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:474::-;1265:6;1273;1322:2;1310:9;1301:7;1297:23;1293:32;1290:119;;;1328:79;;:::i;:::-;1290:119;1448:1;1473:53;1518:7;1509:6;1498:9;1494:22;1473:53;:::i;:::-;1463:63;;1419:117;1575:2;1601:53;1646:7;1637:6;1626:9;1622:22;1601:53;:::i;:::-;1591:63;;1546:118;1197:474;;;;;:::o;1677:118::-;1764:24;1782:5;1764:24;:::i;:::-;1759:3;1752:37;1677:118;;:::o;1801:222::-;1894:4;1932:2;1921:9;1917:18;1909:26;;1945:71;2013:1;2002:9;1998:17;1989:6;1945:71;:::i;:::-;1801:222;;;;:::o;2029:149::-;2065:7;2105:66;2098:5;2094:78;2083:89;;2029:149;;;:::o;2184:120::-;2256:23;2273:5;2256:23;:::i;:::-;2249:5;2246:34;2236:62;;2294:1;2291;2284:12;2236:62;2184:120;:::o;2310:137::-;2355:5;2393:6;2380:20;2371:29;;2409:32;2435:5;2409:32;:::i;:::-;2310:137;;;;:::o;2453:327::-;2511:6;2560:2;2548:9;2539:7;2535:23;2531:32;2528:119;;;2566:79;;:::i;:::-;2528:119;2686:1;2711:52;2755:7;2746:6;2735:9;2731:22;2711:52;:::i;:::-;2701:62;;2657:116;2453:327;;;;:::o;2786:90::-;2820:7;2863:5;2856:13;2849:21;2838:32;;2786:90;;;:::o;2882:109::-;2963:21;2978:5;2963:21;:::i;:::-;2958:3;2951:34;2882:109;;:::o;2997:210::-;3084:4;3122:2;3111:9;3107:18;3099:26;;3135:65;3197:1;3186:9;3182:17;3173:6;3135:65;:::i;:::-;2997:210;;;;:::o;3213:329::-;3272:6;3321:2;3309:9;3300:7;3296:23;3292:32;3289:119;;;3327:79;;:::i;:::-;3289:119;3447:1;3472:53;3517:7;3508:6;3497:9;3493:22;3472:53;:::i;:::-;3462:63;;3418:117;3213:329;;;;:::o;3548:99::-;3600:6;3634:5;3628:12;3618:22;;3548:99;;;:::o;3653:169::-;3737:11;3771:6;3766:3;3759:19;3811:4;3806:3;3802:14;3787:29;;3653:169;;;;:::o;3828:246::-;3909:1;3919:113;3933:6;3930:1;3927:13;3919:113;;;4018:1;4013:3;4009:11;4003:18;3999:1;3994:3;3990:11;3983:39;3955:2;3952:1;3948:10;3943:15;;3919:113;;;4066:1;4057:6;4052:3;4048:16;4041:27;3890:184;3828:246;;;:::o;4080:102::-;4121:6;4172:2;4168:7;4163:2;4156:5;4152:14;4148:28;4138:38;;4080:102;;;:::o;4188:377::-;4276:3;4304:39;4337:5;4304:39;:::i;:::-;4359:71;4423:6;4418:3;4359:71;:::i;:::-;4352:78;;4439:65;4497:6;4492:3;4485:4;4478:5;4474:16;4439:65;:::i;:::-;4529:29;4551:6;4529:29;:::i;:::-;4524:3;4520:39;4513:46;;4280:285;4188:377;;;;:::o;4571:313::-;4684:4;4722:2;4711:9;4707:18;4699:26;;4771:9;4765:4;4761:20;4757:1;4746:9;4742:17;4735:47;4799:78;4872:4;4863:6;4799:78;:::i;:::-;4791:86;;4571:313;;;;:::o;4890:117::-;4999:1;4996;4989:12;5013:180;5061:77;5058:1;5051:88;5158:4;5155:1;5148:15;5182:4;5179:1;5172:15;5199:281;5282:27;5304:4;5282:27;:::i;:::-;5274:6;5270:40;5412:6;5400:10;5397:22;5376:18;5364:10;5361:34;5358:62;5355:88;;;5423:18;;:::i;:::-;5355:88;5463:10;5459:2;5452:22;5242:238;5199:281;;:::o;5486:129::-;5520:6;5547:20;;:::i;:::-;5537:30;;5576:33;5604:4;5596:6;5576:33;:::i;:::-;5486:129;;;:::o;5621:311::-;5698:4;5788:18;5780:6;5777:30;5774:56;;;5810:18;;:::i;:::-;5774:56;5860:4;5852:6;5848:17;5840:25;;5920:4;5914;5910:15;5902:23;;5621:311;;;:::o;5938:117::-;6047:1;6044;6037:12;6078:710;6174:5;6199:81;6215:64;6272:6;6215:64;:::i;:::-;6199:81;:::i;:::-;6190:90;;6300:5;6329:6;6322:5;6315:21;6363:4;6356:5;6352:16;6345:23;;6416:4;6408:6;6404:17;6396:6;6392:30;6445:3;6437:6;6434:15;6431:122;;;6464:79;;:::i;:::-;6431:122;6579:6;6562:220;6596:6;6591:3;6588:15;6562:220;;;6671:3;6700:37;6733:3;6721:10;6700:37;:::i;:::-;6695:3;6688:50;6767:4;6762:3;6758:14;6751:21;;6638:144;6622:4;6617:3;6613:14;6606:21;;6562:220;;;6566:21;6180:608;;6078:710;;;;;:::o;6811:370::-;6882:5;6931:3;6924:4;6916:6;6912:17;6908:27;6898:122;;6939:79;;:::i;:::-;6898:122;7056:6;7043:20;7081:94;7171:3;7163:6;7156:4;7148:6;7144:17;7081:94;:::i;:::-;7072:103;;6888:293;6811:370;;;;:::o;7187:117::-;7296:1;7293;7286:12;7310:307;7371:4;7461:18;7453:6;7450:30;7447:56;;;7483:18;;:::i;:::-;7447:56;7521:29;7543:6;7521:29;:::i;:::-;7513:37;;7605:4;7599;7595:15;7587:23;;7310:307;;;:::o;7623:146::-;7720:6;7715:3;7710;7697:30;7761:1;7752:6;7747:3;7743:16;7736:27;7623:146;;;:::o;7775:423::-;7852:5;7877:65;7893:48;7934:6;7893:48;:::i;:::-;7877:65;:::i;:::-;7868:74;;7965:6;7958:5;7951:21;8003:4;7996:5;7992:16;8041:3;8032:6;8027:3;8023:16;8020:25;8017:112;;;8048:79;;:::i;:::-;8017:112;8138:54;8185:6;8180:3;8175;8138:54;:::i;:::-;7858:340;7775:423;;;;;:::o;8217:338::-;8272:5;8321:3;8314:4;8306:6;8302:17;8298:27;8288:122;;8329:79;;:::i;:::-;8288:122;8446:6;8433:20;8471:78;8545:3;8537:6;8530:4;8522:6;8518:17;8471:78;:::i;:::-;8462:87;;8278:277;8217:338;;;;:::o;8561:1509::-;8715:6;8723;8731;8739;8747;8796:3;8784:9;8775:7;8771:23;8767:33;8764:120;;;8803:79;;:::i;:::-;8764:120;8923:1;8948:53;8993:7;8984:6;8973:9;8969:22;8948:53;:::i;:::-;8938:63;;8894:117;9050:2;9076:53;9121:7;9112:6;9101:9;9097:22;9076:53;:::i;:::-;9066:63;;9021:118;9206:2;9195:9;9191:18;9178:32;9237:18;9229:6;9226:30;9223:117;;;9259:79;;:::i;:::-;9223:117;9364:78;9434:7;9425:6;9414:9;9410:22;9364:78;:::i;:::-;9354:88;;9149:303;9519:2;9508:9;9504:18;9491:32;9550:18;9542:6;9539:30;9536:117;;;9572:79;;:::i;:::-;9536:117;9677:78;9747:7;9738:6;9727:9;9723:22;9677:78;:::i;:::-;9667:88;;9462:303;9832:3;9821:9;9817:19;9804:33;9864:18;9856:6;9853:30;9850:117;;;9886:79;;:::i;:::-;9850:117;9991:62;10045:7;10036:6;10025:9;10021:22;9991:62;:::i;:::-;9981:72;;9775:288;8561:1509;;;;;;;;:::o;10076:311::-;10153:4;10243:18;10235:6;10232:30;10229:56;;;10265:18;;:::i;:::-;10229:56;10315:4;10307:6;10303:17;10295:25;;10375:4;10369;10365:15;10357:23;;10076:311;;;:::o;10410:710::-;10506:5;10531:81;10547:64;10604:6;10547:64;:::i;:::-;10531:81;:::i;:::-;10522:90;;10632:5;10661:6;10654:5;10647:21;10695:4;10688:5;10684:16;10677:23;;10748:4;10740:6;10736:17;10728:6;10724:30;10777:3;10769:6;10766:15;10763:122;;;10796:79;;:::i;:::-;10763:122;10911:6;10894:220;10928:6;10923:3;10920:15;10894:220;;;11003:3;11032:37;11065:3;11053:10;11032:37;:::i;:::-;11027:3;11020:50;11099:4;11094:3;11090:14;11083:21;;10970:144;10954:4;10949:3;10945:14;10938:21;;10894:220;;;10898:21;10512:608;;10410:710;;;;;:::o;11143:370::-;11214:5;11263:3;11256:4;11248:6;11244:17;11240:27;11230:122;;11271:79;;:::i;:::-;11230:122;11388:6;11375:20;11413:94;11503:3;11495:6;11488:4;11480:6;11476:17;11413:94;:::i;:::-;11404:103;;11220:293;11143:370;;;;:::o;11519:894::-;11637:6;11645;11694:2;11682:9;11673:7;11669:23;11665:32;11662:119;;;11700:79;;:::i;:::-;11662:119;11848:1;11837:9;11833:17;11820:31;11878:18;11870:6;11867:30;11864:117;;;11900:79;;:::i;:::-;11864:117;12005:78;12075:7;12066:6;12055:9;12051:22;12005:78;:::i;:::-;11995:88;;11791:302;12160:2;12149:9;12145:18;12132:32;12191:18;12183:6;12180:30;12177:117;;;12213:79;;:::i;:::-;12177:117;12318:78;12388:7;12379:6;12368:9;12364:22;12318:78;:::i;:::-;12308:88;;12103:303;11519:894;;;;;:::o;12419:114::-;12486:6;12520:5;12514:12;12504:22;;12419:114;;;:::o;12539:184::-;12638:11;12672:6;12667:3;12660:19;12712:4;12707:3;12703:14;12688:29;;12539:184;;;;:::o;12729:132::-;12796:4;12819:3;12811:11;;12849:4;12844:3;12840:14;12832:22;;12729:132;;;:::o;12867:108::-;12944:24;12962:5;12944:24;:::i;:::-;12939:3;12932:37;12867:108;;:::o;12981:179::-;13050:10;13071:46;13113:3;13105:6;13071:46;:::i;:::-;13149:4;13144:3;13140:14;13126:28;;12981:179;;;;:::o;13166:113::-;13236:4;13268;13263:3;13259:14;13251:22;;13166:113;;;:::o;13315:732::-;13434:3;13463:54;13511:5;13463:54;:::i;:::-;13533:86;13612:6;13607:3;13533:86;:::i;:::-;13526:93;;13643:56;13693:5;13643:56;:::i;:::-;13722:7;13753:1;13738:284;13763:6;13760:1;13757:13;13738:284;;;13839:6;13833:13;13866:63;13925:3;13910:13;13866:63;:::i;:::-;13859:70;;13952:60;14005:6;13952:60;:::i;:::-;13942:70;;13798:224;13785:1;13782;13778:9;13773:14;;13738:284;;;13742:14;14038:3;14031:10;;13439:608;;;13315:732;;;;:::o;14053:373::-;14196:4;14234:2;14223:9;14219:18;14211:26;;14283:9;14277:4;14273:20;14269:1;14258:9;14254:17;14247:47;14311:108;14414:4;14405:6;14311:108;:::i;:::-;14303:116;;14053:373;;;;:::o;14432:118::-;14519:24;14537:5;14519:24;:::i;:::-;14514:3;14507:37;14432:118;;:::o;14556:222::-;14649:4;14687:2;14676:9;14672:18;14664:26;;14700:71;14768:1;14757:9;14753:17;14744:6;14700:71;:::i;:::-;14556:222;;;;:::o;14784:116::-;14854:21;14869:5;14854:21;:::i;:::-;14847:5;14844:32;14834:60;;14890:1;14887;14880:12;14834:60;14784:116;:::o;14906:133::-;14949:5;14987:6;14974:20;14965:29;;15003:30;15027:5;15003:30;:::i;:::-;14906:133;;;;:::o;15045:468::-;15110:6;15118;15167:2;15155:9;15146:7;15142:23;15138:32;15135:119;;;15173:79;;:::i;:::-;15135:119;15293:1;15318:53;15363:7;15354:6;15343:9;15339:22;15318:53;:::i;:::-;15308:63;;15264:117;15420:2;15446:50;15488:7;15479:6;15468:9;15464:22;15446:50;:::i;:::-;15436:60;;15391:115;15045:468;;;;;:::o;15519:117::-;15628:1;15625;15618:12;15656:553;15714:8;15724:6;15774:3;15767:4;15759:6;15755:17;15751:27;15741:122;;15782:79;;:::i;:::-;15741:122;15895:6;15882:20;15872:30;;15925:18;15917:6;15914:30;15911:117;;;15947:79;;:::i;:::-;15911:117;16061:4;16053:6;16049:17;16037:29;;16115:3;16107:4;16099:6;16095:17;16085:8;16081:32;16078:41;16075:128;;;16122:79;;:::i;:::-;16075:128;15656:553;;;;;:::o;16215:529::-;16286:6;16294;16343:2;16331:9;16322:7;16318:23;16314:32;16311:119;;;16349:79;;:::i;:::-;16311:119;16497:1;16486:9;16482:17;16469:31;16527:18;16519:6;16516:30;16513:117;;;16549:79;;:::i;:::-;16513:117;16662:65;16719:7;16710:6;16699:9;16695:22;16662:65;:::i;:::-;16644:83;;;;16440:297;16215:529;;;;;:::o;16750:474::-;16818:6;16826;16875:2;16863:9;16854:7;16850:23;16846:32;16843:119;;;16881:79;;:::i;:::-;16843:119;17001:1;17026:53;17071:7;17062:6;17051:9;17047:22;17026:53;:::i;:::-;17016:63;;16972:117;17128:2;17154:53;17199:7;17190:6;17179:9;17175:22;17154:53;:::i;:::-;17144:63;;17099:118;16750:474;;;;;:::o;17230:1089::-;17334:6;17342;17350;17358;17366;17415:3;17403:9;17394:7;17390:23;17386:33;17383:120;;;17422:79;;:::i;:::-;17383:120;17542:1;17567:53;17612:7;17603:6;17592:9;17588:22;17567:53;:::i;:::-;17557:63;;17513:117;17669:2;17695:53;17740:7;17731:6;17720:9;17716:22;17695:53;:::i;:::-;17685:63;;17640:118;17797:2;17823:53;17868:7;17859:6;17848:9;17844:22;17823:53;:::i;:::-;17813:63;;17768:118;17925:2;17951:53;17996:7;17987:6;17976:9;17972:22;17951:53;:::i;:::-;17941:63;;17896:118;18081:3;18070:9;18066:19;18053:33;18113:18;18105:6;18102:30;18099:117;;;18135:79;;:::i;:::-;18099:117;18240:62;18294:7;18285:6;18274:9;18270:22;18240:62;:::i;:::-;18230:72;;18024:288;17230:1089;;;;;;;;:::o;18325:329::-;18384:6;18433:2;18421:9;18412:7;18408:23;18404:32;18401:119;;;18439:79;;:::i;:::-;18401:119;18559:1;18584:53;18629:7;18620:6;18609:9;18605:22;18584:53;:::i;:::-;18574:63;;18530:117;18325:329;;;;:::o;18660:180::-;18708:77;18705:1;18698:88;18805:4;18802:1;18795:15;18829:4;18826:1;18819:15;18846:320;18890:6;18927:1;18921:4;18917:12;18907:22;;18974:1;18968:4;18964:12;18995:18;18985:81;;19051:4;19043:6;19039:17;19029:27;;18985:81;19113:2;19105:6;19102:14;19082:18;19079:38;19076:84;;19132:18;;:::i;:::-;19076:84;18897:269;18846:320;;;:::o;19172:148::-;19274:11;19311:3;19296:18;;19172:148;;;;:::o;19326:141::-;19375:4;19398:3;19390:11;;19421:3;19418:1;19411:14;19455:4;19452:1;19442:18;19434:26;;19326:141;;;:::o;19497:874::-;19600:3;19637:5;19631:12;19666:36;19692:9;19666:36;:::i;:::-;19718:89;19800:6;19795:3;19718:89;:::i;:::-;19711:96;;19838:1;19827:9;19823:17;19854:1;19849:166;;;;20029:1;20024:341;;;;19816:549;;19849:166;19933:4;19929:9;19918;19914:25;19909:3;19902:38;19995:6;19988:14;19981:22;19973:6;19969:35;19964:3;19960:45;19953:52;;19849:166;;20024:341;20091:38;20123:5;20091:38;:::i;:::-;20151:1;20165:154;20179:6;20176:1;20173:13;20165:154;;;20253:7;20247:14;20243:1;20238:3;20234:11;20227:35;20303:1;20294:7;20290:15;20279:26;;20201:4;20198:1;20194:12;20189:17;;20165:154;;;20348:6;20343:3;20339:16;20332:23;;20031:334;;19816:549;;19604:767;;19497:874;;;;:::o;20377:390::-;20483:3;20511:39;20544:5;20511:39;:::i;:::-;20566:89;20648:6;20643:3;20566:89;:::i;:::-;20559:96;;20664:65;20722:6;20717:3;20710:4;20703:5;20699:16;20664:65;:::i;:::-;20754:6;20749:3;20745:16;20738:23;;20487:280;20377:390;;;;:::o;20773:155::-;20913:7;20909:1;20901:6;20897:14;20890:31;20773:155;:::o;20934:400::-;21094:3;21115:84;21197:1;21192:3;21115:84;:::i;:::-;21108:91;;21208:93;21297:3;21208:93;:::i;:::-;21326:1;21321:3;21317:11;21310:18;;20934:400;;;:::o;21340:695::-;21618:3;21640:92;21728:3;21719:6;21640:92;:::i;:::-;21633:99;;21749:95;21840:3;21831:6;21749:95;:::i;:::-;21742:102;;21861:148;22005:3;21861:148;:::i;:::-;21854:155;;22026:3;22019:10;;21340:695;;;;;:::o;22041:332::-;22162:4;22200:2;22189:9;22185:18;22177:26;;22213:71;22281:1;22270:9;22266:17;22257:6;22213:71;:::i;:::-;22294:72;22362:2;22351:9;22347:18;22338:6;22294:72;:::i;:::-;22041:332;;;;;:::o;22379:::-;22500:4;22538:2;22527:9;22523:18;22515:26;;22551:71;22619:1;22608:9;22604:17;22595:6;22551:71;:::i;:::-;22632:72;22700:2;22689:9;22685:18;22676:6;22632:72;:::i;:::-;22379:332;;;;;:::o;22717:180::-;22765:77;22762:1;22755:88;22862:4;22859:1;22852:15;22886:4;22883:1;22876:15;22903:180;22951:77;22948:1;22941:88;23048:4;23045:1;23038:15;23072:4;23069:1;23062:15;23089:191;23129:3;23148:20;23166:1;23148:20;:::i;:::-;23143:25;;23182:20;23200:1;23182:20;:::i;:::-;23177:25;;23225:1;23222;23218:9;23211:16;;23246:3;23243:1;23240:10;23237:36;;;23253:18;;:::i;:::-;23237:36;23089:191;;;;:::o;23310:330::-;23426:3;23447:89;23529:6;23524:3;23447:89;:::i;:::-;23440:96;;23546:56;23595:6;23590:3;23583:5;23546:56;:::i;:::-;23627:6;23622:3;23618:16;23611:23;;23310:330;;;;;:::o;23646:295::-;23788:3;23810:105;23911:3;23902:6;23894;23810:105;:::i;:::-;23803:112;;23932:3;23925:10;;23646:295;;;;;:::o;23947:269::-;24076:3;24098:92;24186:3;24177:6;24098:92;:::i;:::-;24091:99;;24207:3;24200:10;;23947:269;;;;:::o;24222:97::-;24281:6;24309:3;24299:13;;24222:97;;;;:::o;24325:93::-;24362:6;24409:2;24404;24397:5;24393:14;24389:23;24379:33;;24325:93;;;:::o;24424:107::-;24468:8;24518:5;24512:4;24508:16;24487:37;;24424:107;;;;:::o;24537:393::-;24606:6;24656:1;24644:10;24640:18;24679:97;24709:66;24698:9;24679:97;:::i;:::-;24797:39;24827:8;24816:9;24797:39;:::i;:::-;24785:51;;24869:4;24865:9;24858:5;24854:21;24845:30;;24918:4;24908:8;24904:19;24897:5;24894:30;24884:40;;24613:317;;24537:393;;;;;:::o;24936:60::-;24964:3;24985:5;24978:12;;24936:60;;;:::o;25002:142::-;25052:9;25085:53;25103:34;25112:24;25130:5;25112:24;:::i;:::-;25103:34;:::i;:::-;25085:53;:::i;:::-;25072:66;;25002:142;;;:::o;25150:75::-;25193:3;25214:5;25207:12;;25150:75;;;:::o;25231:269::-;25341:39;25372:7;25341:39;:::i;:::-;25402:91;25451:41;25475:16;25451:41;:::i;:::-;25443:6;25436:4;25430:11;25402:91;:::i;:::-;25396:4;25389:105;25307:193;25231:269;;;:::o;25506:73::-;25551:3;25506:73;:::o;25585:189::-;25662:32;;:::i;:::-;25703:65;25761:6;25753;25747:4;25703:65;:::i;:::-;25638:136;25585:189;;:::o;25780:186::-;25840:120;25857:3;25850:5;25847:14;25840:120;;;25911:39;25948:1;25941:5;25911:39;:::i;:::-;25884:1;25877:5;25873:13;25864:22;;25840:120;;;25780:186;;:::o;25972:543::-;26073:2;26068:3;26065:11;26062:446;;;26107:38;26139:5;26107:38;:::i;:::-;26191:29;26209:10;26191:29;:::i;:::-;26181:8;26177:44;26374:2;26362:10;26359:18;26356:49;;;26395:8;26380:23;;26356:49;26418:80;26474:22;26492:3;26474:22;:::i;:::-;26464:8;26460:37;26447:11;26418:80;:::i;:::-;26077:431;;26062:446;25972:543;;;:::o;26521:117::-;26575:8;26625:5;26619:4;26615:16;26594:37;;26521:117;;;;:::o;26644:169::-;26688:6;26721:51;26769:1;26765:6;26757:5;26754:1;26750:13;26721:51;:::i;:::-;26717:56;26802:4;26796;26792:15;26782:25;;26695:118;26644:169;;;;:::o;26818:295::-;26894:4;27040:29;27065:3;27059:4;27040:29;:::i;:::-;27032:37;;27102:3;27099:1;27095:11;27089:4;27086:21;27078:29;;26818:295;;;;:::o;27118:1403::-;27242:44;27282:3;27277;27242:44;:::i;:::-;27351:18;27343:6;27340:30;27337:56;;;27373:18;;:::i;:::-;27337:56;27417:38;27449:4;27443:11;27417:38;:::i;:::-;27502:67;27562:6;27554;27548:4;27502:67;:::i;:::-;27596:1;27625:2;27617:6;27614:14;27642:1;27637:632;;;;28313:1;28330:6;28327:84;;;28386:9;28381:3;28377:19;28364:33;28355:42;;28327:84;28437:67;28497:6;28490:5;28437:67;:::i;:::-;28431:4;28424:81;28286:229;27607:908;;27637:632;27689:4;27685:9;27677:6;27673:22;27723:37;27755:4;27723:37;:::i;:::-;27782:1;27796:215;27810:7;27807:1;27804:14;27796:215;;;27896:9;27891:3;27887:19;27874:33;27866:6;27859:49;27947:1;27939:6;27935:14;27925:24;;27994:2;27983:9;27979:18;27966:31;;27833:4;27830:1;27826:12;27821:17;;27796:215;;;28039:6;28030:7;28027:19;28024:186;;;28104:9;28099:3;28095:19;28082:33;28147:48;28189:4;28181:6;28177:17;28166:9;28147:48;:::i;:::-;28139:6;28132:64;28047:163;28024:186;28256:1;28252;28244:6;28240:14;28236:22;28230:4;28223:36;27644:625;;;27607:908;;27217:1304;;;27118:1403;;;:::o;28527:180::-;28575:77;28572:1;28565:88;28672:4;28669:1;28662:15;28696:4;28693:1;28686:15;28713:98;28764:6;28798:5;28792:12;28782:22;;28713:98;;;:::o;28817:168::-;28900:11;28934:6;28929:3;28922:19;28974:4;28969:3;28965:14;28950:29;;28817:168;;;;:::o;28991:373::-;29077:3;29105:38;29137:5;29105:38;:::i;:::-;29159:70;29222:6;29217:3;29159:70;:::i;:::-;29152:77;;29238:65;29296:6;29291:3;29284:4;29277:5;29273:16;29238:65;:::i;:::-;29328:29;29350:6;29328:29;:::i;:::-;29323:3;29319:39;29312:46;;29081:283;28991:373;;;;:::o;29370:751::-;29593:4;29631:3;29620:9;29616:19;29608:27;;29645:71;29713:1;29702:9;29698:17;29689:6;29645:71;:::i;:::-;29726:72;29794:2;29783:9;29779:18;29770:6;29726:72;:::i;:::-;29808;29876:2;29865:9;29861:18;29852:6;29808:72;:::i;:::-;29890;29958:2;29947:9;29943:18;29934:6;29890:72;:::i;:::-;30010:9;30004:4;30000:20;29994:3;29983:9;29979:19;29972:49;30038:76;30109:4;30100:6;30038:76;:::i;:::-;30030:84;;29370:751;;;;;;;;:::o;30127:141::-;30183:5;30214:6;30208:13;30199:22;;30230:32;30256:5;30230:32;:::i;:::-;30127:141;;;;:::o;30274:349::-;30343:6;30392:2;30380:9;30371:7;30367:23;30363:32;30360:119;;;30398:79;;:::i;:::-;30360:119;30518:1;30543:63;30598:7;30589:6;30578:9;30574:22;30543:63;:::i;:::-;30533:73;;30489:127;30274:349;;;;:::o;30629:1053::-;30952:4;30990:3;30979:9;30975:19;30967:27;;31004:71;31072:1;31061:9;31057:17;31048:6;31004:71;:::i;:::-;31085:72;31153:2;31142:9;31138:18;31129:6;31085:72;:::i;:::-;31204:9;31198:4;31194:20;31189:2;31178:9;31174:18;31167:48;31232:108;31335:4;31326:6;31232:108;:::i;:::-;31224:116;;31387:9;31381:4;31377:20;31372:2;31361:9;31357:18;31350:48;31415:108;31518:4;31509:6;31415:108;:::i;:::-;31407:116;;31571:9;31565:4;31561:20;31555:3;31544:9;31540:19;31533:49;31599:76;31670:4;31661:6;31599:76;:::i;:::-;31591:84;;30629:1053;;;;;;;;:::o;31688:553::-;31865:4;31903:3;31892:9;31888:19;31880:27;;31917:71;31985:1;31974:9;31970:17;31961:6;31917:71;:::i;:::-;31998:72;32066:2;32055:9;32051:18;32042:6;31998:72;:::i;:::-;32080;32148:2;32137:9;32133:18;32124:6;32080:72;:::i;:::-;32162;32230:2;32219:9;32215:18;32206:6;32162:72;:::i;:::-;31688:553;;;;;;;:::o;32247:634::-;32468:4;32506:2;32495:9;32491:18;32483:26;;32555:9;32549:4;32545:20;32541:1;32530:9;32526:17;32519:47;32583:108;32686:4;32677:6;32583:108;:::i;:::-;32575:116;;32738:9;32732:4;32728:20;32723:2;32712:9;32708:18;32701:48;32766:108;32869:4;32860:6;32766:108;:::i;:::-;32758:116;;32247:634;;;;;:::o

ipfs://e39933ca2d8cb798ec6ae76f00fcee69bb8dfb806ad1c4bf78de928737b158f6