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-01-12
*/

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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


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

pragma solidity ^0.8.0;


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

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

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

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

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

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

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

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

        return (signer, RecoverError.NoError);
    }

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

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// 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/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// 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.6.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/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: contracts/ERC1155D5000.sol


// Donkeverse Contracts v0.0.1
//AE THER
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 ERC1155D is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    uint256 public constant MAX_SUPPLY = 5000;

    address[MAX_SUPPLY+1] internal _owners;

    // 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: balance query for the zero address");
        require(id < MAX_SUPPLY, "ERC1155D: id exceeds maximum");

        return _owners[id] == account ? 1 : 0;
    }

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

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

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

        return batchBalances;
    }

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

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

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

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

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

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

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

        require(_owners[id] == from && amount < 2, "ERC1155: insufficient balance for transfer");

        // The ERC1155 spec allows for transfering zero tokens, but we are still expected
        // to run the other checks and emit the event. But we don't want an ownership change
        // in that case
        if (amount == 1) {
            _owners[id] = to;
        }

        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];

            require(_owners[id] == from && amounts[i] < 2, "ERC1155: insufficient balance for transfer");

            if (amounts[i] == 1) {
                _owners[id] = to;
            }
        }

        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");
        require(amount < 2, "ERC1155D: exceeds supply");
        require(id < MAX_SUPPLY, "ERC1155D: invalid id");

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

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

        // The ERC1155 spec allows for transfering zero tokens, but we are still expected
        // to run the other checks and emit the event. But we don't want an ownership change
        // in that case
        if (amount == 1) {
            _owners[id] = to;
        }

        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 Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `id` must be less than MAX_SUPPLY;
     * This does not implement smart contract checks according to ERC1155 so it exists as a separate function
     */

    function _mintSingle(address to, uint256 id) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address"); // you can remove this if only minting to msg.sender
        require(_owners[id] == address(0), "ERC1155D: supply exceeded");
        require(id > 0, "ERC1155D: invalid id 0"); 
        _owners[id] = to; // this can be made more efficient with assembly if you know what you are doing!
        emit TransferSingle(to, address(0), to, id, 1);
    }

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

        address operator = _msgSender();

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

        for (uint256 i = 0; i < ids.length; i++) {
            require(amounts[i] < 2, "ERC1155D: exceeds supply");
            require(_owners[ids[i]] == address(0), "ERC1155D: supply exceeded");

            if (amounts[i] == 1) {
                _owners[ids[i]] = to;
            }
        }

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

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

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

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

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

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

        require(_owners[id] == from && amount < 2, "ERC1155: burn amount exceeds balance");
        if (amount == 1) {
            _owners[id] = address(0);
        }

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

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

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

        address operator = _msgSender();

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

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            require(_owners[id] == from && amounts[i] < 2, "ERC1155: burn amount exceeds balance");
            if (amounts[i] == 1) {
                _owners[id] = address(0);
            }
        }

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

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

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

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

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

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try 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) internal pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }

    function _prepayGas(uint256 start, uint256 end) internal {
        require(end <= MAX_SUPPLY, "ERC1155D: end id exceeds maximum");

        for (uint256 i = start; i < end; i++) {

            bytes32 slotValue;
            assembly {
                slotValue := sload(add(_owners.slot, i))
            }

            bytes32 leftmostBitSetToOne = slotValue | bytes32(uint256(1) << 255);
            assembly {
                sstore(add(_owners.slot, i), leftmostBitSetToOne)
            }
        }
    }

    function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY+1] memory) {
        return _owners;
    }

    function ownerOfERC721Like(uint256 id) external view returns(address) {
        require(id < _owners.length, "ERC1155D: id exceeds maximum");
        address owner = _owners[id];
        require(owner != address(0), "ERC1155D: owner query for nonexistent token");
        return owner;
    }

    function getERC721BalanceOffChain(address _address) external view returns(uint256) {
        uint256 counter = 0;
        for (uint256 i; i < _owners.length; i++) {
            if (_owners[i] == _address) {
                counter++;
            }
        }
        return counter;
    }
}
// File: contracts/Companions.sol

pragma solidity >=0.8;

interface IKeys {
  function balanceOf(address account, uint256 id) external returns (uint256);

  function safeTransferFrom(
    address from,
    address to,
    uint256 id,
    uint256 amount,
    bytes memory data
  ) external;
}

//AE THER
pragma solidity >=0.8;





contract Companions is ERC1155D, Ownable, ReentrancyGuard {
  using ECDSA for bytes32;
  using Strings for uint256;
  event Received(address, uint256);
  event claimNftWithKey(uint256 tokenId, uint256 keyId);
  event claimNftWithIndex(uint256 tokenId, uint256 Index);
  // Contract name
  string public name;
  // Contract symbol
  string public symbol;
  uint256 public count;
  string public baseUri;
  string public contractURI;
  string public extension;
  address public keyReceiver;
  address private _recipient;
  address public signerAddress;
  uint256 royaltyPercentage;
  IKeys public immutable keys;

  constructor(
    string memory _Name,
    string memory _Symbol,
    string memory _contractURI,
    string memory _baseUri,
    address _signerAddress,
    address _keyReceiver,
    address Keys,
    uint256 _royaltyPercentage,
    string memory _extension
  ) ERC1155D(_contractURI) {
    name = _Name;
    symbol = _Symbol;
    signerAddress = _signerAddress;
    contractURI = _contractURI;
    baseUri = _baseUri;
    keyReceiver = _keyReceiver;
    keys = IKeys(Keys);
    _recipient = owner();
    royaltyPercentage = _royaltyPercentage;
    extension =_extension;
  }

  function validateUsingECDASignature(
    bytes calldata signature,
    uint256 tokenId,
    uint256 id
  ) public view {
    bytes32 hash = keccak256(
      abi.encodePacked(bytes32(uint256(uint160(msg.sender))), tokenId, id)
    );
    require(
      signerAddress == hash.toEthSignedMessageHash().recover(signature),
      "Signer address mismatch."
    );
  }

  function validateKeyOwnership(address sender, uint256 keyId) public {
    require(keys.balanceOf(sender, keyId) == 1, "user is not owner of nft_id");
  }

  function mintWithKey(
    bytes calldata signature,
    uint256 tokenId,
    uint256 keyId
  ) public payable nonReentrant {
    //can mint
    validateUsingECDASignature(signature, tokenId, keyId);
    //verify that owner of Keys nfts
    validateKeyOwnership(msg.sender, keyId);
    //transfering keys nft
    keys.safeTransferFrom(msg.sender, keyReceiver, keyId, 1, "");
    //minting
    _mintSingle(msg.sender, tokenId);
    //loggin tokenID and KeyId
    emit claimNftWithKey(tokenId, keyId);
  }

    function mintWithIndex(
    bytes calldata signature,
    uint256 tokenId,
    uint256 index
  ) public payable nonReentrant {
    //can mint
    validateUsingECDASignature(signature, tokenId, index);
    //minting
    _mintSingle(msg.sender, tokenId);
    //loggin tokenID and KeyId
    emit claimNftWithIndex(tokenId, index);
  }


  function burn(
    address from,
    uint256 id,
    uint256 amount
  ) public {
    _burn(from, id, amount);
  }

  function burnBatch(
    address from,
    uint256[] memory ids,
    uint256[] memory amounts
  ) public {
    _burnBatch(from, ids, amounts);
  }

  //Normal minting allows minting on public sale satisfyign the necessary conditions
  function airdrop(address reciever, uint256[] memory tokenIds)
    external
    onlyOwner
  {
    uint256 amount = tokenIds.length;
    require(amount >= 1, "nonzero airdrop");
    if (amount == 1) {
      _mintSingle(reciever, tokenIds[0]);
    } else {
      uint256[] memory values = new uint256[](amount);
      for (uint256 i = 0; i < amount; i++) {
        values[i] = 1;
      }
      _mintBatch(reciever, tokenIds, values, "");
    }
  }

  function uri(uint256 _tokenId) public view override returns (string memory) {
    require(_owners[_tokenId] != address(0), "tokenId does not exist");
    return
      bytes(baseUri).length > 0
        ? string(abi.encodePacked(baseUri, _tokenId.toString(), extension))
        : "";
  }


  function setExtension(string memory _extension) public onlyOwner nonReentrant {
    extension = _extension;
  }

  function setContractURI(string memory newContractURI)
    public
    onlyOwner
    nonReentrant
  {
    contractURI = newContractURI;
  }

  function setUri(string memory _uri) public onlyOwner nonReentrant {
    baseUri = _uri;
  }

  function setSignerAddress(address _signerAddress)
    public
    onlyOwner
    nonReentrant
  {
    signerAddress = _signerAddress;
  }

  function setKeyReceiver(address _newKeyReceiver)
    public
    onlyOwner
    nonReentrant
  {
    keyReceiver = _newKeyReceiver;
  }

  function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
    external
    view
    returns (address receiver, uint256 royaltyAmount)
  {
    return (_recipient, (_salePrice * royaltyPercentage) / 10000);
  }

  function setRoyalityPercentage(uint256 _royaltyPercentage) public onlyOwner nonReentrant{
    royaltyPercentage = _royaltyPercentage;
  }

  function supportsInterface(bytes4 interfaceId)
    public
    view
    virtual
    override(ERC1155D)
    returns (bool)
  {
    return (interfaceId == type(IERC2981).interfaceId ||
      super.supportsInterface(interfaceId));
  }

  function _setRoyalties(address newRecipient) internal {
    require(
      newRecipient != address(0),
      "Royalties: new recipient is the zero address"
    );
    _recipient = newRecipient;
  }

  function setRoyalties(address newRecipient) external onlyOwner nonReentrant {
    _setRoyalties(newRecipient);
  }
  // release address based on shares.
  function withdrawEth() external onlyOwner nonReentrant {
    (bool success, ) = msg.sender.call{value: address(this).balance}("");
    require(success, "Transfer failed.");
  }
  
  receive() external payable {
    emit Received(msg.sender, msg.value);
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_Name","type":"string"},{"internalType":"string","name":"_Symbol","type":"string"},{"internalType":"string","name":"_contractURI","type":"string"},{"internalType":"string","name":"_baseUri","type":"string"},{"internalType":"address","name":"_signerAddress","type":"address"},{"internalType":"address","name":"_keyReceiver","type":"address"},{"internalType":"address","name":"Keys","type":"address"},{"internalType":"uint256","name":"_royaltyPercentage","type":"uint256"},{"internalType":"string","name":"_extension","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"Received","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"Index","type":"uint256"}],"name":"claimNftWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"keyId","type":"uint256"}],"name":"claimNftWithKey","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"reciever","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","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":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"getERC721BalanceOffChain","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwnershipRecordOffChain","outputs":[{"internalType":"address[5001]","name":"","type":"address[5001]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keyReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keys","outputs":[{"internalType":"contract IKeys","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"mintWithIndex","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"keyId","type":"uint256"}],"name":"mintWithKey","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOfERC721Like","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","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":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newContractURI","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_extension","type":"string"}],"name":"setExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newKeyReceiver","type":"address"}],"name":"setKeyReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_royaltyPercentage","type":"uint256"}],"name":"setRoyalityPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRecipient","type":"address"}],"name":"setRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signerAddress","type":"address"}],"name":"setSignerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signerAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"keyId","type":"uint256"}],"name":"validateKeyOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"validateUsingECDASignature","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000220000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a3691000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a36910000000000000000000000002b5f2fc733acd1521a9efc6c4f354cdd7eec6c1b000000000000000000000000000000000000000000000000000000000000030900000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000013526966746572733a20436f6d70616e696f6e7300000000000000000000000000000000000000000000000000000000000000000000000000000000000000001152696674657273436f6d70616e696f6e730000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042697066733a2f2f6261666b7265696832767134686a35736c6e3778703476636571336b716f63776d65616d64786432617237366d7069766c626534376f65733733710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043697066733a2f2f626166796265696778766b6f6f3779777077627178673770713373626a6b676135747378727574777262776232697768616876636f7432786334612f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000052e6a736f6e000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _Name (string): Rifters: Companions
Arg [1] : _Symbol (string): RiftersCompanions
Arg [2] : _contractURI (string): ipfs://bafkreih2vq4hj5sln7xp4vceq3kqocwmeamdxd2ar76mpivlbe47oes73q
Arg [3] : _baseUri (string): ipfs://bafybeigxvkoo7ywpwbqxg7pq3sbjkga5tsxrutwrbwb2iwhahvcot2xc4a/
Arg [4] : _signerAddress (address): 0xC4D12607206F2f1eeA6f8E05241eD052F39A3691
Arg [5] : _keyReceiver (address): 0xC4D12607206F2f1eeA6f8E05241eD052F39A3691
Arg [6] : Keys (address): 0x2b5F2fc733Acd1521a9Efc6C4f354CDD7eEC6C1b
Arg [7] : _royaltyPercentage (uint256): 777
Arg [8] : _extension (string): .json

