Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-07-16
*/

// SPDX-License-Identifier: MIT
// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/lib/Constants.sol


pragma solidity ^0.8.13;

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address registrantToSubscribe) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address addr) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/OperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 *         Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract OperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);

    /// @dev The constructor that is called when the contract is being deployed.
    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    /**
     * @dev A helper function to check if an operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 * @dev    Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract DefaultOperatorFilterer is OperatorFilterer {
    /// @dev The constructor that is called when the contract is being deployed.
    constructor() OperatorFilterer(CANONICAL_CORI_SUBSCRIPTION, true) {}
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && 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 down.
     *
     * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


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

    /**
     * @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), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @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) {
        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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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);
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/interfaces/IERC2981.sol


// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

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


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/common/ERC2981.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

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


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

pragma solidity ^0.8.0;


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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;







/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

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

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

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

    /**
     * @dev See {_setURI}.
     */
    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) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: address zero is not a valid owner");
        return _balances[id][account];
    }

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

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

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

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

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

        return array;
    }
}

// File: contracts/GregsAmazingNFTcollection.sol


pragma solidity ^0.8.18;





// following code comes from import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IERC20 {
// standard IERC20 from openzeppelin
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
// additional function to get current price of EQT
    function getEQTprice() external view returns (uint256);
    function transferExactAmount(address from, address to, uint256 amount) external returns (bool);
}


 
// This smart-contract was created by the developer of Equivalence Protocol (@EquivalenceTeam)

//********************************************************************************************
//***********************      HERE STARTS THE CODE OF CONTRACT     **************************
//********************************************************************************************

