StandardToken

{{
  "language": "Solidity",
  "sources": {
    "contracts/StandardTokens/StandardToken.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
\r
pragma solidity ^0.8.1;\r
\r
library Address {\r
    function isContract(address account) internal view returns (bool) {\r
        // This method relies on extcodesize/address.code.length, which returns 0\r
        // for contracts in construction, since the code is only stored at the end\r
        // of the constructor execution.\r
\r
        return account.code.length > 0;\r
    }\r
    function sendValue(address payable recipient, uint256 amount) internal {\r
        require(address(this).balance >= amount, "Address: insufficient balance");\r
\r
        (bool success, ) = recipient.call{value: amount}("");\r
        require(success, "Address: unable to send value, recipient may have reverted");\r
    }\r
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");\r
    }\r
    function functionCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, 0, errorMessage);\r
    }\r
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");\r
    }\r
    function functionCallWithValue(\r
        address target,\r
        bytes memory data,\r
        uint256 value,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        require(address(this).balance >= value, "Address: insufficient balance for call");\r
        (bool success, bytes memory returndata) = target.call{value: value}(data);\r
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\r
    }\r
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r
        return functionStaticCall(target, data, "Address: low-level static call failed");\r
    }\r
    function functionStaticCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal view returns (bytes memory) {\r
        (bool success, bytes memory returndata) = target.staticcall(data);\r
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\r
    }\r
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");\r
    }\r
    function functionDelegateCall(\r
        address target,\r
        bytes memory data,\r
        string memory errorMessage\r
    ) internal returns (bytes memory) {\r
        (bool success, bytes memory returndata) = target.delegatecall(data);\r
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\r
    }\r
    function verifyCallResultFromTarget(\r
        address target,\r
        bool success,\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) internal view returns (bytes memory) {\r
        if (success) {\r
            if (returndata.length == 0) {\r
                // only check isContract if the call was successful and the return data is empty\r
                // otherwise we already know that it was a contract\r
                require(isContract(target), "Address: call to non-contract");\r
            }\r
            return returndata;\r
        } else {\r
            _revert(returndata, errorMessage);\r
        }\r
    }\r
    function verifyCallResult(\r
        bool success,\r
        bytes memory returndata,\r
        string memory errorMessage\r
    ) internal pure returns (bytes memory) {\r
        if (success) {\r
            return returndata;\r
        } else {\r
            _revert(returndata, errorMessage);\r
        }\r
    }\r
    function _revert(bytes memory returndata, string memory errorMessage) private pure {\r
        // Look for revert reason and bubble it up if present\r
        if (returndata.length > 0) {\r
            // The easiest way to bubble the revert reason is using memory via assembly\r
            /// @solidity memory-safe-assembly\r
            assembly {\r
                let returndata_size := mload(returndata)\r
                revert(add(32, returndata), returndata_size)\r
            }\r
        } else {\r
            revert(errorMessage);\r
        }\r
    }\r
}\r
\r
pragma solidity ^0.8.0;\r
\r
interface IERC20 {\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
    function totalSupply() external view returns (uint256);\r
    function balanceOf(address account) external view returns (uint256);\r
    function transfer(address to, uint256 amount) external returns (bool);\r
    function allowance(address owner, address spender) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function transferFrom(address from, address to, uint256 amount) external returns (bool);\r
}\r
\r
interface IERC20Metadata is IERC20 {\r
    function name() external view returns (string memory);\r
    function symbol() external view returns (string memory);\r
    function decimals() external view returns (uint8);\r
}\r
\r
abstract contract Context {\r
    function _msgSender() internal view virtual returns (address) {\r
        return msg.sender;\r
    }\r
\r
    function _msgData() internal view virtual returns (bytes calldata) {\r
        return msg.data;\r
    }\r
}\r
\r
contract ERC20 is Context, IERC20, IERC20Metadata {\r
    mapping(address => uint256) private _balances;\r
\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    uint256 private _totalSupply;\r
\r
    string private _name;\r
    string private _symbol;\r
    constructor(string memory name_, string memory symbol_) {\r
        _name = name_;\r
        _symbol = symbol_;\r
    }\r
    function name() public view virtual override returns (string memory) {\r
        return _name;\r
    }\r
    function symbol() public view virtual override returns (string memory) {\r
        return _symbol;\r
    }\r
    function decimals() public view virtual override returns (uint8) {\r
        return 18;\r
    }\r
    function totalSupply() public view virtual override returns (uint256) {\r
        return _totalSupply;\r
    }\r
    function balanceOf(address account) public view virtual override returns (uint256) {\r
        return _balances[account];\r
    }\r
    function transfer(address to, uint256 amount) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _transfer(owner, to, amount);\r
        return true;\r
    }\r
    function allowance(address owner, address spender) public view virtual override returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
    function approve(address spender, uint256 amount) public virtual override returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, amount);\r
        return true;\r
    }\r
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\r
        address spender = _msgSender();\r
        _spendAllowance(from, spender, amount);\r
        _transfer(from, to, amount);\r
        return true;\r
    }\r
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\r
        address owner = _msgSender();\r
        _approve(owner, spender, allowance(owner, spender) + addedValue);\r
        return true;\r
    }\r
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\r
        address owner = _msgSender();\r
        uint256 currentAllowance = allowance(owner, spender);\r
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");\r
        unchecked {\r
            _approve(owner, spender, currentAllowance - subtractedValue);\r
        }\r