-----Encoded View---------------
23 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [2] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000220
Arg [4] : 000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a3691
Arg [5] : 000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a3691
Arg [6] : 0000000000000000000000002b5f2fc733acd1521a9efc6c4f354cdd7eec6c1b
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000309
Arg [8] : 00000000000000000000000000000000000000000000000000000000000002a0
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000013
Arg [10] : 526966746572733a20436f6d70616e696f6e7300000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000011
Arg [12] : 52696674657273436f6d70616e696f6e73000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000042
Arg [14] : 697066733a2f2f6261666b7265696832767134686a35736c6e37787034766365
Arg [15] : 71336b716f63776d65616d64786432617237366d7069766c626534376f657337
Arg [16] : 3371000000000000000000000000000000000000000000000000000000000000
Arg [17] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [18] : 697066733a2f2f626166796265696778766b6f6f377977707762717867377071
Arg [19] : 3373626a6b676135747378727574777262776232697768616876636f74327863
Arg [20] : 34612f0000000000000000000000000000000000000000000000000000000000
Arg [21] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [22] : 2e6a736f6e000000000000000000000000000000000000000000000000000000

70572:5689:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76221:31;;;76230:10;188:51:1;;76242:9:0;270:2:1;255:18;;248:34;76221:31:0;;161:18:1;76221:31:0;;;;;;;70572:5689;;;;;52220:308;;;;;;;;;;-1:-1:-1;52220:308:0;;;;;:::i;:::-;;:::i;:::-;;;876:25:1;;;864:2;849:18;52220:308:0;;;;;;;;75382:239;;;;;;;;;;-1:-1:-1;75382:239:0;;;;;:::i;:::-;;:::i;:::-;;;1463:14:1;;1456:22;1438:41;;1426:2;1411:18;75382:239:0;1298:187:1;74724:141:0;;;;;;;;;;-1:-1:-1;74724:141:0;;;;;:::i;:::-;;:::i;:::-;;70938:20;;;;;;;;;;;;;;;;70868:18;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;74057:292::-;;;;;;;;;;-1:-1:-1;74057:292:0;;;;;:::i;:::-;;:::i;75016:215::-;;;;;;;;;;-1:-1:-1;75016:215:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;206:32:1;;;188:51;;270:2;255:18;;248:34;;;;161:18;75016:215:0;14:274:1;75836:116:0;;;;;;;;;;-1:-1:-1;75836:116:0;;;;;:::i;:::-;;:::i;71019:23::-;;;;;;;;;;;;;:::i;54236:442::-;;;;;;;;;;-1:-1:-1;54236:442:0;;;;;:::i;:::-;;:::i;71172:27::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;6002:32:1;;;5984:51;;5972:2;5957:18;71172:27:0;5824:217:1;50690:41:0;;;;;;;;;;;;50727:4;50690:41;;69917:295;;;;;;;;;;-1:-1:-1;69917:295:0;;;;;:::i;:::-;;:::i;71808:374::-;;;;;;;;;;-1:-1:-1;71808:374:0;;;;;:::i;:::-;;:::i;72349:517::-;;;;;;:::i;:::-;;:::i;52694:524::-;;;;;;;;;;-1:-1:-1;52694:524:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;69482:123::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;71109:28::-;;;;;;;;;;-1:-1:-1;71109:28:0;;;;-1:-1:-1;;;;;71109:28:0;;;73349:151;;;;;;;;;;-1:-1:-1;73349:151:0;;;;;:::i;:::-;;:::i;29682:103::-;;;;;;;;;;;;;:::i;74357:113::-;;;;;;;;;;-1:-1:-1;74357:113:0;;;;;:::i;:::-;;:::i;74871:139::-;;;;;;;;;;-1:-1:-1;74871:139:0;;;;;:::i;:::-;;:::i;73592:459::-;;;;;;;;;;-1:-1:-1;73592:459:0;;;;;:::i;:::-;;:::i;75237:139::-;;;;;;;;;;-1:-1:-1;75237:139:0;;;;;:::i;:::-;;:::i;72874:342::-;;;;;;:::i;:::-;;:::i;29034:87::-;;;;;;;;;;-1:-1:-1;29107:6:0;;-1:-1:-1;;;;;29107:6:0;29034:87;;69613:296;;;;;;;;;;-1:-1:-1;69613:296:0;;;;;:::i;:::-;;:::i;74476:143::-;;;;;;;;;;-1:-1:-1;74476:143:0;;;;;:::i;:::-;;:::i;70913:20::-;;;;;;;;;;;;;:::i;70963:21::-;;;;;;;;;;;;;:::i;74625:93::-;;;;;;;;;;-1:-1:-1;74625:93:0;;;;;:::i;:::-;;:::i;72188:155::-;;;;;;;;;;-1:-1:-1;72188:155:0;;;;;:::i;:::-;;:::i;75995:179::-;;;;;;;;;;;;;:::i;53291:155::-;;;;;;;;;;-1:-1:-1;53291:155:0;;;;;:::i;:::-;;:::i;71047:26::-;;;;;;;;;;-1:-1:-1;71047:26:0;;;;-1:-1:-1;;;;;71047:26:0;;;70989:25;;;;;;;;;;;;;:::i;53518:168::-;;;;;;;;;;-1:-1:-1;53518:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;53641:27:0;;;53617:4;53641:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;53518:168;53758:401;;;;;;;;;;-1:-1:-1;53758:401:0;;;;;:::i;:::-;;:::i;29940:201::-;;;;;;;;;;-1:-1:-1;29940:201:0;;;;;:::i;:::-;;:::i;73224:119::-;;;;;;;;;;-1:-1:-1;73224:119:0;;;;;:::i;:::-;;:::i;52220:308::-;52306:7;-1:-1:-1;;;;;52334:21:0;;52326:77;;;;-1:-1:-1;;;52326:77:0;;12761:2:1;52326:77:0;;;12743:21:1;12800:2;12780:18;;;12773:30;12839:34;12819:18;;;12812:62;-1:-1:-1;;;12890:18:1;;;12883:41;12941:19;;52326:77:0;;;;;;;;;50727:4;52422:2;:15;52414:56;;;;-1:-1:-1;;;52414:56:0;;13173:2:1;52414:56:0;;;13155:21:1;13212:2;13192:18;;;13185:30;13251;13231:18;;;13224:58;13299:18;;52414:56:0;12971:352:1;52414:56:0;52505:7;-1:-1:-1;;;;;52490:22:0;:7;52498:2;52490:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;52490:11:0;:22;:30;;52519:1;52490:30;;;52515:1;52490:30;52483:37;;;;52220:308;;;;;:::o;75382:239::-;75502:4;-1:-1:-1;;;;;;75526:41:0;;-1:-1:-1;;;75526:41:0;;:88;;;75578:36;75602:11;75578:23;:36::i;74724:141::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74829:13:::2;:30:::0;;-1:-1:-1;;;;;;74829:30:0::2;-1:-1:-1::0;;;;;74829:30:0;::::2;;::::0;;-1:-1:-1;2909:7:0;:22;74724:141;:::o;2389:20::-:1;74724:141:::0;:::o;70868:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;74057:292::-;74118:13;74177:1;;74156:8;74148:17;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;74148:17:0;:31;74140:66;;;;-1:-1:-1;;;74140:66:0;;14047:2:1;74140:66:0;;;14029:21:1;14086:2;14066:18;;;14059:30;-1:-1:-1;;;14105:18:1;;;14098:52;14167:18;;74140:66:0;13845:346:1;74140:66:0;74251:1;74233:7;74227:21;;;;;:::i;:::-;;;:25;:116;;;;;;;;;;;;;;;;;74288:7;74297:19;:8;:17;:19::i;:::-;74318:9;74271:57;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74213:130;74057:292;-1:-1:-1;;74057:292:0:o;75016:215::-;75172:10;;75198:17;;75113:16;;;;-1:-1:-1;;;;;75172:10:0;;;;75219:5;;75185:30;;:10;:30;:::i;:::-;75184:40;;;;:::i;:::-;75164:61;;;;75016:215;;;;;;:::o;75836:116::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;75919:27:::2;75933:12;75919:13;:27::i;:::-;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;71019:23;;;;;;;:::i;54236:442::-;-1:-1:-1;;;;;54469:20:0;;27665:10;54469:20;;:60;;-1:-1:-1;54493:36:0;54510:4;27665:10;53518:168;:::i;54493:36::-;54447:160;;;;-1:-1:-1;;;54447:160:0;;16384:2:1;54447:160:0;;;16366:21:1;16423:2;16403:18;;;16396:30;16462:34;16442:18;;;16435:62;-1:-1:-1;;;16513:18:1;;;16506:48;16571:19;;54447:160:0;16182:414:1;54447:160:0;54618:52;54641:4;54647:2;54651:3;54656:7;54665:4;54618:22;:52::i;:::-;54236:442;;;;;:::o;69917:295::-;69991:7;;;70041:139;70061:14;70057:1;:18;70041:139;;;70115:8;-1:-1:-1;;;;;70101:22:0;:7;70109:1;70101:10;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;70101:10:0;:22;70097:72;;70144:9;;;;:::i;:::-;;;;70097:72;70077:3;;;;:::i;:::-;;;;70041:139;;;-1:-1:-1;70197:7:0;69917:295;-1:-1:-1;;69917:295:0:o;71808:374::-;71971:68;;;72012:10;71971:68;;;16926:19:1;16961:12;;;16954:28;;;16998:12;;;16991:28;;;71938:12:0;;17035::1;;71971:68:0;;;;;;;;;;;;71953:93;;;;;;71938:108;;72086:48;72124:9;;72086:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72086:29:0;;-1:-1:-1;72086:4:0;;-1:-1:-1;72086:27:0;;-1:-1:-1;72086:29:0:i;:::-;:37;;:48::i;:::-;72069:13;;-1:-1:-1;;;;;72069:13:0;;;:65;;;72053:123;;;;-1:-1:-1;;;72053:123:0;;17260:2:1;72053:123:0;;;17242:21:1;17299:2;17279:18;;;17272:30;17338:26;17318:18;;;17311:54;17382:18;;72053:123:0;17058:348:1;72349:517:0;2345:21;:19;:21::i;:::-;72499:53:::1;72526:9;;72537:7;72546:5;72499:26;:53::i;:::-;72597:39;72618:10;72630:5;72597:20;:39::i;:::-;72705:11;::::0;72671:60:::1;::::0;-1:-1:-1;;;72671:60:0;;72693:10:::1;72671:60;::::0;::::1;17752:34:1::0;-1:-1:-1;;;;;72705:11:0;;::::1;17802:18:1::0;;;17795:43;17854:18;;;17847:34;;;72705:11:0;17897:18:1;;;17890:34;17732:3;17940:19;;;17933:32;-1:-1:-1;17981:19:1;;;17974:30;72671:4:0::1;:21:::0;;::::1;::::0;::::1;::::0;18021:19:1;;72671:60:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;72753:32;72765:10;72777:7;72753:11;:32::i;:::-;72829:31;::::0;;18225:25:1;;;18281:2;18266:18;;18259:34;;;72829:31:0::1;::::0;18198:18:1;72829:31:0::1;;;;;;;;2389:20:::0;1783:1;2909:7;:22;2726:213;2389:20;72349:517;;;;:::o;52694:524::-;52850:16;52911:3;:10;52892:8;:15;:29;52884:83;;;;-1:-1:-1;;;52884:83:0;;18506:2:1;52884:83:0;;;18488:21:1;18545:2;18525:18;;;18518:30;18584:34;18564:18;;;18557:62;-1:-1:-1;;;18635:18:1;;;18628:39;18684:19;;52884:83:0;18304:405:1;52884:83:0;52980:30;53027:8;:15;-1:-1:-1;;;;;53013:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53013:30:0;;52980:63;;53061:9;53056:122;53080:8;:15;53076:1;:19;53056:122;;;53136:30;53146:8;53155:1;53146:11;;;;;;;;:::i;:::-;;;;;;;53159:3;53163:1;53159:6;;;;;;;;:::i;:::-;;;;;;;53136:9;:30::i;:::-;53117:13;53131:1;53117:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;53097:3;;;:::i;:::-;;;53056:122;;;-1:-1:-1;53197:13:0;52694:524;-1:-1:-1;;;52694:524:0:o;69482:123::-;69542:28;;:::i;:::-;69583:14;;;;;;;;;;;-1:-1:-1;;69583:14:0;;-1:-1:-1;69583:14:0;;;;-1:-1:-1;;;;;69583:14:0;;;;;;;;;;;;;;;;;;;;;;69482:123;:::o;73349:151::-;73464:30;73475:4;73481:3;73486:7;73464:10;:30::i;:::-;73349:151;;;:::o;29682:103::-;28920:13;:11;:13::i;:::-;29747:30:::1;29774:1;29747:18;:30::i;:::-;29682:103::o:0;74357:113::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74442:9:::2;:22;74454:10:::0;74442:9;:22:::2;:::i;:::-;;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;74871:139;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74975:11:::2;:29:::0;;-1:-1:-1;;;;;;74975:29:0::2;-1:-1:-1::0;;;;;74975:29:0;::::2;;::::0;;-1:-1:-1;2909:7:0;:22;74724:141;:::o;73592:459::-;28920:13;:11;:13::i;:::-;73710:15;;73750:1:::1;73740:11:::0;::::1;;73732:39;;;::::0;-1:-1:-1;;;73732:39:0;;20994:2:1;73732:39:0::1;::::0;::::1;20976:21:1::0;21033:2;21013:18;;;21006:30;-1:-1:-1;;;21052:18:1;;;21045:45;21107:18;;73732:39:0::1;20792:339:1::0;73732:39:0::1;73782:6;73792:1;73782:11:::0;73778:268:::1;;73804:34;73816:8;73826;73835:1;73826:11;;;;;;;;:::i;:::-;;;;;;;73804;:34::i;73778:268::-;73861:23;73901:6;-1:-1:-1::0;;;;;73887:21:0::1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;73887:21:0::1;;73861:47;;73922:9;73917:71;73941:6;73937:1;:10;73917:71;;;73977:1;73965:6;73972:1;73965:9;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;:13;73949:3;::::1;::::0;::::1;:::i;:::-;;;;73917:71;;;;73996:42;74007:8;74017;74027:6;73996:42;;;;;;;;;;;::::0;:10:::1;:42::i;75237:139::-:0;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;75332:17:::2;:38:::0;;;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;72874:342;2345:21;:19;:21::i;:::-;73026:53:::1;73053:9;;73064:7;73073:5;73026:26;:53::i;:::-;73101:32;73113:10;73125:7;73101:11;:32::i;:::-;73177:33;::::0;;18225:25:1;;;18281:2;18266:18;;18259:34;;;73177:33:0::1;::::0;18198:18:1;73177:33:0::1;18051:248:1::0;69613:296:0;69674:7;69707:14;69702:2;:19;69694:60;;;;-1:-1:-1;;;69694:60:0;;13173:2:1;69694:60:0;;;13155:21:1;13212:2;13192:18;;;13185:30;13251;13231:18;;;13224:58;13299:18;;69694:60:0;12971:352:1;69694:60:0;69765:13;69781:7;69789:2;69781:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;69781:11:0;;-1:-1:-1;69781:11:0;69803:75;;;;-1:-1:-1;;;69803:75:0;;21338:2:1;69803:75:0;;;21320:21:1;21377:2;21357:18;;;21350:30;21416:34;21396:18;;;21389:62;-1:-1:-1;;;21467:18:1;;;21460:41;21518:19;;69803:75:0;21136:407:1;74476:143:0;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74585:11:::2;:28;74599:14:::0;74585:11;:28:::2;:::i;70913:20::-:0;;;;;;;:::i;70963:21::-;;;;;;;:::i;74625:93::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74698:7:::2;:14;74708:4:::0;74698:7;:14:::2;:::i;72188:155::-:0;72271:29;;-1:-1:-1;;;72271:29:0;;-1:-1:-1;;;;;206:32:1;;;72271:29:0;;;188:51:1;255:18;;;248:34;;;72271:4:0;:14;;;;161:18:1;;72271:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72304:1;72271:34;72263:74;;;;-1:-1:-1;;;72263:74:0;;21939:2:1;72263:74:0;;;21921:21:1;21978:2;21958:18;;;21951:30;22017:29;21997:18;;;21990:57;22064:18;;72263:74:0;21737:351:1;72263:74:0;72188:155;;:::o;75995:179::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;76076:49:::2;::::0;76058:12:::2;::::0;76076:10:::2;::::0;76099:21:::2;::::0;76058:12;76076:49;76058:12;76076:49;76099:21;76076:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76057:68;;;76140:7;76132:36;;;::::0;-1:-1:-1;;;76132:36:0;;22505:2:1;76132:36:0::2;::::0;::::2;22487:21:1::0;22544:2;22524:18;;;22517:30;-1:-1:-1;;;22563:18:1;;;22556:46;22619:18;;76132:36:0::2;22303:340:1::0;76132:36:0::2;76050:124;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;53291:155;53386:52;27665:10;53419:8;53429;53386:18;:52::i;70989:25::-;;;;;;;:::i;53758:401::-;-1:-1:-1;;;;;53966:20:0;;27665:10;53966:20;;:60;;-1:-1:-1;53990:36:0;54007:4;27665:10;53518:168;:::i;53990:36::-;53944:151;;;;-1:-1:-1;;;53944:151:0;;22850:2:1;53944:151:0;;;22832:21:1;22889:2;22869:18;;;22862:30;22928:34;22908:18;;;22901:62;-1:-1:-1;;;22979:18:1;;;22972:39;23028:19;;53944:151:0;22648:405:1;53944:151:0;54106:45;54124:4;54130:2;54134;54138:6;54146:4;54106:17;:45::i;29940:201::-;28920:13;:11;:13::i;:::-;-1:-1:-1;;;;;30029:22:0;::::1;30021:73;;;::::0;-1:-1:-1;;;30021:73:0;;23260:2:1;30021:73:0::1;::::0;::::1;23242:21:1::0;23299:2;23279:18;;;23272:30;23338:34;23318:18;;;23311:62;-1:-1:-1;;;23389:18:1;;;23382:36;23435:19;;30021:73:0::1;23058:402:1::0;30021:73:0::1;30105:28;30124:8;30105:18;:28::i;73224:119::-:0;73314:23;73320:4;73326:2;73330:6;73314:5;:23::i;51243:310::-;51345:4;-1:-1:-1;;;;;;51382:41:0;;-1:-1:-1;;;51382:41:0;;:110;;-1:-1:-1;;;;;;;51440:52:0;;-1:-1:-1;;;51440:52:0;51382:110;:163;;;-1:-1:-1;;;;;;;;;;42716:40:0;;;51509:36;42607:157;29199:132;29107:6;;-1:-1:-1;;;;;29107:6:0;27665:10;29263:23;29255:68;;;;-1:-1:-1;;;29255:68:0;;23667:2:1;29255:68:0;;;23649:21:1;;;23686:18;;;23679:30;23745:34;23725:18;;;23718:62;23797:18;;29255:68:0;23465:356:1;2425:293:0;1827:1;2559:7;;:19;2551:63;;;;-1:-1:-1;;;2551:63:0;;24028:2:1;2551:63:0;;;24010:21:1;24067:2;24047:18;;;24040:30;24106:33;24086:18;;;24079:61;24157:18;;2551:63:0;23826:355:1;2551:63:0;1827:1;2692:7;:18;2425:293::o;16251:716::-;16307:13;16358:14;16375:17;16386:5;16375:10;:17::i;:::-;16395:1;16375:21;16358:38;;16411:20;16445:6;-1:-1:-1;;;;;16434:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16434:18:0;-1:-1:-1;16411:41:0;-1:-1:-1;16576:28:0;;;16592:2;16576:28;16633:288;-1:-1:-1;;16665:5:0;-1:-1:-1;;;16802:2:0;16791:14;;16786:30;16665:5;16773:44;16863:2;16854:11;;;-1:-1:-1;16884:21:0;16633:288;16884:21;-1:-1:-1;16942:6:0;16251:716;-1:-1:-1;;;16251:716:0:o;75627:203::-;-1:-1:-1;;;;;75704:26:0;;75688:104;;;;-1:-1:-1;;;75688:104:0;;24388:2:1;75688:104:0;;;24370:21:1;24427:2;24407:18;;;24400:30;24466:34;24446:18;;;24439:62;-1:-1:-1;;;24517:18:1;;;24510:42;24569:19;;75688:104:0;24186:408:1;75688:104:0;75799:10;:25;;-1:-1:-1;;;;;;75799:25:0;-1:-1:-1;;;;;75799:25:0;;;;;;;;;;75627:203::o;56589:1009::-;56816:7;:14;56802:3;:10;:28;56794:81;;;;-1:-1:-1;;;56794:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56894:16:0;;56886:66;;;;-1:-1:-1;;;56886:66:0;;;;;;;:::i;:::-;27665:10;56965:16;57082:284;57106:3;:10;57102:1;:14;57082:284;;;57138:10;57151:3;57155:1;57151:6;;;;;;;;:::i;:::-;;;;;;;57138:19;;57197:4;-1:-1:-1;;;;;57182:19:0;:7;57190:2;57182:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;57182:11:0;:19;:37;;;;;57218:1;57205:7;57213:1;57205:10;;;;;;;;:::i;:::-;;;;;;;:14;57182:37;57174:92;;;;-1:-1:-1;;;57174:92:0;;;;;;;:::i;:::-;57287:7;57295:1;57287:10;;;;;;;;:::i;:::-;;;;;;;57301:1;57287:15;57283:72;;57337:2;57323:7;57331:2;57323:11;;;;;;;:::i;:::-;;:16;;-1:-1:-1;;;;;;57323:16:0;-1:-1:-1;;;;;57323:16:0;;;;;;;;;;57283:72;-1:-1:-1;57118:3:0;;;:::i;:::-;;;57082:284;;;;57413:2;-1:-1:-1;;;;;57383:47:0;57407:4;-1:-1:-1;;;;;57383:47:0;57397:8;-1:-1:-1;;;;;57383:47:0;;57417:3;57422:7;57383:47;;;;;;;:::i;:::-;;;;;;;;57515:75;57551:8;57561:4;57567:2;57571:3;57576:7;57585:4;57515:35;:75::i;:::-;56783:815;56589:1009;;;;;:::o;25591:269::-;25793:58;;26537:66:1;25793:58:0;;;26525:79:1;26620:12;;;26613:28;;;25660:7:0;;26657:12:1;;25793:58:0;;;;;;;;;;;;25783:69;;;;;;25776:76;;25591:269;;;:::o;21901:231::-;21979:7;22000:17;22019:18;22041:27;22052:4;22058:9;22041:10;:27::i;:::-;21999:69;;;;22079:18;22091:5;22079:11;:18::i;60404:488::-;-1:-1:-1;;;;;60485:16:0;;60477:62;;;;-1:-1:-1;;;60477:62:0;;;;;;;:::i;:::-;60634:1;;60619:2;60611:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;60611:11:0;:25;60603:63;;;;-1:-1:-1;;;60603:63:0;;27284:2:1;60603:63:0;;;27266:21:1;27323:2;27303:18;;;27296:30;-1:-1:-1;;;27342:18:1;;;27335:55;27407:18;;60603:63:0;27082:349:1;60603:63:0;60690:1;60685:2;:6;60677:41;;;;-1:-1:-1;;;60677:41:0;;27638:2:1;60677:41:0;;;27620:21:1;27677:2;27657:18;;;27650:30;-1:-1:-1;;;27696:18:1;;;27689:52;27758:18;;60677:41:0;27436:346:1;60677:41:0;60744:2;60730:7;60738:2;60730:11;;;;;;;:::i;:::-;;:16;;-1:-1:-1;;;;;;60730:16:0;-1:-1:-1;;;;;60730:16:0;;;;;;60843:41;;;18225:25:1;;;-1:-1:-1;18281:2:1;18266:18;;18259:34;60843:41:0;;;;-1:-1:-1;;60843:41:0;;;;18198:18:1;60843:41:0;;;;;;;60404:488;;:::o;63461:878::-;-1:-1:-1;;;;;63613:18:0;;63605:66;;;;-1:-1:-1;;;63605:66:0;;;;;;;:::i;:::-;63704:7;:14;63690:3;:10;:28;63682:81;;;;-1:-1:-1;;;63682:81:0;;;;;;;:::i;:::-;63820:66;;;;;;;;;63776:16;63820:66;;;;27665:10;;63899:282;63923:3;:10;63919:1;:14;63899:282;;;63955:10;63968:3;63972:1;63968:6;;;;;;;;:::i;:::-;;;;;;;63955:19;;64012:4;-1:-1:-1;;;;;63997:19:0;:7;64005:2;63997:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;63997:11:0;:19;:37;;;;;64033:1;64020:7;64028:1;64020:10;;;;;;;;:::i;:::-;;;;;;;:14;63997:37;63989:86;;;;-1:-1:-1;;;63989:86:0;;;;;;;:::i;:::-;64094:7;64102:1;64094:10;;;;;;;;:::i;:::-;;;;;;;64108:1;64094:15;64090:80;;64152:1;64130:7;64138:2;64130:11;;;;;;;:::i;:::-;;:24;;-1:-1:-1;;;;;;64130:24:0;-1:-1:-1;;;;;64130:24:0;;;;;;;;;;64090:80;-1:-1:-1;63935:3:0;;;;:::i;:::-;;;;63899:282;;;;64236:1;-1:-1:-1;;;;;64198:55:0;64222:4;-1:-1:-1;;;;;64198:55:0;64212:8;-1:-1:-1;;;;;64198:55:0;;64240:3;64245:7;64198:55;;;;;;;:::i;:::-;;;;;;;;64266:65;;;;;;;;;64310:1;64266:65;;;56589:1009;30301:191;30394:6;;;-1:-1:-1;;;;;30411:17:0;;;-1:-1:-1;;;;;;30411:17:0;;;;;;;30444:40;;30394:6;;;30411:17;30394:6;;30444:40;;30375:16;;30444:40;30364:128;30301:191;:::o;61248:1003::-;-1:-1:-1;;;;;61426:16:0;;61418:62;;;;-1:-1:-1;;;61418:62:0;;;;;;;:::i;:::-;61513:7;:14;61499:3;:10;:28;61491:81;;;;-1:-1:-1;;;61491:81:0;;;;;;;:::i;:::-;27665:10;61585:16;61708:293;61732:3;:10;61728:1;:14;61708:293;;;61785:1;61772:7;61780:1;61772:10;;;;;;;;:::i;:::-;;;;;;;:14;61764:51;;;;-1:-1:-1;;;61764:51:0;;29059:2:1;61764:51:0;;;29041:21:1;29098:2;29078:18;;;29071:30;29137:26;29117:18;;;29110:54;29181:18;;61764:51:0;28857:348:1;61764:51:0;61865:1;-1:-1:-1;;;;;61838:29:0;:7;61846:3;61850:1;61846:6;;;;;;;;:::i;:::-;;;;;;;61838:15;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;61838:15:0;:29;61830:67;;;;-1:-1:-1;;;61830:67:0;;27284:2:1;61830:67:0;;;27266:21:1;27323:2;27303:18;;;27296:30;-1:-1:-1;;;27342:18:1;;;27335:55;27407:18;;61830:67:0;27082:349:1;61830:67:0;61918:7;61926:1;61918:10;;;;;;;;:::i;:::-;;;;;;;61932:1;61918:15;61914:76;;61972:2;61954:7;61962:3;61966:1;61962:6;;;;;;;;:::i;:::-;;;;;;;61954:15;;;;;;;:::i;:::-;;:20;;-1:-1:-1;;;;;;61954:20:0;-1:-1:-1;;;;;61954:20:0;;;;;;;;;;61914:76;61744:3;;;;:::i;:::-;;;;61708:293;;;;62054:2;-1:-1:-1;;;;;62018:53:0;62050:1;-1:-1:-1;;;;;62018:53:0;62032:8;-1:-1:-1;;;;;62018:53:0;;62058:3;62063:7;62018:53;;;;;;;:::i;:::-;;;;;;;;62162:81;62198:8;62216:1;62220:2;62224:3;62229:7;62238:4;62162:35;:81::i;64481:331::-;64636:8;-1:-1:-1;;;;;64627:17:0;:5;-1:-1:-1;;;;;64627:17:0;;64619:71;;;;-1:-1:-1;;;64619:71:0;;29412:2:1;64619:71:0;;;29394:21:1;29451:2;29431:18;;;29424:30;29490:34;29470:18;;;29463:62;-1:-1:-1;;;29541:18:1;;;29534:39;29590:19;;64619:71:0;29210:405:1;64619:71:0;-1:-1:-1;;;;;64701:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;64701:46:0;;;;;;;;;;64763:41;;1438::1;;;64763::0;;1411:18:1;64763:41:0;;;;;;;64481:331;;;:::o;55142:1089::-;-1:-1:-1;;;;;55330:16:0;;55322:66;;;;-1:-1:-1;;;55322:66:0;;;;;;;:::i;:::-;27665:10;55401:16;55466:21;55484:2;55466:17;:21::i;:::-;55443:44;;55498:24;55525:25;55543:6;55525:17;:25::i;:::-;55498:52;;55659:4;-1:-1:-1;;;;;55644:19:0;:7;55652:2;55644:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;55644:11:0;:19;:33;;;;;55676:1;55667:6;:10;55644:33;55636:88;;;;-1:-1:-1;;;55636:88:0;;;;;;;:::i;:::-;55951:6;55961:1;55951:11;55947:60;;55993:2;55979:7;55987:2;55979:11;;;;;;;:::i;:::-;;:16;;-1:-1:-1;;;;;;55979:16:0;-1:-1:-1;;;;;55979:16:0;;;;;;;;;;55947:60;56055:2;-1:-1:-1;;;;;56024:46:0;56049:4;-1:-1:-1;;;;;56024:46:0;56039:8;-1:-1:-1;;;;;56024:46:0;;56059:2;56063:6;56024:46;;;;;;18225:25:1;;;18281:2;18266:18;;18259:34;18213:2;18198:18;;18051:248;56024:46:0;;;;;;;;56155:68;56186:8;56196:4;56202:2;56206;56210:6;56218:4;56155:30;:68::i;:::-;55311:920;;;55142:1089;;;;;:::o;62501:757::-;-1:-1:-1;;;;;62628:18:0;;62620:66;;;;-1:-1:-1;;;62620:66:0;;;;;;;:::i;:::-;27665:10;62699:16;62764:21;62782:2;62764:17;:21::i;:::-;62741:44;;62796:24;62823:25;62841:6;62823:17;:25::i;:::-;62861:66;;;;;;;;;62906:1;62861:66;;62796:52;-1:-1:-1;62963:4:0;-1:-1:-1;;;;;62948:19:0;:7;62956:2;62948:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;62948:11:0;:19;:33;;;;;62980:1;62971:6;:10;62948:33;62940:82;;;;-1:-1:-1;;;62940:82:0;;;;;;;:::i;:::-;63037:6;63047:1;63037:11;63033:68;;63087:1;63065:7;63073:2;63065:11;;;;;;;:::i;:::-;;:24;;-1:-1:-1;;;;;;63065:24:0;-1:-1:-1;;;;;63065:24:0;;;;;;;;;;63033:68;63118:54;;;18225:25:1;;;18281:2;18266:18;;18259:34;;;63157:1:0;;-1:-1:-1;;;;;63118:54:0;;;;;;;;;;18198:18:1;63118:54:0;;;;;;;63185:65;;;;;;;;;63229:1;63185:65;;;56589:1009;13117:922;13170:7;;-1:-1:-1;;;13248:15:0;;13244:102;;-1:-1:-1;;;13284:15:0;;;-1:-1:-1;13328:2:0;13318:12;13244:102;13373:6;13364:5;:15;13360:102;;13409:6;13400:15;;;-1:-1:-1;13444:2:0;13434:12;13360:102;13489:6;13480:5;:15;13476:102;;13525:6;13516:15;;;-1:-1:-1;13560:2:0;13550:12;13476:102;13605:5;13596;:14;13592:99;;13640:5;13631:14;;;-1:-1:-1;13674:1:0;13664:11;13592:99;13718:5;13709;:14;13705:99;;13753:5;13744:14;;;-1:-1:-1;13787:1:0;13777:11;13705:99;13831:5;13822;:14;13818:99;;13866:5;13857:14;;;-1:-1:-1;13900:1:0;13890:11;13818:99;13944:5;13935;:14;13931:66;;13980:1;13970:11;14025:6;13117:922;-1:-1:-1;;13117:922:0:o;67924:813::-;-1:-1:-1;;;;;68164:13:0;;32027:19;:23;68160:570;;68200:79;;-1:-1:-1;;;68200:79:0;;-1:-1:-1;;;;;68200:43:0;;;;;:79;;68244:8;;68254:4;;68260:3;;68265:7;;68274:4;;68200:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68200:79:0;;;;;;;;-1:-1:-1;;68200:79:0;;;;;;;;;;;;:::i;:::-;;;68196:523;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;68592:6;68585:14;;-1:-1:-1;;;68585:14:0;;;;;;;;:::i;68196:523::-;;;68641:62;;-1:-1:-1;;;68641:62:0;;31768:2:1;68641:62:0;;;31750:21:1;31807:2;31787:18;;;31780:30;31846:34;31826:18;;;31819:62;-1:-1:-1;;;31897:18:1;;;31890:50;31957:19;;68641:62:0;31566:416:1;68196:523:0;-1:-1:-1;;;;;;68361:60:0;;-1:-1:-1;;;68361:60:0;68357:159;;68446:50;;-1:-1:-1;;;68446:50:0;;;;;;;:::i;68357:159::-;68280:251;67924:813;;;;;;:::o;20352:747::-;20433:7;20442:12;20471:9;:16;20491:2;20471:22;20467:625;;20815:4;20800:20;;20794:27;20865:4;20850:20;;20844:27;20923:4;20908:20;;20902:27;20510:9;20894:36;20966:25;20977:4;20894:36;20794:27;20844;20966:10;:25::i;:::-;20959:32;;;;;;;;;20467:625;-1:-1:-1;21040:1:0;;-1:-1:-1;21044:35:0;21024:56;;18745:521;18823:20;18814:5;:29;;;;;;;;:::i;:::-;;18810:449;;18745:521;:::o;18810:449::-;18921:29;18912:5;:38;;;;;;;;:::i;:::-;;18908:351;;18967:34;;-1:-1:-1;;;18967:34:0;;32730:2:1;18967:34:0;;;32712:21:1;32769:2;32749:18;;;32742:30;32808:26;32788:18;;;32781:54;32852:18;;18967:34:0;32528:348:1;18908:351:0;19032:35;19023:5;:44;;;;;;;;:::i;:::-;;19019:240;;19084:41;;-1:-1:-1;;;19084:41:0;;33083:2:1;19084:41:0;;;33065:21:1;33122:2;33102:18;;;33095:30;33161:33;33141:18;;;33134:61;33212:18;;19084:41:0;32881:355:1;19019:240:0;19156:30;19147:5;:39;;;;;;;;:::i;:::-;;19143:116;;19203:44;;-1:-1:-1;;;19203:44:0;;33443:2:1;19203:44:0;;;33425:21:1;33482:2;33462:18;;;33455:30;33521:34;33501:18;;;33494:62;-1:-1:-1;;;33572:18:1;;;33565:32;33614:19;;19203:44:0;33241:398:1;68745:199:0;68866:16;;;68880:1;68866:16;;;;;;;;;68812;;68841:22;;68866:16;;;;;;;;;;;;-1:-1:-1;68866:16:0;68841:41;;68904:7;68893:5;68899:1;68893:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;68931:5;68745:199;-1:-1:-1;;68745:199:0:o;67172:744::-;-1:-1:-1;;;;;67387:13:0;;32027:19;:23;67383:526;;67423:72;;-1:-1:-1;;;67423:72:0;;-1:-1:-1;;;;;67423:38:0;;;;;:72;;67462:8;;67472:4;;67478:2;;67482:6;;67490:4;;67423:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67423:72:0;;;;;;;;-1:-1:-1;;67423:72:0;;;;;;;;;;;;:::i;:::-;;;67419:479;;;;:::i;:::-;-1:-1:-1;;;;;;67545:55:0;;-1:-1:-1;;;67545:55:0;67541:154;;67625:50;;-1:-1:-1;;;67625:50:0;;;;;;;:::i;23353:1520::-;23484:7;;24418:66;24405:79;;24401:163;;;-1:-1:-1;24517:1:0;;-1:-1:-1;24521:30:0;24501:51;;24401:163;24678:24;;;24661:14;24678:24;;;;;;;;;34437:25:1;;;34510:4;34498:17;;34478:18;;;34471:45;;;;34532:18;;;34525:34;;;34575:18;;;34568:34;;;24678:24:0;;34409:19:1;;24678:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;24678:24:0;;-1:-1:-1;;24678:24:0;;;-1:-1:-1;;;;;;;24717:20:0;;24713:103;;24770:1;24774:29;24754:50;;;;;;;24713:103;24836:6;-1:-1:-1;24844:20:0;;-1:-1:-1;23353:1520:0;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;293:173:1:-;361:20;;-1:-1:-1;;;;;410:31:1;;400:42;;390:70;;456:1;453;446:12;390:70;293:173;;;:::o;471:254::-;539:6;547;600:2;588:9;579:7;575:23;571:32;568:52;;;616:1;613;606:12;568:52;639:29;658:9;639:29;:::i;:::-;629:39;715:2;700:18;;;;687:32;;-1:-1:-1;;;471:254:1:o;912:131::-;-1:-1:-1;;;;;;986:32:1;;976:43;;966:71;;1033:1;1030;1023:12;1048:245;1106:6;1159:2;1147:9;1138:7;1134:23;1130:32;1127:52;;;1175:1;1172;1165:12;1127:52;1214:9;1201:23;1233:30;1257:5;1233:30;:::i;:::-;1282:5;1048:245;-1:-1:-1;;;1048:245:1:o;1490:186::-;1549:6;1602:2;1590:9;1581:7;1577:23;1573:32;1570:52;;;1618:1;1615;1608:12;1570:52;1641:29;1660:9;1641:29;:::i;1681:250::-;1766:1;1776:113;1790:6;1787:1;1784:13;1776:113;;;1866:11;;;1860:18;1847:11;;;1840:39;1812:2;1805:10;1776:113;;;-1:-1:-1;;1923:1:1;1905:16;;1898:27;1681:250::o;1936:271::-;1978:3;2016:5;2010:12;2043:6;2038:3;2031:19;2059:76;2128:6;2121:4;2116:3;2112:14;2105:4;2098:5;2094:16;2059:76;:::i;:::-;2189:2;2168:15;-1:-1:-1;;2164:29:1;2155:39;;;;2196:4;2151:50;;1936:271;-1:-1:-1;;1936:271:1:o;2212:220::-;2361:2;2350:9;2343:21;2324:4;2381:45;2422:2;2411:9;2407:18;2399:6;2381:45;:::i;2437:180::-;2496:6;2549:2;2537:9;2528:7;2524:23;2520:32;2517:52;;;2565:1;2562;2555:12;2517:52;-1:-1:-1;2588:23:1;;2437:180;-1:-1:-1;2437:180:1:o;2622:248::-;2690:6;2698;2751:2;2739:9;2730:7;2726:23;2722:32;2719:52;;;2767:1;2764;2757:12;2719:52;-1:-1:-1;;2790:23:1;;;2860:2;2845:18;;;2832:32;;-1:-1:-1;2622:248:1:o;2875:127::-;2936:10;2931:3;2927:20;2924:1;2917:31;2967:4;2964:1;2957:15;2991:4;2988:1;2981:15;3007:249;3117:2;3098:13;;-1:-1:-1;;3094:27:1;3082:40;;-1:-1:-1;;;;;3137:34:1;;3173:22;;;3134:62;3131:88;;;3199:18;;:::i;:::-;3235:2;3228:22;-1:-1:-1;;3007:249:1:o;3261:183::-;3321:4;-1:-1:-1;;;;;3346:6:1;3343:30;3340:56;;;3376:18;;:::i;:::-;-1:-1:-1;3421:1:1;3417:14;3433:4;3413:25;;3261:183::o;3449:724::-;3503:5;3556:3;3549:4;3541:6;3537:17;3533:27;3523:55;;3574:1;3571;3564:12;3523:55;3610:6;3597:20;3636:4;3659:43;3699:2;3659:43;:::i;:::-;3731:2;3725:9;3743:31;3771:2;3763:6;3743:31;:::i;:::-;3809:18;;;3901:1;3897:10;;;;3885:23;;3881:32;;;3843:15;;;;-1:-1:-1;3925:15:1;;;3922:35;;;3953:1;3950;3943:12;3922:35;3989:2;3981:6;3977:15;4001:142;4017:6;4012:3;4009:15;4001:142;;;4083:17;;4071:30;;4121:12;;;;4034;;4001:142;;;-1:-1:-1;4161:6:1;3449:724;-1:-1:-1;;;;;;3449:724:1:o;4178:468::-;4242:5;-1:-1:-1;;;;;4268:6:1;4265:30;4262:56;;;4298:18;;:::i;:::-;4347:2;4341:9;4359:69;4416:2;4395:15;;-1:-1:-1;;4391:29:1;4422:4;4387:40;4341:9;4359:69;:::i;:::-;4446:6;4437:15;;4476:6;4468;4461:22;4516:3;4507:6;4502:3;4498:16;4495:25;4492:45;;;4533:1;4530;4523:12;4492:45;4583:6;4578:3;4571:4;4563:6;4559:17;4546:44;4638:1;4631:4;4622:6;4614;4610:19;4606:30;4599:41;;4178:468;;;;;:::o;4651:220::-;4693:5;4746:3;4739:4;4731:6;4727:17;4723:27;4713:55;;4764:1;4761;4754:12;4713:55;4786:79;4861:3;4852:6;4839:20;4832:4;4824:6;4820:17;4786:79;:::i;4876:943::-;5030:6;5038;5046;5054;5062;5115:3;5103:9;5094:7;5090:23;5086:33;5083:53;;;5132:1;5129;5122:12;5083:53;5155:29;5174:9;5155:29;:::i;:::-;5145:39;;5203:38;5237:2;5226:9;5222:18;5203:38;:::i;:::-;5193:48;;5292:2;5281:9;5277:18;5264:32;-1:-1:-1;;;;;5356:2:1;5348:6;5345:14;5342:34;;;5372:1;5369;5362:12;5342:34;5395:61;5448:7;5439:6;5428:9;5424:22;5395:61;:::i;:::-;5385:71;;5509:2;5498:9;5494:18;5481:32;5465:48;;5538:2;5528:8;5525:16;5522:36;;;5554:1;5551;5544:12;5522:36;5577:63;5632:7;5621:8;5610:9;5606:24;5577:63;:::i;:::-;5567:73;;5693:3;5682:9;5678:19;5665:33;5649:49;;5723:2;5713:8;5710:16;5707:36;;;5739:1;5736;5729:12;5707:36;;5762:51;5805:7;5794:8;5783:9;5779:24;5762:51;:::i;:::-;5752:61;;;4876:943;;;;;;;;:::o;6046:733::-;6134:6;6142;6150;6158;6211:2;6199:9;6190:7;6186:23;6182:32;6179:52;;;6227:1;6224;6217:12;6179:52;6267:9;6254:23;-1:-1:-1;;;;;6337:2:1;6329:6;6326:14;6323:34;;;6353:1;6350;6343:12;6323:34;6391:6;6380:9;6376:22;6366:32;;6436:7;6429:4;6425:2;6421:13;6417:27;6407:55;;6458:1;6455;6448:12;6407:55;6498:2;6485:16;6524:2;6516:6;6513:14;6510:34;;;6540:1;6537;6530:12;6510:34;6587:7;6580:4;6571:6;6567:2;6563:15;6559:26;6556:39;6553:59;;;6608:1;6605;6598:12;6553:59;6639:4;6631:13;;;;6663:6;;-1:-1:-1;6701:20:1;;;6688:34;;6769:2;6754:18;6741:32;;-1:-1:-1;6046:733:1;;-1:-1:-1;;;;6046:733:1:o;6784:1208::-;6902:6;6910;6963:2;6951:9;6942:7;6938:23;6934:32;6931:52;;;6979:1;6976;6969:12;6931:52;7019:9;7006:23;-1:-1:-1;;;;;7089:2:1;7081:6;7078:14;7075:34;;;7105:1;7102;7095:12;7075:34;7143:6;7132:9;7128:22;7118:32;;7188:7;7181:4;7177:2;7173:13;7169:27;7159:55;;7210:1;7207;7200:12;7159:55;7246:2;7233:16;7268:4;7291:43;7331:2;7291:43;:::i;:::-;7363:2;7357:9;7375:31;7403:2;7395:6;7375:31;:::i;:::-;7441:18;;;7529:1;7525:10;;;;7517:19;;7513:28;;;7475:15;;;;-1:-1:-1;7553:19:1;;;7550:39;;;7585:1;7582;7575:12;7550:39;7609:11;;;;7629:148;7645:6;7640:3;7637:15;7629:148;;;7711:23;7730:3;7711:23;:::i;:::-;7699:36;;7662:12;;;;7755;;;;7629:148;;;7796:6;-1:-1:-1;;7840:18:1;;7827:32;;-1:-1:-1;;7871:16:1;;;7868:36;;;7900:1;7897;7890:12;7868:36;;7923:63;7978:7;7967:8;7956:9;7952:24;7923:63;:::i;:::-;7913:73;;;6784:1208;;;;;:::o;7997:435::-;8050:3;8088:5;8082:12;8115:6;8110:3;8103:19;8141:4;8170:2;8165:3;8161:12;8154:19;;8207:2;8200:5;8196:14;8228:1;8238:169;8252:6;8249:1;8246:13;8238:169;;;8313:13;;8301:26;;8347:12;;;;8382:15;;;;8274:1;8267:9;8238:169;;;-1:-1:-1;8423:3:1;;7997:435;-1:-1:-1;;;;;7997:435:1:o;8437:261::-;8616:2;8605:9;8598:21;8579:4;8636:56;8688:2;8677:9;8673:18;8665:6;8636:56;:::i;8703:532::-;8889:6;8874:22;;8878:9;8973:6;8847:4;9007:222;9021:6;9018:1;9015:13;9007:222;;;9086:13;;-1:-1:-1;;;;;9082:39:1;9070:52;;9145:4;9169:12;;;;9204:15;;;;9118:1;9036:9;9007:222;;;9011:3;;;8703:532;;;;:::o;9448:669::-;9575:6;9583;9591;9644:2;9632:9;9623:7;9619:23;9615:32;9612:52;;;9660:1;9657;9650:12;9612:52;9683:29;9702:9;9683:29;:::i;:::-;9673:39;;9763:2;9752:9;9748:18;9735:32;-1:-1:-1;;;;;9827:2:1;9819:6;9816:14;9813:34;;;9843:1;9840;9833:12;9813:34;9866:61;9919:7;9910:6;9899:9;9895:22;9866:61;:::i;:::-;9856:71;;9980:2;9969:9;9965:18;9952:32;9936:48;;10009:2;9999:8;9996:16;9993:36;;;10025:1;10022;10015:12;9993:36;;10048:63;10103:7;10092:8;10081:9;10077:24;10048:63;:::i;:::-;10038:73;;;9448:669;;;;;:::o;10122:450::-;10191:6;10244:2;10232:9;10223:7;10219:23;10215:32;10212:52;;;10260:1;10257;10250:12;10212:52;10300:9;10287:23;-1:-1:-1;;;;;10325:6:1;10322:30;10319:50;;;10365:1;10362;10355:12;10319:50;10388:22;;10441:4;10433:13;;10429:27;-1:-1:-1;10419:55:1;;10470:1;10467;10460:12;10419:55;10493:73;10558:7;10553:2;10540:16;10535:2;10531;10527:11;10493:73;:::i;:::-;10483:83;10122:450;-1:-1:-1;;;;10122:450:1:o;10577:422::-;10670:6;10678;10731:2;10719:9;10710:7;10706:23;10702:32;10699:52;;;10747:1;10744;10737:12;10699:52;10770:29;10789:9;10770:29;:::i;:::-;10760:39;;10850:2;10839:9;10835:18;10822:32;-1:-1:-1;;;;;10869:6:1;10866:30;10863:50;;;10909:1;10906;10899:12;10863:50;10932:61;10985:7;10976:6;10965:9;10961:22;10932:61;:::i;11004:347::-;11069:6;11077;11130:2;11118:9;11109:7;11105:23;11101:32;11098:52;;;11146:1;11143;11136:12;11098:52;11169:29;11188:9;11169:29;:::i;:::-;11159:39;;11248:2;11237:9;11233:18;11220:32;11295:5;11288:13;11281:21;11274:5;11271:32;11261:60;;11317:1;11314;11307:12;11261:60;11340:5;11330:15;;;11004:347;;;;;:::o;11356:260::-;11424:6;11432;11485:2;11473:9;11464:7;11460:23;11456:32;11453:52;;;11501:1;11498;11491:12;11453:52;11524:29;11543:9;11524:29;:::i;:::-;11514:39;;11572:38;11606:2;11595:9;11591:18;11572:38;:::i;:::-;11562:48;;11356:260;;;;;:::o;11621:606::-;11725:6;11733;11741;11749;11757;11810:3;11798:9;11789:7;11785:23;11781:33;11778:53;;;11827:1;11824;11817:12;11778:53;11850:29;11869:9;11850:29;:::i;:::-;11840:39;;11898:38;11932:2;11921:9;11917:18;11898:38;:::i;:::-;11888:48;;11983:2;11972:9;11968:18;11955:32;11945:42;;12034:2;12023:9;12019:18;12006:32;11996:42;;12089:3;12078:9;12074:19;12061:33;-1:-1:-1;;;;;12109:6:1;12106:30;12103:50;;;12149:1;12146;12139:12;12103:50;12172:49;12213:7;12204:6;12193:9;12189:22;12172:49;:::i;12232:322::-;12309:6;12317;12325;12378:2;12366:9;12357:7;12353:23;12349:32;12346:52;;;12394:1;12391;12384:12;12346:52;12417:29;12436:9;12417:29;:::i;:::-;12407:39;12493:2;12478:18;;12465:32;;-1:-1:-1;12544:2:1;12529:18;;;12516:32;;12232:322;-1:-1:-1;;;12232:322:1:o;13328:127::-;13389:10;13384:3;13380:20;13377:1;13370:31;13420:4;13417:1;13410:15;13444:4;13441:1;13434:15;13460:380;13539:1;13535:12;;;;13582;;;13603:61;;13657:4;13649:6;13645:17;13635:27;;13603:61;13710:2;13702:6;13699:14;13679:18;13676:38;13673:161;;13756:10;13751:3;13747:20;13744:1;13737:31;13791:4;13788:1;13781:15;13819:4;13816:1;13809:15;13673:161;;13460:380;;;:::o;14322:722::-;14372:3;14413:5;14407:12;14442:36;14468:9;14442:36;:::i;:::-;14497:1;14514:18;;;14541:133;;;;14688:1;14683:355;;;;14507:531;;14541:133;-1:-1:-1;;14574:24:1;;14562:37;;14647:14;;14640:22;14628:35;;14619:45;;;-1:-1:-1;14541:133:1;;14683:355;14714:5;14711:1;14704:16;14743:4;14788:2;14785:1;14775:16;14813:1;14827:165;14841:6;14838:1;14835:13;14827:165;;;14919:14;;14906:11;;;14899:35;14962:16;;;;14856:10;;14827:165;;;14831:3;;;15021:6;15016:3;15012:16;15005:23;;14507:531;;;;;14322:722;;;;:::o;15049:469::-;15270:3;15298:38;15332:3;15324:6;15298:38;:::i;:::-;15365:6;15359:13;15381:65;15439:6;15435:2;15428:4;15420:6;15416:17;15381:65;:::i;:::-;15462:50;15504:6;15500:2;15496:15;15488:6;15462:50;:::i;:::-;15455:57;15049:469;-1:-1:-1;;;;;;;15049:469:1:o;15523:127::-;15584:10;15579:3;15575:20;15572:1;15565:31;15615:4;15612:1;15605:15;15639:4;15636:1;15629:15;15655:168;15728:9;;;15759;;15776:15;;;15770:22;;15756:37;15746:71;;15797:18;;:::i;15960:217::-;16000:1;16026;16016:132;;16070:10;16065:3;16061:20;16058:1;16051:31;16105:4;16102:1;16095:15;16133:4;16130:1;16123:15;16016:132;-1:-1:-1;16162:9:1;;15960:217::o;16601:135::-;16640:3;16661:17;;;16658:43;;16681:18;;:::i;:::-;-1:-1:-1;16728:1:1;16717:13;;16601:135::o;18714:545::-;18816:2;18811:3;18808:11;18805:448;;;18852:1;18877:5;18873:2;18866:17;18922:4;18918:2;18908:19;18992:2;18980:10;18976:19;18973:1;18969:27;18963:4;18959:38;19028:4;19016:10;19013:20;19010:47;;;-1:-1:-1;19051:4:1;19010:47;19106:2;19101:3;19097:12;19094:1;19090:20;19084:4;19080:31;19070:41;;19161:82;19179:2;19172:5;19169:13;19161:82;;;19224:17;;;19205:1;19194:13;19161:82;;19435:1352;19561:3;19555:10;-1:-1:-1;;;;;19580:6:1;19577:30;19574:56;;;19610:18;;:::i;:::-;19639:97;19729:6;19689:38;19721:4;19715:11;19689:38;:::i;:::-;19683:4;19639:97;:::i;:::-;19791:4;;19855:2;19844:14;;19872:1;19867:663;;;;20574:1;20591:6;20588:89;;;-1:-1:-1;20643:19:1;;;20637:26;20588:89;-1:-1:-1;;19392:1:1;19388:11;;;19384:24;19380:29;19370:40;19416:1;19412:11;;;19367:57;20690:81;;19837:944;;19867:663;14269:1;14262:14;;;14306:4;14293:18;;-1:-1:-1;;19903:20:1;;;20021:236;20035:7;20032:1;20029:14;20021:236;;;20124:19;;;20118:26;20103:42;;20216:27;;;;20184:1;20172:14;;;;20051:19;;20021:236;;;20025:3;20285:6;20276:7;20273:19;20270:201;;;20346:19;;;20340:26;-1:-1:-1;;20429:1:1;20425:14;;;20441:3;20421:24;20417:37;20413:42;20398:58;20383:74;;20270:201;-1:-1:-1;;;;;20517:1:1;20501:14;;;20497:22;20484:36;;-1:-1:-1;19435:1352:1:o;21548:184::-;21618:6;21671:2;21659:9;21650:7;21646:23;21642:32;21639:52;;;21687:1;21684;21677:12;21639:52;-1:-1:-1;21710:16:1;;21548:184;-1:-1:-1;21548:184:1:o;24599:404::-;24801:2;24783:21;;;24840:2;24820:18;;;24813:30;24879:34;24874:2;24859:18;;24852:62;-1:-1:-1;;;24945:2:1;24930:18;;24923:38;24993:3;24978:19;;24599:404::o;25008:401::-;25210:2;25192:21;;;25249:2;25229:18;;;25222:30;25288:34;25283:2;25268:18;;25261:62;-1:-1:-1;;;25354:2:1;25339:18;;25332:35;25399:3;25384:19;;25008:401::o;25414:406::-;25616:2;25598:21;;;25655:2;25635:18;;;25628:30;25694:34;25689:2;25674:18;;25667:62;-1:-1:-1;;;25760:2:1;25745:18;;25738:40;25810:3;25795:19;;25414:406::o;25825:465::-;26082:2;26071:9;26064:21;26045:4;26108:56;26160:2;26149:9;26145:18;26137:6;26108:56;:::i;:::-;26212:9;26204:6;26200:22;26195:2;26184:9;26180:18;26173:50;26240:44;26277:6;26269;26240:44;:::i;:::-;26232:52;25825:465;-1:-1:-1;;;;;25825:465:1:o;26680:397::-;26882:2;26864:21;;;26921:2;26901:18;;;26894:30;26960:34;26955:2;26940:18;;26933:62;-1:-1:-1;;;27026:2:1;27011:18;;27004:31;27067:3;27052:19;;26680:397::o;28048:399::-;28250:2;28232:21;;;28289:2;28269:18;;;28262:30;28328:34;28323:2;28308:18;;28301:62;-1:-1:-1;;;28394:2:1;28379:18;;28372:33;28437:3;28422:19;;28048:399::o;28452:400::-;28654:2;28636:21;;;28693:2;28673:18;;;28666:30;28732:34;28727:2;28712:18;;28705:62;-1:-1:-1;;;28798:2:1;28783:18;;28776:34;28842:3;28827:19;;28452:400::o;29620:827::-;-1:-1:-1;;;;;30017:15:1;;;29999:34;;30069:15;;30064:2;30049:18;;30042:43;29979:3;30116:2;30101:18;;30094:31;;;29942:4;;30148:57;;30185:19;;30177:6;30148:57;:::i;:::-;30253:9;30245:6;30241:22;30236:2;30225:9;30221:18;30214:50;30287:44;30324:6;30316;30287:44;:::i;:::-;30273:58;;30380:9;30372:6;30368:22;30362:3;30351:9;30347:19;30340:51;30408:33;30434:6;30426;30408:33;:::i;:::-;30400:41;29620:827;-1:-1:-1;;;;;;;;29620:827:1:o;30452:249::-;30521:6;30574:2;30562:9;30553:7;30549:23;30545:32;30542:52;;;30590:1;30587;30580:12;30542:52;30622:9;30616:16;30641:30;30665:5;30641:30;:::i;30706:179::-;30741:3;30783:1;30765:16;30762:23;30759:120;;;30829:1;30826;30823;30808:23;-1:-1:-1;30866:1:1;30860:8;30855:3;30851:18;30759:120;30706:179;:::o;30890:671::-;30929:3;30971:4;30953:16;30950:26;30947:39;;;30890:671;:::o;30947:39::-;31013:2;31007:9;-1:-1:-1;;31078:16:1;31074:25;;31071:1;31007:9;31050:50;31129:4;31123:11;31153:16;-1:-1:-1;;;;;31259:2:1;31252:4;31244:6;31240:17;31237:25;31232:2;31224:6;31221:14;31218:45;31215:58;;;31266:5;;;;;30890:671;:::o;31215:58::-;31303:6;31297:4;31293:17;31282:28;;31339:3;31333:10;31366:2;31358:6;31355:14;31352:27;;;31372:5;;;;;;30890:671;:::o;31352:27::-;31456:2;31437:16;31431:4;31427:27;31423:36;31416:4;31407:6;31402:3;31398:16;31394:27;31391:69;31388:82;;;31463:5;;;;;;30890:671;:::o;31388:82::-;31479:57;31530:4;31521:6;31513;31509:19;31505:30;31499:4;31479:57;:::i;:::-;-1:-1:-1;31552:3:1;;30890:671;-1:-1:-1;;;;;30890:671:1:o;31987:404::-;32189:2;32171:21;;;32228:2;32208:18;;;32201:30;32267:34;32262:2;32247:18;;32240:62;-1:-1:-1;;;32333:2:1;32318:18;;32311:38;32381:3;32366:19;;31987:404::o;32396:127::-;32457:10;32452:3;32448:20;32445:1;32438:31;32488:4;32485:1;32478:15;32512:4;32509:1;32502:15;33644:561;-1:-1:-1;;;;;33941:15:1;;;33923:34;;33993:15;;33988:2;33973:18;;33966:43;34040:2;34025:18;;34018:34;;;34083:2;34068:18;;34061:34;;;33903:3;34126;34111:19;;34104:32;;;33866:4;;34153:46;;34179:19;;34171:6;34153:46;:::i

ipfs://74e05272ac3a21e358adb5ba7a9cbfbedcb770a709a4dd5fbe75b408f3301a00