Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

/*

Telegram - https://t.me/the_number_game 
Twitter - https://twitter.com/numberscoin
Website - https://numberscoin.info

    _______ _            _   _                 _                  _____                      
   |__   __| |          | \ | |               | |                / ____|                     
      | |  | |__   ___  |  \| |_   _ _ __ ___ | |__   ___ _ __  | |  __  __ _ _ __ ___   ___ 
      | |  | '_ \ / _ \ | . ` | | | | '_ ` _ \| '_ \ / _ \ '__| | | |_ |/ _` | '_ ` _ \ / _ \
      | |  | | | |  __/ | |\  | |_| | | | | | | |_) |  __/ |    | |__| | (_| | | | | | |  __/
      |_|  |_| |_|\___| |_| \_|\__,_|_| |_| |_|_.__/ \___|_|     \_____|\__,_|_| |_| |_|\___|

Welcome to The Number Game. Here are the rules:

▶ There are 10 levels. Each level gets 10x harder to guess the number correctly than the last.
  For example, on level 1 the chances of guessing correctly are 1/10.
  On level 2 the chances of guessing correctly are 1/100.
  On level 3 the chances of guessing correctly are 1/1000.
  And so on...

▶ Anyone can guess a number using the guessNumber() function. 
  Each player's guesses are unique to their public address, so MEV is not an issue.

▶ If a player guesses the number correctly, the player will be able to successfully claim 1% of the total supply of tokens.
  The game will then proceed to the next level each time a prize is claimed until the game is over after level 10.

▶ Finally, in order to claim the prize a player must own at least 0.1% of the total supply.

Good luck!

*/

pragma solidity ^0.8.21;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

pragma solidity ^0.8.21;

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

pragma solidity ^0.8.21;

