BNB Chain
0xac87667ecab980c7cfbd51ba8b2bc8cc2052d086
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xac87667e…2052d08617.5 KB29.7 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xac87667ecab980c7cfbd51ba8b2bc8cc2052d086
2,692 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;interface IDesolexERC20 { function balanceOf(address account) external view returns (uint256 balance); function transfer(address recipient, uint256 amount) external returns (bool success); function approve(address spender, uint256 amount) external returns (bool success);}interface IDesolexUniswapV2Pair { function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);}contract DesolexContract { address public constant v3Router = address(0x1b81d678ffb9c0263b24a97847620c99d213eb14); address public constant owner = address(0x42d73da3daca18374ee1ab8d700351350a3b0064); address public constant WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c; address public constant v2Router = address(0x10ed43c718714eb63d5aa57b78b54704e256024e); uint256 public constant MAX_TRANSFER_TAX_BPS = 325; address public constant SMART_ROUTER = address(0x13f4ea83d0bd40e75c8222255bc855a974568dd4); mapping(address => uint256) mapping_0; // STORAGE[0x0] mapping(bytes32 => bytes32) mapping_1; // STORAGE[0x1] // DESOLEX_RAW_STORAGE: whole slot: array [Layout] vs mapping [Layout] (ambiguous) mapping(bytes32 => bytes32) mapping_2; // STORAGE[0x2] // DESOLEX_RAW_STORAGE: whole slot: array [Layout] vs mapping [Layout] (ambiguous) mapping(address => bool) mapping_3; // STORAGE[0x3] mapping(address => bool) mapping_4; // STORAGE[0x4] mapping(address => uint256) public unresolved_1ed8a376; // STORAGE[0x5] uint256 stor_expr_a; bytes32 stor_expr_aa; uint256 stor_expr_ab; bytes32 stor_expr_af; bool stor_expr_ai; bytes32 stor_expr_aj; // DESOLEX_RAW_STORAGE: whole slot: uint248 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous) uint256 stor_expr_al; uint256 stor_expr_am; uint256 stor_expr_ap; bool stor_expr_at; bytes32 stor_expr_au; // DESOLEX_RAW_STORAGE: whole slot: uint248 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous) uint256 stor_expr_aw; uint256 stor_expr_ax; uint256 stor_expr_ba; bool stor_expr_be; uint256 stor_expr_bh; uint256 stor_expr_bk; uint256 stor_expr_bn; uint256 stor_expr_bq; bytes32 stor_expr_bu; bytes32 stor_expr_bv; uint256 stor_expr_c; uint256 stor_expr_j; address stor_expr_k; uint256 stor_expr_l; bytes32 stor_expr_m; // DESOLEX_RAW_STORAGE: whole slot: uint248 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous) uint256 stor_expr_o; bytes32 stor_expr_p; // DESOLEX_RAW_STORAGE: whole slot: address [LegacyInference] vs uint256 [LegacyInference] (ambiguous) address stor_expr_q; uint256 stor_expr_r; uint256 stor_expr_s; uint256 stor_expr_v; bytes32 stor_expr_w; bytes32 stor_expr_x; error CustomError_ca63a25a(); error BadFill(); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } receive() external payable { } fallback() external { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x2c319749)) { // Route to Unknown_2c319749(address,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x70e78409)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x3afdde16)) { // Route to Unknown_3afdde16(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0xd71516f5)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x3c50b4a8)) { // Route to Unknown_3c50b4a8(bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x00f599a6)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x510dc341)) { // Route to Unknown_510dc341(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0xb5f966a8)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x529cf2e4)) { // Route to Unknown_529cf2e4(address,uint256,address,uint64) after replacing only msg.sig. __desolexSelectorShim(uint32(0x372b15f1)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x7fd782db)) { // Route to Unknown_7fd782db(address,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0xf634989a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x824f3e22)) { // Route to Unknown_824f3e22(address,uint256,address,uint64,uint16,uint16) after replacing only msg.sig. __desolexSelectorShim(uint32(0xcdbe11af)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x85e293e0)) { // Route to Unknown_85e293e0(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x25cec185)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x9689148d)) { // Route to Unknown_9689148d(address,uint24) after replacing only msg.sig. __desolexSelectorShim(uint32(0x637ea26a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x97f7c960)) { // Route to Unknown_97f7c960(address,uint24,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xcaf4211c)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xce1bc5c5)) { // Route to Unknown_ce1bc5c5(address,uint256,uint64) after replacing only msg.sig. __desolexSelectorShim(uint32(0x20ed58aa)); return; } revert(); } function getPosition(address account) public view returns (bool) { return abi.encodePacked(!(!(bytes1(stor_expr_a / 0x01000000000000000000000000000000000000000000000000))), mapping_0[account], address(stor_expr_c), address(stor_expr_c / 0x0100000000000000000000000000000000), address(stor_expr_a), uint16(stor_expr_a / 0x010000000000000000000000000000000000000000000000000000), uint16(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000000000), bytes1(stor_expr_a / 0x01000000000000000000000000000000000000000000000000000000000000), bytes1(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000000000000000)); } function getPositions(address[] memory arg0) public view returns (bytes memory) { if (arg0.length > 0xffffffffffffffff) _desolexPanic(65); address[] var_a = arg0; uint256 var_b; var_b = var_b + (0x20 + (0x20 * arg0.length)); uint256 value0 = arg0; if (arg0 != 0x0) { value0 = (arg0.length * 0x20) + (0x20 + var_b); } if (arg0.length > 0xffffffffffffffff) _desolexPanic(65); address[] var_d = arg0; var_b = var_b + (0x20 + (0x20 * arg0.length)); uint256 value1 = arg0; if (arg0 != 0x0) { value1 = (arg0.length * 0x20) + (0x20 + var_b); } if (arg0.length > 0xffffffffffffffff) _desolexPanic(65); address[] var_e = arg0; var_b = var_b + (0x20 + (0x20 * arg0.length)); uint256 value2 = arg0; if (arg0 != 0x0) { value2 = (arg0.length * 0x20) + (0x20 + var_b); } uint256 value3 = 0; while (true) { if (!(value3 < arg0.length)) { break; } if (!(value3 < var_b.length)) _desolexPanic(50); if (!(value3 < var_b.length)) _desolexPanic(50); if (!(value3 < var_b.length)) _desolexPanic(50); value3 = 0x01 + value3; } uint256 value4 = 0; uint256 value5 = var_b + 0x80; uint256 value6 = var_b + 0x20; while (true) { if (!(value4 < var_b.length)) { break; } value4 = 0x01 + value4; value5 = value5 + 0x20; value6 = 0x20 + value6; } uint256 value7 = 0; uint256 value8 = var_b + 0x20; uint256 value9 = (var_b + 0x80) + 0x20; while (true) { if (!(value7 < var_b.length)) { break; } value7 = 0x01 + value7; value8 = value8 + 0x20; value9 = 0x20 + value9; } value7 = 0; value8 = var_b + 0x20; value9 = ((var_b + 0x80) + 0x20) + 0x20; while (true) { if (!(value7 < var_b.length)) { break; } value7 = 0x01 + value7; value8 = value8 + 0x20; value9 = 0x20 + value9; return abi.encodePacked(0x60, value5 - var_b, value9 - var_b, var_b.length, var_b.length, var_b.length); } } function Unknown_2c319749(address token, uint256 arg1, uint256 arg2, bytes memory arg3) public returns (uint256) { require(!(((0x04 + arg3) + arg3 + 0x20) > msg.data.length)); require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); bool flag0 = !(token); if (token != address(0)) { var_a = var_a; flag0 = var_a == token; } bool flag1 = flag0; if (!(flag0)) { flag1 = arg1 == 0x0; } bool flag2 = flag1; if (!(flag1)) { flag2 = arg2 == 0x0; } require(!(flag2 || arg3.length < 0x4), CustomError_ca63a25a()); require(0x5ae401dc00000000000000000000000000000000000000000000000000000000 == ((0x20 + arg3) & (0xffffffff00000000000000000000000000000000000000000000000000000000)), CustomError_ca63a25a()); var_a = var_a; uint256 accountBalance = IDesolexERC20(var_a).balanceOf(address(this)); require(!(accountBalance < arg1), BadFill()); uint256 beforeBalance = IDesolexERC20(token).balanceOf(address(this)); (bool success2, bytes memory returnData2) = address(0x13f4ea83d0bd40e75c8222255bc855a974568dd4).call(""); // call uint256 value0 = 0x60; uint256 var_d; if (returnData2.length != 0) { var_d = var_d + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_d; } if (!(success2)) { require(0x0 != var_i, CustomError_ca63a25a()); revert(); } var_a = var_a; (bool success3, bytes memory returnData3) = var_a.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success3); var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData3.length) - var_d) < 0x20)); bool flag4 = var_d.length > accountBalance; if (!(var_d.length > accountBalance)) { flag4 = (accountBalance - var_d.length) > arg1; } require(!flag4, CustomError_ca63a25a()); uint256 afterBalance = IDesolexERC20(token).balanceOf(address(this)); require(!(afterBalance < beforeBalance), CustomError_ca63a25a()); require(!((afterBalance - beforeBalance) < arg2), BadFill()); if (0x0 == unresolved_1ed8a376[token]) { unresolved_1ed8a376[token] = afterBalance - beforeBalance; } if (!mapping_3[token]) { IDesolexERC20(token).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); require(approvalSucceeded == approvalSucceeded); IDesolexERC20(token).approve(0x1b81d678ffb9c0263b24a97847620c99d213eb14, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); require(approvalSucceeded1 == approvalSucceeded1); mapping_3[token] = true; } return afterBalance - beforeBalance; } function withdraw(uint256 arg0) public { internal_d6e(arg0); } function Unknown_3afdde16(address token) public returns (bytes memory) { uint256 accountBalance = IDesolexERC20(token).balanceOf(address(this)); return abi.encodePacked(accountBalance, unresolved_1ed8a376[token]); } function Unknown_3c50b4a8(bytes memory arg0) public { require(!(((0x04 + arg0) + (arg0.length << 0x07) + 0x20) > msg.data.length)); require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); uint256 value0 = 0; while (true) { if (value0 >= arg0.length) { break; } require(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] == (msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(bytes1(stor_expr_j / 0x01000000000000000000000000000000000000000000000000))) { require(0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x60 - (0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x40) >= 0x20); require((msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]) == ((msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]) & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 var_d; if (stor_expr_k != 0x0) { require(0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x40 - (0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x20) >= 0x20); require(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20] == (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))); } else { (bool success0, bytes memory returnData0) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).token0(); // staticcall require(success0); var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData0.length) - var_d >= 0x20); require(var_e == (var_e & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value2 = msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]; if (!(address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]))) { var_a = var_a; value2 = var_a; } if (address(var_f) - (address(value2)) != 0) { stor_expr_l = 0x0100000000000000000000000000000000000000000000000000 | (var_f & (0xffffffffffffffffffffffffffffffffffffffff) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & stor_expr_l)); } else { (bool success1, bytes memory returnData1) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).token1(); // staticcall require(success1); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData1.length) - var_d >= 0x20); require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff)); stor_expr_l = (address(var_f)) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & stor_expr_l); } require(0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x40 - (0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x20) >= 0x20); require(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20] == (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))); } require(0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x80 - (0x80 * value0 + (0x20 + (0x04 + arg0)) + 0x60) >= 0x20); require(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60] == (uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]))); if (!(uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) { break; } if (!(address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]))) { break; } (bool success2, bytes memory returnData2) = address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]).balanceOf(address(this)); // staticcall require(success2); var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData2.length) - var_d >= 0x20); if (0 - var_f != 0) { break; if (!(var_f < (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))) { (bool success3, bytes memory returnData3) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).getReserves(); // staticcall require(success3); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData3, (uint112, uint112, uint32)); uint256 value4 = uint112(var_f); uint256 value5 = uint112(var_p); if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { value4 = uint112(var_p); value5 = uint112(var_f); } if (0 != (((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))))) { if (0 == mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]) { mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = ((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))); } else if (((0x26f7 * uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])) * value4) / ((0x2710 * value5) + (0x26f7 * uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) <= mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]) { mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = ((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))); } else { if (!((0x2710 * (((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))) - mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])])) / mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] < (uint16(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60])))) { if (!(!(address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40])))) { uint256 value6 = 0; if (0 != 0) { uint256 accountBalance_4 = IDesolexERC20(stor_expr_k).balanceOf(address(this)); value6 = accountBalance_4; } if (!(!(!(address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]))))) { var_a = var_a; (bool success5, bytes memory returnData5) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))); // call transfer require(success5); var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData5.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success6, bytes memory returnData6) = address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]).transfer(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])); // call require(success6); var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData6.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success7, bytes memory returnData7) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(0, (((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))))), address(this), 0x80); // call require(success7); } else { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success8, bytes memory returnData8) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))), 0, address(this), 0x80); // call require(success8); } break; } var_a = var_a; uint256 accountBalance = IDesolexERC20(var_a).balanceOf(address(this)); if (0 - accountBalance != 0) { if (!(accountBalance < (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))) { uint256 value7 = 0; if (0 != 0) { uint256 accountBalance_11 = IDesolexERC20(stor_expr_k).balanceOf(address(this)); value7 = accountBalance_11; } if (!(!(!(address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]))))) { var_a = var_a; (bool success12, bytes memory returnData12) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))); // call transfer require(success12); var_d = var_d + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData12.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success13, bytes memory returnData13) = address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]).transfer(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])); // call require(success13); var_d = var_d + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData13.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success15, bytes memory returnData15) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(0, (((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))))), address(this), 0x80); // call require(success15); } else { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success16, bytes memory returnData16) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))), 0, address(this), 0x80); // call require(success16); } uint256 value11 = ((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))); require(value11 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); stor_expr_o = (address(value11) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & stor_expr_o); stor_expr_p = (address(uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])) * 0x0100000000000000000000000000000000) | (stor_expr_q); stor_expr_r = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = ((!(!(bytes1(stor_expr_r / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (uint16(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (uint16(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (bytes1(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_m = (bytes1(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(stor_expr_m)); stor_expr_s = ((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))); mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = (0 * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]); uint256 value12 = 0; value12 = 0; mapping_1[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = (mapping_1[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value12)); } else { (bool success18, bytes memory returnData18) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).getReserves(); // staticcall require(success18); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData18, (uint112, uint112, uint32)); uint256 value13 = (0x26f7 * accountBalance) * (uint112(var_f)) / ((0x2710 * (uint112(var_p))) + (0x26f7 * accountBalance)); uint256 value14 = uint112(var_f); uint256 value15 = uint112(var_p); if (bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000) != 0x0) { } else { value13 = (0x26f7 * accountBalance) * (uint112(var_p)) / ((0x2710 * (uint112(var_f))) + (0x26f7 * accountBalance)); value14 = uint112(var_p); value15 = uint112(var_f); } if (0x0 != value13) { uint256 value16 = 0; if (0 != 0) { uint256 accountBalance_19 = IDesolexERC20(stor_expr_k).balanceOf(address(this)); value16 = accountBalance_19; } if (!(!(!(address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]))))) { var_a = var_a; (bool success20, bytes memory returnData20) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), accountBalance)); // call transfer require(success20); var_d = var_d + ((returnData20.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData20.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success21, bytes memory returnData21) = address(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x40]).transfer(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), accountBalance); // call require(success21); var_d = var_d + ((returnData21.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData21.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success23, bytes memory returnData23) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(0, (((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))))), address(this), 0x80); // call require(success23); } else { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success24, bytes memory returnData24) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))), 0, address(this), 0x80); // call require(success24); } uint256 value20 = value13; require(value20 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); stor_expr_o = (address(value20) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & stor_expr_o); stor_expr_p = (address(accountBalance) * 0x0100000000000000000000000000000000) | (stor_expr_q); stor_expr_r = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = ((!(!(bytes1(stor_expr_r / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (uint16(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (uint16(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_r = (bytes1(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_r); stor_expr_m = (bytes1(uint64(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x60]) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(stor_expr_m)); stor_expr_s = value13; mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = (0 * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]); uint256 value21 = 0; value21 = 0; mapping_1[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = (mapping_1[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value21)); } } } } else { mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = ((0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20]))) * value4) / ((0x2710 * value5) + (0x26f7 * (uint96(msg.data[((0x80 * value0) + (0x20 + (0x04 + arg0))) + 0x20])))); } } } } } } else { if (0x0 != (address(stor_expr_v))) { uint256 value22 = address(stor_expr_v); if (uint16(mapping_1[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])])) { value22 = ((0x2710 - (uint16(mapping_1[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]))) * (address(stor_expr_v))) / 0x2710; } (bool success26, bytes memory returnData26) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).getReserves(); // staticcall require(success26); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData26, (uint112, uint112, uint32)); uint256 value23 = uint112(var_p); uint256 value24 = uint112(var_f); if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { value23 = uint112(var_f); value24 = uint112(var_p); } if (0 != (((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)))) { bool flag4 = ((((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)) * 0x2710) / (address(stor_expr_v / 0x0100000000000000000000000000000000))) < (uint16(stor_expr_j / 0x010000000000000000000000000000000000000000000000000000) + 0x2710); if ((((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)) * 0x2710) / (address(stor_expr_v / 0x0100000000000000000000000000000000)) < (uint16(stor_expr_j / 0x010000000000000000000000000000000000000000000000000000) + 0x2710)) { flag4 = (uint16(stor_expr_j / 0x0100000000000000000000000000000000000000000000000000000000) + ((((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)) * 0x2710) / (address(stor_expr_v / 0x0100000000000000000000000000000000)))) > 0x2710; } if (!flag4) { if (!(bytes1(mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]))) { IDesolexERC20(stor_expr_k).transfer(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint256(stor_expr_v)); } else { var_d = var_d + 0x64; (bool success28, bytes memory returnData28) = stor_expr_k.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ay, var_az)); // call transfer uint256 value25 = 0x60; if (returnData28.length != 0) { var_d = var_d + ((returnData28.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value25 = var_d; } uint256 value26 = success28; if (success28) { uint256 value42 = !var_ba; if (var_ba != 0x0) { require(((0x20 + value25) + var_ba) - (0x20 + value25) >= 0x20); require(var_ai == (var_ai != 0x0)); value42 = var_bb; } value26 = value42; } require(value26 != 0x0, "token transfer fail"); } uint256 value29 = ((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)); if (bytes1(mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])])) { (bool success29, bytes memory returnData29) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).getReserves(); // staticcall require(success29); var_d = var_d + ((returnData29.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData29.length) - var_d >= 0x60); require(var_bc == (uint32(var_bc))); uint256 value27 = uint112(var_p); uint256 value28 = uint112(var_f); if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { value27 = uint112(var_f); value28 = uint112(var_p); } uint256 accountBalance_30 = IDesolexERC20(stor_expr_w).balanceOf(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])); require(accountBalance_30 > value28, "0 taxed in"); require(((0x26f7 * (accountBalance_30 - value28)) * value27) / ((0x2710 * value28) + (0x26f7 * (accountBalance_30 - value28))) > 0, "0 taxed out"); value29 = ((0x26f7 * (accountBalance_30 - value28)) * value27) / ((0x2710 * value28) + (0x26f7 * (accountBalance_30 - value28))); } if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success31, bytes memory returnData31) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(value29, 0, address(this), 0x80); // call require(success31); } else { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success32, bytes memory returnData32) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(0, value29, address(this), 0x80); // call require(success32); } stor_expr_x = 0; stor_expr_l = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_l; mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = 0; mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; } else { if (0x0 != (uint32(stor_expr_j / 0x010000000000000000000000000000000000000000))) { if (!((block.timestamp - (uint32(stor_expr_j / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_j / 0x0100000000000000000000000000000000000000000000000000000000000000)))) { if (!(bytes1(mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]))) { IDesolexERC20(stor_expr_k).transfer(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint256(stor_expr_v)); } else { var_d = var_d + 0x64; (bool success34, bytes memory returnData34) = stor_expr_k.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ay, var_az)); // call transfer uint256 value30 = 0x60; if (returnData34.length != 0) { var_d = var_d + ((returnData34.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value30 = var_d; } uint256 value31 = success34; if (success34) { uint256 value43 = !var_bg; if (var_bg != 0x0) { require(((0x20 + value30) + var_bg) - (0x20 + value30) >= 0x20); require(var_ai == (var_ai != 0x0)); value43 = var_bh; } value31 = value43; } require(value31 != 0x0, "token transfer fail"); } uint256 value34 = ((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)); if (bytes1(mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])])) { (bool success35, bytes memory returnData35) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).getReserves(); // staticcall require(success35); var_d = var_d + ((returnData35.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData35.length) - var_d >= 0x60); require(var_bc == (uint32(var_bc))); uint256 value32 = uint112(var_p); uint256 value33 = uint112(var_f); if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { value32 = uint112(var_f); value33 = uint112(var_p); } uint256 accountBalance_36 = IDesolexERC20(stor_expr_w).balanceOf(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])); require(accountBalance_36 > value33, "0 taxed in"); require(((0x26f7 * (accountBalance_36 - value33)) * value32) / ((0x2710 * value33) + (0x26f7 * (accountBalance_36 - value33))) > 0, "0 taxed out"); value34 = ((0x26f7 * (accountBalance_36 - value33)) * value32) / ((0x2710 * value33) + (0x26f7 * (accountBalance_36 - value33))); } if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success37, bytes memory returnData37) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(value29, 0, address(this), 0x80); // call require(success37); } else { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success38, bytes memory returnData38) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(0, value29, address(this), 0x80); // call require(success38); } stor_expr_x = 0; stor_expr_l = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_l; mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = 0; mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; } else { bool flag5 = (block.timestamp - (uint32(stor_expr_j / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_j / 0x01000000000000000000000000000000000000000000000000000000000000)); if ((block.timestamp - uint32(stor_expr_j / 0x010000000000000000000000000000000000000000)) >= bytes1(stor_expr_j / 0x01000000000000000000000000000000000000000000000000000000000000)) { flag5 = !((((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)) * 0x2710) / (address(stor_expr_v / 0x0100000000000000000000000000000000)) < 0x251c); } if (!flag5) { if (!(bytes1(mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])]))) { IDesolexERC20(stor_expr_k).transfer(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]), uint256(stor_expr_v)); } else { var_d = var_d + 0x64; (bool success40, bytes memory returnData40) = stor_expr_k.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ay, var_az)); // call transfer uint256 value35 = 0x60; if (returnData40.length != 0) { var_d = var_d + ((returnData40.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value35 = var_d; } uint256 value36 = success40; if (success40) { uint256 value44 = !var_bi; if (var_bi != 0x0) { require(((0x20 + value35) + var_bi) - (0x20 + value35) >= 0x20); require(var_ai == (var_ai != 0x0)); value44 = var_bj; } value36 = value44; } require(value36 != 0x0, "token transfer fail"); } uint256 value39 = ((0x26f7 * value22) * value23) / ((0x2710 * value24) + (0x26f7 * value22)); if (bytes1(mapping_2[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])])) { (bool success41, bytes memory returnData41) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).getReserves(); // staticcall require(success41); var_d = var_d + ((returnData41.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData41.length) - var_d >= 0x60); require(var_bc == (uint32(var_bc))); uint256 value37 = uint112(var_p); uint256 value38 = uint112(var_f); if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { value37 = uint112(var_f); value38 = uint112(var_p); } uint256 accountBalance_42 = IDesolexERC20(stor_expr_w).balanceOf(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])); require(accountBalance_42 > value38, "0 taxed in"); require(((0x26f7 * (accountBalance_42 - value38)) * value37) / ((0x2710 * value38) + (0x26f7 * (accountBalance_42 - value38))) > 0, "0 taxed out"); value39 = ((0x26f7 * (accountBalance_42 - value38)) * value37) / ((0x2710 * value38) + (0x26f7 * (accountBalance_42 - value38))); } if (!(bytes1(stor_expr_m / 0x0100000000000000000000000000000000000000000000000000))) { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success43, bytes memory returnData43) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(value29, 0, address(this), 0x80); // call require(success43); } else { require(address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).code.length != 0x0); (bool success44, bytes memory returnData44) = address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))]).swap(0, value29, address(this), 0x80); // call require(success44); } stor_expr_x = 0; stor_expr_l = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_l; mapping_0[address(msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))])] = 0; mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; } } } } } } else { stor_expr_r = (0xffffffffffffff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_r; mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[msg.data[(0x80 * value0) + (0x20 + (0x04 + arg0))] & (0xffffffffffffffffffffffffffffffffffffffff)]; } } value0 = 0x01 + value0; } } function rescueToken(address arg0) public { require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); require(address(stor_expr_aa) != 0x0, "no pos"); uint256 accountBalance = IDesolexERC20(stor_expr_aa).balanceOf(address(this)); require(accountBalance > 0, "0 bal"); IDesolexUniswapV2Pair(arg0).getReserves(); uint256 value0 = uint112(var_j); uint256 value1 = uint112(var_k); if (!(bytes1(stor_expr_ab / 0x0100000000000000000000000000000000000000000000000000))) { value0 = uint112(var_k); value1 = uint112(var_j); } uint256 value2 = accountBalance; if (uint16(mapping_1[arg0])) { value2 = ((0x2710 - (uint16(mapping_1[arg0]))) * accountBalance) / 0x2710; } require(0x26f7 * value2 * value0 / (0x2710 * value1 + 0x26f7 * value2) > 0x0, "0 out"); if (!(bytes1(mapping_2[arg0]))) { IDesolexERC20(stor_expr_aa).transfer(arg0, accountBalance); uint256 value3 = ((0x26f7 * value2) * value0) / ((0x2710 * value1) + (0x26f7 * value2)); uint256 var_e; if (bytes1(mapping_2[arg0])) { (bool success3, bytes memory returnData3) = stor_expr_aa.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg0)); // staticcall balanceOf require(success3); var_e = var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData3.length) - var_e) < 0x20)); require(var_e.length > value1, "0 taxed in"); require(((0x26f7 * (var_e.length - value1)) * value0) / ((0x2710 * value1) + (0x26f7 * (var_e.length - value1))) > 0, "0 taxed out"); value3 = ((0x26f7 * (var_e.length - value1)) * value0) / ((0x2710 * value1) + (0x26f7 * (var_e.length - value1))); } if (!(bytes1(stor_expr_ab / 0x0100000000000000000000000000000000000000000000000000))) { require(arg0.code.length != 0x0); (bool success4, bytes memory returnData4) = arg0.swap(value3, 0, address(this), 0x80); // call require(success4); } else { require(arg0.code.length != 0x0); (bool success5, bytes memory returnData5) = arg0.swap(0, value3, address(this), 0x80); // call require(success5); } stor_expr_af = 0; stor_expr_aa = stor_expr_aa & (0xff0000000000ffffffffffffffffffffffffffffffffffffffff); mapping_0[arg0] = 0; mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg0]; mapping_1[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg0]; } else { var_e = var_e + 0x64; (bool success6, bytes memory returnData6) = stor_expr_aa.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_w, var_x)); // call transfer uint256 value4 = 0x60; if (returnData6.length != 0) { var_e = var_e + ((returnData6.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value4 = var_e; } } } function Unknown_510dc341(address arg0) public view returns (bool) { return !(!(bytes1(mapping_2[arg0]))); } function Unknown_529cf2e4(address arg0, uint256 arg1, address arg2, uint64 arg3) public { require(arg3 == (arg3 & 0xffffffffffffffff)); internal_16b6(arg3, arg2, arg1, arg0); } function positions(address account) public view returns (bool) { return abi.encodePacked(mapping_0[account], address(stor_expr_c), address(stor_expr_c / 0x0100000000000000000000000000000000), address(stor_expr_a), uint32(stor_expr_a / 0x010000000000000000000000000000000000000000), !(!(bytes1(stor_expr_a / 0x01000000000000000000000000000000000000000000000000))), !(!(bytes1(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000))), uint16(stor_expr_a / 0x010000000000000000000000000000000000000000000000000000), uint16(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000000000), bytes1(stor_expr_a / 0x01000000000000000000000000000000000000000000000000000000000000), bytes1(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000000000000000)); } function Unknown_7fd782db(address token, uint256 arg1, uint256 arg2, bytes memory arg3) public returns (uint256) { require(!(((0x04 + arg3) + arg3 + 0x20) > msg.data.length)); require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); bool flag0 = !(token); if (token != address(0)) { var_a = var_a; flag0 = var_a == token; } bool flag1 = flag0; if (!(flag0)) { flag1 = arg1 == 0x0; } bool flag2 = flag1; if (!(flag1)) { flag2 = arg2 == 0x0; } require(!(flag2 || arg3.length < 0x4), CustomError_ca63a25a()); require(0x5ae401dc00000000000000000000000000000000000000000000000000000000 == ((0x20 + arg3) & (0xffffffff00000000000000000000000000000000000000000000000000000000)), CustomError_ca63a25a()); uint256 accountBalance = IDesolexERC20(token).balanceOf(address(this)); require(!(accountBalance < arg1), BadFill()); var_a = var_a; uint256 beforeBalance = IDesolexERC20(var_a).balanceOf(address(this)); if (mapping_4[token]) { (bool success2, bytes memory returnData2) = address(0x13f4ea83d0bd40e75c8222255bc855a974568dd4).call(""); // call uint256 value0 = 0x60; uint256 var_d; if (returnData2.length != 0) { var_d = var_d + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_d; } if (!(success2)) { require(0x0 != var_j, CustomError_ca63a25a()); revert(); } (bool success3, bytes memory returnData3) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success3); var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData3.length) - var_d) < 0x20)); bool flag4 = var_d.length > accountBalance; if (!(var_d.length > accountBalance)) { flag4 = !((accountBalance - var_d.length) == arg1); } require(!flag4, CustomError_ca63a25a()); var_a = var_a; uint256 afterBalance = IDesolexERC20(var_a).balanceOf(address(this)); require(!(afterBalance < beforeBalance), CustomError_ca63a25a()); require(!((afterBalance - beforeBalance) < arg2), BadFill()); unresolved_1ed8a376[token] = 0; return afterBalance - beforeBalance; } else { IDesolexERC20(token).approve(0x13f4ea83d0bd40e75c8222255bc855a974568dd4, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); mapping_4[token] = true; (bool success6, bytes memory returnData6) = address(0x13f4ea83d0bd40e75c8222255bc855a974568dd4).call(""); // call uint256 value1 = 0x60; if (returnData6.length != 0) { var_d = var_d + ((returnData6.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_d; } if (!(success6)) { require(0x0 != var_o, CustomError_ca63a25a()); revert(); } (bool success7, bytes memory returnData7) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success7); var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData7.length) - var_d) < 0x20)); bool flag5 = var_d.length > accountBalance; if (!(var_d.length > accountBalance)) { flag5 = !((accountBalance - var_d.length) == arg1); } require(!flag5, CustomError_ca63a25a()); var_a = var_a; uint256 afterBalance1 = IDesolexERC20(var_a).balanceOf(address(this)); require(!(afterBalance1 < beforeBalance), CustomError_ca63a25a()); require(!((afterBalance1 - beforeBalance) < arg2), BadFill()); unresolved_1ed8a376[token] = 0; return afterBalance1 - beforeBalance; } } function Unknown_824f3e22(address arg0, uint256 arg1, address arg2, uint64 arg3, uint16 arg4, uint16 arg5) public { require(arg3 == (arg3 & 0xffffffffffffffff)); require(arg4 == (arg4 & 0xffff)); require(arg5 == (arg5 & 0xffff)); internal_1b65(arg5, arg4, arg3, arg2, arg1, arg0); } function Unknown_85e293e0(address arg0) public view returns (uint16) { return uint16(mapping_1[arg0]); } function quote(address pair, uint256 arg1, bool arg2) public returns (uint256) { (uint112 reserve0, uint112 reserve1, ) = IDesolexUniswapV2Pair(pair).getReserves(); if (arg2) { uint256 value0 = uint112(reserve0); uint256 value1 = uint112(reserve1); if (!(bytes1(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000))) { value0 = uint112(reserve1); value1 = uint112(reserve0); } return ((0x26f7 * arg1) * uint112(var_b.length)) / ((0x2710 * uint112(var_h)) + (0x26f7 * arg1)); } else if (bytes1(stor_expr_a / 0x0100000000000000000000000000000000000000000000000000) == 0x0) { return ((0x26f7 * arg1) * uint112(var_b.length)) / ((0x2710 * uint112(var_h)) + (0x26f7 * arg1)); } else { return ((0x26f7 * arg1) * (uint112(reserve1))) / ((0x2710 * (uint112(reserve0))) + (0x26f7 * arg1)); } } function Unknown_9689148d(address token, uint24 arg1) public returns (uint256) { require(arg1 == (arg1 & 0xffffff)); require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); uint256 accountBalance = IDesolexERC20(token).balanceOf(address(this)); uint256 value5; if (0 - accountBalance != 0) { uint256 value6 = var_c.length - var_c.length; if (mapping_3[token]) { var_d = var_d; uint256 accountBalance_1 = IDesolexERC20(var_d).balanceOf(address(this)); if (0x0 != (0xffffff & arg1)) { var_c = var_c + 0x0100; var_d = var_d; (bool success2, bytes memory returnData2) = address(0x1b81d678ffb9c0263b24a97847620c99d213eb14).exactInputSingle(address(var_c.length)); // call require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData2.length) - var_c) < 0x20)); } else { var_c = var_c + 0x60; accountBalance_1 = msg.data[4:68]; if (!(0 < var_c.length)) _desolexPanic(50); var_d = var_d; if (!(0x01 < var_c.length)) _desolexPanic(50); uint256 value1 = 0; uint256 value2 = (0x04 + var_c) + 0xc0; uint256 value3 = var_c + 0x20; while (true) { if (!(value1 < var_c.length)) { break; } value1 = 0x01 + value1; value2 = value2 + 0x20; value3 = 0x20 + value3; } require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0); (bool success3, bytes memory returnData3) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).swapExactTokensForTokensSupportingFeeOnTransferTokens(accountBalance, 0, 0xa0, address(this), block.timestamp); // call require(success3); } unresolved_1ed8a376[token] = 0; var_d = var_d; (bool success4, bytes memory returnData4) = var_d.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success4); var_c = var_c + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData4.length) - var_c) < 0x20)); } else { IDesolexERC20(token).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); require(approvalSucceeded == approvalSucceeded); IDesolexERC20(token).approve(0x1b81d678ffb9c0263b24a97847620c99d213eb14, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); require(approvalSucceeded1 == approvalSucceeded1); mapping_3[token] = true; var_d = var_d; (bool success7, bytes memory returnData7) = var_d.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success7); var_c = var_c + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData7.length) - var_c) < 0x20)); if (0x0 != (0xffffff & arg1)) { var_c = var_c + 0x0100; var_d = var_d; (bool success8, bytes memory returnData8) = address(0x1b81d678ffb9c0263b24a97847620c99d213eb14).exactInputSingle(address(var_c.length)); // call require(success8); var_c = var_c + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData8.length) - var_c) < 0x20)); unresolved_1ed8a376[token] = 0; var_d = var_d; (bool success9, bytes memory returnData9) = var_d.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success9); var_c = var_c + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData9.length) - var_c) < 0x20)); } else { var_c = var_c + 0x60; if (!(0 < var_c.length)) _desolexPanic(50); var_d = var_d; if (!(0x01 < var_c.length)) _desolexPanic(50); uint256 value1 = 0; uint256 value2 = (0x04 + var_c) + 0xc0; uint256 value3 = var_c + 0x20; while (true) { } } value6 = var_c.length - var_c.length; } value5 = value6; } else { unresolved_1ed8a376[token] = 0; value5 = 0; } // duplicate declaration of value5 omitted } function Unknown_97f7c960(address token, uint24 arg1, uint256 arg2) public returns (uint256) { require(arg1 == (arg1 & 0xffffff)); require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); require(arg2 > 0x0, "0 amount"); var_c = var_c; uint256 accountBalance = IDesolexERC20(var_c).balanceOf(address(this)); require(!(accountBalance < arg2), "low wbnb"); uint256 accountBalance1 = IDesolexERC20(token).balanceOf(address(this)); uint256 var_d; if (0x0 != (0xffffff & arg1)) { var_d = var_d + 0x0100; var_c = var_c; (bool success2, bytes memory returnData2) = address(0x1b81d678ffb9c0263b24a97847620c99d213eb14).exactInputSingle(address(var_d.length)); // call require(success2); var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData2.length) - var_d) < 0x20)); } else { var_d = var_d + 0x60; var_c = var_c; if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); uint256 value1 = 0; uint256 value2 = (0x04 + var_d) + 0xc0; uint256 value3 = var_d + 0x20; while (true) { if (!(value1 < var_d.length)) { break; } value1 = 0x01 + value1; value2 = value2 + 0x20; value3 = 0x20 + value3; } require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0); (bool success3, bytes memory returnData3) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).swapExactTokensForTokensSupportingFeeOnTransferTokens(arg2, 0, 0xa0, address(this), block.timestamp); // call require(success3); } (bool success4, bytes memory returnData4) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success4); var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData4.length) - var_d) < 0x20)); require((var_d.length - accountBalance1) > 0, "0 received"); if (0x0 == unresolved_1ed8a376[token]) { unresolved_1ed8a376[token] = var_d.length - accountBalance1; } if (!mapping_3[token]) { IDesolexERC20(token).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); require(approvalSucceeded == approvalSucceeded); IDesolexERC20(token).approve(0x1b81d678ffb9c0263b24a97847620c99d213eb14, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); require(approvalSucceeded1 == approvalSucceeded1); mapping_3[token] = true; } return var_d.length - accountBalance1; } function withdrawToken(address token, uint256 arg1) public { internal_27bb(arg1, token); } function Unknown_ce1bc5c5(address arg0, uint256 arg1, uint64 arg2) public { require(arg2 == (arg2 & 0xffffffffffffffff)); internal_28d5(arg2, arg1, arg0); } function wrapBNB() public { require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); if (address(this).balance != 0x0) { var_a = var_a; require(address(var_a).code.length != 0x0); (bool success0, bytes memory returnData0) = address(var_a).deposit{ value: address(this).balance }(); // call require(success0); } } function forceClose(address arg0) public { require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); stor_expr_bu = 0; stor_expr_bv = stor_expr_bv & (0xff0000000000ffffffffffffffffffffffffffffffffffffffff); mapping_0[arg0] = 0; mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg0]; mapping_1[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg0]; } function internal_d6e(uint256 arg0) private { // Decompilation incomplete: helper effect provenance is conservative. require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); var_c = var_c; uint256 accountBalance = IDesolexERC20(var_c).balanceOf(address(this)); if (arg0 == 0x0) { require((accountBalance + address(this).balance) > 0, "0 bal"); if ((accountBalance + SELFBALANCE() > SELFBALANCE()) && (accountBalance > 0x0)) { uint256 value0 = (accountBalance + address(this).balance) - address(this).balance; if ((accountBalance + address(this).balance) - address(this).balance > accountBalance) { value0 = accountBalance; } var_c = var_c; require(address(var_c).code.length != 0x0); (bool success1, bytes memory returnData1) = address(var_c).withdraw(value0); // call require(success1); } (bool success2, bytes memory returnData2) = address(0x42d73da3daca18374ee1ab8d700351350a3b0064).call{ value: accountBalance + address(this).balance }(""); // call uint256 value1 = 0x60; if (returnData2.length != 0) { uint256 var_d; var_d = var_d + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_d; } } else { uint256 value2 = accountBalance + address(this).balance; if (!(arg0 > (accountBalance + address(this).balance))) { value2 = arg0; } require(value2 > 0x0, "0 bal"); if ((value2 > SELFBALANCE()) && (accountBalance > 0x0)) { uint256 value3 = value2 - address(this).balance; if ((value2 - address(this).balance) > accountBalance) { value3 = accountBalance; } var_c = var_c; require(address(var_c).code.length != 0x0); (bool success3, bytes memory returnData3) = address(var_c).withdraw(value3); // call require(success3); } (bool success4, bytes memory returnData4) = address(0x42d73da3daca18374ee1ab8d700351350a3b0064).call{ value: value2 }(""); // call uint256 value4 = 0x60; if (returnData4.length != 0) { var_d = var_d + ((returnData4.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value4 = var_d; } } require(success4, "withdraw fail"); } function internal_16b6(uint64 arg0, address arg1, uint256 arg2, address arg3) private { // Decompilation incomplete: helper effect provenance is conservative. require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); if (!(bytes1(stor_expr_ai / 0x01000000000000000000000000000000000000000000000000))) { if (!(address(stor_expr_ai))) { (bool success0, bytes memory returnData0) = arg3.token0(); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData0.length) - var_d >= 0x20); require(var_e == (var_e & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value1 = arg1; if (arg1 == address(0)) { var_a = var_a; value1 = var_a; } if (address(var_f) - (address(value1)) != 0) { stor_expr_ai = 0x0100000000000000000000000000000000000000000000000000 | (var_f & (0xffffffffffffffffffffffffffffffffffffffff) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & stor_expr_ai)); } else { (bool success1, bytes memory returnData1) = arg3.token1(); // staticcall require(success1); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData1.length) - var_d >= 0x20); require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff)); stor_expr_ai = (address(var_f)) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & stor_expr_ai); } } if (arg2 != 0x0) { if (arg1 != address(0)) { (bool success2, bytes memory returnData2) = arg1.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success2); var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData2.length) - var_d >= 0x20); if (0 - var_f != 0) { if (0 != 0) { if (!(var_f < arg2)) { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg3).getReserves(); uint256 value3 = uint112(var_f); uint256 value4 = uint112((var_p)); if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { value3 = uint112((var_p)); value4 = uint112(var_f); } if (0 == (((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))) { return; } else if (0x0 == mapping_0[arg3]) { mapping_0[arg3] = (((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))); return; } else { if ((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))) > mapping_0[arg3]) { if (!((0x2710 * ((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))) - mapping_0[arg3])) / mapping_0[arg3] < (uint16(arg0)))) { if (arg1 != address(0)) { uint256 value5 = 0; if (0 != 0) { (bool success4, bytes memory returnData4) = stor_expr_ai.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success4); var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData4.length) - var_d >= 0x20); value5 = var_f; } if (arg1 == address(0)) { var_a = var_a; (bool success5, bytes memory returnData5) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg3, arg2)); // call transfer require(success5); var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData5.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success6, bytes memory returnData6) = arg1.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg3, arg2)); // call transfer require(success6); var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData6.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { require(arg3.code.length != 0x0); (bool success8, bytes memory returnData8) = arg3.swap(0, ((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))), address(this), 0x80); // call require(success8); } else { require(arg3.code.length != 0x0); (bool success9, bytes memory returnData9) = arg3.swap(((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))), 0, address(this), 0x80); // call require(success9); } } else { var_a = var_a; uint256 accountBalance = IDesolexERC20(var_a).balanceOf(address(this)); if (0 - accountBalance != 0) { if (!(accountBalance < arg2)) { uint256 value9 = 0; if (0 != 0) { uint256 accountBalance_12 = IDesolexERC20(stor_expr_ai).balanceOf(address(this)); value9 = accountBalance_12; } if (arg1 == address(0)) { var_a = var_a; (bool success13, bytes memory returnData13) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg3, arg2)); // call transfer require(success13); var_d = var_d + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData13.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success14, bytes memory returnData14) = arg1.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg3, arg2)); // call transfer require(success14); var_d = var_d + ((returnData14.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData14.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { require(arg3.code.length != 0x0); (bool success16, bytes memory returnData16) = arg3.swap(0, ((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))), address(this), 0x80); // call require(success16); } else { require(arg3.code.length != 0x0); (bool success17, bytes memory returnData17) = arg3.swap(((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))), 0, address(this), 0x80); // call require(success17); } uint256 value13 = (((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))); require(value13 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); stor_expr_al = (address(value13) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & stor_expr_al); stor_expr_al = (address(arg2) * 0x0100000000000000000000000000000000) | (address(stor_expr_al)); stor_expr_aj = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = ((!(!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (uint16(uint64(arg0) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (uint16(uint64(arg0) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (bytes1(uint64(arg0) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (bytes1(uint64(arg0) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(stor_expr_aj)); stor_expr_am = (((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))); mapping_2[arg3] = (0 * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[arg3]); uint256 value14 = 0; value14 = 0; mapping_1[arg3] = (mapping_1[arg3] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value14)); } else { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg3).getReserves(); uint256 value15 = ((0x26f7 * accountBalance) * (uint112(var_f)) / ((0x2710 * (uint112((var_p)))) + (0x26f7 * accountBalance))); uint256 value16 = uint112(var_f); uint256 value17 = uint112((var_p)); if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000) != 0x0)) { value15 = ((0x26f7 * accountBalance) * (uint112((var_p))) / ((0x2710 * (uint112(var_f))) + (0x26f7 * accountBalance))); value16 = uint112((var_p)); value17 = uint112(var_f); } if (0x0 != value15) { uint256 value18 = 0; if (0 != 0) { uint256 accountBalance_20 = IDesolexERC20(stor_expr_ai).balanceOf(address(this)); value18 = accountBalance_20; } if (arg1 == address(0)) { var_a = var_a; (bool success21, bytes memory returnData21) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg3, accountBalance)); // call transfer require(success21); var_d = var_d + ((returnData21.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData21.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success22, bytes memory returnData22) = arg1.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg3, accountBalance)); // call transfer require(success22); var_d = var_d + ((returnData22.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData22.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { require(arg3.code.length != 0x0); (bool success24, bytes memory returnData24) = arg3.swap(0, ((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))), address(this), 0x80); // call require(success24); } else { require(arg3.code.length != 0x0); (bool success25, bytes memory returnData25) = arg3.swap(((((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2)))), 0, address(this), 0x80); // call require(success25); } uint256 value22 = value15; require(value22 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); stor_expr_al = (address(value22) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & stor_expr_al); stor_expr_al = (address(accountBalance) * 0x0100000000000000000000000000000000) | (address(stor_expr_al)); stor_expr_aj = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = ((!(!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (uint16(uint64(arg0) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (uint16(uint64(arg0) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (bytes1(uint64(arg0) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_aj); stor_expr_aj = (bytes1(uint64(arg0) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(stor_expr_aj)); stor_expr_am = value15; mapping_2[arg3] = (0 * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[arg3]); uint256 value23 = 0; value23 = 0; mapping_1[arg3] = (mapping_1[arg3] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value23)); } } } return; } } else { mapping_0[arg3] = (((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))); return; } } else { mapping_0[arg3] = (((0x26f7 * arg2) * value3) / ((0x2710 * value4) + (0x26f7 * arg2))); return; } } } else { return; } } } else { return; } } } } else { if (0x0 != (address(stor_expr_ap))) { uint256 value24 = address(stor_expr_ap); if (uint16(mapping_1[arg3])) { value24 = (((0x2710 - (uint16(mapping_1[arg3]))) * (address(stor_expr_ap))) / 0x2710); } (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg3).getReserves(); uint256 value25 = uint112((var_p)); uint256 value26 = uint112(var_f); if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { value25 = uint112(var_f); value26 = uint112((var_p)); } if (0 != ((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))))) { bool flag4 = (((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_ap / 0x0100000000000000000000000000000000))) < ((uint16(stor_expr_ai / 0x010000000000000000000000000000000000000000000000000000) + 0x2710)); if (((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_ap / 0x0100000000000000000000000000000000)) < ((uint16(stor_expr_ai / 0x010000000000000000000000000000000000000000000000000000) + 0x2710))) { flag4 = ((uint16(stor_expr_ai / 0x0100000000000000000000000000000000000000000000000000000000) + (((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_ap / 0x0100000000000000000000000000000000))))) > 0x2710; } if (!flag4) { if (!(bytes1(mapping_2[arg3]))) { IDesolexERC20(stor_expr_ai).transfer(arg3, uint256(stor_expr_ap)); } else { var_d = var_d + 0x64; (bool success29, bytes memory returnData29) = stor_expr_ai.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bb, var_ab)); // call transfer uint256 value27 = 0x60; if (returnData29.length != 0) { var_d = var_d + ((returnData29.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value27 = var_d; } uint256 value28 = success29; if (success29) { uint256 value45 = !var_bc; if (var_bc != 0x0) { require(((0x20 + value27) + var_bc) - (0x20 + value27) >= 0x20); require(var_af == (var_af != 0x0)); value45 = var_bd; } value28 = value45; } require(value28 != 0x0, "token transfer fail"); } uint256 value31 = (((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))); if (bytes1(mapping_2[arg3])) { (bool success30, bytes memory returnData30) = arg3.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success30); var_d = var_d + ((returnData30.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData30.length) - var_d >= 0x60); require(var_be == (uint32(var_be))); uint256 value29 = uint112((var_p)); uint256 value30 = uint112(var_f); if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { value29 = uint112(var_f); value30 = uint112((var_p)); } uint256 accountBalance_31 = IDesolexERC20(stor_expr_aj).balanceOf(arg3); require(accountBalance_31 > value30, "0 taxed in"); require((((0x26f7 * ((accountBalance_31 - value30))) * value29) / ((0x2710 * value30) + (0x26f7 * ((accountBalance_31 - value30))))) > 0, "0 taxed out"); value31 = (((0x26f7 * ((accountBalance_31 - value30))) * value29) / ((0x2710 * value30) + (0x26f7 * ((accountBalance_31 - value30))))); } if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { require(arg3.code.length != 0x0); (bool success32, bytes memory returnData32) = arg3.swap(value31, 0, address(this), 0x80); // call require(success32); } else { require(arg3.code.length != 0x0); (bool success33, bytes memory returnData33) = arg3.swap(0, value31, address(this), 0x80); // call require(success33); } stor_expr_ap = 0; stor_expr_ai = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_ai; mapping_0[arg3] = 0; mapping_2[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg3]; mapping_1[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg3]; } else { if (0x0 != (uint32(stor_expr_ai / 0x010000000000000000000000000000000000000000))) { if (!((block.timestamp - (uint32(stor_expr_ai / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_ai / 0x0100000000000000000000000000000000000000000000000000000000000000)))) { if (!(bytes1(mapping_2[arg3]))) { IDesolexERC20(stor_expr_ai).transfer(arg3, uint256(stor_expr_ap)); } else { var_d = var_d + 0x64; (bool success35, bytes memory returnData35) = stor_expr_ai.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bb, var_ab)); // call transfer uint256 value32 = 0x60; if (returnData35.length != 0) { var_d = var_d + ((returnData35.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value32 = var_d; } uint256 value33 = success35; if (success35) { uint256 value46 = !var_bi; if (var_bi != 0x0) { require(((0x20 + value32) + var_bi) - (0x20 + value32) >= 0x20); require(var_af == (var_af != 0x0)); value46 = var_bj; } value33 = value46; } require(value33 != 0x0, "token transfer fail"); } uint256 value36 = (((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))); if (bytes1(mapping_2[arg3])) { (bool success36, bytes memory returnData36) = arg3.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success36); var_d = var_d + ((returnData36.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData36.length) - var_d >= 0x60); require(var_be == (uint32(var_be))); uint256 value34 = uint112((var_p)); uint256 value35 = uint112(var_f); if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { value34 = uint112(var_f); value35 = uint112((var_p)); } uint256 accountBalance_37 = IDesolexERC20(stor_expr_aj).balanceOf(arg3); require(accountBalance_37 > value35, "0 taxed in"); require((((0x26f7 * ((accountBalance_37 - value35))) * value34) / ((0x2710 * value35) + (0x26f7 * ((accountBalance_37 - value35))))) > 0, "0 taxed out"); value36 = (((0x26f7 * ((accountBalance_37 - value35))) * value34) / ((0x2710 * value35) + (0x26f7 * ((accountBalance_37 - value35))))); } if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { require(arg3.code.length != 0x0); (bool success38, bytes memory returnData38) = arg3.swap(value31, 0, address(this), 0x80); // call require(success38); } else { require(arg3.code.length != 0x0); (bool success39, bytes memory returnData39) = arg3.swap(0, value31, address(this), 0x80); // call require(success39); } stor_expr_ap = 0; stor_expr_ai = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_ai; mapping_0[arg3] = 0; mapping_2[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg3]; mapping_1[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg3]; } else { bool flag5 = (block.timestamp - (uint32(stor_expr_ai / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_ai / 0x01000000000000000000000000000000000000000000000000000000000000)); if ((block.timestamp - uint32(stor_expr_ai / 0x010000000000000000000000000000000000000000)) >= bytes1(stor_expr_ai / 0x01000000000000000000000000000000000000000000000000000000000000)) { flag5 = !(((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_ap / 0x0100000000000000000000000000000000)) < 0x251c); } if (!flag5) { if (!(bytes1(mapping_2[arg3]))) { IDesolexERC20(stor_expr_ai).transfer(arg3, uint256(stor_expr_ap)); } else { var_d = var_d + 0x64; (bool success41, bytes memory returnData41) = stor_expr_ai.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bb, var_ab)); // call transfer uint256 value37 = 0x60; if (returnData41.length != 0) { var_d = var_d + ((returnData41.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value37 = var_d; } uint256 value38 = success41; if (success41) { uint256 value47 = !var_bk; if (var_bk != 0x0) { require(((0x20 + value37) + var_bk) - (0x20 + value37) >= 0x20); require(var_af == (var_af != 0x0)); value47 = var_bl; } value38 = value47; } require(value38 != 0x0, "token transfer fail"); } uint256 value41 = (((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))); if (bytes1(mapping_2[arg3])) { (bool success42, bytes memory returnData42) = arg3.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success42); var_d = var_d + ((returnData42.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData42.length) - var_d >= 0x60); require(var_be == (uint32(var_be))); uint256 value39 = uint112((var_p)); uint256 value40 = uint112(var_f); if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { value39 = uint112(var_f); value40 = uint112((var_p)); } uint256 accountBalance_43 = IDesolexERC20(stor_expr_aj).balanceOf(arg3); require(accountBalance_43 > value40, "0 taxed in"); require((((0x26f7 * ((accountBalance_43 - value40))) * value39) / ((0x2710 * value40) + (0x26f7 * ((accountBalance_43 - value40))))) > 0, "0 taxed out"); value41 = (((0x26f7 * ((accountBalance_43 - value40))) * value39) / ((0x2710 * value40) + (0x26f7 * ((accountBalance_43 - value40))))); } if (!(bytes1(stor_expr_aj / 0x0100000000000000000000000000000000000000000000000000))) { require(arg3.code.length != 0x0); (bool success44, bytes memory returnData44) = arg3.swap(value31, 0, address(this), 0x80); // call require(success44); } else { require(arg3.code.length != 0x0); (bool success45, bytes memory returnData45) = arg3.swap(0, value31, address(this), 0x80); // call require(success45); } stor_expr_ap = 0; stor_expr_ai = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_ai; mapping_0[arg3] = 0; mapping_2[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg3]; mapping_1[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg3]; } } } } } } else { stor_expr_aj = (0xffffffffffffff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_aj; mapping_2[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg3]; mapping_1[arg3] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg3]; } return; } } function internal_1b65(uint16 arg0, uint16 arg1, uint64 arg2, address arg3, uint256 arg4, address arg5) private { // Decompilation incomplete: helper effect provenance is conservative. require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); require(((arg1 & 0xffff) <= 0x145 && (arg0 & 0xffff) <= 0x145), "tax cap"); address var_a = arg5; if (!(bytes1(stor_expr_at / 0x01000000000000000000000000000000000000000000000000))) { uint256 value0 = var_a; if (!(arg3 == address(0))) { value0 = arg3; } (bool success0, bytes memory returnData0) = arg5.token0(); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0x20)); require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success1, bytes memory returnData1) = arg5.token1(); // staticcall require(success1); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData1.length) - var_d) < 0x20)); require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff)); bool flag1 = (0xffffffffffffffffffffffffffffffffffffffff & value1) == (0xffffffffffffffffffffffffffffffffffffffff & value0); if (address(var_d.length) != address(value0)) { flag1 = (0xffffffffffffffffffffffffffffffffffffffff & value1) == (0xffffffffffffffffffffffffffffffffffffffff & value0); } require(flag1, "quote mismatch"); if (!(address(stor_expr_at))) { (bool success2, bytes memory returnData2) = arg5.token0(); // staticcall require(success2); var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData2.length) - var_d >= 0x20); require(var_g == (var_g & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value4 = arg3; if (arg3 == address(0)) { var_a = var_a; value4 = var_a; } if (address(var_h) - (address(value4)) != 0) { stor_expr_at = 0x0100000000000000000000000000000000000000000000000000 | (var_h & (0xffffffffffffffffffffffffffffffffffffffff) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & stor_expr_at)); } else { (bool success3, bytes memory returnData3) = arg5.token1(); // staticcall require(success3); var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData3.length) - var_d >= 0x20); require(var_j == (var_j & 0xffffffffffffffffffffffffffffffffffffffff)); stor_expr_at = (address(var_h)) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & stor_expr_at); } } uint256 value6 = var_d.length; if (address(var_d.length) != address(value0)) { value6 = var_d.length; } require(address(value6) == (address(stor_expr_at)), "pair mismatch"); if (arg4 != 0x0) { if (arg3 != address(0)) { (bool success4, bytes memory returnData4) = arg3.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success4); var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData4.length) - var_d >= 0x20); if (0 - var_h != 0) { if (((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0200000000)) { if (!(var_h < arg4)) { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg5).getReserves(); uint256 value7 = uint112(var_h); uint256 value8 = uint112((var_r)); if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { value7 = uint112((var_r)); value8 = uint112(var_h); } if (0 == (((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4)))) { return; } else if (0x0 == mapping_0[arg5]) { mapping_0[arg5] = (((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))); return; } else { if ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))) > mapping_0[arg5]) { if (!((0x2710 * ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))) - mapping_0[arg5])) / mapping_0[arg5] < (uint16(arg2)))) { if (arg3 != address(0)) { uint256 value9 = 0; if (((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)) { uint256 accountBalance_6 = IDesolexERC20(stor_expr_at).balanceOf(address(this)); value9 = accountBalance_6; } if (!(!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000))))) { if (arg3 == address(0)) { var_a = var_a; (bool success7, bytes memory returnData7) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg4)); // call transfer require(success7); var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData7.length) - var_d >= 0x20); require(var_w == (var_w != 0x0)); } else { (bool success8, bytes memory returnData8) = arg3.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg4)); // call transfer require(success8); var_d = var_d + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData8.length) - var_d >= 0x20); require(var_x == (var_x != 0x0)); } if (bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000)) { require(arg5.code.length != 0x0); (bool success9, bytes memory returnData9) = arg5.swap(((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4)))), 0, address(this), 0x80); // call require(success9); if (!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)))) { address(stor_expr_at).balanceOf(address(this)); // staticcall } } } } else { var_a = var_a; uint256 accountBalance = IDesolexERC20(var_a).balanceOf(address(this)); if (0 - accountBalance != 0) { if (!(accountBalance < arg4)) { uint256 value10 = 0; if (((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)) { (bool success12, bytes memory returnData12) = stor_expr_at.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success12); var_d = var_d + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData12.length) - var_d >= 0x20); value10 = var_h; } if (!(!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000))))) { if (arg3 == address(0)) { var_a = var_a; (bool success13, bytes memory returnData13) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg4)); // call transfer require(success13); var_d = var_d + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData13.length) - var_d >= 0x20); require(var_w == (var_w != 0x0)); } else { (bool success14, bytes memory returnData14) = arg3.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg4)); // call transfer require(success14); var_d = var_d + ((returnData14.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData14.length) - var_d >= 0x20); require(var_x == (var_x != 0x0)); } } else { uint256 value11 = arg3; if (arg3 == address(0)) { var_a = var_a; value11 = var_a; } var_d = var_d + 0x64; uint256 var_af = 0; (bool success15, bytes memory returnData15) = value11.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ah, var_ai)); // call transfer uint256 value12 = 0x60; if (returnData15.length != 0) { var_d = var_d + ((returnData15.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value12 = var_d; } uint256 value13 = success15; if (success15) { uint256 value43 = !var_aj; if (var_aj != 0x0) { require(((0x20 + value12) + var_aj) - (0x20 + value12) >= 0x20); require(var_ak == (var_ak != 0x0)); value43 = var_al; } value13 = value43; } require(value13 != 0x0, "token transfer fail"); } if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success16, bytes memory returnData16) = arg5.swap(0, ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4)))), address(this), 0x80); // call require(success16); } else { require(arg5.code.length != 0x0); (bool success17, bytes memory returnData17) = arg5.swap(((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4)))), 0, address(this), 0x80); // call require(success17); } uint256 value14 = (((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))); if (!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)))) { (bool success18, bytes memory returnData18) = stor_expr_at.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success18); var_d = var_d + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData18.length) - var_d >= 0x20); bool flag2 = !((var_h - value10) < (((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))) - (((((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0xffff) * ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))))) / 0x2710))))); if (!((var_h - value10) < (((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))) - (((((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0xffff) * ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))))) / 0x2710)))))) { flag2 = !((var_h - value10) > ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))))); } require((flag2 && var_h - value10 > 0x0), "buy tax"); value14 = (var_h - value10); } require(value14 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); stor_expr_aw = (address(value14) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & stor_expr_aw); stor_expr_aw = (address(arg4) * 0x0100000000000000000000000000000000) | (address(stor_expr_aw)); stor_expr_au = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = ((!(!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (uint16(uint64(arg2) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (uint16(uint64(arg2) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (bytes1(uint64(arg2) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (bytes1(uint64(arg2) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(stor_expr_au)); stor_expr_ax = (((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))); mapping_2[arg5] = ((!(!(!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)))))) * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[arg5]); uint256 value15 = (uint64((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000)) >> 0x10; if (!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000))) { value15 = 0; } mapping_1[arg5] = (mapping_1[arg5] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value15)); } else { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg5).getReserves(); uint256 value16 = ((0x26f7 * accountBalance) * (uint112(var_h)) / ((0x2710 * (uint112((var_r)))) + (0x26f7 * accountBalance))); uint256 value17 = uint112(var_h); uint256 value18 = uint112((var_r)); if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000) != 0x0)) { value16 = ((0x26f7 * accountBalance) * (uint112((var_r))) / ((0x2710 * (uint112(var_h))) + (0x26f7 * accountBalance))); value17 = uint112((var_r)); value18 = uint112(var_h); } if (0x0 != value16) { uint256 value19 = 0; if (((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)) { (bool success20, bytes memory returnData20) = stor_expr_at.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success20); var_d = var_d + ((returnData20.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData20.length) - var_d >= 0x20); value19 = var_h; } if (!(!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000))))) { if (arg3 == address(0)) { var_a = var_a; (bool success21, bytes memory returnData21) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, accountBalance)); // call transfer require(success21); var_d = var_d + ((returnData21.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData21.length) - var_d >= 0x20); require(var_w == (var_w != 0x0)); } else { (bool success22, bytes memory returnData22) = arg3.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, accountBalance)); // call transfer require(success22); var_d = var_d + ((returnData22.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData22.length) - var_d >= 0x20); require(var_x == (var_x != 0x0)); } } else { uint256 value20 = arg3; if (arg3 == address(0)) { var_a = var_a; value20 = var_a; } var_d = var_d + 0x64; (bool success23, bytes memory returnData23) = value20.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ai, var_af)); // call transfer uint256 value21 = 0x60; if (returnData23.length != 0) { var_d = var_d + ((returnData23.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value21 = var_d; } uint256 value22 = success23; if (success23) { uint256 value44 = !var_at; if (var_at != 0x0) { require(((0x20 + value21) + var_at) - (0x20 + value21) >= 0x20); require(var_ak == (var_ak != 0x0)); value44 = var_au; } value22 = value44; } require(value22 != 0x0, "token transfer fail"); } if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success24, bytes memory returnData24) = arg5.swap(0, ((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4)))), address(this), 0x80); // call require(success24); } else { require(arg5.code.length != 0x0); (bool success25, bytes memory returnData25) = arg5.swap(((((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4)))), 0, address(this), 0x80); // call require(success25); } uint256 value23 = value16; if (!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)))) { (bool success26, bytes memory returnData26) = stor_expr_at.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success26); var_d = var_d + ((returnData26.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData26.length) - var_d >= 0x20); bool flag4 = !((var_h - value19) < ((value16 - (((((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0xffff) * value16) / 0x2710))))); if (!((var_h - value19) < ((value16 - (((((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0xffff) * value16) / 0x2710)))))) { flag4 = !((var_h - value19) > value16); } require((flag4 && var_h - value10 > 0x0), "buy tax"); value23 = (var_h - value19); } require(value23 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); stor_expr_aw = (address(value23) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & stor_expr_aw); stor_expr_aw = (address(accountBalance) * 0x0100000000000000000000000000000000) | (address(stor_expr_aw)); stor_expr_au = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = ((!(!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (uint16(uint64(arg2) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (uint16(uint64(arg2) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (bytes1(uint64(arg2) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_expr_au); stor_expr_au = (bytes1(uint64(arg2) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(stor_expr_au)); stor_expr_ax = value16; mapping_2[arg5] = ((!(!(!(!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000)))))) * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[arg5]); uint256 value24 = (uint64((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000)) >> 0x10; if (!(((arg0 << 0x10) & (0xffff0000) | (arg1 & (0xffff)) | 0x0300000000) & (0x0100000000))) { value24 = 0; } mapping_1[arg5] = (mapping_1[arg5] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value24)); } } } return; } } else { mapping_0[arg5] = (((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))); return; } } else { mapping_0[arg5] = (((0x26f7 * arg4) * value7) / ((0x2710 * value8) + (0x26f7 * arg4))); return; } } } else { return; } } } else { return; } } } } else { mapping_2[arg5] = 0x01 | (mapping_2[arg5] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); mapping_1[arg5] = (arg0 & (0xffff)) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000 & mapping_1[arg5]); if (0x0 != (address(stor_expr_ba))) { uint256 value25 = address(stor_expr_ba); if (uint16(mapping_1[arg5])) { value25 = (((0x2710 - (uint16(mapping_1[arg5]))) * (address(stor_expr_ba))) / 0x2710); } (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg5).getReserves(); uint256 value26 = uint112((var_r)); uint256 value27 = uint112(var_h); if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { value26 = uint112(var_h); value27 = uint112((var_r)); } if (0 != ((((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))))) { bool flag6 = (((((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))) * 0x2710) / (address(stor_expr_ba / 0x0100000000000000000000000000000000))) < ((uint16(stor_expr_at / 0x010000000000000000000000000000000000000000000000000000) + 0x2710)); if (((((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))) * 0x2710) / (address(stor_expr_ba / 0x0100000000000000000000000000000000)) < ((uint16(stor_expr_at / 0x010000000000000000000000000000000000000000000000000000) + 0x2710))) { flag6 = ((uint16(stor_expr_at / 0x0100000000000000000000000000000000000000000000000000000000) + (((((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))) * 0x2710) / (address(stor_expr_ba / 0x0100000000000000000000000000000000))))) > 0x2710; } if (!flag6) { if (!(bytes1(mapping_2[arg5]))) { IDesolexERC20(stor_expr_at).transfer(arg5, uint256(stor_expr_ba)); } else { var_d = var_d + 0x64; (bool success29, bytes memory returnData29) = stor_expr_at.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bc, var_bd)); // call transfer uint256 value28 = 0x60; if (returnData29.length != 0) { var_d = var_d + ((returnData29.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value28 = var_d; } uint256 value29 = success29; if (success29) { uint256 value45 = !var_be; if (var_be != 0x0) { require(((0x20 + value28) + var_be) - (0x20 + value28) >= 0x20); require(var_ak == (var_ak != 0x0)); value45 = var_bf; } value29 = value45; } require(value29 != 0x0, "token transfer fail"); } uint256 value32 = (((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))); if (bytes1(mapping_2[arg5])) { (bool success30, bytes memory returnData30) = arg5.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success30); var_d = var_d + ((returnData30.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData30.length) - var_d >= 0x60); require(var_bg == (uint32(var_bg))); uint256 value30 = uint112((var_r)); uint256 value31 = uint112(var_h); if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { value30 = uint112(var_h); value31 = uint112((var_r)); } (bool success31, bytes memory returnData31) = stor_expr_au.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg5)); // staticcall balanceOf require(success31); var_d = var_d + ((returnData31.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData31.length) - var_d >= 0x20); require(var_h > value31, "0 taxed in"); require((((0x26f7 * ((var_h - value31))) * value30) / ((0x2710 * value31) + (0x26f7 * ((var_h - value31))))) > 0, "0 taxed out"); value32 = (((0x26f7 * ((var_h - value31))) * value30) / ((0x2710 * value31) + (0x26f7 * ((var_h - value31))))); } if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success32, bytes memory returnData32) = arg5.swap(value32, 0, address(this), 0x80); // call require(success32); } else { require(arg5.code.length != 0x0); (bool success33, bytes memory returnData33) = arg5.swap(0, value32, address(this), 0x80); // call require(success33); } stor_expr_ba = 0; stor_expr_at = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_at; mapping_0[arg5] = 0; mapping_2[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg5]; mapping_1[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg5]; } else { if (0x0 != (uint32(stor_expr_at / 0x010000000000000000000000000000000000000000))) { if (!((block.timestamp - (uint32(stor_expr_at / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_at / 0x0100000000000000000000000000000000000000000000000000000000000000)))) { if (!(bytes1(mapping_2[arg5]))) { IDesolexERC20(stor_expr_at).transfer(arg5, uint256(stor_expr_ba)); } else { var_d = var_d + 0x64; (bool success35, bytes memory returnData35) = stor_expr_at.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bc, var_bd)); // call transfer uint256 value33 = 0x60; if (returnData35.length != 0) { var_d = var_d + ((returnData35.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value33 = var_d; } uint256 value34 = success35; if (success35) { uint256 value46 = !var_bk; if (var_bk != 0x0) { require(((0x20 + value33) + var_bk) - (0x20 + value33) >= 0x20); require(var_ak == (var_ak != 0x0)); value46 = var_bl; } value34 = value46; } require(value34 != 0x0, "token transfer fail"); } uint256 value37 = (((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))); if (bytes1(mapping_2[arg5])) { (bool success36, bytes memory returnData36) = arg5.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success36); var_d = var_d + ((returnData36.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData36.length) - var_d >= 0x60); require(var_bg == (uint32(var_bg))); uint256 value35 = uint112((var_r)); uint256 value36 = uint112(var_h); if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { value35 = uint112(var_h); value36 = uint112((var_r)); } (bool success37, bytes memory returnData37) = stor_expr_au.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg5)); // staticcall balanceOf require(success37); var_d = var_d + ((returnData37.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData37.length) - var_d >= 0x20); require(var_h > value36, "0 taxed in"); require((((0x26f7 * ((var_h - value36))) * value35) / ((0x2710 * value36) + (0x26f7 * ((var_h - value36))))) > 0, "0 taxed out"); value37 = (((0x26f7 * ((var_h - value36))) * value35) / ((0x2710 * value36) + (0x26f7 * ((var_h - value36))))); } if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success38, bytes memory returnData38) = arg5.swap(value32, 0, address(this), 0x80); // call require(success38); } else { require(arg5.code.length != 0x0); (bool success39, bytes memory returnData39) = arg5.swap(0, value32, address(this), 0x80); // call require(success39); } stor_expr_ba = 0; stor_expr_at = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_at; mapping_0[arg5] = 0; mapping_2[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg5]; mapping_1[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg5]; } else { bool flag7 = (block.timestamp - (uint32(stor_expr_at / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_at / 0x01000000000000000000000000000000000000000000000000000000000000)); if ((block.timestamp - uint32(stor_expr_at / 0x010000000000000000000000000000000000000000)) >= bytes1(stor_expr_at / 0x01000000000000000000000000000000000000000000000000000000000000)) { flag7 = !(((((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))) * 0x2710) / (address(stor_expr_ba / 0x0100000000000000000000000000000000)) < 0x251c); } if (!flag7) { if (!(bytes1(mapping_2[arg5]))) { IDesolexERC20(stor_expr_at).transfer(arg5, uint256(stor_expr_ba)); } else { var_d = var_d + 0x64; (bool success41, bytes memory returnData41) = stor_expr_at.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bc, var_bd)); // call transfer uint256 value38 = 0x60; if (returnData41.length != 0) { var_d = var_d + ((returnData41.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value38 = var_d; } uint256 value39 = success41; if (success41) { uint256 value47 = !var_bm; if (var_bm != 0x0) { require(((0x20 + value38) + var_bm) - (0x20 + value38) >= 0x20); require(var_ak == (var_ak != 0x0)); value47 = var_bn; } value39 = value47; } require(value39 != 0x0, "token transfer fail"); } uint256 value42 = (((0x26f7 * value25) * value26) / ((0x2710 * value27) + (0x26f7 * value25))); if (bytes1(mapping_2[arg5])) { (bool success42, bytes memory returnData42) = arg5.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success42); var_d = var_d + ((returnData42.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData42.length) - var_d >= 0x60); require(var_bg == (uint32(var_bg))); uint256 value40 = uint112((var_r)); uint256 value41 = uint112(var_h); if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { value40 = uint112(var_h); value41 = uint112((var_r)); } (bool success43, bytes memory returnData43) = stor_expr_au.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg5)); // staticcall balanceOf require(success43); var_d = var_d + ((returnData43.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData43.length) - var_d >= 0x20); require(var_h > value41, "0 taxed in"); require((((0x26f7 * ((var_h - value41))) * value40) / ((0x2710 * value41) + (0x26f7 * ((var_h - value41))))) > 0, "0 taxed out"); value42 = (((0x26f7 * ((var_h - value41))) * value40) / ((0x2710 * value41) + (0x26f7 * ((var_h - value41))))); } if (!(bytes1(stor_expr_au / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success44, bytes memory returnData44) = arg5.swap(value32, 0, address(this), 0x80); // call require(success44); } else { require(arg5.code.length != 0x0); (bool success45, bytes memory returnData45) = arg5.swap(0, value32, address(this), 0x80); // call require(success45); } stor_expr_ba = 0; stor_expr_at = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_at; mapping_0[arg5] = 0; mapping_2[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg5]; mapping_1[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg5]; } } } } } } else { stor_expr_au = (0xffffffffffffff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_au; mapping_2[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg5]; mapping_1[arg5] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg5]; } return; } } function internal_27bb(uint256 arg0, address arg1) private { // Decompilation incomplete: helper effect provenance is conservative. require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); uint256 accountBalance = IDesolexERC20(arg1).balanceOf(address(this)); if (arg0 == 0x0) { require(accountBalance > 0, "0 bal"); uint256 var_c; var_c = var_c + 0x64; (bool success1, bytes memory returnData1) = arg1.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_k, var_l)); // call transfer uint256 value0 = 0x60; if (returnData1.length != 0) { var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } uint256 value1 = success1; if (success1) { uint256 value5 = !var_n; if (var_n != 0x0) { require(((0x20 + value0) + var_n) - (0x20 + value0) >= 0x20); require(var_o == (var_o != 0x0)); value5 = var_p; } value1 = value5; } require(value1 != 0x0, "token transfer fail"); } else { uint256 value2 = accountBalance; if (!(arg0 > accountBalance)) { value2 = arg0; } require(value2 > 0x0, "0 bal"); var_c = var_c + 0x64; (bool success2, bytes memory returnData2) = arg1.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_k, var_l)); // call transfer uint256 value3 = 0x60; if (returnData2.length != 0) { var_c = var_c + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value3 = var_c; } uint256 value4 = success2; if (success2) { uint256 value6 = !var_q; if (var_q != 0x0) { require(((0x20 + value3) + var_q) - (0x20 + value3) >= 0x20); require(var_o == (var_o != 0x0)); value6 = var_r; } value4 = value6; } require(value4 != 0x0, "token transfer fail"); } } function internal_28d5(uint64 arg0, uint256 arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. require(address(0x42d73da3daca18374ee1ab8d700351350a3b0064) == msg.sender, "!owner"); if (!(bytes1(stor_expr_be / 0x01000000000000000000000000000000000000000000000000))) { if (!(address(stor_expr_be))) { (bool success0, bytes memory returnData0) = arg2.token0(); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData0.length) - var_d >= 0x20); require(var_e == (var_e & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value1 = 0; if (!(address(0))) { var_a = var_a; value1 = var_a; } if (address(var_f) - (address(value1)) != 0) { mapping_2[(keccak256(abi.encode(arg2, 0)))] = 0x0100000000000000000000000000000000000000000000000000 | (var_f & (uint256(type(uint160).max)) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & mapping_2[(keccak256(abi.encode(arg2, 0)))])); } else { (bool success1, bytes memory returnData1) = arg2.token1(); // staticcall require(success1); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData1.length) - var_d >= 0x20); require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff)); mapping_2[(keccak256(abi.encode(arg2, 0)))] = (address(var_f)) | (0xffffffffffff00ffffffffff0000000000000000000000000000000000000000 & mapping_2[(keccak256(abi.encode(arg2, 0)))]); } } internal_335a(0, arg0, 0, arg1, keccak256(abi.encode(arg2, 0)), arg2); return; } else { if (0x0 != (address(stor_expr_bn))) { uint256 value24 = address(stor_expr_bn); if (uint16(mapping_1[arg2])) { value24 = (((0x2710 - (uint16(mapping_1[arg2]))) * (address(stor_expr_bn))) / 0x2710); } IDesolexUniswapV2Pair(arg2).getReserves(); uint256 value25 = uint112((var_p)); uint256 value26 = uint112(var_f); if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { value25 = uint112(var_f); value26 = uint112((var_p)); } if (0 != ((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))))) { bool flag5 = (((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_bn / 0x0100000000000000000000000000000000))) < ((uint16(stor_expr_be / 0x010000000000000000000000000000000000000000000000000000) + 0x2710)); if (((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_bn / 0x0100000000000000000000000000000000)) < ((uint16(stor_expr_be / 0x010000000000000000000000000000000000000000000000000000) + 0x2710))) { flag5 = ((uint16(stor_expr_be / 0x0100000000000000000000000000000000000000000000000000000000) + (((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_bn / 0x0100000000000000000000000000000000))))) > 0x2710; } if (!flag5) { if (!(bytes1(mapping_2[arg2]))) { IDesolexERC20(stor_expr_be).transfer(arg2, uint256(stor_expr_bn)); } else { var_d = var_d + 0x64; (bool success4, bytes memory returnData4) = stor_expr_be.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bb, var_ab)); // call transfer uint256 value27 = 0x60; if (returnData4.length != 0) { var_d = var_d + ((returnData4.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value27 = var_d; } uint256 value28 = success4; if (success4) { uint256 value45 = !var_bc; if (var_bc != 0x0) { require(((0x20 + value27) + var_bc) - (0x20 + value27) >= 0x20); require(var_af == (var_af != 0x0)); value45 = var_bd; } value28 = value45; } require(value28 != 0x0, "token transfer fail"); } uint256 value31 = (((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))); if (bytes1(mapping_2[arg2])) { (bool success5, bytes memory returnData5) = arg2.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success5); var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData5.length) - var_d >= 0x60); require(var_be == (uint32(var_be))); uint256 value29 = uint112((var_p)); uint256 value30 = uint112(var_f); if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { value29 = uint112(var_f); value30 = uint112((var_p)); } (bool success6, bytes memory returnData6) = stor_expr_bq.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg2)); // staticcall balanceOf require(success6); var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData6.length) - var_d >= 0x20); require(var_f > value30, "0 taxed in"); require((((0x26f7 * ((var_f - value30))) * value29) / ((0x2710 * value30) + (0x26f7 * ((var_f - value30))))) > 0, "0 taxed out"); value31 = (((0x26f7 * ((var_f - value30))) * value29) / ((0x2710 * value30) + (0x26f7 * ((var_f - value30))))); } if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { require(arg2.code.length != 0x0); (bool success7, bytes memory returnData7) = arg2.swap(value31, 0, address(this), 0x80); // call require(success7); } else { require(arg2.code.length != 0x0); (bool success8, bytes memory returnData8) = arg2.swap(0, value31, address(this), 0x80); // call require(success8); } stor_expr_bn = 0; stor_expr_be = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_be; mapping_0[arg2] = 0; mapping_2[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg2]; mapping_1[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg2]; } else { if (0x0 != (uint32(stor_expr_be / 0x010000000000000000000000000000000000000000))) { if (!((block.timestamp - (uint32(stor_expr_be / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_be / 0x0100000000000000000000000000000000000000000000000000000000000000)))) { if (!(bytes1(mapping_2[arg2]))) { IDesolexERC20(stor_expr_be).transfer(arg2, uint256(stor_expr_bn)); } else { var_d = var_d + 0x64; (bool success10, bytes memory returnData10) = stor_expr_be.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bb, var_ab)); // call transfer uint256 value32 = 0x60; if (returnData10.length != 0) { var_d = var_d + ((returnData10.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value32 = var_d; } uint256 value33 = success10; if (success10) { uint256 value46 = !var_bi; if (var_bi != 0x0) { require(((0x20 + value32) + var_bi) - (0x20 + value32) >= 0x20); require(var_af == (var_af != 0x0)); value46 = var_bj; } value33 = value46; } require(value33 != 0x0, "token transfer fail"); } uint256 value36 = (((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))); if (bytes1(mapping_2[arg2])) { (bool success11, bytes memory returnData11) = arg2.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success11); var_d = var_d + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData11.length) - var_d >= 0x60); require(var_be == (uint32(var_be))); uint256 value34 = uint112((var_p)); uint256 value35 = uint112(var_f); if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { value34 = uint112(var_f); value35 = uint112((var_p)); } (bool success12, bytes memory returnData12) = stor_expr_bq.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg2)); // staticcall balanceOf require(success12); var_d = var_d + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData12.length) - var_d >= 0x20); require(var_f > value35, "0 taxed in"); require((((0x26f7 * ((var_f - value35))) * value34) / ((0x2710 * value35) + (0x26f7 * ((var_f - value35))))) > 0, "0 taxed out"); value36 = (((0x26f7 * ((var_f - value35))) * value34) / ((0x2710 * value35) + (0x26f7 * ((var_f - value35))))); } if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { require(arg2.code.length != 0x0); (bool success13, bytes memory returnData13) = arg2.swap(value31, 0, address(this), 0x80); // call require(success13); } else { require(arg2.code.length != 0x0); (bool success14, bytes memory returnData14) = arg2.swap(0, value31, address(this), 0x80); // call require(success14); } stor_expr_bn = 0; stor_expr_be = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_be; mapping_0[arg2] = 0; mapping_2[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg2]; mapping_1[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg2]; } else { bool flag6 = (block.timestamp - (uint32(stor_expr_be / 0x010000000000000000000000000000000000000000))) < (bytes1(stor_expr_be / 0x01000000000000000000000000000000000000000000000000000000000000)); if ((block.timestamp - uint32(stor_expr_be / 0x010000000000000000000000000000000000000000)) >= bytes1(stor_expr_be / 0x01000000000000000000000000000000000000000000000000000000000000)) { flag6 = !(((((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))) * 0x2710) / (address(stor_expr_bn / 0x0100000000000000000000000000000000)) < 0x251c); } if (!flag6) { if (!(bytes1(mapping_2[arg2]))) { IDesolexERC20(stor_expr_be).transfer(arg2, uint256(stor_expr_bn)); } else { var_d = var_d + 0x64; (bool success16, bytes memory returnData16) = stor_expr_be.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_bb, var_ab)); // call transfer uint256 value37 = 0x60; if (returnData16.length != 0) { var_d = var_d + ((returnData16.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value37 = var_d; } uint256 value38 = success16; if (success16) { uint256 value47 = !var_bk; if (var_bk != 0x0) { require(((0x20 + value37) + var_bk) - (0x20 + value37) >= 0x20); require(var_af == (var_af != 0x0)); value47 = var_bl; } value38 = value47; } require(value38 != 0x0, "token transfer fail"); } uint256 value41 = (((0x26f7 * value24) * value25) / ((0x2710 * value26) + (0x26f7 * value24))); if (bytes1(mapping_2[arg2])) { (bool success17, bytes memory returnData17) = arg2.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success17); var_d = var_d + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData17.length) - var_d >= 0x60); require(var_be == (uint32(var_be))); uint256 value39 = uint112((var_p)); uint256 value40 = uint112(var_f); if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { value39 = uint112(var_f); value40 = uint112((var_p)); } (bool success18, bytes memory returnData18) = stor_expr_bq.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), arg2)); // staticcall balanceOf require(success18); var_d = var_d + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData18.length) - var_d >= 0x20); require(var_f > value40, "0 taxed in"); require((((0x26f7 * ((var_f - value40))) * value39) / ((0x2710 * value40) + (0x26f7 * ((var_f - value40))))) > 0, "0 taxed out"); value41 = (((0x26f7 * ((var_f - value40))) * value39) / ((0x2710 * value40) + (0x26f7 * ((var_f - value40))))); } if (!(bytes1(stor_expr_bq / 0x0100000000000000000000000000000000000000000000000000))) { require(arg2.code.length != 0x0); (bool success19, bytes memory returnData19) = arg2.swap(value31, 0, address(this), 0x80); // call require(success19); } else { require(arg2.code.length != 0x0); (bool success20, bytes memory returnData20) = arg2.swap(0, value31, address(this), 0x80); // call require(success20); } stor_expr_bn = 0; stor_expr_be = (0xff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_be; mapping_0[arg2] = 0; mapping_2[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg2]; mapping_1[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg2]; } } } } } } else { stor_expr_bq = (0xffffffffffffff0000000000ffffffffffffffffffffffffffffffffffffffff) & stor_expr_bq; mapping_2[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & mapping_2[arg2]; mapping_1[arg2] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) & mapping_1[arg2]; } return; } } function internal_335a(uint256 arg0, uint256 arg1, address arg2, uint256 arg3, uint256 arg4, address arg5) private { // Decompilation incomplete: helper effect provenance is conservative. if (arg3 != 0x0) { if (arg2 != 0x0) { (bool success0, bytes memory returnData0) = arg2.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success0); var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData0.length) - var_d >= 0x20); if (0 - var_f != 0) { if ((arg0 & 0x200000000) != 0x0) { if (!(var_f < arg3)) { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg5).getReserves(); uint256 value3 = uint112(var_f); uint256 value4 = uint112((var_p)); if (!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000))) { value3 = uint112((var_p)); value4 = uint112(var_f); } if (0 == (((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))) { return; } else if (0x0 == stor_expr_bh) { stor_expr_bh = (((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))); return; } else { if ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))) > stor_expr_bh) { if (!(((0x2710 * ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))) - stor_expr_bh)) / stor_expr_bh) < (uint16(arg1)))) { if (arg2 != address(0)) { uint256 value5 = 0; if ((arg0 & 0x100000000) != 0x0) { (bool success2, bytes memory returnData2) = address(mapping_2[arg4]).balanceOf(address(this)); // staticcall require(success2); uint256 accountBalance_2 = abi.decode(returnData2, (uint256)); value5 = accountBalance_2; } if ((arg0 & 0x100000000) == 0x0) { if (arg2 == 0x0) { var_a = var_a; (bool success3, bytes memory returnData3) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg3)); // call transfer require(success3); var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData3.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success4, bytes memory returnData4) = arg2.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg3)); // call transfer require(success4); var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData4.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } } else { uint256 value6 = (arg2) ? 1 : 0; if (arg2 == address(0)) { var_a = var_a; value6 = var_a; } var_d = var_d + 0x64; uint256 var_z = 0; (bool success5, bytes memory returnData5) = value6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ab, var_ac)); // call transfer uint256 value7 = 0x60; if (returnData5.length != 0) { var_d = var_d + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value7 = var_d; } uint256 value8 = success5; if (success5) { uint256 value42 = !var_ae; if (var_ae != 0x0) { require(((0x20 + value7) + var_ae) - (0x20 + value7) >= 0x20); require(var_af == (var_af != 0x0)); value42 = var_ag; } value8 = value42; } require(value8 != 0x0, "token transfer fail"); } if (!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success6, bytes memory returnData6) = arg5.swap(0, ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))), address(this), 0x80); // call require(success6); } else { require(arg5.code.length != 0x0); (bool success7, bytes memory returnData7) = arg5.swap(((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))), 0, address(this), 0x80); // call require(success7); } if (!(!(arg0 & (0x0100000000)))) { (bool success8, bytes memory returnData8) = address(mapping_2[arg4]).balanceOf(address(this)); // staticcall require(success8); uint256 accountBalance_8 = abi.decode(returnData8, (uint256)); bool flag0 = !((accountBalance_8 - value5) < (((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))) - (((uint16(arg0) * ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))))) / 0x2710))))); if (!((accountBalance_8 - value5) < (((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))) - (((uint16(arg0) * ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))))) / 0x2710)))))) { flag0 = !((accountBalance_8 - value5) > ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))))); } } } else { var_a = var_a; uint256 accountBalance = IDesolexERC20(var_a).balanceOf(address(this)); if (0 - accountBalance != 0) { if (!(accountBalance < arg3)) { uint256 value9 = 0; if ((arg0 & 0x100000000) != 0x0) { (bool success10, bytes memory returnData10) = address(mapping_2[arg4]).balanceOf(address(this)); // staticcall require(success10); uint256 accountBalance_10 = abi.decode(returnData10, (uint256)); value9 = accountBalance_10; } if ((arg0 & 0x100000000) == 0x0) { if (arg2 == 0x0) { var_a = var_a; (bool success11, bytes memory returnData11) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg3)); // call transfer require(success11); var_d = var_d + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData11.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success12, bytes memory returnData12) = arg2.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, arg3)); // call transfer require(success12); var_d = var_d + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData12.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } } else { uint256 value10 = (arg2) ? 1 : 0; if (arg2 == address(0)) { var_a = var_a; value10 = var_a; } var_d = var_d + 0x64; uint256 var_al = 0; (bool success13, bytes memory returnData13) = value10.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_ac, var_z)); // call transfer uint256 value11 = 0x60; if (returnData13.length != 0) { var_d = var_d + ((returnData13.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value11 = var_d; } uint256 value12 = success13; if (success13) { uint256 value43 = !var_am; if (var_am != 0x0) { require(((0x20 + value11) + var_am) - (0x20 + value11) >= 0x20); require(var_af == (var_af != 0x0)); value43 = var_an; } value12 = value43; } require(value12 != 0x0, "token transfer fail"); } if (!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success14, bytes memory returnData14) = arg5.swap(0, ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))), address(this), 0x80); // call require(success14); } else { require(arg5.code.length != 0x0); (bool success15, bytes memory returnData15) = arg5.swap(((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))), 0, address(this), 0x80); // call require(success15); } uint256 value13 = (((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))); if (!(!(arg0 & (0x0100000000)))) { (bool success16, bytes memory returnData16) = address(mapping_2[arg4]).balanceOf(address(this)); // staticcall require(success16); uint256 accountBalance_16 = abi.decode(returnData16, (uint256)); bool flag1 = !((accountBalance_16 - value9) < (((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))) - (((uint16(arg0) * ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))))) / 0x2710))))); if (!((accountBalance_16 - value9) < (((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))) - (((uint16(arg0) * ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))))) / 0x2710)))))) { flag1 = !((accountBalance_16 - value9) > ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))))); } require((flag1 && accountBalance_16 - value5 > 0x0), "buy tax"); value13 = (accountBalance_16 - value9); } require(value13 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); mapping_1[arg4] = (address(value13) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & mapping_1[arg4]); mapping_1[arg4] = (address(arg3) * 0x0100000000000000000000000000000000) | (address(mapping_1[arg4])); mapping_2[arg4] = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = ((!(!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (uint16(uint64(arg1) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (uint16(uint64(arg1) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (bytes1(uint64(arg1) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (bytes1(uint64(arg1) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(mapping_2[arg4])); stor_expr_bk = (((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))); mapping_2[arg5] = ((!(!(!(!(arg0 & (0x0100000000)))))) * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[arg5]); uint256 value14 = (uint64(arg0)) >> 0x10; if ((arg0 & 0x100000000) == 0x0) { value14 = 0; } mapping_1[arg5] = (mapping_1[arg5] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value14)); } else { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(arg5).getReserves(); uint256 value15 = ((0x26f7 * accountBalance) * (uint112(var_f)) / ((0x2710 * (uint112((var_p)))) + (0x26f7 * accountBalance))); uint256 value16 = uint112(var_f); uint256 value17 = uint112((var_p)); if (!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000) != 0x0)) { value15 = ((0x26f7 * accountBalance) * (uint112((var_p))) / ((0x2710 * (uint112(var_f))) + (0x26f7 * accountBalance))); value16 = uint112((var_p)); value17 = uint112(var_f); } if (0x0 != value15) { uint256 value18 = 0; if ((arg0 & 0x100000000) != 0x0) { (bool success18, bytes memory returnData18) = address(mapping_2[arg4]).balanceOf(address(this)); // staticcall require(success18); var_d = var_d + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData18.length) - var_d >= 0x20); value18 = var_f; } if ((arg0 & 0x100000000) == 0x0) { if (arg2 == 0x0) { var_a = var_a; (bool success19, bytes memory returnData19) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, accountBalance)); // call transfer require(success19); var_d = var_d + ((returnData19.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData19.length) - var_d >= 0x20); require(var_u == (var_u != 0x0)); } else { (bool success20, bytes memory returnData20) = arg2.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg5, accountBalance)); // call transfer require(success20); var_d = var_d + ((returnData20.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_d + returnData20.length) - var_d >= 0x20); require(var_v == (var_v != 0x0)); } } else { uint256 value19 = (arg2) ? 1 : 0; if (arg2 == address(0)) { var_a = var_a; value19 = var_a; } var_d = var_d + 0x64; (bool success21, bytes memory returnData21) = value19.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_z, var_al)); // call transfer uint256 value20 = 0x60; if (returnData21.length != 0) { var_d = var_d + ((returnData21.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value20 = var_d; } uint256 value21 = success21; if (success21) { uint256 value44 = !var_au; if (var_au != 0x0) { require(((0x20 + value20) + var_au) - (0x20 + value20) >= 0x20); require(var_af == (var_af != 0x0)); value44 = var_av; } value21 = value44; } require(value21 != 0x0, "token transfer fail"); } if (!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000))) { require(arg5.code.length != 0x0); (bool success22, bytes memory returnData22) = arg5.swap(0, ((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))), address(this), 0x80); // call require(success22); } else { require(arg5.code.length != 0x0); (bool success23, bytes memory returnData23) = arg5.swap(((((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3)))), 0, address(this), 0x80); // call require(success23); } uint256 value22 = value15; if (!(!(arg0 & (0x0100000000)))) { (bool success24, bytes memory returnData24) = address(mapping_2[arg4]).balanceOf(address(this)); // staticcall require(success24); uint256 accountBalance_24 = abi.decode(returnData24, (uint256)); bool flag3 = !((accountBalance_24 - value18) < ((value15 - (((uint16(arg0) * value15) / 0x2710))))); if (!((accountBalance_24 - value18) < ((value15 - (((uint16(arg0) * value15) / 0x2710)))))) { flag3 = !((accountBalance_24 - value18) > value15); } require((flag3 && accountBalance_24 - value5 > 0x0), "buy tax"); value22 = (accountBalance_24 - value18); } require(value22 <= 0xffffffffffffffffffffffffffffffff, "amount overflow"); mapping_1[arg4] = (address(value22) * 0x01) | (0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 & mapping_1[arg4]); mapping_1[arg4] = (address(accountBalance) * 0x0100000000000000000000000000000000) | (address(mapping_1[arg4])); mapping_2[arg4] = (uint32(block.timestamp) * 0x010000000000000000000000000000000000000000) | (0xffffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (0x01 * 0x01000000000000000000000000000000000000000000000000) | (0xffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = ((!(!(bytes1(mapping_2[arg4] / 0x0100000000000000000000000000000000000000000000000000)))) * 0x0100000000000000000000000000000000000000000000000000) | (0xffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (uint16(uint64(arg1) >> 0x10) * 0x010000000000000000000000000000000000000000000000000000) | (0xffffffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (uint16(uint64(arg1) >> 0x20) * 0x0100000000000000000000000000000000000000000000000000000000) | (0xffff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (bytes1(uint64(arg1) >> 0x30) * 0x01000000000000000000000000000000000000000000000000000000000000) | (0xff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & mapping_2[arg4]); mapping_2[arg4] = (bytes1(uint64(arg1) >> 0x38) * 0x0100000000000000000000000000000000000000000000000000000000000000) | (uint248(mapping_2[arg4])); stor_expr_bk = value15; mapping_2[arg5] = ((!(!(!(!(arg0 & (0x0100000000)))))) * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_2[arg5]); uint256 value23 = (uint64(arg0)) >> 0x10; if ((arg0 & 0x100000000) == 0x0) { value23 = 0; } mapping_1[arg5] = (mapping_1[arg5] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (uint16(value23)); } } } return; } } else { stor_expr_bh = (((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))); return; } } else { stor_expr_bh = (((0x26f7 * arg3) * value3) / ((0x2710 * value4) + (0x26f7 * arg3))); return; } } } else { return; } } } } } } 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. // 0x0dc91306 => v3Router() // 0x16c19739 => getPosition(address) // 0x1ed8a376 => unresolved_1ed8a376(address) // 0x24a046fb => getPositions(address[]) // 0x2c319749 => Unknown_2c319749(address,uint256,uint256,bytes) // 0x2e1a7d4d => withdraw(uint256) // 0x3afdde16 => Unknown_3afdde16(address) // 0x3c50b4a8 => Unknown_3c50b4a8(bytes) // 0x4460d3cf => rescueToken(address) // 0x510dc341 => Unknown_510dc341(address) // 0x529cf2e4 => Unknown_529cf2e4(address,uint256,address,uint64) // 0x55f57510 => positions(address) // 0x7fd782db => Unknown_7fd782db(address,uint256,uint256,bytes) // 0x824f3e22 => Unknown_824f3e22(address,uint256,address,uint64,uint16,uint16) // 0x85e293e0 => Unknown_85e293e0(address) // 0x8da5cb5b => owner() // 0x8dd95002 => WBNB() // 0x92f87d7b => quote(address,uint256,bool) // 0x9689148d => Unknown_9689148d(address,uint24) // 0x97f7c960 => Unknown_97f7c960(address,uint24,uint256) // 0x9e281a98 => withdrawToken(address,uint256) // 0xce1bc5c5 => Unknown_ce1bc5c5(address,uint256,uint64) // 0xd5b09163 => wrapBNB() // 0xd6ae57c7 => forceClose(address) // 0xdeadbc14 => v2Router() // 0xef9caa88 => MAX_TRANSFER_TAX_BPS() // 0xfe131994 => SMART_ROUTER()}