BNB Chain
0xcfc7ba4fefeaf9e9689cad944177ee633842b0ba
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xcfc7ba4f…3842b0ba8.8 KB26.7 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xcfc7ba4fefeaf9e9689cad944177ee633842b0ba
2,350 lines · Click a variable or keyword to highlight its references · Click a line number to copy its link; Shift-click to copy a block link
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { uint256 public constant BLACK_ADDRESS = 57005; address public constant bnbTokenAddress = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c); uint256 public constant BASE_PERCENT = 10000; uint8 public constant decimals = 18; mapping(address => uint256) public balanceOf; // STORAGE[0x0] mapping(address => mapping(address => uint256)) public allowance; // STORAGE[0x1] uint256 public totalSupply; // STORAGE[0x2] string _name; // STORAGE[0x3] string _symbol; // STORAGE[0x4] address public owner; // STORAGE[0x5] uint256 public buyBurnRate; // STORAGE[0x6] uint256 public buyLpRate; // STORAGE[0x7] uint256 public sellBurnRate; // STORAGE[0x8] uint256 public sellLpRate; // STORAGE[0x9] address public uniswapPair; // STORAGE[0xa] address public uniswapV2RouterContractAddress; // STORAGE[0xb] address public uniswapV2Router; // STORAGE[0xc] mapping(address => bool) public pairs; // STORAGE[0xd] mapping(address => uint256) public isTaxExempt; // STORAGE[0xe] // DESOLEX_STORAGE_CONFLICT_RESOLVED: mapping value 0: bool [ResolvedAbi] vs uint256 [VerifiedAbi] (selected uint256) mapping(address => bool) public isBlacklisted; // STORAGE[0xf] // DESOLEX_STORAGE_CONFLICT_RESOLVED: mapping value 0: bool [VerifiedAbi] vs uint256 [ResolvedAbi] (selected bool) address public lpAddress; // STORAGE[0x10] bytes 0 to 19 bool public isCanBuy; // STORAGE[0x10] bytes 20 to 20 bool public isCanSell; // STORAGE[0x10] bytes 21 to 21 bool stor_10_22_22; // STORAGE[0x10] bytes 22 to 22 mapping(address => uint256) public addLiquidityUnlockTime; // STORAGE[0x11] address stor_12; // STORAGE[0x12] address public admin; // STORAGE[0x13] address public lockContract; // STORAGE[0x14] event OwnershipTransferred(address indexed, address indexed); event AddThePool(address indexed, address indexed, uint256 indexed); event RemoveThePool(address indexed, address indexed, uint256 indexed); event UpdateLog(address indexed, address indexed, uint256 indexed, bool, bool); event Approval(address indexed, address indexed, uint256); error ERC20InsufficientBalance(address, uint256, uint256); error ERC20InvalidApprover(address); event WithdrawalToken(address indexed, address indexed, uint256 indexed); error OwnableUnauthorizedAccount(address); error ERC20InvalidSender(address); event Transfer(address indexed, address indexed, uint256); error OwnableInvalidOwner(address); error ERC20InvalidReceiver(address); error ERC20InvalidSpender(address); event OriginLog(address indexed, address indexed, uint256 indexed, address, bool, bool); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } modifier onlyOwner() { require(msg.sender == owner, OwnableUnauthorizedAccount()); _; } receive() external payable { uint256 value0 = 0x08fc; if (msg.value != 0x0) { value0 = 0; } (bool success0, bytes memory returnData0) = address(msg.sender).call{ value: msg.value }(""); // call require(success0); } fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x14ad4bb0)) { // Route to Unknown_14ad4bb0(bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x51f148fd)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x5271f968)) { // Route to Unknown_5271f968() after replacing only msg.sig. __desolexSelectorShim(uint32(0x7d798494)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x9a63ad67)) { // Route to Unknown_9a63ad67(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x85411254)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xdc7ac7d2)) { // Route to Unknown_dc7ac7d2(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xb5342f70)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xdf0a7bd7)) { // Route to Unknown_df0a7bd7(uint256,address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x7daeacc6)); return; } revert(); } function setSellBurnRate(uint256 newSellBurnRate) public onlyOwner { sellBurnRate = newSellBurnRate; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), OwnableInvalidOwner()); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function Unknown_df0a7bd7(uint256 amountADesired, address arg1) public payable { if (!(msg.value)) { if ((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) >= 0x40) { if (arg1 == arg1) { if (((msg.sender != owner) && (msg.sender == admin)) || (msg.sender == owner)) { if (amountADesired != 0x0) { (bool success0, bytes memory returnData0) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves if (success0) { uint256 value1 = 0x20; uint256 value2 = var_c; uint256 value6 = var_d; if (success0) { uint256 value0 = returnData0.length; if (0x60 <= returnData0.length) { value0 = 0x60; } uint256 var_b; if (((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value0) - var_b) >= 0x60); require(var_e == (uint112(var_e))); require(var_f == (uint112(var_f))); require(var_g == (uint32(var_g))); } else { value1 = var_b; value2 = 0; value6 = 0; } (bool success1, bytes memory returnData1) = uniswapPair.token0(); // staticcall if (success1) { uint256 value4 = this.code.length; uint256 value5 = var_b.length; if (success1) { uint256 value3 = returnData1.length; if (0x20 <= returnData1.length) { value3 = 0x20; } if (((var_b + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value3) - var_b) >= 0x20); require(var_b.length == (address(var_b.length))); } else { value4 = var_b; value5 = 0; } uint256 value7 = uint112(value2); uint256 value8 = uint112(value6); if ((value5 & 0xffffffffffffffffffffffffffffffffffffffff) == 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c) { value7 = uint112(value6); value8 = uint112(value2); } if (amountADesired != 0x0) { if ((value8 != 0x0) && (value7 != 0x0)) { if ((!((amountADesired * value7) / value8)) | ((((amountADesired * value7) / value8) * 0x2774) / ((amountADesired * value7) / value8) == 0x2774)) { if (amountADesired * value7 / value8 * 0x2774 / 0x2710 != 0x0) { (bool success2, bytes memory returnData2) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).transferFrom(msg.sender, address(this), amountADesired); // call if (success2) { if (success2) { if (0x20 <= returnData2.length) { if (!(((var_b + 0x20) > 0xffffffffffffffff) | ((var_b + 0x20) < var_b))) { var_b = var_b + 0x20; if (((var_b + 0x20) - var_b) >= 0x20) { if (var_b.length == var_b.length) { (bool success3, bytes memory returnData3) = this.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), (((amountADesired * value7) / value8) * 0x2774) / 0x2710)); // call transferFrom if (success3) { if (!(success3)) { if (block.timestamp <= (block.timestamp + 0x0258)) { (bool success4, bytes memory returnData4) = uniswapV2Router.call(abi.encodeWithSelector(bytes4(0xe8e33700), 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c, address(this), amountADesired, (((amountADesired * value7) / value8) * 0x2774) / 0x2710, 0, 0, address(this), block.timestamp + 0x0258)); // call addLiquidity if (success4) { uint256 value10 = this.code.length; if (success4) { uint256 value9 = returnData4.length; if (0x60 <= returnData4.length) { value9 = 0x60; } if (((var_b + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value9) - var_b) >= 0x60); } else { value10 = var_b; } uint256 value11 = this.code.length; if (balanceOf[address(this)] == 0x0) { value11 = balanceOf[address(this)]; } else if (address(this) == address(0)) { totalSupply = totalSupply + balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } else { require(!(balanceOf[address(this)] < balanceOf[address(this)])); balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } (bool success5, bytes memory returnData5) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(address(this)); // staticcall if (success5) { uint256 value13 = this.code.length; uint256 value14 = var_b.length; if (success5) { uint256 value12 = returnData5.length; if (0x20 <= returnData5.length) { value12 = 0x20; } if (((var_b + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value12) - var_b) >= 0x20); } else { value13 = var_b; value14 = 0; } uint256 value82 = 0; uint256 value21 = 0x20; if (value14 != 0x0) { if (((var_b + 0x80) > 0xffffffffffffffff) | ((var_b + 0x80) < var_b)) _desolexPanic(65); var_b = var_b + 0x80; (bool success6, bytes memory returnData6) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).transfer(admin, value14); // call if (returnData6.length != 0x0) { if (!(returnData6.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + ((((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success7, bytes memory returnData7) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success7); uint256 value16 = this.code.length; uint256 value17 = var_b.length; if (success7) { uint256 value15 = returnData7.length; if (0x20 <= returnData7.length) { value15 = 0x20; } if (((var_b + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value15) - var_b) >= 0x20); } else { value16 = var_b; value17 = 0; } (bool success8, bytes memory returnData8) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value17)); // call approve require(success8); uint256 value19 = this.code.length; uint256 value20 = this.code.length; if (success8) { uint256 value18 = returnData8.length; if (returnData8.length >= 0x20) { value18 = 0x20; } if (((var_b + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value18) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value19 = var_b; value20 = 0x20; } require(lockContract.code.length); (bool success9, bytes memory returnData9) = lockContract.lockFor(arg1, value17); // call require(success9); if (!(success9)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b; require(!(0)); return; } } else { flag2 = value14 != 0x0; value21 = 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c; } (bool success10, bytes memory returnData10) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf if (success10) { uint256 value23 = this.code.length; uint256 value24 = var_b.length; if (success10) { uint256 value22 = returnData10.length; if (0x20 <= returnData10.length) { value22 = 0x20; } if (((var_b + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value22) - var_b) >= 0x20); } else { value23 = var_b; value24 = 0; } (bool success11, bytes memory returnData11) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value24)); // call approve if (success11 && !success11 && lockContract.code.length) { (bool success12, bytes memory returnData12) = lockContract.lockFor(arg1, value24); // call if (success12 && !(success12)) { return; } } } } } } } } } } } } } else { (bool success13, bytes memory returnData13) = this.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), (((amountADesired * value7) / value8) * 0x2774) / 0x2710)); // call transferFrom require(success13); if (!(success13)) { (bool success14, bytes memory returnData14) = uniswapV2Router.call(abi.encodeWithSelector(bytes4(0xe8e33700), 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c, address(this), amountADesired, (((amountADesired * value7) / value8) * 0x2774) / 0x2710, 0, 0, address(this), block.timestamp + 0x0258)); // call addLiquidity require(success14); uint256 value26 = this.code.length; if (success14) { uint256 value25 = returnData14.length; if (0x60 <= returnData14.length) { value25 = 0x60; } if (((var_b + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value25) - var_b) >= 0x60); } else { value26 = var_b; } uint256 value27 = this.code.length; if (balanceOf[address(this)] == 0x0) { value27 = balanceOf[address(this)]; } else if (address(this) == address(0)) { totalSupply = totalSupply + balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } else { require(!(balanceOf[address(this)] < balanceOf[address(this)])); balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } (bool success15, bytes memory returnData15) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(address(this)); // staticcall require(success15); uint256 value29 = this.code.length; uint256 value30 = var_b.length; if (success15) { uint256 value28 = returnData15.length; if (0x20 <= returnData15.length) { value28 = 0x20; } if (((var_b + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value28) - var_b) >= 0x20); } else { value29 = var_b; value30 = 0; } uint256 value83 = 0; uint256 value37 = 0x20; if (value30 != 0x0) { if (((var_b + 0x80) > 0xffffffffffffffff) | ((var_b + 0x80) < var_b)) _desolexPanic(65); var_b = var_b + 0x80; (bool success16, bytes memory returnData16) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).transfer(admin, value30); // call if (returnData16.length != 0x0) { if (!(returnData16.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + ((((returnData16.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((((returnData16.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((((returnData16.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success17, bytes memory returnData17) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success17); uint256 value32 = this.code.length; uint256 value33 = var_b.length; if (success17) { uint256 value31 = returnData17.length; if (0x20 <= returnData17.length) { value31 = 0x20; } if (((var_b + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value31) - var_b) >= 0x20); } else { value32 = var_b; value33 = 0; } (bool success18, bytes memory returnData18) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value33)); // call approve require(success18); uint256 value35 = this.code.length; uint256 value36 = this.code.length; if (success18) { uint256 value34 = returnData18.length; if (returnData18.length >= 0x20) { value34 = 0x20; } if (((var_b + ((value34 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value34 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value34 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value34) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value35 = var_b; value36 = 0x20; } require(lockContract.code.length); (bool success19, bytes memory returnData19) = lockContract.lockFor(arg1, value33); // call require(success19); if (!(success19)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b; require(!(0)); return; } } else { flag3 = value30 != 0x0; value37 = 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c; } (bool success20, bytes memory returnData20) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success20); uint256 value39 = this.code.length; uint256 value40 = var_b.length; if (success20) { uint256 value38 = returnData20.length; if (0x20 <= returnData20.length) { value38 = 0x20; } if (((var_b + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value38) - var_b) >= 0x20); } else { value39 = var_b; value40 = 0; } (bool success21, bytes memory returnData21) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value40)); // call approve require(success21); uint256 value42 = this.code.length; uint256 value43 = this.code.length; if (success21) { uint256 value41 = returnData21.length; if (returnData21.length >= 0x20) { value41 = 0x20; } if (((var_b + ((value41 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value41 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value41 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value41) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value42 = var_b; value43 = 0x20; } require(lockContract.code.length); (bool success22, bytes memory returnData22) = lockContract.lockFor(arg1, value40); // call require(success22); if (!(success22)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b; require(!(0)); return; } if (0x20 > returnData13.length) { if (((var_b + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + returnData13.length) - var_b) >= 0x20); require(var_b.length == var_b.length); (bool success23, bytes memory returnData23) = uniswapV2Router.call(abi.encodeWithSelector(bytes4(0xe8e33700), 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c, address(this), amountADesired, (((amountADesired * value7) / value8) * 0x2774) / 0x2710, 0, 0, address(this), block.timestamp + 0x0258)); // call addLiquidity require(success23); uint256 value45 = this.code.length; if (success23) { uint256 value44 = returnData23.length; if (0x60 <= returnData23.length) { value44 = 0x60; } if (((var_b + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value44) - var_b) >= 0x60); } else { value45 = var_b; } uint256 value46 = this.code.length; if (balanceOf[address(this)] == 0x0) { value46 = balanceOf[address(this)]; } else if (address(this) == address(0)) { totalSupply = totalSupply + balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } else { require(!(balanceOf[address(this)] < balanceOf[address(this)])); balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } (bool success24, bytes memory returnData24) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(address(this)); // staticcall require(success24); uint256 value48 = this.code.length; uint256 value49 = var_b.length; if (success24) { uint256 value47 = returnData24.length; if (0x20 <= returnData24.length) { value47 = 0x20; } if (((var_b + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value47) - var_b) >= 0x20); } else { value48 = var_b; value49 = 0; } uint256 value84 = 0; uint256 value56 = 0x20; if (value49 != 0x0) { if (((var_b + 0x80) > 0xffffffffffffffff) | ((var_b + 0x80) < var_b)) _desolexPanic(65); var_b = var_b + 0x80; (bool success25, bytes memory returnData25) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).transfer(admin, value49); // call if (returnData25.length != 0x0) { if (!(returnData25.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + ((((returnData25.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((((returnData25.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((((returnData25.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success26, bytes memory returnData26) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success26); uint256 value51 = this.code.length; uint256 value52 = var_b.length; if (success26) { uint256 value50 = returnData26.length; if (0x20 <= returnData26.length) { value50 = 0x20; } if (((var_b + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value50) - var_b) >= 0x20); } else { value51 = var_b; value52 = 0; } (bool success27, bytes memory returnData27) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value52)); // call approve require(success27); uint256 value54 = this.code.length; uint256 value55 = this.code.length; if (success27) { uint256 value53 = returnData27.length; if (returnData27.length >= 0x20) { value53 = 0x20; } if (((var_b + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value53) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value54 = var_b; value55 = 0x20; } require(lockContract.code.length); (bool success28, bytes memory returnData28) = lockContract.lockFor(arg1, value52); // call require(success28); if (!(success28)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b; require(!(0)); return; } } else { flag4 = value49 != 0x0; value56 = 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c; } (bool success29, bytes memory returnData29) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success29); uint256 value58 = this.code.length; uint256 value59 = var_b.length; if (success29) { uint256 value57 = returnData29.length; if (0x20 <= returnData29.length) { value57 = 0x20; } if (((var_b + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value57) - var_b) >= 0x20); } else { value58 = var_b; value59 = 0; } (bool success30, bytes memory returnData30) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value59)); // call approve require(success30); uint256 value61 = this.code.length; uint256 value62 = this.code.length; if (success30) { uint256 value60 = returnData30.length; if (returnData30.length >= 0x20) { value60 = 0x20; } if (((var_b + ((value60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value60) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value61 = var_b; value62 = 0x20; } require(lockContract.code.length); lockContract.lockFor(arg1, value59); // call } else { if (((var_b + 0x20) > 0xffffffffffffffff) | ((var_b + 0x20) < var_b)) _desolexPanic(65); var_b = var_b + 0x20; require(((var_b + 0x20) - var_b) >= 0x20); require(var_b.length == var_b.length); (bool success32, bytes memory returnData32) = uniswapV2Router.call(abi.encodeWithSelector(bytes4(0xe8e33700), 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c, address(this), amountADesired, (((amountADesired * value7) / value8) * 0x2774) / 0x2710, 0, 0, address(this), block.timestamp + 0x0258)); // call addLiquidity require(success32); uint256 value64 = this.code.length; if (success32) { uint256 value63 = returnData32.length; if (0x60 <= returnData32.length) { value63 = 0x60; } if (((var_b + ((value63 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value63 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value63 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value63) - var_b) >= 0x60); } else { value64 = var_b; } uint256 value65 = this.code.length; if (balanceOf[address(this)] == 0x0) { value65 = balanceOf[address(this)]; } else if (address(this) == address(0)) { totalSupply = totalSupply + balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } else { require(!(balanceOf[address(this)] < balanceOf[address(this)])); balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)]; if ((admin & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[address(admin)] = balanceOf[address(admin)] + balanceOf[address(this)]; } else { totalSupply = totalSupply - balanceOf[address(this)]; } emit Transfer(address(this), address(admin), balanceOf[address(this)]); } (bool success33, bytes memory returnData33) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(address(this)); // staticcall require(success33); uint256 value67 = this.code.length; uint256 value68 = var_b.length; if (success33) { uint256 value66 = returnData33.length; if (0x20 <= returnData33.length) { value66 = 0x20; } if (((var_b + ((value66 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value66 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value66 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value66) - var_b) >= 0x20); } else { value67 = var_b; value68 = 0; } uint256 value85 = 0; uint256 value75 = 0x20; if (value68 != 0x0) { if (((var_b + 0x80) > 0xffffffffffffffff) | ((var_b + 0x80) < var_b)) _desolexPanic(65); var_b = var_b + 0x80; (bool success34, bytes memory returnData34) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).transfer(admin, value68); // call if (returnData34.length != 0x0) { if (!(returnData34.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + ((((returnData34.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((((returnData34.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((((returnData34.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success35, bytes memory returnData35) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success35); uint256 value70 = this.code.length; uint256 value71 = var_b.length; if (success35) { uint256 value69 = returnData35.length; if (0x20 <= returnData35.length) { value69 = 0x20; } if (((var_b + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value69) - var_b) >= 0x20); } else { value70 = var_b; value71 = 0; } (bool success36, bytes memory returnData36) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value71)); // call approve require(success36); uint256 value73 = this.code.length; uint256 value74 = this.code.length; if (success36) { uint256 value72 = returnData36.length; if (returnData36.length >= 0x20) { value72 = 0x20; } if (((var_b + ((value72 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value72 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value72 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value72) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value73 = var_b; value74 = 0x20; } require(lockContract.code.length); (bool success37, bytes memory returnData37) = lockContract.lockFor(arg1, value71); // call require(success37); if (!(success37)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b; require(!(0)); return; } } else { flag5 = value68 != 0x0; value75 = 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c; } (bool success38, bytes memory returnData38) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success38); uint256 value77 = this.code.length; uint256 value78 = var_b.length; if (success38) { uint256 value76 = returnData38.length; if (0x20 <= returnData38.length) { value76 = 0x20; } if (((var_b + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value76) - var_b) >= 0x20); } else { value77 = var_b; value78 = 0; } (bool success39, bytes memory returnData39) = uniswapPair.call(abi.encodeWithSelector(bytes4(0x095ea7b3), lockContract, value78)); // call approve require(success39); uint256 value80 = this.code.length; uint256 value81 = this.code.length; if (success39) { uint256 value79 = returnData39.length; if (returnData39.length >= 0x20) { value79 = 0x20; } if (((var_b + ((value79 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value79 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value79 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value79) - var_b) >= 0x20); require(var_b.length == var_b.length); } else { value80 = var_b; value81 = 0x20; } require(lockContract.code.length); lockContract.lockFor(arg1, value78); // call } require(success13); if (!(success13)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); require(!(0)); return; } } } } } } } } } } } } } } function Unknown_dc7ac7d2(uint256 arg0) public returns (uint256) { internal_17a2(arg0); return (((arg0 * value7) / value8) * 0x2774) / 0x2710; } function setSellLpRate(uint256 newSellLpRate) public onlyOwner { sellLpRate = newSellLpRate; } function setBuyBurnRate(uint256 newBuyBurnRate) public onlyOwner { buyBurnRate = newBuyBurnRate; } function setInitiallyAddThePoolAddr(address newAddress) public onlyOwner { stor_12 = newAddress; } function wrapEth(uint256 arg0) public { require(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c.code.length != 0x0); (bool success0, bytes memory returnData0) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).deposit{ value: arg0 }(); // call require(success0); if (!(success0)) { return; } if (!(var_b <= 0xffffffffffffffff)) _desolexPanic(65); } function setLockContract(address newAddress) public onlyOwner { require(newAddress != address(0), "Invalid address"); lockContract = newAddress; } function transfer(address to, uint256 amount) public returns (uint256) { require(msg.sender != 0x0, ERC20InvalidSender(address(0))); require(to != address(0), ERC20InvalidReceiver(address(0))); require(!isBlacklisted[msg.sender], "ERC20: sender is blacklisted"); bool flag0 = bytes1(isTaxExempt[to]); if (!(bytes1(isTaxExempt[msg.sender]))) { } else { flag0 = bytes1(isTaxExempt[msg.sender]); } if (flag0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount), ERC20InsufficientBalance(msg.sender, balanceOf[msg.sender], amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); } else { bool flag1 = !(bytes1(isTaxExempt[to])); if (!(bytes1(isTaxExempt[msg.sender]))) { } else { flag1 = !(bytes1(isTaxExempt[msg.sender])); } uint256 value8; uint256 var_d; if (flag1) { uint256 value37 = 0; if (pairs[to]) { (bool success0, bytes memory returnData0) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success0); uint256 value0 = this.code.length; uint256 value1 = var_d.length; uint256 value2 = var_e; if (success0) { if (0x60 > returnData0.length) { if (((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData0.length) - var_d) >= 0x60); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_h == (uint32(var_h))); } else { if (((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x60) - var_d) < 0x60)); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_i == (uint32(var_i))); } } else { value0 = var_d; value1 = 0; value2 = 0; } (bool success1, bytes memory returnData1) = uniswapPair.token0(); // staticcall require(success1); uint256 value3 = this.code.length; uint256 value4 = var_d.length; if (success1) { if (0x20 > returnData1.length) { if (((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData1.length) - var_d) >= 0x20); require(var_d.length == (address(var_d.length))); } else { if (((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x20) - var_d) < 0x20)); require(var_m == (address(var_m))); } } else { value3 = var_d; value4 = 0; } uint256 value5 = value2; if (0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c == (0xffffffffffffffffffffffffffffffffffffffff & value4)) { value5 = value1; } (bool success2, bytes memory returnData2) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(uniswapPair); // staticcall require(success2); uint256 value7 = var_d.length; if (success2) { uint256 value6 = returnData2.length; if (0x20 <= returnData2.length) { value6 = 0x20; } if (((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + value6) - var_d) >= 0x20); } else { value7 = 0; } value37 = (value7 > (uint112(value5))) ? 1 : 0; } value8 = value37; } else { value8 = 0; } uint256 value17; if (pairs[msg.sender]) { (bool success3, bytes memory returnData3) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success3); uint256 value9 = this.code.length; uint256 value10 = var_d.length; uint256 value11 = var_e; if (success3) { if (0x60 > returnData3.length) { if (((var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData3.length) - var_d) >= 0x60); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_h == (uint32(var_h))); } else { if (((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x60) - var_d) < 0x60)); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_i == (uint32(var_i))); } } else { value9 = var_d; value10 = 0; value11 = 0; } (bool success4, bytes memory returnData4) = uniswapPair.token0(); // staticcall require(success4); uint256 value12 = this.code.length; uint256 value13 = var_d.length; if (success4) { if (0x20 > returnData4.length) { if (((var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData4.length) - var_d) >= 0x20); require(var_d.length == (address(var_d.length))); } else { if (((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x20) - var_d) < 0x20)); require(var_m == (address(var_m))); } } else { value12 = var_d; value13 = 0; } uint256 value14 = value11; if (0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c == (0xffffffffffffffffffffffffffffffffffffffff & value13)) { value14 = value10; } (bool success5, bytes memory returnData5) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(uniswapPair); // staticcall require(success5); uint256 value16 = var_d.length; if (success5) { uint256 value15 = returnData5.length; if (0x20 <= returnData5.length) { value15 = 0x20; } if (((var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + value15) - var_d) >= 0x20); } else { value16 = 0; } value17 = (value16 < (uint112(value14))) ? 1 : 0; } else { value17 = 0; } emit OriginLog(msg.sender, to, amount, tx.origin, value8, value17); emit UpdateLog(msg.sender, to, amount, value8, value17); bool flag2 = !(bytes1(isTaxExempt[to])); if (!(bytes1(isTaxExempt[msg.sender]))) { } else { flag2 = !(bytes1(isTaxExempt[msg.sender])); } uint256 value18 = this.code.length; if (!(flag2)) { value18 = 0xffffffffffffffffffffffffffffffffffffffff; } if (!(flag2 && msg.sender != uniswapV2Router)) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); return 0x01; } if (value8 != 0x0) { emit AddThePool(msg.sender, to, amount); if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); return 0x01; } bool flag4 = !(isBlacklisted[to]); if (value17 != 0x0) { } else { flag4 = value17 != 0x0; } if (flag4) { emit RemoveThePool(msg.sender, to, amount); if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); return 0x01; } if (!(!pairs[msg.sender])) { require(isCanBuy, "Buying is prohibited"); if (stor_10_22_22) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); return 0x01; } stor_10_22_22 = true; uint256 value19 = 0; if (!(amount == 0x0)) { require(amount * buyBurnRate / amount == buyBurnRate, "SafeMath: multiplication overflow"); value19 = amount * buyBurnRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if (value19 / 0x2710 != 0x0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < (value19 / 0x2710))); balanceOf[msg.sender] = balanceOf[msg.sender] - (value19 / 0x2710); } else { totalSupply = totalSupply + (value19 / 0x2710); } balanceOf[0xdead] = balanceOf[0xdead] + (value19 / 0x2710); emit Transfer(msg.sender, 0xdead, value19 / 0x2710); if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value19 / 0x2710) > amount) { require(0 < var_w, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { } uint256 value20 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value20 = amount * buyLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value21 = this.code.length; uint256 value22 = (amount - (value19 / 0x2710)) - (value20 / 0x2710); uint256 value23 = (amount - (value19 / 0x2710)) - (value20 / 0x2710); if (value20 / 0x2710 != 0x0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < (value20 / 0x2710))); balanceOf[msg.sender] = balanceOf[msg.sender] - (value20 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value20 / 0x2710); } else { totalSupply = totalSupply - (value20 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value20 / 0x2710)); } else { totalSupply = totalSupply + (value20 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value20 / 0x2710); } else { totalSupply = totalSupply - (value20 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value20 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value20 / 0x2710) > (amount - (value19 / 0x2710))) { require(0 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { } } else { value21 = value20 / 0x2710; value22 = amount - (value19 / 0x2710); value23 = msg.sender; } stor_10_22_22 = false; if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < value22)); balanceOf[msg.sender] = balanceOf[msg.sender] - value22; } else { totalSupply = totalSupply + value22; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value22; } else { totalSupply = totalSupply - value22; } emit Transfer(msg.sender, to, (value22)); } else { uint256 value24 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value24 = amount * buyLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value25 = this.code.length; uint256 value26 = amount - (value24 / 0x2710); uint256 value27 = amount - (value24 / 0x2710); if (value24 / 0x2710 != 0x0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < (value24 / 0x2710))); balanceOf[msg.sender] = balanceOf[msg.sender] - (value24 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value24 / 0x2710); } else { totalSupply = totalSupply - (value24 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value24 / 0x2710)); } else { totalSupply = totalSupply + (value20 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value20 / 0x2710); } else { totalSupply = totalSupply - (value20 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value20 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value24 / 0x2710) > amount) { require(0 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { } } else { value25 = value24 / 0x2710; value26 = amount; value27 = msg.sender; } stor_10_22_22 = false; if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < value26)); balanceOf[msg.sender] = balanceOf[msg.sender] - value26; } else { totalSupply = totalSupply + value26; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value26; } else { totalSupply = totalSupply - value26; } emit Transfer(msg.sender, to, (value26)); } return 0x01; } if (!pairs[to]) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); return 0x01; } require(isCanSell, "Selling is prohibited"); if (stor_10_22_22) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < amount)); balanceOf[msg.sender] = balanceOf[msg.sender] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(msg.sender, to, amount); return 0x01; } stor_10_22_22 = true; uint256 value28 = 0; if (!(amount == 0x0)) { require(amount * buyBurnRate / amount == buyBurnRate, "SafeMath: multiplication overflow"); value28 = amount * sellBurnRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if (value28 / 0x2710 != 0x0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < (value28 / 0x2710))); balanceOf[msg.sender] = balanceOf[msg.sender] - (value28 / 0x2710); } else { totalSupply = totalSupply + (value28 / 0x2710); } balanceOf[0xdead] = balanceOf[0xdead] + (value28 / 0x2710); emit Transfer(msg.sender, 0xdead, value28 / 0x2710); if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value28 / 0x2710) > amount) { require(0 < var_w, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { } uint256 value29 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value29 = amount * sellLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value30 = this.code.length; uint256 value31 = (amount - (value28 / 0x2710)) - (value29 / 0x2710); uint256 value32 = (amount - (value28 / 0x2710)) - (value29 / 0x2710); if (value29 / 0x2710 != 0x0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < (value29 / 0x2710))); balanceOf[msg.sender] = balanceOf[msg.sender] - (value29 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value29 / 0x2710); } else { totalSupply = totalSupply - (value29 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value29 / 0x2710)); } else { totalSupply = totalSupply + (value20 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value20 / 0x2710); } else { totalSupply = totalSupply - (value20 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value20 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value29 / 0x2710) > (amount - (value28 / 0x2710))) { require(0 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { } } else { value30 = value29 / 0x2710; value31 = amount - (value28 / 0x2710); value32 = msg.sender; } stor_10_22_22 = false; if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < value31)); balanceOf[msg.sender] = balanceOf[msg.sender] - value31; } else { totalSupply = totalSupply + value31; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value31; } else { totalSupply = totalSupply - value31; } emit Transfer(msg.sender, to, (value31)); } else { uint256 value33 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value33 = amount * sellLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value34 = this.code.length; uint256 value35 = amount - (value33 / 0x2710); uint256 value36 = amount - (value33 / 0x2710); if (value33 / 0x2710 != 0x0) { if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < (value33 / 0x2710))); balanceOf[msg.sender] = balanceOf[msg.sender] - (value33 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value33 / 0x2710); } else { totalSupply = totalSupply - (value33 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value33 / 0x2710)); } else { totalSupply = totalSupply + (value20 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value20 / 0x2710); } else { totalSupply = totalSupply - (value20 / 0x2710); } emit Transfer(msg.sender, lpAddress, (value20 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value33 / 0x2710) > amount) { require(0 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { } } else { value34 = value33 / 0x2710; value35 = amount; value36 = msg.sender; } stor_10_22_22 = false; if (msg.sender != address(0)) { require(!(balanceOf[msg.sender] < value35)); balanceOf[msg.sender] = balanceOf[msg.sender] - value35; } else { totalSupply = totalSupply + value35; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value35; } else { totalSupply = totalSupply - value35; } emit Transfer(msg.sender, to, (value35)); } } return 0x01; } function Unknown_9a63ad67(uint256 arg0) public onlyOwner { buyLpRate = (arg0) ? 1 : 0; } function symbol() public view returns (string memory) { return _symbol; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(owner, address(0)); owner = address(0); } function setAdmin(address newAddress) public onlyOwner { admin = newAddress; } function setLpAddress(address newAddress) public onlyOwner { lpAddress = newAddress; } function Unknown_5271f968() public returns (bytes memory) { (bool success0, bytes memory returnData0) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success0); uint256 value0 = this.code.length; uint256 value1; uint256 value2; uint256 var_b; if (success0) { uint256 value7 = var_b.length; uint256 value8 = var_c; if (0x60 > returnData0.length) { if (((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + returnData0.length) - var_b) >= 0x60); require(var_b.length == (uint112(var_b.length))); require(var_c == (uint112(var_c))); require(var_d == (uint32(var_d))); } else { if (((var_b + 0x60) > 0xffffffffffffffff) | ((var_b + 0x60) < var_b)) _desolexPanic(65); var_b = var_b + 0x60; require(((var_b + 0x60) - var_b) >= 0x60); require(var_e == (uint112(var_e))); require(var_f == (uint112(var_f))); require(var_d == (uint32(var_d))); value7 = var_h; value8 = var_g; } value1 = value7; value2 = value8; } else { value0 = var_b; value1 = 0; value2 = 0; } (bool success1, bytes memory returnData1) = uniswapPair.token0(); // staticcall require(success1); uint256 value3 = this.code.length; uint256 value4 = var_b.length; if (success1) { if (0x20 > returnData1.length) { if (((var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + returnData1.length) - var_b) >= 0x20); } else { if (((var_b + 0x20) > 0xffffffffffffffff) | ((var_b + 0x20) < var_b)) _desolexPanic(65); var_b = var_b + 0x20; require(((var_b + 0x20) - var_b) >= 0x20); } require(var_b.length == (address(var_b.length))); } else { value3 = var_b; value4 = 0; } uint256 value5 = value2; if (0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c == (0xffffffffffffffffffffffffffffffffffffffff & value4)) { value5 = value1; } (bool success2, bytes memory returnData2) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(uniswapPair); // staticcall require(success2); if (success2) { uint256 value6 = returnData2.length; if (0x20 <= returnData2.length) { value6 = 0x20; } if (((var_b + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value6) - var_b) >= 0x20); return abi.encodePacked(uint112(value5), var_b.length); } else { return abi.encodePacked(uint112(value5), 0); } } function withdrawalToken(address token, address recipient, uint256 amount) public onlyOwner { (bool success0, bytes memory returnData0) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, amount)); // call transfer require(success0); if (!(success0)) { emit WithdrawalToken(token, recipient, amount); return; } uint256 var_d; if (0x20 > returnData0.length) { if (((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData0.length) - var_d) >= 0x20); } else { if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65); var_d = var_d + 0x20; require(((var_d + 0x20) - var_d) >= 0x20); } require(var_d.length == var_d.length); emit WithdrawalToken(token, recipient, amount); } function blacklistBatch(address[] memory accounts, bool enabled) public { require((accounts + 0x23) < msg.data.length); require(!(((accounts + (accounts.length << 0x05)) + 0x24) > msg.data.length)); require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value0 = 0; while (true) { if (!(value0 < accounts.length)) { return; } if (!((value0 < accounts.length))) _desolexPanic(50); if (msg.data[(value0 << 0x05) + (0x24 + accounts)] != (address(msg.data[(value0 << 0x05) + (0x24 + accounts)]))) { revert(); break; } isBlacklisted[address(msg.data[(value0 << 0x05) + (0x24 + accounts)])] = (bytes1(enabled)) | (isBlacklisted[address(msg.data[(value0 << 0x05) + (0x24 + accounts)])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value0 = value0 + 0x01; } } function excludeFromFeeBatch(address[] memory accounts, bool excluded) public { require((accounts + 0x23) < msg.data.length); require(!(((accounts + (accounts.length << 0x05)) + 0x24) > msg.data.length)); require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value0 = 0; while (true) { if (!(value0 < accounts.length)) { return; } if (!(value0 < accounts.length)) { _desolexPanic(50); break; } if (msg.data[(value0 << 0x05) + (0x24 + accounts)] != (address(msg.data[(value0 << 0x05) + (0x24 + accounts)]))) { revert(); break; } isTaxExempt[address(msg.data[(value0 << 0x05) + (0x24 + accounts)])] = (bytes1(excluded)) | (isTaxExempt[address(msg.data[(value0 << 0x05) + (0x24 + accounts)])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value0 = value0 + 0x01; } } function transferFrom(address from, address to, uint256 amount) public payable returns (uint256) { if (!(msg.value)) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x60) { if (from == from) { if (to == to) { if (allowance[from][msg.sender] == type(uint256).max) { require(from != address(0), ERC20InvalidSender(address(0))); require(to != address(0), ERC20InvalidReceiver(address(0))); require(!isBlacklisted[from], "ERC20: sender is blacklisted"); bool flag0 = bytes1(isTaxExempt[to]); if (!(bytes1(isTaxExempt[from]))) { } else { flag0 = bytes1(isTaxExempt[from]); } if (flag0) { if (from != address(0)) { require(!(balanceOf[from] < amount), ERC20InsufficientBalance(from, balanceOf[from], amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); } else { bool flag1 = !(bytes1(isTaxExempt[to])); if (!(bytes1(isTaxExempt[from]))) { } else { flag1 = !(bytes1(isTaxExempt[from])); } uint256 value8; uint256 var_d; if (flag1) { uint256 value42 = 0; if (pairs[to]) { (bool success0, bytes memory returnData0) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success0); uint256 value0 = this.code.length; uint256 value1 = var_d.length; uint256 value2 = var_e; if (success0) { if (0x60 > returnData0.length) { if (((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData0.length) - var_d) >= 0x60); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_h == (uint32(var_h))); } else { if (((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x60) - var_d) < 0x60)); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_i == (uint32(var_i))); } } else { value0 = var_d; value1 = 0; value2 = 0; } (bool success1, bytes memory returnData1) = uniswapPair.token0(); // staticcall require(success1); uint256 value3 = this.code.length; uint256 value4 = var_d.length; if (success1) { if (0x20 > returnData1.length) { if (((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData1.length) - var_d) >= 0x20); require(var_d.length == (address(var_d.length))); } else { if (((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x20) - var_d) < 0x20)); require(var_m == (address(var_m))); } } else { value3 = var_d; value4 = 0; } uint256 value5 = value2; if (0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c == (0xffffffffffffffffffffffffffffffffffffffff & value4)) { value5 = value1; } (bool success2, bytes memory returnData2) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(uniswapPair); // staticcall require(success2); uint256 value7 = var_d.length; if (success2) { uint256 value6 = returnData2.length; if (0x20 <= returnData2.length) { value6 = 0x20; } if (((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + value6) - var_d) >= 0x20); } else { value7 = 0; } value42 = (value7 > (uint112(value5))) ? 1 : 0; } value8 = value42; } else { value8 = 0; } uint256 value17; if (pairs[from]) { (bool success3, bytes memory returnData3) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success3); uint256 value9 = this.code.length; uint256 value10 = var_d.length; uint256 value11 = var_e; if (success3) { if (0x60 > returnData3.length) { if (((var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData3.length) - var_d) >= 0x60); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_h == (uint32(var_h))); } else { if (((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x60) - var_d) < 0x60)); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_i == (uint32(var_i))); } } else { value9 = var_d; value10 = 0; value11 = 0; } (bool success4, bytes memory returnData4) = uniswapPair.token0(); // staticcall require(success4); uint256 value12 = this.code.length; uint256 value13 = var_d.length; if (success4) { if (0x20 > returnData4.length) { if (((var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData4.length) - var_d) >= 0x20); require(var_d.length == (address(var_d.length))); } else { if (((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x20) - var_d) < 0x20)); require(var_m == (address(var_m))); } } else { value12 = var_d; value13 = 0; } uint256 value14 = value11; if (0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c == (0xffffffffffffffffffffffffffffffffffffffff & value13)) { value14 = value10; } (bool success5, bytes memory returnData5) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(uniswapPair); // staticcall require(success5); uint256 value16 = var_d.length; if (success5) { uint256 value15 = returnData5.length; if (0x20 <= returnData5.length) { value15 = 0x20; } if (((var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + value15) - var_d) >= 0x20); } else { value16 = 0; } value17 = (value16 < (uint112(value14))) ? 1 : 0; } else { value17 = 0; } emit OriginLog(from, to, amount, tx.origin, value8, value17); emit UpdateLog(from, to, amount, value8, value17); bool flag2 = !(bytes1(isTaxExempt[to])); if (!(bytes1(isTaxExempt[from]))) { } else { flag2 = !(bytes1(isTaxExempt[from])); } uint256 value18 = this.code.length; if (!(flag2)) { value18 = 0xffffffffffffffffffffffffffffffffffffffff; } if (!(flag2 && from != uniswapV2Router)) { if (from != address(0)) { require(!(balanceOf[from] < amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } if (value8 != 0x0) { emit AddThePool(from, to, amount); if (from != address(0)) { require(!(balanceOf[from] < amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } bool flag4 = !(isBlacklisted[to]); if (value17 != 0x0) { } else { flag4 = value17 != 0x0; } if (flag4) { emit RemoveThePool(from, to, amount); if (from != address(0)) { require(!(balanceOf[from] < amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } if (!(!pairs[from])) { require(isCanBuy, "Buying is prohibited"); if (stor_10_22_22) { if (from != address(0)) { require(!(balanceOf[from] < amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } stor_10_22_22 = true; uint256 value19 = 0; if (!(amount == 0x0)) { require(amount * buyBurnRate / amount == buyBurnRate, "SafeMath: multiplication overflow"); value19 = amount * buyBurnRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if (value19 / 0x2710 != 0x0) { if (from != address(0)) { require(!(balanceOf[from] < (value19 / 0x2710))); balanceOf[from] = balanceOf[from] - (value19 / 0x2710); } else { totalSupply = totalSupply + (value19 / 0x2710); } balanceOf[0xdead] = balanceOf[0xdead] + (value19 / 0x2710); emit Transfer(from, 0xdead, value19 / 0x2710); if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value19 / 0x2710) > amount) { uint256 value20 = 0; while (true) { require(value20 < var_w, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); value20 = 0x20 + value20; } } else { } uint256 value21 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value21 = amount * buyLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value22 = this.code.length; uint256 value23 = (amount - (value19 / 0x2710)) - (value21 / 0x2710); uint256 value24 = (amount - (value19 / 0x2710)) - (value21 / 0x2710); if (value21 / 0x2710 != 0x0) { if (from != address(0)) { require(!(balanceOf[from] < (value21 / 0x2710))); balanceOf[from] = balanceOf[from] - (value21 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value21 / 0x2710); } else { totalSupply = totalSupply - (value21 / 0x2710); } emit Transfer(from, lpAddress, (value21 / 0x2710)); } else { totalSupply = totalSupply + (value21 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value21 / 0x2710); } else { totalSupply = totalSupply - (value21 / 0x2710); } emit Transfer(from, lpAddress, (value21 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value21 / 0x2710) > (amount - (value19 / 0x2710))) { uint256 value20 = 0; while (true) { require(value20 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); value20 = 0x20 + value20; } } else { } } else { value22 = value21 / 0x2710; value23 = amount - (value19 / 0x2710); value24 = from; } stor_10_22_22 = false; if (from != address(0)) { require(!(balanceOf[from] < value23)); balanceOf[from] = balanceOf[from] - value23; } else { totalSupply = totalSupply + value23; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value23; } else { totalSupply = totalSupply - value23; } emit Transfer(from, to, (value23)); } else { uint256 value25 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value25 = amount * buyLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value26 = this.code.length; uint256 value27 = amount - (value25 / 0x2710); uint256 value28 = amount - (value25 / 0x2710); if (value25 / 0x2710 != 0x0) { if (from != address(0)) { require(!(balanceOf[from] < (value25 / 0x2710))); balanceOf[from] = balanceOf[from] - (value25 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value25 / 0x2710); } else { totalSupply = totalSupply - (value25 / 0x2710); } emit Transfer(from, lpAddress, (value25 / 0x2710)); } else { totalSupply = totalSupply + (value21 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value21 / 0x2710); } else { totalSupply = totalSupply - (value21 / 0x2710); } emit Transfer(from, lpAddress, (value21 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value25 / 0x2710) > amount) { uint256 value20 = 0; while (true) { require(value20 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); value20 = 0x20 + value20; } } else { } } else { value26 = value25 / 0x2710; value27 = amount; value28 = from; } stor_10_22_22 = false; if (from != address(0)) { require(!(balanceOf[from] < value27)); balanceOf[from] = balanceOf[from] - value27; } else { totalSupply = totalSupply + value27; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value27; } else { totalSupply = totalSupply - value27; } emit Transfer(from, to, (value27)); } return 0x01; } if (!pairs[to]) { if (from != address(0)) { require(!(balanceOf[from] < amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } require(isCanSell, "Selling is prohibited"); if (stor_10_22_22) { if (from != address(0)) { require(!(balanceOf[from] < amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } stor_10_22_22 = true; uint256 value29 = 0; if (!(amount == 0x0)) { require(amount * buyBurnRate / amount == buyBurnRate, "SafeMath: multiplication overflow"); value29 = amount * sellBurnRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if (value29 / 0x2710 != 0x0) { if (from != address(0)) { require(!(balanceOf[from] < (value29 / 0x2710))); balanceOf[from] = balanceOf[from] - (value29 / 0x2710); } else { totalSupply = totalSupply + (value29 / 0x2710); } balanceOf[0xdead] = balanceOf[0xdead] + (value29 / 0x2710); emit Transfer(from, 0xdead, value29 / 0x2710); if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value29 / 0x2710) > amount) { uint256 value20 = 0; while (true) { require(value20 < var_w, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); value20 = 0x20 + value20; } } else { } uint256 value30 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value30 = amount * sellLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value31 = this.code.length; uint256 value32 = (amount - (value29 / 0x2710)) - (value30 / 0x2710); uint256 value33 = (amount - (value29 / 0x2710)) - (value30 / 0x2710); if (value30 / 0x2710 != 0x0) { if (from != address(0)) { require(!(balanceOf[from] < (value30 / 0x2710))); balanceOf[from] = balanceOf[from] - (value30 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value30 / 0x2710); } else { totalSupply = totalSupply - (value30 / 0x2710); } emit Transfer(from, lpAddress, (value30 / 0x2710)); } else { totalSupply = totalSupply + (value21 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value21 / 0x2710); } else { totalSupply = totalSupply - (value21 / 0x2710); } emit Transfer(from, lpAddress, (value21 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value30 / 0x2710) > (amount - (value29 / 0x2710))) { uint256 value20 = 0; while (true) { require(value20 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); value20 = 0x20 + value20; } } else { } } else { value31 = value30 / 0x2710; value32 = amount - (value29 / 0x2710); value33 = from; } stor_10_22_22 = false; if (from != address(0)) { require(!(balanceOf[from] < value32)); balanceOf[from] = balanceOf[from] - value32; } else { totalSupply = totalSupply + value32; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value32; } else { totalSupply = totalSupply - value32; } emit Transfer(from, to, (value32)); } else { uint256 value34 = 0; if (!(amount == 0x0)) { require(amount * buyLpRate / amount == buyLpRate, "SafeMath: multiplication overflow"); value34 = amount * sellLpRate; } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; uint256 value35 = this.code.length; uint256 value36 = amount - (value34 / 0x2710); uint256 value37 = amount - (value34 / 0x2710); if (value34 / 0x2710 != 0x0) { if (from != address(0)) { require(!(balanceOf[from] < (value34 / 0x2710))); balanceOf[from] = balanceOf[from] - (value34 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value34 / 0x2710); } else { totalSupply = totalSupply - (value34 / 0x2710); } emit Transfer(from, lpAddress, (value34 / 0x2710)); } else { totalSupply = totalSupply + (value21 / 0x2710); if ((lpAddress & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { balanceOf[lpAddress] = balanceOf[lpAddress] + (value21 / 0x2710); } else { totalSupply = totalSupply - (value21 / 0x2710); } emit Transfer(from, lpAddress, (value21 / 0x2710)); } if (((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d)) _desolexPanic(65); var_d = var_d + 0x40; if ((value34 / 0x2710) > amount) { uint256 value20 = 0; while (true) { require(value20 < var_af, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); value20 = 0x20 + value20; } } else { } } else { value35 = value34 / 0x2710; value36 = amount; value37 = from; } stor_10_22_22 = false; if (from != address(0)) { require(!(balanceOf[from] < value36)); balanceOf[from] = balanceOf[from] - value36; } else { totalSupply = totalSupply + value36; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + value36; } else { totalSupply = totalSupply - value36; } emit Transfer(from, to, (value36)); } } return 0x01; } if (allowance[from][msg.sender] >= amount) { if (from != address(0)) { if (msg.sender != address(0)) { allowance[from][msg.sender] = allowance[from][msg.sender] - amount; if (from != address(0)) { require(to != address(0), ERC20InvalidReceiver(address(0))); require(!isBlacklisted[from], "ERC20: sender is blacklisted"); bool flag5 = bytes1(isTaxExempt[to]); if (!(bytes1(isTaxExempt[from]))) { } else { flag5 = bytes1(isTaxExempt[from]); } if (flag5) { if (from != address(0)) { require(!(balanceOf[from] < amount), ERC20InsufficientBalance(from, balanceOf[from], amount)); balanceOf[from] = balanceOf[from] - amount; } else { totalSupply = totalSupply + amount; } if (to != address(0)) { balanceOf[to] = balanceOf[to] + amount; } else { totalSupply = totalSupply - amount; } emit Transfer(from, to, amount); return 0x01; } else { bool flag6 = !(bytes1(isTaxExempt[to])); if (!(bytes1(isTaxExempt[from]))) { } else { flag6 = !(bytes1(isTaxExempt[from])); } if (!(flag6)) { if (pairs[from]) { (bool success6, bytes memory returnData6) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves if (success6) { uint256 value38 = this.code.length; uint256 value39 = var_d.length; uint256 value40 = var_e; if (success6) { if (0x60 > returnData6.length) { if (((var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + returnData6.length) - var_d) >= 0x60); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_h == (uint32(var_h))); } else { if (((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + 0x60) - var_d) < 0x60)); require(var_f == (uint112(var_f))); require(var_g == (uint112(var_g))); require(var_i == (uint32(var_i))); } } else { value38 = var_d; value39 = 0; value40 = 0; } (bool success7, bytes memory returnData7) = uniswapPair.token0(); // staticcall if (success7 && !(success7)) { uint256 value41 = value40; if (0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c == 0) { value41 = value39; } address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).balanceOf(uniswapPair); // staticcall } } } } } } } } } } } } } } function withdrawEth(address arg0, uint256 arg1) public onlyOwner { require(address(this).balance >= arg1, "Insufficient BNB"); uint256 value0 = 0x08fc; if (arg1 != 0x0) { value0 = 0; } (bool success0, bytes memory returnData0) = arg0.call{ value: arg1 }(""); // call require(success0); emit WithdrawalToken(address(0), arg0, arg1); } function Unknown_14ad4bb0(bool arg0) public onlyOwner { isCanSell = arg0; } function approve(address spender, uint256 amount) public returns (bool) { require(msg.sender != address(0), ERC20InvalidApprover(address(0))); require(spender != address(0), ERC20InvalidSpender(address(0))); allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, allowance[msg.sender][spender]); return true; } function name() public view returns (string memory) { return _name; } function setIsCanBuy(bool arg0) public onlyOwner { isCanBuy = arg0; } function internal_17a2(uint256 arg0) private { // Decompilation incomplete: helper effect provenance is conservative. (bool success0, bytes memory returnData0) = uniswapPair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success0); uint256 value1 = 0x20; uint256 value2 = var_c; uint256 value6 = var_d; uint256 var_b; if (success0) { uint256 value0 = returnData0.length; if (0x60 <= returnData0.length) { value0 = 0x60; } if (((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value0) - var_b) >= 0x60); require(var_e == (uint112(var_e))); require(var_f == (uint112(var_f))); require(var_g == (uint32(var_g))); } else { value1 = var_b; value2 = 0; value6 = 0; } (bool success1, bytes memory returnData1) = uniswapPair.token0(); // staticcall require(success1); uint256 value4 = this.code.length; uint256 value5 = var_b.length; if (success1) { uint256 value3 = returnData1.length; if (0x20 <= returnData1.length) { value3 = 0x20; } if (((var_b + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_b + value3) - var_b) >= 0x20); require(var_b.length == (address(var_b.length))); } else { value4 = var_b; value5 = 0; } uint256 value7 = uint112(value2); uint256 value8 = uint112(value6); if ((value5 & 0xffffffffffffffffffffffffffffffffffffffff) == 0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c) { value7 = uint112(value6); value8 = uint112(value2); } require(arg0 != 0x0, "PancakeLibrary: INSUFFICIENT_AMOUNT"); require(value8 != 0x0 && value7 != 0x0, "PancakeLibrary: INSUFFICIENT_LIQUIDITY"); } function __desolexSelectorShim(uint32 rewrittenSelector) private { assembly { let input := mload(0x40) calldatacopy(input, 0, calldatasize()) mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff)))) let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0) let size := returndatasize() returndatacopy(input, 0, size) switch success case 0 { revert(input, size) } default { return(input, size) } } } // Note: This selector table is synthetic and is not part of the original Solidity source. // It records the recovered selector-to-signature mapping without executable behavior. // 0x01dc0f12 => setIsCanBuy(bool) // 0x06fdde03 => name() // 0x095ea7b3 => approve(address,uint256) // 0x14ad4bb0 => Unknown_14ad4bb0(bool) // 0x1694505e => uniswapV2Router() // 0x16c2be6b => isTaxExempt(address) // 0x18160ddd => totalSupply() // 0x1b9a91a4 => withdrawEth(address,uint256) // 0x206b8b2a => buyBurnRate() // 0x23b872dd => transferFrom(address,address,uint256) // 0x3079ddc3 => isCanBuy() // 0x30afaabb => excludeFromFeeBatch(address[],bool) // 0x313ce567 => decimals() // 0x377b2009 => isCanSell() // 0x37f89a26 => blacklistBatch(address[],bool) // 0x3c3cb515 => withdrawalToken(address,address,uint256) // 0x5271f968 => Unknown_5271f968() // 0x5d7b2ffc => buyLpRate() // 0x62f3765e => BASE_PERCENT() // 0x67c64ec5 => sellLpRate() // 0x6f5e0212 => setLpAddress(address) // 0x704b6c02 => setAdmin(address) // 0x70a08231 => balanceOf(address) // 0x715018a6 => renounceOwnership() // 0x753868e3 => lockContract() // 0x83f53259 => addLiquidityUnlockTime(address) // 0x8da5cb5b => owner() // 0x95d89b41 => symbol() // 0x9a63ad67 => Unknown_9a63ad67(uint256) // 0x9b4dc8cc => lpAddress() // 0xa9059cbb => transfer(address,uint256) // 0xac71fce5 => uniswapV2RouterContractAddress() // 0xacd487c2 => setLockContract(address) // 0xae9779c6 => wrapEth(uint256) // 0xb3b640df => bnbTokenAddress() // 0xb3e15577 => setInitiallyAddThePoolAddr(address) // 0xbd3d544b => setBuyBurnRate(uint256) // 0xc816841b => uniswapPair() // 0xcc9cf5b4 => setSellLpRate(uint256) // 0xdc7ac7d2 => Unknown_dc7ac7d2(uint256) // 0xdd62ed3e => allowance(address,address) // 0xdf0a7bd7 => Unknown_df0a7bd7(uint256,address) // 0xe0934e4b => sellBurnRate() // 0xf2fde38b => transferOwnership(address) // 0xf4663235 => BLACK_ADDRESS() // 0xf851a440 => admin() // 0xfe11f240 => setSellBurnRate(uint256) // 0xfe33b302 => pairs(address) // 0xfe575a87 => isBlacklisted(address)}