\r
        return true;\r
    }\r
    function _transfer(address from, address to, uint256 amount) internal virtual {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
\r
        _beforeTokenTransfer(from, to, amount);\r
\r
        uint256 fromBalance = _balances[from];\r
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");\r
        unchecked {\r
            _balances[from] = fromBalance - amount;\r
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\r
            // decrementing then incrementing.\r
            _balances[to] += amount;\r
        }\r
\r
        emit Transfer(from, to, amount);\r
\r
        _afterTokenTransfer(from, to, amount);\r
    }\r
    function _mint(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: mint to the zero address");\r
\r
        _beforeTokenTransfer(address(0), account, amount);\r
\r
        _totalSupply += amount;\r
        unchecked {\r
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\r
            _balances[account] += amount;\r
        }\r
        emit Transfer(address(0), account, amount);\r
\r
        _afterTokenTransfer(address(0), account, amount);\r
    }\r
    function _burn(address account, uint256 amount) internal virtual {\r
        require(account != address(0), "ERC20: burn from the zero address");\r
\r
        _beforeTokenTransfer(account, address(0), amount);\r
\r
        uint256 accountBalance = _balances[account];\r
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");\r
        unchecked {\r
            _balances[account] = accountBalance - amount;\r
            // Overflow not possible: amount <= accountBalance <= totalSupply.\r
            _totalSupply -= amount;\r
        }\r
\r
        emit Transfer(account, address(0), amount);\r
\r
        _afterTokenTransfer(account, address(0), amount);\r
    }\r
    function _approve(address owner, address spender, uint256 amount) internal virtual {\r
        require(owner != address(0), "ERC20: approve from the zero address");\r
        require(spender != address(0), "ERC20: approve to the zero address");\r
\r
        _allowances[owner][spender] = amount;\r
        emit Approval(owner, spender, amount);\r
    }\r
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\r
        uint256 currentAllowance = allowance(owner, spender);\r
        if (currentAllowance != type(uint256).max) {\r
            require(currentAllowance >= amount, "ERC20: insufficient allowance");\r
            unchecked {\r
                _approve(owner, spender, currentAllowance - amount);\r
            }\r
        }\r
    }\r
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\r
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\r
}\r
\r
abstract contract Ownable is Context {\r
    address private _owner;\r
\r
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r
    constructor() {\r
        _transferOwnership(_msgSender());\r
    }\r
    modifier onlyOwner() {\r
        _checkOwner();\r
        _;\r
    }\r
    function owner() public view virtual returns (address) {\r
        return _owner;\r
    }\r
    function _checkOwner() internal view virtual {\r
        require(owner() == _msgSender(), "Ownable: caller is not the owner");\r
    }\r
    function renounceOwnership() public virtual onlyOwner {\r
        _transferOwnership(address(0));\r
    }\r
    function transferOwnership(address newOwner) public virtual onlyOwner {\r
        require(newOwner != address(0), "Ownable: new owner is the zero address");\r
        _transferOwnership(newOwner);\r
    }\r
    function _transferOwnership(address newOwner) internal virtual {\r
        address oldOwner = _owner;\r
        _owner = newOwner;\r
        emit OwnershipTransferred(oldOwner, newOwner);\r
    }\r
}\r
\r
interface IERC20Permit {\r
    function permit(\r
        address owner,\r
        address spender,\r
        uint256 value,\r
        uint256 deadline,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external;\r
    function nonces(address owner) external view returns (uint256);\r
    function DOMAIN_SEPARATOR() external view returns (bytes32);\r
}\r
\r
library SafeERC20 {\r
    using Address for address;\r
    function safeTransfer(IERC20 token, address to, uint256 value) internal {\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\r
    }\r
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\r
    }\r
    function safeApprove(IERC20 token, address spender, uint256 value) internal {\r
        // safeApprove should only be called when setting an initial allowance,\r
        // or when resetting it to zero. To increase and decrease it, use\r
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\r
        require(\r
            (value == 0) || (token.allowance(address(this), spender) == 0),\r
            "SafeERC20: approve from non-zero to non-zero allowance"\r
        );\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\r
    }\r
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\r
        uint256 oldAllowance = token.allowance(address(this), spender);\r
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\r
    }\r
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\r
        unchecked {\r
            uint256 oldAllowance = token.allowance(address(this), spender);\r
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");\r
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\r
        }\r
    }\r
    function forceApprove(IERC20 token, address spender, uint256 value) internal {\r
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\r
\r
        if (!_callOptionalReturnBool(token, approvalCall)) {\r
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\r
            _callOptionalReturn(token, approvalCall);\r
        }\r
    }\r
    function safePermit(\r
        IERC20Permit token,\r
        address owner,\r
        address spender,\r
        uint256 value,\r
        uint256 deadline,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) internal {\r
        uint256 nonceBefore = token.nonces(owner);\r
        token.permit(owner, spender, value, deadline, v, r, s);\r
        uint256 nonceAfter = token.nonces(owner);\r
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");\r
    }\r
    function _callOptionalReturn(IERC20 token, bytes memory data) private {\r
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\r
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\r
        // the target address contains contract code and also asserts for success in the low-level call.\r
\r
        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");\r
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");\r
    }\r
\r
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\r
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\r
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\r
        // and not revert is the subcall reverts.\r
