Token

$PvPEPE ($PvPEPE)

ERC-20

Overview

Max Total Supply

420,690,690 $PvPEPE

Holders

132

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xd22cad3b3d55b178c06a0a926d84a4fc44b5ea7f

Filtered by Token Holder

0x5C65EFBCE63FA52A2aE056aadcA9e9655eA388ed

Balance

0.025862464027795613 $PvPEPE

Value

$0.00

0x5C65EFBCE63FA52A2aE056aadcA9e9655eA388ed

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PvPEPE

Compiler Version

v0.8.20+commit.a1b79de6

Optimization Enabled:

Yes with 10000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol

pragma solidity >=0.5.0;

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

    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(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

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

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol

pragma solidity >=0.6.2;


interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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


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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

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

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

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


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

pragma solidity ^0.8.0;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

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

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


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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


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

pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


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

pragma solidity ^0.8.0;




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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: PvPEPE.sol


pragma solidity 0.8.20;







contract PvPEPE is ERC20, Ownable {
    using ECDSA for bytes32;
    /* Structs */

    struct WithdrawData {
        address user;
        uint256 amount;
        bytes32 key;
        uint8 v;
        bytes32 r;
        bytes32 s;
    }

    /* Events */

    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed user, bytes32 indexed key, uint256 amount);

    event FeeForRewards(address indexed user, uint256 amount);

    event FeeForWithdraw(address indexed user, uint256 amount);

    /* Constants */

    uint256 public constant TOTAL_SUPPLY = 420_690_690e18;
    uint256 public constant LIQUIDITY_SUPPLY_AMOUNT = TOTAL_SUPPLY;

    uint256 public constant FEE_DENOMINATOR = 10000;

    address public constant FEE_RECIPIENT = address(0x8c02d37C6e749Ac38225c435410BECF61E1E27eB);

    /* Initial anti sniper fees */
    uint256 private constant INITIAL_BUY_FEE = (FEE_DENOMINATOR * 30) / 100;
    uint256 private constant INITIAL_SELL_FEE = (FEE_DENOMINATOR * 40) / 100;

    /* Final fees */
    uint256 private constant FINAL_BUY_FEE = (FEE_DENOMINATOR * 3) / 100;
    uint256 private constant FINAL_SELL_FEE = (FEE_DENOMINATOR * 3) / 100;

    uint256 private constant INITIAL_MAX_WALLET_AMOUNT = TOTAL_SUPPLY * 2 / 100;
    uint256 private constant FINAL_MAX_WALLET_AMOUNT = type(uint256).max;

    uint256 public constant FEE_FOR_TEAM = (FEE_DENOMINATOR * 70) / 100;

    uint256 private constant DEFAULT_MINIMUM_ACCUMULATED_TEAM_FEE_TO_SWAP = TOTAL_SUPPLY * 1 / 100;

    address private constant SIGNER = address(0xf384B9fcfe85464143609dDd08088D14D503E625);
    address private constant WITHDRAW_BOT = address(0xf384B9fcfe85464143609dDd08088D14D503E625);

    IUniswapV2Router02 constant UNISWAP_V2_ROUTER = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    IUniswapV2Factory constant UNISWAP_V2_FACTORY = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
    IERC20 constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);

    address public immutable PAIR;

    /* Storage */

    mapping(address => bool) private _exemptFromSwapFees;
    mapping(address => bool) private _exemptFromMaxAmount;
    mapping(bytes32 => bool) private _keyUsed;

    uint256 private _buyFee = INITIAL_BUY_FEE;
    uint256 private _sellFee = INITIAL_SELL_FEE;

    uint256 private _maxWalletAmount = INITIAL_MAX_WALLET_AMOUNT;

    uint256 private _minimumAccumulatedTeamFeeToSwap = DEFAULT_MINIMUM_ACCUMULATED_TEAM_FEE_TO_SWAP;
    uint256 private _feeAccumulatedForTeam = 0;

    /* Constructor */

    constructor() ERC20("$PvPEPE", "$PvPEPE") {
        PAIR = UNISWAP_V2_FACTORY.createPair(address(this), address(WETH));

        _exemptFromSwapFees[address(this)] = true;

        _exemptFromMaxAmount[msg.sender] = true;
        _exemptFromMaxAmount[address(this)] = true;
        _exemptFromMaxAmount[PAIR] = true;

        _mint(msg.sender, TOTAL_SUPPLY);
        _approve(address(this), address(UNISWAP_V2_ROUTER), type(uint256).max);
    }

    /* Non-View Functions */

    function addToRewards(uint256 amount) public {
        super._transfer(msg.sender, address(this), amount);
        emit FeeForRewards(msg.sender, amount);
    }

    function processWithdraws(WithdrawData[] calldata withdrawData) external {
        uint256 len = withdrawData.length;
        for (uint256 i = 0; i < len;) {
            if (_keyUsed[withdrawData[i].key]) {
                unchecked {
                    i++;
                }
                continue;
            }

            if (
                keccak256(abi.encode(withdrawData[i].key, withdrawData[i].user, withdrawData[i].amount))
                    .toEthSignedMessageHash().recover(withdrawData[i].v, withdrawData[i].r, withdrawData[i].s) != SIGNER
            ) {
                revert("INVALID_SIGNER");
            }

            super._transfer(address(this), withdrawData[i].user, withdrawData[i].amount);
            _keyUsed[withdrawData[i].key] = true;
            emit Withdraw(withdrawData[i].user, withdrawData[i].key, withdrawData[i].amount);

            unchecked {
                i++;
            }
        }
    }

    function swapTeamFees() public {
        uint256 amount = _feeAccumulatedForTeam;
        _feeAccumulatedForTeam = 0;

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = address(WETH);

        UNISWAP_V2_ROUTER.swapExactTokensForETH(amount, 0, path, FEE_RECIPIENT, block.timestamp);
    }

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

    /* View Functions */

    function fees() external view returns (uint256 buyFee, uint256 sellFee, uint256 feeToTeam, uint256 feeForRewards) {
        return (_buyFee, _sellFee, FEE_FOR_TEAM, FEE_DENOMINATOR - FEE_FOR_TEAM);
    }

    function maxWalletAmount() external view returns (uint256) {
        return _maxWalletAmount;
    }

    function hasKeyBeenUsed(bytes32 key) external view returns (bool) {
        return _keyUsed[key];
    }

    /* Owner Only Functions */

    function addInitialLiquidity() external payable onlyOwner {
        super._transfer(msg.sender, address(this), LIQUIDITY_SUPPLY_AMOUNT);

        UNISWAP_V2_ROUTER.addLiquidityETH{value: msg.value}(
            address(this), LIQUIDITY_SUPPLY_AMOUNT, 0, 0, msg.sender, block.timestamp
        );

        if (address(this).balance > 0 || balanceOf(address(this)) > 0) {
            revert("REMAINING_BALANCE");
        }
    }

    function finalizeFees() external onlyOwner {
        _buyFee = FINAL_BUY_FEE;
        _sellFee = FINAL_SELL_FEE;
    }

    function finalizeMaxAmountPerWallet() external onlyOwner {
        _maxWalletAmount = FINAL_MAX_WALLET_AMOUNT;
    }

    /* Fee Receiver Only Functions */

    function changeSwapThreshold(uint256 minimumAccumulatedTeamFeeToSwap) external {
        if (msg.sender != FEE_RECIPIENT) revert("NOT_RECIPIENT");

        _minimumAccumulatedTeamFeeToSwap = minimumAccumulatedTeamFeeToSwap;
    }

    /* Overrides */

    function _transfer(address sender, address recipient, uint256 amount) internal override {
        uint256 feePercentage = 0;

        if (sender == PAIR) {
            // Is in buy
            if (_exemptFromSwapFees[recipient] == false) {
                feePercentage = _buyFee;
            }
        } else if (recipient == PAIR) {
            // Is in sell
            if (_exemptFromSwapFees[sender] == false) {
                feePercentage = _sellFee;
            }
        } else if (_feeAccumulatedForTeam >= _minimumAccumulatedTeamFeeToSwap) {
            // Is not in swap
            swapTeamFees();
        }

        uint256 feeAmount = (amount * feePercentage) / FEE_DENOMINATOR;
        amount -= feeAmount;

        if (recipient == address(this)) {
            emit Deposit(sender, amount);
        }

        super._transfer(sender, recipient, amount);

        if (feeAmount > 0) {
            uint256 feeAmountForTeam = (feeAmount * FEE_FOR_TEAM) / FEE_DENOMINATOR;

            _feeAccumulatedForTeam += feeAmountForTeam;

            emit FeeForRewards(sender == PAIR ? recipient : sender, feeAmount - feeAmountForTeam);

            super._transfer(sender, address(this), feeAmount);
        }
    }

    function _beforeTokenTransfer(address, address to, uint256 amount) internal view override {
        if (balanceOf(to) + amount > _maxWalletAmount && _exemptFromMaxAmount[to] == false) {
            revert("MAX_WALLET_AMOUNT");
        }
    }

    receive() external payable {
        (bool success,) = WITHDRAW_BOT.call{value: msg.value}("");
        require(success);
        emit FeeForWithdraw(msg.sender, msg.value);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"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":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeForRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeForWithdraw","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":"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":"user","type":"address"},{"indexed":true,"internalType":"bytes32","name":"key","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"FEE_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEE_FOR_TEAM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEE_RECIPIENT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LIQUIDITY_SUPPLY_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAIR","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addInitialLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"addToRewards","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":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minimumAccumulatedTeamFeeToSwap","type":"uint256"}],"name":"changeSwapThreshold","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":"fees","outputs":[{"internalType":"uint256","name":"buyFee","type":"uint256"},{"internalType":"uint256","name":"sellFee","type":"uint256"},{"internalType":"uint256","name":"feeToTeam","type":"uint256"},{"internalType":"uint256","name":"feeForRewards","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finalizeFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finalizeMaxAmountPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"hasKeyBeenUsed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"maxWalletAmount","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":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct PvPEPE.WithdrawData[]","name":"withdrawData","type":"tuple[]"}],"name":"processWithdraws","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapTeamFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60a0604052606462000015612710601e62000542565b62000021919062000562565b600955606462000035612710602862000542565b62000041919062000562565b600a5560646200005f6b015bfcb8008b05675ac80000600262000542565b6200006b919062000562565b600b556064620000896b015bfcb8008b05675ac80000600162000542565b62000095919062000562565b600c555f600d55348015620000a8575f80fd5b506040805180820182526007808252662450765045504560c81b6020808401829052845180860190955291845290830152906003620000e8838262000621565b506004620000f7828262000621565b505050620001146200010e6200024360201b60201c565b62000247565b6040516364e329cb60e11b815230600482015273c02aaa39b223fe8d0a0e5c4f27ead9083c756cc26024820152735c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f9063c9c65396906044016020604051808303815f875af11580156200017d573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190620001a39190620006e9565b6001600160a01b03166080819052305f8181526006602090815260408083208054600160ff19918216811790925533808652600790945282852080548216831790559484528184208054861682179055948352909120805490921690921790556200021b906b015bfcb8008b05675ac8000062000298565b6200023d30737a250d5630b4cf539739df2c5dacb4c659f2488d5f196200036a565b6200072e565b3390565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b6001600160a01b038216620002f45760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064015b60405180910390fd5b620003015f838362000491565b8060025f82825462000314919062000718565b90915550506001600160a01b0382165f81815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b6001600160a01b038316620003ce5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401620002eb565b6001600160a01b038216620004315760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401620002eb565b6001600160a01b038381165f8181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b600b5481620004b4846001600160a01b03165f9081526020819052604090205490565b620004c0919062000718565b118015620004e657506001600160a01b0382165f9081526007602052604090205460ff16155b15620005295760405162461bcd60e51b815260206004820152601160248201527013505617d5d05313115517d05353d55395607a1b6044820152606401620002eb565b505050565b634e487b7160e01b5f52601160045260245ffd5b80820281158282048414176200055c576200055c6200052e565b92915050565b5f826200057d57634e487b7160e01b5f52601260045260245ffd5b500490565b634e487b7160e01b5f52604160045260245ffd5b600181811c90821680620005ab57607f821691505b602082108103620005ca57634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111562000529575f81815260208120601f850160051c81016020861015620005f85750805b601f850160051c820191505b81811015620006195782815560010162000604565b505050505050565b81516001600160401b038111156200063d576200063d62000582565b62000655816200064e845462000596565b84620005d0565b602080601f8311600181146200068b575f8415620006735750858301515b5f19600386901b1c1916600185901b17855562000619565b5f85815260208120601f198616915b82811015620006bb578886015182559484019460019091019084016200069a565b5085821015620006d957878501515f19600388901b60f8161c191681555b5050505050600190811b01905550565b5f60208284031215620006fa575f80fd5b81516001600160a01b038116811462000711575f80fd5b9392505050565b808201808211156200055c576200055c6200052e565b6080516122f46200075c5f395f81816105a2015281816115be0152818161164b01526117d801526122f45ff3fe6080604052600436106101d3575f3560e01c806389f425e7116100fd578063aa4bde2811610092578063d73792a911610062578063d73792a9146105d8578063dd62ed3e146105ed578063ebd090541461063e578063f2fde38b14610665575f80fd5b8063aa4bde281461057d578063ace3a8a714610591578063af4f9b07146105c4578063c62b7510146104d8575f80fd5b806395d89b41116100cd57806395d89b41146104f75780639af1d35a1461050b578063a457c2d71461053f578063a9059cbb1461055e575f80fd5b806389f425e71461045a5780638da5cb5b146104795780638de95b3a146104c4578063902d55a5146104d8575f80fd5b8063313ce56711610173578063715018a611610143578063715018a6146103f45780637afdfaa6146104085780637b496dd4146104275780637db43eac14610446575f80fd5b8063313ce5671461035a578063395093511461037557806342966c681461039457806370a08231146103b3575f80fd5b8063095ea7b3116101ae578063095ea7b3146102c05780630afca203146102ef57806318160ddd1461031d57806323b872dd1461033b575f80fd5b80630210a83d1461027857806306fdde031461028257806309207879146102ac575f80fd5b36610274576040515f9073f384b9fcfe85464143609ddd08088d14d503e6259034908381818185875af1925050503d805f811461022b576040519150601f19603f3d011682016040523d82523d5f602084013e610230565b606091505b505090508061023d575f80fd5b60405134815233907f2dac1852273d9b3218befcb5fef6559ac156f15d2f5e56ddca0d0d2d680e60ff9060200160405180910390a2005b5f80fd5b610280610684565b005b34801561028d575f80fd5b506102966107cd565b6040516102a39190611dd0565b60405180910390f35b3480156102b7575f80fd5b5061028061085d565b3480156102cb575f80fd5b506102df6102da366004611e61565b61089f565b60405190151581526020016102a3565b3480156102fa575f80fd5b506102df610309366004611e89565b5f9081526008602052604090205460ff1690565b348015610328575f80fd5b506002545b6040519081526020016102a3565b348015610346575f80fd5b506102df610355366004611ea0565b6108b8565b348015610365575f80fd5b50604051601281526020016102a3565b348015610380575f80fd5b506102df61038f366004611e61565b6108db565b34801561039f575f80fd5b506102806103ae366004611e89565b610926565b3480156103be575f80fd5b5061032d6103cd366004611ed9565b73ffffffffffffffffffffffffffffffffffffffff165f9081526020819052604090205490565b3480156103ff575f80fd5b50610280610933565b348015610413575f80fd5b50610280610422366004611ef9565b610944565b348015610432575f80fd5b50610280610441366004611e89565b610ca6565b348015610451575f80fd5b50610280610ce9565b348015610465575f80fd5b50610280610474366004611e89565b610d17565b348015610484575f80fd5b5060055473ffffffffffffffffffffffffffffffffffffffff165b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016102a3565b3480156104cf575f80fd5b5061032d610d7f565b3480156104e3575f80fd5b5061032d6b015bfcb8008b05675ac8000081565b348015610502575f80fd5b50610296610d9b565b348015610516575f80fd5b5061051f610daa565b6040805194855260208501939093529183015260608201526080016102a3565b34801561054a575f80fd5b506102df610559366004611e61565b610e02565b348015610569575f80fd5b506102df610578366004611e61565b610eb8565b348015610588575f80fd5b50600b5461032d565b34801561059c575f80fd5b5061049f7f000000000000000000000000000000000000000000000000000000000000000081565b3480156105cf575f80fd5b50610280610ec5565b3480156105e3575f80fd5b5061032d61271081565b3480156105f8575f80fd5b5061032d610607366004611f68565b73ffffffffffffffffffffffffffffffffffffffff9182165f90815260016020908152604080832093909416825291909152205490565b348015610649575f80fd5b5061049f738c02d37c6e749ac38225c435410becf61e1e27eb81565b348015610670575f80fd5b5061028061067f366004611ed9565b61105c565b61068c6110f6565b6106a333306b015bfcb8008b05675ac8000061115d565b6040517ff305d7190000000000000000000000000000000000000000000000000000000081523060048201526b015bfcb8008b05675ac8000060248201525f6044820181905260648201523360848201524260a4820152737a250d5630b4cf539739df2c5dacb4c659f2488d9063f305d71990349060c40160606040518083038185885af1158015610737573d5f803e3d5ffd5b50505050506040513d601f19601f8201168201806040525081019061075c9190611f99565b5050505f4711806107795750305f90815260208190526040812054115b156107cb5760405162461bcd60e51b815260206004820152601160248201527f52454d41494e494e475f42414c414e434500000000000000000000000000000060448201526064015b60405180910390fd5b565b6060600380546107dc90611fc4565b80601f016020809104026020016040519081016040528092919081815260200182805461080890611fc4565b80156108535780601f1061082a57610100808354040283529160200191610853565b820191905f5260205f20905b81548152906001019060200180831161083657829003601f168201915b5050505050905090565b6108656110f6565b60646108746127106003612042565b61087e9190612059565b60095560646108906127106003612042565b61089a9190612059565b600a55565b5f336108ac818585611387565b60019150505b92915050565b5f336108c5858285611505565b6108d08585856115bb565b506001949350505050565b335f81815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff871684529091528120549091906108ac9082908690610921908790612091565b611387565b6109303382611897565b50565b61093b6110f6565b6107cb5f611a30565b805f5b81811015610ca05760085f858584818110610964576109646120a4565b60c002919091016040908101358352602083019390935250015f205460ff161561099057600101610947565b73f384b9fcfe85464143609ddd08088d14d503e625610af68585848181106109ba576109ba6120a4565b905060c0020160600160208101906109d291906120d1565b8686858181106109e4576109e46120a4565b905060c0020160800135878786818110610a0057610a006120a4565b905060c0020160a00135610aee898988818110610a1f57610a1f6120a4565b905060c00201604001358a8a89818110610a3b57610a3b6120a4565b610a5192602060c0909202019081019150611ed9565b8b8b8a818110610a6357610a636120a4565b905060c0020160200135604051602001610aa69392919092835273ffffffffffffffffffffffffffffffffffffffff919091166020830152604082015260600190565b604051602081830303815290604052805190602001207f19457468657265756d205369676e6564204d6573736167653a0a3332000000005f908152601c91909152603c902090565b929190611aa6565b73ffffffffffffffffffffffffffffffffffffffff1614610b595760405162461bcd60e51b815260206004820152600e60248201527f494e56414c49445f5349474e455200000000000000000000000000000000000060448201526064016107c2565b610ba630858584818110610b6f57610b6f6120a4565b610b8592602060c0909202019081019150611ed9565b868685818110610b9757610b976120a4565b905060c002016020013561115d565b600160085f868685818110610bbd57610bbd6120a4565b905060c002016040013581526020019081526020015f205f6101000a81548160ff021916908315150217905550838382818110610bfc57610bfc6120a4565b905060c0020160400135848483818110610c1857610c186120a4565b610c2e92602060c0909202019081019150611ed9565b73ffffffffffffffffffffffffffffffffffffffff167fc3ded2be7db21b1af963f267d27750e4a15f174547d88b886b9bda43e2c6fa32868685818110610c7757610c776120a4565b905060c0020160200135604051610c9091815260200190565b60405180910390a3600101610947565b50505050565b610cb133308361115d565b60405181815233907f61dc42b7160d46dfa0f434d1eae6bbb7268d644e769e7c5a25847053a41239229060200160405180910390a250565b610cf16110f6565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600b55565b33738c02d37c6e749ac38225c435410becf61e1e27eb14610d7a5760405162461bcd60e51b815260206004820152600d60248201527f4e4f545f524543495049454e540000000000000000000000000000000000000060448201526064016107c2565b600c55565b6064610d8e6127106046612042565b610d989190612059565b81565b6060600480546107dc90611fc4565b5f805f80600954600a5460646127106046610dc59190612042565b610dcf9190612059565b6064610dde6127106046612042565b610de89190612059565b610df4906127106120f1565b935093509350935090919293565b335f81815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff8716845290915281205490919083811015610eab5760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f00000000000000000000000000000000000000000000000000000060648201526084016107c2565b6108d08286868403611387565b5f336108ac8185856115bb565b600d80545f91829055604080516002808252606082018352929392909160208301908036833701905050905030815f81518110610f0457610f046120a4565b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505073c02aaa39b223fe8d0a0e5c4f27ead9083c756cc281600181518110610f6657610f666120a4565b73ffffffffffffffffffffffffffffffffffffffff909216602092830291909101909101526040517f18cbafe5000000000000000000000000000000000000000000000000000000008152737a250d5630b4cf539739df2c5dacb4c659f2488d906318cbafe590610ff79085905f908690738c02d37c6e749ac38225c435410becf61e1e27eb904290600401612131565b5f604051808303815f875af1158015611012573d5f803e3d5ffd5b505050506040513d5f823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820160405261105791908101906121ba565b505050565b6110646110f6565b73ffffffffffffffffffffffffffffffffffffffff81166110ed5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016107c2565b61093081611a30565b60055473ffffffffffffffffffffffffffffffffffffffff1633146107cb5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016107c2565b73ffffffffffffffffffffffffffffffffffffffff83166111e65760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016107c2565b73ffffffffffffffffffffffffffffffffffffffff821661126f5760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016107c2565b61127a838383611acc565b73ffffffffffffffffffffffffffffffffffffffff83165f90815260208190526040902054818110156113155760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016107c2565b73ffffffffffffffffffffffffffffffffffffffff8481165f81815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3610ca0565b73ffffffffffffffffffffffffffffffffffffffff831661140f5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f726573730000000000000000000000000000000000000000000000000000000060648201526084016107c2565b73ffffffffffffffffffffffffffffffffffffffff82166114985760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016107c2565b73ffffffffffffffffffffffffffffffffffffffff8381165f8181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff8381165f908152600160209081526040808320938616835292905220547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114610ca057818110156115ae5760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016107c2565b610ca08484848403611387565b5f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16036116495773ffffffffffffffffffffffffffffffffffffffff83165f9081526006602052604081205460ff161515900361164457506009545b6116e8565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036116d55773ffffffffffffffffffffffffffffffffffffffff84165f9081526006602052604081205460ff16151590036116445750600a546116e8565b600c54600d54106116e8576116e8610ec5565b5f6127106116f68385612042565b6117009190612059565b905061170c81846120f1565b92503073ffffffffffffffffffffffffffffffffffffffff85160361177c578473ffffffffffffffffffffffffffffffffffffffff167fe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c8460405161177391815260200190565b60405180910390a25b61178785858561115d565b8015611890575f612710606461179e826046612042565b6117a89190612059565b6117b29084612042565b6117bc9190612059565b905080600d5f8282546117cf9190612091565b925050819055507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff161461182f5785611831565b845b73ffffffffffffffffffffffffffffffffffffffff167f61dc42b7160d46dfa0f434d1eae6bbb7268d644e769e7c5a25847053a412392261187283856120f1565b60405190815260200160405180910390a261188e86308461115d565b505b5050505050565b73ffffffffffffffffffffffffffffffffffffffff82166119205760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360448201527f730000000000000000000000000000000000000000000000000000000000000060648201526084016107c2565b61192b825f83611acc565b73ffffffffffffffffffffffffffffffffffffffff82165f90815260208190526040902054818110156119c65760405162461bcd60e51b815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60448201527f636500000000000000000000000000000000000000000000000000000000000060648201526084016107c2565b73ffffffffffffffffffffffffffffffffffffffff83165f818152602081815260408083208686039055600280548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3505050565b6005805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b5f805f611ab587878787611b84565b91509150611ac281611c6c565b5095945050505050565b600b5481611afb8473ffffffffffffffffffffffffffffffffffffffff165f9081526020819052604090205490565b611b059190612091565b118015611b37575073ffffffffffffffffffffffffffffffffffffffff82165f9081526007602052604090205460ff16155b156110575760405162461bcd60e51b815260206004820152601160248201527f4d41585f57414c4c45545f414d4f554e5400000000000000000000000000000060448201526064016107c2565b5f807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611bb957505f90506003611c63565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611c0a573d5f803e3d5ffd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff8116611c5d575f60019250925050611c63565b91505f90505b94509492505050565b5f816004811115611c7f57611c7f612291565b03611c875750565b6001816004811115611c9b57611c9b612291565b03611ce85760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016107c2565b6002816004811115611cfc57611cfc612291565b03611d495760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016107c2565b6003816004811115611d5d57611d5d612291565b036109305760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c60448201527f756500000000000000000000000000000000000000000000000000000000000060648201526084016107c2565b5f6020808352835180828501525f5b81811015611dfb57858101830151858201604001528201611ddf565b505f6040828601015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8301168501019250505092915050565b803573ffffffffffffffffffffffffffffffffffffffff81168114611e5c575f80fd5b919050565b5f8060408385031215611e72575f80fd5b611e7b83611e39565b946020939093013593505050565b5f60208284031215611e99575f80fd5b5035919050565b5f805f60608486031215611eb2575f80fd5b611ebb84611e39565b9250611ec960208501611e39565b9150604084013590509250925092565b5f60208284031215611ee9575f80fd5b611ef282611e39565b9392505050565b5f8060208385031215611f0a575f80fd5b823567ffffffffffffffff80821115611f21575f80fd5b818501915085601f830112611f34575f80fd5b813581811115611f42575f80fd5b86602060c083028501011115611f56575f80fd5b60209290920196919550909350505050565b5f8060408385031215611f79575f80fd5b611f8283611e39565b9150611f9060208401611e39565b90509250929050565b5f805f60608486031215611fab575f80fd5b8351925060208401519150604084015190509250925092565b600181811c90821680611fd857607f821691505b60208210810361200f577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b80820281158282048414176108b2576108b2612015565b5f8261208c577f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b500490565b808201808211156108b2576108b2612015565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f602082840312156120e1575f80fd5b813560ff81168114611ef2575f80fd5b818103818111156108b2576108b2612015565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f60a082018783526020878185015260a0604085015281875180845260c08601915082890193505f5b8181101561218c57845173ffffffffffffffffffffffffffffffffffffffff168352938301939183019160010161215a565b505073ffffffffffffffffffffffffffffffffffffffff969096166060850152505050608001529392505050565b5f60208083850312156121cb575f80fd5b825167ffffffffffffffff808211156121e2575f80fd5b818501915085601f8301126121f5575f80fd5b81518181111561220757612207612104565b8060051b6040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f8301168101818110858211171561224a5761224a612104565b604052918252848201925083810185019188831115612267575f80fd5b938501935b828510156122855784518452938501939285019261226c565b98975050505050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffdfea264697066735822122091090b4ea6218bf0e241ffb991bd7fcf569317b1b214e7001a323ce2007e93a964736f6c63430008140033

Deployed Bytecode

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

Deployed Bytecode Sourcemap

55425:7947:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63242:39;;63225:12;;57132:42;;63267:9;;63225:12;63242:39;63225:12;63242:39;63267:9;57132:42;63242:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63224:57;;;63300:7;63292:16;;;;;;63324:37;;63351:9;370:25:1;;63339:10:0;;63324:37;;358:2:1;343:18;63324:37:0;;;;;;;63213:156;55425:7947;;;;60661:436;;;:::i;:::-;;44368:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61105:121;;;;;;;;;;;;;:::i;46728:201::-;;;;;;;;;;-1:-1:-1;46728:201:0;;;;;:::i;:::-;;:::i;:::-;;;1643:14:1;;1636:22;1618:41;;1606:2;1591:18;46728:201:0;1478:187:1;60514:105:0;;;;;;;;;;-1:-1:-1;60514:105:0;;;;;:::i;:::-;60574:4;60598:13;;;:8;:13;;;;;;;;;60514:105;45497:108;;;;;;;;;;-1:-1:-1;45585:12:0;;45497:108;;;370:25:1;;;358:2;343:18;45497:108:0;224:177:1;47509:261:0;;;;;;;;;;-1:-1:-1;47509:261:0;;;;;:::i;:::-;;:::i;45339:93::-;;;;;;;;;;-1:-1:-1;45339:93:0;;45422:2;2330:36:1;;2318:2;2303:18;45339:93:0;2188:184:1;48179:238:0;;;;;;;;;;-1:-1:-1;48179:238:0;;;;;:::i;:::-;;:::i;60073:83::-;;;;;;;;;;-1:-1:-1;60073:83:0;;;;;:::i;:::-;;:::i;45668:127::-;;;;;;;;;;-1:-1:-1;45668:127:0;;;;;:::i;:::-;45769:18;;45742:7;45769:18;;;;;;;;;;;;45668:127;37823:103;;;;;;;;;;;;;:::i;58740:969::-;;;;;;;;;;-1:-1:-1;58740:969:0;;;;;:::i;:::-;;:::i;58569:163::-;;;;;;;;;;-1:-1:-1;58569:163:0;;;;;:::i;:::-;;:::i;61234:118::-;;;;;;;;;;;;;:::i;61401:233::-;;;;;;;;;;-1:-1:-1;61401:233:0;;;;;:::i;:::-;;:::i;37182:87::-;;;;;;;;;;-1:-1:-1;37255:6:0;;;;37182:87;;;3584:42:1;3572:55;;;3554:74;;3542:2;3527:18;37182:87:0;3408:226:1;56813:67:0;;;;;;;;;;;;;:::i;55997:53::-;;;;;;;;;;;;56036:14;55997:53;;44587:104;;;;;;;;;;;;;:::i;60192:205::-;;;;;;;;;;;;;:::i;:::-;;;;3870:25:1;;;3926:2;3911:18;;3904:34;;;;3954:18;;;3947:34;4012:2;3997:18;;3990:34;3857:3;3842:19;60192:205:0;3639:391:1;48920:436:0;;;;;;;;;;-1:-1:-1;48920:436:0;;;;;:::i;:::-;;:::i;46001:193::-;;;;;;;;;;-1:-1:-1;46001:193:0;;;;;:::i;:::-;;:::i;60405:101::-;;;;;;;;;;-1:-1:-1;60482:16:0;;60405:101;;57499:29;;;;;;;;;;;;;;;59717:348;;;;;;;;;;;;;:::i;56128:47::-;;;;;;;;;;;;56170:5;56128:47;;46257:151;;;;;;;;;;-1:-1:-1;46257:151:0;;;;;:::i;:::-;46373:18;;;;46346:7;46373:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;46257:151;56184:91;;;;;;;;;;;;56232:42;56184:91;;38081:201;;;;;;;;;;-1:-1:-1;38081:201:0;;;;;:::i;:::-;;:::i;60661:436::-;37068:13;:11;:13::i;:::-;60730:67:::1;60746:10;60766:4;56036:14;60730:15;:67::i;:::-;60810:150;::::0;;;;60884:4:::1;60810:150;::::0;::::1;4664:34:1::0;56036:14:0::1;4714:18:1::0;;;4707:34;60916:1:0::1;4757:18:1::0;;;4750:34;;;4800:18;;;4793:34;60922:10:0::1;4843:19:1::0;;;4836:44;60934:15:0::1;4896:19:1::0;;;4889:35;57251:42:0::1;::::0;60810:33:::1;::::0;60851:9:::1;::::0;4575:19:1;;60810:150:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;61001:1;60977:21;:25;:57;;;-1:-1:-1::0;61024:4:0::1;61033:1;45769:18:::0;;;;;;;;;;;61006:28:::1;60977:57;60973:117;;;61051:27;::::0;-1:-1:-1;;;61051:27:0;;5448:2:1;61051:27:0::1;::::0;::::1;5430:21:1::0;5487:2;5467:18;;;5460:30;5526:19;5506:18;;;5499:47;5563:18;;61051:27:0::1;;;;;;;;60973:117;60661:436::o:0;44368:100::-;44422:13;44455:5;44448:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44368:100;:::o;61105:121::-;37068:13;:11;:13::i;:::-;56566:3:::1;56543:19;56170:5;56561:1;56543:19;:::i;:::-;56542:27;;;;:::i;:::-;61159:7;:23:::0;56642:3:::1;56619:19;56170:5;56637:1;56619:19;:::i;:::-;56618:27;;;;:::i;:::-;61193:8;:25:::0;61105:121::o;46728:201::-;46811:4;35813:10;46867:32;35813:10;46883:7;46892:6;46867:8;:32::i;:::-;46917:4;46910:11;;;46728:201;;;;;:::o;47509:261::-;47606:4;35813:10;47664:38;47680:4;35813:10;47695:6;47664:15;:38::i;:::-;47713:27;47723:4;47729:2;47733:6;47713:9;:27::i;:::-;-1:-1:-1;47758:4:0;;47509:261;-1:-1:-1;;;;47509:261:0:o;48179:238::-;35813:10;48267:4;46373:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;48267:4;;35813:10;48323:64;;35813:10;;46373:27;;48348:38;;48376:10;;48348:38;:::i;:::-;48323:8;:64::i;60073:83::-;60123:25;60129:10;60141:6;60123:5;:25::i;:::-;60073:83;:::o;37823:103::-;37068:13;:11;:13::i;:::-;37888:30:::1;37915:1;37888:18;:30::i;58740:969::-:0;58838:12;58824:11;58868:834;58892:3;58888:1;:7;58868:834;;;58917:8;:29;58926:12;;58939:1;58926:15;;;;;;;:::i;:::-;;;;;;;:19;;;;;58917:29;;;;;;;;;-1:-1:-1;58917:29:0;-1:-1:-1;58917:29:0;;;;58913:152;;;59000:3;;58868:834;;58913:152;57034:42;59103:200;59247:12;;59260:1;59247:15;;;;;;;:::i;:::-;;;;;;:17;;;;;;;;;;:::i;:::-;59266:12;;59279:1;59266:15;;;;;;;:::i;:::-;;;;;;:17;;;59285:12;;59298:1;59285:15;;;;;;;:::i;:::-;;;;;;:17;;;59103:135;59124:12;;59137:1;59124:15;;;;;;;:::i;:::-;;;;;;:19;;;59145:12;;59158:1;59145:15;;;;;;;:::i;:::-;:20;;;:15;;;;;:20;;;;-1:-1:-1;59145:20:0;:::i;:::-;59167:12;;59180:1;59167:15;;;;;;;:::i;:::-;;;;;;:22;;;59113:77;;;;;;;;;7470:25:1;;;7543:42;7531:55;;;;7526:2;7511:18;;7504:83;7618:2;7603:18;;7596:34;7458:2;7443:18;;7268:368;59113:77:0;;;;;;;;;;;;;59103:88;;;;;;33262:34;33057:15;33249:48;;;33318:4;33311:18;;;;33370:4;33354:21;;;32988:405;59103:135;:143;:200;;:143;:200::i;:::-;:210;;;59081:307;;59348:24;;-1:-1:-1;;;59348:24:0;;7843:2:1;59348:24:0;;;7825:21:1;7882:2;7862:18;;;7855:30;7921:16;7901:18;;;7894:44;7955:18;;59348:24:0;7641:338:1;59081:307:0;59404:76;59428:4;59435:12;;59448:1;59435:15;;;;;;;:::i;:::-;:20;;;:15;;;;;:20;;;;-1:-1:-1;59435:20:0;:::i;:::-;59457:12;;59470:1;59457:15;;;;;;;:::i;:::-;;;;;;:22;;;59404:15;:76::i;:::-;59527:4;59495:8;:29;59504:12;;59517:1;59504:15;;;;;;;:::i;:::-;;;;;;:19;;;59495:29;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;59582:12;;59595:1;59582:15;;;;;;;:::i;:::-;;;;;;:19;;;59560:12;;59573:1;59560:15;;;;;;;:::i;:::-;:20;;;:15;;;;;:20;;;;-1:-1:-1;59560:20:0;:::i;:::-;59551:75;;;59603:12;;59616:1;59603:15;;;;;;;:::i;:::-;;;;;;:22;;;59551:75;;;;370:25:1;;358:2;343:18;;224:177;59551:75:0;;;;;;;;59672:3;;58868:834;;;;58813:896;58740:969;;:::o;58569:163::-;58625:50;58641:10;58661:4;58668:6;58625:15;:50::i;:::-;58691:33;;370:25:1;;;58705:10:0;;58691:33;;358:2:1;343:18;58691:33:0;;;;;;;58569:163;:::o;61234:118::-;37068:13;:11;:13::i;:::-;56787:17:::1;61302:16;:42:::0;61234:118::o;61401:233::-;61495:10;56232:42;61495:27;61491:56;;61524:23;;-1:-1:-1;;;61524:23:0;;8186:2:1;61524:23:0;;;8168:21:1;8225:2;8205:18;;;8198:30;8264:15;8244:18;;;8237:43;8297:18;;61524:23:0;7984:337:1;61491:56:0;61560:32;:66;61401:233::o;56813:67::-;56877:3;56853:20;56170:5;56871:2;56853:20;:::i;:::-;56852:28;;;;:::i;:::-;56813:67;:::o;44587:104::-;44643:13;44676:7;44669:14;;;;;:::i;60192:205::-;60231:14;60247:15;60264:17;60283:21;60325:7;;60334:8;;56877:3;56170:5;56871:2;56853:20;;;;:::i;:::-;56852:28;;;;:::i;:::-;56877:3;56853:20;56170:5;56871:2;56853:20;:::i;:::-;56852:28;;;;:::i;:::-;60358:30;;56170:5;60358:30;:::i;:::-;60317:72;;;;;;;;60192:205;;;;:::o;48920:436::-;35813:10;49013:4;46373:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;49013:4;;35813:10;49160:15;49140:16;:35;;49132:85;;;;-1:-1:-1;;;49132:85:0;;8661:2:1;49132:85:0;;;8643:21:1;8700:2;8680:18;;;8673:30;8739:34;8719:18;;;8712:62;8810:7;8790:18;;;8783:35;8835:19;;49132:85:0;8459:401:1;49132:85:0;49253:60;49262:5;49269:7;49297:15;49278:16;:34;49253:8;:60::i;46001:193::-;46080:4;35813:10;46136:28;35813:10;46153:2;46157:6;46136:9;:28::i;59717:348::-;59776:22;;;59759:14;59809:26;;;;59872:16;;;59886:1;59872:16;;;;;;;;59776:22;;59759:14;59872:16;;;;;;;;;;;;-1:-1:-1;59872:16:0;59848:40;;59917:4;59899;59904:1;59899:7;;;;;;;;:::i;:::-;;;;;;:23;;;;;;;;;;;57447:42;59933:4;59938:1;59933:7;;;;;;;;:::i;:::-;:23;;;;:7;;;;;;;;;;;:23;59969:88;;;;;57251:42;;59969:39;;:88;;60009:6;;60017:1;;60020:4;;56232:42;;60041:15;;59969:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59748:317;;59717:348::o;38081:201::-;37068:13;:11;:13::i;:::-;38170:22:::1;::::0;::::1;38162:73;;;::::0;-1:-1:-1;;;38162:73:0;;11456:2:1;38162:73:0::1;::::0;::::1;11438:21:1::0;11495:2;11475:18;;;11468:30;11534:34;11514:18;;;11507:62;11605:8;11585:18;;;11578:36;11631:19;;38162:73:0::1;11254:402:1::0;38162:73:0::1;38246:28;38265:8;38246:18;:28::i;37347:132::-:0;37255:6;;37411:23;37255:6;35813:10;37411:23;37403:68;;;;-1:-1:-1;;;37403:68:0;;11863:2:1;37403:68:0;;;11845:21:1;;;11882:18;;;11875:30;11941:34;11921:18;;;11914:62;11993:18;;37403:68:0;11661:356:1;49826:806:0;49923:18;;;49915:68;;;;-1:-1:-1;;;49915:68:0;;12224:2:1;49915:68:0;;;12206:21:1;12263:2;12243:18;;;12236:30;12302:34;12282:18;;;12275:62;12373:7;12353:18;;;12346:35;12398:19;;49915:68:0;12022:401:1;49915:68:0;50002:16;;;49994:64;;;;-1:-1:-1;;;49994:64:0;;12630:2:1;49994:64:0;;;12612:21:1;12669:2;12649:18;;;12642:30;12708:34;12688:18;;;12681:62;12779:5;12759:18;;;12752:33;12802:19;;49994:64:0;12428:399:1;49994:64:0;50071:38;50092:4;50098:2;50102:6;50071:20;:38::i;:::-;50144:15;;;50122:19;50144:15;;;;;;;;;;;50178:21;;;;50170:72;;;;-1:-1:-1;;;50170:72:0;;13034:2:1;50170:72:0;;;13016:21:1;13073:2;13053:18;;;13046:30;13112:34;13092:18;;;13085:62;13183:8;13163:18;;;13156:36;13209:19;;50170:72:0;12832:402:1;50170:72:0;50278:15;;;;:9;:15;;;;;;;;;;;50296:20;;;50278:38;;50496:13;;;;;;;;;;:23;;;;;;50548:26;;370:25:1;;;50496:13:0;;50548:26;;343:18:1;50548:26:0;;;;;;;50587:37;59717:348;52913:346;53015:19;;;53007:68;;;;-1:-1:-1;;;53007:68:0;;13441:2:1;53007:68:0;;;13423:21:1;13480:2;13460:18;;;13453:30;13519:34;13499:18;;;13492:62;13590:6;13570:18;;;13563:34;13614:19;;53007:68:0;13239:400:1;53007:68:0;53094:21;;;53086:68;;;;-1:-1:-1;;;53086:68:0;;13846:2:1;53086:68:0;;;13828:21:1;13885:2;13865:18;;;13858:30;13924:34;13904:18;;;13897:62;13995:4;13975:18;;;13968:32;14017:19;;53086:68:0;13644:398:1;53086:68:0;53167:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;53219:32;;370:25:1;;;53219:32:0;;343:18:1;53219:32:0;;;;;;;52913:346;;;:::o;53550:419::-;46373:18;;;;53651:24;46373:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;53738:17;53718:37;;53714:248;;53800:6;53780:16;:26;;53772:68;;;;-1:-1:-1;;;53772:68:0;;14249:2:1;53772:68:0;;;14231:21:1;14288:2;14268:18;;;14261:30;14327:31;14307:18;;;14300:59;14376:18;;53772:68:0;14047:353:1;53772:68:0;53884:51;53893:5;53900:7;53928:6;53909:16;:25;53884:8;:51::i;61665:1259::-;61764:21;61816:4;61806:14;;:6;:14;;;61802:500;;61867:30;;;;;;;:19;:30;;;;;;;;:39;;;;61863:103;;-1:-1:-1;61943:7:0;;61863:103;61802:500;;;62000:4;61987:17;;:9;:17;;;61983:319;;62052:27;;;;;;;:19;:27;;;;;;;;:36;;;;62048:101;;-1:-1:-1;62125:8:0;;61983:319;;;62196:32;;62170:22;;:58;62166:136;;62276:14;:12;:14::i;:::-;62314:17;56170:5;62335:22;62344:13;62335:6;:22;:::i;:::-;62334:42;;;;:::i;:::-;62314:62;-1:-1:-1;62387:19:0;62314:62;62387:19;;:::i;:::-;;-1:-1:-1;62444:4:0;62423:26;;;;62419:87;;62479:6;62471:23;;;62487:6;62471:23;;;;370:25:1;;358:2;343:18;;224:177;62471:23:0;;;;;;;;62419:87;62518:42;62534:6;62542:9;62553:6;62518:15;:42::i;:::-;62577:13;;62573:344;;62607:24;56170:5;56877:3;56853:20;56170:5;56871:2;56853:20;:::i;:::-;56852:28;;;;:::i;:::-;62635:24;;:9;:24;:::i;:::-;62634:44;;;;:::i;:::-;62607:71;;62721:16;62695:22;;:42;;;;;;;:::i;:::-;;;;;;;;62783:4;62773:14;;:6;:14;;;:35;;62802:6;62773:35;;;62790:9;62773:35;62759:80;;;62810:28;62822:16;62810:9;:28;:::i;:::-;62759:80;;370:25:1;;;358:2;343:18;62759:80:0;;;;;;;62856:49;62872:6;62888:4;62895:9;62856:15;:49::i;:::-;62592:325;62573:344;61753:1171;;61665:1259;;;:::o;51800:675::-;51884:21;;;51876:67;;;;-1:-1:-1;;;51876:67:0;;14607:2:1;51876:67:0;;;14589:21:1;14646:2;14626:18;;;14619:30;14685:34;14665:18;;;14658:62;14756:3;14736:18;;;14729:31;14777:19;;51876:67:0;14405:397:1;51876:67:0;51956:49;51977:7;51994:1;51998:6;51956:20;:49::i;:::-;52043:18;;;52018:22;52043:18;;;;;;;;;;;52080:24;;;;52072:71;;;;-1:-1:-1;;;52072:71:0;;15009:2:1;52072:71:0;;;14991:21:1;15048:2;15028:18;;;15021:30;15087:34;15067:18;;;15060:62;15158:4;15138:18;;;15131:32;15180:19;;52072:71:0;14807:398:1;52072:71:0;52179:18;;;:9;:18;;;;;;;;;;;52200:23;;;52179:44;;52318:12;:22;;;;;;;52369:37;370:25:1;;;52179:9:0;;:18;52369:37;;343:18:1;52369:37:0;;;;;;;59969:88;59748:317;;59717:348::o;38442:191::-;38535:6;;;;38552:17;;;;;;;;;;;38585:40;;38535:6;;;38552:17;38535:6;;38585:40;;38516:16;;38585:40;38505:128;38442:191;:::o;32452:236::-;32537:7;32558:17;32577:18;32599:25;32610:4;32616:1;32619;32622;32599:10;:25::i;:::-;32557:67;;;;32635:18;32647:5;32635:11;:18::i;:::-;-1:-1:-1;32671:9:0;32452:236;-1:-1:-1;;;;;32452:236:0:o;62932:246::-;63062:16;;63053:6;63037:13;63047:2;45769:18;;45742:7;45769:18;;;;;;;;;;;;45668:127;63037:13;:22;;;;:::i;:::-;:41;:78;;;;-1:-1:-1;63082:24:0;;;;;;;:20;:24;;;;;;;;:33;63037:78;63033:138;;;63132:27;;-1:-1:-1;;;63132:27:0;;15412:2:1;63132:27:0;;;15394:21:1;15451:2;15431:18;;;15424:30;15490:19;15470:18;;;15463:47;15527:18;;63132:27:0;15210:341:1;30836:1477:0;30924:7;;31858:66;31845:79;;31841:163;;;-1:-1:-1;31957:1:0;;-1:-1:-1;31961:30:0;31941:51;;31841:163;32118:24;;;32101:14;32118:24;;;;;;;;;15783:25:1;;;15856:4;15844:17;;15824:18;;;15817:45;;;;15878:18;;;15871:34;;;15921:18;;;15914:34;;;32118:24:0;;15755:19:1;;32118:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;32118:24:0;;;;;;-1:-1:-1;;32157:20:0;;;32153:103;;32210:1;32214:29;32194:50;;;;;;;32153:103;32276:6;-1:-1:-1;32284:20:0;;-1:-1:-1;30836:1477:0;;;;;;;;:::o;26296:521::-;26374:20;26365:5;:29;;;;;;;;:::i;:::-;;26361:449;;26296:521;:::o;26361:449::-;26472:29;26463:5;:38;;;;;;;;:::i;:::-;;26459:351;;26518:34;;-1:-1:-1;;;26518:34:0;;16350:2:1;26518:34:0;;;16332:21:1;16389:2;16369:18;;;16362:30;16428:26;16408:18;;;16401:54;16472:18;;26518:34:0;16148:348:1;26459:351:0;26583:35;26574:5;:44;;;;;;;;:::i;:::-;;26570:240;;26635:41;;-1:-1:-1;;;26635:41:0;;16703:2:1;26635:41:0;;;16685:21:1;16742:2;16722:18;;;16715:30;16781:33;16761:18;;;16754:61;16832:18;;26635:41:0;16501:355:1;26570:240:0;26707:30;26698:5;:39;;;;;;;;:::i;:::-;;26694:116;;26754:44;;-1:-1:-1;;;26754:44:0;;17063:2:1;26754:44:0;;;17045:21:1;17102:2;17082:18;;;17075:30;17141:34;17121:18;;;17114:62;17212:4;17192:18;;;17185:32;17234:19;;26754:44:0;16861:398:1;406:607;518:4;547:2;576;565:9;558:21;608:6;602:13;651:6;646:2;635:9;631:18;624:34;676:1;686:140;700:6;697:1;694:13;686:140;;;795:14;;;791:23;;785:30;761:17;;;780:2;757:26;750:66;715:10;;686:140;;;690:3;875:1;870:2;861:6;850:9;846:22;842:31;835:42;1004:2;934:66;929:2;921:6;917:15;913:88;902:9;898:104;894:113;886:121;;;;406:607;;;;:::o;1018:196::-;1086:20;;1146:42;1135:54;;1125:65;;1115:93;;1204:1;1201;1194:12;1115:93;1018:196;;;:::o;1219:254::-;1287:6;1295;1348:2;1336:9;1327:7;1323:23;1319:32;1316:52;;;1364:1;1361;1354:12;1316:52;1387:29;1406:9;1387:29;:::i;:::-;1377:39;1463:2;1448:18;;;;1435:32;;-1:-1:-1;;;1219:254:1:o;1670:180::-;1729:6;1782:2;1770:9;1761:7;1757:23;1753:32;1750:52;;;1798:1;1795;1788:12;1750:52;-1:-1:-1;1821:23:1;;1670:180;-1:-1:-1;1670:180:1:o;1855:328::-;1932:6;1940;1948;2001:2;1989:9;1980:7;1976:23;1972:32;1969:52;;;2017:1;2014;2007:12;1969:52;2040:29;2059:9;2040:29;:::i;:::-;2030:39;;2088:38;2122:2;2111:9;2107:18;2088:38;:::i;:::-;2078:48;;2173:2;2162:9;2158:18;2145:32;2135:42;;1855:328;;;;;:::o;2562:186::-;2621:6;2674:2;2662:9;2653:7;2649:23;2645:32;2642:52;;;2690:1;2687;2680:12;2642:52;2713:29;2732:9;2713:29;:::i;:::-;2703:39;2562:186;-1:-1:-1;;;2562:186:1:o;2753:650::-;2871:6;2879;2932:2;2920:9;2911:7;2907:23;2903:32;2900:52;;;2948:1;2945;2938:12;2900:52;2988:9;2975:23;3017:18;3058:2;3050:6;3047:14;3044:34;;;3074:1;3071;3064:12;3044:34;3112:6;3101:9;3097:22;3087:32;;3157:7;3150:4;3146:2;3142:13;3138:27;3128:55;;3179:1;3176;3169:12;3128:55;3219:2;3206:16;3245:2;3237:6;3234:14;3231:34;;;3261:1;3258;3251:12;3231:34;3317:7;3312:2;3304:4;3296:6;3292:17;3288:2;3284:26;3280:35;3277:48;3274:68;;;3338:1;3335;3328:12;3274:68;3369:2;3361:11;;;;;3391:6;;-1:-1:-1;2753:650:1;;-1:-1:-1;;;;2753:650:1:o;4035:260::-;4103:6;4111;4164:2;4152:9;4143:7;4139:23;4135:32;4132:52;;;4180:1;4177;4170:12;4132:52;4203:29;4222:9;4203:29;:::i;:::-;4193:39;;4251:38;4285:2;4274:9;4270:18;4251:38;:::i;:::-;4241:48;;4035:260;;;;;:::o;4935:306::-;5023:6;5031;5039;5092:2;5080:9;5071:7;5067:23;5063:32;5060:52;;;5108:1;5105;5098:12;5060:52;5137:9;5131:16;5121:26;;5187:2;5176:9;5172:18;5166:25;5156:35;;5231:2;5220:9;5216:18;5210:25;5200:35;;4935:306;;;;;:::o;5592:437::-;5671:1;5667:12;;;;5714;;;5735:61;;5789:4;5781:6;5777:17;5767:27;;5735:61;5842:2;5834:6;5831:14;5811:18;5808:38;5805:218;;5879:77;5876:1;5869:88;5980:4;5977:1;5970:15;6008:4;6005:1;5998:15;5805:218;;5592:437;;;:::o;6034:184::-;6086:77;6083:1;6076:88;6183:4;6180:1;6173:15;6207:4;6204:1;6197:15;6223:168;6296:9;;;6327;;6344:15;;;6338:22;;6324:37;6314:71;;6365:18;;:::i;6396:274::-;6436:1;6462;6452:189;;6497:77;6494:1;6487:88;6598:4;6595:1;6588:15;6626:4;6623:1;6616:15;6452:189;-1:-1:-1;6655:9:1;;6396:274::o;6675:125::-;6740:9;;;6761:10;;;6758:36;;;6774:18;;:::i;6805:184::-;6857:77;6854:1;6847:88;6954:4;6951:1;6944:15;6978:4;6975:1;6968:15;6994:269;7051:6;7104:2;7092:9;7083:7;7079:23;7075:32;7072:52;;;7120:1;7117;7110:12;7072:52;7159:9;7146:23;7209:4;7202:5;7198:16;7191:5;7188:27;7178:55;;7229:1;7226;7219:12;8326:128;8393:9;;;8414:11;;;8411:37;;;8428:18;;:::i;8865:184::-;8917:77;8914:1;8907:88;9014:4;9011:1;9004:15;9038:4;9035:1;9028:15;9054:1026;9316:4;9364:3;9353:9;9349:19;9395:6;9384:9;9377:25;9421:2;9459:6;9454:2;9443:9;9439:18;9432:34;9502:3;9497:2;9486:9;9482:18;9475:31;9526:6;9561;9555:13;9592:6;9584;9577:22;9630:3;9619:9;9615:19;9608:26;;9669:2;9661:6;9657:15;9643:29;;9690:1;9700:218;9714:6;9711:1;9708:13;9700:218;;;9779:13;;9794:42;9775:62;9763:75;;9893:15;;;;9858:12;;;;9736:1;9729:9;9700:218;;;-1:-1:-1;;9986:42:1;9974:55;;;;9969:2;9954:18;;9947:83;-1:-1:-1;;;10061:3:1;10046:19;10039:35;9935:3;9054:1026;-1:-1:-1;;;9054:1026:1:o;10085:1164::-;10180:6;10211:2;10254;10242:9;10233:7;10229:23;10225:32;10222:52;;;10270:1;10267;10260:12;10222:52;10303:9;10297:16;10332:18;10373:2;10365:6;10362:14;10359:34;;;10389:1;10386;10379:12;10359:34;10427:6;10416:9;10412:22;10402:32;;10472:7;10465:4;10461:2;10457:13;10453:27;10443:55;;10494:1;10491;10484:12;10443:55;10523:2;10517:9;10545:2;10541;10538:10;10535:36;;;10551:18;;:::i;:::-;10597:2;10594:1;10590:10;10629:2;10623:9;10688:66;10683:2;10679;10675:11;10671:84;10663:6;10659:97;10806:6;10794:10;10791:22;10786:2;10774:10;10771:18;10768:46;10765:72;;;10817:18;;:::i;:::-;10853:2;10846:22;10903:18;;;10937:15;;;;-1:-1:-1;10979:11:1;;;10975:20;;;11007:19;;;11004:39;;;11039:1;11036;11029:12;11004:39;11063:11;;;;11083:135;11099:6;11094:3;11091:15;11083:135;;;11165:10;;11153:23;;11116:12;;;;11196;;;;11083:135;;;11237:6;10085:1164;-1:-1:-1;;;;;;;;10085:1164:1:o;15959:184::-;16011:77;16008:1;16001:88;16108:4;16105:1;16098:15;16132:4;16129:1;16122:15

Swarm Source

ipfs://91090b4ea6218bf0e241ffb991bd7fcf569317b1b214e7001a323ce2007e93a9

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services