creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"
      },
      "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"
      },
      "contracts/interfaces/IFACTORY.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\ninterface IFACTORY {\n    function proofRevenueAddress() external view returns (address);\n\n    function proofRewardPoolAddress() external view returns (address);\n\n    function isWhitelisted(address user) external view returns(bool);\n}"
      },
      "contracts/interfaces/IProofNonReflectionTokenCutter.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport \"../libraries/ProofNonReflectionTokenFees.sol\";\n\ninterface IProofNonReflectionTokenCutter is IERC20, IERC20Metadata {\n    struct BaseData {\n        string tokenName;\n        string tokenSymbol;\n        uint256 initialSupply;\n        uint256 percentToLP;\n        address owner;\n        address dev;\n        address main;\n        address routerAddress;\n        address initialProofAdmin;\n        uint256 antiSnipeDuration;\n    }\n\n    function setBasicData(\n        BaseData memory _baseData,\n        ProofNonReflectionTokenFees.allFees memory fees\n    ) external;\n\n    function changeIsTxLimitExempt(\n        address holder,\n        bool exempt\n    ) external;\n\n    function changeFees(\n        uint256 initialMainFee,\n        uint256 initialMainFeeOnSell,\n        uint256 initialLpFee,\n        uint256 initialLpFeeOnSell,\n        uint256 initialDevFee,\n        uint256 initialDevFeeOnSell\n    ) external;\n}\n"
      },
      "contracts/interfaces/IUniswapV2Factory.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\ninterface IUniswapV2Factory {\n    function createPair(address tokenA, address tokenB)\n        external\n        returns (address pair);\n}"
      },
      "contracts/interfaces/IUniswapV2Router02.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\ninterface IUniswapV2Router02 {\n    function swapExactTokensForETHSupportingFeeOnTransferTokens(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external;\n\n    function swapExactETHForTokensSupportingFeeOnTransferTokens(\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external payable;\n\n    function factory() external pure returns (address);\n\n    function WETH() external pure returns (address);\n\n    function addLiquidityETH(\n        address token,\n        uint256 amountTokenDesired,\n        uint256 amountTokenMin,\n        uint256 amountETHMin,\n        address to,\n        uint256 deadline\n    )\n        external\n        payable\n        returns (\n            uint256 amountToken,\n            uint256 amountETH,\n            uint256 liquidity\n        );\n\n    function removeLiquidityETH(\n        address token,\n        uint256 liquidity,\n        uint256 amountTokenMin,\n        uint256 amountETHMin,\n        address to,\n        uint256 deadline\n    ) external returns (uint256 amountToken, uint256 amountETH);\n}"
      },
      "contracts/libraries/Context.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}"
      },
      "contracts/libraries/Ownable.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\nimport \"./Context.sol\";\n\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(\n        address indexed previousOwner,\n        address indexed newOwner\n    );\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(\n            newOwner != address(0),\n            \"Ownable: new owner is the zero address\"\n        );\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}"
      },
      "contracts/libraries/ProofNonReflectionTokenFees.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\nlibrary ProofNonReflectionTokenFees {\n    struct allFees {\n        uint256 mainFee;\n        uint256 mainFeeOnSell;\n        uint256 lpFee;\n        uint256 lpFeeOnSell;\n        uint256 devFee;\n        uint256 devFeeOnSell;\n    }\n}"
      },
      "contracts/tokenCutters/ProofNonReflectionTokenCutter.sol": {
        "content": "// SPDX-License-Identifier: None\npragma solidity ^0.8.17;\n\nimport \"../libraries/Ownable.sol\";\nimport \"../libraries/ProofNonReflectionTokenFees.sol\";\nimport \"../interfaces/IFACTORY.sol\";\nimport \"../interfaces/IUniswapV2Router02.sol\";\nimport \"../interfaces/IUniswapV2Factory.sol\";\nimport \"../interfaces/IProofNonReflectionTokenCutter.sol\";\n\ncontract ProofNonReflectionTokenCutter is Ownable, IProofNonReflectionTokenCutter {\n    //This token was created with PROOF, and audited by Solidity Finance — https://proofplatform.io/projects\n    mapping(address => uint256) private _balances;\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    address constant DEAD = 0x000000000000000000000000000000000000dEaD;\n    address constant ZERO = 0x0000000000000000000000000000000000000000;\n    address public proofAdmin;\n\n    bool public restrictWhales = true;\n\n    mapping(address => bool) public isFeeExempt;\n    mapping(address => bool) public isTxLimitExempt;\n    mapping(address => bool) public isDividendExempt;\n\n    uint256 public launchedAt;\n    uint256 public proofFee = 2;\n    uint256 public proofFeeOnSell = 2;\n\n    uint256 public mainFee;\n    uint256 public lpFee;\n    uint256 public devFee;\n\n    uint256 public mainFeeOnSell;\n    uint256 public lpFeeOnSell;\n    uint256 public devFeeOnSell;\n\n    uint256 public totalFee;\n    uint256 public totalFeeIfSelling;\n\n    bool public proofFeeRemoved = false;\n    bool public proofFeeReduced = false;\n\n    uint256 accMainFees;\n    uint256 accLpFees;\n    uint256 accDevFees;\n    uint256 accProofFees;\n\n    IUniswapV2Router02 public router;\n    address public pair;\n    address public factory;\n    address payable public devWallet;\n    address payable public mainWallet;\n\n    bool inSwapAndLiquify;\n    bool public swapAndLiquifyEnabled = true;\n    bool public tradingStatus = true;\n\n    mapping(address => bool) public bots;\n\n    uint256 public antiSnipeDuration;\n    uint256 public antiSnipeEndTime;\n\n    uint256 public _maxTxAmount;\n    uint256 public _walletMax;\n    uint256 public swapThreshold;\n\n    constructor() {\n        factory = msg.sender;\n    }\n\n    modifier lockTheSwap() {\n        inSwapAndLiquify = true;\n        _;\n        inSwapAndLiquify = false;\n    }\n\n    modifier onlyProofAdmin() {\n        require(proofAdmin == _msgSender(), \"Caller is not the proofAdmin\");\n        _;\n    }\n\n    modifier onlyFactory() {\n        require(factory == _msgSender(), \"Caller is not the factory\");\n        _;\n    }\n\n    function setBasicData(\n        BaseData memory _baseData,\n        ProofNonReflectionTokenFees.allFees memory fees\n    ) external onlyFactory {\n        _name = _baseData.tokenName;\n        _symbol = _baseData.tokenSymbol;\n        _totalSupply = _baseData.initialSupply;\n\n        //Tx & Wallet Limits\n        require(_baseData.percentToLP >= 70, \"Too low\");\n        _maxTxAmount = (_baseData.initialSupply * 5) / 1000;\n        _walletMax = (_baseData.initialSupply * 1) / 100;\n        swapThreshold = (_baseData.initialSupply * 5) / 4000;\n\n        router = IUniswapV2Router02(_baseData.routerAddress);\n        pair = IUniswapV2Factory(router.factory()).createPair(\n            router.WETH(),\n            address(this)\n        );\n\n        _allowances[address(this)][address(router)] = type(uint256).max;\n\n        isFeeExempt[address(this)] = true;\n        isFeeExempt[factory] = true;\n        isFeeExempt[_baseData.owner] = true;\n\n        isTxLimitExempt[_baseData.owner] = true;\n        isTxLimitExempt[pair] = true;\n        isTxLimitExempt[factory] = true;\n        isTxLimitExempt[DEAD] = true;\n        isTxLimitExempt[ZERO] = true;\n\n        //Fees\n        lpFee = fees.lpFee;\n        lpFeeOnSell = fees.lpFeeOnSell;\n        devFee = fees.devFee;\n        devFeeOnSell = fees.devFeeOnSell;\n        mainFee = fees.mainFee;\n        mainFeeOnSell = fees.mainFeeOnSell;\n\n        if (fees.devFee + fees.lpFee + fees.mainFee == 0) {\n            proofFee = 0;\n        } \n        totalFee = fees.devFee + fees.lpFee + fees.mainFee + proofFee;\n\n        if (fees.devFeeOnSell + fees.lpFeeOnSell + fees.mainFeeOnSell == 0) {\n            proofFeeOnSell = 0;\n        }\n        totalFeeIfSelling = fees.devFeeOnSell + fees.lpFeeOnSell + fees.mainFeeOnSell + proofFeeOnSell;\n\n\n        if (IFACTORY(factory).isWhitelisted(_baseData.owner)) {\n            require(totalFee <= 12, \"high KYC fee\");\n            require(totalFeeIfSelling <= 17, \"high KYC fee\");\n        } else {\n            require(totalFee <= 7, \"high fee\");\n            require(totalFeeIfSelling <= 7, \"high fee\");\n        }\n\n        devWallet = payable(_baseData.dev);\n        mainWallet = payable(_baseData.main);\n        proofAdmin = _baseData.initialProofAdmin;\n\n        //Initial supply\n        uint256 forLP = (_baseData.initialSupply * _baseData.percentToLP) / 100; //95%\n        uint256 forOwner = _baseData.initialSupply - forLP; //5%\n\n        _balances[msg.sender] += forLP;\n        _balances[_baseData.owner] += forOwner;\n\n        antiSnipeDuration = _baseData.antiSnipeDuration;\n\n        emit Transfer(address(0), msg.sender, forLP);\n        emit Transfer(address(0), _baseData.owner, forOwner);\n    }\n\n    //proofAdmin functions\n\n    function updateProofAdmin(\n        address newAdmin\n    ) external virtual onlyProofAdmin {\n        proofAdmin = newAdmin;\n    }\n\n    //Factory functions\n    function swapTradingStatus() external onlyFactory {\n        tradingStatus = !tradingStatus;\n    }\n\n    function setLaunchedAt() external onlyFactory {\n        require(launchedAt == 0, \"launched\");\n        launchedAt = block.timestamp;\n        antiSnipeEndTime = block.timestamp + antiSnipeDuration;\n    }\n\n    function cancelToken() external onlyFactory {\n        isFeeExempt[address(router)] = true;\n        isTxLimitExempt[address(router)] = true;\n        isTxLimitExempt[owner()] = true;\n        tradingStatus = true;\n        restrictWhales = false;\n        swapAndLiquifyEnabled = false;\n    }\n\n    //Owner functions\n    function changeRestrictWhales(bool _enable) external onlyOwner {\n        restrictWhales = _enable;\n    }\n\n    function changeFees(\n        uint256 initialMainFee,\n        uint256 initialMainFeeOnSell,\n        uint256 initialLpFee,\n        uint256 initialLpFeeOnSell,\n        uint256 initialDevFee,\n        uint256 initialDevFeeOnSell\n    ) external onlyOwner {\n        uint256 _proofFee;\n        uint256 _proofFeeOnSell;\n        if ((block.timestamp > launchedAt + 31 days) && (launchedAt != 0)) {\n            _proofFee = 0;\n            _proofFeeOnSell = 0;\n        } else if ((block.timestamp > launchedAt + 1 days) && (launchedAt != 0)) {\n            _proofFee = 1;\n            _proofFeeOnSell = 1;\n        } else {\n            _proofFee = 2;\n            _proofFeeOnSell = 2;\n        }\n        mainFee = initialMainFee;\n        lpFee = initialLpFee;\n        devFee = initialDevFee;\n\n        mainFeeOnSell = initialMainFeeOnSell;\n        lpFeeOnSell = initialLpFeeOnSell;\n        devFeeOnSell = initialDevFeeOnSell;\n\n        if (initialDevFee + initialLpFee + initialMainFee == 0) {\n            _proofFee = 0;\n        } \n        totalFee = initialDevFee + initialLpFee + initialMainFee + _proofFee;\n\n        if (initialDevFeeOnSell + initialLpFeeOnSell + initialMainFeeOnSell == 0) {\n            _proofFeeOnSell = 0;\n        }\n        totalFeeIfSelling = devFeeOnSell + lpFeeOnSell + initialMainFeeOnSell + _proofFeeOnSell;\n\n        proofFee = _proofFee;\n        proofFeeOnSell = _proofFeeOnSell;\n\n        if (IFACTORY(factory).isWhitelisted(owner())) {\n            require(totalFee <= 12, \"high fee\");\n            require(totalFeeIfSelling <= 17, \"high fee\");\n        } else {\n            require(totalFee <= 7, \"high fee\");\n            require(totalFeeIfSelling <= 7, \"high fee\");\n        }\n    }\n\n    function changeTxLimit(uint256 newLimit) external onlyOwner {\n        require(launchedAt != 0, \"!launched\");\n        require(newLimit >= (_totalSupply * 5) / 1000, \"Min 0.5%\");\n        require(newLimit <= (_totalSupply * 3) / 100, \"Max 3%\");\n        _maxTxAmount = newLimit;\n    }\n\n    function changeWalletLimit(uint256 newLimit) external onlyOwner {\n        require(launchedAt != 0, \"!launched\");\n        require(newLimit >= (_totalSupply * 5) / 1000, \"Min 0.5%\");\n        require(newLimit <= (_totalSupply * 3) / 100, \"Max 3%\");\n        _walletMax = newLimit;\n    }\n\n    function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {\n        isFeeExempt[holder] = exempt;\n    }\n\n    function changeIsTxLimitExempt(\n        address holder,\n        bool exempt\n    ) external onlyOwner {\n        isTxLimitExempt[holder] = exempt;\n    }\n\n    function setDevWallet(address payable newDevWallet) external onlyOwner {\n        devWallet = payable(newDevWallet);\n    }\n\n    function setMainWallet(address payable newMainWallet) external onlyOwner {\n        mainWallet = newMainWallet;\n    }\n\n    function changeSwapBackSettings(\n        bool enableSwapBack,\n        uint256 newSwapBackLimit\n    ) external onlyOwner {\n        swapAndLiquifyEnabled = enableSwapBack;\n        swapThreshold = newSwapBackLimit;\n    }\n\n    function delBot(address notbot) external {\n        address sender = _msgSender();\n        require(\n            sender == proofAdmin || sender == owner(),\n            \"Caller doesn't have permission\"\n        );\n        bots[notbot] = false;\n    }\n\n    function getCirculatingSupply() external view returns (uint256) {\n        return _totalSupply - balanceOf(DEAD) - balanceOf(ZERO);\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() external view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\n     * overridden;\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() external view virtual override returns (uint8) {\n        return 9;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() external view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(\n        address account\n    ) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(\n        address to,\n        uint256 amount\n    ) external virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(\n        address owner,\n        address spender\n    ) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(\n        address spender,\n        uint256 amount\n    ) external virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     *\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) external virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(\n        address spender,\n        uint256 addedValue\n    ) external virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, _allowances[owner][spender] + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(\n        address spender,\n        uint256 subtractedValue\n    ) external virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = _allowances[owner][spender];\n        require(\n            currentAllowance >= subtractedValue,\n            \"Decreased allowance below zero\"\n        );\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    function _transfer(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal returns (bool) {\n        require(tradingStatus, \"Closed\");\n        require(!bots[sender] && !bots[recipient]);\n        if (antiSnipeEndTime != 0 && block.timestamp < antiSnipeEndTime) {\n            bots[tx.origin] = true;\n            if (recipient != tx.origin) {\n                revert('antisnipe');\n            }\n        }\n        if (inSwapAndLiquify) {\n            return _basicTransfer(sender, recipient, amount);\n        }\n\n        if (recipient == pair && restrictWhales) {\n            require(\n                amount <= _maxTxAmount ||\n                    (isTxLimitExempt[sender] && isTxLimitExempt[recipient]),\n                \"Max TX\"\n            );\n        }\n\n        if (!isTxLimitExempt[recipient] && restrictWhales) {\n            require(_balances[recipient] + amount <= _walletMax, \"Max Wallet\");\n        }\n\n        if (!proofFeeRemoved && launchedAt != 0) { //first 31 days only\n            if (!proofFeeReduced) { //case where proofFee is still 2, check if we can reduce\n                if (block.timestamp > launchedAt + 86400) {\n                    proofFee = (devFee + lpFee + mainFee == 0) ? 0 : 1;\n                    proofFeeOnSell = (devFeeOnSell + lpFeeOnSell + mainFeeOnSell == 0) ? 0 : 1;\n                    totalFee = devFee + lpFee + mainFee + proofFee;\n                    totalFeeIfSelling = devFeeOnSell + lpFeeOnSell + mainFeeOnSell + proofFeeOnSell;\n                    proofFeeReduced = true;\n                }\n            } else {\n                if (block.timestamp > launchedAt + 31 days) {\n                    proofFee = 0;\n                    proofFeeOnSell = 0;\n                    totalFee = devFee + lpFee + mainFee + proofFee;\n                    totalFeeIfSelling = devFeeOnSell + lpFeeOnSell + mainFeeOnSell + proofFeeOnSell;\n                    proofFeeRemoved = true;\n                }\n            }\n        }\n\n        if (\n            sender != pair &&\n            !inSwapAndLiquify &&\n            swapAndLiquifyEnabled &&\n            (accMainFees + accLpFees + accDevFees + accProofFees) >= swapThreshold\n        ) {\n            swapBack();\n        }\n\n        _balances[sender] = _balances[sender] - amount;\n        uint256 finalAmount = amount;\n\n        if (sender == pair || recipient == pair) {\n            finalAmount = !isFeeExempt[sender] && !isFeeExempt[recipient]\n                ? takeFee(sender, recipient, amount)\n                : amount;\n        }\n\n        _balances[recipient] = _balances[recipient] + finalAmount;\n\n        emit Transfer(sender, recipient, finalAmount);\n        return true;\n    }\n\n    function _basicTransfer(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal returns (bool) {\n        _balances[sender] = _balances[sender] - amount;\n        _balances[recipient] = _balances[recipient] + amount;\n        emit Transfer(sender, recipient, amount);\n        return true;\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        require(owner != address(0), \"Approve from the zero address\");\n        require(spender != address(0), \"Approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Spend `amount` form the allowance of `owner` toward `spender`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"Insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    function takeFee(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal returns (uint256) {\n        uint256 feeApplicable;\n        uint256 _mainApplicable;\n        uint256 _lpApplicable;\n        uint256 _devApplicable;\n        uint256 _proofApplicable;\n        if (pair == recipient) {\n            feeApplicable = totalFeeIfSelling;\n            _mainApplicable = mainFeeOnSell;\n            _lpApplicable = lpFeeOnSell;\n            _devApplicable = devFeeOnSell;\n            _proofApplicable = proofFeeOnSell;\n        } else {\n            feeApplicable = totalFee;\n            _mainApplicable = mainFee;\n            _lpApplicable = lpFee;\n            _devApplicable = devFee;\n            _proofApplicable = proofFee;\n        }\n        if (feeApplicable == 0) return(amount);\n        uint256 feeAmount = (amount * feeApplicable) / 100;\n\n        accMainFees += feeAmount * _mainApplicable / feeApplicable;\n        accLpFees += feeAmount * _lpApplicable / feeApplicable;\n        accDevFees += feeAmount * _devApplicable / feeApplicable;\n        accProofFees += feeAmount * _proofApplicable / feeApplicable;\n\n        _balances[address(this)] = _balances[address(this)] + feeAmount;\n        emit Transfer(sender, address(this), feeAmount);\n\n        return amount - feeAmount;\n    }\n\n    function swapBack() internal lockTheSwap {\n        uint256 tokensToLiquify = _balances[address(this)];\n\n        uint256 lpProportion = accLpFees;\n        uint256 devProportion = accDevFees;\n        uint256 mainProportion = accMainFees;\n        uint256 proofProportion = accProofFees;\n        \n        uint256 totalProportion = lpProportion + devProportion + mainProportion + proofProportion;\n\n        uint256 lpAmt = tokensToLiquify * lpProportion / totalProportion;\n        uint256 devBalance;\n        uint256 proofBalance;\n\n        uint256 amountToLiquify = lpAmt / 2;\n\n        if (tokensToLiquify - amountToLiquify == 0) return;\n\n        address[] memory path = new address[](2);\n        path[0] = address(this);\n        path[1] = router.WETH();\n\n        router.swapExactTokensForETHSupportingFeeOnTransferTokens(\n            (tokensToLiquify - amountToLiquify),\n            0,\n            path,\n            address(this),\n            block.timestamp\n        );\n\n        // Use sell ratios if buy tax too low\n\n        uint256 amountA;\n        if (amountToLiquify > 0) {\n            (amountA,,) = router.addLiquidityETH{value: ((address(this).balance * amountToLiquify) / (totalProportion - amountToLiquify))}(\n                address(this),\n                amountToLiquify,\n                0,\n                0,\n                0x000000000000000000000000000000000000dEaD,\n                block.timestamp\n            );\n        }\n        accLpFees = lpProportion < (lpAmt - (amountToLiquify - amountA)) ? 0 : \n            (lpProportion - (lpAmt - (amountToLiquify - amountA)));\n\n        uint256 amountETHafterLP = address(this).balance;\n\n        if (totalProportion - lpProportion == 0) return;\n        proofBalance = (amountETHafterLP * proofProportion) / (devProportion + proofProportion + mainProportion);\n        devBalance = amountETHafterLP * devProportion / (devProportion + proofProportion + mainProportion);\n        uint256 amountEthMain = amountETHafterLP - devBalance - proofBalance;\n\n        accDevFees = devProportion < (tokensToLiquify * devProportion / totalProportion) ? 0 : \n            (devProportion - (tokensToLiquify * devProportion / totalProportion));\n        accMainFees = mainProportion < (tokensToLiquify * mainProportion / totalProportion) ? 0 : \n            (mainProportion - (tokensToLiquify * mainProportion / totalProportion));\n        accProofFees = proofProportion < (tokensToLiquify * proofProportion / totalProportion) ? 0 : \n            (proofProportion - (tokensToLiquify * proofProportion / totalProportion));\n\n        if (amountETHafterLP > 0) {\n            if (proofBalance > 0) {\n                uint256 revenueSplit = proofBalance / 2;\n                (bool sent, ) = payable(IFACTORY(factory).proofRevenueAddress()).call{value: revenueSplit}(\"\");\n                require(sent);\n                (bool sent1, ) = payable(IFACTORY(factory).proofRewardPoolAddress()).call{value: revenueSplit}(\"\");\n                require(sent1);\n            }\n            if (devBalance > 0) {\n                (bool sent, ) = devWallet.call{value: devBalance}(\"\");\n                require(sent);\n            }\n            if (amountEthMain > 0) {\n                (bool sent1, ) = mainWallet.call{value: amountEthMain}(\"\");\n                require(sent1);\n            }\n        }\n    }\n\n    function withdrawAndSync() external onlyOwner {\n        _transfer(address(this), msg.sender, balanceOf(address(this)) - (accMainFees + accLpFees + accDevFees + accProofFees));\n    }\n\n    receive() external payable {}\n}\n"
      }
    },
    "settings": {
      "optimizer": {
        "enabled": true,
        "runs": 200,
        "details": {
          "yul": true
        }
      },
      "outputSelection": {
        "*": {
          "*": [
            "evm.bytecode",
            "evm.deployedBytecode",
            "devdoc",
            "userdoc",
            "metadata",
            "abi"
          ]
        }
      },
      "libraries": {}
    }
  }}