contract GregsAmazingLandscapes is ERC1155, DefaultOperatorFilterer, ERC2981 {

    address private _owner;
    modifier onlyOwner() {require(_owner == msg.sender, "Ownable: caller is not the owner"); _;}
    string public name = "Amazing Landscapes by Greg Miller - Limited Editions"; // name displayed on NFT platforms
    string internal baseURI = "ipfs://bafybeidyufdh2dvucuwcdffkmm2isgcc6dm4rhpbym5cunp6p66nbsnyaa/";
    IERC20 public EQT = IERC20(0xFdDCb0760F61f486fF0Ee65fc8C5014FCF586dB1);
    error incorrectSet();
    error incorrectCurrency();
    error alreadyMinted();
    error NFTnotOwned();
    error incorrectAmountOfETH();
    error NFTnotOnSale();
    bool[] public mintedSets = new bool[](11);
    bool public metadataFrozen;
    mapping(uint256 => uint256) public salePrices;          // 0 = no sale, other number = price of sale
    mapping(uint256 => uint256) public saleCurrency;        // 0 = ETH and EQT, 1 = ETH only, 2 = EQT only
    mapping(uint256 => address) internal saleAddresses;     // addresses which receive payment for NFT
    mapping(uint256 => address) internal previousOwners;    // addresses which receive part of royalty when NFT is resold using functions of this smart-contract

    constructor() ERC1155("") {
        _owner = msg.sender;
        _setDefaultRoyalty(_owner, 1000);
        uint256[] memory ids = new uint256[](41);
        uint256[] memory amounts = new uint256[](41);
        for (uint256 i = 0; i <= 40;) {ids[i] = i; amounts[i] = 1; unchecked{i++;}}
        _mintBatch(_owner, ids, amounts, "");
        mintedSets[0] = true;
    }

    function setEQTaddress(IERC20 _addr) external onlyOwner {if (!metadataFrozen) {EQT = _addr;}}
    function setBaseURI(string memory _uri) external onlyOwner {if (!metadataFrozen) {baseURI = _uri;}}
    function withdraw () external onlyOwner {
        if (address(this).balance >= 1) {payable(_owner).transfer(address(this).balance);}
        if (EQT.balanceOf(address(this)) >= 1) {EQT.transfer(_owner, EQT.balanceOf(address(this)));}}
    function freezeMetadata(bool confirm) external onlyOwner {if (confirm) {metadataFrozen = true;}}
    function mintNFTset (uint256 nftSet, address nftSetOwner) external onlyOwner {
        if (nftSet == 0 || nftSet >= 11) {revert incorrectSet();}
        if (mintedSets[nftSet]) {revert alreadyMinted();}
        uint256[] memory ids = new uint256[](41);
        uint256[] memory amounts = new uint256[](41);
        for (uint256 i = 0; i <= 40;) {amounts[i] = 1; unchecked{ids[i] = (40 + nftSet + (10 * i)); i++;}}
        _mintBatch(nftSetOwner, ids, amounts, "");
        mintedSets[nftSet] = true;
    }
    function createSale(uint256 id, uint256 price, uint256 currency) external {
        if (balanceOf(msg.sender, id) == 0) {revert NFTnotOwned();}
        if (currency >= 3) {revert incorrectCurrency();}
        saleCurrency[id]=currency; salePrices[id]=price; saleAddresses[id]=msg.sender;
    }
    function cancelSale (uint256 id) external {
        if (balanceOf(msg.sender, id) == 0) {revert NFTnotOwned();}
        saleCurrency[id]=0; salePrices[id]=0; saleAddresses[id]=address(0);
    }
    function checkSaleTotalETHprice (uint256 id) external view returns (uint256) {
        uint256 commission = 3*salePrices[id]/400;                      // calculation of 0.75% commission to the project of the developer of this contract
        unchecked {                                                     // 3*salePrices[id] is the largest potential number, if that doesn't overflow, no other calculation will and those can be unchecked
        uint256 royalty = salePrices[id]/20;                            // calculation of 5% royalty
        if (previousOwners[id] != address(0)) {return salePrices[id]+royalty+royalty+commission;} else {return salePrices[id]+royalty+commission;}
    }}
    function checkSaleTotalEQTprice (uint256 id) external view returns (uint256) {
        uint256 EQTamount = (10**18 * salePrices[id]) / EQT.getEQTprice();
        unchecked {                                                     // 10**18 * salePrices[id] is the highest number that can theoretically appear, if that doesn't overflow, no other calculation will and those can be unchecked
        uint256 royalty = EQTamount/20;                                 // calculation of 5% royalty
        if (previousOwners[id] != address(0)) {return EQTamount+royalty+royalty;} else {return EQTamount+royalty;}
    }}
    function buyNFT (uint256 id) external payable {
        if (salePrices[id] == 0) {revert NFTnotOnSale();}
        if (saleCurrency[id] == 2) {revert incorrectCurrency();}
        uint256 commission = 3*salePrices[id]/400;                      // calculation of 0.75% commission to the project of the developer of this contract
        unchecked {                                                     // 3*salePrices[id] is the largest potential number, if that doesn't overflow, no other calculation will and those can be unchecked
            uint256 royalty = salePrices[id]/20;                        // calculation of 5% royalty
            if (previousOwners[id] != address(0)) {
                if (msg.value != (salePrices[id]+royalty+royalty+commission)) {revert incorrectAmountOfETH();}
                payable(previousOwners[id]).transfer(royalty);          // payment of the royalty to the previous NFT owner, if such address exists
            } else {
                if (msg.value != (salePrices[id]+royalty+commission)) {revert incorrectAmountOfETH();}
            }
            payable(_owner).transfer(royalty);                          // payment of the royalty to the artist
        }
        payable(0x59dD9131b950DC5335e348A842D23cE7286bC248).transfer(commission);   // payment of the commission
        payable(saleAddresses[id]).transfer(salePrices[id]);            // payment to the owner of NFT
        previousOwners[id] = saleAddresses[id];
        _safeTransferFrom(saleAddresses[id], msg.sender, id, 1, "");    // transfer of the NFT
        saleCurrency[id]=0; salePrices[id]=0; saleAddresses[id]=address(0);
    } 
    function buyNFTwithEQT (uint256 id) external {
        if (salePrices[id] == 0) {revert NFTnotOnSale();}
        if (saleCurrency[id] == 1) {revert incorrectCurrency();}
        uint256 EQTamount = (10**18 * salePrices[id]) / EQT.getEQTprice();
        unchecked {                                                     // 10**18 * salePrices[id] is the highest number that can theoretically appear, if that doesn't overflow, no other calculation will and those can be unchecked
            uint256 royalty = EQTamount/20;                             // calculation of 5% royalty
            if (previousOwners[id] != address(0)) {EQT.transferExactAmount(msg.sender, previousOwners[id], royalty);}          // payment of the royalty to the previous NFT owner, if such address exists
            EQT.transferExactAmount(msg.sender, _owner, royalty);       // payment of the royalty to the artist
        }
        EQT.transferExactAmount(msg.sender, saleAddresses[id], EQTamount);     // payment to the owner of NFT
        previousOwners[id] = saleAddresses[id];
        _safeTransferFrom(saleAddresses[id], msg.sender, id, 1, "");    // transfer of the NFT
        saleCurrency[id]=0; salePrices[id]=0; saleAddresses[id]=address(0);
    }

// necessary overrides
    function uri(uint256 _tokenid) override public view returns (string memory) {
        return string(abi.encodePacked(baseURI, Strings.toString(_tokenid),".json"));
    }
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, ERC2981) returns (bool) {
        return ERC1155.supportsInterface(interfaceId) || ERC2981.supportsInterface(interfaceId);
    }
    function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, amount, data);
        if (salePrices[tokenId] > 0) {saleCurrency[tokenId]=0; salePrices[tokenId]=0; saleAddresses[tokenId]=address(0);}
    }
    function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public virtual override onlyAllowedOperator(from) {
        super.safeBatchTransferFrom(from, to, ids, amounts, data);
        for (uint256 i = 0; i <= ids.length-1;) {
            if (salePrices[ids[i]] > 0) {saleCurrency[ids[i]]=0; salePrices[ids[i]]=0; saleAddresses[ids[i]]=address(0);}
            unchecked{i++;}
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NFTnotOnSale","type":"error"},{"inputs":[],"name":"NFTnotOwned","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"alreadyMinted","type":"error"},{"inputs":[],"name":"incorrectAmountOfETH","type":"error"},{"inputs":[],"name":"incorrectCurrency","type":"error"},{"inputs":[],"name":"incorrectSet","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":"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":[],"name":"EQT","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"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":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"buyNFT","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"buyNFTwithEQT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"cancelSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"checkSaleTotalEQTprice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"checkSaleTotalETHprice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"currency","type":"uint256"}],"name":"createSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"confirm","type":"bool"}],"name":"freezeMetadata","outputs":[],"stateMutability":"nonpayable","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":[],"name":"metadataFrozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"nftSet","type":"uint256"},{"internalType":"address","name":"nftSetOwner","type":"address"}],"name":"mintNFTset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintedSets","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","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":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"saleCurrency","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"salePrices","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"_uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_addr","type":"address"}],"name":"setEQTaddress","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":[{"internalType":"uint256","name":"_tokenid","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

70314:8871:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53306:230;;;;;;;;;;-1:-1:-1;53306:230:0;;;;;:::i;:::-;;:::i;:::-;;;616:25:1;;;604:2;589:18;53306:230:0;;;;;;;;73517:698;;;;;;;;;;-1:-1:-1;73517:698:0;;;;;:::i;:::-;;:::i;77966:215::-;;;;;;;;;;-1:-1:-1;77966:215:0;;;;;:::i;:::-;;:::i;:::-;;;1388:14:1;;1381:22;1363:41;;1351:2;1336:18;77966:215:0;1223:187:1;70527:75:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;71945:93::-;;;;;;;;;;-1:-1:-1;71945:93:0;;;;;:::i;:::-;;:::i;:::-;;74221:612;;;;;;;;;;-1:-1:-1;74221:612:0;;;;;:::i;:::-;;:::i;77789:171::-;;;;;;;;;;-1:-1:-1;77789:171:0;;;;;:::i;:::-;;:::i;41315:438::-;;;;;;;;;;-1:-1:-1;41315:438:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2883:32:1;;;2865:51;;2947:2;2932:18;;2925:34;;;;2838:18;41315:438:0;2691:274:1;78718:464:0;;;;;;;;;;-1:-1:-1;78718:464:0;;;;;:::i;:::-;;:::i;71079:45::-;;;;;;;;;;-1:-1:-1;71079:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;72149:236;;;;;;;;;;;;;:::i;7900:143::-;;;;;;;;;;;;228:42;7900:143;;;;;-1:-1:-1;;;;;6242:32:1;;;6224:51;;6212:2;6197:18;7900:143:0;6047:234:1;53702:524:0;;;;;;;;;;-1:-1:-1;53702:524:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;74839:1662::-;;;;;;:::i;:::-;;:::i;72044:99::-;;;;;;;;;;-1:-1:-1;72044:99:0;;;;;:::i;:::-;;:::i;70998:41::-;;;;;;;;;;-1:-1:-1;70998:41:0;;;;;:::i;:::-;;:::i;73012:297::-;;;;;;;;;;-1:-1:-1;73012:297:0;;;;;:::i;:::-;;:::i;78187:176::-;;;;;;;;;;-1:-1:-1;78187:176:0;;;;;:::i;:::-;;:::i;72493:513::-;;;;;;;;;;-1:-1:-1;72493:513:0;;;;;:::i;:::-;;:::i;73315:196::-;;;;;;;;;;-1:-1:-1;73315:196:0;;;;;:::i;:::-;;:::i;70746:70::-;;;;;;;;;;-1:-1:-1;70746:70:0;;;;-1:-1:-1;;;;;70746:70:0;;;72391:96;;;;;;;;;;-1:-1:-1;72391:96:0;;;;;:::i;:::-;;:::i;54526:168::-;;;;;;;;;;-1:-1:-1;54526:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;54649:27:0;;;54625:4;54649:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;54526:168;76508:1249;;;;;;;;;;-1:-1:-1;76508:1249:0;;;;;:::i;:::-;;:::i;78369:343::-;;;;;;;;;;-1:-1:-1;78369:343:0;;;;;:::i;:::-;;:::i;71185:47::-;;;;;;;;;;-1:-1:-1;71185:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;71046:26;;;;;;;;;;-1:-1:-1;71046:26:0;;;;;;;;53306:230;53392:7;-1:-1:-1;;;;;53420:21:0;;53412:76;;;;-1:-1:-1;;;53412:76:0;;11683:2:1;53412:76:0;;;11665:21:1;11722:2;11702:18;;;11695:30;11761:34;11741:18;;;11734:62;-1:-1:-1;;;11812:18:1;;;11805:40;11862:19;;53412:76:0;;;;;;;;;-1:-1:-1;53506:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;53506:22:0;;;;;;;;;;53306:230;;;;;:::o;73517:698::-;73585:7;73628:14;;;:10;:14;;;;;;73585:7;;73643:3;;73626:16;;:1;:16;:::i;:::-;:20;;;;:::i;:::-;73967:15;73985:14;;;:10;:14;;;;;;;;;74073;:18;;;;;;;73605:41;;-1:-1:-1;74000:2:0;73985:17;;;-1:-1:-1;;;;;74073:18:0;:32;74069:138;;74115:14;;;;:10;:14;;;;;;;:22;;:30;;;:41;;;;73517:698;-1:-1:-1;73517:698:0:o;74069:138::-;74172:14;;;;:10;:14;;;;;;;:22;;;:33;;;;73517:698;-1:-1:-1;73517:698:0:o;77966:215::-;78069:4;78093:38;78119:11;78093:25;:38::i;:::-;:80;;;;78135:38;78161:11;78135:25;:38::i;70527:75::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;71945:93::-;70459:6;;-1:-1:-1;;;;;70459:6:0;70469:10;70459:20;70451:65;;;;-1:-1:-1;;;70451:65:0;;;;;;;:::i;:::-;72007:14:::1;::::0;::::1;;72002:35;;72024:3;:11:::0;;-1:-1:-1;;;;;;72024:11:0::1;-1:-1:-1::0;;;;;72024:11:0;::::1;;::::0;;72002:35:::1;71945:93:::0;:::o;74221:612::-;74289:7;74309:17;74357:3;;;;;;;;;-1:-1:-1;;;;;74357:3:0;-1:-1:-1;;;;;74357:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74339:14;;;;:10;:14;;;;;;74330:23;;:6;:23;:::i;:::-;74329:45;;;;:::i;:::-;74617:15;74723:18;;;:14;:18;;;;;;74309:65;;-1:-1:-1;74645:2:0;74635:12;;;-1:-1:-1;;;;;74723:18:0;:32;74719:106;;74765:17;;;:25;;74221:612;-1:-1:-1;;74221:612:0:o;74719:106::-;74806:17;;74221:612;-1:-1:-1;;74221:612:0:o;77789:171::-;77850:13;77907:7;77916:26;77933:8;77916:16;:26::i;:::-;77890:61;;;;;;;;;:::i;:::-;;;;;;;;;;;;;77876:76;;77789:171;;;:::o;41315:438::-;41410:7;41468:26;;;:17;:26;;;;;;;;41439:55;;;;;;;;;-1:-1:-1;;;;;41439:55:0;;;;;-1:-1:-1;;;41439:55:0;;;-1:-1:-1;;;;;41439:55:0;;;;;;;;41410:7;;41507:92;;-1:-1:-1;41558:29:0;;;;;;;;;41568:19;41558:29;-1:-1:-1;;;;;41558:29:0;;;;-1:-1:-1;;;41558:29:0;;-1:-1:-1;;;;;41558:29:0;;;;;41507:92;41648:23;;;;41611:21;;42119:5;;41636:35;;-1:-1:-1;;;;;41636:35:0;:9;:35;:::i;:::-;41635:57;;;;:::i;:::-;41713:16;;;;;-1:-1:-1;41315:438:0;;-1:-1:-1;;;;41315:438:0:o;78718:464::-;78886:4;-1:-1:-1;;;;;9408:18:0;;9416:10;9408:18;9404:83;;9443:32;9464:10;9443:20;:32::i;:::-;78903:57:::1;78931:4;78937:2;78941:3;78946:7;78955:4;78903:27;:57::i;:::-;78976:9;78971:204;79007:1;78996:3;:10;:12;;;;:::i;:::-;78991:1;:17;78971:204;;79051:1;79030:10;:18;79041:3;79045:1;79041:6;;;;;;;;:::i;:::-;;;;;;;79030:18;;;;;;;;;;;;:22;79026:109;;;79076:1;79055:12;:20;79068:3;79072:1;79068:6;;;;;;;;:::i;:::-;;;;;;;79055:20;;;;;;;;;;;:22;;;;79098:1;79079:10;:18;79090:3;79094:1;79090:6;;;;;;;;:::i;:::-;;;;;;;79079:18;;;;;;;;;;;:20;;;;79131:1;79101:13;:21;79115:3;79119:1;79115:6;;;;;;;;:::i;:::-;;;;;;;79101:21;;;;;;;;;;;;:32;;;;;-1:-1:-1::0;;;;;79101:32:0::1;;;;;-1:-1:-1::0;;;;;79101:32:0::1;;;;;;79026:109;79159:3;;78971:204;;;;78718:464:::0;;;;;;:::o;72149:236::-;70459:6;;-1:-1:-1;;;;;70459:6:0;70469:10;70459:20;70451:65;;;;-1:-1:-1;;;70451:65:0;;;;;;;:::i;:::-;72229:1:::1;72204:21;:26;72200:82;;72241:6;::::0;72233:47:::1;::::0;-1:-1:-1;;;;;72241:6:0;;::::1;::::0;72258:21:::1;72233:47:::0;::::1;;;::::0;72241:6:::1;72233:47:::0;72241:6;72233:47;72258:21;72241:6;72233:47;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;72200:82;72296:3;::::0;:28:::1;::::0;-1:-1:-1;;;72296:28:0;;72318:4:::1;72296:28;::::0;::::1;6224:51:1::0;72328:1:0::1;::::0;-1:-1:-1;;;;;72296:3:0::1;::::0;:13:::1;::::0;6197:18:1;;72296:28:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;72292:92;;72332:3;::::0;72345:6:::1;::::0;72353:28:::1;::::0;-1:-1:-1;;;72353:28:0;;72375:4:::1;72353:28;::::0;::::1;6224:51:1::0;-1:-1:-1;;;;;72332:3:0;;::::1;::::0;:12:::1;::::0;72345:6:::1;::::0;72332:3;;72353:13:::1;::::0;6197:18:1;;72353:28:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72332:50;::::0;-1:-1:-1;;;;;;72332:50:0::1;::::0;;;;;;-1:-1:-1;;;;;2883:32:1;;;72332:50:0::1;::::0;::::1;2865:51:1::0;2932:18;;;2925:34;2838:18;;72332:50:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;72292:92::-;72149:236::o:0;53702:524::-;53858:16;53919:3;:10;53900:8;:15;:29;53892:83;;;;-1:-1:-1;;;53892:83:0;;15729:2:1;53892:83:0;;;15711:21:1;15768:2;15748:18;;;15741:30;15807:34;15787:18;;;15780:62;-1:-1:-1;;;15858:18:1;;;15851:39;15907:19;;53892:83:0;15527:405:1;53892:83:0;53988:30;54035:8;:15;54021:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54021:30:0;;53988:63;;54069:9;54064:122;54088:8;:15;54084:1;:19;54064:122;;;54144:30;54154:8;54163:1;54154:11;;;;;;;;:::i;:::-;;;;;;;54167:3;54171:1;54167:6;;;;;;;;:::i;:::-;;;;;;;54144:9;:30::i;:::-;54125:13;54139:1;54125:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;54105:3;;;:::i;:::-;;;54064:122;;;-1:-1:-1;54205:13:0;53702:524;-1:-1:-1;;;53702:524:0:o;74839:1662::-;74900:14;;;;:10;:14;;;;;;:19;;74896:49;;74929:14;;-1:-1:-1;;;74929:14:0;;;;;;;;;;;74896:49;74959:16;;;;:12;:16;;;;;;74979:1;74959:21;74955:56;;74990:19;;-1:-1:-1;;;74990:19:0;;;;;;;;;;;74955:56;75021:18;75044:14;;;:10;:14;;;;;;75059:3;;75042:16;;:1;:16;:::i;:::-;:20;;;;:::i;:::-;75387:15;75405:14;;;:10;:14;;;;;;;;;75493;:18;;;;;;;75021:41;;-1:-1:-1;75420:2:0;75405:17;;;-1:-1:-1;;;;;75493:18:0;:32;75489:441;;75564:14;;;;:10;:14;;;;;;:22;;:30;;:41;;75550:9;:56;75546:94;;75616:22;;-1:-1:-1;;;75616:22:0;;;;;;;;;;;75546:94;75666:18;;;;:14;:18;;;;;;;75658:45;;-1:-1:-1;;;;;75666:18:0;;;;75658:45;;;;;75695:7;;75658:45;75666:18;75658:45;75695:7;75666:18;75658:45;;;;;;;;;;;;;;;;;;;;;75489:441;;;75847:14;;;;:10;:14;;;;;;:22;;:33;;75833:9;:48;75829:86;;75891:22;;-1:-1:-1;;;75891:22:0;;;;;;;;;;;75829:86;75952:6;;75944:33;;-1:-1:-1;;;;;75952:6:0;;;;75944:33;;;;;75969:7;;75952:6;75944:33;75952:6;75944:33;75969:7;75952:6;75944:33;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;76064:72:0;;76072:42;;76064:72;;;;;76125:10;;76064:72;;;;76125:10;76072:42;76064:72;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76186:17:0;;;;:13;:17;;;;;;;;;76214:10;:14;;;;;;;76178:51;;-1:-1:-1;;;;;76186:17:0;;;;76178:51;;;;;;;76186:17;76178:51;76214:14;76186:17;76178:51;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76303:17:0;;;;:13;:17;;;;;;;;;;76282:14;:18;;;;;:38;;-1:-1:-1;;;;;;76282:38:0;-1:-1:-1;;;;;76303:17:0;;;76282:38;;;76349:17;;;;76331:59;;;;;;;;;;;;;76349:17;;;;76368:10;;76317:2;;76303:17;;76331;:59::i;:::-;-1:-1:-1;76444:1:0;76427:16;;;:12;:16;;;;;;;;:18;;;76447:10;:14;;;;;:16;;;76465:13;:17;;;;;:28;;-1:-1:-1;;;;;;76465:28:0;;;74839:1662::o;72044:99::-;70459:6;;-1:-1:-1;;;;;70459:6:0;70469:10;70459:20;70451:65;;;;-1:-1:-1;;;70451:65:0;;;;;;;:::i;:::-;72109:14:::1;::::0;::::1;;72104:38;;72126:7;:14;72136:4:::0;72126:7;:14:::1;:::i;:::-;;72044:99:::0;:::o;70998:41::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;73012:297::-;73101:25;73111:10;73123:2;73101:9;:25::i;:::-;73130:1;73101:30;73097:59;;73141:13;;-1:-1:-1;;;73141:13:0;;;;;;;;;;;73097:59;73182:1;73170:8;:13;73166:48;;73193:19;;-1:-1:-1;;;73193:19:0;;;;;;;;;;;73166:48;73224:16;;;;:12;:16;;;;;;;;:25;;;;73251:10;:14;;;;;:20;;;;73273:13;:17;;;;;:28;;-1:-1:-1;;;;;;73273:28:0;73291:10;73273:28;;;73012:297::o;78187:176::-;78291:8;9682:30;9703:8;9682:20;:30::i;:::-;78312:43:::1;78336:8;78346;78312:23;:43::i;:::-;78187:176:::0;;;:::o;72493:513::-;70459:6;;-1:-1:-1;;;;;70459:6:0;70469:10;70459:20;70451:65;;;;-1:-1:-1;;;70451:65:0;;;;;;;:::i;:::-;72585:11;;;:27:::1;;;72610:2;72600:6;:12;;72585:27;72581:57;;;72622:14;;-1:-1:-1::0;;;72622:14:0::1;;;;;;;;;;;72581:57;72652:10;72663:6;72652:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;72648:49;;;72680:15;;-1:-1:-1::0;;;72680:15:0::1;;;;;;;;;;;72648:49;72730:17;::::0;;72744:2:::1;72730:17:::0;;;;;::::1;::::0;;;72707:20:::1;::::0;72730:17:::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;72785:17:0::1;::::0;;72799:2:::1;72785:17:::0;;;;;::::1;::::0;;;72707:40;;-1:-1:-1;72758:24:0::1;::::0;72785:17;-1:-1:-1;72785:17:0::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;72785:17:0::1;72758:44;;72818:9;72813:98;72838:2;72833:1;:7;72813:98;;72857:1;72844:7;72852:1;72844:10;;;;;;;;:::i;:::-;;;;;;:14;;;::::0;::::1;72900:1;72895:2;:6;72885;72880:2;:11;:22;72870:3;72874:1;72870:6;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;:33;72905:3:::1;;72813:98;;;;72921:41;72932:11;72945:3;72950:7;72921:41;;;;;;;;;;;::::0;:10:::1;:41::i;:::-;72994:4;72973:10;72984:6;72973:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:25;;;;;;;;;;;;;;;;;;72570:436;;72493:513:::0;;:::o;73315:196::-;73372:25;73382:10;73394:2;73372:9;:25::i;:::-;73401:1;73372:30;73368:59;;73412:13;;-1:-1:-1;;;73412:13:0;;;;;;;;;;;73368:59;73454:1;73437:16;;;:12;:16;;;;;;;;:18;;;73457:10;:14;;;;;:16;;;73475:13;:17;;;;;:28;;-1:-1:-1;;;;;;73475:28:0;;;73315:196::o;72391:96::-;70459:6;;-1:-1:-1;;;;;70459:6:0;70469:10;70459:20;70451:65;;;;-1:-1:-1;;;70451:65:0;;;;;;;:::i;:::-;72453:7:::1;72449:37;;;72463:14;:21:::0;;-1:-1:-1;;72463:21:0::1;72480:4;72463:21;::::0;;72391:96;:::o;76508:1249::-;76568:14;;;;:10;:14;;;;;;:19;;76564:49;;76597:14;;-1:-1:-1;;;76597:14:0;;;;;;;;;;;76564:49;76627:16;;;;:12;:16;;;;;;76647:1;76627:21;76623:56;;76658:19;;-1:-1:-1;;;76658:19:0;;;;;;;;;;;76623:56;76737:3;;:17;;;-1:-1:-1;;;76737:17:0;;;;76689;;-1:-1:-1;;;;;76737:3:0;;:15;;:17;;;;;;;;;;;;;;:3;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76719:14;;;;:10;:14;;;;;;76710:23;;:6;:23;:::i;:::-;76709:45;;;;:::i;:::-;77001:15;77107:18;;;:14;:18;;;;;;76689:65;;-1:-1:-1;77029:2:0;77019:12;;;-1:-1:-1;;;;;77107:18:0;:32;77103:105;;77142:3;;;77178:18;;;:14;:18;;;;;;;;77142:64;;-1:-1:-1;;;77142:64:0;;77166:10;77142:64;;;18395:34:1;-1:-1:-1;;;;;77178:18:0;;;18445::1;;;18438:43;18497:18;;;18490:34;;;77142:3:0;;;:23;;18330:18:1;;77142:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77103:105;77307:3;;77343:6;;77307:52;;-1:-1:-1;;;77307:52:0;;77331:10;77307:52;;;18395:34:1;-1:-1:-1;;;;;77343:6:0;;;18445:18:1;;;18438:43;18497:18;;;18490:34;;;77307:3:0;;;:23;;18330:18:1;;77307:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;77427:3:0;;;77463:17;;;:13;:17;;;;;;;;77427:65;;-1:-1:-1;;;77427:65:0;;77451:10;77427:65;;;18395:34:1;-1:-1:-1;;;;;77463:17:0;;;18445:18:1;;;18438:43;18497:18;;;18490:34;;;77427:3:0;;;:23;;18330:18:1;;77427:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;78369:343::-;78509:4;-1:-1:-1;;;;;9408:18:0;;9416:10;9408:18;9404:83;;9443:32;9464:10;9443:20;:32::i;:::-;78526:55:::1;78549:4;78555:2;78559:7;78568:6;78576:4;78526:22;:55::i;:::-;78618:1;78596:19:::0;;;:10:::1;:19;::::0;;;;;:23;78592:113:::1;;78644:1;78622:21:::0;;;:12:::1;:21;::::0;;;;;;;:23;;;78647:10:::1;:19:::0;;;;;:21;;;78670:13:::1;:22:::0;;;;;:33;;-1:-1:-1;;;;;;78670:33:0::1;::::0;;78592:113:::1;78369:343:::0;;;;;;:::o;28622:326::-;-1:-1:-1;;;;;28917:19:0;;:23;;;28622:326::o;52329:310::-;52431:4;-1:-1:-1;;;;;;52468:41:0;;-1:-1:-1;;;52468:41:0;;:110;;-1:-1:-1;;;;;;;52526:52:0;;-1:-1:-1;;;52526:52:0;52468:110;:163;;;-1:-1:-1;;;;;;;;;;39604:40:0;;;52595:36;39495:157;41045:215;41147:4;-1:-1:-1;;;;;;41171:41:0;;-1:-1:-1;;;41171:41:0;;:81;;;41216:36;41240:11;41216:23;:36::i;24602:716::-;24658:13;24709:14;24726:17;24737:5;24726:10;:17::i;:::-;24746:1;24726:21;24709:38;;24762:20;24796:6;24785:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24785:18:0;-1:-1:-1;24762:41:0;-1:-1:-1;24927:28:0;;;24943:2;24927:28;24984:288;-1:-1:-1;;25016:5:0;-1:-1:-1;;;25153:2:0;25142:14;;25137:30;25016:5;25124:44;25214:2;25205:11;;;-1:-1:-1;25235:21:0;24984:288;25235:21;-1:-1:-1;25293:6:0;24602:716;-1:-1:-1;;;24602:716:0:o;9825:647::-;228:42;10016:45;:49;10012:453;;10315:67;;-1:-1:-1;;;10315:67:0;;10366:4;10315:67;;;18747:34:1;-1:-1:-1;;;;;18817:15:1;;18797:18;;;18790:43;228:42:0;;10315;;18682:18:1;;10315:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10310:144;;10410:28;;-1:-1:-1;;;10410:28:0;;-1:-1:-1;;;;;6242:32:1;;10410:28:0;;;6224:51:1;6197:18;;10410:28:0;6047:234:1;55249:438:0;-1:-1:-1;;;;;55482:20:0;;27255:10;55482:20;;:60;;-1:-1:-1;55506:36:0;55523:4;27255:10;54526:168;:::i;55506:36::-;55460:156;;;;-1:-1:-1;;;55460:156:0;;;;;;;:::i;:::-;55627:52;55650:4;55656:2;55660:3;55665:7;55674:4;55627:22;:52::i;:::-;55249:438;;;;;:::o;56151:974::-;-1:-1:-1;;;;;56339:16:0;;56331:66;;;;-1:-1:-1;;;56331:66:0;;;;;;;:::i;:::-;27255:10;56410:16;56475:21;56493:2;56475:17;:21::i;:::-;56452:44;;56507:24;56534:25;56552:6;56534:17;:25::i;:::-;56507:52;;56645:19;56667:13;;;;;;;;;;;-1:-1:-1;;;;;56667:19:0;;;;;;;;;;56705:21;;;;56697:76;;;;-1:-1:-1;;;56697:76:0;;;;;;;:::i;:::-;56809:9;:13;;;;;;;;;;;-1:-1:-1;;;;;56809:19:0;;;;;;;;;;56831:20;;;56809:42;;56873:17;;;;;;;:27;;56831:20;;56809:9;56873:27;;56831:20;;56873:27;:::i;:::-;;;;-1:-1:-1;;56918:46:0;;;20380:25:1;;;20436:2;20421:18;;20414:34;;;-1:-1:-1;;;;;56918:46:0;;;;;;;;;;;;;;20353:18:1;56918:46:0;;;;;;;57049:68;57080:8;57090:4;57096:2;57100;57104:6;57112:4;57049:30;:68::i;:::-;56320:805;;;;56151:974;;;;;:::o;54299:155::-;54394:52;27255:10;54427:8;54437;54394:18;:52::i;61079:813::-;-1:-1:-1;;;;;61257:16:0;;61249:62;;;;-1:-1:-1;;;61249:62:0;;20661:2:1;61249:62:0;;;20643:21:1;20700:2;20680:18;;;20673:30;20739:34;20719:18;;;20712:62;-1:-1:-1;;;20790:18:1;;;20783:31;20831:19;;61249:62:0;20459:397:1;61249:62:0;61344:7;:14;61330:3;:10;:28;61322:81;;;;-1:-1:-1;;;61322:81:0;;;;;;;:::i;:::-;27255:10;61416:16;61539:103;61563:3;:10;61559:1;:14;61539:103;;;61620:7;61628:1;61620:10;;;;;;;;:::i;:::-;;;;;;;61595:9;:17;61605:3;61609:1;61605:6;;;;;;;;:::i;:::-;;;;;;;61595:17;;;;;;;;;;;:21;61613:2;-1:-1:-1;;;;;61595:21:0;-1:-1:-1;;;;;61595:21:0;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;61575:3:0;;-1:-1:-1;61575:3:0;;;:::i;:::-;;;;61539:103;;;;61695:2;-1:-1:-1;;;;;61659:53:0;61691:1;-1:-1:-1;;;;;61659:53:0;61673:8;-1:-1:-1;;;;;61659:53:0;;61699:3;61704:7;61659:53;;;;;;;:::i;:::-;;;;;;;;61803:81;61839:8;61857:1;61861:2;61865:3;61870:7;61879:4;61803:35;:81::i;54766:406::-;-1:-1:-1;;;;;54974:20:0;;27255:10;54974:20;;:60;;-1:-1:-1;54998:36:0;55015:4;27255:10;54526:168;:::i;54998:36::-;54952:156;;;;-1:-1:-1;;;54952:156:0;;;;;;;:::i;:::-;55119:45;55137:4;55143:2;55147;55151:6;55159:4;55119:17;:45::i;21468:922::-;21521:7;;-1:-1:-1;;;21599:15:0;;21595:102;;-1:-1:-1;;;21635:15:0;;;-1:-1:-1;21679:2:0;21669:12;21595:102;21724:6;21715:5;:15;21711:102;;21760:6;21751:15;;;-1:-1:-1;21795:2:0;21785:12;21711:102;21840:6;21831:5;:15;21827:102;;21876:6;21867:15;;;-1:-1:-1;21911:2:0;21901:12;21827:102;21956:5;21947;:14;21943:99;;21991:5;21982:14;;;-1:-1:-1;22025:1:0;22015:11;21943:99;22069:5;22060;:14;22056:99;;22104:5;22095:14;;;-1:-1:-1;22138:1:0;22128:11;22056:99;22182:5;22173;:14;22169:99;;22217:5;22208:14;;;-1:-1:-1;22251:1:0;22241:11;22169:99;22295:5;22286;:14;22282:66;;22331:1;22321:11;22376:6;21468:922;-1:-1:-1;;21468:922:0:o;57483:1146::-;57710:7;:14;57696:3;:10;:28;57688:81;;;;-1:-1:-1;;;57688:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;57788:16:0;;57780:66;;;;-1:-1:-1;;;57780:66:0;;;;;;;:::i;:::-;27255:10;57859:16;57976:421;58000:3;:10;57996:1;:14;57976:421;;;58032:10;58045:3;58049:1;58045:6;;;;;;;;:::i;:::-;;;;;;;58032:19;;58066:14;58083:7;58091:1;58083:10;;;;;;;;:::i;:::-;;;;;;;;;;;;58110:19;58132:13;;;;;;;;;;-1:-1:-1;;;;;58132:19:0;;;;;;;;;;;;58083:10;;-1:-1:-1;58174:21:0;;;;58166:76;;;;-1:-1:-1;;;58166:76:0;;;;;;;:::i;:::-;58286:9;:13;;;;;;;;;;;-1:-1:-1;;;;;58286:19:0;;;;;;;;;;58308:20;;;58286:42;;58358:17;;;;;;;:27;;58308:20;;58286:9;58358:27;;58308:20;;58358:27;:::i;:::-;;;;;;;;58017:380;;;58012:3;;;;:::i;:::-;;;57976:421;;;;58444:2;-1:-1:-1;;;;;58414:47:0;58438:4;-1:-1:-1;;;;;58414:47:0;58428:8;-1:-1:-1;;;;;58414:47:0;;58448:3;58453:7;58414:47;;;;;;;:::i;:::-;;;;;;;;58546:75;58582:8;58592:4;58598:2;58602:3;58607:7;58616:4;58546:35;:75::i;68626:198::-;68746:16;;;68760:1;68746:16;;;;;;;;;68692;;68721:22;;68746:16;;;;;;;;;;;;-1:-1:-1;68746:16:0;68721:41;;68784:7;68773:5;68779:1;68773:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;68811:5;68626:198;-1:-1:-1;;68626:198:0:o;67053:744::-;-1:-1:-1;;;;;67268:13:0;;28917:19;:23;67264:526;;67304:72;;-1:-1:-1;;;67304:72:0;;-1:-1:-1;;;;;67304:38:0;;;;;:72;;67343:8;;67353:4;;67359:2;;67363:6;;67371:4;;67304:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67304:72:0;;;;;;;;-1:-1:-1;;67304:72:0;;;;;;;;;;;;:::i;:::-;;;67300:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;67652:6;67645:14;;-1:-1:-1;;;67645:14:0;;;;;;;;:::i;67300:479::-;;;67701:62;;-1:-1:-1;;;67701:62:0;;23622:2:1;67701:62:0;;;23604:21:1;23661:2;23641:18;;;23634:30;23700:34;23680:18;;;23673:62;-1:-1:-1;;;23751:18:1;;;23744:50;23811:19;;67701:62:0;23420:416:1;67300:479:0;-1:-1:-1;;;;;;67426:55:0;;-1:-1:-1;;;67426:55:0;67422:154;;67506:50;;-1:-1:-1;;;67506:50:0;;;;;;;:::i;64360:331::-;64515:8;-1:-1:-1;;;;;64506:17:0;:5;-1:-1:-1;;;;;64506:17:0;;64498:71;;;;-1:-1:-1;;;64498:71:0;;24452:2:1;64498:71:0;;;24434:21:1;24491:2;24471:18;;;24464:30;24530:34;24510:18;;;24503:62;-1:-1:-1;;;24581:18:1;;;24574:39;24630:19;;64498:71:0;24250:405:1;64498:71:0;-1:-1:-1;;;;;64580:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;64580:46:0;;;;;;;;;;64642:41;;1363::1;;;64642::0;;1336:18:1;64642:41:0;;;;;;;64360:331;;;:::o;67805:813::-;-1:-1:-1;;;;;68045:13:0;;28917:19;:23;68041:570;;68081:79;;-1:-1:-1;;;68081:79:0;;-1:-1:-1;;;;;68081:43:0;;;;;:79;;68125:8;;68135:4;;68141:3;;68146:7;;68155:4;;68081:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68081:79:0;;;;;;;;-1:-1:-1;;68081:79:0;;;;;;;;;;;;:::i;:::-;;;68077:523;;;;:::i;:::-;-1:-1:-1;;;;;;68242:60:0;;-1:-1:-1;;;68242:60:0;68238:159;;68327:50;;-1:-1:-1;;;68327:50:0;;;;;;;:::i;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:315;218:6;226;279:2;267:9;258:7;254:23;250:32;247:52;;;295:1;292;285:12;247:52;334:9;321:23;353:31;378:5;353:31;:::i;:::-;403:5;455:2;440:18;;;;427:32;;-1:-1:-1;;;150:315:1:o;652:180::-;711:6;764:2;752:9;743:7;739:23;735:32;732:52;;;780:1;777;770:12;732:52;-1:-1:-1;803:23:1;;652:180;-1:-1:-1;652:180:1:o;837:131::-;-1:-1:-1;;;;;;911:32:1;;901:43;;891:71;;958:1;955;948:12;973:245;1031:6;1084:2;1072:9;1063:7;1059:23;1055:32;1052:52;;;1100:1;1097;1090:12;1052:52;1139:9;1126:23;1158:30;1182:5;1158:30;:::i;:::-;1207:5;973:245;-1:-1:-1;;;973:245:1:o;1415:250::-;1500:1;1510:113;1524:6;1521:1;1518:13;1510:113;;;1600:11;;;1594:18;1581:11;;;1574:39;1546:2;1539:10;1510:113;;;-1:-1:-1;;1657:1:1;1639:16;;1632:27;1415:250::o;1670:271::-;1712:3;1750:5;1744:12;1777:6;1772:3;1765:19;1793:76;1862:6;1855:4;1850:3;1846:14;1839:4;1832:5;1828:16;1793:76;:::i;:::-;1923:2;1902:15;-1:-1:-1;;1898:29:1;1889:39;;;;1930:4;1885:50;;1670:271;-1:-1:-1;;1670:271:1:o;1946:220::-;2095:2;2084:9;2077:21;2058:4;2115:45;2156:2;2145:9;2141:18;2133:6;2115:45;:::i;2171:262::-;2245:6;2298:2;2286:9;2277:7;2273:23;2269:32;2266:52;;;2314:1;2311;2304:12;2266:52;2353:9;2340:23;2372:31;2397:5;2372:31;:::i;2438:248::-;2506:6;2514;2567:2;2555:9;2546:7;2542:23;2538:32;2535:52;;;2583:1;2580;2573:12;2535:52;-1:-1:-1;;2606:23:1;;;2676:2;2661:18;;;2648:32;;-1:-1:-1;2438:248:1:o;2970:127::-;3031:10;3026:3;3022:20;3019:1;3012:31;3062:4;3059:1;3052:15;3086:4;3083:1;3076:15;3102:249;3212:2;3193:13;;-1:-1:-1;;3189:27:1;3177:40;;3247:18;3232:34;;3268:22;;;3229:62;3226:88;;;3294:18;;:::i;:::-;3330:2;3323:22;-1:-1:-1;;3102:249:1:o;3356:183::-;3416:4;3449:18;3441:6;3438:30;3435:56;;;3471:18;;:::i;:::-;-1:-1:-1;3516:1:1;3512:14;3528:4;3508:25;;3356:183::o;3544:724::-;3598:5;3651:3;3644:4;3636:6;3632:17;3628:27;3618:55;;3669:1;3666;3659:12;3618:55;3705:6;3692:20;3731:4;3754:43;3794:2;3754:43;:::i;:::-;3826:2;3820:9;3838:31;3866:2;3858:6;3838:31;:::i;:::-;3904:18;;;3996:1;3992:10;;;;3980:23;;3976:32;;;3938:15;;;;-1:-1:-1;4020:15:1;;;4017:35;;;4048:1;4045;4038:12;4017:35;4084:2;4076:6;4072:15;4096:142;4112:6;4107:3;4104:15;4096:142;;;4178:17;;4166:30;;4216:12;;;;4129;;4096:142;;;-1:-1:-1;4256:6:1;3544:724;-1:-1:-1;;;;;;3544:724:1:o;4273:468::-;4337:5;4371:18;4363:6;4360:30;4357:56;;;4393:18;;:::i;:::-;4442:2;4436:9;4454:69;4511:2;4490:15;;-1:-1:-1;;4486:29:1;4517:4;4482:40;4436:9;4454:69;:::i;:::-;4541:6;4532:15;;4571:6;4563;4556:22;4611:3;4602:6;4597:3;4593:16;4590:25;4587:45;;;4628:1;4625;4618:12;4587:45;4678:6;4673:3;4666:4;4658:6;4654:17;4641:44;4733:1;4726:4;4717:6;4709;4705:19;4701:30;4694:41;;4273:468;;;;;:::o;4746:220::-;4788:5;4841:3;4834:4;4826:6;4822:17;4818:27;4808:55;;4859:1;4856;4849:12;4808:55;4881:79;4956:3;4947:6;4934:20;4927:4;4919:6;4915:17;4881:79;:::i;4971:1071::-;5125:6;5133;5141;5149;5157;5210:3;5198:9;5189:7;5185:23;5181:33;5178:53;;;5227:1;5224;5217:12;5178:53;5266:9;5253:23;5285:31;5310:5;5285:31;:::i;:::-;5335:5;-1:-1:-1;5392:2:1;5377:18;;5364:32;5405:33;5364:32;5405:33;:::i;:::-;5457:7;-1:-1:-1;5515:2:1;5500:18;;5487:32;5538:18;5568:14;;;5565:34;;;5595:1;5592;5585:12;5565:34;5618:61;5671:7;5662:6;5651:9;5647:22;5618:61;:::i;:::-;5608:71;;5732:2;5721:9;5717:18;5704:32;5688:48;;5761:2;5751:8;5748:16;5745:36;;;5777:1;5774;5767:12;5745:36;5800:63;5855:7;5844:8;5833:9;5829:24;5800:63;:::i;:::-;5790:73;;5916:3;5905:9;5901:19;5888:33;5872:49;;5946:2;5936:8;5933:16;5930:36;;;5962:1;5959;5952:12;5930:36;;5985:51;6028:7;6017:8;6006:9;6002:24;5985:51;:::i;:::-;5975:61;;;4971:1071;;;;;;;;:::o;6286:1277::-;6404:6;6412;6465:2;6453:9;6444:7;6440:23;6436:32;6433:52;;;6481:1;6478;6471:12;6433:52;6521:9;6508:23;6550:18;6591:2;6583:6;6580:14;6577:34;;;6607:1;6604;6597:12;6577:34;6645:6;6634:9;6630:22;6620:32;;6690:7;6683:4;6679:2;6675:13;6671:27;6661:55;;6712:1;6709;6702:12;6661:55;6748:2;6735:16;6770:4;6793:43;6833:2;6793:43;:::i;:::-;6865:2;6859:9;6877:31;6905:2;6897:6;6877:31;:::i;:::-;6943:18;;;7031:1;7027:10;;;;7019:19;;7015:28;;;6977:15;;;;-1:-1:-1;7055:19:1;;;7052:39;;;7087:1;7084;7077:12;7052:39;7111:11;;;;7131:217;7147:6;7142:3;7139:15;7131:217;;;7227:3;7214:17;7244:31;7269:5;7244:31;:::i;:::-;7288:18;;7164:12;;;;7326;;;;7131:217;;;7367:6;-1:-1:-1;;7411:18:1;;7398:32;;-1:-1:-1;;7442:16:1;;;7439:36;;;7471:1;7468;7461:12;7439:36;;7494:63;7549:7;7538:8;7527:9;7523:24;7494:63;:::i;:::-;7484:73;;;6286:1277;;;;;:::o;7568:435::-;7621:3;7659:5;7653:12;7686:6;7681:3;7674:19;7712:4;7741:2;7736:3;7732:12;7725:19;;7778:2;7771:5;7767:14;7799:1;7809:169;7823:6;7820:1;7817:13;7809:169;;;7884:13;;7872:26;;7918:12;;;;7953:15;;;;7845:1;7838:9;7809:169;;;-1:-1:-1;7994:3:1;;7568:435;-1:-1:-1;;;;;7568:435:1:o;8008:261::-;8187:2;8176:9;8169:21;8150:4;8207:56;8259:2;8248:9;8244:18;8236:6;8207:56;:::i;8274:450::-;8343:6;8396:2;8384:9;8375:7;8371:23;8367:32;8364:52;;;8412:1;8409;8402:12;8364:52;8452:9;8439:23;8485:18;8477:6;8474:30;8471:50;;;8517:1;8514;8507:12;8471:50;8540:22;;8593:4;8585:13;;8581:27;-1:-1:-1;8571:55:1;;8622:1;8619;8612:12;8571:55;8645:73;8710:7;8705:2;8692:16;8687:2;8683;8679:11;8645:73;:::i;:::-;8635:83;8274:450;-1:-1:-1;;;;8274:450:1:o;8729:316::-;8806:6;8814;8822;8875:2;8863:9;8854:7;8850:23;8846:32;8843:52;;;8891:1;8888;8881:12;8843:52;-1:-1:-1;;8914:23:1;;;8984:2;8969:18;;8956:32;;-1:-1:-1;9035:2:1;9020:18;;;9007:32;;8729:316;-1:-1:-1;8729:316:1:o;9050:118::-;9136:5;9129:13;9122:21;9115:5;9112:32;9102:60;;9158:1;9155;9148:12;9173:382;9238:6;9246;9299:2;9287:9;9278:7;9274:23;9270:32;9267:52;;;9315:1;9312;9305:12;9267:52;9354:9;9341:23;9373:31;9398:5;9373:31;:::i;:::-;9423:5;-1:-1:-1;9480:2:1;9465:18;;9452:32;9493:30;9452:32;9493:30;:::i;:::-;9542:7;9532:17;;;9173:382;;;;;:::o;9560:315::-;9628:6;9636;9689:2;9677:9;9668:7;9664:23;9660:32;9657:52;;;9705:1;9702;9695:12;9657:52;9741:9;9728:23;9718:33;;9801:2;9790:9;9786:18;9773:32;9814:31;9839:5;9814:31;:::i;10103:241::-;10159:6;10212:2;10200:9;10191:7;10187:23;10183:32;10180:52;;;10228:1;10225;10218:12;10180:52;10267:9;10254:23;10286:28;10308:5;10286:28;:::i;10349:388::-;10417:6;10425;10478:2;10466:9;10457:7;10453:23;10449:32;10446:52;;;10494:1;10491;10484:12;10446:52;10533:9;10520:23;10552:31;10577:5;10552:31;:::i;:::-;10602:5;-1:-1:-1;10659:2:1;10644:18;;10631:32;10672:33;10631:32;10672:33;:::i;10742:734::-;10846:6;10854;10862;10870;10878;10931:3;10919:9;10910:7;10906:23;10902:33;10899:53;;;10948:1;10945;10938:12;10899:53;10987:9;10974:23;11006:31;11031:5;11006:31;:::i;:::-;11056:5;-1:-1:-1;11113:2:1;11098:18;;11085:32;11126:33;11085:32;11126:33;:::i;:::-;11178:7;-1:-1:-1;11232:2:1;11217:18;;11204:32;;-1:-1:-1;11283:2:1;11268:18;;11255:32;;-1:-1:-1;11338:3:1;11323:19;;11310:33;11366:18;11355:30;;11352:50;;;11398:1;11395;11388:12;11352:50;11421:49;11462:7;11453:6;11442:9;11438:22;11421:49;:::i;11892:127::-;11953:10;11948:3;11944:20;11941:1;11934:31;11984:4;11981:1;11974:15;12008:4;12005:1;11998:15;12024:168;12097:9;;;12128;;12145:15;;;12139:22;;12125:37;12115:71;;12166:18;;:::i;12329:217::-;12369:1;12395;12385:132;;12439:10;12434:3;12430:20;12427:1;12420:31;12474:4;12471:1;12464:15;12502:4;12499:1;12492:15;12385:132;-1:-1:-1;12531:9:1;;12329:217::o;12551:380::-;12630:1;12626:12;;;;12673;;;12694:61;;12748:4;12740:6;12736:17;12726:27;;12694:61;12801:2;12793:6;12790:14;12770:18;12767:38;12764:161;;12847:10;12842:3;12838:20;12835:1;12828:31;12882:4;12879:1;12872:15;12910:4;12907:1;12900:15;12764:161;;12551:380;;;:::o;12936:356::-;13138:2;13120:21;;;13157:18;;;13150:30;13216:34;13211:2;13196:18;;13189:62;13283:2;13268:18;;12936:356::o;13297:184::-;13367:6;13420:2;13408:9;13399:7;13395:23;13391:32;13388:52;;;13436:1;13433;13426:12;13388:52;-1:-1:-1;13459:16:1;;13297:184;-1:-1:-1;13297:184:1:o;13612:1187::-;13889:3;13918:1;13951:6;13945:13;13981:36;14007:9;13981:36;:::i;:::-;14036:1;14053:18;;;14080:133;;;;14227:1;14222:356;;;;14046:532;;14080:133;-1:-1:-1;;14113:24:1;;14101:37;;14186:14;;14179:22;14167:35;;14158:45;;;-1:-1:-1;14080:133:1;;14222:356;14253:6;14250:1;14243:17;14283:4;14328:2;14325:1;14315:16;14353:1;14367:165;14381:6;14378:1;14375:13;14367:165;;;14459:14;;14446:11;;;14439:35;14502:16;;;;14396:10;;14367:165;;;14371:3;;;14561:6;14556:3;14552:16;14545:23;;14046:532;;;;;14609:6;14603:13;14625:68;14684:8;14679:3;14672:4;14664:6;14660:17;14625:68;:::i;:::-;-1:-1:-1;;;14715:18:1;;14742:22;;;14791:1;14780:13;;13612:1187;-1:-1:-1;;;;13612:1187:1:o;14804:128::-;14871:9;;;14892:11;;;14889:37;;;14906:18;;:::i;14937:127::-;14998:10;14993:3;14989:20;14986:1;14979:31;15029:4;15026:1;15019:15;15053:4;15050:1;15043:15;15277:245;15344:6;15397:2;15385:9;15376:7;15372:23;15368:32;15365:52;;;15413:1;15410;15403:12;15365:52;15445:9;15439:16;15464:28;15486:5;15464:28;:::i;15937:135::-;15976:3;15997:17;;;15994:43;;16017:18;;:::i;:::-;-1:-1:-1;16064:1:1;16053:13;;15937:135::o;16077:545::-;16179:2;16174:3;16171:11;16168:448;;;16215:1;16240:5;16236:2;16229:17;16285:4;16281:2;16271:19;16355:2;16343:10;16339:19;16336:1;16332:27;16326:4;16322:38;16391:4;16379:10;16376:20;16373:47;;;-1:-1:-1;16414:4:1;16373:47;16469:2;16464:3;16460:12;16457:1;16453:20;16447:4;16443:31;16433:41;;16524:82;16542:2;16535:5;16532:13;16524:82;;;16587:17;;;16568:1;16557:13;16524:82;;16798:1352;16924:3;16918:10;16951:18;16943:6;16940:30;16937:56;;;16973:18;;:::i;:::-;17002:97;17092:6;17052:38;17084:4;17078:11;17052:38;:::i;:::-;17046:4;17002:97;:::i;:::-;17154:4;;17218:2;17207:14;;17235:1;17230:663;;;;17937:1;17954:6;17951:89;;;-1:-1:-1;18006:19:1;;;18000:26;17951:89;-1:-1:-1;;16755:1:1;16751:11;;;16747:24;16743:29;16733:40;16779:1;16775:11;;;16730:57;18053:81;;17200:944;;17230:663;13559:1;13552:14;;;13596:4;13583:18;;-1:-1:-1;;17266:20:1;;;17384:236;17398:7;17395:1;17392:14;17384:236;;;17487:19;;;17481:26;17466:42;;17579:27;;;;17547:1;17535:14;;;;17414:19;;17384:236;;;17388:3;17648:6;17639:7;17636:19;17633:201;;;17709:19;;;17703:26;-1:-1:-1;;17792:1:1;17788:14;;;17804:3;17784:24;17780:37;17776:42;17761:58;17746:74;;17633:201;-1:-1:-1;;;;;17880:1:1;17864:14;;;17860:22;17847:36;;-1:-1:-1;16798:1352:1:o;18844:410::-;19046:2;19028:21;;;19085:2;19065:18;;;19058:30;19124:34;19119:2;19104:18;;19097:62;-1:-1:-1;;;19190:2:1;19175:18;;19168:44;19244:3;19229:19;;18844:410::o;19259:401::-;19461:2;19443:21;;;19500:2;19480:18;;;19473:30;19539:34;19534:2;19519:18;;19512:62;-1:-1:-1;;;19605:2:1;19590:18;;19583:35;19650:3;19635:19;;19259:401::o;19665:406::-;19867:2;19849:21;;;19906:2;19886:18;;;19879:30;19945:34;19940:2;19925:18;;19918:62;-1:-1:-1;;;20011:2:1;19996:18;;19989:40;20061:3;20046:19;;19665:406::o;20076:125::-;20141:9;;;20162:10;;;20159:36;;;20175:18;;:::i;20861:404::-;21063:2;21045:21;;;21102:2;21082:18;;;21075:30;21141:34;21136:2;21121:18;;21114:62;-1:-1:-1;;;21207:2:1;21192:18;;21185:38;21255:3;21240:19;;20861:404::o;21270:465::-;21527:2;21516:9;21509:21;21490:4;21553:56;21605:2;21594:9;21590:18;21582:6;21553:56;:::i;:::-;21657:9;21649:6;21645:22;21640:2;21629:9;21625:18;21618:50;21685:44;21722:6;21714;21685:44;:::i;:::-;21677:52;21270:465;-1:-1:-1;;;;;21270:465:1:o;21740:561::-;-1:-1:-1;;;;;22037:15:1;;;22019:34;;22089:15;;22084:2;22069:18;;22062:43;22136:2;22121:18;;22114:34;;;22179:2;22164:18;;22157:34;;;21999:3;22222;22207:19;;22200:32;;;21962:4;;22249:46;;22275:19;;22267:6;22249:46;:::i;:::-;22241:54;21740:561;-1:-1:-1;;;;;;;21740:561:1:o;22306:249::-;22375:6;22428:2;22416:9;22407:7;22403:23;22399:32;22396:52;;;22444:1;22441;22434:12;22396:52;22476:9;22470:16;22495:30;22519:5;22495:30;:::i;22560:179::-;22595:3;22637:1;22619:16;22616:23;22613:120;;;22683:1;22680;22677;22662:23;-1:-1:-1;22720:1:1;22714:8;22709:3;22705:18;22613:120;22560:179;:::o;22744:671::-;22783:3;22825:4;22807:16;22804:26;22801:39;;;22744:671;:::o;22801:39::-;22867:2;22861:9;-1:-1:-1;;22932:16:1;22928:25;;22925:1;22861:9;22904:50;22983:4;22977:11;23007:16;23042:18;23113:2;23106:4;23098:6;23094:17;23091:25;23086:2;23078:6;23075:14;23072:45;23069:58;;;23120:5;;;;;22744:671;:::o;23069:58::-;23157:6;23151:4;23147:17;23136:28;;23193:3;23187:10;23220:2;23212:6;23209:14;23206:27;;;23226:5;;;;;;22744:671;:::o;23206:27::-;23310:2;23291:16;23285:4;23281:27;23277:36;23270:4;23261:6;23256:3;23252:16;23248:27;23245:69;23242:82;;;23317:5;;;;;;22744:671;:::o;23242:82::-;23333:57;23384:4;23375:6;23367;23363:19;23359:30;23353:4;23333:57;:::i;:::-;-1:-1:-1;23406:3:1;;22744:671;-1:-1:-1;;;;;22744:671:1:o;23841:404::-;24043:2;24025:21;;;24082:2;24062:18;;;24055:30;24121:34;24116:2;24101:18;;24094:62;-1:-1:-1;;;24187:2:1;24172:18;;24165:38;24235:3;24220:19;;23841:404::o;24660:827::-;-1:-1:-1;;;;;25057:15:1;;;25039:34;;25109:15;;25104:2;25089:18;;25082:43;25019:3;25156:2;25141:18;;25134:31;;;24982:4;;25188:57;;25225:19;;25217:6;25188:57;:::i;:::-;25293:9;25285:6;25281:22;25276:2;25265:9;25261:18;25254:50;25327:44;25364:6;25356;25327:44;:::i;:::-;25313:58;;25420:9;25412:6;25408:22;25402:3;25391:9;25387:19;25380:51;25448:33;25474:6;25466;25448:33;:::i;:::-;25440:41;24660:827;-1:-1:-1;;;;;;;;24660:827:1:o

ipfs://aaa766c7ba191465a5c82bc910df25bbc2b050c075132ab5c812a60a4af3cd92