library SafeMath {
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

pragma solidity ^0.8.4;

/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The `length` of the output is too small to contain all the hex digits.
    error HexLengthInsufficient();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when the `search` is not found in the string.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     DECIMAL OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            let w := not(0) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 1)`.
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        unchecked {
            str = toString(uint256(-value));
        }
        /// @solidity memory-safe-assembly
        assembly {
            // We still have some spare memory space on the left,
            // as we have allocated 3 words (96 bytes) for up to 78 digits.
            let length := mload(str) // Load the string length.
            mstore(str, 0x2d) // Store the '-' character.
            str := sub(str, 1) // Move back the string pointer by a byte.
            mstore(str, add(length, 1)) // Update the string length.
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   HEXADECIMAL OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2 + 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value, length);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexStringNoPrefix(uint256 value, uint256 length)
        internal
        pure
        returns (string memory str)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes
            // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.
            // We add 0x20 to the total and round down to a multiple of 0x20.
            // (0x20 + 0x20 + 0x02 + 0x20) = 0x62.
            str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let start := sub(str, add(length, length))
            let w := not(1) // Tsk.
            let temp := value
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for {} 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(xor(str, start)) { break }
            }

            if temp {
                // Store the function selector of `HexLengthInsufficient()`.
                mstore(0x00, 0x2194895a)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2 + 2` bytes.
    function toHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x".
    /// The output excludes leading "0" from the `toHexString` output.
    /// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`.
    function toMinimalHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(add(str, o), 0x3078) // Write the "0x" prefix, accounting for leading zero.
            str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero.
            mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output excludes leading "0" from the `toHexStringNoPrefix` output.
    /// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`.
    function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
            let strLength := mload(str) // Get the length.
            str := add(str, o) // Move the pointer, accounting for leading zero.
            mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2` bytes.
    function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x40 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.
            str := add(mload(0x40), 0x80)
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let w := not(1) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(temp) { break }
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte,
    /// and the alphabets are capitalized conditionally according to
    /// https://eips.ethereum.org/EIPS/eip-55
    function toHexStringChecksummed(address value) internal pure returns (string memory str) {
        str = toHexString(value);
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
            let o := add(str, 0x22)
            let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `
            let t := shl(240, 136) // `0b10001000 << 240`
            for { let i := 0 } 1 {} {
                mstore(add(i, i), mul(t, byte(i, hashed)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
            mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
            o := add(o, 0x20)
            mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    function toHexString(address value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(address value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            str := mload(0x40)

            // Allocate the memory.
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x28 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.
            mstore(0x40, add(str, 0x80))

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            str := add(str, 2)
            mstore(str, 40)

            let o := add(str, 0x20)
            mstore(add(o, 40), 0)

            value := shl(96, value)

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let i := 0 } 1 {} {
                let p := add(o, add(i, i))
                let temp := byte(i, value)
                mstore8(add(p, 1), mload(and(temp, 15)))
                mstore8(p, mload(shr(4, temp)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexString(bytes memory raw) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(raw);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(raw)
            str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
            mstore(str, add(length, length)) // Store the length of the output.

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let o := add(str, 0x20)
            let end := add(raw, length)

            for {} iszero(eq(raw, end)) {} {
                raw := add(raw, 1)
                mstore8(add(o, 1), mload(and(mload(raw), 15)))
                mstore8(o, mload(and(shr(4, mload(raw)), 15)))
                o := add(o, 2)
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate the memory.
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   RUNE STRING OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the number of UTF characters in the string.
    function runeCount(string memory s) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(s) {
                mstore(0x00, div(not(0), 255))
                mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)
                let o := add(s, 0x20)
                let end := add(o, mload(s))
                for { result := 1 } 1 { result := add(result, 1) } {
                    o := add(o, byte(0, mload(shr(250, mload(o)))))
                    if iszero(lt(o, end)) { break }
                }
            }
        }
    }

    /// @dev Returns if this string is a 7-bit ASCII string.
    /// (i.e. all characters codes are in [0..127])
    function is7BitASCII(string memory s) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(7, div(not(0), 255))
            result := 1
            let n := mload(s)
            if n {
                let o := add(s, 0x20)
                let end := add(o, n)
                let last := mload(end)
                mstore(end, 0)
                for {} 1 {} {
                    if and(mask, mload(o)) {
                        result := 0
                        break
                    }
                    o := add(o, 0x20)
                    if iszero(lt(o, end)) { break }
                }
                mstore(end, last)
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   BYTE STRING OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // For performance and bytecode compactness, all indices of the following operations
    // are byte (ASCII) offsets, not UTF character offsets.

    /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.
    function replace(string memory subject, string memory search, string memory replacement)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)
            let replacementLength := mload(replacement)

            subject := add(subject, 0x20)
            search := add(search, 0x20)
            replacement := add(replacement, 0x20)
            result := add(mload(0x40), 0x20)

            let subjectEnd := add(subject, subjectLength)
            if iszero(gt(searchLength, subjectLength)) {
                let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                mstore(result, t)
                                result := add(result, 1)
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Copy the `replacement` one word at a time.
                        for { let o := 0 } 1 {} {
                            mstore(add(result, o), mload(add(replacement, o)))
                            o := add(o, 0x20)
                            if iszero(lt(o, replacementLength)) { break }
                        }
                        result := add(result, replacementLength)
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    mstore(result, t)
                    result := add(result, 1)
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
            }

            let resultRemainder := result
            result := add(mload(0x40), 0x20)
            let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))
            // Copy the rest of the string one word at a time.
            for {} lt(subject, subjectEnd) {} {
                mstore(resultRemainder, mload(subject))
                resultRemainder := add(resultRemainder, 0x20)
                subject := add(subject, 0x20)
            }
            result := sub(result, 0x20)
            let last := add(add(result, 0x20), k) // Zeroize the slot after the string.
            mstore(last, 0)
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
            mstore(result, k) // Store the length.
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for { let subjectLength := mload(subject) } 1 {} {
                if iszero(mload(search)) {
                    if iszero(gt(from, subjectLength)) {
                        result := from
                        break
                    }
                    result := subjectLength
                    break
                }
                let searchLength := mload(search)
                let subjectStart := add(subject, 0x20)

                result := not(0) // Initialize to `NOT_FOUND`.

                subject := add(subjectStart, from)
                let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)

                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(add(search, 0x20))

                if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }

                if iszero(lt(searchLength, 0x20)) {
                    for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                        if iszero(shr(m, xor(mload(subject), s))) {
                            if eq(keccak256(subject, searchLength), h) {
                                result := sub(subject, subjectStart)
                                break
                            }
                        }
                        subject := add(subject, 1)
                        if iszero(lt(subject, end)) { break }
                    }
                    break
                }
                for {} 1 {} {
                    if iszero(shr(m, xor(mload(subject), s))) {
                        result := sub(subject, subjectStart)
                        break
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = indexOf(subject, search, 0);
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for {} 1 {} {
                result := not(0) // Initialize to `NOT_FOUND`.
                let searchLength := mload(search)
                if gt(searchLength, mload(subject)) { break }
                let w := result

                let fromMax := sub(mload(subject), searchLength)
                if iszero(gt(fromMax, from)) { from := fromMax }

                let end := add(add(subject, 0x20), w)
                subject := add(add(subject, 0x20), from)
                if iszero(gt(subject, end)) { break }
                // As this function is not too often used,
                // we shall simply use keccak256 for smaller bytecode size.
                for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                    if eq(keccak256(subject, searchLength), h) {
                        result := sub(subject, add(end, 1))
                        break
                    }
                    subject := add(subject, w) // `sub(subject, 1)`.
                    if iszero(gt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = lastIndexOf(subject, search, uint256(int256(-1)));
    }

    /// @dev Returns whether `subject` starts with `search`.
    function startsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                iszero(gt(searchLength, mload(subject))),
                eq(
                    keccak256(add(subject, 0x20), searchLength),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns whether `subject` ends with `search`.
    function endsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            let subjectLength := mload(subject)
            // Whether `search` is not longer than `subject`.
            let withinRange := iszero(gt(searchLength, subjectLength))
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                withinRange,
                eq(
                    keccak256(
                        // `subject + 0x20 + max(subjectLength - searchLength, 0)`.
                        add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),
                        searchLength
                    ),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns `subject` repeated `times`.
    function repeat(string memory subject, uint256 times)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(or(iszero(times), iszero(subjectLength))) {
                subject := add(subject, 0x20)
                result := mload(0x40)
                let output := add(result, 0x20)
                for {} 1 {} {
                    // Copy the `subject` one word at a time.
                    for { let o := 0 } 1 {} {
                        mstore(add(output, o), mload(add(subject, o)))
                        o := add(o, 0x20)
                        if iszero(lt(o, subjectLength)) { break }
                    }
                    output := add(output, subjectLength)
                    times := sub(times, 1)
                    if iszero(times) { break }
                }
                mstore(output, 0) // Zeroize the slot after the string.
                let resultLength := sub(output, add(result, 0x20))
                mstore(result, resultLength) // Store the length.
                // Allocate the memory.
                mstore(0x40, add(result, add(resultLength, 0x20)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).
    /// `start` and `end` are byte offsets.
    function slice(string memory subject, uint256 start, uint256 end)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(gt(subjectLength, end)) { end := subjectLength }
            if iszero(gt(subjectLength, start)) { start := subjectLength }
            if lt(start, end) {
                result := mload(0x40)
                let resultLength := sub(end, start)
                mstore(result, resultLength)
                subject := add(subject, start)
                let w := not(0x1f)
                // Copy the `subject` one word at a time, backwards.
                for { let o := and(add(resultLength, 0x1f), w) } 1 {} {
                    mstore(add(result, o), mload(add(subject, o)))
                    o := add(o, w) // `sub(o, 0x20)`.
                    if iszero(o) { break }
                }
                // Zeroize the slot after the string.
                mstore(add(add(result, 0x20), resultLength), 0)
                // Allocate memory for the length and the bytes,
                // rounded up to a multiple of 32.
                mstore(0x40, add(result, and(add(resultLength, 0x3f), w)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to the end of the string.
    /// `start` is a byte offset.
    function slice(string memory subject, uint256 start)
        internal
        pure
        returns (string memory result)
    {
        result = slice(subject, start, uint256(int256(-1)));
    }

    /// @dev Returns all the indices of `search` in `subject`.
    /// The indices are byte offsets.
    function indicesOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256[] memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)

            if iszero(gt(searchLength, subjectLength)) {
                subject := add(subject, 0x20)
                search := add(search, 0x20)
                result := add(mload(0x40), 0x20)

                let subjectStart := subject
                let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Append to `result`.
                        mstore(result, sub(subject, subjectStart))
                        result := add(result, 0x20)
                        // Advance `subject` by `searchLength`.
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
                let resultEnd := result
                // Assign `result` to the free memory pointer.
                result := mload(0x40)
                // Store the length of `result`.
                mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))
                // Allocate memory for result.
                // We allocate one more word, so this array can be recycled for {split}.
                mstore(0x40, add(resultEnd, 0x20))
            }
        }
    }

    /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.
    function split(string memory subject, string memory delimiter)
        internal
        pure
        returns (string[] memory result)
    {
        uint256[] memory indices = indicesOf(subject, delimiter);
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            let indexPtr := add(indices, 0x20)
            let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))
            mstore(add(indicesEnd, w), mload(subject))
            mstore(indices, add(mload(indices), 1))
            let prevIndex := 0
            for {} 1 {} {
                let index := mload(indexPtr)
                mstore(indexPtr, 0x60)
                if iszero(eq(index, prevIndex)) {
                    let element := mload(0x40)
                    let elementLength := sub(index, prevIndex)
                    mstore(element, elementLength)
                    // Copy the `subject` one word at a time, backwards.
                    for { let o := and(add(elementLength, 0x1f), w) } 1 {} {
                        mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
                        o := add(o, w) // `sub(o, 0x20)`.
                        if iszero(o) { break }
                    }
                    // Zeroize the slot after the string.
                    mstore(add(add(element, 0x20), elementLength), 0)
                    // Allocate memory for the length and the bytes,
                    // rounded up to a multiple of 32.
                    mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))
                    // Store the `element` into the array.
                    mstore(indexPtr, element)
                }
                prevIndex := add(index, mload(delimiter))
                indexPtr := add(indexPtr, 0x20)
                if iszero(lt(indexPtr, indicesEnd)) { break }
            }
            result := indices
            if iszero(mload(delimiter)) {
                result := add(indices, 0x20)
                mstore(result, sub(mload(indices), 2))
            }
        }
    }

    /// @dev Returns a concatenated string of `a` and `b`.
    /// Cheaper than `string.concat()` and does not de-align the free memory pointer.
    function concat(string memory a, string memory b)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            result := mload(0x40)
            let aLength := mload(a)
            // Copy `a` one word at a time, backwards.
            for { let o := and(add(aLength, 0x20), w) } 1 {} {
                mstore(add(result, o), mload(add(a, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let bLength := mload(b)
            let output := add(result, aLength)
            // Copy `b` one word at a time, backwards.
            for { let o := and(add(bLength, 0x20), w) } 1 {} {
                mstore(add(output, o), mload(add(b, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let totalLength := add(aLength, bLength)
            let last := add(add(result, 0x20), totalLength)
            // Zeroize the slot after the string.
            mstore(last, 0)
            // Stores the length.
            mstore(result, totalLength)
            // Allocate memory for the length and the bytes,
            // rounded up to a multiple of 32.
            mstore(0x40, and(add(last, 0x1f), w))
        }
    }

    /// @dev Returns a copy of the string in either lowercase or UPPERCASE.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function toCase(string memory subject, bool toUpper)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(subject)
            if length {
                result := add(mload(0x40), 0x20)
                subject := add(subject, 1)
                let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
                let w := not(0)
                for { let o := length } 1 {} {
                    o := add(o, w)
                    let b := and(0xff, mload(add(subject, o)))
                    mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))
                    if iszero(o) { break }
                }
                result := mload(0x40)
                mstore(result, length) // Store the length.
                let last := add(add(result, 0x20), length)
                mstore(last, 0) // Zeroize the slot after the string.
                mstore(0x40, add(last, 0x20)) // Allocate the memory.
            }
        }
    }

    /// @dev Returns a lowercased copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function lower(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, false);
    }

    /// @dev Returns an UPPERCASED copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function upper(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, true);
    }

    /// @dev Escapes the string to be used within HTML tags.
    function escapeHTML(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {
                let end := add(s, mload(s))
                result := add(mload(0x40), 0x20)
                // Store the bytes of the packed offsets and strides into the scratch space.
                // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.
                mstore(0x1f, 0x900094)
                mstore(0x08, 0xc0000000a6ab)
                // Store "&quot;&amp;&#39;&lt;&gt;" into the scratch space.
                mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
            } iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                // Not in `["\"","'","&","<",">"]`.
                if iszero(and(shl(c, 1), 0x500000c400000000)) {
                    mstore8(result, c)
                    result := add(result, 1)
                    continue
                }
                let t := shr(248, mload(c))
                mstore(result, mload(and(t, 0x1f)))
                result := add(result, shr(5, t))
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    function escapeJSON(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {
                let end := add(s, mload(s))
                result := add(mload(0x40), 0x20)
                // Store "\\u0000" in scratch space.
                // Store "0123456789abcdef" in scratch space.
                // Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`.
                // into the scratch space.
                mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
                // Bitmask for detecting `["\"","\\"]`.
                let e := or(shl(0x22, 1), shl(0x5c, 1))
            } iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                if iszero(lt(c, 0x20)) {
                    if iszero(and(shl(c, 1), e)) {
                        // Not in `["\"","\\"]`.
                        mstore8(result, c)
                        result := add(result, 1)
                        continue
                    }
                    mstore8(result, 0x5c) // "\\".
                    mstore8(add(result, 1), c)
                    result := add(result, 2)
                    continue
                }
                if iszero(and(shl(c, 1), 0x3700)) {
                    // Not in `["\b","\t","\n","\f","\d"]`.
                    mstore8(0x1d, mload(shr(4, c))) // Hex value.
                    mstore8(0x1e, mload(and(c, 15))) // Hex value.
                    mstore(result, mload(0x19)) // "\\u00XX".
                    result := add(result, 6)
                    continue
                }
                mstore8(result, 0x5c) // "\\".
                mstore8(add(result, 1), mload(add(c, 8)))
                result := add(result, 2)
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Returns whether `a` equals `b`.
    function eq(string memory a, string memory b) internal pure returns (bool result) {
        assembly {
            result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
        }
    }

    /// @dev Packs a single string with its length into a single word.
    /// Returns `bytes32(0)` if the length is zero or greater than 31.
    function packOne(string memory a) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // We don't need to zero right pad the string,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes.
                    mload(add(a, 0x1f)),
                    // `length != 0 && length < 32`. Abuses underflow.
                    // Assumes that the length is valid and within the block gas limit.
                    lt(sub(mload(a), 1), 0x1f)
                )
        }
    }

    /// @dev Unpacks a string packed using {packOne}.
    /// Returns the empty string if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packOne}, the output behaviour is undefined.
    function unpackOne(bytes32 packed) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            result := mload(0x40)
            // Allocate 2 words (1 for the length, 1 for the bytes).
            mstore(0x40, add(result, 0x40))
            // Zeroize the length slot.
            mstore(result, 0)
            // Store the length and bytes.
            mstore(add(result, 0x1f), packed)
            // Right pad with zeroes.
            mstore(add(add(result, 0x20), mload(result)), 0)
        }
    }

    /// @dev Packs two strings with their lengths into a single word.
    /// Returns `bytes32(0)` if combined length is zero or greater than 30.
    function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let aLength := mload(a)
            // We don't need to zero right pad the strings,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes of `a` and `b`.
                    or(
                        shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),
                        mload(sub(add(b, 0x1e), aLength))
                    ),
                    // `totalLength != 0 && totalLength < 31`. Abuses underflow.
                    // Assumes that the lengths are valid and within the block gas limit.
                    lt(sub(add(aLength, mload(b)), 1), 0x1e)
                )
        }
    }

    /// @dev Unpacks strings packed using {packTwo}.
    /// Returns the empty strings if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packTwo}, the output behaviour is undefined.
    function unpackTwo(bytes32 packed)
        internal
        pure
        returns (string memory resultA, string memory resultB)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            resultA := mload(0x40)
            resultB := add(resultA, 0x40)
            // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.
            mstore(0x40, add(resultB, 0x40))
            // Zeroize the length slots.
            mstore(resultA, 0)
            mstore(resultB, 0)
            // Store the lengths and bytes.
            mstore(add(resultA, 0x1f), packed)
            mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
            // Right pad with zeroes.
            mstore(add(add(resultA, 0x20), mload(resultA)), 0)
            mstore(add(add(resultB, 0x20), mload(resultB)), 0)
        }
    }

    /// @dev Directly returns `a` without copying.
    function directReturn(string memory a) internal pure {
        assembly {
            // Assumes that the string does not start from the scratch space.
            let retStart := sub(a, 0x20)
            let retSize := add(mload(a), 0x40)
            // Right pad with zeroes. Just in case the string is produced
            // by a method that doesn't zero right pad.
            mstore(add(retStart, retSize), 0)
            // Store the return offset.
            mstore(retStart, 0x20)
            // End the transaction, returning the string.
            return(retStart, retSize)
        }
    }
}