\r
        (bool success, bytes memory returndata) = address(token).call(data);\r
        return\r
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\r
    }\r
}\r
\r
library Math {\r
    enum Rounding {\r
        Down, // Toward negative infinity\r
        Up, // Toward infinity\r
        Zero // Toward zero\r
    }\r
    function max(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a > b ? a : b;\r
    }\r
    function min(uint256 a, uint256 b) internal pure returns (uint256) {\r
        return a < b ? a : b;\r
    }\r
    function average(uint256 a, uint256 b) internal pure returns (uint256) {\r
        // (a + b) / 2 can overflow.\r
        return (a & b) + (a ^ b) / 2;\r
    }\r
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\r
        // (a + b - 1) / b can overflow on addition, so we distribute.\r
        return a == 0 ? 0 : (a - 1) / b + 1;\r
    }\r
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\r
        unchecked {\r
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\r
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\r
            // variables such that product = prod1 * 2^256 + prod0.\r
            uint256 prod0; // Least significant 256 bits of the product\r
            uint256 prod1; // Most significant 256 bits of the product\r
            assembly {\r
                let mm := mulmod(x, y, not(0))\r
                prod0 := mul(x, y)\r
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\r
            }\r
\r
            // Handle non-overflow cases, 256 by 256 division.\r
            if (prod1 == 0) {\r
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\r
                // The surrounding unchecked block does not change this fact.\r
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\r
                return prod0 / denominator;\r
            }\r
\r
            // Make sure the result is less than 2^256. Also prevents denominator == 0.\r
            require(denominator > prod1, "Math: mulDiv overflow");\r
\r
            uint256 remainder;\r
            assembly {\r
                // Compute remainder using mulmod.\r
                remainder := mulmod(x, y, denominator)\r
\r
                // Subtract 256 bit number from 512 bit number.\r
                prod1 := sub(prod1, gt(remainder, prod0))\r
                prod0 := sub(prod0, remainder)\r
            }\r
\r
            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\r
            // See https://cs.stackexchange.com/q/138556/92363.\r
\r
            // Does not overflow because the denominator cannot be zero at this stage in the function.\r
            uint256 twos = denominator & (~denominator + 1);\r
            assembly {\r
                // Divide denominator by twos.\r
                denominator := div(denominator, twos)\r
\r
                // Divide [prod1 prod0] by twos.\r
                prod0 := div(prod0, twos)\r
\r
                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\r
                twos := add(div(sub(0, twos), twos), 1)\r
            }\r
\r
            // Shift in bits from prod1 into prod0.\r
            prod0 |= prod1 * twos;\r
\r
            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\r
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\r
            // four bits. That is, denominator * inv = 1 mod 2^4.\r
            uint256 inverse = (3 * denominator) ^ 2;\r
\r
            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\r
            // in modular arithmetic, doubling the correct bits in each step.\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^8\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^16\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^32\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^64\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^128\r
            inverse *= 2 - denominator * inverse; // inverse mod 2^256\r
\r
            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\r
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\r
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\r
            // is no longer required.\r
            result = prod0 * inverse;\r
            return result;\r
        }\r
    }\r
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\r
        uint256 result = mulDiv(x, y, denominator);\r
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\r
            result += 1;\r
        }\r
        return result;\r
    }\r
    function sqrt(uint256 a) internal pure returns (uint256) {\r
        if (a == 0) {\r
            return 0;\r
        }\r
\r
        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\r
        //\r
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have\r
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\r
        //\r
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\r
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\r
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\r
        //\r
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\r
        uint256 result = 1 << (log2(a) >> 1);\r
\r
        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\r
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\r
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\r
        // into the expected uint128 result.\r
        unchecked {\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            result = (result + a / result) >> 1;\r
            return min(result, a / result);\r
        }\r
    }\r
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = sqrt(a);\r
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\r
        }\r
    }\r
    function log2(uint256 value) internal pure returns (uint256) {\r
        uint256 result = 0;\r
        unchecked {\r
            if (value >> 128 > 0) {\r
                value >>= 128;\r
                result += 128;\r
            }\r
            if (value >> 64 > 0) {\r
                value >>= 64;\r
                result += 64;\r
            }\r
            if (value >> 32 > 0) {\r
                value >>= 32;\r
                result += 32;\r
            }\r
            if (value >> 16 > 0) {\r
                value >>= 16;\r
                result += 16;\r
            }\r
            if (value >> 8 > 0) {\r
                value >>= 8;\r
                result += 8;\r
            }\r
            if (value >> 4 > 0) {\r
                value >>= 4;\r
                result += 4;\r
            }\r
            if (value >> 2 > 0) {\r
                value >>= 2;\r
                result += 2;\r
            }\r
            if (value >> 1 > 0) {\r
                result += 1;\r
            }\r
        }\r
        return result;\r
    }\r
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = log2(value);\r
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\r
        }\r
    }\r
    function log10(uint256 value) internal pure returns (uint256) {\r
        uint256 result = 0;\r
        unchecked {\r
            if (value >= 10 ** 64) {\r
                value /= 10 ** 64;\r
                result += 64;\r
            }\r
            if (value >= 10 ** 32) {\r
                value /= 10 ** 32;\r
                result += 32;\r
            }\r
            if (value >= 10 ** 16) {\r
                value /= 10 ** 16;\r
                result += 16;\r
            }\r
            if (value >= 10 ** 8) {\r
                value /= 10 ** 8;\r
                result += 8;\r
            }\r
            if (value >= 10 ** 4) {\r
                value /= 10 ** 4;\r
                result += 4;\r
            }\r
            if (value >= 10 ** 2) {\r
                value /= 10 ** 2;\r
                result += 2;\r
            }\r
            if (value >= 10 ** 1) {\r
                result += 1;\r
            }\r
        }\r
        return result;\r
    }\r
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = log10(value);\r
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\r
        }\r
    }\r
    function log256(uint256 value) internal pure returns (uint256) {\r
        uint256 result = 0;\r
        unchecked {\r
            if (value >> 128 > 0) {\r
                value >>= 128;\r
                result += 16;\r
            }\r
            if (value >> 64 > 0) {\r
                value >>= 64;\r
                result += 8;\r
            }\r
            if (value >> 32 > 0) {\r
                value >>= 32;\r
                result += 4;\r
            }\r
            if (value >> 16 > 0) {\r
                value >>= 16;\r
                result += 2;\r
            }\r
            if (value >> 8 > 0) {\r
                result += 1;\r
            }\r
        }\r
        return result;\r
    }\r
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\r
        unchecked {\r
            uint256 result = log256(value);\r
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\r
        }\r
    }\r
}\r
\r
pragma solidity >=0.5.0;\r
\r
interface IUniswapV2Factory {\r
    event PairCreated(\r
        address indexed token0,\r
        address indexed token1,\r
        address pair,\r
        uint256\r
    );\r
\r
    function feeTo() external view returns (address);\r
\r
    function feeToSetter() external view returns (address);\r
\r
    function getPair(address tokenA, address tokenB)\r
        external\r
        view\r
        returns (address pair);\r
\r
    function allPairs(uint256) external view returns (address pair);\r
\r
    function allPairsLength() external view returns (uint256);\r
\r
    function createPair(address tokenA, address tokenB)\r
        external\r
        returns (address pair);\r
\r
    function setFeeTo(address) external;\r
\r
    function setFeeToSetter(address) external;\r
}\r
interface IUniswapV2Pair {\r
    event Approval(address indexed owner, address indexed spender, uint value);\r
    event Transfer(address indexed from, address indexed to, uint value);\r
\r
    function name() external pure returns (string memory);\r
    function symbol() external pure returns (string memory);\r
    function decimals() external pure returns (uint8);\r
    function totalSupply() external view returns (uint);\r
    function balanceOf(address owner) external view returns (uint);\r
    function allowance(address owner, address spender) external view returns (uint);\r
\r
    function approve(address spender, uint value) external returns (bool);\r
    function transfer(address to, uint value) external returns (bool);\r
    function transferFrom(address from, address to, uint value) external returns (bool);\r
\r
    function DOMAIN_SEPARATOR() external view returns (bytes32);\r
    function PERMIT_TYPEHASH() external pure returns (bytes32);\r
    function nonces(address owner) external view returns (uint);\r
\r
    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\r
\r
    event Mint(address indexed sender, uint amount0, uint amount1);\r
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\r
    event Swap(\r
        address indexed sender,\r
        uint amount0In,\r
        uint amount1In,\r
        uint amount0Out,\r
        uint amount1Out,\r
        address indexed to\r
    );\r
    event Sync(uint112 reserve0, uint112 reserve1);\r
\r
    function MINIMUM_LIQUIDITY() external pure returns (uint);\r
    function factory() external view returns (address);\r
    function token0() external view returns (address);\r
    function token1() external view returns (address);\r
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\r
    function price0CumulativeLast() external view returns (uint);\r
    function price1CumulativeLast() external view returns (uint);\r
    function kLast() external view returns (uint);\r
\r
    function mint(address to) external returns (uint liquidity);\r
    function burn(address to) external returns (uint amount0, uint amount1);\r
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\r
    function skim(address to) external;\r
    function sync() external;\r
\r
    function initialize(address, address) external;\r
}\r
\r
pragma solidity >=0.6.2;\r
\r
interface IUniswapV2Router01 {\r
    function factory() external pure returns (address);\r
\r
    function WETH() external pure returns (address);\r
\r
    function addLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint256 amountADesired,\r
        uint256 amountBDesired,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline\r
    )\r
        external\r
        returns (\r
            uint256 amountA,\r
            uint256 amountB,\r
            uint256 liquidity\r
        );\r
