{"Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn\u0027t rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length \u003e 0;\n }\n\n /**\n * @dev Replacement for Solidity\u0027s `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance \u003e= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance \u003e= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn\u0027t, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length \u003e 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n"},"Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\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}\n"},"contract.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\nimport \"./Ownable.sol\";\nimport \"./IERC20.sol\";\nimport \"./Address.sol\";\nimport \"./uniswap_contracts.sol\";\nimport \"./IPinkAntiBot.sol\";\n\ncontract RCADE is Context, IERC20, Ownable {\n IPinkAntiBot public pinkAntiBot;\n bool antiBotEnabled = false;\n using Address for address;\n // Data to customize\n string private constant _name = \"Rcade Token\";\n string private constant _symbol = \"Rcade\";\n uint256 private totalToken = 100_000_000;\n\n // dev fee converted in BNB, can be sent to 2 wallets (example marketing \u0026 dev)\n uint256 public _devBNBFeeBuy = 8;\n uint256 public _devBNBFeeSell = _devBNBFeeBuy;\n address payable devWalletOne =\n payable(0x8c3b5aD389396ecE447185AFc1615140aeB10c3c);\n address payable devWalletTwo =\n payable(0xd5E44FFD5952197F9060A7754a2225E5759f685D);\n\n // dev fee to recover token, optional, set to 0 (example charity wallet)\n uint256 public _optionalDevFeeBuy = 0;\n uint256 public _optionalDevFeeSell = _optionalDevFeeBuy;\n address payable devWalletOptional =\n payable(0x000000000000000000000000000000000000dEaD);\n\n // redistribution tax fee\n uint256 public _taxFeeBuy = 2;\n uint256 public _taxFeeSell = _taxFeeBuy;\n\n // automatic liquidity fee, optional, set to 0\n uint256 public _liquidityFeeBuy = 2;\n uint256 public _liquidityFeeSell = _liquidityFeeBuy;\n\n // END_ Data to customize\n uint256 private _tTotal = totalToken * _DECIMALFACTOR;\n\n // swap when you accumulate 0.01% of tokens\n // It means it swaps when trading volume reaches 0.2% of total token\n uint256 private numTokensSellToAddToLiquidity = _tTotal / 10000;\n\n mapping(address =\u003e uint256) private _rOwned;\n mapping(address =\u003e uint256) private _tOwned;\n mapping(address =\u003e mapping(address =\u003e uint256)) private _allowances;\n mapping(address =\u003e bool) private _isExcludedFromFee;\n mapping(address =\u003e bool) private _isExcludedFromTransfer;\n mapping(address =\u003e bool) private _isExcluded;\n address[] private _excluded;\n\n uint8 private constant _DECIMALS = 8;\n uint256 private constant _DECIMALFACTOR = 10**uint256(_DECIMALS);\n uint256 private constant MAX = ~uint256(0);\n uint256 private _rTotal = (MAX - (MAX % _tTotal));\n\n uint256 private _tFeeTotal;\n\n uint256 private _previousTaxFeeBuy = _taxFeeBuy;\n uint256 private _previousTaxFeeSell = _taxFeeSell;\n\n uint256 private _previousDevFeeBuy = _optionalDevFeeBuy;\n uint256 private _previousDevFeeSell = _optionalDevFeeSell;\n\n uint256 private _previousLiquidityFeeBuy = _liquidityFeeBuy;\n uint256 private _previousLiquidityFeeSell = _liquidityFeeSell;\n\n uint256 private _previousdevBNBFeeBuy = _devBNBFeeBuy;\n uint256 private _previousdevBNBFeeSell = _devBNBFeeSell;\n\n IUniswapV2Router02 public uniswapV2Router;\n address public uniswapV2Pair;\n\n bool inSwapAndLiquify;\n\n event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);\n event SwapAndLiquify(\n uint256 tokensSwapped,\n uint256 ethReceived,\n uint256 tokensIntoLiquidity\n );\n event AddLiquidityETH(uint256 amountA, uint256 amountB);\n\n modifier lockTheSwap() {\n inSwapAndLiquify = true;\n _;\n inSwapAndLiquify = false;\n }\n\n constructor() {\n _rOwned[_msgSender()] = _rTotal;\n // BSC\u0027s mainnet antibot.\n // See guide here https://github.com/pinkmoonfinance/pink-antibot-guide\n address pinkAntiBot_ = 0x8EFDb3b642eb2a20607ffe0A56CFefF6a95Df002;\n pinkAntiBot = IPinkAntiBot(pinkAntiBot_);\n pinkAntiBot.setTokenOwner(msg.sender);\n IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(\n 0x10ED43C718714eb63d5aA57B78B54704E256024E\n ); // v2 testnet 0xD99D1c33F9fC3444f8101754aBC46c52416550D1\n // Create a pancakeswap pair for this new token\n uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())\n .createPair(address(this), _uniswapV2Router.WETH());\n\n // set the rest of the contract variables\n uniswapV2Router = _uniswapV2Router;\n\n //exclude owner and this contract from fee\n _isExcludedFromFee[owner()] = true;\n _isExcludedFromFee[address(this)] = true;\n emit Transfer(address(0), _msgSender(), _tTotal);\n }\n\n function name() public pure returns (string memory) {\n return _name;\n }\n\n function symbol() public pure returns (string memory) {\n return _symbol;\n }\n\n function decimals() public pure returns (uint8) {\n return _DECIMALS;\n }\n\n function totalSupply() public view override returns (uint256) {\n return _tTotal;\n }\n\n function balanceOf(address account) public view override returns (uint256) {\n if (_isExcluded[account]) return _tOwned[account];\n return tokenFromReflection(_rOwned[account]);\n }\n\n function transfer(address recipient, uint256 amount)\n public\n override\n returns (bool)\n {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n function allowance(address owner, address spender)\n public\n view\n override\n returns (uint256)\n {\n return _allowances[owner][spender];\n }\n\n function approve(address spender, uint256 amount)\n public\n override\n returns (bool)\n {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) public override returns (bool) {\n _transfer(sender, recipient, amount);\n require(\n _allowances[sender][_msgSender()] \u003e= amount,\n \"BEP20: transfer amount exceeds allowance\"\n );\n _approve(\n sender,\n _msgSender(),\n _allowances[sender][_msgSender()] - amount\n );\n return true;\n }\n\n function increaseAllowance(address spender, uint256 addedValue)\n public\n virtual\n returns (bool)\n {\n _approve(\n _msgSender(),\n spender,\n _allowances[_msgSender()][spender] addedValue\n );\n return true;\n }\n\n function decreaseAllowance(address spender, uint256 subtractedValue)\n public\n virtual\n returns (bool)\n {\n require(\n _allowances[_msgSender()][spender] \u003e= subtractedValue,\n \"BEP20: decreased allowance below zero\"\n );\n _approve(\n _msgSender(),\n spender,\n _allowances[_msgSender()][spender] - subtractedValue\n );\n return true;\n }\n\n function isExcludedFromReward(address account) public view returns (bool) {\n return _isExcluded[account];\n }\n\n function totalFees() public view returns (uint256) {\n return _tFeeTotal;\n }\n\n function reflectionFromToken(uint256 tAmount, bool deductTransferFee)\n public\n view\n returns (uint256)\n {\n require(tAmount \u003c= _tTotal, \"Amount must be less than supply\");\n Values memory values = _getValues(tAmount, true);\n if (!deductTransferFee) {\n return values.rAmount;\n } else {\n return values.rTransferAmount;\n }\n }\n\n function tokenFromReflection(uint256 rAmount)\n public\n view\n returns (uint256)\n {\n require(\n rAmount \u003c= _rTotal,\n \"Amount must be less than total reflections\"\n );\n uint256 currentRate = _getRate();\n return rAmount / currentRate;\n }\n\n function excludeFromReward(address account) public onlyOwner {\n require(!_isExcluded[account], \"Account is already excluded\");\n if (_rOwned[account] \u003e 0) {\n _tOwned[account] = tokenFromReflection(_rOwned[account]);\n }\n _isExcluded[account] = true;\n _excluded.push(account);\n }\n\n function includeInReward(address account) external onlyOwner {\n /* Changed error message to \"Account not excluded\"\n See \"SSL-01 | Incorrect error message\" from the Certik\n audit of safemoon.\n */\n require(_isExcluded[account], \"Account not excluded\");\n for (uint256 i = 0; i \u003c _excluded.length; i ) {\n if (_excluded[i] == account) {\n _excluded[i] = _excluded[_excluded.length - 1];\n _tOwned[account] = 0;\n _isExcluded[account] = false;\n _excluded.pop();\n break;\n }\n }\n }\n\n function excludeFromTransfer(address account) public onlyOwner {\n _isExcludedFromTransfer[account] = true;\n }\n\n function includeInTransfer(address account) public onlyOwner {\n _isExcludedFromTransfer[account] = false;\n }\n\n function excludeFromFee(address account) public onlyOwner {\n _isExcludedFromFee[account] = true;\n }\n\n function includeInFee(address account) public onlyOwner {\n _isExcludedFromFee[account] = false;\n }\n\n function setTaxFeeBuyPercent(uint256 taxFee) external onlyOwner {\n _taxFeeBuy = taxFee;\n }\n\n function setTaxFeeSellPercent(uint256 taxFee) external onlyOwner {\n _taxFeeSell = taxFee;\n }\n\n function setOptionalDevFeeBuyPercent(uint256 charityFee)\n external\n onlyOwner\n {\n _optionalDevFeeBuy = charityFee;\n }\n\n function setOptionalDevFeeSellPercent(uint256 charityFee)\n external\n onlyOwner\n {\n _optionalDevFeeSell = charityFee;\n }\n\n function setdevBNBFeeBuyPercent(uint256 devBNBFee) external onlyOwner {\n _devBNBFeeBuy = devBNBFee;\n }\n\n function setdevBNBFeeSellPercent(uint256 devBNBFee) external onlyOwner {\n _devBNBFeeSell = devBNBFee;\n }\n\n function setLiquidityFeeBuyPercent(uint256 liquidityFee)\n external\n onlyOwner\n {\n _liquidityFeeBuy = liquidityFee;\n }\n\n function setLiquidityFeeSellPercent(uint256 liquidityFee)\n external\n onlyOwner\n {\n _liquidityFeeSell = liquidityFee;\n }\n\n //to recieve BNB from pancakeswapV2Router when swaping\n receive() external payable {}\n\n function _reflectFee(uint256 rFee, uint256 tFee) private {\n _rTotal = _rTotal - rFee;\n _tFeeTotal = _tFeeTotal - tFee;\n }\n\n struct Values {\n uint256 rAmount;\n uint256 rTransferAmount;\n uint256 rFee;\n uint256 tTransferAmount;\n uint256 tFee;\n uint256 tLiquidity;\n uint256 tDev;\n uint256 tDevBNB;\n }\n struct TValues {\n uint256 tTransferAmount;\n uint256 tFee;\n uint256 tDevBNB;\n uint256 tLiquidity;\n uint256 tDev;\n }\n\n function _getValues(uint256 tAmount, bool isBuy)\n private\n view\n returns (Values memory)\n {\n TValues memory tValues = _getTValues(tAmount, isBuy);\n Values memory values;\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(\n tAmount,\n tValues.tFee,\n tValues.tLiquidity,\n tValues.tDev,\n tValues.tDevBNB,\n _getRate()\n );\n values.rAmount = rAmount;\n values.rTransferAmount = rTransferAmount;\n values.rFee = rFee;\n values.tTransferAmount = tValues.tTransferAmount;\n values.tFee = tValues.tFee;\n values.tLiquidity = tValues.tLiquidity;\n values.tDev = tValues.tDev;\n values.tDevBNB = tValues.tDevBNB;\n return values;\n }\n\n function _getTValues(uint256 tAmount, bool isBuy)\n private\n view\n returns (TValues memory)\n {\n TValues memory tValues;\n tValues.tFee = calculateTaxFee(tAmount, isBuy);\n tValues.tDev = calculateDevFee(tAmount, isBuy);\n tValues.tDevBNB = calculatedevBNBFee(tAmount, isBuy);\n tValues.tLiquidity = calculateLiquidityFee(tAmount, isBuy);\n tValues.tTransferAmount =\n tAmount -\n tValues.tFee -\n tValues.tLiquidity -\n tValues.tDev;\n return tValues;\n }\n\n function _getRValues(\n uint256 tAmount,\n uint256 tFee,\n uint256 tLiquidity,\n uint256 tDev,\n uint256 tDevBNB,\n uint256 currentRate\n )\n private\n pure\n returns (\n uint256,\n uint256,\n uint256\n )\n {\n uint256 rAmount = tAmount * currentRate;\n uint256 rDevBNB = tDevBNB * currentRate;\n uint256 rFee = tFee * currentRate;\n uint256 rLiquidity = tLiquidity * currentRate;\n uint256 rDev = tDev * currentRate;\n uint256 rTransferAmount = rAmount - rFee - rLiquidity - rDev - rDevBNB;\n return (rAmount, rTransferAmount, rFee);\n }\n\n function _getRate() private view returns (uint256) {\n (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();\n return rSupply / tSupply;\n }\n\n function _getCurrentSupply() private view returns (uint256, uint256) {\n uint256 rSupply = _rTotal;\n uint256 tSupply = _tTotal;\n for (uint256 i = 0; i \u003c _excluded.length; i ) {\n if (\n _rOwned[_excluded[i]] \u003e rSupply ||\n _tOwned[_excluded[i]] \u003e tSupply\n ) return (_rTotal, _tTotal);\n rSupply = rSupply - _rOwned[_excluded[i]];\n tSupply = tSupply - _tOwned[_excluded[i]];\n }\n if (rSupply \u003c _rTotal / _tTotal) return (_rTotal, _tTotal);\n return (rSupply, tSupply);\n }\n\n function _takeDevForBNB(uint256 tDevBNB) private {\n uint256 currentRate = _getRate();\n uint256 rDevBNB = tDevBNB * currentRate;\n _rOwned[address(this)] = _rOwned[address(this)] rDevBNB;\n if (_isExcluded[address(this)])\n _tOwned[address(this)] = _tOwned[address(this)] tDevBNB;\n }\n\n function _takeLiquidity(uint256 tLiquidity) private {\n uint256 currentRate = _getRate();\n uint256 rLiquidity = tLiquidity * currentRate;\n _rOwned[address(this)] = _rOwned[address(this)] rLiquidity;\n if (_isExcluded[address(this)])\n _tOwned[address(this)] = _tOwned[address(this)] tLiquidity;\n }\n\n function _takeDev(uint256 tDev) private {\n uint256 currentRate = _getRate();\n uint256 rDev = tDev * currentRate;\n _rOwned[devWalletOptional] = _rOwned[devWalletOptional] rDev;\n if (_isExcluded[devWalletOptional])\n _tOwned[devWalletOptional] = _tOwned[devWalletOptional] tDev;\n }\n\n function calculateTaxFee(uint256 _amount, bool isBuy)\n private\n view\n returns (uint256)\n {\n uint256 _taxFee = _taxFeeBuy;\n if (!isBuy) {\n _taxFee = _taxFeeSell;\n }\n return (_amount * _taxFee) / 10**2;\n }\n\n function calculateDevFee(uint256 _amount, bool isBuy)\n private\n view\n returns (uint256)\n {\n uint256 _optionalDevFee = _optionalDevFeeBuy;\n if (!isBuy) {\n _optionalDevFee = _optionalDevFeeSell;\n }\n return (_amount * _optionalDevFeeBuy) / 10**2;\n }\n\n function calculatedevBNBFee(uint256 _amount, bool isBuy)\n private\n view\n returns (uint256)\n {\n uint256 _devBNBFee = _devBNBFeeBuy;\n if (!isBuy) {\n _devBNBFee = _devBNBFeeSell;\n }\n return (_amount * _devBNBFeeBuy) / 10**2;\n }\n\n function calculateLiquidityFee(uint256 _amount, bool isBuy)\n private\n view\n returns (uint256)\n {\n uint256 _liquidityFee = _liquidityFeeBuy;\n if (!isBuy) {\n _liquidityFee = _liquidityFeeSell;\n }\n return (_amount * _liquidityFeeBuy) / 10**2;\n }\n\n function removeFees() external onlyOwner {\n removeAllFee();\n }\n\n function restoreFees() external onlyOwner {\n restoreAllFee();\n }\n\n function removeAllFee() private {\n if (\n _taxFeeBuy == 0 \u0026\u0026\n _liquidityFeeBuy == 0 \u0026\u0026\n _optionalDevFeeBuy == 0 \u0026\u0026\n _devBNBFeeBuy == 0 \u0026\u0026\n _taxFeeSell == 0 \u0026\u0026\n _liquidityFeeSell == 0 \u0026\u0026\n _optionalDevFeeSell == 0 \u0026\u0026\n _devBNBFeeSell == 0\n ) return;\n\n _previousTaxFeeBuy = _taxFeeBuy;\n _previousLiquidityFeeBuy = _liquidityFeeBuy;\n _previousDevFeeBuy = _optionalDevFeeBuy;\n _previousdevBNBFeeBuy = _devBNBFeeBuy;\n\n _previousTaxFeeSell = _taxFeeSell;\n _previousLiquidityFeeSell = _liquidityFeeSell;\n _previousDevFeeSell = _optionalDevFeeSell;\n _previousdevBNBFeeSell = _devBNBFeeSell;\n\n _taxFeeBuy = 0;\n _liquidityFeeBuy = 0;\n _optionalDevFeeBuy = 0;\n _devBNBFeeBuy = 0;\n _taxFeeSell = 0;\n _liquidityFeeSell = 0;\n _optionalDevFeeSell = 0;\n _devBNBFeeSell = 0;\n }\n\n function restoreAllFee() private {\n _taxFeeBuy = _previousTaxFeeBuy;\n _liquidityFeeBuy = _previousLiquidityFeeBuy;\n _optionalDevFeeBuy = _previousDevFeeBuy;\n _devBNBFeeBuy = _previousdevBNBFeeBuy;\n _taxFeeSell = _previousTaxFeeSell;\n _liquidityFeeSell = _previousLiquidityFeeSell;\n _optionalDevFeeSell = _previousDevFeeSell;\n _devBNBFeeSell = _previousdevBNBFeeSell;\n }\n\n function isExcludedFromFee(address account) public view returns (bool) {\n return _isExcludedFromFee[account];\n }\n\n function _approve(\n address owner,\n address spender,\n uint256 amount\n ) private {\n require(owner != address(0), \"BEP20: approve from the zero address\");\n require(spender != address(0), \"BEP20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n function _transfer(\n address from,\n address to,\n uint256 amount\n ) private {\n require(from != address(0), \"BEP20: transfer from the zero address\");\n require(to != address(0), \"BEP20: transfer to the zero address\");\n require(amount \u003e 0, \"Transfer amount must be greater than zero\");\n require(\n !_isExcludedFromTransfer[from],\n \"This adress can\u0027t send Tokens\"\n ); // excluded adress can\u0027t sell\n require(\n !_isExcludedFromTransfer[to],\n \"This adress can\u0027t receive Tokens\"\n ); // excluded adress can\u0027t buy\n if (antiBotEnabled) {\n pinkAntiBot.onPreTransferCheck(from, to, amount);\n }\n\n // is the token balance of this contract address over the min number of\n // tokens that we need to initiate a swap liquidity lock?\n // also, don\u0027t get caught in a circular liquidity event.\n // also, don\u0027t swap \u0026 liquify if sender is pancakeswap pair.\n uint256 contractTokenBalance = balanceOf(address(this));\n\n bool overMinTokenBalance = contractTokenBalance \u003e=\n numTokensSellToAddToLiquidity;\n if (overMinTokenBalance \u0026\u0026 !inSwapAndLiquify \u0026\u0026 from != uniswapV2Pair) {\n contractTokenBalance = numTokensSellToAddToLiquidity;\n //add liquidity\n swapAndLiquifyAndSendBNBToDevs(contractTokenBalance);\n }\n\n //indicates if fee should be deducted from transfer\n bool takeFee = true;\n // indicates if it\u0027s a sell or a buy\n bool isBuy = (from == address(uniswapV2Router));\n bool isSell = (to == address(uniswapV2Router));\n\n //if any account belongs to _isExcludedFromFee account then remove the fee\n if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {\n takeFee = false;\n }\n\n //if it\u0027s neither a buy nor a sell, no fee\n if (!isBuy \u0026\u0026 !isSell) {\n takeFee = false;\n }\n\n //transfer amount, it will take tax, dev, liquidity fee\n _tokenTransfer(from, to, amount, takeFee, isBuy);\n }\n\n function swapAndLiquifyAndSendBNBToDevs(uint256 contractTokenBalance)\n private\n lockTheSwap\n {\n // split the contract balance into 3 parts, based on the fees\n // numToken * _devBNBFeeBuy / (_devBNBFeeBuy _liquidityFeeBuy ) for dev\n // numToken * _liquidityFeeBuy / (_devBNBFeeBuy _liquidityFeeBuy ) for liquidity\n // use a magnitude to avoid integer division problem\n uint256 magnitude = 1000;\n uint256 partForLiquidity = (contractTokenBalance *\n magnitude *\n _devBNBFeeBuy) /\n (_devBNBFeeBuy _liquidityFeeBuy) /\n magnitude;\n uint256 partForDev = contractTokenBalance - partForLiquidity;\n\n // Swap tokens, and send them to devs\n uint256 originalBalance = address(this).balance;\n swapTokensForETH(partForDev);\n uint256 swappedBNB = address(this).balance - originalBalance;\n uint256 halfBnB = swappedBNB / 2;\n (bool success1, ) = devWalletOne.call{value: halfBnB}(\"\");\n (bool success2, ) = devWalletTwo.call{value: swappedBNB - halfBnB}(\"\");\n\n require(success1 \u0026\u0026 success2, \"Swap and liquify failed\");\n // capture the contract\u0027s current BNB balance.\n // this is so that we can capture exactly the amount of BNB that the\n // swap creates, and not make the liquidity event include any BNB that\n // has been manually sent to the contract\n uint256 initialBalance = address(this).balance;\n uint256 partForLiquidityToSwap = partForLiquidity / 2;\n uint256 partForLiquidityToAdd = partForLiquidity -\n partForLiquidityToSwap;\n // swap tokens for BNB\n swapTokensForETH(partForLiquidityToSwap);\n // how much BNB did we just swap into?\n uint256 BnbSwapped = address(this).balance - initialBalance;\n // add liquidity to pancakeswap\n addLiquidity(partForLiquidityToAdd, BnbSwapped);\n emit SwapAndLiquify(\n partForLiquidityToSwap,\n BnbSwapped,\n partForLiquidityToAdd\n );\n }\n\n function sendBnbLeftoverToDev() external onlyOwner {\n // see \"SSL- 03 | Contract gains non-withdrawable BNB via the swapAndLiquifyfunction\"\n // buy back with BNB leftover from SwapAndLiquify to increase price\n uint256 swappedBNB = address(this).balance;\n uint256 halfSwappedBNB = swappedBNB / 2;\n (bool success1, ) = devWalletTwo.call{value: halfSwappedBNB}(\"\");\n (bool success2, ) = devWalletTwo.call{\n value: swappedBNB - halfSwappedBNB\n }(\"\");\n require(success1 \u0026\u0026 success2, \"Swap and liquify failed\");\n }\n\n function buyWithLeftoverBNB(uint256 amount) external onlyOwner {\n // see \"SSL- 03 | Contract gains non-withdrawable BNB via the swapAndLiquifyfunction\"\n // buy back with BNB leftover from SwapAndLiquify to increase price\n // from Safemoon Certik Audit\n address[] memory path = new address[](2);\n path[0] = uniswapV2Router.WETH();\n path[1] = address(this);\n\n _approve(address(this), address(uniswapV2Router), amount);\n\n uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens(\n amount,\n path,\n address(this),\n block.timestamp\n );\n }\n\n function swapTokensForETH(uint256 tokenAmount) private {\n // generate the pancakeswap pair path of token -\u003e WBNB\n address[] memory path = new address[](2);\n path[0] = address(this);\n path[1] = uniswapV2Router.WETH();\n\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n\n // make the swap\n uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(\n tokenAmount,\n 0, // accept any amount of BNB\n path,\n address(this),\n block.timestamp\n );\n }\n\n function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {\n // approve token transfer to cover all possible scenarios\n /* \"to\" account changed to address(this) to mitigate major centralization\n issue in Safemoon\u0027s contract.\n See \"SSL-04 | Centralized risk in addLiquidity\" from the Certik\n audit of Safemoon.\n */\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n\n // add the liquidity\n uniswapV2Router.addLiquidityETH{value: ethAmount}(\n address(this),\n tokenAmount,\n 0, // slippage is unavoidable\n 0, // slippage is unavoidable\n address(this),\n block.timestamp\n );\n emit AddLiquidityETH(tokenAmount, ethAmount);\n }\n\n //this method is responsible for taking all fee, if takeFee is true\n function _tokenTransfer(\n address sender,\n address recipient,\n uint256 amount,\n bool takeFee,\n bool isBuy\n ) private {\n /* Removed:\n \".....else if (!_isExcluded[sender] \u0026\u0026 !_isExcluded[recipient]) {{ \n _transferStandard(sender, recipient, amount); }.....\"\n \n See \"SSL-02 | Redundant code\" from the Certik audit of Safemoon\n */\n if (!takeFee) removeAllFee();\n\n if (_isExcluded[sender] \u0026\u0026 !_isExcluded[recipient]) {\n _transferFromExcluded(sender, recipient, amount, isBuy);\n } else if (!_isExcluded[sender] \u0026\u0026 _isExcluded[recipient]) {\n _transferToExcluded(sender, recipient, amount, isBuy);\n } else if (_isExcluded[sender] \u0026\u0026 _isExcluded[recipient]) {\n _transferBothExcluded(sender, recipient, amount, isBuy);\n } else {\n _transferStandard(sender, recipient, amount, isBuy);\n }\n\n if (!takeFee) restoreAllFee();\n }\n\n function _transferStandard(\n address sender,\n address recipient,\n uint256 tAmount,\n bool isBuy\n ) private {\n Values memory values = _getValues(tAmount, isBuy);\n _rOwned[sender] = _rOwned[sender] - values.rAmount;\n _rOwned[recipient] = _rOwned[recipient] values.rTransferAmount;\n _takeDevForBNB(values.tDevBNB);\n _takeLiquidity(values.tLiquidity);\n _takeDev(values.tDev);\n _reflectFee(values.rFee, values.tFee);\n emit Transfer(sender, recipient, values.tTransferAmount);\n }\n\n function _transferToExcluded(\n address sender,\n address recipient,\n uint256 tAmount,\n bool isBuy\n ) private {\n Values memory values = _getValues(tAmount, isBuy);\n _rOwned[sender] = _rOwned[sender] - values.rAmount;\n _tOwned[recipient] = _tOwned[recipient] values.tTransferAmount;\n _rOwned[recipient] = _rOwned[recipient] values.rTransferAmount;\n _takeDevForBNB(values.tDevBNB);\n _takeLiquidity(values.tLiquidity);\n _takeDev(values.tDev);\n _reflectFee(values.rFee, values.tFee);\n emit Transfer(sender, recipient, values.tTransferAmount);\n }\n\n function _transferFromExcluded(\n address sender,\n address recipient,\n uint256 tAmount,\n bool isBuy\n ) private {\n Values memory values = _getValues(tAmount, isBuy);\n _tOwned[sender] = _tOwned[sender] - tAmount;\n _rOwned[sender] = _rOwned[sender] - values.rAmount;\n _rOwned[recipient] = _rOwned[recipient] values.rTransferAmount;\n _takeDevForBNB(values.tDevBNB);\n _takeLiquidity(values.tLiquidity);\n _takeDev(values.tDev);\n _reflectFee(values.rFee, values.tFee);\n emit Transfer(sender, recipient, values.tTransferAmount);\n }\n\n function _transferBothExcluded(\n address sender,\n address recipient,\n uint256 tAmount,\n bool isBuy\n ) private {\n Values memory values = _getValues(tAmount, isBuy);\n _tOwned[sender] = _tOwned[sender] - tAmount;\n _rOwned[sender] = _rOwned[sender] - values.rAmount;\n _tOwned[recipient] = _tOwned[recipient] values.tTransferAmount;\n _rOwned[recipient] = _rOwned[recipient] values.rTransferAmount;\n _takeDevForBNB(values.tDevBNB);\n _takeLiquidity(values.tLiquidity);\n _takeDev(values.tDev);\n _reflectFee(values.rFee, values.tFee);\n emit Transfer(sender, recipient, values.tTransferAmount);\n }\n\n //New Pancakeswap router version?\n //No problem, just change it!\n function setRouterAddress(address newRouter) external onlyOwner {\n IUniswapV2Router02 _uniswapV2newRouter = IUniswapV2Router02(newRouter);\n // Create a pancakeswap pair for this new token\n uniswapV2Pair = IUniswapV2Factory(_uniswapV2newRouter.factory())\n .createPair(address(this), _uniswapV2newRouter.WETH());\n\n // set the rest of the contract variables\n uniswapV2Router = _uniswapV2newRouter;\n }\n\n function setDevOneWallet(address payable newWallet) external onlyOwner {\n devWalletOne = newWallet;\n }\n\n function getDevOneWalletAddress() external view returns (address) {\n return devWalletOne;\n }\n\n function setDevTwoWallet(address payable newWallet) external onlyOwner {\n devWalletTwo = newWallet;\n }\n\n function getDevTwoWalletAddress() external view returns (address) {\n return devWalletTwo;\n }\n\n function getOptionnalDevWalletAddress() external view returns (address) {\n return devWalletOptional;\n }\n\n function setOptionalDevWallet(address payable newWallet)\n external\n onlyOwner\n {\n devWalletOptional = newWallet;\n }\n\n function setNumTokensToTriggerDevAndLiquidity(uint256 newvalue)\n external\n onlyOwner\n {\n numTokensSellToAddToLiquidity = newvalue;\n }\n\n function disableAntibot() external onlyOwner {\n antiBotEnabled = false;\n }\n\n function enableAntibot() external onlyOwner {\n antiBotEnabled = true;\n }\n}\n"},"IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (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 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\u0027s account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, 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\u0027s 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\u0027s 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 `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller\u0027s\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external returns (bool);\n\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"},"IPinkAntiBot.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity \u003e=0.5.0;\n\ninterface IPinkAntiBot {\n function setTokenOwner(address owner) external;\n\n function onPreTransferCheck(\n address from,\n address to,\n uint256 amount\n ) external;\n}"},"Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\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 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 called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\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(newOwner != address(0), \"Ownable: new owner is the zero address\");\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}\n"},"uniswap_contracts.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.12;\n\ninterface IUniswapV2Factory {\n event PairCreated(\n address indexed token0,\n address indexed token1,\n address pair,\n uint256\n );\n\n function feeTo() external view returns (address);\n\n function feeToSetter() external view returns (address);\n\n function getPair(address tokenA, address tokenB)\n external\n view\n returns (address pair);\n\n function allPairs(uint256) external view returns (address pair);\n\n function allPairsLength() external view returns (uint256);\n\n function createPair(address tokenA, address tokenB)\n external\n returns (address pair);\n\n function setFeeTo(address) external;\n\n function setFeeToSetter(address) external;\n}\n\ninterface IUniswapV2Router01 {\n function factory() external pure returns (address);\n\n function WETH() external pure returns (address);\n\n function addLiquidity(\n address tokenA,\n address tokenB,\n uint256 amountADesired,\n uint256 amountBDesired,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n )\n external\n returns (\n uint256 amountA,\n uint256 amountB,\n uint256 liquidity\n );\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 removeLiquidity(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountA, uint256 amountB);\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\n function removeLiquidityWithPermit(\n address tokenA,\n address tokenB,\n uint256 liquidity,\n uint256 amountAMin,\n uint256 amountBMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountA, uint256 amountB);\n\n function removeLiquidityETHWithPermit(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountToken, uint256 amountETH);\n\n function swapExactTokensForTokens(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapTokensForExactTokens(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapExactETHForTokens(\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n\n function swapTokensForExactETH(\n uint256 amountOut,\n uint256 amountInMax,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapExactTokensForETH(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external returns (uint256[] memory amounts);\n\n function swapETHForExactTokens(\n uint256 amountOut,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external payable returns (uint256[] memory amounts);\n\n function quote(\n uint256 amountA,\n uint256 reserveA,\n uint256 reserveB\n ) external pure returns (uint256 amountB);\n\n function getAmountOut(\n uint256 amountIn,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountOut);\n\n function getAmountIn(\n uint256 amountOut,\n uint256 reserveIn,\n uint256 reserveOut\n ) external pure returns (uint256 amountIn);\n\n function getAmountsOut(uint256 amountIn, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n\n function getAmountsIn(uint256 amountOut, address[] calldata path)\n external\n view\n returns (uint256[] memory amounts);\n}\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n function removeLiquidityETHSupportingFeeOnTransferTokens(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline\n ) external returns (uint256 amountETH);\n\n function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\n address token,\n uint256 liquidity,\n uint256 amountTokenMin,\n uint256 amountETHMin,\n address to,\n uint256 deadline,\n bool approveMax,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256 amountETH);\n\n function swapExactTokensForTokensSupportingFeeOnTransferTokens(\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 swapExactTokensForETHSupportingFeeOnTransferTokens(\n uint256 amountIn,\n uint256 amountOutMin,\n address[] calldata path,\n address to,\n uint256 deadline\n ) external;\n}\n"}}