pragma solidity ^0.8.21;

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

pragma solidity ^0.8.21;


interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

pragma solidity ^0.8.21;

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

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

pragma solidity ^0.8.21;


abstract contract Ownable is Context {
    address private _owner;

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

    constructor() {
        _transferOwnership(_msgSender());
    }

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

    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

pragma solidity ^0.8.21;


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;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

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

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

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    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;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

    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;
        }
        _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, uint256 amount) internal virtual {}

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

pragma solidity ^0.8.21;

contract NumberGame is ERC20, Ownable {
    using SafeMath for uint256;

    error ZeroValue();
    error InvalidNumber();
    error GameNotActive();
    error TransferFailed();
    error DoesntEqualTotal();
    error GameNotConfigured();
    error GameAlreadyStarted();

    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable uniswapV2Pair;
    address public constant deadAddress = address(0xdead);

    bool private swapping;
    bool public gameActive;

    address private marketingWallet;
    address private devWallet;

    uint256 public maxTransactionAmount;
    uint256 public swapTokensAtAmount;
    uint256 public maxWallet;

    bool public limitsInEffect = true;
    bool public tradingActive = false;
    bool public swapEnabled = false;

    uint256 private launchedAt;
    uint256 private launchedTime;
    uint256 public deadBlocks;

    uint256 public buyTotalFees;

    uint256 public sellTotalFees;

    uint256 public numberGuessBalance;
    uint256 public currentLevel;
    uint256 public totalLevels;
    uint256 public minGuessHoldings;
    mapping(uint256 => uint256) public payoutPerLevel;

    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) public _isExcludedMaxTransactionAmount;

    mapping(address => bool) public automatedMarketMakerPairs;

    event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);

    event ExcludeFromFees(address indexed account, bool isExcluded);

    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);

    event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);

    event GameStarted();
    event GameEnded();
    event CorrectGuess(address indexed guesser, uint256 indexed level, uint256 indexed number);

    constructor() ERC20("Number Game", "NUMBER") {
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D );

        excludeFromMaxTransaction(address(_uniswapV2Router), true);
        uniswapV2Router = _uniswapV2Router;

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        excludeFromMaxTransaction(address(uniswapV2Pair), true);
        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);

        uint256 totalSupply = 1_000_000_000 * 1e18;
        // TODO: Manually define numberGuessSupply
        uint256 numberGuessSupply = 100_000_000 * 1e18;
        minGuessHoldings = 1_000_000 * 1e18;

        maxTransactionAmount = 5_000_000 * 1e18;
        maxWallet = 5_000_000 * 1e18;
        swapTokensAtAmount = 150_000 * 1e18; // 0.015% * 20 = 0.3%

        marketingWallet = msg.sender;
        devWallet = msg.sender;

        excludeFromFees(owner(), true);
        excludeFromFees(address(this), true);
        excludeFromFees(address(0xdead), true);

        excludeFromMaxTransaction(owner(), true);
        excludeFromMaxTransaction(address(this), true);
        excludeFromMaxTransaction(address(0xdead), true);

        // Adjusted supply mints to account for numberGuessSupply being stored in contract
        _mint(msg.sender, totalSupply - numberGuessSupply);
        _mint(address(this), numberGuessSupply);
        // Store the tokens allocated to number guess game for proper accounting
        numberGuessBalance = numberGuessSupply;
    }

    receive() external payable {}

    function updateMinimumTokenHoldings(uint256 _newMin) external onlyOwner {
        minGuessHoldings = _newMin * 1e18;
    }

    // Configure number guess game by specifying number of levels and the payout per level
    function configureGuessGame(uint256[] calldata _payouts) external onlyOwner {
        // Prevent reconfiguration if game has already started
        if (gameActive) { revert GameAlreadyStarted(); }
        // Store each level's payout value and tally payouts to prevent exceeding allocation
        uint256 totalPayout;
        for (uint256 i; i < _payouts.length;) {
            if (_payouts[i] == 0) { revert ZeroValue(); }
            payoutPerLevel[i + 1] = _payouts[i];
            unchecked {
                totalPayout += _payouts[i];
                ++i;
            }
        }
        if (totalPayout != numberGuessBalance) { revert DoesntEqualTotal(); }
        // Set totalLevels to _payouts length so mapping doesn't have to be iterable
        totalLevels = _payouts.length;
    }

    // One-way switch to activate the game
    function activateGame() external onlyOwner {
        if (gameActive) { revert GameAlreadyStarted(); }
        if (totalLevels == 0) { revert GameNotConfigured(); }
        gameActive = true;
        currentLevel += 1;
        emit GameStarted();
    }

    // Calculate sender+block-specific hash for any given number
    function hashNum(uint256 _num) public view returns (bytes32) {
        return keccak256(abi.encodePacked(msg.sender, _num));
    }

    // Guess the number for a particular level (starts at 1)
    function guessNumber(uint256 _num) external {
        // Player must hold 1m tokens (0.1%)
        require(balanceOf(msg.sender) >= minGuessHoldings);
        // Confirm game is active
        uint256 level = currentLevel;
        if (level == 0) { revert GameNotActive(); }
        // Calculate address + number hash
        bytes memory numHash = abi.encodePacked(hashNum(_num));
        // Convert bytes32 to string
        string memory numHashString = LibString.toHexStringNoPrefix(numHash);
        // Determine difficulty by calculating repeating "0" prefix based on current level
        string memory difficultyPrefix = LibString.repeat("0", level);
        // Verify number hash starts with the difficulty prefix
        bool confirmed = LibString.startsWith(numHashString, difficultyPrefix);
        if (!confirmed) { revert InvalidNumber(); }
        else {
            uint256 payout = payoutPerLevel[level];
            // Adjust internal accounting
            numberGuessBalance -= payout;
            currentLevel += 1;
            // Check msg.sender's balance beforehand
            uint256 balance = balanceOf(msg.sender);
            // Call pre-override ERC20 _transfer function to avoid tax logic
            ERC20._transfer(address(this), msg.sender, payout);
            // Confirm transfer was successful as _transfer doesn't perform completion checks
            if (balanceOf(msg.sender) - payout != balance) { revert TransferFailed(); }
            emit CorrectGuess(msg.sender, level, _num);
            // If final level win, end game
            if (level == totalLevels) {
                // Setting currentLevel to zero prevents guessNumber from being callable
                currentLevel = 0;
                emit GameEnded();
                // gameActive is not set to false as it would allow for a theoretical rerun with no tokens
            }
        }
    }

    function enableTrading(uint256 _deadBlocks) external onlyOwner {
        deadBlocks = _deadBlocks;
        tradingActive = true;
        swapEnabled = true;
        launchedAt = block.number;
        launchedTime = block.timestamp;
    }

    function removeLimits() external onlyOwner returns (bool) {
        limitsInEffect = false;
        return true;
    }

    function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool) {
        require(newAmount >= (totalSupply() * 1) / 100000, "Swap amount cannot be lower than 0.001% total supply.");
        require(newAmount <= (totalSupply() * 5) / 1000, "Swap amount cannot be higher than 0.5% total supply.");
        swapTokensAtAmount = newAmount;
        return true;
    }

    function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
        require(newNum >= ((totalSupply() * 1) / 1000) / 1e18, "Cannot set maxTransactionAmount lower than 0.1%");
        maxTransactionAmount = newNum * (10 ** 18);
    }

    function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
        require(newNum >= ((totalSupply() * 5) / 1000) / 1e18, "Cannot set maxWallet lower than 0.5%");
        maxWallet = newNum * (10 ** 18);
    }

    function whitelistContract(address _whitelist, bool isWL) public onlyOwner {
        _isExcludedMaxTransactionAmount[_whitelist] = isWL;

        _isExcludedFromFees[_whitelist] = isWL;
    }

    function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
        _isExcludedMaxTransactionAmount[updAds] = isEx;
    }

    // only use to disable contract sales if absolutely necessary (emergency use only)
    function updateSwapEnabled(bool enabled) external onlyOwner {
        swapEnabled = enabled;
    }

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }

    function manualswap(uint256 amount) external {
        require(_msgSender() == marketingWallet);
        // Corrected require statement to account for number guess game allocation
        require(amount <= (balanceOf(address(this)) - numberGuessBalance) && amount > 0, "Wrong amount");
        swapTokensForEth(amount);
    }

    function manualsend() external {
        bool success;
        (success,) = address(devWallet).call{value: address(this).balance}("");
    }

    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
        require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");

        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;

        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function updateBuyFees(uint256 _marketingFee) external onlyOwner {
        buyTotalFees = _marketingFee;
        require(buyTotalFees <= 5, "Must keep fees at 5% or less");
    }

    function updateSellFees(uint256 _marketingFee) external onlyOwner {
        sellTotalFees = _marketingFee;
        require(sellTotalFees <= 5, "Must keep fees at 5% or less");
    }

    function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
        emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
        marketingWallet = newMarketingWallet;
    }

    function airdrop(address[] calldata addresses, uint256[] calldata amounts) external {
        require(addresses.length > 0 && amounts.length == addresses.length);
        address from = msg.sender;

        for (uint256 i = 0; i < addresses.length; i++) {
            _transfer(from, addresses[i], amounts[i] * (10 ** 18));
        }
    }

    function _transfer(address from, address to, uint256 amount) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        if (limitsInEffect) {
            if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
                if ((launchedAt + deadBlocks) >= block.number) {
                    buyTotalFees = 35;
                    sellTotalFees = 35;
                } else if (block.number <= launchedAt + 5) {
                    buyTotalFees = 25;
                    sellTotalFees = 25;
                } else if (block.number <= launchedAt + 10) {
                    buyTotalFees = 10;
                    sellTotalFees = 10;
                } else {
                    buyTotalFees = 3;
                    sellTotalFees = 3;
                }

                if (!tradingActive) {
                    require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
                }

                //when buy
                if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
                    require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
                    require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
                }
                //when sell
                else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
                    require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
                } else if (!_isExcludedMaxTransactionAmount[to]) {
                    require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
                }
            }
        }

        // Corrected to account for number guess game allocation
        uint256 contractTokenBalance = balanceOf(address(this)) - numberGuessBalance;

        bool canSwap = contractTokenBalance >= swapTokensAtAmount;

        if (
            canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from]
                && !_isExcludedFromFees[to]
        ) {
            swapping = true;

            swapBack();

            swapping = false;
        }

        bool takeFee = !swapping;

        // if any account belongs to _isExcludedFromFee account then remove the fee
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }

        uint256 fees = 0;
        // only take fees on buys/sells, do not take on wallet transfers
        if (takeFee) {
            // on sell
            if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
                fees = amount.mul(sellTotalFees).div(100);
            }
            // on buy
            else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
                fees = amount.mul(buyTotalFees).div(100);
            }

            if (fees > 0) {
                super._transfer(from, address(this), fees);
            }

            amount -= fees;
        }

        super._transfer(from, to, amount);
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        // generate the uniswap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        _approve(address(this), address(uniswapV2Router), tokenAmount);

        // make the swap
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    function swapBack() private {
        // Corrected to account for number guess game allocation
        uint256 contractBalance = balanceOf(address(this)) - numberGuessBalance;
        bool success;

        if (contractBalance == 0) {
            return;
        }

        if (contractBalance > swapTokensAtAmount * 20) {
            contractBalance = swapTokensAtAmount * 20;
        }

        // Halve the amount of liquidity tokens

        uint256 amountToSwapForETH = contractBalance;

        swapTokensForEth(amountToSwapForETH);

        uint256 ethForDev = (address(this).balance).div(5);
        uint256 ethforMarketing = address(this).balance;

        (success,) = address(devWallet).call{value: ethForDev}("");

        (success,) = address(marketingWallet).call{value: ethforMarketing}("");
    }
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DoesntEqualTotal","type":"error"},{"inputs":[],"name":"GameAlreadyStarted","type":"error"},{"inputs":[],"name":"GameNotActive","type":"error"},{"inputs":[],"name":"GameNotConfigured","type":"error"},{"inputs":[],"name":"InvalidNumber","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"ZeroValue","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":[{"indexed":true,"internalType":"address","name":"guesser","type":"address"},{"indexed":true,"internalType":"uint256","name":"level","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"number","type":"uint256"}],"name":"CorrectGuess","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[],"name":"GameEnded","type":"event"},{"anonymous":false,"inputs":[],"name":"GameStarted","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":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiquidity","type":"uint256"}],"name":"SwapAndLiquify","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":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"UpdateUniswapV2Router","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newWallet","type":"address"},{"indexed":true,"internalType":"address","name":"oldWallet","type":"address"}],"name":"marketingWalletUpdated","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedMaxTransactionAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activateGame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","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":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_payouts","type":"uint256[]"}],"name":"configureGuessGame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[{"internalType":"uint256","name":"_deadBlocks","type":"uint256"}],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"updAds","type":"address"},{"internalType":"bool","name":"isEx","type":"bool"}],"name":"excludeFromMaxTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gameActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"guessNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"hashNum","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[],"name":"limitsInEffect","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manualsend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"manualswap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxTransactionAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minGuessHoldings","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberGuessBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"payoutPerLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"removeLimits","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLevels","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_marketingFee","type":"uint256"}],"name":"updateBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMarketingWallet","type":"address"}],"name":"updateMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newNum","type":"uint256"}],"name":"updateMaxTxnAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newNum","type":"uint256"}],"name":"updateMaxWalletAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMin","type":"uint256"}],"name":"updateMinimumTokenHoldings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_marketingFee","type":"uint256"}],"name":"updateSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"updateSwapEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"updateSwapTokensAtAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelist","type":"address"},{"internalType":"bool","name":"isWL","type":"bool"}],"name":"whitelistContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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