\r
    function addLiquidityETH(\r
        address token,\r
        uint256 amountTokenDesired,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    )\r
        external\r
        payable\r
        returns (\r
            uint256 amountToken,\r
            uint256 amountETH,\r
            uint256 liquidity\r
        );\r
\r
    function removeLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint256 liquidity,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountA, uint256 amountB);\r
\r
    function removeLiquidityETH(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountToken, uint256 amountETH);\r
\r
    function removeLiquidityWithPermit(\r
        address tokenA,\r
        address tokenB,\r
        uint256 liquidity,\r
        uint256 amountAMin,\r
        uint256 amountBMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountA, uint256 amountB);\r
\r
    function removeLiquidityETHWithPermit(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountToken, uint256 amountETH);\r
\r
    function swapExactTokensForTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapTokensForExactTokens(\r
        uint256 amountOut,\r
        uint256 amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapExactETHForTokens(\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable returns (uint256[] memory amounts);\r
\r
    function swapTokensForExactETH(\r
        uint256 amountOut,\r
        uint256 amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapExactTokensForETH(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256[] memory amounts);\r
\r
    function swapETHForExactTokens(\r
        uint256 amountOut,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable returns (uint256[] memory amounts);\r
\r
    function quote(\r
        uint256 amountA,\r
        uint256 reserveA,\r
        uint256 reserveB\r
    ) external pure returns (uint256 amountB);\r
\r
    function getAmountOut(\r
        uint256 amountIn,\r
        uint256 reserveIn,\r
        uint256 reserveOut\r
    ) external pure returns (uint256 amountOut);\r
\r
    function getAmountIn(\r
        uint256 amountOut,\r
        uint256 reserveIn,\r
        uint256 reserveOut\r
    ) external pure returns (uint256 amountIn);\r
\r
    function getAmountsOut(uint256 amountIn, address[] calldata path)\r
        external\r
        view\r
        returns (uint256[] memory amounts);\r
\r
    function getAmountsIn(uint256 amountOut, address[] calldata path)\r
        external\r
        view\r
        returns (uint256[] memory amounts);\r
}\r
interface IUniswapV2Router02 is IUniswapV2Router01 {\r
    function removeLiquidityETHSupportingFeeOnTransferTokens(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline\r
    ) external returns (uint256 amountETH);\r
\r
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r
        address token,\r
        uint256 liquidity,\r
        uint256 amountTokenMin,\r
        uint256 amountETHMin,\r
        address to,\r
        uint256 deadline,\r
        bool approveMax,\r
        uint8 v,\r
        bytes32 r,\r
        bytes32 s\r
    ) external returns (uint256 amountETH);\r
\r
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external;\r
\r
    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external payable;\r
\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint256 deadline\r
    ) external;\r
}\r
pragma solidity 0.8.19;\r
\r
interface IUniswapV2Caller {\r
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
        address router,\r
        uint256 amountIn,\r
        uint256 amountOutMin,\r
        address[] calldata path,\r
        uint256 deadline\r
    ) external;\r
}\r
interface IFee {\r
    function payFee(\r
        uint256 _tokenType,\r
        address creator,\r
        bool isAntibot,\r
        address referrer\r
    ) external payable;\r
}\r
contract StandardToken is ERC20, Ownable {\r
    using SafeERC20 for IERC20;\r
    struct Args {\r
        string name;\r
        string symbol;\r
        uint8 decimals;\r
        uint256 totalSupply;\r
        uint256 maxWallet;\r
        uint256 maxTransactionAmount;\r
        address marketingWallet;\r
        address baseTokenForMarket;\r
        address mainRouter;\r
        bool isMarketingFeeBaseToken;\r
        uint24 sellLiquidityFee;\r
        uint24 buyLiquidityFee;\r
        uint24 sellMarketingFee;\r
        uint24 buyMarketingFee;\r
        address feeContract;\r
        address uniswapV2Caller;\r
    }\r
    IUniswapV2Caller public uniswapV2Caller;\r
\r
    uint256 private constant MAX = ~uint256(0);\r
\r
    uint8 private _decimals;\r
    ///////////////////////////////////////////////////////////////////////////\r
    address public baseTokenForMarket;\r
    bool public isBaseTokenWETH;\r
    bool private inSwapAndLiquify;\r
    uint24 public sellLiquidityFee;\r
    uint24 public buyLiquidityFee;\r
\r
    uint24 public sellMarketingFee;\r
    uint24 public buyMarketingFee;\r
\r
    address public marketingWallet;\r
    bool public isMarketingFeeBaseToken;\r
\r
    uint256 public minAmountToTakeFee;\r
    uint256 public maxWallet;\r
    uint256 public maxTransactionAmount;\r
\r
    address public mainRouter;\r
    address public mainPair;\r
\r
\r
    mapping(address => bool) public isExcludedFromMaxTransactionAmount;\r
    mapping(address => bool) public isExcludedFromFee;\r
    mapping(address => bool) public automatedMarketMakerPairs;\r
\r
    uint256 private _liquidityFeeTokens;\r
    uint256 private _marketingFeeTokens;\r
    event UpdateLiquidityFee(\r
        uint24 newSellLiquidityFee,\r
        uint24 newBuyLiquidityFee,\r
        uint24 oldSellLiquidityFee,\r
        uint24 oldBuyLiquidityFee\r
    );\r
    event UpdateMarketingFee(\r
        uint24 newSellMarketingFee,\r
        uint24 newBuyMarketingFee,\r
        uint24 oldSellMarketingFee,\r
        uint24 oldBuyMarketingFee\r
    );\r
    event UpdateMarketingWallet(\r
        address indexed newMarketingWallet,\r
        bool newIsMarketingFeeBaseToken,\r
        address indexed oldMarketingWallet,\r
        bool oldIsMarketingFeeBaseToken\r
    );\r
    event ExcludedFromMaxTransactionAmount(address indexed account, bool isExcluded);\r
    event UpdateMinAmountToTakeFee(uint256 newMinAmountToTakeFee, uint256 oldMinAmountToTakeFee);\r
    event SetAutomatedMarketMakerPair(address indexed pair, bool value);\r
    event ExcludedFromFee(address indexed account, bool isEx);\r
    event SwapAndLiquify(\r
        uint256 tokensForLiquidity,\r
        uint256 baseTokenForLiquidity\r
    );\r
    event MarketingFeeTaken(\r
        uint256 marketingFeeTokens,\r
        uint256 marketingFeeBaseTokenSwapped\r
    );\r
    event MainRouterUpdated(\r
        address mainRouter, address mainPair, address baseTokenForMarket\r
    );\r
    event UpdateMaxWallet(uint256 newMaxWallet, uint256 oldMaxWallet);\r
    event UpdateMaxTransactionAmount(uint256 newMaxTransactionAmount, uint256 oldMaxTransactionAmount);\r
    ///////////////////////////////////////////////////////////////////////////////\r
 \r
\r
    constructor(\r
        Args memory args,\r
        address[] memory autoApproveAddressList,\r
        address referrer\r
    ) ERC20(args.name, args.symbol) payable {\r
        IFee(args.feeContract).payFee{value: msg.value}(1, _msgSender(), false, referrer);   \r
        _decimals = args.decimals;\r
        _mint(msg.sender, args.totalSupply);\r
        uniswapV2Caller = IUniswapV2Caller(args.uniswapV2Caller);\r
        baseTokenForMarket=args.baseTokenForMarket;\r
        require(args.marketingWallet!=address(0), "marketing wallet can not be 0");\r
        require(args.mainRouter!=address(0), "Router address can not be 0");\r
        require(args.sellLiquidityFee+args.sellMarketingFee<=200000, "sell fee <= 20%");\r
        require(args.buyLiquidityFee+args.buyMarketingFee<=200000, "buy fee <= 20%");\r
\r
        marketingWallet=args.marketingWallet;\r
        isMarketingFeeBaseToken=args.isMarketingFeeBaseToken;\r
        emit UpdateMarketingWallet(\r
            marketingWallet,\r
            isMarketingFeeBaseToken,\r
            address(0),\r
            false\r
        );\r
        mainRouter=args.mainRouter;\r
        if(baseTokenForMarket != IUniswapV2Router02(mainRouter).WETH()){            \r
            IERC20(baseTokenForMarket).safeApprove(mainRouter, MAX);            \r
        }else{\r
            isBaseTokenWETH=true;\r
        }\r
       \r
        \r
        _approve(address(this), address(uniswapV2Caller), MAX);\r
        _approve(address(this), mainRouter, MAX);\r
        for(uint256 i=0;i<autoApproveAddressList.length;i++){\r
            _approve(_msgSender(), autoApproveAddressList[i], MAX);\r
            isExcludedFromFee[autoApproveAddressList[i]] = true;\r
            isExcludedFromMaxTransactionAmount[autoApproveAddressList[i]]=true;\r
        }\r
        \r
        emit MainRouterUpdated(mainRouter, mainPair, baseTokenForMarket);\r
        mainPair = IUniswapV2Factory(IUniswapV2Router02(mainRouter).factory()).createPair(\r
            address(this),\r
            baseTokenForMarket\r
        );\r
 \r
        \r
        require(args.maxTransactionAmount>=args.totalSupply / 10000, "maxTransactionAmount >= total supply / 10000");\r
        require(args.maxWallet>=args.totalSupply / 10000, "maxWallet >= total supply / 10000");\r
        maxWallet=args.maxWallet;\r
        emit UpdateMaxWallet(maxWallet, 0);\r
        maxTransactionAmount=args.maxTransactionAmount;\r
        emit UpdateMaxTransactionAmount(maxTransactionAmount, 0);\r
        \r
        sellLiquidityFee=args.sellLiquidityFee;\r
        buyLiquidityFee=args.buyLiquidityFee;\r
        emit UpdateLiquidityFee(sellLiquidityFee, buyLiquidityFee, 0, 0);        \r
        sellMarketingFee=args.sellMarketingFee;\r
        buyMarketingFee=args.buyMarketingFee;\r
        emit UpdateMarketingFee(\r
            sellMarketingFee,\r
            buyMarketingFee,\r
            0,\r
            0\r
        );\r
        minAmountToTakeFee=args.totalSupply/10000;\r
        emit UpdateMinAmountToTakeFee(minAmountToTakeFee, 0);\r
        isExcludedFromFee[address(this)]=true;\r
        isExcludedFromFee[marketingWallet]=true;\r
        isExcludedFromFee[_msgSender()]=true;\r
        isExcludedFromFee[address(0xdead)] = true;\r
        isExcludedFromMaxTransactionAmount[address(0xdead)]=true;\r
        isExcludedFromMaxTransactionAmount[address(this)]=true;\r
        isExcludedFromMaxTransactionAmount[marketingWallet]=true;\r
        isExcludedFromMaxTransactionAmount[_msgSender()]=true;\r
        _setAutomatedMarketMakerPair(mainPair, true);\r
    }\r
\r
    function decimals() public view override returns (uint8) {\r
        return _decimals;\r
    }\r
\r
    function updateMainPair(\r
        address _mainRouter,\r
        address _baseTokenForMarket\r
    ) external onlyOwner {\r
        baseTokenForMarket = _baseTokenForMarket;\r
        if(mainRouter != _mainRouter){\r
            _approve(address(this), _mainRouter, MAX);\r
            mainRouter = _mainRouter;\r
        } \r
        mainPair = IUniswapV2Factory(IUniswapV2Router02(mainRouter).factory()).createPair(\r
            address(this),\r
            baseTokenForMarket\r
        );\r
        if(baseTokenForMarket != IUniswapV2Router02(mainRouter).WETH()){            \r
            IERC20(baseTokenForMarket).safeApprove(mainRouter, MAX);\r
            isBaseTokenWETH=false;            \r
        }else{\r
            isBaseTokenWETH=true;\r
        }\r
     \r
        emit MainRouterUpdated(mainRouter, mainPair, baseTokenForMarket);\r
        _setAutomatedMarketMakerPair(mainPair, true);\r
    }\r
\r
\r
    /////////////////////////////////////////////////////////////////////////////////\r
    modifier lockTheSwap() {\r
        inSwapAndLiquify = true;\r
        _;\r
        inSwapAndLiquify = false;\r
    }\r
\r
    function updateLiquidityFee(\r
        uint24 _sellLiquidityFee,\r
        uint24 _buyLiquidityFee\r
    ) external onlyOwner {\r
        require(\r
            _sellLiquidityFee + sellMarketingFee <= 200000,\r
            "sell fee <= 20%"\r
        );\r
        require(_buyLiquidityFee + buyMarketingFee <= 200000, "buy fee <= 20%");\r
        emit UpdateLiquidityFee(\r
            _sellLiquidityFee,\r
            _buyLiquidityFee,\r
            sellLiquidityFee,\r
            buyLiquidityFee\r
        );\r
        sellLiquidityFee = _sellLiquidityFee;\r
        buyLiquidityFee = _buyLiquidityFee;           \r
    }\r
\r
    function updateMaxWallet(uint256 _maxWallet) external onlyOwner {\r
        require(_maxWallet>=totalSupply() / 10000, "maxWallet >= total supply / 10000");\r
        emit UpdateMaxWallet(_maxWallet, maxWallet);\r
        maxWallet = _maxWallet;\r
    }\r
\r
    function updateMaxTransactionAmount(uint256 _maxTransactionAmount)\r
        external\r
        onlyOwner\r
    {\r
        require(_maxTransactionAmount>=totalSupply() / 10000, "maxTransactionAmount >= total supply / 10000");\r
        emit UpdateMaxTransactionAmount(_maxTransactionAmount, maxTransactionAmount);\r
        maxTransactionAmount = _maxTransactionAmount;\r
    }\r
\r
    function updateMarketingFee(\r
        uint24 _sellMarketingFee,\r
        uint24 _buyMarketingFee\r
    ) external onlyOwner {\r
        require(\r
            _sellMarketingFee + sellLiquidityFee <= 200000,\r
            "sell fee <= 20%"\r
        );\r
        require(_buyMarketingFee + buyLiquidityFee <= 200000, "buy fee <= 20%");\r
        emit UpdateMarketingFee(\r
            _sellMarketingFee,\r
            _buyMarketingFee,\r
            sellMarketingFee,\r
            buyMarketingFee\r
        );\r
        sellMarketingFee = _sellMarketingFee;\r
        buyMarketingFee = _buyMarketingFee;  \r
    }\r
\r
    function updateMarketingWallet(\r
        address _marketingWallet,\r
        bool _isMarketingFeeBaseToken\r
    ) external onlyOwner {\r
        require(_marketingWallet != address(0), "marketing wallet can't be 0");\r
        emit UpdateMarketingWallet(_marketingWallet, _isMarketingFeeBaseToken,\r
            marketingWallet, isMarketingFeeBaseToken);\r
        marketingWallet = _marketingWallet;\r
        isMarketingFeeBaseToken = _isMarketingFeeBaseToken;\r
        isExcludedFromFee[_marketingWallet] = true;\r
        isExcludedFromMaxTransactionAmount[_marketingWallet] = true;\r
    }\r
\r
    function updateMinAmountToTakeFee(uint256 _minAmountToTakeFee)\r
        external\r
        onlyOwner\r
    {\r
        require(_minAmountToTakeFee > 0, "minAmountToTakeFee > 0");\r
        emit UpdateMinAmountToTakeFee(_minAmountToTakeFee, minAmountToTakeFee);\r
        minAmountToTakeFee = _minAmountToTakeFee;     \r
    }\r
\r
    function setAutomatedMarketMakerPair(address pair, bool value)\r
        public\r
        onlyOwner\r
    {\r
        require(\r
            automatedMarketMakerPairs[pair] != value,\r
            "Automated market maker pair is already set to that value"\r
        );\r
        _setAutomatedMarketMakerPair(pair, value);\r
    }\r
\r
    function _setAutomatedMarketMakerPair(address pair, bool value) private {        \r
        automatedMarketMakerPairs[pair] = value;\r
        isExcludedFromMaxTransactionAmount[pair] = value;\r
        emit SetAutomatedMarketMakerPair(pair, value);\r
    }\r
\r
    function excludeFromFee(address account, bool isEx) external onlyOwner {\r
        require(isExcludedFromFee[account] != isEx, "already");\r
        isExcludedFromFee[account] = isEx;\r
        emit ExcludedFromFee(account, isEx);\r
    }\r
\r
    function excludeFromMaxTransactionAmount(address account, bool isEx)\r
        external\r
        onlyOwner\r
    {\r
        require(isExcludedFromMaxTransactionAmount[account]!=isEx, "already");\r
        isExcludedFromMaxTransactionAmount[account] = isEx;\r
        emit ExcludedFromMaxTransactionAmount(account, isEx);\r
    }\r
\r
    function _transfer(\r
        address from,\r
        address to,\r
        uint256 amount\r
    ) internal override {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
        uint256 contractTokenBalance = balanceOf(address(this));\r
        \r
        uint256 totalTokensTaken = _liquidityFeeTokens + _marketingFeeTokens;\r
        bool overMinimumTokenBalance = totalTokensTaken >=\r
            minAmountToTakeFee && totalTokensTaken <= contractTokenBalance;\r
        // Take Fee\r
        if (\r
            !inSwapAndLiquify &&\r
            balanceOf(mainPair) > 0 &&\r
            overMinimumTokenBalance &&\r
            automatedMarketMakerPairs[to]\r
        ) {\r
            takeFee();\r
        }\r
\r
        uint256 _liquidityFee;\r
        uint256 _marketingFee;\r
        // If any account belongs to isExcludedFromFee account then remove the fee\r
\r
        if (\r
            !inSwapAndLiquify &&\r
            !isExcludedFromFee[from] &&\r
            !isExcludedFromFee[to]\r
        ) {\r
            // Buy\r
            if (automatedMarketMakerPairs[from]) {\r
                _liquidityFee = amount * buyLiquidityFee / 1000000;\r
                _marketingFee = amount * buyMarketingFee / 1000000;\r
            }\r
            // Sell\r
            else if (automatedMarketMakerPairs[to]) {\r
                _liquidityFee = amount * sellLiquidityFee / 1000000;\r
                _marketingFee = amount * sellMarketingFee / 1000000;\r
            }\r
            uint256 _feeTotal = _liquidityFee + _marketingFee;\r
            if (_feeTotal > 0) super._transfer(from, address(this), _feeTotal);\r
            amount = amount - _liquidityFee - _marketingFee;\r
            _liquidityFeeTokens = _liquidityFeeTokens + _liquidityFee;\r
            _marketingFeeTokens = _marketingFeeTokens + _marketingFee;\r
        }\r
        super._transfer(from, to, amount);\r
        if (!inSwapAndLiquify) {\r
            if (!isExcludedFromMaxTransactionAmount[from]) {\r
                require(\r
                    amount <= maxTransactionAmount,\r
                    "ERC20: exceeds transfer limit"\r
                );\r
            }\r
            if (!isExcludedFromMaxTransactionAmount[to]) {\r
                require(\r
                    balanceOf(to) <= maxWallet,\r
                    "ERC20: exceeds max wallet limit"\r
                );\r
            }\r
        }\r
    }\r
\r
    function takeFee() private lockTheSwap {\r
\r
        // Halve the amount of liquidity tokens\r
        uint256 tokensForLiquidity = _liquidityFeeTokens / 2;\r
        uint256 initialBaseTokenBalance = isBaseTokenWETH ? address(this).balance\r
            : IERC20(baseTokenForMarket).balanceOf(address(this));        \r
         \r
        uint256 baseTokenForLiquidity;\r
        if (isMarketingFeeBaseToken) {\r
            uint256 tokensForSwap=tokensForLiquidity+_marketingFeeTokens;\r
            if(tokensForSwap>0)\r
                swapTokensForBaseToken(tokensForSwap);\r
            uint256 baseTokenBalance = isBaseTokenWETH ? address(this).balance - initialBaseTokenBalance\r
                : IERC20(baseTokenForMarket).balanceOf(address(this)) - initialBaseTokenBalance;\r
            uint256 baseTokenAmountForMarketing = (baseTokenBalance *\r
                _marketingFeeTokens) / tokensForSwap;\r
            baseTokenForLiquidity = baseTokenBalance - baseTokenAmountForMarketing;\r
            if(baseTokenAmountForMarketing>0){\r
                if(isBaseTokenWETH){                \r
                    (bool success, )=address(marketingWallet).call{value: baseTokenAmountForMarketing}("");\r
                    if(success){\r
                        emit MarketingFeeTaken(0, baseTokenAmountForMarketing);\r
                    }\r
                }else{\r
                    IERC20(baseTokenForMarket).safeTransfer(\r
                        marketingWallet,\r
                        baseTokenAmountForMarketing\r
                    );\r
                    emit MarketingFeeTaken(0, baseTokenAmountForMarketing);\r
                }                \r
            }            \r
        } else {\r
            if(tokensForLiquidity>0)\r
                swapTokensForBaseToken(tokensForLiquidity);\r
            baseTokenForLiquidity = isBaseTokenWETH ? address(this).balance - initialBaseTokenBalance\r
                : IERC20(baseTokenForMarket).balanceOf(address(this)) - initialBaseTokenBalance;\r
            if(_marketingFeeTokens>0){\r
                _transfer(address(this), marketingWallet, _marketingFeeTokens);\r
                emit MarketingFeeTaken(_marketingFeeTokens, 0);                \r
            }            \r
        }\r
\r
        if (tokensForLiquidity > 0 && baseTokenForLiquidity > 0) {\r
            addLiquidity(tokensForLiquidity, baseTokenForLiquidity);\r
            emit SwapAndLiquify(tokensForLiquidity, baseTokenForLiquidity);\r
        }\r
        _marketingFeeTokens = 0;\r
        _liquidityFeeTokens = 0;    \r
        if(balanceOf(address(this))>0){\r
            if(owner()!=address(0)){\r
                _transfer(address(this), owner(), balanceOf(address(this)));  \r
            }else{\r
                _transfer(address(this), address(0xdead), balanceOf(address(this)));  \r
            }\r
        } \r
    }\r
\r
    function swapTokensForBaseToken(uint256 tokenAmount) private {\r
        address[] memory path = new address[](2);\r
        path[0] = address(this);\r
        path[1] = baseTokenForMarket;     \r
        if (isBaseTokenWETH){\r
            IUniswapV2Router02(mainRouter).swapExactTokensForETHSupportingFeeOnTransferTokens(\r
                tokenAmount,\r
                0, // accept any amount of BaseToken\r
                path,\r
                address(this),\r
                block.timestamp\r
            );\r
        }else{\r
            uniswapV2Caller.swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
                    address(mainRouter),\r
                    tokenAmount,\r
                    0, // accept any amount of BaseToken\r
                    path,\r
                    block.timestamp\r
                );\r
        }\r
        \r
    }\r
\r
    function addLiquidity(uint256 tokenAmount, uint256 baseTokenAmount)\r
        private\r
    {\r
        if (isBaseTokenWETH) \r
            IUniswapV2Router02(mainRouter).addLiquidityETH{value: baseTokenAmount}(\r
                address(this),\r
                tokenAmount,\r
                0, // slippage is unavoidable\r
                0, // slippage is unavoidable\r
                address(0xdead),\r
                block.timestamp\r
            );\r
        else{\r
            IUniswapV2Router02(mainRouter).addLiquidity(\r
                address(this),\r
                baseTokenForMarket,\r
                tokenAmount,\r
                baseTokenAmount,\r
                0,\r
                0,\r
                address(0xdead),\r
                block.timestamp\r
            );\r
        }  \r
    }\r
\r
    function withdrawETH() external onlyOwner {\r
        (bool success, )=address(owner()).call{value: address(this).balance}("");\r
        require(success, "Failed in withdrawal");\r
    }\r
    function withdrawToken(address token) external onlyOwner{\r
        require(address(this) != token, "Not allowed");\r
        IERC20(token).safeTransfer(owner(), IERC20(token).balanceOf(address(this)));\r
    }\r
    receive() external payable {}\r
}\r
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "libraries": {}
  }
}}