BNB Chain
0x61c89f1d5ec949d99cebd7a517a2512dbb91e208
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x61c89f1d…bb91e20822.8 KB97.2 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x61c89f1d5ec949d99cebd7a517a2512dbb91e208
3,884 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// Decompilation incomplete: generated symbolic output exceeded safe postprocessing limits for 1 of 68 entry points; ABI and selector evidence were preserved but those Solidity bodies were omitted: b260c42a// SPDX-License-Identifier: MITpragma solidity >=0.8.0;interface IDesolexUniswapV2Pair { function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);}contract DesolexContract { uint8 public constant decimals = 18; address public constant logic = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7); mapping(address => uint256) mapping_0; // STORAGE[0x0] mapping(bytes32 => mapping(bytes32 => bytes32)) mapping_1; // STORAGE[0x1] // DESOLEX_RAW_STORAGE: whole slot: array [Layout] vs mapping [Layout] (ambiguous) uint256 public totalSupply; // STORAGE[0x2] string _name; // STORAGE[0x3] string _symbol; // STORAGE[0x4] address public owner; // STORAGE[0x5] uint256 public unresolved_849b0dcd; // STORAGE[0x7] uint256 public totalPower; // STORAGE[0x8] uint256 public startTime; // STORAGE[0x9] uint256 public lastMiningDay; // STORAGE[0xa] bytes32 stor_b; // STORAGE[0xb] mapping(uint256 => address) public idToAddress; // STORAGE[0xc] mapping(uint256 => bytes32) mapping_d; // STORAGE[0xd] mapping(address => address) mapping_e; // STORAGE[0xe] mapping(address => uint256) mapping_f; // STORAGE[0xf] mapping(address => uint256) public userBuyUsdtAmount; // STORAGE[0x10] mapping(address => uint256) public unresolved_11cb3b3e; // STORAGE[0x11] mapping(address => bool) public isWL; // STORAGE[0x12] mapping(address => bool) mapping_13; // STORAGE[0x13] mapping(uint256 => uint256) public totalAmountOfDay; // STORAGE[0x14] mapping(bytes32 => uint256) public unresolved_1a449f57; // STORAGE[0x15] mapping(bytes32 => bytes32) mapping_16; // STORAGE[0x16] mapping(bytes32 => bool) public unresolved_de05af31; // STORAGE[0x17] mapping(bytes32 => bool) public unresolved_2ee3a441; // STORAGE[0x18] mapping(address => uint256) mapping_19; // STORAGE[0x19] mapping(bytes32 => uint256) public unresolved_9135dd85; // STORAGE[0x1a] uint256 stor_1b; // STORAGE[0x1b] uint256 stor_1c; // STORAGE[0x1c] bytes public lastDayReserves; // STORAGE[0x1d] uint256 public dailyLimit; // STORAGE[0x1e] uint256 stor_1f; // STORAGE[0x1f] bytes public addresses; // STORAGE[0x22] address stor_23; // STORAGE[0x23] address stor_24; // STORAGE[0x24] address stor_25; // STORAGE[0x25] address public basePair; // STORAGE[0x27] address public TOP_USER; // STORAGE[0x28] uint256 public ETH_MIN_LIMIT; // STORAGE[0x29] uint256 public ETH_MAX_LIMIT; // STORAGE[0x2a] uint256 stor_2b; // STORAGE[0x2b] mapping(address => mapping(uint256 => bool)) public buyBlockMapping; // STORAGE[0x2c] bytes32 stor_expr_aa; bytes32 stor_expr_ab; uint256 stor_expr_ac; bytes32 stor_expr_ad; uint256 stor_expr_ae; bytes32 stor_expr_af; bytes32 stor_expr_ag; bytes32 stor_expr_ah; uint256 stor_expr_aj; uint256 stor_expr_bx; uint256 stor_expr_cn; uint256 stor_expr_cy; uint256 stor_expr_dk; uint256 stor_expr_dl; uint256 stor_expr_dm; uint256 stor_expr_dn; uint256 stor_expr_do; uint256 stor_expr_dq; bytes32 stor_expr_dr; uint256 stor_expr_ds; bytes32 stor_expr_dt; bytes32 stor_expr_dv; bytes32 stor_expr_dw; bytes32 stor_expr_dx; uint256 stor_expr_dy; uint256 stor_expr_ea; uint256 stor_expr_ee; uint256 stor_expr_ef; uint256 stor_expr_eg; bytes32 stor_expr_el; address stor_expr_eq; uint256 stor_expr_ew; bytes32 stor_expr_fa; address stor_expr_fp; bytes32 stor_expr_fq; bytes32 stor_expr_fr; bytes32 stor_expr_fs; bytes32 stor_expr_ft; bytes32 stor_expr_fu; bytes32 stor_expr_fv; bytes32 stor_expr_fw; bytes32 stor_expr_fx; bytes32 stor_expr_fy; uint256 stor_expr_gi; uint256 stor_expr_gk; uint256 stor_expr_go; uint256 stor_expr_gp; uint256 stor_expr_gq; uint256 stor_expr_gs; bytes32 stor_expr_gv; bytes32 stor_expr_gx; bytes32 stor_expr_gy; bytes32 stor_expr_gz; uint256 stor_expr_ha; uint256 stor_expr_hc; uint256 stor_expr_hg; uint256 stor_expr_hh; bytes32 stor_expr_hn; bytes32 stor_expr_m; uint256 stor_expr_n; bytes32 stor_expr_o; bytes32 stor_expr_p; uint256 stor_expr_q; uint256 stor_expr_r; bytes32 stor_expr_s; bytes32 stor_expr_t; bytes32 stor_expr_u; bytes32 stor_expr_v; bytes32 stor_expr_w; bytes32 stor_expr_x; bytes32 stor_expr_z; event Mining(uint256, uint256, uint256, uint256, uint256); event Deposit(address, uint256, uint256, uint256, uint256, uint256); event Approval(address indexed, address indexed, uint256); event Event_03ad3c3e(uint256, uint256, uint256); error ERC20InvalidApprover(address); event Buy(address, uint256, uint256, uint256); event Sync(uint256, uint256, uint256, uint256); error ERC20InvalidSender(address); error OwnableUnauthorizedAccount(address); event Transfer(address indexed, address indexed, uint256); error OwnableInvalidOwner(address); error ERC20InvalidReceiver(address); error ERC20InsufficientAllowance(address, uint256, uint256); event RemoveLp(address, uint256, uint256, uint256); error ERC20InvalidSpender(address); event OwnershipTransferred(address indexed, address indexed); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } modifier onlyOwner() { require(msg.sender == owner, OwnableUnauthorizedAccount()); _; } fallback() external { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x0088d22f)) { // Route to Unknown_0088d22f(bytes,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x67e7b2ad)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x0e7bf8d3)) { // Route to Unknown_0e7bf8d3(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xdf22a637)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x186f0ac7)) { // Route to Unknown_186f0ac7(bytes,bytes,bytes,bytes,bytes,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xde2ed76d)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x2e106537)) { // Route to Unknown_2e106537(bytes32) after replacing only msg.sig. __desolexSelectorShim(uint32(0x36038134)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x2e51b77e)) { // Route to Unknown_2e51b77e(bytes,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x65cba01f)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x33ffc7dd)) { // Route to Unknown_33ffc7dd(address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x61e9f240)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x5e9f9879)) { // Route to Unknown_5e9f9879(bytes,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0xdd7c8a3c)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x656976a3)) { // Route to Unknown_656976a3(bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5f99a7d8)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xe11ca3f4)) { // Route to Unknown_e11ca3f4(bytes32) after replacing only msg.sig. __desolexSelectorShim(uint32(0x84c6bb61)); return; } revert(); } function Unknown_0088d22f(bytes memory arg0, bool arg1) public { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + arg0) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = ((0x04 + arg0) + (arg0.length << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + arg0; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } require(msg.data[value0] == (address(msg.data[value0]))); value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value7 = 0; while (true) { if (value7 >= var_d) { break; } mapping_13[address(var_f)] = arg1; value7 = 0x01 + value7; } } } function name() public view returns (string memory) { return _name; } function approve(address spender, uint256 amount) public returns (bool) { require(msg.sender != address(0), ERC20InvalidApprover(address(0))); require(spender != address(0), ERC20InvalidSpender(address(0))); mapping_1[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function Unknown_0e7bf8d3(uint256 arg0) public onlyOwner { totalPower = (arg0) ? 1 : 0; } function bindStatus() public view returns (bool) { return !(!(bytes1(stor_2b))); } function Unknown_186f0ac7(bytes memory arg0, bytes memory arg1, bytes memory arg2, bytes memory arg3, bytes memory arg4, uint256 arg5, uint256 arg6) public { if (!(arg0 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + arg0) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = ((0x04 + arg0) + (arg0.length << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + arg0; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } require(msg.data[value0] == (address(msg.data[value0]))); value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; if (!(arg1 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); uint256 value7 = (0x04 + arg1) + 0x20; uint256 value9 = var_a; uint256 value10 = var_a + 0x20; uint256 value8 = ((0x04 + arg1) + (arg1.length << 0x05)) + 0x20; uint256 value11 = 0; uint256 value12 = 0x04 + arg1; uint256 value13 = msg.data.length; while (true) { if (value7 >= value8) { break; } value7 = 0x20 + value7; value9 = value9; value10 = 0x20 + value10; value8 = value8; value11 = value11; value12 = value12; value13 = value13; if (!(arg2 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); require(!(((0x04 + arg2) + (arg2.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + arg2) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = ((0x04 + arg2) + (arg2.length << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + arg2; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } require(msg.data[value0] == (address(msg.data[value0]))); value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; if (!(arg3 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg3.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg3.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg3.length << 0x05)) + 0x1f)); require(!(((0x04 + arg3) + (arg3.length << 0x05) + 0x20) > msg.data.length)); uint256 value7 = (0x04 + arg3) + 0x20; uint256 value9 = var_a; uint256 value10 = var_a + 0x20; uint256 value8 = ((0x04 + arg3) + (arg3.length << 0x05)) + 0x20; uint256 value11 = 0; uint256 value12 = 0x04 + arg3; uint256 value13 = msg.data.length; while (true) { if (value7 >= value8) { break; } value7 = 0x20 + value7; value9 = value9; value10 = 0x20 + value10; value8 = value8; value11 = value11; value12 = value12; value13 = value13; if (!(arg4 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg4.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg4.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg4.length << 0x05)) + 0x1f)); require(!(((0x04 + arg4) + (arg4.length << 0x05) + 0x20) > msg.data.length)); uint256 value7 = (0x04 + arg4) + 0x20; uint256 value9 = var_a; uint256 value10 = var_a + 0x20; uint256 value8 = ((0x04 + arg4) + (arg4.length << 0x05)) + 0x20; uint256 value11 = 0; uint256 value12 = 0x04 + arg4; uint256 value13 = msg.data.length; while (true) { if (value7 >= value8) { break; } value7 = 0x20 + value7; value9 = value9; value10 = 0x20 + value10; value8 = value8; value11 = value11; value12 = value12; value13 = value13; require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value14 = 0; uint256 value16 = value2 + 0x20; uint256 value15 = var_i; uint256 value17 = 0; uint256 value18 = value2; uint256 value19 = ((0x24 + var_a) + 0xe0) + 0x20; while (true) { if (value14 >= value15) { break; } if ((0x01 + value14) >= value15) { break; } value14 = 0x01 + (0x01 + value14); value16 = (value16 + 0x20) + 0x20; value15 = value15; value17 = value17; value18 = value18; value19 = 0x20 + (0x20 + value19); uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_p; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value19) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value14 = 0; uint256 value16 = value2 + 0x20; uint256 value15 = var_v; uint256 value17 = 0; uint256 value18 = value2; uint256 value19 = (0x20 + value25) + 0x20; while (true) { if (value14 >= value15) { break; } if ((0x01 + value14) >= value15) { break; } value14 = 0x01 + value14; value16 = value16 + 0x20; value15 = value15; value17 = value17; value18 = value18; value19 = 0x20 + value19; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_aa; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value19 + 0x20; uint256 var_az; uint256 var_ax; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value25 + 0x20; uint256 var_bb; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba, var_bb, var_bc, var_bd, var_be); // delegatecall uint256 value26 = 0x60; if (returnData0.length != 0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value26 = var_a; } require(success0); (bool success1, bytes memory returnData1) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba, var_bb); // delegatecall uint256 value27 = 0x60; if (returnData1.length != 0) { var_a = var_a + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value27 = var_a; } require(success1); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success2, bytes memory returnData2) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba, var_bb, var_bc); // delegatecall uint256 value28 = 0x60; if (returnData2.length != 0) { var_a = var_a + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value28 = var_a; } require(success2); var_bb = 0; (bool success3, bytes memory returnData3) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay); // delegatecall uint256 value29 = 0x60; if (returnData3.length != 0) { var_a = var_a + ((returnData3.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value29 = var_a; } require(success3); } } } uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_aa; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value19 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success4, bytes memory returnData4) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba, var_bb, var_bc); // delegatecall uint256 value30 = 0x60; if (returnData4.length != 0) { var_a = var_a + ((returnData4.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value30 = var_a; } require(success4); (bool success5, bytes memory returnData5) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az); // delegatecall uint256 value31 = 0x60; if (returnData5.length != 0) { var_a = var_a + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value31 = var_a; } require(success5); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_bb = 0; (bool success6, bytes memory returnData6) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba); // delegatecall uint256 value32 = 0x60; if (returnData6.length != 0) { var_a = var_a + ((returnData6.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value32 = var_a; } require(success6); var_a = value25; var_az = 0; (bool success7, bytes memory returnData7) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av); // delegatecall uint256 value33 = 0x60; if (returnData7.length != 0) { var_a = var_a + ((returnData7.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value33 = var_a; } require(success7); } } value14 = 0; value16 = value2 + 0x20; value15 = var_v; value17 = 0; value18 = value2; value19 = value25 + 0x20; while (true) { if (value14 >= value15) { break; } if ((0x01 + value14) >= value15) { break; } value14 = 0x01 + value14; value16 = value16 + 0x20; value15 = value15; value17 = value17; value18 = value18; value19 = 0x20 + value19; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_aa; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value19) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success8, bytes memory returnData8) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba, var_bb, var_bc); // delegatecall uint256 value34 = 0x60; if (returnData8.length != 0) { var_a = var_a + ((returnData8.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value34 = var_a; } require(success8); (bool success9, bytes memory returnData9) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az); // delegatecall uint256 value35 = 0x60; if (returnData9.length != 0) { var_a = var_a + ((returnData9.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value35 = var_a; } require(success9); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success10, bytes memory returnData10) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba); // delegatecall uint256 value36 = 0x60; if (returnData10.length != 0) { var_a = var_a + ((returnData10.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value36 = var_a; } require(success10); var_a = value25; var_az = 0; (bool success11, bytes memory returnData11) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw); // delegatecall uint256 value37 = 0x60; if (returnData11.length != 0) { var_a = var_a + ((returnData11.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value37 = var_a; } require(success11); } } } value20 = 0; value22 = value9 + 0x20; value21 = var_aa; value23 = 0; value24 = value9; value25 = value19 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value25) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_bb = 0; (bool success12, bytes memory returnData12) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba); // delegatecall uint256 value38 = 0x60; if (returnData12.length != 0) { var_a = var_a + ((returnData12.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value38 = var_a; } require(success12); var_a = value25; (bool success13, bytes memory returnData13) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax); // delegatecall uint256 value39 = 0x60; if (returnData13.length != 0) { var_a = var_a + ((returnData13.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value39 = var_a; } require(success13); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_a = 0x20 + value25; var_az = 0; (bool success14, bytes memory returnData14) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay); // delegatecall uint256 value40 = 0x60; if (returnData14.length != 0) { var_a = var_a + ((returnData14.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value40 = var_a; } require(success14); var_a = value25; var_ax = 0; (bool success15, bytes memory returnData15) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bj, var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as); // delegatecall uint256 value41 = 0x60; if (returnData15.length != 0) { var_a = var_a + ((returnData15.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value41 = var_a; } require(success15); } } } } uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_p; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value19 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + (0x01 + value20); value22 = (value22 + 0x20) + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + (0x20 + value25); uint256 value14 = 0; uint256 value16 = value2 + 0x20; uint256 value15 = var_v; uint256 value17 = 0; uint256 value18 = value2; uint256 value19 = (0x20 + value25) + 0x20; while (true) { if (value14 >= value15) { break; } if ((0x01 + value14) >= value15) { break; } value14 = 0x01 + value14; value16 = value16 + 0x20; value15 = value15; value17 = value17; value18 = value18; value19 = 0x20 + value19; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_aa; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value19) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success16, bytes memory returnData16) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba, var_bb, var_bc); // delegatecall uint256 value42 = 0x60; if (returnData16.length != 0) { var_a = var_a + ((returnData16.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value42 = var_a; } require(success16); (bool success17, bytes memory returnData17) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az); // delegatecall uint256 value43 = 0x60; if (returnData17.length != 0) { var_a = var_a + ((returnData17.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value43 = var_a; } require(success17); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success18, bytes memory returnData18) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba); // delegatecall uint256 value44 = 0x60; if (returnData18.length != 0) { var_a = var_a + ((returnData18.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value44 = var_a; } require(success18); var_a = value25; var_az = 0; (bool success19, bytes memory returnData19) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw); // delegatecall uint256 value45 = 0x60; if (returnData19.length != 0) { var_a = var_a + ((returnData19.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value45 = var_a; } require(success19); } } } uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_aa; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value19 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value25) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success20, bytes memory returnData20) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba); // delegatecall uint256 value46 = 0x60; if (returnData20.length != 0) { var_a = var_a + ((returnData20.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value46 = var_a; } require(success20); var_a = value25; (bool success21, bytes memory returnData21) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax); // delegatecall uint256 value47 = 0x60; if (returnData21.length != 0) { var_a = var_a + ((returnData21.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value47 = var_a; } require(success21); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_a = 0x20 + value25; var_az = 0; (bool success22, bytes memory returnData22) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay); // delegatecall uint256 value48 = 0x60; if (returnData22.length != 0) { var_a = var_a + ((returnData22.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value48 = var_a; } require(success22); var_a = value25; var_ax = 0; (bool success23, bytes memory returnData23) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bj, var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at); // delegatecall uint256 value49 = 0x60; if (returnData23.length != 0) { var_a = var_a + ((returnData23.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value49 = var_a; } require(success23); } } value14 = 0; value16 = value2 + 0x20; value15 = var_v; value17 = 0; value18 = value2; value19 = value25 + 0x20; while (true) { if (value14 >= value15) { break; } if ((0x01 + value14) >= value15) { break; } value14 = 0x01 + (0x01 + value14); value16 = (value16 + 0x20) + 0x20; value15 = value15; value17 = value17; value18 = value18; value19 = 0x20 + (0x20 + value19); uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_aa; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value19) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value25) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; (bool success24, bytes memory returnData24) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay, var_az, var_ba); // delegatecall uint256 value50 = 0x60; if (returnData24.length != 0) { var_a = var_a + ((returnData24.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value50 = var_a; } require(success24); var_a = value25; (bool success25, bytes memory returnData25) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax); // delegatecall uint256 value51 = 0x60; if (returnData25.length != 0) { var_a = var_a + ((returnData25.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value51 = var_a; } require(success25); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_a = 0x20 + value25; (bool success26, bytes memory returnData26) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay); // delegatecall uint256 value52 = 0x60; if (returnData26.length != 0) { var_a = var_a + ((returnData26.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value52 = var_a; } require(success26); var_a = value25; var_ax = 0; (bool success27, bytes memory returnData27) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bj, var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au); // delegatecall uint256 value53 = 0x60; if (returnData27.length != 0) { var_a = var_a + ((returnData27.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value53 = var_a; } require(success27); } } } value20 = 0; value22 = value9 + 0x20; value21 = var_aa; value23 = 0; value24 = value9; value25 = value19 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + (0x01 + value20); value22 = (value22 + 0x20) + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + (0x20 + value25); uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_af; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value25) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_a = 0x20 + value25; (bool success28, bytes memory returnData28) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw, var_ax, var_ay); // delegatecall uint256 value54 = 0x60; if (returnData28.length != 0) { var_a = var_a + ((returnData28.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value54 = var_a; } require(success28); var_a = value25; (bool success29, bytes memory returnData29) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bj, var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av); // delegatecall uint256 value55 = 0x60; if (returnData29.length != 0) { var_a = var_a + ((returnData29.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value55 = var_a; } require(success29); } value20 = 0; value22 = value9 + 0x20; value21 = var_af; value23 = 0; value24 = value9; value25 = value25 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + (0x01 + value20); value22 = (value22 + 0x20) + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + (0x20 + value25); var_a = 0x20 + value25; (bool success30, bytes memory returnData30) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bj, var_bh, var_bg, var_bf, var_ao, var_ap, var_aq, var_ar, var_as, var_at, var_au, var_av, var_aw); // delegatecall uint256 value56 = 0x60; if (returnData30.length != 0) { var_a = var_a + ((returnData30.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value56 = var_a; } require(success30); var_a = value25; (bool success31, bytes memory returnData31) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_acd877c0(var_bk, var_bj, var_bh, var_bg, var_bf, var_ao, var_ap); // delegatecall uint256 value57 = 0x60; if (returnData31.length != 0) { var_a = var_a + ((returnData31.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value57 = var_a; } require(success31); } } } } } } } } } function userInfo(address account) public view returns (bytes memory) { return abi.encodePacked(mapping_e[account], stor_expr_m, stor_expr_n, stor_expr_o, stor_expr_p, stor_expr_q, stor_expr_r, stor_expr_s, stor_expr_t, stor_expr_u, stor_expr_v, stor_expr_w, stor_expr_x); } function setLimit(uint256 arg0, uint256 arg1) public onlyOwner { ETH_MIN_LIMIT = (arg0) ? 1 : 0; ETH_MAX_LIMIT = (arg1) ? 1 : 0; } function transferFrom(address from, address to, uint256 amount) public returns (bool) { if (mapping_1[from][msg.sender] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { require(!(mapping_1[from][msg.sender] < amount), ERC20InsufficientAllowance(msg.sender, mapping_1[from][msg.sender], amount)); require(from != address(0), ERC20InvalidApprover(address(0))); require(msg.sender != address(0), ERC20InvalidSpender(address(0))); mapping_1[from][msg.sender] = mapping_1[from][address(msg.sender)] - amount; } require(from != address(0), ERC20InvalidSender(address(0))); require(to != address(0), ERC20InvalidReceiver(address(0))); if (!(bytes1(stor_1f))) { uint256 var_e; var_e = 0x44 + var_e; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).executeReward(var_j); // delegatecall uint256 value0 = 0x60; if (returnData0.length != 0) { var_e = var_e + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_e; } require(success0); var_e = 0x44 + var_e; (bool success1, bytes memory returnData1) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).executeReward(var_n); // delegatecall uint256 value1 = 0x60; if (returnData1.length != 0) { var_e = var_e + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_e; } require(success1); if (!(isWL[from] || isWL[to])) { require(!mapping_13[from], "transfer error"); if (((0xff & stor_b) == 0x0) && (basePair != from)) { var_e = 0x20 + (var_e + (0x20 * stor_expr_bx)); uint256 value4 = stor_expr_bx; uint256 value5 = (keccak256(abi.encode(from, 0x0e))) + 0x0d; uint256 value6 = var_e + 0x20; if (stor_expr_bx != 0) { uint256 value2 = 0x20 + (var_e + 0x20); uint256 value3 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(from, 0x0e)) + 0x0d))); uint256 value35; uint256 value34; while (true) { value34 = 0x20 + value2; value35 = 0x01 + value3; if ((var_e + 0x20) + (0x20 * stor_expr_bx) <= value2) { break; } if ((var_e + 0x20) + (0x20 * stor_expr_bx) <= (0x20 + value2)) { break; } value2 = 0x20 + (0x20 + value2); value3 = 0x01 + (0x01 + value3); } value34 = value2; value35 = value3; value4 = value34; value5 = value35; value6 = (var_e + 0x20) + (0x20 * stor_expr_bx); } bool flag2 = !(var_ar < 0x152d02c7e14af6800000); if (!(var_ar < 0x152d02c7e14af6800000)) { flag2 = !(var_as < 0x09); } uint256 value7; if (!flag2) { bool flag3 = !(var_ar < 0x010f0cf064dd59200000); if (!(var_ar < 0x010f0cf064dd59200000)) { flag3 = !(var_as < 0x08); } uint256 value36; if (!flag3) { bool flag4 = !(var_ar < 0x6c6b935b8bbd400000); if (!(var_ar < 0x6c6b935b8bbd400000)) { flag4 = !(var_as < 0x07); } uint256 value37; if (!flag4) { bool flag5 = !(var_ar < 0x3635c9adc5dea00000); if (!(var_ar < 0x3635c9adc5dea00000)) { flag5 = !(var_as < 0x06); } uint256 value38; if (!flag5) { bool flag6 = !(var_ar < 0x1043561a8829300000); if (!(var_ar < 0x1043561a8829300000)) { flag6 = !(var_as < 0x05); } uint256 value39; if (!flag6) { bool flag7 = !(var_ar < 0x056bc75e2d63100000); if (!(var_ar < 0x056bc75e2d63100000)) { flag7 = !(var_as < 0x04); } uint256 value40; if (!flag7) { bool flag8 = !(var_ar < 0x01a055690d9db80000); if (!(var_ar < 0x01a055690d9db80000)) { flag8 = !(var_as < 0x03); } uint256 value41; if (!flag8) { bool flag9 = !(var_ar < 0x8ac7230489e80000); if (!(var_ar < 0x8ac7230489e80000)) { flag9 = !(var_as < 0x02); } uint256 value42; if (!flag9) { bool flag10 = !(var_ar < 0x4563918244f40000); if (!(var_ar < 0x4563918244f40000)) { flag10 = !(var_at < 0x1bc16d674ec80000); } uint256 value43 = 0; if (flag10) { value43 = 0x01; } value42 = value43; } else { value42 = 0x02; } value41 = value42; } else { value41 = 0x03; } value40 = value41; } else { value40 = 0x04; } value39 = value40; } else { value39 = 0x05; } value38 = value39; } else { value38 = 0x06; } value37 = value38; } else { value37 = 0x07; } value36 = value37; } else { value36 = 0x08; } value7 = value36; } else { value7 = 0x09; } bool flag11 = value7 == 0x0; if (value7 == 0) { flag11 = var_au > 0; } uint256 value8 = value7; if (flag11) { value8 = 0x01; } if (mapping_0[from] > (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])) { if (from != address(0)) { require(!(mapping_0[from] < (mapping_0[from] - (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])))); mapping_0[from] = mapping_0[from] - (mapping_0[from] - (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])); } else { totalSupply = (mapping_0[from] - (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])) + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = (mapping_0[from] - (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])) + mapping_0[address(0)]; } else { totalSupply = totalSupply - (mapping_0[from] - (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])); } emit Transfer(from, address(0), mapping_0[from] - (unresolved_11cb3b3e[from] + unresolved_1a449f57[value8])); } } if (from != basePair) { if (to == basePair) { (bool success2, bytes memory returnData2) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success2); var_e = var_e + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData2.length) - var_e >= 0x60); require(var_ax == (uint32(var_ax))); if ((uint112(var_e.length) > 0) && (var_bb < (uint32(var_ba) / 0x015180))) { var_e = var_e + 0x60; stor_1b = uint112(var_e.length); stor_1c = uint112(var_g); lastDayReserves = (uint32(var_ba)) / 0x015180; emit Sync(uint32(var_ba) / 0x015180, uint112(var_e.length), uint112(var_bc), var_e.length); } if (((0xff & stor_b) == 0x0) && ((totalSupply <= 0xcb49b44ba602d800000) || ((0xffffffffffffffffffffffffffff & var_bd) >= 0x27b46536c66c8e3000000))) { stor_b = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_b); } uint256 value9 = 0x01; value9 = (lastMiningDay > 0) ? 1 : 0; if (!(value9 == 0x0)) { if (0x0 != totalPower) { if ((block.timestamp / 0x015180) > lastMiningDay) { uint256 value10; if (uint112(var_e.length) <= 0x23bbf4b14c2e7ff800000) { uint256 value44; if (uint112(var_e.length) <= 0x1fc3842bd1f071c000000) { uint256 value45; if (uint112(var_e.length) <= 0x1bcb13a657b2638800000) { uint256 value46; if (uint112(var_e.length) <= 0x17d2a320dd74555000000) { uint256 value47; if (uint112(var_e.length) <= 0x13da329b6336471800000) { uint256 value48; if (uint112(var_e.length) <= 0xfe1c215e8f838e000000) { uint256 value49; if (uint112(var_e.length) <= 0xbe951906eba2aa800000) { uint256 value50 = 0; if (uint112(var_e.length) > 0x7f0e10af47c1c7000000) { value50 = 0x0927c0; } value49 = value50; } else { value49 = 0x0dbba0; } value48 = value49; } else { value48 = 0x124f80; } value47 = value48; } else { value47 = 0x16e360; } value46 = value47; } else { value46 = 0x1b7740; } value45 = value46; } else { value45 = 0x200b20; } value44 = value45; } else { value44 = 0x249f00; } value10 = value44; } else { value10 = 0x2932e0; } var_e = 0x40 + var_e; uint256 value11 = mapping_16[value10]; if (totalSupply <= 0x0cb49b44ba602d800000) { value11 = 0; } if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < (stor_expr_cn * (uint112(var_g)) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - (stor_expr_cn * (uint112(var_g)) / 0x03e8); } else { totalSupply = (stor_expr_cn * (uint112(var_g)) / 0x03e8) + totalSupply; } if (address(this) != address(0)) { mapping_0[address(this)] = (stor_expr_cn * (uint112(var_g)) / 0x03e8) + mapping_0[address(this)]; } else { totalSupply = totalSupply - (stor_expr_cn * (uint112(var_g)) / 0x03e8); } emit Transfer(address(basePair), address(this), (stor_expr_cn * (uint112(var_g)) / 0x03e8)); if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < ((value11 * (uint112(var_g))) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - ((value11 * (uint112(var_g))) / 0x03e8); } else { totalSupply = ((value11 * (uint112(var_g))) / 0x03e8) + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = ((value11 * (uint112(var_g))) / 0x03e8) + mapping_0[address(0)]; } else { totalSupply = totalSupply - ((value11 * (uint112(var_g))) / 0x03e8); } emit Transfer(address(basePair), address(0), ((value11 * (uint112(var_g))) / 0x03e8)); unresolved_849b0dcd = (((stor_expr_cn * (uint112(var_g)) / 0x03e8) * 0xc097ce7bc90715b34b9f1000000000) / totalPower) + unresolved_849b0dcd; lastMiningDay = block.timestamp / 0x015180; require(basePair.code.length != 0x0); (bool success3, bytes memory returnData3) = basePair.sync(); // call require(success3); emit Mining(block.timestamp / 0x015180, uint112(var_g), uint112(var_e.length), (value11 * (uint112(var_g))) / 0x03e8, (stor_expr_cn * (uint112(var_g))) / 0x03e8); } } } require((startTime > 0x0 && block.timestamp > startTime), "launched"); require(!(bytes1(buyBlockMapping[tx.origin][block.number])), "no flash"); (bool success4, bytes memory returnData4) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success4); var_e = var_e + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData4.length) - var_e >= 0x60); require(var_be == (uint32(var_be))); var_e = var_e + 0x60; if (0 != stor_1b && !(bytes1(stor_b))) { } } } else { (bool success5, bytes memory returnData5) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success5); var_e = var_e + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData5.length) - var_e >= 0x60); require(var_bh == (uint32(var_bh))); (bool success6, bytes memory returnData6) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(basePair); // staticcall require(success6); uint256 accountBalance = abi.decode(returnData6, (uint256)); uint256 value13 = 0; uint256 value14 = 0; if (!(accountBalance < (uint112(var_e.length)))) { uint256 value12 = 0; if (((0xffffffffffffffffffffffffffff & var_bd) > 0x0) && ((0xffffffffffffffffffffffffffff & var_g) > 0x0)) { require(!(accountBalance < (uint112(var_e.length) + ((uint112(var_e.length) * amount) / (uint112(var_bc) - amount))))); value12 = (uint112(var_e.length) * amount) / (uint112(var_bc) - amount); } } else { (bool success7, bytes memory returnData7) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success7); var_e = var_e + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData7.length) - var_e >= 0x20); value13 = (uint112(var_e.length)) - accountBalance; value14 = (var_e.length * amount) / (mapping_0[basePair] - amount); } if (value14 == 0) { (bool success8, bytes memory returnData8) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success8); var_e = var_e + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData8.length) - var_e >= 0x60); require(var_ax == (uint32(var_ax))); if ((uint112(var_e.length) > 0) && (var_bb < (uint32(var_ba) / 0x015180))) { var_e = var_e + 0x60; stor_1b = uint112(var_e.length); stor_1c = uint112(var_g); lastDayReserves = (uint32(var_ba)) / 0x015180; emit Sync(uint32(var_ba) / 0x015180, uint112(var_e.length), uint112(var_bc), var_e.length); } if (((0xff & stor_b) == 0x0) && ((totalSupply <= 0xcb49b44ba602d800000) || ((0xffffffffffffffffffffffffffff & var_bd) >= 0x27b46536c66c8e3000000))) { stor_b = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_b); } uint256 value15 = 0; if (!(value15 == 0x0)) { if (0x0 != totalPower) { if ((block.timestamp / 0x015180) > lastMiningDay) { uint256 value16; if (uint112(var_e.length) <= 0x23bbf4b14c2e7ff800000) { uint256 value51; if (uint112(var_e.length) <= 0x1fc3842bd1f071c000000) { uint256 value52; if (uint112(var_e.length) <= 0x1bcb13a657b2638800000) { uint256 value53; if (uint112(var_e.length) <= 0x17d2a320dd74555000000) { uint256 value54; if (uint112(var_e.length) <= 0x13da329b6336471800000) { uint256 value55; if (uint112(var_e.length) <= 0xfe1c215e8f838e000000) { uint256 value56; if (uint112(var_e.length) <= 0xbe951906eba2aa800000) { uint256 value57 = 0; if (uint112(var_e.length) > 0x7f0e10af47c1c7000000) { value57 = 0x0927c0; } value56 = value57; } else { value56 = 0x0dbba0; } value55 = value56; } else { value55 = 0x124f80; } value54 = value55; } else { value54 = 0x16e360; } value53 = value54; } else { value53 = 0x1b7740; } value52 = value53; } else { value52 = 0x200b20; } value51 = value52; } else { value51 = 0x249f00; } value16 = value51; } else { value16 = 0x2932e0; } var_e = 0x40 + var_e; uint256 value17 = mapping_16[value16]; if (totalSupply <= 0x0cb49b44ba602d800000) { value17 = 0; } if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < (stor_expr_cy * (uint112(var_g)) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - (stor_expr_cy * (uint112(var_g)) / 0x03e8); } else { totalSupply = (stor_expr_cy * (uint112(var_g)) / 0x03e8) + totalSupply; } if (address(this) != address(0)) { mapping_0[address(this)] = (stor_expr_cy * (uint112(var_g)) / 0x03e8) + mapping_0[address(this)]; } else { totalSupply = totalSupply - (stor_expr_cy * (uint112(var_g)) / 0x03e8); } emit Transfer(address(basePair), address(this), (stor_expr_cy * (uint112(var_g)) / 0x03e8)); if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < ((value17 * (uint112(var_g))) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - ((value17 * (uint112(var_g))) / 0x03e8); } else { totalSupply = ((value17 * (uint112(var_g))) / 0x03e8) + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = ((value17 * (uint112(var_g))) / 0x03e8) + mapping_0[address(0)]; } else { totalSupply = totalSupply - ((value17 * (uint112(var_g))) / 0x03e8); } emit Transfer(address(basePair), address(0), ((value17 * (uint112(var_g))) / 0x03e8)); unresolved_849b0dcd = (((stor_expr_cy * (uint112(var_g)) / 0x03e8) * 0xc097ce7bc90715b34b9f1000000000) / totalPower) + unresolved_849b0dcd; lastMiningDay = block.timestamp / 0x015180; require(basePair.code.length != 0x0); (bool success9, bytes memory returnData9) = basePair.sync(); // call require(success9); emit Mining(block.timestamp / 0x015180, uint112(var_g), uint112(var_e.length), (value17 * (uint112(var_g))) / 0x03e8, (stor_expr_cy * (uint112(var_g))) / 0x03e8); } } } var_e = var_e + 0x60; if (!(0 < var_e.length)) _desolexPanic(50); if (!(0x01 < var_e.length)) _desolexPanic(50); uint256 value18 = 0; uint256 value20 = var_e + 0x20; uint256 value19 = var_bl; uint256 value21 = 0; uint256 value22 = var_e; uint256 value23 = ((0x04 + var_e) + 0x40) + 0x20; while (true) { if (value18 >= value19) { break; } value18 = 0x01 + value18; value20 = value20 + 0x20; value19 = value19; value21 = value21; value22 = value22; value23 = 0x20 + value23; } (bool success10, bytes memory returnData10) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).getAmountsIn(amount, 0x40); // staticcall require(success10); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData10.length + 0x1f)); require((var_e + returnData10.length) - var_e >= 0x20); require(!(var_br > 0xffffffffffffffff)); require((var_e + returnData10.length) > ((var_e + var_br) + 0x1f)); if (!(var_bs <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bs << 0x05)) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bs << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bs << 0x05)) + 0x1f)); require(!(((var_e + var_br) + (var_bt << 0x05) + 0x20) > (var_e + returnData10.length))); uint256 value26 = var_e; uint256 value27 = var_e + 0x20; uint256 value25 = ((var_e + var_br) + (var_bt << 0x05)) + 0x20; uint256 value24 = (var_e + var_br) + 0x20; uint256 value28 = 0; uint256 value29 = var_e; uint256 value30 = var_e + returnData10.length; while (true) { if (value24 >= value25) { break; } if ((0x20 + value24) >= value25) { break; } value26 = value26; value27 = (value27 + 0x20) + 0x20; value25 = value25; value24 = 0x20 + (0x20 + value24); value28 = value28; value29 = value29; value30 = value30; if (!(0 < var_bw)) _desolexPanic(50); if (!(bytes1(stor_b))) { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(basePair).getReserves(); require(!(uint112(reserve0) < 0x01a784379d99db42000000), "un launched"); require(userBuyUsdtAmount[to] < mapping_f[to], "buy limit"); require(!(var_ca > (mapping_f[to] - userBuyUsdtAmount[to])), "buy limit"); } if (from != address(0)) { require(!(mapping_0[from] < ((amount * 0x01f4) / 0x2710))); mapping_0[from] = mapping_0[from] - ((amount * 0x01f4) / 0x2710); } else { totalSupply = ((amount * 0x01f4) / 0x2710) + totalSupply; } if ((stor_24 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(stor_24)] = ((amount * 0x01f4) / 0x2710) + mapping_0[address(stor_24)]; } else { totalSupply = totalSupply - ((amount * 0x01f4) / 0x2710); } emit Transfer(from, address(stor_24), ((amount * 0x01f4) / 0x2710)); if (from != address(0)) { require(!(mapping_0[from] < (amount - ((amount * 0x01f4) / 0x2710)))); mapping_0[from] = mapping_0[from] - (amount - ((amount * 0x01f4) / 0x2710)); } else { totalSupply = (amount - ((amount * 0x01f4) / 0x2710)) + totalSupply; } if (to != address(0)) { mapping_0[to] = (amount - ((amount * 0x01f4) / 0x2710)) + mapping_0[to]; } else { totalSupply = totalSupply - (amount - ((amount * 0x01f4) / 0x2710)); } emit Transfer(from, to, (amount - ((amount * 0x01f4) / 0x2710))); userBuyUsdtAmount[to] = var_ca + userBuyUsdtAmount[to]; unresolved_11cb3b3e[to] = (amount - ((amount * 0x01f4) / 0x2710)) + unresolved_11cb3b3e[to]; buyBlockMapping[tx.origin][block.number] = true; emit Buy(to, var_ca, (amount - ((amount * 0x01f4) / 0x2710)), ((amount * 0x01f4) / 0x2710)); return true; } if (!(0 < var_cb)) _desolexPanic(50); if (!(bytes1(stor_b))) { (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(basePair).getReserves(); require(!(uint112(var_cc) < 0x01a784379d99db42000000), "un launched"); require(userBuyUsdtAmount[to] < mapping_f[to], "buy limit"); require(!(var_cd > (mapping_f[to] - userBuyUsdtAmount[to])), "buy limit"); } internal_3c8b(((amount * 0x01f4) / 0x2710), stor_24, from); internal_3c8b((amount - ((amount * 0x01f4) / 0x2710)), to, from); userBuyUsdtAmount[to] = var_cd + userBuyUsdtAmount[to]; unresolved_11cb3b3e[to] = (amount - ((amount * 0x01f4) / 0x2710)) + unresolved_11cb3b3e[to]; buyBlockMapping[tx.origin][block.number] = true; emit Buy(to, var_ca, (amount - ((amount * 0x01f4) / 0x2710)), ((amount * 0x01f4) / 0x2710)); } else { require(to == tx.origin, "err origin"); require(!(stor_expr_dm < ((stor_expr_dn * value14) / stor_expr_do)), "err lp amount"); stor_expr_dq = stor_expr_dq - value14; require(!(0x03e8 < stor_expr_do), "lp must remove all"); if (stor_expr_do != 0) { stor_expr_do = 0; } uint256 value31 = 0; uint256 value32 = 0; while (true) { stor_expr_dr = 0; emit RemoveLp(to, (value14), ((stor_expr_dk * value14) / stor_expr_dl), amount); if (!(value31 < stor_expr_ds)) { break; } if (((0x1 == stor_expr_dv) || (0x2 == stor_expr_dv)) && ((0xff & stor_expr_dw) == 0x0)) { stor_expr_dx = 0; if (stor_expr_dy != 0) { totalPower = totalPower - stor_expr_ea; stor_expr_dn = stor_expr_dn - stor_expr_dy; stor_expr_dy = 0; } emit Event_03ad3c3e(mapping_d[stor_expr_dt], 0, 0x02); } uint256 value33 = value32; if ((0x1 == stor_expr_dv) || (0x2 == stor_expr_dv)) { value33 = stor_expr_ee + value32; } value31 = 0x01 + value31; value32 = value33; } stor_expr_ef = value32; stor_expr_eg = (unresolved_849b0dcd * stor_expr_dn) / 0xc097ce7bc90715b34b9f1000000000; internal_3c8b(amount, 0, from); } return true; } } else { if (from != address(0)) { require(!(mapping_0[from] < amount)); mapping_0[from] = mapping_0[from] - amount; if (to != address(0)) { mapping_0[to] = amount + mapping_0[to]; // Decompilation incomplete: internal helper 0x3da4(0x20 + var_e, 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, address(from), address(to), amount, to, from) occurrence=2947 return=0x1ebd kind=reuse may have stateful effects. } else { totalSupply = totalSupply - amount; // Decompilation incomplete: internal helper 0x3d5f(amount, to, from) occurrence=2946 return=0x1ebd kind=reuse may have stateful effects. } } else { totalSupply = amount + totalSupply; // Decompilation incomplete: internal helper 0x3d25(amount, to, from) occurrence=2943 return=0x1ebd kind=reuse may have stateful effects. } return true; } } else { if (from != address(0)) { require(!(mapping_0[from] < amount)); mapping_0[from] = mapping_0[from] - amount; if (to != address(0)) { mapping_0[to] = amount + mapping_0[to]; emit Transfer(from, to, amount); } else { totalSupply = totalSupply - amount; emit Transfer(from, to, amount); } } else { totalSupply = amount + totalSupply; if (to != address(0)) { mapping_0[to] = amount + mapping_0[to]; emit Transfer(from, to, amount); } else { totalSupply = totalSupply - amount; emit Transfer(from, to, amount); } } return true; } } function getMiningAndBurnRate(uint256 index) public view returns (bytes memory) { internal_20e0(index); return abi.encodePacked(stor_expr_el, value1); } function getSellFee() public returns (bool) { IDesolexUniswapV2Pair(basePair).getReserves(); uint256 var_b; var_b = var_b + 0x60; uint256 value0; uint256 value1; uint256 value2; if (0x0 != stor_1b) { uint256 value3; uint256 value4; uint256 value5 = 0x05; if (bytes1(stor_b) != 0x0) { uint256 value6 = 0; uint256 value8 = 0; if (totalSupply > 0x0cb49b44ba602d800000) { uint256 value11; if (!(uint112(var_g) < 0xd3c21bcecceda1000000)) { uint256 value12 = 0x1e; if (!(((uint112(var_g) * 0x0de0b6b3a7640000) / (uint112(var_f)) * 0x64) / ((var_b.length * 0x0de0b6b3a7640000) / var_f) > 0x67)) { value12 = 0x32; } value11 = value12; } else { value11 = 0x64; } value6 = value11; value8 = 0x01; } value3 = value6; value4 = value8; } else { uint256 value7; uint256 value9; uint256 value10; if (!(((uint112(var_g) * 0x64) / var_b.length) < 0x5d)) { uint256 value13; uint256 value15; uint256 value17; if (!(((uint112(var_g) * 0x64) / var_b.length) < 0x5e)) { uint256 value18; uint256 value20; uint256 value22; if (!(((uint112(var_g) * 0x64) / var_b.length) < 0x5f)) { uint256 value23; uint256 value25; uint256 value27; if (!(((uint112(var_g) * 0x64) / var_b.length) < 0x60)) { uint256 value32 = 0x05; if (((uint112(var_g) * 0x64) / var_b.length) < 0x61) { value32 = 0x0a; } uint256 value28 = 0; uint256 value30 = 0; if (totalSupply > 0x0cb49b44ba602d800000) { uint256 value33; if (!(uint112(var_g) < 0xd3c21bcecceda1000000)) { uint256 value34 = 0x1e; if (!(((uint112(var_g) * 0x0de0b6b3a7640000) / (uint112(var_f)) * 0x64) / ((var_b.length * 0x0de0b6b3a7640000) / var_f) > 0x67)) { value34 = 0x32; } value33 = value34; } else { value33 = 0x64; } value28 = value33; value30 = 0x01; } value23 = value28; value25 = value30; value27 = value32; } else { uint256 value29 = 0; uint256 value31 = 0; if (totalSupply > 0x0cb49b44ba602d800000) { uint256 value35; if (!(uint112(var_g) < 0xd3c21bcecceda1000000)) { uint256 value36 = 0x1e; if (!(((uint112(var_g) * 0x0de0b6b3a7640000) / (uint112(var_f)) * 0x64) / ((var_b.length * 0x0de0b6b3a7640000) / var_f) > 0x67)) { value36 = 0x32; } value35 = value36; } else { value35 = 0x64; } value29 = value35; value31 = 0x01; } value23 = value29; value25 = value31; value27 = 0x14; } value18 = value23; value20 = value25; value22 = value27; } else { uint256 value24 = 0; uint256 value26 = 0; if (totalSupply > 0x0cb49b44ba602d800000) { uint256 value37; if (!(uint112(var_g) < 0xd3c21bcecceda1000000)) { uint256 value38 = 0x1e; if (!(((uint112(var_g) * 0x0de0b6b3a7640000) / (uint112(var_f)) * 0x64) / ((var_b.length * 0x0de0b6b3a7640000) / var_f) > 0x67)) { value38 = 0x32; } value37 = value38; } else { value37 = 0x64; } value24 = value37; value26 = 0x01; } value18 = value24; value20 = value26; value22 = 0x1e; } value13 = value18; value15 = value20; value17 = value22; } else { uint256 value19 = 0; uint256 value21 = 0; if (totalSupply > 0x0cb49b44ba602d800000) { uint256 value39; if (!(uint112(var_g) < 0xd3c21bcecceda1000000)) { uint256 value40 = 0x1e; if (!(((uint112(var_g) * 0x0de0b6b3a7640000) / (uint112(var_f)) * 0x64) / ((var_b.length * 0x0de0b6b3a7640000) / var_f) > 0x67)) { value40 = 0x32; } value39 = value40; } else { value39 = 0x64; } value19 = value39; value21 = 0x01; } value13 = value19; value15 = value21; value17 = 0x28; } value7 = value13; value9 = value15; value10 = value17; } else { uint256 value14 = 0; uint256 value16 = 0; if (totalSupply > 0x0cb49b44ba602d800000) { uint256 value41; if (!(uint112(var_g) < 0xd3c21bcecceda1000000)) { uint256 value42 = 0x1e; if (!(((uint112(var_g) * 0x0de0b6b3a7640000) / (uint112(var_f)) * 0x64) / ((var_b.length * 0x0de0b6b3a7640000) / var_f) > 0x67)) { value42 = 0x32; } value41 = value42; } else { value41 = 0x64; } value14 = value41; value16 = 0x01; } value7 = value14; value9 = value16; value10 = 0x32; } value3 = value7; value4 = value9; value5 = value10; } value0 = value3; value1 = value4; value2 = value5; } else { value0 = 0; value1 = 0; value2 = 0x05; } return abi.encodePacked(value2, value1, uint112(var_f), value0); } function Unknown_2e106537(bytes32 arg0) public view returns (uint256) { return unresolved_1a449f57[arg0]; } function Unknown_2e51b77e(bytes memory arg0, bytes memory arg1) public { if (!(arg0 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + arg0) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = ((0x04 + arg0) + (arg0.length << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + arg0; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; if (arg1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); uint256 value7 = (0x04 + arg1) + 0x20; uint256 value8 = var_a + 0x20; while (true) { if (!(value7 < ((0x04 + arg1) + (arg1.length << 0x05) + 0x20))) { break; } require(!(msg.data[value7] > 0xffffffffffffffff)); require(((((0x04 + arg1) + msg.data[value7]) + 0x20) + 0x1f) < msg.data.length); if (!(((arg1 + msg.data[value7]) + 0x20) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (((arg1 + msg.data[value7]) + 0x20) << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (((arg1 + msg.data[value7]) + 0x20) << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (((arg1 + msg.data[value7]) + 0x20) << 0x05)) + 0x1f)); require(!(((((0x04 + arg1) + msg.data[value7]) + 0x20) + (((arg1 + msg.data[value7]) + 0x20) << 0x05) + 0x20) > msg.data.length)); uint256 value0 = ((0x04 + arg1) + (arg1 + 0x20) + 0x20) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = (((0x04 + arg1) + (arg1 + 0x20) + 0x20) + ((arg1 + (arg1 + 0x20) + 0x20) << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = ((0x04 + arg1) + (arg1 + 0x20)) + 0x20; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; value7 = 0x20 + value7; value8 = 0x20 + value8; } } require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value9 = 0; uint256 value11 = value2 + 0x20; uint256 value10 = var_f; uint256 value12 = 0; uint256 value13 = value2; uint256 value14 = ((0x24 + var_a) + 0x40) + 0x20; while (true) { if (value9 >= value10) { break; } if ((0x01 + value9) >= value10) { break; } value9 = 0x01 + (0x01 + value9); value11 = (value11 + 0x20) + 0x20; value10 = value10; value12 = value12; value13 = value13; value14 = 0x20 + (0x20 + value14); uint256 value15 = 0; uint256 value16 = var_a + 0x20; uint256 value17 = ((((0x24 + var_a) + 0x40) + 0x20) + (var_m << 0x05)) + 0x20; uint256 value18 = (((0x24 + var_a) + 0x40) + 0x20) + 0x20; uint256 var_aa; while (true) { if (!(value15 < var_m)) { break; } uint256 value9 = 0; uint256 value11 = var_q + 0x20; uint256 value10 = var_o; uint256 value12 = 0; uint256 value13 = var_q; uint256 value14 = value17 + 0x20; while (true) { if (value9 < value10) { if ((0x01 + value9) >= value10) { break; } value9 = 0x01 + value9; value11 = value11 + 0x20; value10 = value10; value12 = value12; value13 = value13; value14 = 0x20 + value14; if (!((0x01 + value15) < var_m)) { var_a = 0x20 + value14; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_2e51b77e(var_x, var_y, var_z, var_aa, var_ab, var_ac, var_ad); // delegatecall if (returnData0.length != 0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } require(success0); break; } value9 = 0; value11 = var_ae + 0x20; value10 = var_o; value12 = 0; value13 = var_ae; value14 = (0x20 + value14) + 0x20; break; } if (!((0x01 + value15) < var_m)) { var_a = value14; (bool success1, bytes memory returnData1) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_2e51b77e(var_af, var_x, var_y, var_z, var_aa, var_ab); // delegatecall uint256 value21 = 0x60; if (returnData1.length != 0) { var_a = var_a + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value21 = var_a; } require(success1); break; } if (!(0 < var_o)) { break; } value9 = 0x01; value11 = (var_q + 0x20) + 0x20; value10 = var_o; value12 = 0; value13 = var_q; value14 = 0x20 + (value17 + 0x20); value15 = 0x01 + (0x01 + value15); value16 = 0x20 + (0x20 + value16); value17 = value14 + 0x20; value18 = 0x20 + (0x20 + value18); } } var_a = value17; var_aa = 0; (bool success2, bytes memory returnData2) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_2e51b77e(var_ah, var_af, var_x, var_y); // delegatecall uint256 value20 = 0x60; if (returnData2.length != 0) { var_a = var_a + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value20 = var_a; } require(success2); } uint256 value15 = 0; uint256 value16 = var_a + 0x20; uint256 value17 = ((((0x24 + var_a) + 0x40) + 0x20) + (var_m << 0x05)) + 0x20; uint256 value18 = (((0x24 + var_a) + 0x40) + 0x20) + 0x20; while (true) { if (!(value15 < var_m)) { break; } uint256 value9 = 0; uint256 value11 = var_q + 0x20; uint256 value10 = var_o; uint256 value12 = 0; uint256 value13 = var_q; uint256 value14 = value17 + 0x20; while (true) { if (value9 >= value10) { break; } if ((0x01 + value9) >= value10) { break; } value9 = 0x01 + (0x01 + value9); value11 = (value11 + 0x20) + 0x20; value10 = value10; value12 = value12; value13 = value13; value14 = 0x20 + (0x20 + value14); if (!((0x01 + value15) < var_m)) { var_a = 0x20 + value14; (bool success3, bytes memory returnData3) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_2e51b77e(var_af, var_x, var_y, var_z, var_aa, var_ab); // delegatecall if (returnData3.length != 0) { var_a = var_a + ((returnData3.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } require(success3); break; } value9 = 0; value11 = var_ae + 0x20; value10 = var_o; value12 = 0; value13 = var_ae; value14 = (0x20 + value14) + 0x20; } value15 = 0x01 + value15; value16 = 0x20 + value16; value17 = value14; value18 = 0x20 + value18; } var_a = value17; (bool success4, bytes memory returnData4) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_2e51b77e(var_ai, var_ah); // delegatecall uint256 value19 = 0x60; if (returnData4.length != 0) { var_a = var_a + ((returnData4.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value19 = var_a; } require(success4); } } function Unknown_33ffc7dd(address arg0, uint256 arg1) public view returns (address) { require(arg1 < mapping_19[arg0]); return stor_expr_eq; } function setAddresses(address arg0, address arg1, address arg2) public onlyOwner { addresses = arg0; stor_23 = arg1; stor_25 = arg2; } function startup(uint256 arg0) public onlyOwner { startTime = (arg0) ? 1 : 0; lastMiningDay = arg0 / 0x015180; } function sync(bool arg0) public { internal_252c(arg0); } function setBindStatus(bool arg0) public onlyOwner { stor_2b = arg0 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_2b); } function Unknown_5e9f9879(bytes memory arg0, bytes memory arg1) public { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + arg0) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = ((0x04 + arg0) + (arg0.length << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + arg0; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } require(msg.data[value0] == (address(msg.data[value0]))); value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; if (!(arg1.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); uint256 value7 = (0x04 + arg1) + 0x20; uint256 value9 = var_a; uint256 value10 = var_a + 0x20; uint256 value8 = ((0x04 + arg1) + (arg1.length << 0x05)) + 0x20; uint256 value11 = 0; uint256 value12 = 0x04 + arg1; uint256 value13 = msg.data.length; while (true) { if (value7 >= value8) { break; } value7 = 0x20 + value7; value9 = value9; value10 = 0x20 + value10; value8 = value8; value11 = value11; value12 = value12; value13 = value13; require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value14 = 0; uint256 value16 = value2 + 0x20; uint256 value15 = var_f; uint256 value17 = 0; uint256 value18 = value2; uint256 value19 = ((0x24 + var_a) + 0x40) + 0x20; while (true) { if (value14 >= value15) { break; } if ((0x01 + value14) >= value15) { break; } value14 = 0x01 + (0x01 + value14); value16 = (value16 + 0x20) + 0x20; value15 = value15; value17 = value17; value18 = value18; value19 = 0x20 + (0x20 + value19); uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_m; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = (0x20 + value19) + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + value20; value22 = value22 + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + value25; var_a = 0x20 + value25; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_a093fa47(var_v, var_w, var_x, var_y, var_z, var_aa); // delegatecall if (returnData0.length != 0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } require(success0); var_a = value25; (bool success1, bytes memory returnData1) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_a093fa47(var_ab, var_v, var_w, var_x); // delegatecall uint256 value26 = 0x60; if (returnData1.length != 0) { var_a = var_a + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value26 = var_a; } require(success1); } } uint256 value20 = 0; uint256 value22 = value9 + 0x20; uint256 value21 = var_m; uint256 value23 = 0; uint256 value24 = value9; uint256 value25 = value19 + 0x20; while (true) { if (value20 >= value21) { break; } if ((0x01 + value20) >= value21) { break; } value20 = 0x01 + (0x01 + value20); value22 = (value22 + 0x20) + 0x20; value21 = value21; value23 = value23; value24 = value24; value25 = 0x20 + (0x20 + value25); var_a = 0x20 + value25; (bool success2, bytes memory returnData2) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_a093fa47(var_ab, var_v, var_w, var_x, var_y); // delegatecall if (returnData2.length != 0) { var_a = var_a + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } require(success2); var_a = value25; (bool success3, bytes memory returnData3) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_a093fa47(var_ac, var_ab); // delegatecall uint256 value27 = 0x60; if (returnData3.length != 0) { var_a = var_a + ((returnData3.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value27 = var_a; } require(success3); } } } } function pending(address arg0) public view returns (uint256) { if (0x0 == totalPower) { return 0; } var_d = 0x20 + (var_d + (0x20 * stor_expr_aj)); uint256 value2 = stor_expr_aj; uint256 value3 = (keccak256(abi.encode(arg0, 0x0e))) + 0x0d; uint256 value4 = var_d + 0x20; if (stor_expr_aj != 0) { uint256 value0 = 0x20 + (var_d + 0x20); uint256 value1 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0e)) + 0x0d))); while (true) { if ((var_d + 0x20) + (0x20 * stor_expr_aj) <= value0) { break; } value0 = 0x20 + value0; value1 = 0x01 + value1; } value2 = value0; value3 = value1; value4 = (var_d + 0x20) + (0x20 * stor_expr_aj); } return (((unresolved_849b0dcd * (stor_expr_ac + var_ad)) / 0xc097ce7bc90715b34b9f1000000000) - var_ae) - stor_expr_ae; } function reward(address arg0) public { uint256 var_c; var_c = 0x44 + var_c; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).executeReward(var_h); // delegatecall uint256 value0 = 0x60; if (returnData0.length != 0) { var_c = var_c + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } require(success0); } function userInfoEx(address account) public view returns (bool) { return abi.encodePacked(mapping_f[account], stor_expr_z, stor_expr_aa, stor_expr_ab, stor_expr_ac, stor_expr_ad, stor_expr_ae, stor_expr_af, stor_expr_ag, stor_expr_ah, !(!(bytes1(stor_expr_fa)))); } function Unknown_656976a3(bytes memory arg0) public { require(!((msg.data.length - 0x04) < 0x40)); if (arg0.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + arg0) + 0x20; uint256 value1 = var_a + 0x20; while (true) { if (!(value0 < ((0x04 + arg0) + (arg0.length << 0x05) + 0x20))) { break; } value0 = 0x20 + value0; value1 = 0x20 + value1; } require(!(msg.data[0x04 + 0x20] > 0xffffffffffffffff)); require((0x04 + (msg.data[0x04 + 0x20])) + 0x1f < msg.data.length); if (!(msg.data[0x04 + (msg.data[0x04 + 0x20])] <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (msg.data[0x04 + (msg.data[0x04 + 0x20])] << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (msg.data[0x04 + (msg.data[0x04 + 0x20])] << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (msg.data[0x04 + (msg.data[0x04 + 0x20])] << 0x05)) + 0x1f)); require(!(((0x04 + (msg.data[0x04 + 0x20])) + (msg.data[0x04 + (msg.data[0x04 + 0x20])] << 0x05) + 0x20) > msg.data.length)); value0 = (0x04 + (msg.data[0x04 + 0x20])) + 0x20; uint256 value3 = var_a; value1 = var_a + 0x20; uint256 value2 = ((0x04 + (msg.data[0x04 + 0x20])) + (msg.data[0x04 + (msg.data[0x04 + 0x20])] << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + (msg.data[0x04 + 0x20]); uint256 value6 = msg.data.length; while (true) { if (value0 >= value2) { break; } if ((0x20 + value0) >= value2) { break; } value0 = 0x20 + (0x20 + value0); value3 = value3; value1 = 0x20 + (0x20 + value1); value2 = value2; value4 = value4; value5 = value5; value6 = value6; require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value7 = 0; uint256 value9 = var_a + 0x20; uint256 value8 = var_f; uint256 value10 = 0; uint256 value11 = var_a; uint256 value12 = ((0x24 + var_a) + 0x40) + 0x20; while (true) { uint256 value13 = value12; if (value7 >= value8) { break; } if ((0x01 + value7) >= value8) { break; } value7 = 0x01 + value7; value9 = value9 + 0x20; value8 = value8; value10 = value10; value11 = value11; value12 = 0x20 + value12; uint256 value7 = 0; uint256 value9 = value3 + 0x20; uint256 value8 = var_n; uint256 value10 = 0; uint256 value11 = value3; uint256 value12 = value12 + 0x20; uint256 var_v; while (true) { if (value7 >= value8) { break; } if ((0x01 + value7) >= value8) { break; } value7 = 0x01 + value7; value9 = value9 + 0x20; value8 = value8; value10 = value10; value11 = value11; value12 = 0x20 + value12; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_656976a3(var_t, var_u, var_v, var_w, var_x, var_y); // delegatecall if (returnData0.length != 0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } require(success0); } value13 = value12; var_a = value13; var_v = 0; (bool success1, bytes memory returnData1) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_656976a3(var_aa, var_ab); // delegatecall uint256 value14 = 0x60; if (returnData1.length != 0) { var_a = var_a + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value14 = var_a; } require(success1); } value7 = 0; value9 = value3 + 0x20; value8 = var_n; value10 = 0; value11 = value3; value12 = value12 + 0x20; while (true) { if (value7 >= value8) { break; } if ((0x01 + value7) >= value8) { break; } value7 = 0x01 + value7; value9 = value9 + 0x20; value8 = value8; value10 = value10; value11 = value11; value12 = 0x20 + value12; (bool success2, bytes memory returnData2) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_656976a3(var_ab, var_t, var_u, var_v, var_w); // delegatecall if (returnData2.length != 0) { var_a = var_a + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } require(success2); } require(msg.sender == owner, OwnableUnauthorizedAccount()); value7 = 0; value9 = var_a + 0x20; value8 = var_f; value10 = 0; value11 = var_a; value12 = ((0x24 + var_a) + 0x40) + 0x20; while (true) { if (value7 >= value8) { break; } value7 = 0x01 + value7; value9 = value9 + 0x20; value8 = value8; value10 = value10; value11 = value11; value12 = 0x20 + value12; var_a = value12; (bool success3, bytes memory returnData3) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_656976a3(var_aa, var_ab); // delegatecall uint256 value15 = 0x60; if (returnData3.length != 0) { var_a = var_a + ((returnData3.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value15 = var_a; } require(success3); } value7 = 0; value9 = value3 + 0x20; value8 = var_n; value10 = 0; value11 = value3; value12 = value12 + 0x20; while (true) { if (value7 >= value8) { break; } value7 = 0x01 + value7; value9 = value9 + 0x20; value8 = value8; value10 = value10; value11 = value11; value12 = 0x20 + value12; } } } function setFundPool(address newAddress) public onlyOwner { stor_1f = (newAddress * 0x010000) | (0xffffffffffffffffffff0000000000000000000000000000000000000000ffff & stor_1f); isWL[newAddress] = true; (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).approve(newAddress, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // call require(success0); abi.decode(returnData0, (bool)); } function balanceOf(address account) public view returns (uint256) { if (0x0 != totalPower) { var_c = 0x20 + (var_c + (0x20 * stor_expr_aj)); uint256 value2 = stor_expr_aj; uint256 value3 = (keccak256(abi.encode(account, 0x0e))) + 0x0d; uint256 value4 = var_c + 0x20; if (stor_expr_aj != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(account, 0x0e)) + 0x0d))); while (true) { if ((var_c + 0x20) + (0x20 * stor_expr_aj) <= value0) { break; } value0 = 0x20 + value0; value1 = 0x01 + value1; } value2 = value0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * stor_expr_aj); } return (((unresolved_849b0dcd * (stor_expr_ac + var_ad)) / 0xc097ce7bc90715b34b9f1000000000) - var_ae - stor_expr_ae) + mapping_0[account]; } else { return 0 + mapping_0[account]; } } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(owner, address(0)); owner = address(0); } function getTeamLevel(address arg0) public view returns (uint256) { var_c = 0x20 + (var_c + (0x20 * stor_expr_aj)); uint256 value2 = stor_expr_aj; uint256 value3 = (keccak256(abi.encode(arg0, 0x0e))) + 0x0d; uint256 value4 = var_c + 0x20; if (stor_expr_aj != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0e)) + 0x0d))); while (true) { if ((var_c + 0x20) + (0x20 * stor_expr_aj) <= value0) { break; } value0 = 0x20 + value0; value1 = 0x01 + value1; } value2 = value0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * stor_expr_aj); } bool flag0 = !(var_u < 0x152d02c7e14af6800000); if (!(var_u < 0x152d02c7e14af6800000)) { flag0 = !(var_v < 0x09); } uint256 value5; if (!flag0) { bool flag1 = !(var_u < 0x010f0cf064dd59200000); if (!(var_u < 0x010f0cf064dd59200000)) { flag1 = !(var_v < 0x08); } uint256 value6; if (!flag1) { bool flag2 = !(var_u < 0x6c6b935b8bbd400000); if (!(var_u < 0x6c6b935b8bbd400000)) { flag2 = !(var_v < 0x07); } uint256 value7; if (!flag2) { bool flag3 = !(var_u < 0x3635c9adc5dea00000); if (!(var_u < 0x3635c9adc5dea00000)) { flag3 = !(var_v < 0x06); } uint256 value8; if (!flag3) { bool flag4 = !(var_u < 0x1043561a8829300000); if (!(var_u < 0x1043561a8829300000)) { flag4 = !(var_v < 0x05); } uint256 value9; if (!flag4) { bool flag5 = !(var_u < 0x056bc75e2d63100000); if (!(var_u < 0x056bc75e2d63100000)) { flag5 = !(var_v < 0x04); } uint256 value10; if (!flag5) { bool flag6 = !(var_u < 0x01a055690d9db80000); if (!(var_u < 0x01a055690d9db80000)) { flag6 = !(var_v < 0x03); } uint256 value11; if (!flag6) { bool flag7 = !(var_u < 0x8ac7230489e80000); if (!(var_u < 0x8ac7230489e80000)) { flag7 = !(var_v < 0x02); } uint256 value12; if (!flag7) { bool flag8 = !(var_u < 0x4563918244f40000); if (!(var_u < 0x4563918244f40000)) { flag8 = !(var_w < 0x1bc16d674ec80000); } uint256 value13 = 0; if (flag8) { value13 = 0x01; } value12 = value13; } else { value12 = 0x02; } value11 = value12; } else { value11 = 0x03; } value10 = value11; } else { value10 = 0x04; } value9 = value10; } else { value9 = 0x05; } value8 = value9; } else { value8 = 0x06; } value7 = value8; } else { value7 = 0x07; } value6 = value7; } else { value6 = 0x08; } value5 = value6; } else { value5 = 0x09; } // duplicate declaration of value5 omitted } function multisetWL(address[] memory accounts, bool enabled) public { if (!(accounts.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (accounts.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (accounts.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (accounts.length << 0x05)) + 0x1f)); address[] var_b = accounts; require(!(((0x04 + accounts) + (accounts.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = (0x04 + accounts) + 0x20; uint256 value2 = var_a; uint256 value3 = var_a + 0x20; uint256 value1 = ((0x04 + accounts) + (accounts.length << 0x05)) + 0x20; uint256 value4 = 0; uint256 value5 = 0x04 + accounts; uint256 value6 = msg.data.length; while (true) { if (value0 >= value1) { break; } require(msg.data[value0] == (address(msg.data[value0]))); value0 = 0x20 + value0; value2 = value2; value3 = 0x20 + value3; value1 = value1; value4 = value4; value5 = value5; value6 = value6; require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value7 = 0; while (true) { if (value7 >= var_d) { break; } isWL[address(var_f)] = enabled; value7 = 0x01 + value7; } } } function launched() public view returns (bool) { return !(!(bytes1(stor_b))); } function userChilds(address arg0) public view returns (bytes memory) { address var_c; var_c = 0x20 + (var_c + (0x20 * mapping_19[arg0])); uint256 value2 = mapping_19[arg0]; uint256 value3 = keccak256(abi.encode(arg0, 0x19)); uint256 value4 = var_c + 0x20; if (mapping_19[arg0] != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x19))))) + 0x01; while (true) { if ((var_c + 0x20) + (0x20 * mapping_19[arg0]) <= value0) { break; } value0 = 0x20 + value0; value1 = value1 + 0x01; } value2 = value0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * mapping_19[arg0]); } uint256 value5 = 0; uint256 value6 = var_c + 0x20; uint256 value7 = (var_c + 0x20) + 0x20; while (true) { if (!(value5 < var_c.length)) { break; } value5 = 0x01 + value5; value6 = value6 + 0x20; value7 = 0x20 + value7; } return abi.encodePacked(0x20, var_c.length); } function idToOrder(uint256 index) public view returns (bool) { return abi.encodePacked(mapping_d[index], stor_expr_fp, stor_expr_fq, stor_expr_fr, stor_expr_fs, stor_expr_ft, stor_expr_fu, stor_expr_fv, !(!(bytes1(stor_expr_fw))), stor_expr_fx, stor_expr_fy); } function activeStatus() public view returns (bool) { return !(!(bytes1(stor_2b / 0x0100))); } function symbol() public view returns (string memory) { return _symbol; } function transfer(address to, uint256 amount) public returns (bool) { _transferToken(amount, to, msg.sender); return true; } function setDailyLimit(uint256 newDailyLimit) public onlyOwner { dailyLimit = newDailyLimit; } function activate(uint256 arg0) public payable { // Function body omitted: symbolic output exceeded safe complexity limits. assembly { revert(0, 0) } } function _getReserves() public returns (bytes memory) { IDesolexUniswapV2Pair(basePair).getReserves(); (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(basePair); // staticcall require(success1); uint256 accountBalance = abi.decode(returnData1, (uint256)); return abi.encodePacked(uint112(var_b.length), uint112(var_j), accountBalance); } function userOrderIds(address arg0) public view returns (bytes memory) { address var_c; var_c = 0x20 + (var_c + (0x20 * stor_expr_hh)); if (stor_expr_hh != 0) { uint256 value3 = 0x20 + (var_c + 0x20); uint256 value4 = 0x01 + (keccak256(abi.encode(0x0d + (keccak256(abi.encode(arg0, 0x0e)))))); while (true) { if ((var_c + 0x20) + (0x20 * stor_expr_hh) <= value3) { break; } value3 = 0x20 + value3; value4 = 0x01 + value4; } } uint256 value0 = 0; uint256 value1 = var_c + 0x20; uint256 value2 = (var_c + 0x20) + 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x01 + value0; value1 = value1 + 0x20; value2 = 0x20 + value2; } return abi.encodePacked(0x20, var_c.length); } function allowance(address owner, address spender) public view returns (uint256) { return mapping_1[owner][spender]; } function Unknown_e11ca3f4(bytes32 arg0) public view returns (bytes memory) { return abi.encodePacked(mapping_16[arg0], stor_expr_hn); } function setActiveStatus(bool arg0) public onlyOwner { stor_2b = (stor_2b & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff)) | (0x0100 * arg0); } function burnLp(uint256 arg0) public { uint256 var_c; var_c = 0x20 + (0x24 + var_c); (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).Unknown_fbf90681(var_g); // delegatecall uint256 value0 = 0x60; if (returnData0.length != 0) { var_c = var_c + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } require(success0); } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), OwnableInvalidOwner()); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function internal_2c80(address arg0) private { var_c = 0x20 + (var_c + (0x20 * stor_expr_aj)); uint256 value2 = stor_expr_aj; uint256 value3 = (keccak256(abi.encode(arg0, 0x0e))) + 0x0d; uint256 value4 = var_c + 0x20; if (stor_expr_aj != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0e)) + 0x0d))); while (true) { if ((var_c + 0x20) + (0x20 * stor_expr_aj) <= value0) { break; } value0 = 0x20 + value0; value1 = 0x01 + value1; } value2 = value0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * stor_expr_aj); } bool flag0 = !(var_af < 0x152d02c7e14af6800000); if (!(var_af < 0x152d02c7e14af6800000)) { flag0 = !(var_ag < 0x09); } uint256 value5; if (!flag0) { bool flag1 = !(var_af < 0x010f0cf064dd59200000); if (!(var_af < 0x010f0cf064dd59200000)) { flag1 = !(var_ag < 0x08); } uint256 value7; if (!flag1) { bool flag2 = !(var_af < 0x6c6b935b8bbd400000); if (!(var_af < 0x6c6b935b8bbd400000)) { flag2 = !(var_ag < 0x07); } uint256 value8; if (!flag2) { bool flag3 = !(var_af < 0x3635c9adc5dea00000); if (!(var_af < 0x3635c9adc5dea00000)) { flag3 = !(var_ag < 0x06); } uint256 value9; if (!flag3) { bool flag4 = !(var_af < 0x1043561a8829300000); if (!(var_af < 0x1043561a8829300000)) { flag4 = !(var_ag < 0x05); } uint256 value10; if (!flag4) { bool flag5 = !(var_af < 0x056bc75e2d63100000); if (!(var_af < 0x056bc75e2d63100000)) { flag5 = !(var_ag < 0x04); } uint256 value11; if (!flag5) { bool flag6 = !(var_af < 0x01a055690d9db80000); if (!(var_af < 0x01a055690d9db80000)) { flag6 = !(var_ag < 0x03); } uint256 value12; if (!flag6) { bool flag7 = !(var_af < 0x8ac7230489e80000); if (!(var_af < 0x8ac7230489e80000)) { flag7 = !(var_ag < 0x02); } uint256 value13; if (!flag7) { bool flag8 = !(var_af < 0x4563918244f40000); if (!(var_af < 0x4563918244f40000)) { flag8 = !(var_ah < 0x1bc16d674ec80000); } uint256 value14 = 0; if (flag8) { value14 = 0x01; } value13 = value14; } else { value13 = 0x02; } value12 = value13; } else { value12 = 0x03; } value11 = value12; } else { value11 = 0x04; } value10 = value11; } else { value10 = 0x05; } value9 = value10; } else { value9 = 0x06; } value8 = value9; } else { value8 = 0x07; } value7 = value8; } else { value7 = 0x08; } value5 = value7; } else { value5 = 0x09; } } function internal_20e0(uint256 arg0) private { uint256 value0; if (arg0 <= 0x23bbf4b14c2e7ff800000) { uint256 value2; if (arg0 <= 0x1fc3842bd1f071c000000) { uint256 value3; if (arg0 <= 0x1bcb13a657b2638800000) { uint256 value4; if (arg0 <= 0x17d2a320dd74555000000) { uint256 value5; if (arg0 <= 0x13da329b6336471800000) { uint256 value6; if (arg0 <= 0xfe1c215e8f838e000000) { uint256 value7; if (arg0 <= 0xbe951906eba2aa800000) { uint256 value8 = 0; if (arg0 > 0x7f0e10af47c1c7000000) { value8 = 0x0927c0; } value7 = value8; } else { value7 = 0x0dbba0; } value6 = value7; } else { value6 = 0x124f80; } value5 = value6; } else { value5 = 0x16e360; } value4 = value5; } else { value4 = 0x1b7740; } value3 = value4; } else { value3 = 0x200b20; } value2 = value3; } else { value2 = 0x249f00; } value0 = value2; } else { value0 = 0x2932e0; } uint256 value1 = mapping_16[value0]; if (totalSupply <= 0x0cb49b44ba602d800000) { value1 = 0; } } function internal_252c(bool arg0) private { // Decompilation incomplete: helper effect provenance is conservative. (, , uint32 blockTimestampLast) = IDesolexUniswapV2Pair(basePair).getReserves(); if ((uint112(var_g) > 0) && (var_k < (uint32(blockTimestampLast) / 0x015180))) { var_b = var_b + 0x60; stor_1b = uint112(var_g); stor_1c = uint112(var_f); lastDayReserves = (uint32(blockTimestampLast)) / 0x015180; emit Sync(uint32(blockTimestampLast) / 0x015180, uint112(var_g), uint112(var_f), var_b.length); } bool flag2; if (!(bytes1(stor_b))) { flag2 = !(totalSupply > 0x0cb49b44ba602d800000); if (totalSupply > 0x0cb49b44ba602d800000) { flag2 = !(uint112(var_g) < 0x027b46536c66c8e3000000); } } if (((0xff & stor_b) == 0x0) && (flag2)) { stor_b = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_b); } if ((arg0) && (lastMiningDay > 0x0)) { if (0x0 != totalPower) { if ((block.timestamp / 0x015180) > lastMiningDay) { uint256 value0; if (!(uint112(var_g) > 0x023bbf4b14c2e7ff800000)) { uint256 value2; if (!(uint112(var_g) > 0x01fc3842bd1f071c000000)) { uint256 value3; if (!(uint112(var_g) > 0x01bcb13a657b2638800000)) { uint256 value4; if (!(uint112(var_g) > 0x017d2a320dd74555000000)) { uint256 value5; if (!(uint112(var_g) > 0x013da329b6336471800000)) { uint256 value6; if (!(uint112(var_g) > 0xfe1c215e8f838e000000)) { uint256 value7; if (!(uint112(var_g) > 0xbe951906eba2aa800000)) { uint256 value8 = 0; if (uint112(var_g) > 0x7f0e10af47c1c7000000) { value8 = 0x0927c0; } value7 = value8; } else { value7 = 0x0dbba0; } value6 = value7; } else { value6 = 0x124f80; } value5 = value6; } else { value5 = 0x16e360; } value4 = value5; } else { value4 = 0x1b7740; } value3 = value4; } else { value3 = 0x200b20; } value2 = value3; } else { value2 = 0x249f00; } value0 = value2; } else { value0 = 0x2932e0; } var_b = 0x40 + var_b; uint256 value1 = mapping_16[value0]; if (totalSupply <= 0x0cb49b44ba602d800000) { value1 = 0; } if (basePair != 0x0) { require(!(mapping_0[basePair] < (stor_expr_ew * (uint112(var_f)) / 0x03e8))); mapping_0[basePair] = mapping_0[basePair] - (stor_expr_ew * (uint112(var_f)) / 0x03e8); } else { totalSupply = ((stor_expr_ew * (uint112(var_f)) / 0x03e8) + totalSupply); } if (address(this) != address(0)) { mapping_0[address(this)] = (stor_expr_ew * (uint112(var_f)) / 0x03e8) + mapping_0[address(this)]; } else { totalSupply = totalSupply - (stor_expr_ew * (uint112(var_f)) / 0x03e8); } emit Transfer(basePair, address(this), (stor_expr_ew * (uint112(var_f))) / 0x03e8); if (basePair != 0x0) { require(!(mapping_0[basePair] < ((value1 * (uint112(var_f))) / 0x03e8))); mapping_0[basePair] = mapping_0[basePair] - ((value1 * (uint112(var_f))) / 0x03e8); } else { totalSupply = (((value1 * (uint112(var_f))) / 0x03e8) + totalSupply); } totalSupply = totalSupply - ((value1 * (uint112(var_f))) / 0x03e8); emit Transfer(basePair, address(0), (value1 * (uint112(var_f))) / 0x03e8); unresolved_849b0dcd = (((stor_expr_ew * (uint112(var_f)) / 0x03e8) * 0xc097ce7bc90715b34b9f1000000000) / totalPower) + unresolved_849b0dcd; lastMiningDay = block.timestamp / 0x015180; require(basePair.code.length != 0x0); (bool success1, bytes memory returnData1) = basePair.sync(); // call require(success1); emit Mining(block.timestamp / 0x015180, uint112(var_f), uint112(var_g), (value1 * (uint112(var_f))) / 0x03e8, (stor_expr_ew * (uint112(var_f))) / 0x03e8); } } } } function _transferToken(uint256 amount, address to, address from) private { // Decompilation incomplete: helper effect provenance is conservative. require(from != address(0), ERC20InvalidSender(address(0))); require(to != address(0), ERC20InvalidReceiver(address(0))); internal_409a(amount, to, from); } function internal_409a(uint256 arg0, address arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. if (!(bytes1(stor_1f))) { uint256 var_c; var_c = 0x44 + var_c; (bool success0, bytes memory returnData0) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).executeReward(var_h); // delegatecall uint256 value0 = 0x60; if (returnData0.length != 0) { var_c = var_c + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } require(success0); var_c = 0x44 + var_c; (bool success1, bytes memory returnData1) = address(0x7ac93ee5ab8fc64903500ac20fa83c026100dbd7).executeReward(var_l); // delegatecall uint256 value1 = 0x60; if (returnData1.length != 0) { var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_c; } require(success1); if (!(isWL[arg2] || isWL[arg1])) { require(!mapping_13[arg2], "transfer error"); if (((0xff & stor_b) == 0x0) && (basePair != arg2)) { var_c = 0x20 + (var_c + (0x20 * stor_expr_bx)); uint256 value2 = stor_expr_bx; uint256 value3 = (keccak256(abi.encode(arg2, 0x0e))) + 0x0d; uint256 value4 = var_c + 0x20; if (stor_expr_bx != 0) { uint256 value17 = 0x20 + (0x20 + (var_c + 0x20)); uint256 value18 = 0x01 + (0x01 + (keccak256(abi.encode(keccak256(abi.encode(arg2, 0x0e)) + 0x0d)))); if (!((var_c + 0x20) + (0x20 * stor_expr_bx) > (0x20 + (var_c + 0x20)))) { value17 = 0x20 + (var_c + 0x20); value18 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(arg2, 0x0e)) + 0x0d))); } value2 = value17; value3 = value18; value4 = (var_c + 0x20) + (0x20 * stor_expr_bx); } bool flag2 = !(var_ar < 0x152d02c7e14af6800000); if (!(var_ar < 0x152d02c7e14af6800000)) { flag2 = !(var_as < 0x09); } uint256 value5; if (!flag2) { bool flag3 = !(var_ar < 0x010f0cf064dd59200000); if (!(var_ar < 0x010f0cf064dd59200000)) { flag3 = !(var_as < 0x08); } uint256 value21; if (!flag3) { bool flag4 = !(var_ar < 0x6c6b935b8bbd400000); if (!(var_ar < 0x6c6b935b8bbd400000)) { flag4 = !(var_as < 0x07); } uint256 value22; if (!flag4) { bool flag5 = !(var_ar < 0x3635c9adc5dea00000); if (!(var_ar < 0x3635c9adc5dea00000)) { flag5 = !(var_as < 0x06); } uint256 value23; if (!flag5) { bool flag6 = !(var_ar < 0x1043561a8829300000); if (!(var_ar < 0x1043561a8829300000)) { flag6 = !(var_as < 0x05); } uint256 value24; if (!flag6) { bool flag7 = !(var_ar < 0x056bc75e2d63100000); if (!(var_ar < 0x056bc75e2d63100000)) { flag7 = !(var_as < 0x04); } uint256 value25; if (!flag7) { bool flag8 = !(var_ar < 0x01a055690d9db80000); if (!(var_ar < 0x01a055690d9db80000)) { flag8 = !(var_as < 0x03); } uint256 value26; if (!flag8) { bool flag9 = !(var_ar < 0x8ac7230489e80000); if (!(var_ar < 0x8ac7230489e80000)) { flag9 = !(var_as < 0x02); } uint256 value27; if (!flag9) { bool flag10 = !(var_ar < 0x4563918244f40000); if (!(var_ar < 0x4563918244f40000)) { flag10 = !(var_at < 0x1bc16d674ec80000); } uint256 value28 = 0; if (flag10) { value28 = 0x01; } value27 = value28; } else { value27 = 0x02; } value26 = value27; } else { value26 = 0x03; } value25 = value26; } else { value25 = 0x04; } value24 = value25; } else { value24 = 0x05; } value23 = value24; } else { value23 = 0x06; } value22 = value23; } else { value22 = 0x07; } value21 = value22; } else { value21 = 0x08; } value5 = value21; } else { value5 = 0x09; } bool flag11 = value5 == 0x0; if (value5 == 0) { flag11 = var_au > 0; } uint256 value6 = value5; if (flag11) { value6 = 0x01; } if (mapping_0[arg2] > (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])) { if (arg2 != address(0)) { require(!(mapping_0[arg2] < (mapping_0[arg2] - (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])))); mapping_0[arg2] = mapping_0[arg2] - (mapping_0[arg2] - (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])); } else { totalSupply = (mapping_0[arg2] - (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])) + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = (mapping_0[arg2] - (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])) + mapping_0[address(0)]; } else { totalSupply = totalSupply - (mapping_0[arg2] - (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])); } emit Transfer(arg2, address(0), mapping_0[arg2] - (unresolved_11cb3b3e[arg2] + unresolved_1a449f57[value6])); } } if (arg2 != basePair) { if (arg1 == basePair) { (bool success2, bytes memory returnData2) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData2.length) - var_c >= 0x60); require(var_ax == (uint32(var_ax))); if ((uint112(var_c.length) > 0) && (var_bb < (uint32(var_ba) / 0x015180))) { var_c = var_c + 0x60; stor_1b = uint112(var_c.length); stor_1c = uint112(var_e); lastDayReserves = (uint32(var_ba)) / 0x015180; emit Sync(uint32(var_ba) / 0x015180, uint112(var_c.length), uint112(var_bc), var_c.length); } if (((0xff & stor_b) == 0x0) && ((totalSupply <= 0xcb49b44ba602d800000) || ((0xffffffffffffffffffffffffffff & var_bd) >= 0x27b46536c66c8e3000000))) { stor_b = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_b); } uint256 value7 = 0x01; value7 = (lastMiningDay > 0) ? 1 : 0; if (!(value7 == 0x0)) { if (0x0 != totalPower) { if ((block.timestamp / 0x015180) > lastMiningDay) { uint256 value8; if (uint112(var_c.length) <= 0x23bbf4b14c2e7ff800000) { uint256 value29; if (uint112(var_c.length) <= 0x1fc3842bd1f071c000000) { uint256 value30; if (uint112(var_c.length) <= 0x1bcb13a657b2638800000) { uint256 value31; if (uint112(var_c.length) <= 0x17d2a320dd74555000000) { uint256 value32; if (uint112(var_c.length) <= 0x13da329b6336471800000) { uint256 value33; if (uint112(var_c.length) <= 0xfe1c215e8f838e000000) { uint256 value34; if (uint112(var_c.length) <= 0xbe951906eba2aa800000) { uint256 value35 = 0; if (uint112(var_c.length) > 0x7f0e10af47c1c7000000) { value35 = 0x0927c0; } value34 = value35; } else { value34 = 0x0dbba0; } value33 = value34; } else { value33 = 0x124f80; } value32 = value33; } else { value32 = 0x16e360; } value31 = value32; } else { value31 = 0x1b7740; } value30 = value31; } else { value30 = 0x200b20; } value29 = value30; } else { value29 = 0x249f00; } value8 = value29; } else { value8 = 0x2932e0; } var_c = 0x40 + var_c; uint256 value9 = mapping_16[value8]; if (totalSupply <= 0x0cb49b44ba602d800000) { value9 = 0; } if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < (stor_expr_gi * (uint112(var_e)) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - (stor_expr_gi * (uint112(var_e)) / 0x03e8); } else { totalSupply = (stor_expr_gi * (uint112(var_e)) / 0x03e8) + totalSupply; } if (address(this) != address(0)) { mapping_0[address(this)] = (stor_expr_gi * (uint112(var_e)) / 0x03e8) + mapping_0[address(this)]; } else { totalSupply = totalSupply - (stor_expr_gi * (uint112(var_e)) / 0x03e8); } emit Transfer(address(basePair), address(this), (stor_expr_gi * (uint112(var_e)) / 0x03e8)); if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < ((value9 * (uint112(var_e))) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - ((value9 * (uint112(var_e))) / 0x03e8); } else { totalSupply = ((value9 * (uint112(var_e))) / 0x03e8) + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = ((value9 * (uint112(var_e))) / 0x03e8) + mapping_0[address(0)]; } else { totalSupply = totalSupply - ((value9 * (uint112(var_e))) / 0x03e8); } emit Transfer(address(basePair), address(0), ((value9 * (uint112(var_e))) / 0x03e8)); unresolved_849b0dcd = (((stor_expr_gi * (uint112(var_e)) / 0x03e8) * 0xc097ce7bc90715b34b9f1000000000) / totalPower) + unresolved_849b0dcd; lastMiningDay = block.timestamp / 0x015180; require(basePair.code.length != 0x0); (bool success3, bytes memory returnData3) = basePair.sync(); // call require(success3); emit Mining(block.timestamp / 0x015180, uint112(var_e), uint112(var_c.length), (value9 * (uint112(var_e))) / 0x03e8, (stor_expr_gi * (uint112(var_e))) / 0x03e8); } } } require((startTime > 0x0 && block.timestamp > startTime), "launched"); require(!(bytes1(buyBlockMapping[tx.origin][block.number])), "no flash"); (bool success4, bytes memory returnData4) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success4); var_c = var_c + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } } else { (bool success5, bytes memory returnData5) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success5); var_c = var_c + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData5.length) - var_c >= 0x60); require(var_be == (uint32(var_be))); (bool success6, bytes memory returnData6) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(basePair); // staticcall require(success6); uint256 accountBalance = abi.decode(returnData6, (uint256)); uint256 value11 = 0; uint256 value12 = 0; if (!(accountBalance < (uint112(var_c.length)))) { uint256 value10 = 0; if (((0xffffffffffffffffffffffffffff & var_bd) > 0x0) && ((0xffffffffffffffffffffffffffff & var_e) > 0x0)) { require(!(accountBalance < (uint112(var_c.length) + ((uint112(var_c.length) * arg0) / (uint112(var_bc) - arg0))))); value10 = (uint112(var_c.length) * arg0) / (uint112(var_bc) - arg0); } } else { (bool success7, bytes memory returnData7) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success7); var_c = var_c + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData7.length) - var_c >= 0x20); value11 = (uint112(var_c.length)) - accountBalance; value12 = (var_c.length * arg0) / (mapping_0[basePair] - arg0); } if (value12 == 0) { (bool success8, bytes memory returnData8) = basePair.staticcall(abi.encodeWithSelector(bytes4(0x0902f1ac))); // staticcall getReserves require(success8); var_c = var_c + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData8.length) - var_c >= 0x60); require(var_ax == (uint32(var_ax))); if ((uint112(var_c.length) > 0) && (var_bb < (uint32(var_ba) / 0x015180))) { var_c = var_c + 0x60; stor_1b = uint112(var_c.length); stor_1c = uint112(var_e); lastDayReserves = (uint32(var_ba)) / 0x015180; emit Sync(uint32(var_ba) / 0x015180, uint112(var_c.length), uint112(var_bc), var_c.length); } if (((0xff & stor_b) == 0x0) && ((totalSupply <= 0xcb49b44ba602d800000) || ((0xffffffffffffffffffffffffffff & var_bd) >= 0x27b46536c66c8e3000000))) { stor_b = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_b); } uint256 value13 = 0; if (!(value13 == 0x0)) { if (0x0 != totalPower) { if ((block.timestamp / 0x015180) > lastMiningDay) { uint256 value14; if (uint112(var_c.length) <= 0x23bbf4b14c2e7ff800000) { uint256 value36; if (uint112(var_c.length) <= 0x1fc3842bd1f071c000000) { uint256 value37; if (uint112(var_c.length) <= 0x1bcb13a657b2638800000) { uint256 value38; if (uint112(var_c.length) <= 0x17d2a320dd74555000000) { uint256 value39; if (uint112(var_c.length) <= 0x13da329b6336471800000) { uint256 value40; if (uint112(var_c.length) <= 0xfe1c215e8f838e000000) { uint256 value41; if (uint112(var_c.length) <= 0xbe951906eba2aa800000) { uint256 value42 = 0; if (uint112(var_c.length) > 0x7f0e10af47c1c7000000) { value42 = 0x0927c0; } value41 = value42; } else { value41 = 0x0dbba0; } value40 = value41; } else { value40 = 0x124f80; } value39 = value40; } else { value39 = 0x16e360; } value38 = value39; } else { value38 = 0x1b7740; } value37 = value38; } else { value37 = 0x200b20; } value36 = value37; } else { value36 = 0x249f00; } value14 = value36; } else { value14 = 0x2932e0; } var_c = 0x40 + var_c; uint256 value15 = mapping_16[value14]; if (totalSupply <= 0x0cb49b44ba602d800000) { value15 = 0; } if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < (stor_expr_gk * (uint112(var_e)) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - (stor_expr_gk * (uint112(var_e)) / 0x03e8); } else { totalSupply = (stor_expr_gk * (uint112(var_e)) / 0x03e8) + totalSupply; } if (address(this) != address(0)) { mapping_0[address(this)] = (stor_expr_gk * (uint112(var_e)) / 0x03e8) + mapping_0[address(this)]; } else { totalSupply = totalSupply - (stor_expr_gk * (uint112(var_e)) / 0x03e8); } emit Transfer(address(basePair), address(this), (stor_expr_gk * (uint112(var_e)) / 0x03e8)); if ((basePair & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(!(mapping_0[address(basePair)] < ((value15 * (uint112(var_e))) / 0x03e8))); mapping_0[address(basePair)] = mapping_0[address(basePair)] - ((value15 * (uint112(var_e))) / 0x03e8); } else { totalSupply = ((value15 * (uint112(var_e))) / 0x03e8) + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = ((value15 * (uint112(var_e))) / 0x03e8) + mapping_0[address(0)]; } else { totalSupply = totalSupply - ((value15 * (uint112(var_e))) / 0x03e8); } emit Transfer(address(basePair), address(0), ((value15 * (uint112(var_e))) / 0x03e8)); unresolved_849b0dcd = (((stor_expr_gk * (uint112(var_e)) / 0x03e8) * 0xc097ce7bc90715b34b9f1000000000) / totalPower) + unresolved_849b0dcd; lastMiningDay = block.timestamp / 0x015180; require(basePair.code.length != 0x0); (bool success9, bytes memory returnData9) = basePair.sync(); // call require(success9); emit Mining(block.timestamp / 0x015180, uint112(var_e), uint112(var_c.length), (value15 * (uint112(var_e))) / 0x03e8, (stor_expr_gk * (uint112(var_e))) / 0x03e8); } } } var_c = var_c + 0x60; if (!(0 < var_c.length)) _desolexPanic(50); if (!(0x01 < var_c.length)) _desolexPanic(50); (bool success10, bytes memory returnData10) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_1f00ca74(arg0, 0x40, var_bl); // staticcall require(success10); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData10.length + 0x1f)); var_c = internal_5a50(var_c, var_c + returnData10.length); if (!(0 < var_by)) _desolexPanic(50); if (!(bytes1(stor_b))) { IDesolexUniswapV2Pair(basePair).getReserves(); require(!(uint112(var_bz) < 0x01a784379d99db42000000), "un launched"); require(userBuyUsdtAmount[arg1] < mapping_f[arg1], "buy limit"); require(!(var_ca > ((mapping_f[arg1] - userBuyUsdtAmount[arg1]))), "buy limit"); } if (arg2 != address(0)) { require(!(mapping_0[arg2] < (((arg0 * 0x01f4) / 0x2710)))); mapping_0[arg2] = mapping_0[arg2] - (((arg0 * 0x01f4) / 0x2710)); } else { totalSupply = (((arg0 * 0x01f4) / 0x2710)) + totalSupply; } if ((stor_24 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(stor_24)] = (((arg0 * 0x01f4) / 0x2710)) + mapping_0[address(stor_24)]; } else { totalSupply = totalSupply - (((arg0 * 0x01f4) / 0x2710)); } emit Transfer(arg2, address(stor_24), (((arg0 * 0x01f4) / 0x2710))); if (arg2 != address(0)) { require(!(mapping_0[arg2] < ((arg0 - (((arg0 * 0x01f4) / 0x2710)))))); mapping_0[arg2] = mapping_0[arg2] - ((arg0 - (((arg0 * 0x01f4) / 0x2710)))); } else { totalSupply = ((arg0 - (((arg0 * 0x01f4) / 0x2710)))) + totalSupply; } if (arg1 != address(0)) { mapping_0[arg1] = ((arg0 - (((arg0 * 0x01f4) / 0x2710)))) + mapping_0[arg1]; } else { totalSupply = totalSupply - ((arg0 - (((arg0 * 0x01f4) / 0x2710)))); } emit Transfer(arg2, arg1, ((arg0 - (((arg0 * 0x01f4) / 0x2710))))); userBuyUsdtAmount[arg1] = (var_ca + userBuyUsdtAmount[arg1]); unresolved_11cb3b3e[arg1] = ((arg0 - (((arg0 * 0x01f4) / 0x2710))) + unresolved_11cb3b3e[arg1]); buyBlockMapping[tx.origin][block.number] = true; emit Buy(arg1, var_cb, ((arg0 - (((arg0 * 0x01f4) / 0x2710)))), (((arg0 * 0x01f4) / 0x2710))); return; } else { require(arg1 == tx.origin, "err origin"); require(!(stor_expr_gq < (((stor_expr_q * value12) / stor_expr_n))), "err lp amount"); stor_expr_gs = (stor_expr_gs - value12); require(!(0x03e8 < stor_expr_n), "lp must remove all"); if (stor_expr_n != 0) { stor_expr_n = 0; } stor_expr_ab = 0; emit RemoveLp(arg1, (value12), (((stor_expr_go * value12) / stor_expr_gp)), arg0); if (!(0 < stor_expr_aj)) { stor_expr_o = 0; stor_expr_r = ((unresolved_849b0dcd * stor_expr_q) / 0xc097ce7bc90715b34b9f1000000000); if (arg2 != address(0)) { require(!(mapping_0[arg2] < arg0)); mapping_0[arg2] = mapping_0[arg2] - arg0; } else { totalSupply = arg0 + totalSupply; } if ((0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(0)] = arg0 + mapping_0[address(0)]; } else { totalSupply = totalSupply - arg0; } emit Transfer(arg2, address(0), arg0); return; } else { if (((0x1 == stor_expr_gx) || (0x2 == stor_expr_gx)) && ((0xff & stor_expr_gy) == 0x0)) { stor_expr_gz = 0; if (stor_expr_ha != 0) { totalPower = (totalPower - stor_expr_hc); stor_expr_q = (stor_expr_q - stor_expr_ha); stor_expr_ha = 0; } emit Event_03ad3c3e(mapping_d[stor_expr_gv], 0, 0x02); } uint256 value16 = 0; if ((0x1 == stor_expr_gx) || (0x2 == stor_expr_gx)) { value16 = (stor_expr_hg + 0); } } } } } else { internal_3c8b(arg0, arg1, arg2); return; } } else { internal_3c8b(arg0, arg1, arg2); } } function internal_3c8b(uint256 arg0, address arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. if (arg2 != address(0)) { require(!(mapping_0[arg2] < arg0)); mapping_0[arg2] = mapping_0[arg2] - arg0; if (arg1 != address(0)) { mapping_0[arg1] = arg0 + mapping_0[arg1]; emit Transfer(arg2, arg1, arg0); } else { totalSupply = totalSupply - arg0; emit Transfer(arg2, arg1, arg0); } return; } else { totalSupply = arg0 + totalSupply; if (arg1 != address(0)) { mapping_0[arg1] = arg0 + mapping_0[arg1]; emit Transfer(arg2, arg1, arg0); } else { totalSupply = totalSupply - arg0; emit Transfer(arg2, arg1, arg0); } return; } } function internal_5a50(uint256 arg0, uint256 arg1) private returns (uint256) { // Decompilation incomplete: helper effect provenance is conservative. require(arg1 - arg0 >= 0x20); require(!(var_bo > 0xffffffffffffffff)); require(arg1 > ((arg0 + var_bo) + 0x1f)); if (!(var_bp <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f)); require(!(((arg0 + var_bo) + (var_bq << 0x05) + 0x20) > arg1)); if (((arg0 + var_bo) + 0x20) < ((arg0 + var_bo) + (var_bq << 0x05) + 0x20)) { if (!(0 < var_c.length)) _desolexPanic(50); if (!(bytes1(stor_b))) { (uint112 reserve0, , ) = IDesolexUniswapV2Pair(basePair).getReserves(); require(!(uint112(reserve0) < 0x01a784379d99db42000000), "un launched"); require(userBuyUsdtAmount[arg1] < mapping_f[arg1], "buy limit"); require(!(var_bw > (mapping_f[arg1] - userBuyUsdtAmount[arg1])), "buy limit"); } if (arg2 != address(0)) { require(!(mapping_0[arg2] < ((arg0 * 0x01f4) / 0x2710))); mapping_0[arg2] = mapping_0[arg2] - ((arg0 * 0x01f4) / 0x2710); } else { totalSupply = ((arg0 * 0x01f4) / 0x2710) + totalSupply; } if ((stor_24 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { mapping_0[address(stor_24)] = ((arg0 * 0x01f4) / 0x2710) + mapping_0[address(stor_24)]; } else { totalSupply = totalSupply - ((arg0 * 0x01f4) / 0x2710); } emit Transfer(arg2, address(stor_24), ((arg0 * 0x01f4) / 0x2710)); if (arg2 != address(0)) { require(!(mapping_0[arg2] < (arg0 - ((arg0 * 0x01f4) / 0x2710)))); mapping_0[arg2] = mapping_0[arg2] - (arg0 - ((arg0 * 0x01f4) / 0x2710)); } else { totalSupply = (arg0 - ((arg0 * 0x01f4) / 0x2710)) + totalSupply; } if (arg1 != address(0)) { mapping_0[arg1] = (arg0 - ((arg0 * 0x01f4) / 0x2710)) + mapping_0[arg1]; } else { totalSupply = totalSupply - (arg0 - ((arg0 * 0x01f4) / 0x2710)); } emit Transfer(arg2, arg1, (arg0 - ((arg0 * 0x01f4) / 0x2710))); userBuyUsdtAmount[arg1] = var_bw + userBuyUsdtAmount[arg1]; unresolved_11cb3b3e[arg1] = (arg0 - ((arg0 * 0x01f4) / 0x2710)) + unresolved_11cb3b3e[arg1]; buyBlockMapping[tx.origin][block.number] = true; emit Buy(arg1, var_bx, (arg0 - ((arg0 * 0x01f4) / 0x2710)), ((arg0 * 0x01f4) / 0x2710)); return; } return var_c; } 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. // 0x0088d22f => Unknown_0088d22f(bytes,bool) // 0x06fdde03 => name() // 0x095ea7b3 => approve(address,uint256) // 0x0e7bf8d3 => Unknown_0e7bf8d3(uint256) // 0x11cb3b3e => unresolved_11cb3b3e(address) // 0x14d39c91 => bindStatus() // 0x17e5259e => ETH_MAX_LIMIT() // 0x18160ddd => totalSupply() // 0x186f0ac7 => Unknown_186f0ac7(bytes,bytes,bytes,bytes,bytes,uint256,uint256) // 0x1959a002 => userInfo(address) // 0x1a449f57 => unresolved_1a449f57(address) // 0x207add91 => setLimit(uint256,uint256) // 0x23b872dd => transferFrom(address,address,uint256) // 0x251f175a => getMiningAndBurnRate(uint256) // 0x289af0d8 => getSellFee() // 0x2a2d0c47 => idToAddress(uint256) // 0x2e106537 => Unknown_2e106537(bytes32) // 0x2e51b77e => Unknown_2e51b77e(bytes,bytes) // 0x2ee3a441 => unresolved_2ee3a441(address) // 0x313ce567 => decimals() // 0x33ffc7dd => Unknown_33ffc7dd(address,uint256) // 0x363bf964 => setAddresses(address,address,address) // 0x46fba40b => startup(uint256) // 0x49eec4d3 => sync(bool) // 0x4f07cc4f => ETH_MIN_LIMIT() // 0x55c38353 => setBindStatus(bool) // 0x5930919b => basePair() // 0x5e9f9879 => Unknown_5e9f9879(bytes,bytes) // 0x5eebea20 => pending(address) // 0x6353586b => reward(address) // 0x64b73aa0 => userInfoEx(address) // 0x656976a3 => Unknown_656976a3(bytes) // 0x67eeba0c => dailyLimit() // 0x6ebdff2c => setFundPool(address) // 0x70a08231 => balanceOf(address) // 0x715018a6 => renounceOwnership() // 0x72b0b7c3 => getTeamLevel(address) // 0x740f4d9f => userBuyUsdtAmount(address) // 0x7624994c => lastDayReserves() // 0x78e97925 => startTime() // 0x79978c28 => TOP_USER() // 0x7d340038 => multisetWL(address[],bool) // 0x7f9fc428 => totalAmountOfDay(uint256) // 0x8091f3bf => launched() // 0x819cde3a => userChilds(address) // 0x849b0dcd => unresolved_849b0dcd() // 0x88566cc5 => buyBlockMapping(address,uint256) // 0x8c831b70 => isWL(address) // 0x8da5cb5b => owner() // 0x8f1ec88f => idToOrder(uint256) // 0x9135dd85 => unresolved_9135dd85(address) // 0x93458030 => activeStatus() // 0x95d89b41 => symbol() // 0xa9059cbb => transfer(address,uint256) // 0xb20d30a9 => setDailyLimit(uint256) // 0xb260c42a => activate(uint256) // 0xb2f7d448 => lastMiningDay() // 0xce4d9f15 => _getReserves() // 0xd7dfa0dd => logic() // 0xda0321cd => addresses() // 0xdb3ad22c => totalPower() // 0xdcd78123 => userOrderIds(address) // 0xdd62ed3e => allowance(address,address) // 0xde05af31 => unresolved_de05af31(address,bytes32) // 0xe11ca3f4 => Unknown_e11ca3f4(bytes32) // 0xec7404b1 => setActiveStatus(bool) // 0xef0c7862 => burnLp(uint256) // 0xf2fde38b => transferOwnership(address)}