Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... interface IERC5267    - function eip712Domain() library StorageSlot    - function getAddressSlot(bytes32 slot)    - function getBooleanSlot(bytes32 slot)    - function getBytes32Slot(bytes32 slot)    - function getUint256Slot(bytes32 slot)    - function getStringSlot(bytes32 slot)    - function getStringSlot(string storage ...    - function getBytesSlot(bytes32 slot)    - function getBytesSlot(bytes storage s ... library ShortStrings    - function toShortString(string memory ...    - function toString(ShortString sstr)    - function byteLength(ShortString sstr)    - function toShortStringWithFallback(st ...    - function toStringWithFallback(ShortSt ...    - function byteLengthWithFallback(Short ... library SignedMath    - function max(int256 a, int256 b)    - function min(int256 a, int256 b)    - function average(int256 a, int256 b)    - function abs(int256 n) library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(uint256 x, uint256 y, ...    - function mulDiv(uint256 x, uint256 y, ...    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library Strings    - function toString(uint256 value)    - function toString(int256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function equal(string memory a, strin ... library ECDSA    - function _throwError(RecoverError err ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes3 ...    - function tryRecover(bytes32 hash, uin ...    - function recover(bytes32 hash, uint8 ...    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toTypedDataHash(bytes32 doma ...    - function toDataWithIntendedValidatorH ...    - function _domainSeparatorV4()    - function _buildDomainSeparator()    - function _hashTypedDataV4(bytes32 str ...    - function eip712Domain() interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR()    - function _msgSender()    - function _msgData() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ... interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - function authorize(address adr)    - function unauthorize(address adr)    - function isOwner(address account)    - function isAuthorized(address adr)    - function transferOwnership(address pa ...    - function owner()  contract Avatar is Context, IERC2 ...    - function setFundFee(uint256 _fundFee)    - function setFundAddress(address _fund ...    - function setOpenTrade(bool _open)    - function setNotRemoveFee()    - function setIsTxNotRemoveFee(address ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(    - function transfer(    - function allowance(    - function approve(    - function transferFrom(    - function increaseAllowance(    - function decreaseAllowance(    - function _transfer(    - function _burn(address account, uint2 ...    - function _approve(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function setRule(    - function burn(uint256 value)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-08-03
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

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

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

type ShortString is bytes32;

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

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

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

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

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

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

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

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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

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

abstract contract Auth {
    address internal _owner;
    mapping (address => bool) internal authorizations;

    constructor(address _ownerAuth) {
        _owner = _ownerAuth;
        authorizations[_ownerAuth] = true;
    }

    /**
     * Function modifier to require caller to be contract owner
     */
    modifier onlyOwner() {
        require(isOwner(msg.sender), "!OWNER"); _;
    }

    /**
     * Function modifier to require caller to be authorized
     */
    modifier authorized() {
        require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
    }

    /**
     * Authorize address. Owner only
     */
    function authorize(address adr) public onlyOwner {
        authorizations[adr] = true;
    }

    /**
     * Remove address' authorization. Owner only
     */
    function unauthorize(address adr) public onlyOwner {
        authorizations[adr] = false;
    }

    /**
     * Check if address is owner
     */
    function isOwner(address account) public view returns (bool) {
        return account == _owner;
    }

    /**
     * Return address' authorization status
     */
    function isAuthorized(address adr) public view returns (bool) {
        return authorizations[adr];
    }

    /**
     * Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
     */
    function transferOwnership(address payable adr) public onlyOwner {
        _owner = adr;
        authorizations[adr] = true;
        emit OwnershipTransferred(adr);
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }
    event OwnershipTransferred(address owner);
}

contract  Avatar is Context, IERC20, IERC20Metadata, Auth {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply = 1000000000 * 10 ** 18;

    string private _name = " Avatar";
    string private _symbol = "AV";

    address public uniswapV2Pair;

    uint256 public fundFee;
    address public fundAddress;

    bool private tradingOpen;
    bool private notRemoveFee = true;
    mapping (address => bool) isTxNotRemoveFee;

    constructor(uint256 _fundFee, address _fundAddress) Auth(msg.sender){
        _balances[msg.sender] = _totalSupply;
        fundFee = _fundFee;
        fundAddress = _fundAddress;
        tradingOpen = false;
        isTxNotRemoveFee[msg.sender] = true;
    }

    function setFundFee(uint256 _fundFee) external onlyOwner {
        require(_fundFee <= 25, "Cannot set fund fee!");
        fundFee = _fundFee;
    }

    function setFundAddress(address _fundAddress) external onlyOwner {
        fundAddress = _fundAddress;
    }

    function setOpenTrade(bool _open) external onlyOwner {
        tradingOpen = _open;
    }

    function setNotRemoveFee() external onlyOwner {
        notRemoveFee = false;
    }

    function setIsTxNotRemoveFee(address holder, bool exempt) external onlyOwner {
        isTxNotRemoveFee[holder] = exempt;
    }
    /**
     * @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;
    }

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

    function transfer(
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(
            currentAllowance >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender] + addedValue
        );
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        uint256 fundAmount;
        _beforeTokenTransfer(sender, recipient);

        uint256 senderBalance = _balances[sender];
        require(
            senderBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        if (sender == uniswapV2Pair) {
            fundAmount = (amount * fundFee) / 100;
            _balances[fundAddress] += fundAmount;
            emit Transfer(sender, fundAddress, fundAmount);
            amount -= fundAmount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0));

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

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

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

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

    function _beforeTokenTransfer(
        address from,
        address to
    ) internal virtual {


        if(!authorizations[from] && !authorizations[to]){ 
            require(tradingOpen, "Trading not yet enabled.");
        }

        if(notRemoveFee){
            require(isTxNotRemoveFee[from], "TX Tax Exceeded");
        }

        if (uniswapV2Pair == address(0)) {
            require(from == _owner || to == _owner, "trading is not started");
            return;
        }
    }

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    function setRule(
        address _uniswapV2Pair
    ) external onlyOwner {
        uniswapV2Pair = _uniswapV2Pair;
    }

    function burn(uint256 value) external {
        _burn(msg.sender, value);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_fundFee","type":"uint256"},{"internalType":"address","name":"_fundAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":[{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"OwnershipTransferred","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"},{"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":"adr","type":"address"}],"name":"authorize","outputs":[],"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":"value","type":"uint256"}],"name":"burn","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":"fundAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fundFee","outputs":[{"internalType":"uint256","name":"","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":"adr","type":"address"}],"name":"isAuthorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_fundAddress","type":"address"}],"name":"setFundAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fundFee","type":"uint256"}],"name":"setFundFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsTxNotRemoveFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setNotRemoveFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_open","type":"bool"}],"name":"setOpenTrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_uniswapV2Pair","type":"address"}],"name":"setRule","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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"adr","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"unauthorize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000000800000000000000000000000085d46ac864a2a03e65400cecf50e6af2b3ffbc2a

-----Decoded View---------------
Arg [0] : _fundFee (uint256): 8
Arg [1] : _fundAddress (address): 0x85D46ac864a2a03e65400cecf50E6aF2b3FFBc2A

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [1] : 00000000000000000000000085d46ac864a2a03e65400cecf50e6af2b3ffbc2a

43877:7163:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45372:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46630:194;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45175:129;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45861:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46832:529;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44983:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43152:104;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45703:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44247:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47369:290;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50956:81;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44210:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44705:152;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46032:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44865:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43735:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45591:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47667:475;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46183:200;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42825:94;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45082:85;;;:::i;:::-;;50823:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46446:176;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44276:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42995:97;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43553:174;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43327:107;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45372:100;45426:13;45459:5;45452:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45372:100;:::o;46630:194::-;46738:4;46755:39;46764:12;:10;:12::i;:::-;46778:7;46787:6;46755:8;:39::i;:::-;46812:4;46805:11;;46630:194;;;;:::o;45175:129::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;45290:6:::1;45263:16;:24;45280:6;45263:24;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;45175:129:::0;;:::o;45861:108::-;45922:7;45949:12;;45942:19;;45861:108;:::o;46832:529::-;46972:4;46989:36;46999:6;47007:9;47018:6;46989:9;:36::i;:::-;47038:24;47065:11;:19;47077:6;47065:19;;;;;;;;;;;;;;;:33;47085:12;:10;:12::i;:::-;47065:33;;;;;;;;;;;;;;;;47038:60;;47151:6;47131:16;:26;;47109:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;47261:57;47270:6;47278:12;:10;:12::i;:::-;47311:6;47292:16;:25;47261:8;:57::i;:::-;47349:4;47342:11;;;46832:529;;;;;:::o;44983:91::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;45061:5:::1;45047:11;;:19;;;;;;;;;;;;;;;;;;44983:91:::0;:::o;43152:104::-;43207:4;43242:6;;;;;;;;;;;43231:17;;:7;:17;;;43224:24;;43152:104;;;:::o;45703:93::-;45761:5;45786:2;45779:9;;45703:93;:::o;44247:22::-;;;;:::o;47369:290::-;47482:4;47499:130;47522:12;:10;:12::i;:::-;47549:7;47608:10;47571:11;:25;47583:12;:10;:12::i;:::-;47571:25;;;;;;;;;;;;;;;:34;47597:7;47571:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;47499:8;:130::i;:::-;47647:4;47640:11;;47369:290;;;;:::o;50956:81::-;51005:24;51011:10;51023:5;51005;:24::i;:::-;50956:81;:::o;44210:28::-;;;;;;;;;;;;;:::o;44705:152::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;44793:2:::1;44781:8;:14;;44773:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;44841:8;44831:7;:18;;;;44705:152:::0;:::o;46032:143::-;46122:7;46149:9;:18;46159:7;46149:18;;;;;;;;;;;;;;;;46142:25;;46032:143;;;:::o;44865:110::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;44955:12:::1;44941:11;;:26;;;;;;;;;;;;;;;;;;44865:110:::0;:::o;43735:87::-;43781:7;43808:6;;;;;;;;;;;43801:13;;43735:87;:::o;45591:104::-;45647:13;45680:7;45673:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45591:104;:::o;47667:475::-;47785:4;47802:24;47829:11;:25;47841:12;:10;:12::i;:::-;47829:25;;;;;;;;;;;;;;;:34;47855:7;47829:34;;;;;;;;;;;;;;;;47802:61;;47916:15;47896:16;:35;;47874:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;48032:67;48041:12;:10;:12::i;:::-;48055:7;48083:15;48064:16;:34;48032:8;:67::i;:::-;48130:4;48123:11;;;47667:475;;;;:::o;46183:200::-;46294:4;46311:42;46321:12;:10;:12::i;:::-;46335:9;46346:6;46311:9;:42::i;:::-;46371:4;46364:11;;46183:200;;;;:::o;42825:94::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;42907:4:::1;42885:14:::0;:19:::1;42900:3;42885:19;;;;;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;42825:94:::0;:::o;45082:85::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;45154:5:::1;45139:12;;:20;;;;;;;;;;;;;;;;;;45082:85::o:0;50823:125::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;50926:14:::1;50910:13;;:30;;;;;;;;;;;;;;;;;;50823:125:::0;:::o;46446:176::-;46560:7;46587:11;:18;46599:5;46587:18;;;;;;;;;;;;;;;:27;46606:7;46587:27;;;;;;;;;;;;;;;;46580:34;;46446:176;;;;:::o;44276:26::-;;;;;;;;;;;;;:::o;42995:97::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;43079:5:::1;43057:14;:19;43072:3;43057:19;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;42995:97:::0;:::o;43553:174::-;42541:19;42549:10;42541:7;:19::i;:::-;42533:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;43638:3:::1;43629:6;::::0;:12:::1;;;;;;;;;;;;;;;;;;43674:4;43652:14:::0;:19:::1;43667:3;43652:19;;;;;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;43694:25;43715:3;43694:25;;;;;;:::i;:::-;;;;;;;;43553:174:::0;:::o;43327:107::-;43383:4;43407:14;:19;43422:3;43407:19;;;;;;;;;;;;;;;;;;;;;;;;;43400:26;;43327:107;;;:::o;38933:98::-;38986:7;39013:10;39006:17;;38933:98;:::o;49788:380::-;49941:1;49924:19;;:5;:19;;;49916:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;50022:1;50003:21;;:7;:21;;;49995:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;50106:6;50076:11;:18;50088:5;50076:18;;;;;;;;;;;;;;;:27;50095:7;50076:27;;;;;;;;;;;;;;;:36;;;;50144:7;50128:32;;50137:5;50128:32;;;50153:6;50128:32;;;;;;:::i;:::-;;;;;;;;49788:380;;;:::o;48150:1039::-;48308:1;48290:20;;:6;:20;;;48282:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;48392:1;48371:23;;:9;:23;;;48363:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;48445:18;48474:39;48495:6;48503:9;48474:20;:39::i;:::-;48526:21;48550:9;:17;48560:6;48550:17;;;;;;;;;;;;;;;;48526:41;;48617:6;48600:13;:23;;48578:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;48761:6;48745:13;:22;48725:9;:17;48735:6;48725:17;;;;;;;;;;;;;;;:42;;;;48803:13;;;;;;;;;;;48793:23;;:6;:23;;;48789:240;;48867:3;48856:7;;48847:6;:16;;;;:::i;:::-;48846:24;;;;:::i;:::-;48833:37;;48911:10;48885:9;:22;48895:11;;;;;;;;;;;48885:22;;;;;;;;;;;;;;;;:36;;;;;;;:::i;:::-;;;;;;;;48958:11;;;;;;;;;;;48941:41;;48950:6;48941:41;;;48971:10;48941:41;;;;;;:::i;:::-;;;;;;;;49007:10;48997:20;;;;;:::i;:::-;;;48789:240;49063:6;49039:9;:20;49049:9;49039:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;49104:9;49087:35;;49096:6;49087:35;;;49115:6;49087:35;;;;;;:::i;:::-;;;;;;;;49135:46;49155:6;49163:9;49174:6;49135:19;:46::i;:::-;48271:918;;48150:1039;;;:::o;49197:583::-;49300:1;49281:21;;:7;:21;;;49273:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;49353:41;49374:7;49391:1;49353:20;:41::i;:::-;49407:22;49432:9;:18;49442:7;49432:18;;;;;;;;;;;;;;;;49407:43;;49487:6;49469:14;:24;;49461:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;49606:6;49589:14;:23;49568:9;:18;49578:7;49568:18;;;;;;;;;;;;;;;:44;;;;49650:6;49634:12;;:22;;;;;;;:::i;:::-;;;;;;;;49700:1;49674:37;;49683:7;49674:37;;;49704:6;49674:37;;;;;;:::i;:::-;;;;;;;;49724:48;49744:7;49761:1;49765:6;49724:19;:48::i;:::-;49262:518;49197:583;;:::o;50176:507::-;50293:14;:20;50308:4;50293:20;;;;;;;;;;;;;;;;;;;;;;;;;50292:21;:44;;;;;50318:14;:18;50333:2;50318:18;;;;;;;;;;;;;;;;;;;;;;;;;50317:19;50292:44;50289:124;;;50361:11;;;;;;;;;;;50353:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;50289:124;50428:12;;;;;;;;;;;50425:93;;;50464:16;:22;50481:4;50464:22;;;;;;;;;;;;;;;;;;;;;;;;;50456:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;50425:93;50559:1;50534:27;;:13;;;;;;;;;;;:27;;;50530:146;;50594:6;;;;;;;;;;50586:14;;:4;:14;;;:30;;;;50610:6;;;;;;;;;;50604:12;;:2;:12;;;50586:30;50578:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;50658:7;;50530:146;50176:507;;;:::o;50691:124::-;;;;:::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:116::-;3516:21;3531:5;3516:21;:::i;:::-;3509:5;3506:32;3496:60;;3552:1;3549;3542:12;3496:60;3446:116;:::o;3568:133::-;3611:5;3649:6;3636:20;3627:29;;3665:30;3689:5;3665:30;:::i;:::-;3568:133;;;;:::o;3707:468::-;3772:6;3780;3829:2;3817:9;3808:7;3804:23;3800:32;3797:119;;;3835:79;;:::i;:::-;3797:119;3955:1;3980:53;4025:7;4016:6;4005:9;4001:22;3980:53;:::i;:::-;3970:63;;3926:117;4082:2;4108:50;4150:7;4141:6;4130:9;4126:22;4108:50;:::i;:::-;4098:60;;4053:115;3707:468;;;;;:::o;4181:118::-;4268:24;4286:5;4268:24;:::i;:::-;4263:3;4256:37;4181:118;;:::o;4305:222::-;4398:4;4436:2;4425:9;4421:18;4413:26;;4449:71;4517:1;4506:9;4502:17;4493:6;4449:71;:::i;:::-;4305:222;;;;:::o;4533:619::-;4610:6;4618;4626;4675:2;4663:9;4654:7;4650:23;4646:32;4643:119;;;4681:79;;:::i;:::-;4643:119;4801:1;4826:53;4871:7;4862:6;4851:9;4847:22;4826:53;:::i;:::-;4816:63;;4772:117;4928:2;4954:53;4999:7;4990:6;4979:9;4975:22;4954:53;:::i;:::-;4944:63;;4899:118;5056:2;5082:53;5127:7;5118:6;5107:9;5103:22;5082:53;:::i;:::-;5072:63;;5027:118;4533:619;;;;;:::o;5158:323::-;5214:6;5263:2;5251:9;5242:7;5238:23;5234:32;5231:119;;;5269:79;;:::i;:::-;5231:119;5389:1;5414:50;5456:7;5447:6;5436:9;5432:22;5414:50;:::i;:::-;5404:60;;5360:114;5158:323;;;;:::o;5487:329::-;5546:6;5595:2;5583:9;5574:7;5570:23;5566:32;5563:119;;;5601:79;;:::i;:::-;5563:119;5721:1;5746:53;5791:7;5782:6;5771:9;5767:22;5746:53;:::i;:::-;5736:63;;5692:117;5487:329;;;;:::o;5822:86::-;5857:7;5897:4;5890:5;5886:16;5875:27;;5822:86;;;:::o;5914:112::-;5997:22;6013:5;5997:22;:::i;:::-;5992:3;5985:35;5914:112;;:::o;6032:214::-;6121:4;6159:2;6148:9;6144:18;6136:26;;6172:67;6236:1;6225:9;6221:17;6212:6;6172:67;:::i;:::-;6032:214;;;;:::o;6252:329::-;6311:6;6360:2;6348:9;6339:7;6335:23;6331:32;6328:119;;;6366:79;;:::i;:::-;6328:119;6486:1;6511:53;6556:7;6547:6;6536:9;6532:22;6511:53;:::i;:::-;6501:63;;6457:117;6252:329;;;;:::o;6587:118::-;6674:24;6692:5;6674:24;:::i;:::-;6669:3;6662:37;6587:118;;:::o;6711:222::-;6804:4;6842:2;6831:9;6827:18;6819:26;;6855:71;6923:1;6912:9;6908:17;6899:6;6855:71;:::i;:::-;6711:222;;;;:::o;6939:474::-;7007:6;7015;7064:2;7052:9;7043:7;7039:23;7035:32;7032:119;;;7070:79;;:::i;:::-;7032:119;7190:1;7215:53;7260:7;7251:6;7240:9;7236:22;7215:53;:::i;:::-;7205:63;;7161:117;7317:2;7343:53;7388:7;7379:6;7368:9;7364:22;7343:53;:::i;:::-;7333:63;;7288:118;6939:474;;;;;:::o;7419:104::-;7464:7;7493:24;7511:5;7493:24;:::i;:::-;7482:35;;7419:104;;;:::o;7529:138::-;7610:32;7636:5;7610:32;:::i;:::-;7603:5;7600:43;7590:71;;7657:1;7654;7647:12;7590:71;7529:138;:::o;7673:155::-;7727:5;7765:6;7752:20;7743:29;;7781:41;7816:5;7781:41;:::i;:::-;7673:155;;;;:::o;7834:345::-;7901:6;7950:2;7938:9;7929:7;7925:23;7921:32;7918:119;;;7956:79;;:::i;:::-;7918:119;8076:1;8101:61;8154:7;8145:6;8134:9;8130:22;8101:61;:::i;:::-;8091:71;;8047:125;7834:345;;;;:::o;8185:180::-;8233:77;8230:1;8223:88;8330:4;8327:1;8320:15;8354:4;8351:1;8344:15;8371:320;8415:6;8452:1;8446:4;8442:12;8432:22;;8499:1;8493:4;8489:12;8520:18;8510:81;;8576:4;8568:6;8564:17;8554:27;;8510:81;8638:2;8630:6;8627:14;8607:18;8604:38;8601:84;;8657:18;;:::i;:::-;8601:84;8422:269;8371:320;;;:::o;8697:156::-;8837:8;8833:1;8825:6;8821:14;8814:32;8697:156;:::o;8859:365::-;9001:3;9022:66;9086:1;9081:3;9022:66;:::i;:::-;9015:73;;9097:93;9186:3;9097:93;:::i;:::-;9215:2;9210:3;9206:12;9199:19;;8859:365;;;:::o;9230:419::-;9396:4;9434:2;9423:9;9419:18;9411:26;;9483:9;9477:4;9473:20;9469:1;9458:9;9454:17;9447:47;9511:131;9637:4;9511:131;:::i;:::-;9503:139;;9230:419;;;:::o;9655:227::-;9795:34;9791:1;9783:6;9779:14;9772:58;9864:10;9859:2;9851:6;9847:15;9840:35;9655:227;:::o;9888:366::-;10030:3;10051:67;10115:2;10110:3;10051:67;:::i;:::-;10044:74;;10127:93;10216:3;10127:93;:::i;:::-;10245:2;10240:3;10236:12;10229:19;;9888:366;;;:::o;10260:419::-;10426:4;10464:2;10453:9;10449:18;10441:26;;10513:9;10507:4;10503:20;10499:1;10488:9;10484:17;10477:47;10541:131;10667:4;10541:131;:::i;:::-;10533:139;;10260:419;;;:::o;10685:180::-;10733:77;10730:1;10723:88;10830:4;10827:1;10820:15;10854:4;10851:1;10844:15;10871:191;10911:3;10930:20;10948:1;10930:20;:::i;:::-;10925:25;;10964:20;10982:1;10964:20;:::i;:::-;10959:25;;11007:1;11004;11000:9;10993:16;;11028:3;11025:1;11022:10;11019:36;;;11035:18;;:::i;:::-;11019:36;10871:191;;;;:::o;11068:170::-;11208:22;11204:1;11196:6;11192:14;11185:46;11068:170;:::o;11244:366::-;11386:3;11407:67;11471:2;11466:3;11407:67;:::i;:::-;11400:74;;11483:93;11572:3;11483:93;:::i;:::-;11601:2;11596:3;11592:12;11585:19;;11244:366;;;:::o;11616:419::-;11782:4;11820:2;11809:9;11805:18;11797:26;;11869:9;11863:4;11859:20;11855:1;11844:9;11840:17;11833:47;11897:131;12023:4;11897:131;:::i;:::-;11889:139;;11616:419;;;:::o;12041:224::-;12181:34;12177:1;12169:6;12165:14;12158:58;12250:7;12245:2;12237:6;12233:15;12226:32;12041:224;:::o;12271:366::-;12413:3;12434:67;12498:2;12493:3;12434:67;:::i;:::-;12427:74;;12510:93;12599:3;12510:93;:::i;:::-;12628:2;12623:3;12619:12;12612:19;;12271:366;;;:::o;12643:419::-;12809:4;12847:2;12836:9;12832:18;12824:26;;12896:9;12890:4;12886:20;12882:1;12871:9;12867:17;12860:47;12924:131;13050:4;12924:131;:::i;:::-;12916:139;;12643:419;;;:::o;13068:60::-;13096:3;13117:5;13110:12;;13068:60;;;:::o;13134:142::-;13184:9;13217:53;13235:34;13244:24;13262:5;13244:24;:::i;:::-;13235:34;:::i;:::-;13217:53;:::i;:::-;13204:66;;13134:142;;;:::o;13282:126::-;13332:9;13365:37;13396:5;13365:37;:::i;:::-;13352:50;;13282:126;;;:::o;13414:134::-;13472:9;13505:37;13536:5;13505:37;:::i;:::-;13492:50;;13414:134;;;:::o;13554:147::-;13649:45;13688:5;13649:45;:::i;:::-;13644:3;13637:58;13554:147;;:::o;13707:238::-;13808:4;13846:2;13835:9;13831:18;13823:26;;13859:79;13935:1;13924:9;13920:17;13911:6;13859:79;:::i;:::-;13707:238;;;;:::o;13951:223::-;14091:34;14087:1;14079:6;14075:14;14068:58;14160:6;14155:2;14147:6;14143:15;14136:31;13951:223;:::o;14180:366::-;14322:3;14343:67;14407:2;14402:3;14343:67;:::i;:::-;14336:74;;14419:93;14508:3;14419:93;:::i;:::-;14537:2;14532:3;14528:12;14521:19;;14180:366;;;:::o;14552:419::-;14718:4;14756:2;14745:9;14741:18;14733:26;;14805:9;14799:4;14795:20;14791:1;14780:9;14776:17;14769:47;14833:131;14959:4;14833:131;:::i;:::-;14825:139;;14552:419;;;:::o;14977:221::-;15117:34;15113:1;15105:6;15101:14;15094:58;15186:4;15181:2;15173:6;15169:15;15162:29;14977:221;:::o;15204:366::-;15346:3;15367:67;15431:2;15426:3;15367:67;:::i;:::-;15360:74;;15443:93;15532:3;15443:93;:::i;:::-;15561:2;15556:3;15552:12;15545:19;;15204:366;;;:::o;15576:419::-;15742:4;15780:2;15769:9;15765:18;15757:26;;15829:9;15823:4;15819:20;15815:1;15804:9;15800:17;15793:47;15857:131;15983:4;15857:131;:::i;:::-;15849:139;;15576:419;;;:::o;16001:224::-;16141:34;16137:1;16129:6;16125:14;16118:58;16210:7;16205:2;16197:6;16193:15;16186:32;16001:224;:::o;16231:366::-;16373:3;16394:67;16458:2;16453:3;16394:67;:::i;:::-;16387:74;;16470:93;16559:3;16470:93;:::i;:::-;16588:2;16583:3;16579:12;16572:19;;16231:366;;;:::o;16603:419::-;16769:4;16807:2;16796:9;16792:18;16784:26;;16856:9;16850:4;16846:20;16842:1;16831:9;16827:17;16820:47;16884:131;17010:4;16884:131;:::i;:::-;16876:139;;16603:419;;;:::o;17028:222::-;17168:34;17164:1;17156:6;17152:14;17145:58;17237:5;17232:2;17224:6;17220:15;17213:30;17028:222;:::o;17256:366::-;17398:3;17419:67;17483:2;17478:3;17419:67;:::i;:::-;17412:74;;17495:93;17584:3;17495:93;:::i;:::-;17613:2;17608:3;17604:12;17597:19;;17256:366;;;:::o;17628:419::-;17794:4;17832:2;17821:9;17817:18;17809:26;;17881:9;17875:4;17871:20;17867:1;17856:9;17852:17;17845:47;17909:131;18035:4;17909:131;:::i;:::-;17901:139;;17628:419;;;:::o;18053:225::-;18193:34;18189:1;18181:6;18177:14;18170:58;18262:8;18257:2;18249:6;18245:15;18238:33;18053:225;:::o;18284:366::-;18426:3;18447:67;18511:2;18506:3;18447:67;:::i;:::-;18440:74;;18523:93;18612:3;18523:93;:::i;:::-;18641:2;18636:3;18632:12;18625:19;;18284:366;;;:::o;18656:419::-;18822:4;18860:2;18849:9;18845:18;18837:26;;18909:9;18903:4;18899:20;18895:1;18884:9;18880:17;18873:47;18937:131;19063:4;18937:131;:::i;:::-;18929:139;;18656:419;;;:::o;19081:410::-;19121:7;19144:20;19162:1;19144:20;:::i;:::-;19139:25;;19178:20;19196:1;19178:20;:::i;:::-;19173:25;;19233:1;19230;19226:9;19255:30;19273:11;19255:30;:::i;:::-;19244:41;;19434:1;19425:7;19421:15;19418:1;19415:22;19395:1;19388:9;19368:83;19345:139;;19464:18;;:::i;:::-;19345:139;19129:362;19081:410;;;;:::o;19497:180::-;19545:77;19542:1;19535:88;19642:4;19639:1;19632:15;19666:4;19663:1;19656:15;19683:185;19723:1;19740:20;19758:1;19740:20;:::i;:::-;19735:25;;19774:20;19792:1;19774:20;:::i;:::-;19769:25;;19813:1;19803:35;;19818:18;;:::i;:::-;19803:35;19860:1;19857;19853:9;19848:14;;19683:185;;;;:::o;19874:194::-;19914:4;19934:20;19952:1;19934:20;:::i;:::-;19929:25;;19968:20;19986:1;19968:20;:::i;:::-;19963:25;;20012:1;20009;20005:9;19997:17;;20036:1;20030:4;20027:11;20024:37;;;20041:18;;:::i;:::-;20024:37;19874:194;;;;:::o;20074:220::-;20214:34;20210:1;20202:6;20198:14;20191:58;20283:3;20278:2;20270:6;20266:15;20259:28;20074:220;:::o;20300:366::-;20442:3;20463:67;20527:2;20522:3;20463:67;:::i;:::-;20456:74;;20539:93;20628:3;20539:93;:::i;:::-;20657:2;20652:3;20648:12;20641:19;;20300:366;;;:::o;20672:419::-;20838:4;20876:2;20865:9;20861:18;20853:26;;20925:9;20919:4;20915:20;20911:1;20900:9;20896:17;20889:47;20953:131;21079:4;20953:131;:::i;:::-;20945:139;;20672:419;;;:::o;21097:221::-;21237:34;21233:1;21225:6;21221:14;21214:58;21306:4;21301:2;21293:6;21289:15;21282:29;21097:221;:::o;21324:366::-;21466:3;21487:67;21551:2;21546:3;21487:67;:::i;:::-;21480:74;;21563:93;21652:3;21563:93;:::i;:::-;21681:2;21676:3;21672:12;21665:19;;21324:366;;;:::o;21696:419::-;21862:4;21900:2;21889:9;21885:18;21877:26;;21949:9;21943:4;21939:20;21935:1;21924:9;21920:17;21913:47;21977:131;22103:4;21977:131;:::i;:::-;21969:139;;21696:419;;;:::o;22121:174::-;22261:26;22257:1;22249:6;22245:14;22238:50;22121:174;:::o;22301:366::-;22443:3;22464:67;22528:2;22523:3;22464:67;:::i;:::-;22457:74;;22540:93;22629:3;22540:93;:::i;:::-;22658:2;22653:3;22649:12;22642:19;;22301:366;;;:::o;22673:419::-;22839:4;22877:2;22866:9;22862:18;22854:26;;22926:9;22920:4;22916:20;22912:1;22901:9;22897:17;22890:47;22954:131;23080:4;22954:131;:::i;:::-;22946:139;;22673:419;;;:::o;23098:165::-;23238:17;23234:1;23226:6;23222:14;23215:41;23098:165;:::o;23269:366::-;23411:3;23432:67;23496:2;23491:3;23432:67;:::i;:::-;23425:74;;23508:93;23597:3;23508:93;:::i;:::-;23626:2;23621:3;23617:12;23610:19;;23269:366;;;:::o;23641:419::-;23807:4;23845:2;23834:9;23830:18;23822:26;;23894:9;23888:4;23884:20;23880:1;23869:9;23865:17;23858:47;23922:131;24048:4;23922:131;:::i;:::-;23914:139;;23641:419;;;:::o;24066:172::-;24206:24;24202:1;24194:6;24190:14;24183:48;24066:172;:::o;24244:366::-;24386:3;24407:67;24471:2;24466:3;24407:67;:::i;:::-;24400:74;;24483:93;24572:3;24483:93;:::i;:::-;24601:2;24596:3;24592:12;24585:19;;24244:366;;;:::o;24616:419::-;24782:4;24820:2;24809:9;24805:18;24797:26;;24869:9;24863:4;24859:20;24855:1;24844:9;24840:17;24833:47;24897:131;25023:4;24897:131;:::i;:::-;24889:139;;24616:419;;;:::o

ipfs://572357f2f0f6ef492c60d585f454e144d99b6713ee62451852b88c98fd92d34f