Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at basescan.org on 2023-09-11
*/

// Website: https://mahadao.com
// Twitter: https://twitter.com/themahadao
// Telegram: https://t.me/mahadao

// File: @openzeppelin/[email protected]/utils/Counters.sol


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/[email protected]/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/[email protected]/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        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/[email protected]/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: @openzeppelin/[email protected]/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: @openzeppelin/[email protected]/token/ERC20/ERC20.sol


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/ERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Permit.sol)

pragma solidity ^0.8.0;






/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.
     * However, to ensure consistency with the upgradeable transpiler, we will continue
     * to reserve a slot.
     * @custom:oz-renamed-from _PERMIT_TYPEHASH
     */
    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

// File: contract-784af3167d.sol


pragma solidity ^0.8.9;






contract MahaDAO is ERC20, ERC20Burnable, Pausable, Ownable, ERC20Permit {
    constructor() ERC20("MahaDAO", "MAHA") ERC20Permit("MahaDAO") {
        _mint(msg.sender, 10000000 * 10 ** decimals());
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

• 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":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","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":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"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":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

73434:662:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57916:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60276:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59045:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61057:261;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58887:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71722:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61727:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73718:65;;;:::i;:::-;;73791:95;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72778:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51188:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59216:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48692:103;;;:::i;:::-;;73188:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71464:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73649:61;;;:::i;:::-;;42873:657;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;48051:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58135:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62468:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59549:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70753:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59805:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48950:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57916:100;57970:13;58003:5;57996:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57916:100;:::o;60276:201::-;60359:4;60376:13;60392:12;:10;:12::i;:::-;60376:28;;60415:32;60424:5;60431:7;60440:6;60415:8;:32::i;:::-;60465:4;60458:11;;;60276:201;;;;:::o;59045:108::-;59106:7;59133:12;;59126:19;;59045:108;:::o;61057:261::-;61154:4;61171:15;61189:12;:10;:12::i;:::-;61171:30;;61212:38;61228:4;61234:7;61243:6;61212:15;:38::i;:::-;61261:27;61271:4;61277:2;61281:6;61261:9;:27::i;:::-;61306:4;61299:11;;;61057:261;;;;;:::o;58887:93::-;58945:5;58970:2;58963:9;;58887:93;:::o;71722:115::-;71782:7;71809:20;:18;:20::i;:::-;71802:27;;71722:115;:::o;61727:238::-;61815:4;61832:13;61848:12;:10;:12::i;:::-;61832:28;;61871:64;61880:5;61887:7;61924:10;61896:25;61906:5;61913:7;61896:9;:25::i;:::-;:38;;;;:::i;:::-;61871:8;:64::i;:::-;61953:4;61946:11;;;61727:238;;;;:::o;73718:65::-;47937:13;:11;:13::i;:::-;73765:10:::1;:8;:10::i;:::-;73718:65::o:0;73791:95::-;47937:13;:11;:13::i;:::-;73861:17:::1;73867:2;73871:6;73861:5;:17::i;:::-;73791:95:::0;;:::o;72778:91::-;72834:27;72840:12;:10;:12::i;:::-;72854:6;72834:5;:27::i;:::-;72778:91;:::o;51188:86::-;51235:4;51259:7;;;;;;;;;;;51252:14;;51188:86;:::o;59216:127::-;59290:7;59317:9;:18;59327:7;59317:18;;;;;;;;;;;;;;;;59310:25;;59216:127;;;:::o;48692:103::-;47937:13;:11;:13::i;:::-;48757:30:::1;48784:1;48757:18;:30::i;:::-;48692:103::o:0;73188:164::-;73265:46;73281:7;73290:12;:10;:12::i;:::-;73304:6;73265:15;:46::i;:::-;73322:22;73328:7;73337:6;73322:5;:22::i;:::-;73188:164;;:::o;71464:128::-;71533:7;71560:24;:7;:14;71568:5;71560:14;;;;;;;;;;;;;;;:22;:24::i;:::-;71553:31;;71464:128;;;:::o;73649:61::-;47937:13;:11;:13::i;:::-;73694:8:::1;:6;:8::i;:::-;73649:61::o:0;42873:657::-;42994:13;43022:18;43055:21;43091:15;43121:25;43161:12;43188:27;43296:41;43323:13;43296:5;:26;;:41;;;;:::i;:::-;43352:47;43382:16;43352:8;:29;;:47;;;;:::i;:::-;43414:13;43450:4;43478:1;43470:10;;43509:1;43495:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43243:279;;;;;;;;;;;;;;;;;;;;;42873:657;;;;;;;:::o;48051:87::-;48097:7;48124:6;;;;;;;;;;;48117:13;;48051:87;:::o;58135:104::-;58191:13;58224:7;58217:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58135:104;:::o;62468:436::-;62561:4;62578:13;62594:12;:10;:12::i;:::-;62578:28;;62617:24;62644:25;62654:5;62661:7;62644:9;:25::i;:::-;62617:52;;62708:15;62688:16;:35;;62680:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;62801:60;62810:5;62817:7;62845:15;62826:16;:34;62801:8;:60::i;:::-;62892:4;62885:11;;;;62468:436;;;;:::o;59549:193::-;59628:4;59645:13;59661:12;:10;:12::i;:::-;59645:28;;59684;59694:5;59701:2;59705:6;59684:9;:28::i;:::-;59730:4;59723:11;;;59549:193;;;;:::o;70753:645::-;70997:8;70978:15;:27;;70970:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;71052:18;69928:95;71112:5;71119:7;71128:5;71135:16;71145:5;71135:9;:16::i;:::-;71153:8;71083:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71073:90;;;;;;71052:111;;71176:12;71191:28;71208:10;71191:16;:28::i;:::-;71176:43;;71232:14;71249:28;71263:4;71269:1;71272;71275;71249:13;:28::i;:::-;71232:45;;71306:5;71296:15;;:6;:15;;;71288:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;71359:31;71368:5;71375:7;71384:5;71359:8;:31::i;:::-;70959:439;;;70753:645;;;;;;;:::o;59805:151::-;59894:7;59921:11;:18;59933:5;59921:18;;;;;;;;;;;;;;;:27;59940:7;59921:27;;;;;;;;;;;;;;;;59914:34;;59805:151;;;;:::o;48950:201::-;47937:13;:11;:13::i;:::-;49059:1:::1;49039:22;;:8;:22;;::::0;49031:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;49115:28;49134:8;49115:18;:28::i;:::-;48950:201:::0;:::o;9655:348::-;9751:11;9801:2;9785:5;9779:19;:24;9775:221;;;9827:20;9841:5;9827:13;:20::i;:::-;9820:27;;;;9775:221;9921:5;9880:32;9906:5;9880:25;:32::i;:::-;:38;;:46;;;;;;:::i;:::-;;8084:66;9965:18;;9941:43;;9655:348;;;;;:::o;5842:207::-;5910:20;6021:10;6011:20;;5842:207;;;:::o;68117:91::-;;;;:::o;46596:98::-;46649:7;46676:10;46669:17;;46596:98;:::o;66461:346::-;66580:1;66563:19;;:5;:19;;;66555:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66661:1;66642:21;;:7;:21;;;66634:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66745:6;66715:11;:18;66727:5;66715:18;;;;;;;;;;;;;;;:27;66734:7;66715:27;;;;;;;;;;;;;;;:36;;;;66783:7;66767:32;;66776:5;66767:32;;;66792:6;66767:32;;;;;;:::i;:::-;;;;;;;;66461:346;;;:::o;67098:419::-;67199:24;67226:25;67236:5;67243:7;67226:9;:25::i;:::-;67199:52;;67286:17;67266:16;:37;67262:248;;67348:6;67328:16;:26;;67320:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67432:51;67441:5;67448:7;67476:6;67457:16;:25;67432:8;:51::i;:::-;67262:248;67188:329;67098:419;;;:::o;63374:806::-;63487:1;63471:18;;:4;:18;;;63463:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63564:1;63550:16;;:2;:16;;;63542:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;63619:38;63640:4;63646:2;63650:6;63619:20;:38::i;:::-;63670:19;63692:9;:15;63702:4;63692:15;;;;;;;;;;;;;;;;63670:37;;63741:6;63726:11;:21;;63718:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;63858:6;63844:11;:20;63826:9;:15;63836:4;63826:15;;;;;;;;;;;;;;;:38;;;;64061:6;64044:9;:13;64054:2;64044:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;64111:2;64096:26;;64105:4;64096:26;;;64115:6;64096:26;;;;;;:::i;:::-;;;;;;;;64135:37;64155:4;64161:2;64165:6;64135:19;:37::i;:::-;63452:728;63374:806;;;:::o;41511:268::-;41564:7;41605:11;41588:28;;41596:4;41588:28;;;:63;;;;;41637:14;41620:13;:31;41588:63;41584:188;;;41675:22;41668:29;;;;41584:188;41737:23;:21;:23::i;:::-;41730:30;;41511:268;;:::o;48216:132::-;48291:12;:10;:12::i;:::-;48280:23;;:7;:5;:7::i;:::-;:23;;;48272:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;48216:132::o;52043:120::-;51052:16;:14;:16::i;:::-;52112:5:::1;52102:7;;:15;;;;;;;;;;;;;;;;;;52133:22;52142:12;:10;:12::i;:::-;52133:22;;;;;;:::i;:::-;;;;;;;;52043:120::o:0;64467:548::-;64570:1;64551:21;;:7;:21;;;64543:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;64621:49;64650:1;64654:7;64663:6;64621:20;:49::i;:::-;64699:6;64683:12;;:22;;;;;;;:::i;:::-;;;;;;;;64876:6;64854:9;:18;64864:7;64854:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;64930:7;64909:37;;64926:1;64909:37;;;64939:6;64909:37;;;;;;:::i;:::-;;;;;;;;64959:48;64987:1;64991:7;65000:6;64959:19;:48::i;:::-;64467:548;;:::o;65348:675::-;65451:1;65432:21;;:7;:21;;;65424:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;65504:49;65525:7;65542:1;65546:6;65504:20;:49::i;:::-;65566:22;65591:9;:18;65601:7;65591:18;;;;;;;;;;;;;;;;65566:43;;65646:6;65628:14;:24;;65620:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;65765:6;65748:14;:23;65727:9;:18;65737:7;65727:18;;;;;;;;;;;;;;;:44;;;;65882:6;65866:12;;:22;;;;;;;;;;;65943:1;65917:37;;65926:7;65917:37;;;65947:6;65917:37;;;;;;:::i;:::-;;;;;;;;65967:48;65987:7;66004:1;66008:6;65967:19;:48::i;:::-;65413:610;65348:675;;:::o;49311:191::-;49385:16;49404:6;;;;;;;;;;;49385:25;;49430:8;49421:6;;:17;;;;;;;;;;;;;;;;;;49485:8;49454:40;;49475:8;49454:40;;;;;;;;;;;;49374:128;49311:191;:::o;992:114::-;1057:7;1084;:14;;;1077:21;;992:114;;;:::o;51784:118::-;50793:19;:17;:19::i;:::-;51854:4:::1;51844:7;;:14;;;;;;;;;;;;;;;;;;51874:20;51881:12;:10;:12::i;:::-;51874:20;;;;;;:::i;:::-;;;;;;;;51784:118::o:0;10139:274::-;10233:13;8084:66;10292:18;;10282:5;10263:47;10259:147;;10334:15;10343:5;10334:8;:15::i;:::-;10327:22;;;;10259:147;10389:5;10382:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10139:274;;;;;:::o;71975:207::-;72035:15;72063:30;72096:7;:14;72104:5;72096:14;;;;;;;;;;;;;;;72063:47;;72131:15;:5;:13;:15::i;:::-;72121:25;;72157:17;:5;:15;:17::i;:::-;72052:130;71975:207;;;:::o;42611:167::-;42688:7;42715:55;42737:20;:18;:20::i;:::-;42759:10;42715:21;:55::i;:::-;42708:62;;42611:167;;;:::o;35184:236::-;35269:7;35290:17;35309:18;35331:25;35342:4;35348:1;35351;35354;35331:10;:25::i;:::-;35289:67;;;;35367:18;35379:5;35367:11;:18::i;:::-;35403:9;35396:16;;;;35184:236;;;;;;:::o;8412:292::-;8477:11;8501:17;8527:3;8501:30;;8560:2;8546:4;:11;:16;8542:74;;;8600:3;8586:18;;;;;;;;;;;:::i;:::-;;;;;;;;8542:74;8683:4;:11;8674:4;8666:13;;;:::i;:::-;8658:22;;:36;8650:45;;8626:70;;;8412:292;;;:::o;73894:199::-;50793:19;:17;:19::i;:::-;74041:44:::1;74068:4;74074:2;74078:6;74041:26;:44::i;:::-;73894:199:::0;;;:::o;68812:90::-;;;;:::o;41787:182::-;41842:7;39703:95;41902:11;41915:14;41931:13;41954:4;41879:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;41869:92;;;;;;41862:99;;41787:182;:::o;51532:108::-;51599:8;:6;:8::i;:::-;51591:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;51532:108::o;51347:::-;51418:8;:6;:8::i;:::-;51417:9;51409:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;51347:108::o;8793:415::-;8852:13;8878:11;8892:16;8903:4;8892:10;:16::i;:::-;8878:30;;8998:17;9029:2;9018:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8998:34;;9123:3;9118;9111:16;9164:4;9157;9152:3;9148:14;9141:28;9197:3;9190:10;;;;8793:415;;;:::o;1114:127::-;1221:1;1203:7;:14;;;:19;;;;;;;;;;;1114:127;:::o;36968:406::-;37061:12;37171:4;37165:11;37202:10;37197:3;37190:23;37250:15;37243:4;37238:3;37234:14;37227:39;37303:10;37296:4;37291:3;37287:14;37280:34;37351:4;37346:3;37336:20;37328:28;;37139:228;36968:406;;;;:::o;33568:1477::-;33656:7;33665:12;34590:66;34585:1;34577:10;;:79;34573:163;;;34689:1;34693:30;34673:51;;;;;;34573:163;34833:14;34850:24;34860:4;34866:1;34869;34872;34850:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34833:41;;34907:1;34889:20;;:6;:20;;;34885:103;;34942:1;34946:29;34926:50;;;;;;;34885:103;35008:6;35016:20;35000:37;;;;;33568:1477;;;;;;;;:::o;29028:521::-;29106:20;29097:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;29093:449;29143:7;29093:449;29204:29;29195:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;29191:351;;29250:34;;;;;;;;;;:::i;:::-;;;;;;;;29191:351;29315:35;29306:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;29302:240;;29367:41;;;;;;;;;;:::i;:::-;;;;;;;;29302:240;29439:30;29430:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;29426:116;;29486:44;;;;;;;;;;:::i;:::-;;;;;;;;29426:116;29028:521;;:::o;9285:251::-;9346:7;9366:14;9419:4;9410;9383:33;;:40;9366:57;;9447:2;9438:6;:11;9434:71;;;9473:20;;;;;;;;;;;;;;9434:71;9522:6;9515:13;;;9285:251;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:86::-;4458:7;4498:4;4491:5;4487:16;4476:27;;4423:86;;;:::o;4515:112::-;4598:22;4614:5;4598:22;:::i;:::-;4593:3;4586:35;4515:112;;:::o;4633:214::-;4722:4;4760:2;4749:9;4745:18;4737:26;;4773:67;4837:1;4826:9;4822:17;4813:6;4773:67;:::i;:::-;4633:214;;;;:::o;4853:77::-;4890:7;4919:5;4908:16;;4853:77;;;:::o;4936:118::-;5023:24;5041:5;5023:24;:::i;:::-;5018:3;5011:37;4936:118;;:::o;5060:222::-;5153:4;5191:2;5180:9;5176:18;5168:26;;5204:71;5272:1;5261:9;5257:17;5248:6;5204:71;:::i;:::-;5060:222;;;;:::o;5288:329::-;5347:6;5396:2;5384:9;5375:7;5371:23;5367:32;5364:119;;;5402:79;;:::i;:::-;5364:119;5522:1;5547:53;5592:7;5583:6;5572:9;5568:22;5547:53;:::i;:::-;5537:63;;5493:117;5288:329;;;;:::o;5623:::-;5682:6;5731:2;5719:9;5710:7;5706:23;5702:32;5699:119;;;5737:79;;:::i;:::-;5699:119;5857:1;5882:53;5927:7;5918:6;5907:9;5903:22;5882:53;:::i;:::-;5872:63;;5828:117;5623:329;;;;:::o;5958:149::-;5994:7;6034:66;6027:5;6023:78;6012:89;;5958:149;;;:::o;6113:115::-;6198:23;6215:5;6198:23;:::i;:::-;6193:3;6186:36;6113:115;;:::o;6234:118::-;6321:24;6339:5;6321:24;:::i;:::-;6316:3;6309:37;6234:118;;:::o;6358:114::-;6425:6;6459:5;6453:12;6443:22;;6358:114;;;:::o;6478:184::-;6577:11;6611:6;6606:3;6599:19;6651:4;6646:3;6642:14;6627:29;;6478:184;;;;:::o;6668:132::-;6735:4;6758:3;6750:11;;6788:4;6783:3;6779:14;6771:22;;6668:132;;;:::o;6806:108::-;6883:24;6901:5;6883:24;:::i;:::-;6878:3;6871:37;6806:108;;:::o;6920:179::-;6989:10;7010:46;7052:3;7044:6;7010:46;:::i;:::-;7088:4;7083:3;7079:14;7065:28;;6920:179;;;;:::o;7105:113::-;7175:4;7207;7202:3;7198:14;7190:22;;7105:113;;;:::o;7254:732::-;7373:3;7402:54;7450:5;7402:54;:::i;:::-;7472:86;7551:6;7546:3;7472:86;:::i;:::-;7465:93;;7582:56;7632:5;7582:56;:::i;:::-;7661:7;7692:1;7677:284;7702:6;7699:1;7696:13;7677:284;;;7778:6;7772:13;7805:63;7864:3;7849:13;7805:63;:::i;:::-;7798:70;;7891:60;7944:6;7891:60;:::i;:::-;7881:70;;7737:224;7724:1;7721;7717:9;7712:14;;7677:284;;;7681:14;7977:3;7970:10;;7378:608;;;7254:732;;;;:::o;7992:1215::-;8341:4;8379:3;8368:9;8364:19;8356:27;;8393:69;8459:1;8448:9;8444:17;8435:6;8393:69;:::i;:::-;8509:9;8503:4;8499:20;8494:2;8483:9;8479:18;8472:48;8537:78;8610:4;8601:6;8537:78;:::i;:::-;8529:86;;8662:9;8656:4;8652:20;8647:2;8636:9;8632:18;8625:48;8690:78;8763:4;8754:6;8690:78;:::i;:::-;8682:86;;8778:72;8846:2;8835:9;8831:18;8822:6;8778:72;:::i;:::-;8860:73;8928:3;8917:9;8913:19;8904:6;8860:73;:::i;:::-;8943;9011:3;9000:9;8996:19;8987:6;8943:73;:::i;:::-;9064:9;9058:4;9054:20;9048:3;9037:9;9033:19;9026:49;9092:108;9195:4;9186:6;9092:108;:::i;:::-;9084:116;;7992:1215;;;;;;;;;;:::o;9213:222::-;9306:4;9344:2;9333:9;9329:18;9321:26;;9357:71;9425:1;9414:9;9410:17;9401:6;9357:71;:::i;:::-;9213:222;;;;:::o;9441:118::-;9512:22;9528:5;9512:22;:::i;:::-;9505:5;9502:33;9492:61;;9549:1;9546;9539:12;9492:61;9441:118;:::o;9565:135::-;9609:5;9647:6;9634:20;9625:29;;9663:31;9688:5;9663:31;:::i;:::-;9565:135;;;;:::o;9706:122::-;9779:24;9797:5;9779:24;:::i;:::-;9772:5;9769:35;9759:63;;9818:1;9815;9808:12;9759:63;9706:122;:::o;9834:139::-;9880:5;9918:6;9905:20;9896:29;;9934:33;9961:5;9934:33;:::i;:::-;9834:139;;;;:::o;9979:1199::-;10090:6;10098;10106;10114;10122;10130;10138;10187:3;10175:9;10166:7;10162:23;10158:33;10155:120;;;10194:79;;:::i;:::-;10155:120;10314:1;10339:53;10384:7;10375:6;10364:9;10360:22;10339:53;:::i;:::-;10329:63;;10285:117;10441:2;10467:53;10512:7;10503:6;10492:9;10488:22;10467:53;:::i;:::-;10457:63;;10412:118;10569:2;10595:53;10640:7;10631:6;10620:9;10616:22;10595:53;:::i;:::-;10585:63;;10540:118;10697:2;10723:53;10768:7;10759:6;10748:9;10744:22;10723:53;:::i;:::-;10713:63;;10668:118;10825:3;10852:51;10895:7;10886:6;10875:9;10871:22;10852:51;:::i;:::-;10842:61;;10796:117;10952:3;10979:53;11024:7;11015:6;11004:9;11000:22;10979:53;:::i;:::-;10969:63;;10923:119;11081:3;11108:53;11153:7;11144:6;11133:9;11129:22;11108:53;:::i;:::-;11098:63;;11052:119;9979:1199;;;;;;;;;;:::o;11184:474::-;11252:6;11260;11309:2;11297:9;11288:7;11284:23;11280:32;11277:119;;;11315:79;;:::i;:::-;11277:119;11435:1;11460:53;11505:7;11496:6;11485:9;11481:22;11460:53;:::i;:::-;11450:63;;11406:117;11562:2;11588:53;11633:7;11624:6;11613:9;11609:22;11588:53;:::i;:::-;11578:63;;11533:118;11184:474;;;;;:::o;11664:180::-;11712:77;11709:1;11702:88;11809:4;11806:1;11799:15;11833:4;11830:1;11823:15;11850:320;11894:6;11931:1;11925:4;11921:12;11911:22;;11978:1;11972:4;11968:12;11999:18;11989:81;;12055:4;12047:6;12043:17;12033:27;;11989:81;12117:2;12109:6;12106:14;12086:18;12083:38;12080:84;;12136:18;;:::i;:::-;12080:84;11901:269;11850:320;;;:::o;12176:180::-;12224:77;12221:1;12214:88;12321:4;12318:1;12311:15;12345:4;12342:1;12335:15;12362:191;12402:3;12421:20;12439:1;12421:20;:::i;:::-;12416:25;;12455:20;12473:1;12455:20;:::i;:::-;12450:25;;12498:1;12495;12491:9;12484:16;;12519:3;12516:1;12513:10;12510:36;;;12526:18;;:::i;:::-;12510:36;12362:191;;;;:::o;12559:180::-;12607:77;12604:1;12597:88;12704:4;12701:1;12694:15;12728:4;12725:1;12718:15;12745:224;12885:34;12881:1;12873:6;12869:14;12862:58;12954:7;12949:2;12941:6;12937:15;12930:32;12745:224;:::o;12975:366::-;13117:3;13138:67;13202:2;13197:3;13138:67;:::i;:::-;13131:74;;13214:93;13303:3;13214:93;:::i;:::-;13332:2;13327:3;13323:12;13316:19;;12975:366;;;:::o;13347:419::-;13513:4;13551:2;13540:9;13536:18;13528:26;;13600:9;13594:4;13590:20;13586:1;13575:9;13571:17;13564:47;13628:131;13754:4;13628:131;:::i;:::-;13620:139;;13347:419;;;:::o;13772:179::-;13912:31;13908:1;13900:6;13896:14;13889:55;13772:179;:::o;13957:366::-;14099:3;14120:67;14184:2;14179:3;14120:67;:::i;:::-;14113:74;;14196:93;14285:3;14196:93;:::i;:::-;14314:2;14309:3;14305:12;14298:19;;13957:366;;;:::o;14329:419::-;14495:4;14533:2;14522:9;14518:18;14510:26;;14582:9;14576:4;14572:20;14568:1;14557:9;14553:17;14546:47;14610:131;14736:4;14610:131;:::i;:::-;14602:139;;14329:419;;;:::o;14754:775::-;14987:4;15025:3;15014:9;15010:19;15002:27;;15039:71;15107:1;15096:9;15092:17;15083:6;15039:71;:::i;:::-;15120:72;15188:2;15177:9;15173:18;15164:6;15120:72;:::i;:::-;15202;15270:2;15259:9;15255:18;15246:6;15202:72;:::i;:::-;15284;15352:2;15341:9;15337:18;15328:6;15284:72;:::i;:::-;15366:73;15434:3;15423:9;15419:19;15410:6;15366:73;:::i;:::-;15449;15517:3;15506:9;15502:19;15493:6;15449:73;:::i;:::-;14754:775;;;;;;;;;:::o;15535:180::-;15675:32;15671:1;15663:6;15659:14;15652:56;15535:180;:::o;15721:366::-;15863:3;15884:67;15948:2;15943:3;15884:67;:::i;:::-;15877:74;;15960:93;16049:3;15960:93;:::i;:::-;16078:2;16073:3;16069:12;16062:19;;15721:366;;;:::o;16093:419::-;16259:4;16297:2;16286:9;16282:18;16274:26;;16346:9;16340:4;16336:20;16332:1;16321:9;16317:17;16310:47;16374:131;16500:4;16374:131;:::i;:::-;16366:139;;16093:419;;;:::o;16518:225::-;16658:34;16654:1;16646:6;16642:14;16635:58;16727:8;16722:2;16714:6;16710:15;16703:33;16518:225;:::o;16749:366::-;16891:3;16912:67;16976:2;16971:3;16912:67;:::i;:::-;16905:74;;16988:93;17077:3;16988:93;:::i;:::-;17106:2;17101:3;17097:12;17090:19;;16749:366;;;:::o;17121:419::-;17287:4;17325:2;17314:9;17310:18;17302:26;;17374:9;17368:4;17364:20;17360:1;17349:9;17345:17;17338:47;17402:131;17528:4;17402:131;:::i;:::-;17394:139;;17121:419;;;:::o;17546:141::-;17595:4;17618:3;17610:11;;17641:3;17638:1;17631:14;17675:4;17672:1;17662:18;17654:26;;17546:141;;;:::o;17693:93::-;17730:6;17777:2;17772;17765:5;17761:14;17757:23;17747:33;;17693:93;;;:::o;17792:107::-;17836:8;17886:5;17880:4;17876:16;17855:37;;17792:107;;;;:::o;17905:393::-;17974:6;18024:1;18012:10;18008:18;18047:97;18077:66;18066:9;18047:97;:::i;:::-;18165:39;18195:8;18184:9;18165:39;:::i;:::-;18153:51;;18237:4;18233:9;18226:5;18222:21;18213:30;;18286:4;18276:8;18272:19;18265:5;18262:30;18252:40;;17981:317;;17905:393;;;;;:::o;18304:60::-;18332:3;18353:5;18346:12;;18304:60;;;:::o;18370:142::-;18420:9;18453:53;18471:34;18480:24;18498:5;18480:24;:::i;:::-;18471:34;:::i;:::-;18453:53;:::i;:::-;18440:66;;18370:142;;;:::o;18518:75::-;18561:3;18582:5;18575:12;;18518:75;;;:::o;18599:269::-;18709:39;18740:7;18709:39;:::i;:::-;18770:91;18819:41;18843:16;18819:41;:::i;:::-;18811:6;18804:4;18798:11;18770:91;:::i;:::-;18764:4;18757:105;18675:193;18599:269;;;:::o;18874:73::-;18919:3;18874:73;:::o;18953:189::-;19030:32;;:::i;:::-;19071:65;19129:6;19121;19115:4;19071:65;:::i;:::-;19006:136;18953:189;;:::o;19148:186::-;19208:120;19225:3;19218:5;19215:14;19208:120;;;19279:39;19316:1;19309:5;19279:39;:::i;:::-;19252:1;19245:5;19241:13;19232:22;;19208:120;;;19148:186;;:::o;19340:543::-;19441:2;19436:3;19433:11;19430:446;;;19475:38;19507:5;19475:38;:::i;:::-;19559:29;19577:10;19559:29;:::i;:::-;19549:8;19545:44;19742:2;19730:10;19727:18;19724:49;;;19763:8;19748:23;;19724:49;19786:80;19842:22;19860:3;19842:22;:::i;:::-;19832:8;19828:37;19815:11;19786:80;:::i;:::-;19445:431;;19430:446;19340:543;;;:::o;19889:117::-;19943:8;19993:5;19987:4;19983:16;19962:37;;19889:117;;;;:::o;20012:169::-;20056:6;20089:51;20137:1;20133:6;20125:5;20122:1;20118:13;20089:51;:::i;:::-;20085:56;20170:4;20164;20160:15;20150:25;;20063:118;20012:169;;;;:::o;20186:295::-;20262:4;20408:29;20433:3;20427:4;20408:29;:::i;:::-;20400:37;;20470:3;20467:1;20463:11;20457:4;20454:21;20446:29;;20186:295;;;;:::o;20486:1395::-;20603:37;20636:3;20603:37;:::i;:::-;20705:18;20697:6;20694:30;20691:56;;;20727:18;;:::i;:::-;20691:56;20771:38;20803:4;20797:11;20771:38;:::i;:::-;20856:67;20916:6;20908;20902:4;20856:67;:::i;:::-;20950:1;20974:4;20961:17;;21006:2;20998:6;20995:14;21023:1;21018:618;;;;21680:1;21697:6;21694:77;;;21746:9;21741:3;21737:19;21731:26;21722:35;;21694:77;21797:67;21857:6;21850:5;21797:67;:::i;:::-;21791:4;21784:81;21653:222;20988:887;;21018:618;21070:4;21066:9;21058:6;21054:22;21104:37;21136:4;21104:37;:::i;:::-;21163:1;21177:208;21191:7;21188:1;21185:14;21177:208;;;21270:9;21265:3;21261:19;21255:26;21247:6;21240:42;21321:1;21313:6;21309:14;21299:24;;21368:2;21357:9;21353:18;21340:31;;21214:4;21211:1;21207:12;21202:17;;21177:208;;;21413:6;21404:7;21401:19;21398:179;;;21471:9;21466:3;21462:19;21456:26;21514:48;21556:4;21548:6;21544:17;21533:9;21514:48;:::i;:::-;21506:6;21499:64;21421:156;21398:179;21623:1;21619;21611:6;21607:14;21603:22;21597:4;21590:36;21025:611;;;20988:887;;20578:1303;;;20486:1395;;:::o;21887:223::-;22027:34;22023:1;22015:6;22011:14;22004:58;22096:6;22091:2;22083:6;22079:15;22072:31;21887:223;:::o;22116:366::-;22258:3;22279:67;22343:2;22338:3;22279:67;:::i;:::-;22272:74;;22355:93;22444:3;22355:93;:::i;:::-;22473:2;22468:3;22464:12;22457:19;;22116:366;;;:::o;22488:419::-;22654:4;22692:2;22681:9;22677:18;22669:26;;22741:9;22735:4;22731:20;22727:1;22716:9;22712:17;22705:47;22769:131;22895:4;22769:131;:::i;:::-;22761:139;;22488:419;;;:::o;22913:221::-;23053:34;23049:1;23041:6;23037:14;23030:58;23122:4;23117:2;23109:6;23105:15;23098:29;22913:221;:::o;23140:366::-;23282:3;23303:67;23367:2;23362:3;23303:67;:::i;:::-;23296:74;;23379:93;23468:3;23379:93;:::i;:::-;23497:2;23492:3;23488:12;23481:19;;23140:366;;;:::o;23512:419::-;23678:4;23716:2;23705:9;23701:18;23693:26;;23765:9;23759:4;23755:20;23751:1;23740:9;23736:17;23729:47;23793:131;23919:4;23793:131;:::i;:::-;23785:139;;23512:419;;;:::o;23937:179::-;24077:31;24073:1;24065:6;24061:14;24054:55;23937:179;:::o;24122:366::-;24264:3;24285:67;24349:2;24344:3;24285:67;:::i;:::-;24278:74;;24361:93;24450:3;24361:93;:::i;:::-;24479:2;24474:3;24470:12;24463:19;;24122:366;;;:::o;24494:419::-;24660:4;24698:2;24687:9;24683:18;24675:26;;24747:9;24741:4;24737:20;24733:1;24722:9;24718:17;24711:47;24775:131;24901:4;24775:131;:::i;:::-;24767:139;;24494:419;;;:::o;24919:224::-;25059:34;25055:1;25047:6;25043:14;25036:58;25128:7;25123:2;25115:6;25111:15;25104:32;24919:224;:::o;25149:366::-;25291:3;25312:67;25376:2;25371:3;25312:67;:::i;:::-;25305:74;;25388:93;25477:3;25388:93;:::i;:::-;25506:2;25501:3;25497:12;25490:19;;25149:366;;;:::o;25521:419::-;25687:4;25725:2;25714:9;25710:18;25702:26;;25774:9;25768:4;25764:20;25760:1;25749:9;25745:17;25738:47;25802:131;25928:4;25802:131;:::i;:::-;25794:139;;25521:419;;;:::o;25946:222::-;26086:34;26082:1;26074:6;26070:14;26063:58;26155:5;26150:2;26142:6;26138:15;26131:30;25946:222;:::o;26174:366::-;26316:3;26337:67;26401:2;26396:3;26337:67;:::i;:::-;26330:74;;26413:93;26502:3;26413:93;:::i;:::-;26531:2;26526:3;26522:12;26515:19;;26174:366;;;:::o;26546:419::-;26712:4;26750:2;26739:9;26735:18;26727:26;;26799:9;26793:4;26789:20;26785:1;26774:9;26770:17;26763:47;26827:131;26953:4;26827:131;:::i;:::-;26819:139;;26546:419;;;:::o;26971:225::-;27111:34;27107:1;27099:6;27095:14;27088:58;27180:8;27175:2;27167:6;27163:15;27156:33;26971:225;:::o;27202:366::-;27344:3;27365:67;27429:2;27424:3;27365:67;:::i;:::-;27358:74;;27441:93;27530:3;27441:93;:::i;:::-;27559:2;27554:3;27550:12;27543:19;;27202:366;;;:::o;27574:419::-;27740:4;27778:2;27767:9;27763:18;27755:26;;27827:9;27821:4;27817:20;27813:1;27802:9;27798:17;27791:47;27855:131;27981:4;27855:131;:::i;:::-;27847:139;;27574:419;;;:::o;27999:182::-;28139:34;28135:1;28127:6;28123:14;28116:58;27999:182;:::o;28187:366::-;28329:3;28350:67;28414:2;28409:3;28350:67;:::i;:::-;28343:74;;28426:93;28515:3;28426:93;:::i;:::-;28544:2;28539:3;28535:12;28528:19;;28187:366;;;:::o;28559:419::-;28725:4;28763:2;28752:9;28748:18;28740:26;;28812:9;28806:4;28802:20;28798:1;28787:9;28783:17;28776:47;28840:131;28966:4;28840:131;:::i;:::-;28832:139;;28559:419;;;:::o;28984:181::-;29124:33;29120:1;29112:6;29108:14;29101:57;28984:181;:::o;29171:366::-;29313:3;29334:67;29398:2;29393:3;29334:67;:::i;:::-;29327:74;;29410:93;29499:3;29410:93;:::i;:::-;29528:2;29523:3;29519:12;29512:19;;29171:366;;;:::o;29543:419::-;29709:4;29747:2;29736:9;29732:18;29724:26;;29796:9;29790:4;29786:20;29782:1;29771:9;29767:17;29760:47;29824:131;29950:4;29824:131;:::i;:::-;29816:139;;29543:419;;;:::o;29968:220::-;30108:34;30104:1;30096:6;30092:14;30085:58;30177:3;30172:2;30164:6;30160:15;30153:28;29968:220;:::o;30194:366::-;30336:3;30357:67;30421:2;30416:3;30357:67;:::i;:::-;30350:74;;30433:93;30522:3;30433:93;:::i;:::-;30551:2;30546:3;30542:12;30535:19;;30194:366;;;:::o;30566:419::-;30732:4;30770:2;30759:9;30755:18;30747:26;;30819:9;30813:4;30809:20;30805:1;30794:9;30790:17;30783:47;30847:131;30973:4;30847:131;:::i;:::-;30839:139;;30566:419;;;:::o;30991:221::-;31131:34;31127:1;31119:6;31115:14;31108:58;31200:4;31195:2;31187:6;31183:15;31176:29;30991:221;:::o;31218:366::-;31360:3;31381:67;31445:2;31440:3;31381:67;:::i;:::-;31374:74;;31457:93;31546:3;31457:93;:::i;:::-;31575:2;31570:3;31566:12;31559:19;;31218:366;;;:::o;31590:419::-;31756:4;31794:2;31783:9;31779:18;31771:26;;31843:9;31837:4;31833:20;31829:1;31818:9;31814:17;31807:47;31871:131;31997:4;31871:131;:::i;:::-;31863:139;;31590:419;;;:::o;32015:98::-;32066:6;32100:5;32094:12;32084:22;;32015:98;;;:::o;32119:116::-;32170:4;32193:3;32185:11;;32223:4;32218:3;32214:14;32206:22;;32119:116;;;:::o;32241:154::-;32284:11;32320:29;32344:3;32338:10;32320:29;:::i;:::-;32383:5;32359:29;;32296:99;32241:154;;;:::o;32401:594::-;32485:5;32516:38;32548:5;32516:38;:::i;:::-;32579:5;32606:40;32640:5;32606:40;:::i;:::-;32594:52;;32665:35;32691:8;32665:35;:::i;:::-;32656:44;;32724:2;32716:6;32713:14;32710:278;;;32795:169;32880:66;32850:6;32846:2;32842:15;32839:1;32835:23;32795:169;:::i;:::-;32772:5;32751:227;32742:236;;32710:278;32491:504;;32401:594;;;:::o;33001:664::-;33206:4;33244:3;33233:9;33229:19;33221:27;;33258:71;33326:1;33315:9;33311:17;33302:6;33258:71;:::i;:::-;33339:72;33407:2;33396:9;33392:18;33383:6;33339:72;:::i;:::-;33421;33489:2;33478:9;33474:18;33465:6;33421:72;:::i;:::-;33503;33571:2;33560:9;33556:18;33547:6;33503:72;:::i;:::-;33585:73;33653:3;33642:9;33638:19;33629:6;33585:73;:::i;:::-;33001:664;;;;;;;;:::o;33671:170::-;33811:22;33807:1;33799:6;33795:14;33788:46;33671:170;:::o;33847:366::-;33989:3;34010:67;34074:2;34069:3;34010:67;:::i;:::-;34003:74;;34086:93;34175:3;34086:93;:::i;:::-;34204:2;34199:3;34195:12;34188:19;;33847:366;;;:::o;34219:419::-;34385:4;34423:2;34412:9;34408:18;34400:26;;34472:9;34466:4;34462:20;34458:1;34447:9;34443:17;34436:47;34500:131;34626:4;34500:131;:::i;:::-;34492:139;;34219:419;;;:::o;34644:166::-;34784:18;34780:1;34772:6;34768:14;34761:42;34644:166;:::o;34816:366::-;34958:3;34979:67;35043:2;35038:3;34979:67;:::i;:::-;34972:74;;35055:93;35144:3;35055:93;:::i;:::-;35173:2;35168:3;35164:12;35157:19;;34816:366;;;:::o;35188:419::-;35354:4;35392:2;35381:9;35377:18;35369:26;;35441:9;35435:4;35431:20;35427:1;35416:9;35412:17;35405:47;35469:131;35595:4;35469:131;:::i;:::-;35461:139;;35188:419;;;:::o;35613:545::-;35786:4;35824:3;35813:9;35809:19;35801:27;;35838:71;35906:1;35895:9;35891:17;35882:6;35838:71;:::i;:::-;35919:68;35983:2;35972:9;35968:18;35959:6;35919:68;:::i;:::-;35997:72;36065:2;36054:9;36050:18;36041:6;35997:72;:::i;:::-;36079;36147:2;36136:9;36132:18;36123:6;36079:72;:::i;:::-;35613:545;;;;;;;:::o;36164:180::-;36212:77;36209:1;36202:88;36309:4;36306:1;36299:15;36333:4;36330:1;36323:15;36350:174;36490:26;36486:1;36478:6;36474:14;36467:50;36350:174;:::o;36530:366::-;36672:3;36693:67;36757:2;36752:3;36693:67;:::i;:::-;36686:74;;36769:93;36858:3;36769:93;:::i;:::-;36887:2;36882:3;36878:12;36871:19;;36530:366;;;:::o;36902:419::-;37068:4;37106:2;37095:9;37091:18;37083:26;;37155:9;37149:4;37145:20;37141:1;37130:9;37126:17;37119:47;37183:131;37309:4;37183:131;:::i;:::-;37175:139;;36902:419;;;:::o;37327:181::-;37467:33;37463:1;37455:6;37451:14;37444:57;37327:181;:::o;37514:366::-;37656:3;37677:67;37741:2;37736:3;37677:67;:::i;:::-;37670:74;;37753:93;37842:3;37753:93;:::i;:::-;37871:2;37866:3;37862:12;37855:19;;37514:366;;;:::o;37886:419::-;38052:4;38090:2;38079:9;38075:18;38067:26;;38139:9;38133:4;38129:20;38125:1;38114:9;38110:17;38103:47;38167:131;38293:4;38167:131;:::i;:::-;38159:139;;37886:419;;;:::o;38311:221::-;38451:34;38447:1;38439:6;38435:14;38428:58;38520:4;38515:2;38507:6;38503:15;38496:29;38311:221;:::o;38538:366::-;38680:3;38701:67;38765:2;38760:3;38701:67;:::i;:::-;38694:74;;38777:93;38866:3;38777:93;:::i;:::-;38895:2;38890:3;38886:12;38879:19;;38538:366;;;:::o;38910:419::-;39076:4;39114:2;39103:9;39099:18;39091:26;;39163:9;39157:4;39153:20;39149:1;39138:9;39134:17;39127:47;39191:131;39317:4;39191:131;:::i;:::-;39183:139;;38910:419;;;:::o

ipfs://c931556f8752cc07a1bdb03c8d38dd955117b54dbb45b9acb53033cc83b5d165