{"Address.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\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 function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n assembly {\n size := extcodesize(account)\n }\n return size \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 function _verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) private 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}"},"AuntieWhale.sol":{"content":"pragma solidity ^0.8.6;\n\n// SPDX-License-Identifier: UNLICENSED\n\nimport \"./IERC20.sol\";\nimport \"./IPancakeFactory.sol\";\nimport \"./IPancakeRouter.sol\";\nimport \"./IAuntieWhaleSniperOracle.sol\";\nimport \"./Ownable.sol\";\nimport \"./SafeMath.sol\";\nimport \"./Context.sol\";\nimport \"./AuntieWhaleAutomaticBuybackAgent.sol\";\nimport \"./AuntieWhaleManualBuybackAgent.sol\";\n\ncontract AuntieWhale is Context, IERC20, Ownable {\n\tusing SafeMath for uint256;\n\n\taddress private constant ROUTER_ADDRESS = 0x10ED43C718714eb63d5aA57B78B54704E256024E;\n\taddress private constant LAUNCHPAD_ADDRESS = 0xDc0a7fE55670dE0EaD8777432701Fc2815EB6b1e;\n\n\tuint256 private constant MAX = 2 ** 256 - 1;\n\taddress constant ZERO_ADDRESS = address(0);\n\taddress constant DEAD_ADDRESS = address(57005);\n\tuint256 private constant RATELIMIT_DELAY = 3;\n\tuint256 private constant FEE_PROCESSING_DELAY = 3;\n\n\tstring constant _name = \"Auntie Whale\";\n\tstring constant _symbol = \"AUNTIE\";\n\tuint8 constant _decimals = 9;\n\n\tuint256 private _tTotal = 1000000000000 * (10 ** _decimals);\n\tuint256 private _rTotal = (MAX - (MAX % _tTotal));\n\tuint256 private _tFeeTotal = 0;\n\n\tmapping(address =\u003e uint256) private _rOwned;\n\tmapping(address =\u003e uint256) private _tOwned;\n\tmapping(address =\u003e mapping(address =\u003e uint256)) private _allowances;\n\n\tmapping(address =\u003e uint256) private _ratelimit;\n\tmapping(address =\u003e bool) private _canTradeBeforeLaunch;\n\tmapping(address =\u003e bool) private _isAllowedToLaunch;\n\tmapping(address =\u003e bool) private _isExcludedFromFee;\n\tmapping(address =\u003e bool) private _isExcluded;\n\taddress[] private _excluded;\n\n\tuint256 private _whaleTaxThreshold = _tTotal / 100;\n\n\tuint256 private _whaleTaxFee = 15;\n\tuint256 private _automaticBuybackFee = 7;\n\tuint256 private _manualBuybackFee = 3;\n\tuint256 private _marketingFee = 3;\n\tuint256 private _holderReflectFee = 1;\n\tuint256 private _liquidityFee = 1;\n\n\tAuntieWhaleAutomaticBuybackAgent private _automaticBuybackAgent;\n\tAuntieWhaleManualBuybackAgent private _manualBuybackAgent;\n\tIAuntieWhaleSniperOracle private _sniperOracle;\n\taddress payable private _marketingWallet;\n\n\tbool private _areFeesActive = true;\n\n\tIPancakeRouter private _router;\n\taddress private _pairAddress;\n\n\tbool private _areFeesBeingProcessed = false;\n\tbool private _isFeeProcessingEnabled = true;\n\tuint256 private _feeProcessingThreshold = _tTotal / 1000;\n\tuint256 private _feesLastProcessedAt;\n\n\tbool private _hasLaunched = false;\n\n\tevent AutomaticBuybackAgentCreated(address contractAddress);\n\tevent ManualBuybackAgentCreated(address contractAddress);\n\tevent FeeProcessingThresholdUpdated(uint256 feeProcessingThreshold);\n\tevent FeeProcessingEnabledUpdated(bool enabled);\n\tevent FeesProcessed(uint256 amount);\n\n\tmodifier lockTheSwap {\n\t\t_areFeesBeingProcessed = true;\n\t\t_;\n\t\t_areFeesBeingProcessed = false;\n\t}\n\n\tconstructor() {\n\t\taddress self = address(this);\n\n\t\t_rOwned[_msgSender()] = _rTotal;\n\n\t\t//Set router and pair variables\n\t\t_router = IPancakeRouter(ROUTER_ADDRESS);\n\t\t_pairAddress = IPancakeFactory(_router.factory()).createPair(self, _router.WETH());\n\n\t\t//Initialize buyback agents\n\t\t_automaticBuybackAgent = new AuntieWhaleAutomaticBuybackAgent(self);\n\t\t_automaticBuybackAgent.transferOwnership(owner());\n\n\t\t_manualBuybackAgent = new AuntieWhaleManualBuybackAgent(self);\n\t\t_manualBuybackAgent.transferOwnership(owner());\n\n\t\t//Exclude necessary addresses from fees\n\t\t_isExcludedFromFee[owner()] = true;\n\t\t_isExcludedFromFee[self] = true;\n\t\t_isExcludedFromFee[ZERO_ADDRESS] = true;\n\t\t_isExcludedFromFee[DEAD_ADDRESS] = true;\n\t\t_isExcludedFromFee[address(_automaticBuybackAgent)] = true;\n\t\t_isExcludedFromFee[address(_manualBuybackAgent)] = true;\n\n\t\t_canTradeBeforeLaunch[owner()] = true;\n\n\t\t_isAllowedToLaunch[owner()] = true;\n\t\t_isAllowedToLaunch[LAUNCHPAD_ADDRESS] = true;\n\n\t\t_marketingWallet = payable(owner());\n\n\t\temit AutomaticBuybackAgentCreated(address(_automaticBuybackAgent));\n\t\temit ManualBuybackAgentCreated(address(_manualBuybackAgent));\n\t\temit Transfer(DEAD_ADDRESS, _msgSender(), _tTotal);\n\t}\n\n\tfunction name() public pure returns (string memory) {\n\t\treturn _name;\n\t}\n\n\tfunction symbol() public pure returns (string memory) {\n\t\treturn _symbol;\n\t}\n\n\tfunction decimals() public pure returns (uint8) {\n\t\treturn _decimals;\n\t}\n\n\tfunction totalSupply() public view override returns (uint256) {\n\t\treturn _tTotal;\n\t}\n\n\tfunction balanceOf(address account) public view override returns (uint256) {\n\t\tif (_isExcluded[account]) return _tOwned[account];\n\t\treturn tokenFromReflection(_rOwned[account]);\n\t}\n\n\tfunction transfer(address recipient, uint256 amount) public override returns (bool) {\n\t\t_transfer(_msgSender(), recipient, amount);\n\t\treturn true;\n\t}\n\n\tfunction allowance(address owner, address spender) public view override returns (uint256) {\n\t\treturn _allowances[owner][spender];\n\t}\n\n\tfunction approve(address spender, uint256 amount) public override returns (bool) {\n\t\t_approve(_msgSender(), spender, amount);\n\t\treturn true;\n\t}\n\n\tfunction transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {\n\t\t_transfer(sender, recipient, amount);\n\t\t_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n\t\treturn true;\n\t}\n\n\tfunction increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n\t\t_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n\t\treturn true;\n\t}\n\n\tfunction decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n\t\t_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n\t\treturn true;\n\t}\n\n\tfunction tokenFromReflection(uint256 rAmount) public view returns (uint256) {\n\t\trequire(rAmount \u003c= _rTotal, \"Amount must be less than total reflections\");\n\t\tuint256 currentRate = _getRate();\n\t\treturn rAmount.div(currentRate);\n\t}\n\n\tfunction isExcludedFromReward(address account) public view returns (bool) {\n\t\treturn _isExcluded[account];\n\t}\n\n\tfunction excludeFromFee(address account) public onlyOwner {\n\t\t_isExcludedFromFee[account] = true;\n\t}\n\n\tfunction includeInFee(address account) public onlyOwner {\n\t\t_isExcludedFromFee[account] = false;\n\t}\n\n\tfunction isExcludedFromFee(address account) public view returns (bool) {\n\t\treturn _isExcludedFromFee[account];\n\t}\n\n\tfunction excludeFromReward(address account) public onlyOwner() {\n\t\trequire(!_isExcluded[account], \"Account is already excluded\");\n\n\t\tif (_rOwned[account] \u003e 0) {\n\t\t\t_tOwned[account] = tokenFromReflection(_rOwned[account]);\n\t\t}\n\n\t\t_isExcluded[account] = true;\n\t\t_excluded.push(account);\n\t}\n\n\tfunction includeInReward(address account) external onlyOwner() {\n\t\trequire(_isExcluded[account], \"Account is not excluded\");\n\n\t\tfor (uint256 i = 0; i \u003c _excluded.length; i ) {\n\t\t\tif (_excluded[i] == account) {\n\t\t\t\t_excluded[i] = _excluded[_excluded.length - 1];\n\t\t\t\t_tOwned[account] = 0;\n\t\t\t\t_isExcluded[account] = false;\n\t\t\t\t_excluded.pop();\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tfunction setCanTradeBeforeLaunch(address account, bool isAllowed) public onlyOwner {\n\t\t_canTradeBeforeLaunch[account] = isAllowed;\n\t}\n\n\tfunction setFees(uint256 whaleTaxFee, uint256 automaticBuybackFee, uint256 manualBuybackFee, uint256 marketingFee, uint256 holderReflectFee, uint256 liquidityFee) public onlyOwner {\n\t\t//No honeypots here\n\t\tuint256 feeSum = whaleTaxFee automaticBuybackFee manualBuybackFee marketingFee holderReflectFee liquidityFee;\n\t\trequire(feeSum \u003c= 45, \"Cannot set fees higher than 45%.\");\n\n\t\t//Update fee variables\n\t\t_whaleTaxFee = whaleTaxFee;\n\t\t_automaticBuybackFee = automaticBuybackFee;\n\t\t_manualBuybackFee = manualBuybackFee;\n\t\t_marketingFee = marketingFee;\n\t\t_holderReflectFee = holderReflectFee;\n\t\t_liquidityFee = liquidityFee;\n\t}\n\n\tfunction calculateWhaleTaxFee(uint256 _amount, address _recipient) private view returns (uint256) {\n\t\tif (_areFeesActive \u0026\u0026 balanceOf(_recipient).add(_amount) \u003e _whaleTaxThreshold \u0026\u0026 _recipient != _pairAddress \u0026\u0026 _recipient != address(_router)) {\n\t\t\treturn _amount.mul(_whaleTaxFee).div(100);\n\t\t} else return 0;\n\t}\n\n\tfunction calculateAutomaticBuybackFee(uint256 _amount) private view returns (uint256) {\n\t\tif (!_areFeesActive) return 0;\n\t\treturn _amount.mul(_automaticBuybackFee).div(100);\n\t}\n\n\tfunction calculateManualBuybackFee(uint256 _amount) private view returns (uint256) {\n\t\tif (!_areFeesActive) return 0;\n\t\treturn _amount.mul(_manualBuybackFee).div(100);\n\t}\n\n\tfunction calculateMarketingFee(uint256 _amount) private view returns (uint256) {\n\t\tif (!_areFeesActive) return 0;\n\t\treturn _amount.mul(_marketingFee).div(100);\n\t}\n\n\tfunction calculateHolderReflectFee(uint256 _amount) private view returns (uint256) {\n\t\tif (!_areFeesActive) return 0;\n\t\treturn _amount.mul(_holderReflectFee).div(100);\n\t}\n\n\tfunction calculateLiquidityFee(uint256 _amount) private view returns (uint256) {\n\t\tif (!_areFeesActive) return 0;\n\t\treturn _amount.mul(_liquidityFee).div(100);\n\t}\n\n\tfunction setFeeProcessingEnabled(bool enabled) public onlyOwner {\n\t\t_isFeeProcessingEnabled = enabled;\n\t\temit FeeProcessingEnabledUpdated(enabled);\n\t}\n\n\tfunction setFeeProcessingThreshold(uint256 threshold) public onlyOwner {\n\t\trequire(threshold \u003e 0, \"Fee processsing threshold must be greater than zero.\");\n\t\t_feeProcessingThreshold = threshold;\n\t\temit FeeProcessingThresholdUpdated(threshold);\n\t}\n\n\tfunction setAutomaticBuybackAgent(AuntieWhaleAutomaticBuybackAgent automaticBuybackAgent) public onlyOwner {\n\t\t_automaticBuybackAgent = automaticBuybackAgent;\n\t\t_isExcludedFromFee[address(_automaticBuybackAgent)] = true;\n\t}\n\n\tfunction setManualBuybackAgent(AuntieWhaleManualBuybackAgent manualBuybackAgent) public onlyOwner {\n\t\t_manualBuybackAgent = manualBuybackAgent;\n\t\t_isExcludedFromFee[address(_manualBuybackAgent)] = true;\n\t}\n\n\tfunction setSniperOracle(IAuntieWhaleSniperOracle sniperOracle) public onlyOwner {\n\t\t_sniperOracle = sniperOracle;\n\t}\n\n\tfunction getAutomaticBuybackAgent() public view returns (address) {\n\t\treturn address(_automaticBuybackAgent);\n\t}\n\n\tfunction getManualBuybackAgent() public view returns (address) {\n\t\treturn address(_manualBuybackAgent);\n\t}\n\n\tfunction getMarketingWallet() public view returns (address) {\n\t\treturn _marketingWallet;\n\t}\n\n\tfunction setMarketingWallet(address payable wallet) public onlyOwner {\n\t\trequire(wallet != ZERO_ADDRESS, \"The marketing wallet cannot be the zero address.\");\n\t\t_marketingWallet = wallet;\n\t\t_isExcludedFromFee[_marketingWallet] = true;\n\t}\n\n\tfunction launch() public {\n\t\trequire(_isAllowedToLaunch[_msgSender()], \"Forbidden.\");\n\t\trequire(!_hasLaunched, \"Already launched.\");\n\t\t_sniperOracle.launch();\n\t\t_hasLaunched = true;\n\t}\n\n\tfunction _approve(address owner, address spender, uint256 amount) private {\n\t\trequire(owner != ZERO_ADDRESS, \"ERC20: approve from the zero address\");\n\t\trequire(spender != ZERO_ADDRESS, \"ERC20: approve to the zero address\");\n\n\t\t_allowances[owner][spender] = amount;\n\t\temit Approval(owner, spender, amount);\n\t}\n\n\tfunction _transfer(address _from, address _to, uint256 _amount) private {\n\t\trequire(_from != ZERO_ADDRESS, \"ERC20: transfer from the zero address\");\n\t\trequire(_to != ZERO_ADDRESS, \"ERC20: transfer to the zero address\");\n\t\trequire(_amount \u003e 0, \"Transfer amount must be greater than zero\");\n\n\t\t//Ensure trading is disabled before launch\n\t\trequire(_hasLaunched || _canTradeBeforeLaunch[_from], \"Cannot trade before launch.\");\n\n\t\t//Making the bots and snipers say uncle.\n\t\t_sniperOracle.processTransfer(_from, _to, _amount);\n\n\t\tbool canProcess = _isFeeProcessingEnabled \u0026\u0026 !_areFeesBeingProcessed;\n\t\tbool hasProcessedFees = false;\n\n\t\tif (canProcess) {\n\t\t\t//Transaction ratelimit\n\t\t\tif (_from != address(_router) \u0026\u0026 _from != _pairAddress \u0026\u0026 !_isExcludedFromFee[_from]) {\n\t\t\t\trequire(block.number \u003e= _ratelimit[_from], \"Too many transactions, try again in a couple of blocks.\");\n\t\t\t\t_ratelimit[_from] = block.number RATELIMIT_DELAY;\n\t\t\t}\n\n\t\t\t//Fee processing logic\n\t\t\tif (block.number \u003e= (_feesLastProcessedAt FEE_PROCESSING_DELAY) \u0026\u0026 balanceOf(address(this)) \u003e= _feeProcessingThreshold \u0026\u0026 _from != _pairAddress) {\n\t\t\t\tprocessFees(_feeProcessingThreshold);\n\t\t\t\thasProcessedFees = true;\n\t\t\t}\n\t\t}\n\n\t\t//Automatic buyback\n\t\tif (canProcess \u0026\u0026 !hasProcessedFees \u0026\u0026 _automaticBuybackAgent.getIsBuybackEnabled()) {\n\t\t\tif (_from != address(_router) \u0026\u0026 _to == _pairAddress) {\n\t\t\t\tprocessAutomaticBuyback();\n\t\t\t}\n\t\t}\n\n\t\t//Process the transfer itself\n\t\t_tokenTransfer(_from, _to, _amount);\n\t}\n\n\tfunction processFees(uint256 amount) private lockTheSwap {\n\t\tuint256 buybackFeeSum = _automaticBuybackFee.add(_manualBuybackFee);\n\t\tuint256 feeSum = buybackFeeSum.add(_marketingFee).add(_liquidityFee);\n\n\t\t//Don\u0027t bother processing if fees are zero\n\t\tif (buybackFeeSum == 0 || feeSum == 0) return;\n\n\t\t//Calculate all necessary amounts\n\t\tuint256 tokensForAutomaticBuyback = amount.mul(_automaticBuybackFee).div(feeSum);\n\t\tuint256 tokensForManualBuyback = amount.mul(_manualBuybackFee).div(feeSum);\n\t\tuint256 tokensForBuyback = tokensForAutomaticBuyback.add(tokensForManualBuyback);\n\t\tuint256 tokensForMarketing = amount.mul(_marketingFee).div(feeSum);\n\t\tuint256 tokensForLiquidity = amount.sub(tokensForBuyback).sub(tokensForMarketing);\n\n\t\t//Sell tokens to fuel the buyback (we swap them both in one transaction to optimize gas)\n\t\tuint256 ethReceivedForBuyback = swapExactTokensForETH(tokensForBuyback);\n\t\tuint256 ethReceivedForAutomaticBuyback = ethReceivedForBuyback.mul(_automaticBuybackFee).div(buybackFeeSum);\n\t\tuint256 ethReceivedForManualBuyback = ethReceivedForBuyback.sub(ethReceivedForAutomaticBuyback);\n\n\t\t//Send the newly swapped ETH to the buyback agents for later\n\t\tpayable(_automaticBuybackAgent).transfer(ethReceivedForAutomaticBuyback);\n\t\tpayable(_manualBuybackAgent).transfer(ethReceivedForManualBuyback);\n\n\t\t//Sell tokens and send to the the marketing wallet\n\t\tuint256 ethReceivedForMarketing = swapExactTokensForETH(tokensForMarketing);\n\t\t_marketingWallet.transfer(ethReceivedForMarketing);\n\n\t\t//The rest goes right into liquidity\n\t\taddLiquidity(tokensForLiquidity);\n\n\t\t//Ensure this cannot be called again for the next few blocks\n\t\t_feesLastProcessedAt = block.number;\n\n\t\temit FeesProcessed(amount);\n\t}\n\n\tfunction swapExactTokensForETH(uint256 amountIn) private returns (uint256) {\n\t\taddress self = address(this);\n\n\t\taddress[] memory path = new address[](2);\n\t\tpath[0] = self;\n\t\tpath[1] = _router.WETH();\n\n\t\t_approve(self, address(_router), amountIn);\n\n\t\tuint256 initialBalance = self.balance;\n\t\t_router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountIn, 0, path, self, block.timestamp);\n\n\t\treturn self.balance.sub(initialBalance);\n\t}\n\n\tfunction addLiquidity(uint256 amountIn) private {\n\t\taddress self = address(this);\n\n\t\t//Split the amount to liquify into halves\n\t\tuint256 tokensToSell = amountIn.div(2);\n\t\tuint256 tokensForLiquidity = amountIn.sub(tokensToSell);\n\n\t\t//Sell one half so that we can add to liquidity\n\t\tuint256 ethForLiquidity = swapExactTokensForETH(tokensToSell);\n\n\t\t//Add the liquidity\n\t\t_approve(self, address(_router), tokensForLiquidity);\n\t\t_router.addLiquidityETH{value : ethForLiquidity}(self, tokensForLiquidity, 0, 0, owner(), block.timestamp);\n\t}\n\n\tfunction processAutomaticBuyback() private lockTheSwap {\n\t\t_automaticBuybackAgent.buyback();\n\t}\n\n\tfunction _tokenTransfer(address sender, address recipient, uint256 amount) private {\n\t\tbool shouldTakeFee = !_isExcludedFromFee[sender] \u0026\u0026 !_isExcludedFromFee[recipient];\n\n\t\tif (!shouldTakeFee) {\n\t\t\t_areFeesActive = false;\n\t\t}\n\n\t\tif (_isExcluded[sender] \u0026\u0026 !_isExcluded[recipient]) {\n\t\t\t_transferFromExcluded(sender, recipient, amount);\n\t\t} else if (!_isExcluded[sender] \u0026\u0026 _isExcluded[recipient]) {\n\t\t\t_transferToExcluded(sender, recipient, amount);\n\t\t} else if (_isExcluded[sender] \u0026\u0026 _isExcluded[recipient]) {\n\t\t\t_transferBothExcluded(sender, recipient, amount);\n\t\t} else {\n\t\t\t_transferStandard(sender, recipient, amount);\n\t\t}\n\n\t\tif (!shouldTakeFee) {\n\t\t\t_areFeesActive = true;\n\t\t}\n\t}\n\n\tfunction _reflectFee(uint256 rFee, uint256 tFee) private {\n\t\t_rTotal = _rTotal.sub(rFee);\n\t\t_tFeeTotal = _tFeeTotal.add(tFee);\n\t}\n\n\tfunction _getValues(uint256 tAmount, address recipient) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {\n\t\t(uint256 tTransferAmount, uint256 tHolderReflectFee, uint256 tOtherFee) = _getTValues(tAmount, recipient);\n\t\t(uint256 rAmount, uint256 rTransferAmount, uint256 rHolderReflectFee) = _getRValues(tAmount, tHolderReflectFee, tOtherFee, _getRate());\n\t\treturn (rAmount, rTransferAmount, rHolderReflectFee, tTransferAmount, tHolderReflectFee, tOtherFee);\n\t}\n\n\tfunction _getTValues(uint256 tAmount, address recipient) private view returns (uint256, uint256, uint256) {\n\t\t//Calculate value of fees taken for this transaction\n\t\tuint256 tWhaleTaxFee = calculateWhaleTaxFee(tAmount, recipient);\n\t\tuint256 tAutomaticBuybackFee = calculateAutomaticBuybackFee(tAmount);\n\t\tuint256 tManualBuybackFee = calculateManualBuybackFee(tAmount);\n\t\tuint256 tMarketingFee = calculateMarketingFee(tAmount);\n\t\tuint256 tHolderReflectFee = calculateHolderReflectFee(tAmount);\n\t\tuint256 tLiquidityFee = calculateLiquidityFee(tAmount);\n\n\t\t//Add up all fees besides the basic holder reflect fee\n\t\tuint256 tOtherFee = tWhaleTaxFee.add(tAutomaticBuybackFee).add(tManualBuybackFee).add(tMarketingFee).add(tLiquidityFee);\n\n\t\treturn (tAmount.sub(tHolderReflectFee).sub(tOtherFee), tHolderReflectFee, tOtherFee);\n\t}\n\n\tfunction _getRValues(uint256 tAmount, uint256 tHolderReflectFee, uint256 tOtherFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {\n\t\tuint256 rAmount = tAmount.mul(currentRate);\n\t\tuint256 rHolderReflectFee = tHolderReflectFee.mul(currentRate);\n\t\tuint256 rOtherFee = tOtherFee.mul(currentRate);\n\t\tuint256 rTransferAmount = rAmount.sub(rHolderReflectFee).sub(rOtherFee);\n\t\treturn (rAmount, rTransferAmount, rHolderReflectFee);\n\t}\n\n\tfunction _getRate() private view returns (uint256) {\n\t\t(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();\n\t\treturn rSupply.div(tSupply);\n\t}\n\n\tfunction _getCurrentSupply() private view returns (uint256, uint256) {\n\t\tuint256 rSupply = _rTotal;\n\t\tuint256 tSupply = _tTotal;\n\n\t\tfor (uint256 i = 0; i \u003c _excluded.length; i ) {\n\t\t\tif (_rOwned[_excluded[i]] \u003e rSupply || _tOwned[_excluded[i]] \u003e tSupply) return (_rTotal, _tTotal);\n\t\t\trSupply = rSupply.sub(_rOwned[_excluded[i]]);\n\t\t\ttSupply = tSupply.sub(_tOwned[_excluded[i]]);\n\t\t}\n\n\t\tif (rSupply \u003c _rTotal.div(_tTotal)) return (_rTotal, _tTotal);\n\t\treturn (rSupply, tSupply);\n\t}\n\n\tfunction _takeFees(uint256 tOtherFee) private {\n\t\taddress self = address(this);\n\n\t\tuint256 currentRate = _getRate();\n\t\tuint256 rOtherFee = tOtherFee.mul(currentRate);\n\n\t\t_rOwned[self] = _rOwned[self].add(rOtherFee);\n\n\t\tif (_isExcluded[self]) {\n\t\t\t_tOwned[self] = _tOwned[self].add(tOtherFee);\n\t\t}\n\t}\n\n\tfunction _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {\n\t\t(uint256 rAmount, uint256 rTransferAmount, uint256 rHolderReflectFee, uint256 tTransferAmount, uint256 tHolderReflectFee, uint256 tOtherFee) = _getValues(tAmount, recipient);\n\t\t_tOwned[sender] = _tOwned[sender].sub(tAmount);\n\t\t_rOwned[sender] = _rOwned[sender].sub(rAmount);\n\t\t_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\t\t_takeFees(tOtherFee);\n\t\t_reflectFee(rHolderReflectFee, tHolderReflectFee);\n\t\temit Transfer(sender, recipient, tTransferAmount);\n\t}\n\n\tfunction _transferToExcluded(address sender, address recipient, uint256 tAmount) private {\n\t\t(uint256 rAmount, uint256 rTransferAmount, uint256 rHolderReflectFee, uint256 tTransferAmount, uint256 tHolderReflectFee, uint256 tOtherFee) = _getValues(tAmount, recipient);\n\t\t_rOwned[sender] = _rOwned[sender].sub(rAmount);\n\t\t_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);\n\t\t_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\t\t_takeFees(tOtherFee);\n\t\t_reflectFee(rHolderReflectFee, tHolderReflectFee);\n\t\temit Transfer(sender, recipient, tTransferAmount);\n\t}\n\n\tfunction _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {\n\t\t(uint256 rAmount, uint256 rTransferAmount, uint256 rHolderReflectFee, uint256 tTransferAmount, uint256 tHolderReflectFee, uint256 tOtherFee) = _getValues(tAmount, recipient);\n\t\t_tOwned[sender] = _tOwned[sender].sub(tAmount);\n\t\t_rOwned[sender] = _rOwned[sender].sub(rAmount);\n\t\t_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);\n\t\t_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\t\t_takeFees(tOtherFee);\n\t\t_reflectFee(rHolderReflectFee, tHolderReflectFee);\n\t\temit Transfer(sender, recipient, tTransferAmount);\n\t}\n\n\tfunction _transferStandard(address sender, address recipient, uint256 tAmount) private {\n\t\t(uint256 rAmount, uint256 rTransferAmount, uint256 rHolderReflectFee, uint256 tTransferAmount, uint256 tHolderReflectFee, uint256 tOtherFee) = _getValues(tAmount, recipient);\n\t\t_rOwned[sender] = _rOwned[sender].sub(rAmount);\n\t\t_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\t\t_takeFees(tOtherFee);\n\t\t_reflectFee(rHolderReflectFee, tHolderReflectFee);\n\t\temit Transfer(sender, recipient, tTransferAmount);\n\t}\n\n\tfunction withdraw(uint256 amount) public onlyOwner {\n\t\tpayable(owner()).transfer(amount == 0 ? address(this).balance : amount);\n\t}\n\n\tfunction forceProcessFees(uint256 amount) public onlyOwner {\n\t\trequire(_isFeeProcessingEnabled, \"Fee processing must be enabled to manually process fees.\");\n\t\trequire(!_areFeesBeingProcessed, \"Contract cannot already be processing fees.\");\n\t\tprocessFees(amount == 0 ? balanceOf(address(this)) : amount);\n\t}\n\n\treceive() external payable {}\n}"},"AuntieWhaleAutomaticBuybackAgent.sol":{"content":"pragma solidity ^0.8.6;\n\n// SPDX-License-Identifier: UNLICENSED\n\nimport \"./IERC20.sol\";\nimport \"./IPancakeRouter.sol\";\nimport \"./Ownable.sol\";\n\ncontract AuntieWhaleAutomaticBuybackAgent is Ownable {\n\taddress constant DEAD_ADDRESS = address(57005);\n\tuint256 constant BUY_ROUNDS = 3;\n\n\tIPancakeRouter router;\n\tIERC20 token;\n\n\tbool isBuybackEnabled = false;\n\n\tuint256 buybackAmountMin = 0;\n\tuint256 buybackAmountMax = 0;\n\tuint256 public timesBought = 0;\n\tuint256 public amountSpent = 0;\n\tuint256 public amountBought = 0;\n\n\tevent BuybackOccured(uint256 amountIn, uint256 amountOut);\n\n\tconstructor(address tokenAddress) {\n\t\trouter = IPancakeRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);\n\t\ttoken = IERC20(tokenAddress);\n\t}\n\n\tfunction getIsBuybackEnabled() public view returns (bool) {\n\t\treturn isBuybackEnabled;\n\t}\n\n\tfunction setIsBuybackEnabled(bool isEnabled) public onlyOwner {\n\t\tisBuybackEnabled = isEnabled;\n\t}\n\n\tfunction setBuybackParameters(uint256 amountMin, uint256 amountMax) public onlyOwner {\n\t\tbuybackAmountMin = amountMin;\n\t\tbuybackAmountMax = amountMax;\n\t}\n\n\tfunction generateArbitraryNumber() private view returns (uint256) {\n\t\t// This will not generate a random number, but it doesn\u0027t matter for this use case.\n\t\t// All we need is for it to be somewhat arbitrary, it being deterministic doesn\u0027t matter for us.\n\n\t\tuint256 seed = uint256(keccak256(abi.encodePacked(\n\t\t\tblock.timestamp block.difficulty \n\t\t\t((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (block.timestamp)) \n\t\t\tblock.gaslimit \n\t\t\t((uint256(keccak256(abi.encodePacked(msg.sender)))) / (block.timestamp)) \n\t\t\tblock.number * (timesBought 1)\n\t\t)));\n\n\t\treturn 1 (seed - ((seed / 10) * 10));\n\t}\n\n\tfunction getBuybackAmount() private view returns (uint256) {\n\t\trequire(buybackAmountMin \u003e 0, \"Minimum buyback amount must be greater than zero.\");\n\t\trequire(buybackAmountMax \u003e buybackAmountMin, \"Maximum buyback amount must be greater than minimum buyback amount.\");\n\n\t\tuint256 spread = buybackAmountMax - buybackAmountMin;\n\t\treturn buybackAmountMin (spread / generateArbitraryNumber());\n\t}\n\n\tfunction _swap(uint256 amountIn) private returns (uint256) {\n\t\taddress[] memory path = new address[](2);\n\t\tpath[0] = router.WETH();\n\t\tpath[1] = address(token);\n\n\t\tuint256 initialTokenBalance = token.balanceOf(DEAD_ADDRESS);\n\t\trouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value : amountIn}(0, path, DEAD_ADDRESS, block.timestamp);\n\t\treturn token.balanceOf(DEAD_ADDRESS) - initialTokenBalance;\n\t}\n\n\tfunction _splitBuys(uint256 amountIn, uint256 chunks) private pure returns (uint256[] memory buys) {\n\t\tuint256 amount = 0;\n\n\t\tbuys = new uint256[](chunks);\n\n\t\tfor (uint256 i = 0; i \u003c chunks; i ) {\n\t\t\tuint256 amountToBuy = i \u003c (chunks - 1) ? amountIn / chunks : (amountIn - amount);\n\t\t\tamount = amountToBuy;\n\t\t\tbuys[i] = amountToBuy;\n\t\t}\n\n\t\treturn buys;\n\t}\n\n\tfunction buyback() public {\n\t\trequire(msg.sender == address(token), \"Only the token itself can initiate buyback.\");\n\t\trequire(isBuybackEnabled, \"Buyback is disabled.\");\n\n\t\tuint256 amountIn = getBuybackAmount();\n\t\tuint256 balance = address(this).balance;\n\t\tif (balance \u003c amountIn) return;\n\n\t\tuint256 amountOut = 0;\n\n\t\tuint256[] memory buys = _splitBuys(amountIn, BUY_ROUNDS);\n\n\t\tfor (uint256 i = 0; i \u003c buys.length; i ) {\n\t\t\tamountOut = _swap(buys[i]);\n\t\t}\n\n\t\ttimesBought ;\n\t\tamountSpent = amountIn;\n\t\tamountBought = amountOut;\n\n\t\temit BuybackOccured(amountIn, amountOut);\n\t}\n\n\treceive() external payable {}\n}"},"AuntieWhaleManualBuybackAgent.sol":{"content":"pragma solidity ^0.8.6;\n\n// SPDX-License-Identifier: UNLICENSED\n\nimport \"./IERC20.sol\";\nimport \"./IPancakeRouter.sol\";\nimport \"./Ownable.sol\";\n\ncontract AuntieWhaleManualBuybackAgent is Ownable {\n\taddress constant DEAD_ADDRESS = address(57005);\n\n\tIPancakeRouter router;\n\tIERC20 token;\n\n\tuint256 public timesBought = 0;\n\tuint256 public amountSpent = 0;\n\tuint256 public amountBought = 0;\n\n\tevent BuybackOccured(uint256 amountIn, uint256 amountOut);\n\n\tconstructor(address tokenAddress) {\n\t\trouter = IPancakeRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);\n\t\ttoken = IERC20(tokenAddress);\n\t}\n\n\tfunction buyback(uint256 amountIn) public onlyOwner {\n\t\trequire(amountIn \u003e= address(this).balance, \"Insufficient balance for buyback.\");\n\n\t\taddress[] memory path = new address[](2);\n\t\tpath[0] = router.WETH();\n\t\tpath[1] = address(token);\n\n\t\tuint256 initialTokenBalance = token.balanceOf(DEAD_ADDRESS);\n\t\trouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amountIn}(0, path, DEAD_ADDRESS, block.timestamp);\n\t\tuint256 amountOut = token.balanceOf(DEAD_ADDRESS) - initialTokenBalance;\n\n\t\ttimesBought ;\n\t\tamountSpent = amountIn;\n\t\tamountBought = amountOut;\n\n\t\temit BuybackOccured(amountIn, amountOut);\n\t}\n\n\treceive() external payable {}\n}"},"Context.sol":{"content":"// SPDX-License-Identifier: MIT\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}"},"IAuntieWhaleSniperOracle.sol":{"content":"pragma solidity ^0.8.4;\n\n// SPDX-License-Identifier: UNLICENSED\n\ninterface IAuntieWhaleSniperOracle {\n\tfunction processTransfer(address _from, address _to, uint256 _amount) external;\n\n\tfunction launch() external;\n}"},"IERC20.sol":{"content":"pragma solidity ^0.8.4;\n\n// SPDX-License-Identifier: UNLICENSED\n\ninterface IERC20 {\n\tfunction totalSupply() external view returns (uint256);\n\n\tfunction balanceOf(address who) external view returns (uint256);\n\n\tfunction allowance(address owner, address spender) external view returns (uint256);\n\n\tfunction transfer(address to, uint256 value) external returns (bool);\n\n\tfunction approve(address spender, uint256 value) external returns (bool);\n\n\tfunction transferFrom(address from, address to, uint256 value) external returns (bool);\n\n\tevent Transfer(address indexed from, address indexed to, uint256 value);\n\tevent Approval(address indexed owner, address indexed spender, uint256 value);\n}"},"IPancakeFactory.sol":{"content":"pragma solidity ^0.8.4;\n\n// SPDX-License-Identifier: UNLICENSED\n\ninterface IPancakeFactory {\n\tfunction createPair(address tokenA, address tokenB) external returns (address pair);\n}"},"IPancakeRouter.sol":{"content":"pragma solidity ^0.8.4;\n\n// SPDX-License-Identifier: UNLICENSED\n\ninterface IPancakeRouter {\n\tfunction factory() external pure returns (address);\n\n\tfunction WETH() external pure returns (address);\n\n\tfunction addLiquidity(\n\t\taddress tokenA,\n\t\taddress tokenB,\n\t\tuint amountADesired,\n\t\tuint amountBDesired,\n\t\tuint amountAMin,\n\t\tuint amountBMin,\n\t\taddress to,\n\t\tuint deadline\n\t) external returns (uint amountA, uint amountB, uint liquidity);\n\n\tfunction addLiquidityETH(\n\t\taddress token,\n\t\tuint amountTokenDesired,\n\t\tuint amountTokenMin,\n\t\tuint amountETHMin,\n\t\taddress to,\n\t\tuint deadline\n\t) external payable returns (uint amountToken, uint amountETH, uint liquidity);\n\n\tfunction swapExactTokensForTokensSupportingFeeOnTransferTokens(\n\t\tuint amountIn,\n\t\tuint amountOutMin,\n\t\taddress[] calldata path,\n\t\taddress to,\n\t\tuint deadline\n\t) external;\n\n\tfunction swapExactETHForTokensSupportingFeeOnTransferTokens(\n\t\tuint amountOutMin,\n\t\taddress[] calldata path,\n\t\taddress to,\n\t\tuint deadline\n\t) external payable;\n\n\tfunction swapExactTokensForETHSupportingFeeOnTransferTokens(\n\t\tuint amountIn,\n\t\tuint amountOutMin,\n\t\taddress[] calldata path,\n\t\taddress to,\n\t\tuint deadline\n\t) external;\n}"},"Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\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 _setOwner(_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 _setOwner(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 _setOwner(newOwner);\n }\n\n function _setOwner(address newOwner) private {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}"},"SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler\u0027s built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity\u0027s arithmetic operations.\n *\n * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a b;\n if (c \u003c a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b \u003e a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring \u0027a\u0027 not being zero, but the\n // benefit is lost if \u0027b\u0027 is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity\u0027s ` ` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity\u0027s `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity\u0027s `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity\u0027s `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity\u0027s `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b \u003c= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b \u003e 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b \u003e 0, errorMessage);\n return a % b;\n }\n }\n}"}}