Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC5267
•    - function eip712Domain()
• library StorageSlot
•    - function getAddressSlot(bytes32 slot)
•    - function getBooleanSlot(bytes32 slot)
•    - function getBytes32Slot(bytes32 slot)
•    - function getUint256Slot(bytes32 slot)
•    - function getStringSlot(bytes32 slot)
•    - function getStringSlot(string storage ...
•    - function getBytesSlot(bytes32 slot)
•    - function getBytesSlot(bytes storage s ...
• library ShortStrings
•    - function toShortString(string memory ...
•    - function toString(ShortString sstr)
•    - function byteLength(ShortString sstr)
•    - function toShortStringWithFallback(st ...
•    - function toStringWithFallback(ShortSt ...
•    - function byteLengthWithFallback(Short ...
• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toString(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(bytes32 hash, uin ...
•    - function recover(bytes32 hash, uint8 ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function toDataWithIntendedValidatorH ...
•    - function _domainSeparatorV4()
•    - function _buildDomainSeparator()
•    - function _hashTypedDataV4(bytes32 str ...
•    - function eip712Domain()
•  contract CUBE_Tx_Handler is EIP712 *
•    - function getNonce(address from)
•    - function verify(ForwardRequest callda ...
•    - function execute(ForwardRequest calld ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2023-09-29
*/

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


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

pragma solidity ^0.8.0;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

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


// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.9.0) (utils/ShortStrings.sol)

pragma solidity ^0.8.8;


// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |
// | length  | 0x                                                              BB |
type ShortString is bytes32;

/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 *
 * Strings of arbitrary length can be optimized using this library if
 * they are short enough (up to 31 bytes) by packing them with their
 * length (1 byte) in a single EVM word (32 bytes). Additionally, a
 * fallback mechanism can be used for every other case.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
library ShortStrings {
    // Used as an identifier for strings longer than 31 bytes.
    bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;

    error StringTooLong(string str);
    error InvalidShortString();

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = byteLength(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function byteLength(ShortString sstr) internal pure returns (uint256) {
        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
        if (result > 31) {
            revert InvalidShortString();
        }
        return result;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(_FALLBACK_SENTINEL);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
            return toString(value);
        } else {
            return store;
        }
    }

    /**
     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     *
     * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
     */
    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
        if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
            return byteLength(value);
        } else {
            return bytes(store).length;
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.9.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) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 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 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.9.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 `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        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);
    }

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.9.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 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @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 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/EIP712.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.8;




/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * _Available since v3.4._
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant _TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {EIP-5267}.
     *
     * _Available since v4.9._
     */
    function eip712Domain()
        public
        view
        virtual
        override
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _name.toStringWithFallback(_nameFallback),
            _version.toStringWithFallback(_versionFallback),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }
}

// File: @openzeppelin/contracts/utils/cryptography/draft-EIP712.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

// EIP-712 is Final as of 2022-08-11. This file is deprecated.


// File: CUBE_Tx_Handler.sol


// OpenZeppelin Contracts v4.4.1 (metatx/MinimalForwarder.sol)

pragma solidity ^0.8.0;



/**
 * @dev Simple minimal forwarder to be used together with an ERC2771 compatible contract. See {ERC2771Context}.
 */
contract CUBE_Tx_Handler is EIP712 {
    using ECDSA for bytes32;

    struct ForwardRequest {
        address from;
        address to;
        uint256 value;
        uint256 gas;
        uint256 nonce;
        bytes data;
    }

    bytes32 private constant _TYPEHASH =
        keccak256("ForwardRequest(address from,address to,uint256 value,uint256 gas,uint256 nonce,bytes data)");

    mapping(address => uint256) private _nonces;

    constructor() EIP712("CUBE_Tx_Handler", "1.0.0") {}

    function getNonce(address from) public view returns (uint256) {
        return _nonces[from];
    }

    function verify(ForwardRequest calldata req, bytes calldata signature) public view returns (bool) {
        address signer = _hashTypedDataV4(
            keccak256(abi.encode(_TYPEHASH, req.from, req.to, req.value, req.gas, req.nonce, keccak256(req.data)))
        ).recover(signature);
        return _nonces[req.from] == req.nonce && signer == req.from;
    }

    function execute(ForwardRequest calldata req, bytes calldata signature)
        public
        payable
        returns (bool, bytes memory)
    {
        require(verify(req, signature), "CUBE_Tx_Handler: signature does not match request");
        _nonces[req.from] = req.nonce + 1;

        (bool success, bytes memory returndata) = req.to.call{gas: req.gas, value: req.value}(
            abi.encodePacked(req.data, req.from)
        );
        // Validate that the relayer has sent enough gas for the call.
        // See https://ronan.eth.link/blog/ethereum-gas-dangers/
        assert(gasleft() > req.gas / 63);

        return (success, returndata);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"gas","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct CUBE_Tx_Handler.ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"execute","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"gas","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct CUBE_Tx_Handler.ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

0x60806040526004361061003f5760003560e01c80632d0335ab1461004457806347153f821461008157806384b0196e146100b2578063bf5d3bdb146100e3575b600080fd5b34801561005057600080fd5b5061006b60048036038101906100669190610c18565b610120565b6040516100789190610c5e565b60405180910390f35b61009b60048036038101906100969190610d02565b610169565b6040516100a9929190610e29565b60405180910390f35b3480156100be57600080fd5b506100c761031c565b6040516100da9796959493929190610fcf565b60405180910390f35b3480156100ef57600080fd5b5061010a60048036038101906101059190610d02565b61041e565b6040516101179190611053565b60405180910390f35b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6000606061017885858561041e565b6101b7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016101ae906110e0565b60405180910390fd5b600185608001356101c8919061112f565b600260008760000160208101906101df9190610c18565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506000808660200160208101906102339190610c18565b73ffffffffffffffffffffffffffffffffffffffff1687606001358860400135898060a001906102639190611172565b8b60000160208101906102769190610c18565b6040516020016102889392919061125c565b6040516020818303038152906040526040516102a491906112b7565b600060405180830381858888f193505050503d80600081146102e2576040519150601f19603f3d011682016040523d82523d6000602084013e6102e7565b606091505b5091509150603f87606001356102fd91906112fd565b5a1161030c5761030b61132e565b5b8181935093505050935093915050565b60006060806000806000606061035c60007f435542455f54785f48616e646c6572000000000000000000000000000000000f6105d490919063ffffffff16565b61039060017f312e302e300000000000000000000000000000000000000000000000000000056105d490919063ffffffff16565b46306000801b600067ffffffffffffffff8111156103b1576103b061135d565b5b6040519080825280602002602001820160405280156103df5781602001602082028036833780820191505090505b507f0f00000000000000000000000000000000000000000000000000000000000000959493929190965096509650965096509650965090919293949596565b60008061052784848080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050506105197fdd8f4b70b0f4393e889bd39128a30628a78b61816a9eb8199759e7a349657e488860000160208101906104a09190610c18565b8960200160208101906104b39190610c18565b8a604001358b606001358c608001358d8060a001906104d29190611172565b6040516104e092919061138c565b60405180910390206040516020016104fe97969594939291906113a5565b60405160208183030381529060405280519060200120610684565b61069e90919063ffffffff16565b90508460800135600260008760000160208101906105459190610c18565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020541480156105ca575084600001602081019061059b9190610c18565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b9150509392505050565b606060ff60001b83146105f1576105ea836106c5565b905061067e565b8180546105fd90611443565b80601f016020809104026020016040519081016040528092919081815260200182805461062990611443565b80156106765780601f1061064b57610100808354040283529160200191610676565b820191906000526020600020905b81548152906001019060200180831161065957829003601f168201915b505050505090505b92915050565b6000610697610691610739565b836107f0565b9050919050565b60008060006106ad8585610831565b915091506106ba81610882565b819250505092915050565b606060006106d2836109e8565b90506000602067ffffffffffffffff8111156106f1576106f061135d565b5b6040519080825280601f01601f1916602001820160405280156107235781602001600182028036833780820191505090505b5090508181528360208201528092505050919050565b60007f00000000000000000000000020723de8e6ab77181bef9478f7c3cf4f44698e6973ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161480156107b557507f000000000000000000000000000000000000000000000000000000000000008946145b156107e2577f249720db78584835e023c63dea1118984cdcb15aec2395c497c5776cbe1b696590506107ed565b6107ea610a38565b90505b90565b60006040517f190100000000000000000000000000000000000000000000000000000000000081528360028201528260228201526042812091505092915050565b60008060418351036108725760008060006020860151925060408601519150606086015160001a905061086687828585610ace565b9450945050505061087b565b60006002915091505b9250929050565b6000600481111561089657610895611474565b5b8160048111156108a9576108a8611474565b5b03156109e557600160048111156108c3576108c2611474565b5b8160048111156108d6576108d5611474565b5b03610916576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090d906114ef565b60405180910390fd5b6002600481111561092a57610929611474565b5b81600481111561093d5761093c611474565b5b0361097d576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109749061155b565b60405180910390fd5b6003600481111561099157610990611474565b5b8160048111156109a4576109a3611474565b5b036109e4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109db906115ed565b60405180910390fd5b5b50565b60008060ff8360001c169050601f811115610a2f576040517fb3512b0c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80915050919050565b60007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f7f10d4a16396b4d986f48619abec0e4ca7b0b28283171a7a0a3e0070811d9dc9467f06c015bd22b4c69690933c1058878ebdfef31f9aaae40bbe86d8a09fe1b2972c4630604051602001610ab395949392919061160d565b60405160208183030381529060405280519060200120905090565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08360001c1115610b09576000600391509150610ba7565b600060018787878760405160008152602001604052604051610b2e949392919061167c565b6020604051602081039080840390855afa158015610b50573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610b9e57600060019250925050610ba7565b80600092509250505b94509492505050565b600080fd5b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000610be582610bba565b9050919050565b610bf581610bda565b8114610c0057600080fd5b50565b600081359050610c1281610bec565b92915050565b600060208284031215610c2e57610c2d610bb0565b5b6000610c3c84828501610c03565b91505092915050565b6000819050919050565b610c5881610c45565b82525050565b6000602082019050610c736000830184610c4f565b92915050565b600080fd5b600060c08284031215610c9457610c93610c79565b5b81905092915050565b600080fd5b600080fd5b600080fd5b60008083601f840112610cc257610cc1610c9d565b5b8235905067ffffffffffffffff811115610cdf57610cde610ca2565b5b602083019150836001820283011115610cfb57610cfa610ca7565b5b9250929050565b600080600060408486031215610d1b57610d1a610bb0565b5b600084013567ffffffffffffffff811115610d3957610d38610bb5565b5b610d4586828701610c7e565b935050602084013567ffffffffffffffff811115610d6657610d65610bb5565b5b610d7286828701610cac565b92509250509250925092565b60008115159050919050565b610d9381610d7e565b82525050565b600081519050919050565b600082825260208201905092915050565b60005b83811015610dd3578082015181840152602081019050610db8565b60008484015250505050565b6000601f19601f8301169050919050565b6000610dfb82610d99565b610e058185610da4565b9350610e15818560208601610db5565b610e1e81610ddf565b840191505092915050565b6000604082019050610e3e6000830185610d8a565b8181036020830152610e508184610df0565b90509392505050565b60007fff0000000000000000000000000000000000000000000000000000000000000082169050919050565b610e8e81610e59565b82525050565b600081519050919050565b600082825260208201905092915050565b6000610ebb82610e94565b610ec58185610e9f565b9350610ed5818560208601610db5565b610ede81610ddf565b840191505092915050565b610ef281610bda565b82525050565b6000819050919050565b610f0b81610ef8565b82525050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b610f4681610c45565b82525050565b6000610f588383610f3d565b60208301905092915050565b6000602082019050919050565b6000610f7c82610f11565b610f868185610f1c565b9350610f9183610f2d565b8060005b83811015610fc2578151610fa98882610f4c565b9750610fb483610f64565b925050600181019050610f95565b5085935050505092915050565b600060e082019050610fe4600083018a610e85565b8181036020830152610ff68189610eb0565b9050818103604083015261100a8188610eb0565b90506110196060830187610c4f565b6110266080830186610ee9565b61103360a0830185610f02565b81810360c08301526110458184610f71565b905098975050505050505050565b60006020820190506110686000830184610d8a565b92915050565b7f435542455f54785f48616e646c65723a207369676e617475726520646f65732060008201527f6e6f74206d617463682072657175657374000000000000000000000000000000602082015250565b60006110ca603183610e9f565b91506110d58261106e565b604082019050919050565b600060208201905081810360008301526110f9816110bd565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061113a82610c45565b915061114583610c45565b925082820190508082111561115d5761115c611100565b5b92915050565b600080fd5b600080fd5b600080fd5b6000808335600160200384360303811261118f5761118e611163565b5b80840192508235915067ffffffffffffffff8211156111b1576111b0611168565b5b6020830192506001820236038313156111cd576111cc61116d565b5b509250929050565b600081905092915050565b82818337600083830152505050565b60006111fb83856111d5565b93506112088385846111e0565b82840190509392505050565b60008160601b9050919050565b600061122c82611214565b9050919050565b600061123e82611221565b9050919050565b61125661125182610bda565b611233565b82525050565b60006112698285876111ef565b91506112758284611245565b601482019150819050949350505050565b600061129182610d99565b61129b81856111d5565b93506112ab818560208601610db5565b80840191505092915050565b60006112c38284611286565b915081905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b600061130882610c45565b915061131383610c45565b925082611323576113226112ce565b5b828204905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006113998284866111ef565b91508190509392505050565b600060e0820190506113ba600083018a610f02565b6113c76020830189610ee9565b6113d46040830188610ee9565b6113e16060830187610c4f565b6113ee6080830186610c4f565b6113fb60a0830185610c4f565b61140860c0830184610f02565b98975050505050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b6000600282049050600182168061145b57607f821691505b60208210810361146e5761146d611414565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f45434453413a20696e76616c6964207369676e61747572650000000000000000600082015250565b60006114d9601883610e9f565b91506114e4826114a3565b602082019050919050565b60006020820190508181036000830152611508816114cc565b9050919050565b7f45434453413a20696e76616c6964207369676e6174757265206c656e67746800600082015250565b6000611545601f83610e9f565b91506115508261150f565b602082019050919050565b6000602082019050818103600083015261157481611538565b9050919050565b7f45434453413a20696e76616c6964207369676e6174757265202773272076616c60008201527f7565000000000000000000000000000000000000000000000000000000000000602082015250565b60006115d7602283610e9f565b91506115e28261157b565b604082019050919050565b60006020820190508181036000830152611606816115ca565b9050919050565b600060a0820190506116226000830188610f02565b61162f6020830187610f02565b61163c6040830186610f02565b6116496060830185610c4f565b6116566080830184610ee9565b9695505050505050565b600060ff82169050919050565b61167681611660565b82525050565b60006080820190506116916000830187610f02565b61169e602083018661166d565b6116ab6040830185610f02565b6116b86060830184610f02565b9594505050505056fea26469706673582212208e69669cacb1c47d6daaded27548214a19f822fd9c52756c9434aea6606319a464736f6c63430008130033

42416:1680:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42932:101;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43416:677;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;41240:657;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;43041:367;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42932:101;42985:7;43012;:13;43020:4;43012:13;;;;;;;;;;;;;;;;43005:20;;42932:101;;;:::o;43416:677::-;43539:4;43545:12;43583:22;43590:3;43595:9;;43583:6;:22::i;:::-;43575:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;43702:1;43690:3;:9;;;:13;;;;:::i;:::-;43670:7;:17;43678:3;:8;;;;;;;;;;:::i;:::-;43670:17;;;;;;;;;;;;;;;:33;;;;43717:12;43731:23;43758:3;:6;;;;;;;;;;:::i;:::-;:11;;43775:3;:7;;;43791:3;:9;;;43833:3;:8;;;;;;;;:::i;:::-;43843:3;:8;;;;;;;;;;:::i;:::-;43816:36;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;43758:105;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43716:147;;;;44041:2;44031:3;:7;;;:12;;;;:::i;:::-;44019:9;:24;44012:32;;;;:::i;:::-;;44065:7;44074:10;44057:28;;;;;;43416:677;;;;;;:::o;41240:657::-;41361:13;41389:18;41422:21;41458:15;41488:25;41528:12;41555:27;41663:41;41690:13;41663:5;:26;;:41;;;;:::i;:::-;41719:47;41749:16;41719:8;:29;;:47;;;;:::i;:::-;41781:13;41817:4;41845:1;41837:10;;41876:1;41862:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41610:279;;;;;;;;;;;;;;;;;;;;;41240:657;;;;;;;:::o;43041:367::-;43133:4;43150:14;43167:163;43320:9;;43167:163;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:144;42709:103;43230:3;:8;;;;;;;;;;:::i;:::-;43240:3;:6;;;;;;;;;;:::i;:::-;43248:3;:9;;;43259:3;:7;;;43268:3;:9;;;43289:3;:8;;;;;;;;:::i;:::-;43279:19;;;;;;;:::i;:::-;;;;;;;;43208:91;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;43198:102;;;;;;43167:16;:144::i;:::-;:152;;:163;;;;:::i;:::-;43150:180;;43369:3;:9;;;43348:7;:17;43356:3;:8;;;;;;;;;;:::i;:::-;43348:17;;;;;;;;;;;;;;;;:30;:52;;;;;43392:3;:8;;;;;;;;;;:::i;:::-;43382:18;;:6;:18;;;43348:52;43341:59;;;43041:367;;;;;:::o;8536:274::-;8630:13;6481:66;8689:18;;8679:5;8660:47;8656:147;;8731:15;8740:5;8731:8;:15::i;:::-;8724:22;;;;8656:147;8786:5;8779:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8536:274;;;;;:::o;40978:167::-;41055:7;41082:55;41104:20;:18;:20::i;:::-;41126:10;41082:21;:55::i;:::-;41075:62;;40978:167;;;:::o;30557:231::-;30635:7;30656:17;30675:18;30697:27;30708:4;30714:9;30697:10;:27::i;:::-;30655:69;;;;30735:18;30747:5;30735:11;:18::i;:::-;30771:9;30764:16;;;;30557:231;;;;:::o;7190:415::-;7249:13;7275:11;7289:16;7300:4;7289:10;:16::i;:::-;7275:30;;7395:17;7426:2;7415:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7395:34;;7520:3;7515;7508:16;7561:4;7554;7549:3;7545:14;7538:28;7594:3;7587:10;;;;7190:415;;;:::o;39878:268::-;39931:7;39972:11;39955:28;;39963:4;39955:28;;;:63;;;;;40004:14;39987:13;:31;39955:63;39951:188;;;40042:22;40035:29;;;;39951:188;40104:23;:21;:23::i;:::-;40097:30;;39878:268;;:::o;35341:406::-;35434:12;35544:4;35538:11;35575:10;35570:3;35563:23;35623:15;35616:4;35611:3;35607:14;35600:39;35676:10;35669:4;35664:3;35660:14;35653:34;35724:4;35719:3;35709:20;35701:28;;35512:228;35341:406;;;;:::o;29008:747::-;29089:7;29098:12;29147:2;29127:9;:16;:22;29123:625;;29166:9;29190;29214:7;29471:4;29460:9;29456:20;29450:27;29445:32;;29521:4;29510:9;29506:20;29500:27;29495:32;;29579:4;29568:9;29564:20;29558:27;29555:1;29550:36;29545:41;;29622:25;29633:4;29639:1;29642;29645;29622:10;:25::i;:::-;29615:32;;;;;;;;;29123:625;29696:1;29700:35;29680:56;;;;29008:747;;;;;;:::o;27401:521::-;27479:20;27470:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;27466:449;27516:7;27466:449;27577:29;27568:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;27564:351;;27623:34;;;;;;;;;;:::i;:::-;;;;;;;;27564:351;27688:35;27679:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;27675:240;;27740:41;;;;;;;;;;:::i;:::-;;;;;;;;27675:240;27812:30;27803:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;27799:116;;27859:44;;;;;;;;;;:::i;:::-;;;;;;;;27799:116;27401:521;;:::o;7682:251::-;7743:7;7763:14;7816:4;7807;7780:33;;:40;7763:57;;7844:2;7835:6;:11;7831:71;;;7870:20;;;;;;;;;;;;;;7831:71;7919:6;7912:13;;;7682:251;;;:::o;40154:182::-;40209:7;38070:95;40269:11;40282:14;40298:13;40321:4;40246:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;40236:92;;;;;;40229:99;;40154:182;:::o;31941:1477::-;32029:7;32038:12;32963:66;32958:1;32950:10;;:79;32946:163;;;33062:1;33066:30;33046:51;;;;;;32946:163;33206:14;33223:24;33233:4;33239:1;33242;33245;33223:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33206:41;;33280:1;33262:20;;:6;:20;;;33258:103;;33315:1;33319:29;33299:50;;;;;;;33258:103;33381:6;33389:20;33373:37;;;;;31941:1477;;;;;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:117::-;1720:1;1717;1710:12;1779:239;1859:5;1900:3;1891:6;1886:3;1882:16;1878:26;1875:113;;;1907:79;;:::i;:::-;1875:113;2006:6;1997:15;;1779:239;;;;:::o;2024:117::-;2133:1;2130;2123:12;2147:117;2256:1;2253;2246:12;2270:117;2379:1;2376;2369:12;2406:552;2463:8;2473:6;2523:3;2516:4;2508:6;2504:17;2500:27;2490:122;;2531:79;;:::i;:::-;2490:122;2644:6;2631:20;2621:30;;2674:18;2666:6;2663:30;2660:117;;;2696:79;;:::i;:::-;2660:117;2810:4;2802:6;2798:17;2786:29;;2864:3;2856:4;2848:6;2844:17;2834:8;2830:32;2827:41;2824:128;;;2871:79;;:::i;:::-;2824:128;2406:552;;;;;:::o;2964:900::-;3077:6;3085;3093;3142:2;3130:9;3121:7;3117:23;3113:32;3110:119;;;3148:79;;:::i;:::-;3110:119;3296:1;3285:9;3281:17;3268:31;3326:18;3318:6;3315:30;3312:117;;;3348:79;;:::i;:::-;3312:117;3453:87;3532:7;3523:6;3512:9;3508:22;3453:87;:::i;:::-;3443:97;;3239:311;3617:2;3606:9;3602:18;3589:32;3648:18;3640:6;3637:30;3634:117;;;3670:79;;:::i;:::-;3634:117;3783:64;3839:7;3830:6;3819:9;3815:22;3783:64;:::i;:::-;3765:82;;;;3560:297;2964:900;;;;;:::o;3870:90::-;3904:7;3947:5;3940:13;3933:21;3922:32;;3870:90;;;:::o;3966:109::-;4047:21;4062:5;4047:21;:::i;:::-;4042:3;4035:34;3966:109;;:::o;4081:98::-;4132:6;4166:5;4160:12;4150:22;;4081:98;;;:::o;4185:168::-;4268:11;4302:6;4297:3;4290:19;4342:4;4337:3;4333:14;4318:29;;4185:168;;;;:::o;4359:246::-;4440:1;4450:113;4464:6;4461:1;4458:13;4450:113;;;4549:1;4544:3;4540:11;4534:18;4530:1;4525:3;4521:11;4514:39;4486:2;4483:1;4479:10;4474:15;;4450:113;;;4597:1;4588:6;4583:3;4579:16;4572:27;4421:184;4359:246;;;:::o;4611:102::-;4652:6;4703:2;4699:7;4694:2;4687:5;4683:14;4679:28;4669:38;;4611:102;;;:::o;4719:373::-;4805:3;4833:38;4865:5;4833:38;:::i;:::-;4887:70;4950:6;4945:3;4887:70;:::i;:::-;4880:77;;4966:65;5024:6;5019:3;5012:4;5005:5;5001:16;4966:65;:::i;:::-;5056:29;5078:6;5056:29;:::i;:::-;5051:3;5047:39;5040:46;;4809:283;4719:373;;;;:::o;5098:407::-;5231:4;5269:2;5258:9;5254:18;5246:26;;5282:65;5344:1;5333:9;5329:17;5320:6;5282:65;:::i;:::-;5394:9;5388:4;5384:20;5379:2;5368:9;5364:18;5357:48;5422:76;5493:4;5484:6;5422:76;:::i;:::-;5414:84;;5098:407;;;;;:::o;5511:149::-;5547:7;5587:66;5580:5;5576:78;5565:89;;5511:149;;;:::o;5666:115::-;5751:23;5768:5;5751:23;:::i;:::-;5746:3;5739:36;5666:115;;:::o;5787:99::-;5839:6;5873:5;5867:12;5857:22;;5787:99;;;:::o;5892:169::-;5976:11;6010:6;6005:3;5998:19;6050:4;6045:3;6041:14;6026:29;;5892:169;;;;:::o;6067:377::-;6155:3;6183:39;6216:5;6183:39;:::i;:::-;6238:71;6302:6;6297:3;6238:71;:::i;:::-;6231:78;;6318:65;6376:6;6371:3;6364:4;6357:5;6353:16;6318:65;:::i;:::-;6408:29;6430:6;6408:29;:::i;:::-;6403:3;6399:39;6392:46;;6159:285;6067:377;;;;:::o;6450:118::-;6537:24;6555:5;6537:24;:::i;:::-;6532:3;6525:37;6450:118;;:::o;6574:77::-;6611:7;6640:5;6629:16;;6574:77;;;:::o;6657:118::-;6744:24;6762:5;6744:24;:::i;:::-;6739:3;6732:37;6657:118;;:::o;6781:114::-;6848:6;6882:5;6876:12;6866:22;;6781:114;;;:::o;6901:184::-;7000:11;7034:6;7029:3;7022:19;7074:4;7069:3;7065:14;7050:29;;6901:184;;;;:::o;7091:132::-;7158:4;7181:3;7173:11;;7211:4;7206:3;7202:14;7194:22;;7091:132;;;:::o;7229:108::-;7306:24;7324:5;7306:24;:::i;:::-;7301:3;7294:37;7229:108;;:::o;7343:179::-;7412:10;7433:46;7475:3;7467:6;7433:46;:::i;:::-;7511:4;7506:3;7502:14;7488:28;;7343:179;;;;:::o;7528:113::-;7598:4;7630;7625:3;7621:14;7613:22;;7528:113;;;:::o;7677:732::-;7796:3;7825:54;7873:5;7825:54;:::i;:::-;7895:86;7974:6;7969:3;7895:86;:::i;:::-;7888:93;;8005:56;8055:5;8005:56;:::i;:::-;8084:7;8115:1;8100:284;8125:6;8122:1;8119:13;8100:284;;;8201:6;8195:13;8228:63;8287:3;8272:13;8228:63;:::i;:::-;8221:70;;8314:60;8367:6;8314:60;:::i;:::-;8304:70;;8160:224;8147:1;8144;8140:9;8135:14;;8100:284;;;8104:14;8400:3;8393:10;;7801:608;;;7677:732;;;;:::o;8415:1215::-;8764:4;8802:3;8791:9;8787:19;8779:27;;8816:69;8882:1;8871:9;8867:17;8858:6;8816:69;:::i;:::-;8932:9;8926:4;8922:20;8917:2;8906:9;8902:18;8895:48;8960:78;9033:4;9024:6;8960:78;:::i;:::-;8952:86;;9085:9;9079:4;9075:20;9070:2;9059:9;9055:18;9048:48;9113:78;9186:4;9177:6;9113:78;:::i;:::-;9105:86;;9201:72;9269:2;9258:9;9254:18;9245:6;9201:72;:::i;:::-;9283:73;9351:3;9340:9;9336:19;9327:6;9283:73;:::i;:::-;9366;9434:3;9423:9;9419:19;9410:6;9366:73;:::i;:::-;9487:9;9481:4;9477:20;9471:3;9460:9;9456:19;9449:49;9515:108;9618:4;9609:6;9515:108;:::i;:::-;9507:116;;8415:1215;;;;;;;;;;:::o;9636:210::-;9723:4;9761:2;9750:9;9746:18;9738:26;;9774:65;9836:1;9825:9;9821:17;9812:6;9774:65;:::i;:::-;9636:210;;;;:::o;9852:236::-;9992:34;9988:1;9980:6;9976:14;9969:58;10061:19;10056:2;10048:6;10044:15;10037:44;9852:236;:::o;10094:366::-;10236:3;10257:67;10321:2;10316:3;10257:67;:::i;:::-;10250:74;;10333:93;10422:3;10333:93;:::i;:::-;10451:2;10446:3;10442:12;10435:19;;10094:366;;;:::o;10466:419::-;10632:4;10670:2;10659:9;10655:18;10647:26;;10719:9;10713:4;10709:20;10705:1;10694:9;10690:17;10683:47;10747:131;10873:4;10747:131;:::i;:::-;10739:139;;10466:419;;;:::o;10891:180::-;10939:77;10936:1;10929:88;11036:4;11033:1;11026:15;11060:4;11057:1;11050:15;11077:191;11117:3;11136:20;11154:1;11136:20;:::i;:::-;11131:25;;11170:20;11188:1;11170:20;:::i;:::-;11165:25;;11213:1;11210;11206:9;11199:16;;11234:3;11231:1;11228:10;11225:36;;;11241:18;;:::i;:::-;11225:36;11077:191;;;;:::o;11274:117::-;11383:1;11380;11373:12;11397:117;11506:1;11503;11496:12;11520:117;11629:1;11626;11619:12;11643:724;11720:4;11726:6;11782:11;11769:25;11882:1;11876:4;11872:12;11861:8;11845:14;11841:29;11837:48;11817:18;11813:73;11803:168;;11890:79;;:::i;:::-;11803:168;12002:18;11992:8;11988:33;11980:41;;12054:4;12041:18;12031:28;;12082:18;12074:6;12071:30;12068:117;;;12104:79;;:::i;:::-;12068:117;12212:2;12206:4;12202:13;12194:21;;12269:4;12261:6;12257:17;12241:14;12237:38;12231:4;12227:49;12224:136;;;12279:79;;:::i;:::-;12224:136;11733:634;11643:724;;;;;:::o;12373:147::-;12474:11;12511:3;12496:18;;12373:147;;;;:::o;12526:146::-;12623:6;12618:3;12613;12600:30;12664:1;12655:6;12650:3;12646:16;12639:27;12526:146;;;:::o;12700:327::-;12814:3;12835:88;12916:6;12911:3;12835:88;:::i;:::-;12828:95;;12933:56;12982:6;12977:3;12970:5;12933:56;:::i;:::-;13014:6;13009:3;13005:16;12998:23;;12700:327;;;;;:::o;13033:94::-;13066:8;13114:5;13110:2;13106:14;13085:35;;13033:94;;;:::o;13133:::-;13172:7;13201:20;13215:5;13201:20;:::i;:::-;13190:31;;13133:94;;;:::o;13233:100::-;13272:7;13301:26;13321:5;13301:26;:::i;:::-;13290:37;;13233:100;;;:::o;13339:157::-;13444:45;13464:24;13482:5;13464:24;:::i;:::-;13444:45;:::i;:::-;13439:3;13432:58;13339:157;;:::o;13502:432::-;13670:3;13692:103;13791:3;13782:6;13774;13692:103;:::i;:::-;13685:110;;13805:75;13876:3;13867:6;13805:75;:::i;:::-;13905:2;13900:3;13896:12;13889:19;;13925:3;13918:10;;13502:432;;;;;;:::o;13940:386::-;14044:3;14072:38;14104:5;14072:38;:::i;:::-;14126:88;14207:6;14202:3;14126:88;:::i;:::-;14119:95;;14223:65;14281:6;14276:3;14269:4;14262:5;14258:16;14223:65;:::i;:::-;14313:6;14308:3;14304:16;14297:23;;14048:278;13940:386;;;;:::o;14332:271::-;14462:3;14484:93;14573:3;14564:6;14484:93;:::i;:::-;14477:100;;14594:3;14587:10;;14332:271;;;;:::o;14609:180::-;14657:77;14654:1;14647:88;14754:4;14751:1;14744:15;14778:4;14775:1;14768:15;14795:185;14835:1;14852:20;14870:1;14852:20;:::i;:::-;14847:25;;14886:20;14904:1;14886:20;:::i;:::-;14881:25;;14925:1;14915:35;;14930:18;;:::i;:::-;14915:35;14972:1;14969;14965:9;14960:14;;14795:185;;;;:::o;14986:180::-;15034:77;15031:1;15024:88;15131:4;15128:1;15121:15;15155:4;15152:1;15145:15;15172:180;15220:77;15217:1;15210:88;15317:4;15314:1;15307:15;15341:4;15338:1;15331:15;15358:291;15498:3;15520:103;15619:3;15610:6;15602;15520:103;:::i;:::-;15513:110;;15640:3;15633:10;;15358:291;;;;;:::o;15655:886::-;15916:4;15954:3;15943:9;15939:19;15931:27;;15968:71;16036:1;16025:9;16021:17;16012:6;15968:71;:::i;:::-;16049:72;16117:2;16106:9;16102:18;16093:6;16049:72;:::i;:::-;16131;16199:2;16188:9;16184:18;16175:6;16131:72;:::i;:::-;16213;16281:2;16270:9;16266:18;16257:6;16213:72;:::i;:::-;16295:73;16363:3;16352:9;16348:19;16339:6;16295:73;:::i;:::-;16378;16446:3;16435:9;16431:19;16422:6;16378:73;:::i;:::-;16461;16529:3;16518:9;16514:19;16505:6;16461:73;:::i;:::-;15655:886;;;;;;;;;;:::o;16547:180::-;16595:77;16592:1;16585:88;16692:4;16689:1;16682:15;16716:4;16713:1;16706:15;16733:320;16777:6;16814:1;16808:4;16804:12;16794:22;;16861:1;16855:4;16851:12;16882:18;16872:81;;16938:4;16930:6;16926:17;16916:27;;16872:81;17000:2;16992:6;16989:14;16969:18;16966:38;16963:84;;17019:18;;:::i;:::-;16963:84;16784:269;16733:320;;;:::o;17059:180::-;17107:77;17104:1;17097:88;17204:4;17201:1;17194:15;17228:4;17225:1;17218:15;17245:174;17385:26;17381:1;17373:6;17369:14;17362:50;17245:174;:::o;17425:366::-;17567:3;17588:67;17652:2;17647:3;17588:67;:::i;:::-;17581:74;;17664:93;17753:3;17664:93;:::i;:::-;17782:2;17777:3;17773:12;17766:19;;17425:366;;;:::o;17797:419::-;17963:4;18001:2;17990:9;17986:18;17978:26;;18050:9;18044:4;18040:20;18036:1;18025:9;18021:17;18014:47;18078:131;18204:4;18078:131;:::i;:::-;18070:139;;17797:419;;;:::o;18222:181::-;18362:33;18358:1;18350:6;18346:14;18339:57;18222:181;:::o;18409:366::-;18551:3;18572:67;18636:2;18631:3;18572:67;:::i;:::-;18565:74;;18648:93;18737:3;18648:93;:::i;:::-;18766:2;18761:3;18757:12;18750:19;;18409:366;;;:::o;18781:419::-;18947:4;18985:2;18974:9;18970:18;18962:26;;19034:9;19028:4;19024:20;19020:1;19009:9;19005:17;18998:47;19062:131;19188:4;19062:131;:::i;:::-;19054:139;;18781:419;;;:::o;19206:221::-;19346:34;19342:1;19334:6;19330:14;19323:58;19415:4;19410:2;19402:6;19398:15;19391:29;19206:221;:::o;19433:366::-;19575:3;19596:67;19660:2;19655:3;19596:67;:::i;:::-;19589:74;;19672:93;19761:3;19672:93;:::i;:::-;19790:2;19785:3;19781:12;19774:19;;19433:366;;;:::o;19805:419::-;19971:4;20009:2;19998:9;19994:18;19986:26;;20058:9;20052:4;20048:20;20044:1;20033:9;20029:17;20022:47;20086:131;20212:4;20086:131;:::i;:::-;20078:139;;19805:419;;;:::o;20230:664::-;20435:4;20473:3;20462:9;20458:19;20450:27;;20487:71;20555:1;20544:9;20540:17;20531:6;20487:71;:::i;:::-;20568:72;20636:2;20625:9;20621:18;20612:6;20568:72;:::i;:::-;20650;20718:2;20707:9;20703:18;20694:6;20650:72;:::i;:::-;20732;20800:2;20789:9;20785:18;20776:6;20732:72;:::i;:::-;20814:73;20882:3;20871:9;20867:19;20858:6;20814:73;:::i;:::-;20230:664;;;;;;;;:::o;20900:86::-;20935:7;20975:4;20968:5;20964:16;20953:27;;20900:86;;;:::o;20992:112::-;21075:22;21091:5;21075:22;:::i;:::-;21070:3;21063:35;20992:112;;:::o;21110:545::-;21283:4;21321:3;21310:9;21306:19;21298:27;;21335:71;21403:1;21392:9;21388:17;21379:6;21335:71;:::i;:::-;21416:68;21480:2;21469:9;21465:18;21456:6;21416:68;:::i;:::-;21494:72;21562:2;21551:9;21547:18;21538:6;21494:72;:::i;:::-;21576;21644:2;21633:9;21629:18;21620:6;21576:72;:::i;:::-;21110:545;;;;;;;:::o

ipfs://8e69669cacb1c47d6daaded27548214a19f822fd9c52756c9434aea6606319a4