BNB Chain
0xe4afb902f1c6b10bb017562774c499cb0a67db46
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xe4afb902…0a67db4623.2 KB71.2 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xe4afb902f1c6b10bb017562774c499cb0a67db46
2,782 lines · Click a variable or keyword to highlight its references · Click a line number to copy its link; Shift-click to copy a block link
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { uint256 public constant unresolved_21f801ff = 27910983754954338009825110243582083662962283593470044932338481578742954956041; uint256 public constant unresolved_39cb81b8 = 13904192984849237252580909277628857438056310346529222418535659322389426451566; uint256 public constant unresolved_9f4d1f53 = 92879549071560785305935022895577845576736214160705595146868830269057077751240; uint256 public constant DEFAULT_ADMIN_ROLE = 0; uint256 public constant CONFIG_ROLE = 59188225887286892209351334377255053218244501363609748534562253846271041614069; address public constant unresolved_e0d496b3 = 0x85Af5f813339e0Cb56b775dCeeC5D06d3D84763B; uint256 public constant UPGRADER_ROLE = 11128870393610018889017711989320518241583568488910388209170242875642230723299; uint256 public _staticRate; // STORAGE[0x0] uint256[] array_1; // STORAGE[0x1] address public mineToken; // STORAGE[0x1] address[] array_2; // STORAGE[0x2] mapping(uint256 => uint256) public unresolved_458b7f2d; // STORAGE[0x4] mapping(address => uint256) mapping_5; // STORAGE[0x5] mapping(address => uint256) mapping_7; // STORAGE[0x7] mapping(address => uint256) public lastStakeAmount; // STORAGE[0x8] mapping(bytes32 => uint256) mapping_9; // STORAGE[0x9] uint256 stor_f0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00; // STORAGE[0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00] mapping(bytes32 => mapping(address => bool)) public hasRole; mapping(bytes32 => bytes32) mapping_expr_ai; mapping(address => uint256) mapping_expr_ak; mapping(address => uint256) mapping_expr_aq; mapping(address => bytes32) mapping_expr_at; mapping(bytes32 => bytes32) mapping_expr_az; mapping(bytes32 => bytes32) mapping_expr_be; mapping(bytes32 => bytes32) mapping_expr_bl; mapping(bytes32 => uint256) mapping_expr_bq; mapping(bytes32 => bytes32) mapping_expr_bw; mapping(uint256 => uint256) public mGetMinedEveryDay; mapping(address => bytes32) mapping_expr_cc; mapping(address => uint256) mapping_expr_cd; mapping(uint256 => uint256) mapping_expr_ch; mapping(bytes32 => bytes32) mapping_expr_ci; mapping(uint256 => uint256) mapping_expr_co; mapping(bytes32 => bytes32) mapping_expr_cp; mapping(uint256 => uint256) mapping_expr_cy; mapping(uint256 => uint256) mapping_expr_dg; mapping(address => bytes32) mapping_expr_dj; mapping(bytes32 => uint256) mapping_expr_dk; mapping(uint256 => uint256) mapping_expr_ds; mapping(bytes32 => bytes32) mapping_expr_dy; mapping(bytes32 => uint256) mapping_expr_ea; mapping(bytes32 => bytes32) mapping_expr_eh; mapping(bytes32 => bytes32) mapping_expr_ez; mapping(bytes32 => bytes32) mapping_expr_fi; mapping(uint256 => uint256) mapping_expr_fp; mapping(bytes32 => uint256) mapping_expr_fq; mapping(bytes32 => bytes32) mapping_expr_ft; mapping(bytes32 => bytes32) mapping_expr_fv; mapping(bytes32 => bytes32) mapping_expr_fx; mapping(bytes32 => bytes32) mapping_expr_fz; mapping(bytes32 => uint256) mapping_expr_gb; mapping(uint256 => uint256) mapping_expr_j; mapping(address => uint256) mapping_expr_t; mapping(uint256 => uint256) mapping_expr_w; mapping(bytes32 => bytes32) mapping_expr_z; bytes32 stor_expr_ac; bytes32 stor_expr_aj; uint256 stor_expr_au; uint256 stor_expr_av; uint256 stor_expr_aw; uint256 stor_expr_ax; bytes32 stor_expr_ba; bytes32 stor_expr_bd; uint256 stor_expr_bg; uint256 stor_expr_bh; uint256 stor_expr_bi; uint256 stor_expr_bj; bytes32 stor_expr_bm; bytes32 stor_expr_bp; uint256 stor_expr_bv; uint256 stor_expr_ce; uint256 stor_expr_cf; uint256 stor_expr_cg; bytes32 stor_expr_cj; uint256 stor_expr_ck; uint256 stor_expr_cm; uint256 stor_expr_cn; bytes32 stor_expr_cq; uint256 stor_expr_cr; uint256 stor_expr_ct; bytes32 stor_expr_cv; uint256 stor_expr_cw; uint256 stor_expr_cx; uint256 stor_expr_da; uint256 stor_expr_db; bytes32 stor_expr_dd; uint256 stor_expr_de; uint256 stor_expr_df; uint256 stor_expr_di; bytes32 stor_expr_dn; bytes32 stor_expr_do; address stor_expr_dp; bool stor_expr_dq; uint256 stor_expr_dw; bytes32 stor_expr_dz; uint256 stor_expr_e; bytes32 stor_expr_ec; bytes32 stor_expr_ei; bytes32 stor_expr_es; uint256 stor_expr_et; uint256 stor_expr_ew; bytes32 stor_expr_ex; bytes32 stor_expr_ey; bytes32 stor_expr_f; uint256 stor_expr_fc; uint256 stor_expr_fd; uint256 stor_expr_fe; uint256 stor_expr_ff; bytes32 stor_expr_fj; bytes32 stor_expr_fl; uint256 stor_expr_fm; uint256 stor_expr_fu; bytes32 stor_expr_fw; uint256 stor_expr_fy; bytes32 stor_expr_g; bytes32 stor_expr_ga; bytes32 stor_expr_h; bytes32 stor_expr_l; uint256 stor_expr_s; bytes32 stor_expr_v; uint256 stor_expr_x; event RoleRevoked(bytes32 indexed, address indexed, address indexed); error UUPSUnsupportedProxiableUUID(bytes32); error UUPSUnauthorizedCallContext(); event RoleGranted(bytes32 indexed, address indexed, address indexed); error InvalidInitialization(); error ERC1967InvalidImplementation(address); event Event_b7e060da(); error AccessControlBadConfirmation(); error FailedCall(); error AddressEmptyCode(address); error AccessControlUnauthorizedAccount(address, bytes32); event Upgraded(address indexed); event Event_3e451024(uint256 indexed, uint256, uint256, uint256); error NotInitializing(); error ERC1967NonPayable(); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } receive() external payable { } fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x1ec1d4cf)) { // Route to Unknown_1ec1d4cf(address,uint256,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x1e083322)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x24337b6e)) { // Route to Unknown_24337b6e(uint256,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x4d79a9a9)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x2f97d107)) { // Route to Unknown_2f97d107() after replacing only msg.sig. __desolexSelectorShim(uint32(0x39a002c2)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x38aea994)) { // Route to Unknown_38aea994(address,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xf6b1b383)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x4211606a)) { // Route to Unknown_4211606a(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x784ef328)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x4a275485)) { // Route to Unknown_4a275485(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x69c1cd87)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x6944e6fd)) { // Route to Unknown_6944e6fd(address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x9349cb4c)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x83c76dee)) { // Route to Unknown_83c76dee(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xfe81288e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x981e8626)) { // Route to Unknown_981e8626(bytes32) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5e634a0e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xacbd3da7)) { // Route to Unknown_acbd3da7(address,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x4128d23e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xadbfe300)) { // Route to Unknown_adbfe300(bytes,bytes,bytes,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0xf353e33b)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xaf23c978)) { // Route to Unknown_af23c978(uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5d16cdfd)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xc7f855b9)) { // Route to Unknown_c7f855b9(address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5e391f1d)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd2cf1ed5)) { // Route to Unknown_d2cf1ed5(uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x3bd65d8a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xdb94054d)) { // Route to Unknown_db94054d(address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5952a3ad)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xdd752e55)) { // Route to Unknown_dd752e55() after replacing only msg.sig. __desolexSelectorShim(uint32(0x78523f54)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xe5028be6)) { // Route to Unknown_e5028be6(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xf6c3babb)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf71d1901)) { // Route to Unknown_f71d1901(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x669b76bc)); return; } revert(); } function supportsInterface(bytes4 interfaceId) public pure returns (bool) { require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)); bool flag0 = 0x7965db0b00000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000); if (0x7965db0b00000000000000000000000000000000000000000000000000000000 != (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x1ffc9a700000000000000000000000000000000000000000000000000000000; } return flag0; } function takeOutToken(address arg0, uint256 arg1, address arg2) public { internal_952(arg2, arg1, arg0); } function Unknown_1ec1d4cf(address arg0, uint256 arg1, bool arg2) public returns (bool) { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][address(msg.sender)]) != 0x0, AccessControlUnauthorizedAccount()); uint256 var_c; var_c = var_c + 0x60; array_2.length = array_2.length + 0x01; stor_expr_e = (address(var_c.length)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_e); stor_expr_f = var_g; stor_expr_g = (!(!(var_h))) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_expr_g); stor_expr_h = 0x015180; array_1[keccak256(abi.encode((array_2.length - 0x01), 0x03))] = 0x1e; mapping_expr_j[(block.timestamp / 0x015180) * 0x015180] = arg1 + mapping_expr_j[(block.timestamp / 0x015180) * 0x015180]; return true; } function Unknown_24337b6e(uint256 arg0, uint256 arg1, uint256 arg2) public payable { require(arg0 < 0x5); require(tx.origin == msg.sender, "not call"); require(!(arg1 == 0x0 || arg2 == 0x0), "addLiquidity amount error"); if (!(arg0 <= 0x4)) _desolexPanic(33); if (arg0 != 0x2) { if (!(arg0 <= 0x4)) _desolexPanic(33); uint256 value16 = (arg2) ? 1 : 0; uint256 value17 = 0; uint256 value18 = arg1; if (arg0 == 0x3) { if (!(arg0 <= 0x4)) _desolexPanic(33); uint256 value11 = var_a.length; if (arg0 != 0x3) { var_c = msg.data[4:68]; var_d = var_d; (bool success0, bytes memory returnData0) = address(var_d).Unknown_27a6cf96(); // staticcall require(success0); var_a = var_a + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData0.length) - var_a >= 0x20); require(var_f == (var_f & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(0 < var_a.length)) _desolexPanic(50); var_d = var_d; (bool success1, bytes memory returnData1) = address(var_d).Unknown_01af8bac(); // staticcall require(success1); var_a = var_a + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData1.length) - var_a >= 0x20); require(var_i == (var_i & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(0x01 < var_a.length)) _desolexPanic(50); var_d = var_d; uint256 value2 = 0; uint256 value3 = var_a + 0x20; uint256 value4 = (0x04 + var_a) + 0x60; while (true) { uint256 value5 = value2; uint256 value6 = value3; uint256 value7 = value4; if (!(value2 < var_n)) { break; } if (!((0x01 + value2) < var_n)) { break; } value2 = 0x01 + (0x01 + value2); value3 = 0x20 + (0x20 + value3); value4 = 0x20 + (0x20 + value4); value5 = 0x01 + value2; value6 = 0x20 + value3; value7 = 0x20 + value4; } (bool success2, bytes memory returnData2) = address(var_d).Unknown_faeba675(0x40, (arg1 / 0x02), var_n); // staticcall require(success2); var_a = var_a + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData2.length) - var_a >= 0x20); } else { var_d = var_d; (bool success3, bytes memory returnData3) = address(var_d).viewPrices(); // staticcall require(success3); var_a = var_a + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData3.length) - var_a >= 0xa0); value11 = (var_z * arg1) / var_c; } require(!(value11 < (arg2 - ((arg2 * 0x0a) / 0x64))), "liquidity fsc amount error"); var_d = var_d; (bool success4, bytes memory returnData4) = address(var_d).Unknown_3afad0dd(); // staticcall require(success4); var_a = var_a + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData4.length) - var_a >= 0x20); require(var_ab == (var_ab & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = 0x60 + (0x24 + var_a); uint256 value12 = 0; while (true) { if (value12 >= var_ag) { break; } value12 = 0x20 + value12; (bool success5, bytes memory returnData5) = address(var_ac).pisnfmc(var_aj, var_ak, var_al); // call uint256 value13 = 0x60; if (returnData5.length != 0) { var_a = var_a + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value13 = var_a; } uint256 value14 = success5; if (success5) { uint256 value28 = !var_am; if (var_am != 0x0) { require(((0x20 + value13) + var_am) - (0x20 + value13) >= 0x20); require(var_an == (var_an != 0x0)); value28 = var_ao; } value14 = value28; } require(value14 != 0x0, "TransferHelper: TRANSFER_FROM_FAILED"); } value16 = 0; value17 = arg1; value18 = value11; } var_d = var_d; (bool success6, bytes memory returnData6) = address(var_d).Unknown_2f97d107(); // staticcall require(success6); var_a = var_a + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData6.length) - var_a >= 0xa0); if (((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a)) _desolexPanic(65); var_a = var_a + 0xa0; require(var_aq == (var_aq & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_ar == (var_ar & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_as == (var_as & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_at == (var_at & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = 0x60 + (0x24 + var_a); uint256 value12 = 0; while (true) { uint256 value19 = value12; if (value12 >= var_ag) { break; } if (0x20 + value12 >= var_ag) { break; } value12 = 0x20 + (0x20 + value12); value19 = 0x20 + value12; } (bool success7, bytes memory returnData7) = address(var_ax).pisnfmc(var_bh, var_bi, var_bj); // call uint256 value20 = 0x60; if (returnData7.length != 0) { var_a = var_a + ((returnData7.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value20 = var_a; } } else { var_d = var_d; (bool success8, bytes memory returnData8) = address(var_d).Unknown_885202c1(); // staticcall require(success8); var_a = var_a + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData8.length) - var_a >= 0x20); require(var_bk == (var_bk & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = 0x60 + (0x24 + var_a); uint256 value12 = 0; while (true) { if (value12 >= var_ag) { break; } value12 = 0x20 + value12; (bool success9, bytes memory returnData9) = address(var_ac).pisnfmc(var_bo, var_bp, var_bq); // call uint256 value22 = 0x60; if (returnData9.length != 0) { var_a = var_a + ((returnData9.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value22 = var_a; } uint256 value23 = success9; if (success9) { uint256 value29 = !var_br; if (var_br != 0x0) { require(((0x20 + value22) + var_br) - (0x20 + value22) >= 0x20); require(var_an == (var_an != 0x0)); value29 = var_bs; } value23 = value29; } require(value23 != 0x0, "TransferHelper: TRANSFER_FROM_FAILED"); var_d = var_d; (bool success10, bytes memory returnData10) = address(var_d).Unknown_885202c1(); // staticcall require(success10); var_a = var_a + ((returnData10.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData10.length) - var_a >= 0x20); require(var_bt == (var_bt & 0xffffffffffffffffffffffffffffffffffffffff)); var_d = var_d; (bool success11, bytes memory returnData11) = address(var_d).Unknown_850fe0b9(); // staticcall require(success11); var_a = var_a + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData11.length) - var_a >= 0x20); require(var_bu == (var_bu & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a + 0x64; uint256 value12 = 0; while (true) { uint256 value25 = value12; if (value12 >= var_bx) { break; } if (0x20 + value12 >= var_bx) { break; } value12 = 0x20 + (0x20 + value12); value25 = 0x20 + value12; } (bool success12, bytes memory returnData12) = address(var_ac).adfepixw(); // call uint256 value26 = 0x60; if (returnData12.length != 0) { var_a = var_a + ((returnData12.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value26 = var_a; } uint256 value27 = success12; if (success12) { uint256 value30 = !var_ca; if (var_ca != 0x0) { require(((0x20 + value26) + var_ca) - (0x20 + value26) >= 0x20); require(var_cb == (var_cb != 0x0)); value30 = var_cc; } value27 = value30; } } } } function getRoleAdmin(bytes32 role) public view returns (uint256) { var_a = var_a; return stor_expr_l; } function grantRole(bytes32 role, address account) public { var_a = var_a; var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); var_a = var_a; var_a = account; uint256 value0 = 0; if (!(bytes1(hasRole[var_a][account]) != 0x0)) { var_a = role; var_a = account; hasRole[role][account] = true; emit RoleGranted(role, account, msg.sender); flag0 = true; } } function Unknown_2f97d107() public returns (bytes memory) { var_g = var_g; (bool success0, bytes memory returnData0) = address(var_g).Unknown_2f97d107(); // staticcall require(success0); var_a = var_a + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData0.length) - var_a) < 0xa0)); if (((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a)) _desolexPanic(65); var_a = var_a + 0xa0; require(var_a.length == (var_a.length & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_j == (var_j & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_l == (var_l & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_n == (var_n & 0xffffffffffffffffffffffffffffffffffffffff)); return abi.encodePacked(address(var_a.length), address(var_w), address(var_x), address(var_y), var_z); } function renounceRole(bytes32 role, address account) public { require(msg.sender == account, AccessControlBadConfirmation()); var_a = var_a; var_a = account; if (bytes1(hasRole[var_a][account])) { var_a = role; var_a = account; hasRole[role][account] = false; emit RoleRevoked(role, account, msg.sender); } } function Unknown_38aea994(address arg0, uint256 arg1, uint256 arg2) public returns (uint256) { uint256 value0; if (0xc != arg2) { uint256 value19 = 0; if (0xd == arg2) { value19 = stor_expr_s / 0x02; } value0 = value19; } else { value0 = stor_expr_s; } uint256 value8; if (value0 > 0x0) { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).viewPrices(); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0xa0)); uint256 value20; if (0x1e != arg1) { uint256 value6; uint256 value7; if (0x3c != arg1) { uint256 value21 = 0 * ((var_d.length * value0) / var_i); uint256 value22 = 0; if (0x5a != arg1) { } else { value21 = 0x0a * ((var_d.length * value0) / var_i); value22 = 0x0a; } value6 = value21; value7 = value22; } else { value6 = 0x14 * ((var_d.length * value0) / var_i); value7 = 0x14; } value20 = value6 / 0x64; } else { value20 = (0x1e * ((var_d.length * value0) / var_i)) / 0x64; } value8 = value20; } else { value8 = 0; } var_a = var_a; var_a = arg0; if (mapping_expr_t[arg0] != 0x0) { if (!((mapping_expr_t[arg0] - 0x01) < mapping_expr_t[arg0])) _desolexPanic(50); var_a = stor_expr_v; uint256 value9; if (0xc != arg2) { uint256 value23 = 0; if (0xd == arg2) { value23 = (mapping_expr_w[stor_expr_x] - mapping_7[arg0]) / 0x02; } value9 = value23; } else { value9 = mapping_expr_w[stor_expr_x] - mapping_7[arg0]; } uint256 value13; if (value9 > 0x0) { uint256 value24; if (0x0 != value9) { uint256 value10 = var_d.length; if (0x0 != value9) { var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_4a275485(value9); // staticcall require(success1); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData1.length) - var_d) < 0x20)); } else { value10 = 0; } uint256 value25; if (0x1e != arg1) { uint256 value11; uint256 value12; if (0x3c != arg1) { uint256 value26 = 0 * value10; uint256 value27 = 0; if (0x5a != arg1) { } else { value26 = 0x0a * value10; value27 = 0x0a; } value11 = value26; value12 = value27; } else { value11 = 0x14 * value10; value12 = 0x14; } value25 = value11 / 0x64; } else { value25 = (0x1e * value10) / 0x64; } value24 = value25; } else { value24 = 0; } value13 = value24; } else { value13 = 0; } return value13 + value8; } else { uint256 value14; if (0xc != arg2) { uint256 value28 = 0; if (0xd == arg2) { value28 = (0 - mapping_7[arg0]) / 0x02; } value14 = value28; } else { value14 = 0 - mapping_7[arg0]; } uint256 value18; if (value14 > 0x0) { uint256 value29; if (0x0 != value14) { uint256 value15 = var_d.length; if (0x0 != value14) { var_a = var_a; (bool success2, bytes memory returnData2) = address(var_a).Unknown_4a275485(value14); // staticcall require(success2); var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData2.length) - var_d) < 0x20)); } else { value15 = 0; } uint256 value30; if (0x1e != arg1) { uint256 value16; uint256 value17; if (0x3c != arg1) { uint256 value31 = 0 * value15; uint256 value32 = 0; if (0x5a != arg1) { } else { value31 = 0x0a * value15; value32 = 0x0a; } value16 = value31; value17 = value32; } else { value16 = 0x14 * value15; value17 = 0x14; } value30 = value16 / 0x64; } else { value30 = (0x1e * value15) / 0x64; } value29 = value30; } else { value29 = 0; } value18 = value29; } else { value18 = 0; } return value18 + value8; } } function userLpInfo(address arg0) public returns (bytes memory) { internal_d9f(arg0); return abi.encodePacked(value0, value4, value3); } function Unknown_4211606a(uint256 arg0) public { require(arg0 < 0x5); if (!(0 < array_2.length)) _desolexPanic(50); uint256 var_b; var_b = var_b + 0x60; uint256 value0 = mapping_expr_ai[stor_expr_aj]; if (mapping_expr_ak[msg.sender] != 0x0) { if (!((mapping_expr_ak[msg.sender] - 0x01) < mapping_expr_ak[msg.sender])) _desolexPanic(50); } else { value0 = 0; } uint256 value14 = 0; if ((mapping_expr_aq[msg.sender] != 0x0) && (mapping_expr_aq[msg.sender] < ((block.timestamp / 0x015180) * 0x015180))) { uint256 value11 = array_1[keccak256(abi.encode(0, 0x03))]; uint256 value12 = ((block.timestamp / 0x015180) * 0x015180) - 0x015180; uint256 value13 = 0; if ((((block.timestamp / 0x015180) * 0x015180) - 0x15180 >= mapping_expr_aq[msg.sender]) && (array_1[keccak256(abi.encode(0, 0x03))] > 0x0)) { uint256 value2 = mapping_expr_at[msg.sender][((block.timestamp / 0x015180) * 0x015180) - 0x015180]; if (0 == mapping_expr_at[msg.sender][((block.timestamp / 0x015180) * 0x015180) - 0x015180]) { if (stor_expr_au != 0x0) { if (!(0 < stor_expr_au)) _desolexPanic(50); } uint256 value1; if (!(stor_expr_au == 0x0 || (((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_av)) { uint256 value23 = 0; if ((stor_expr_au > 0x0) && (0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!((stor_expr_au - 0x01) < stor_expr_au)) _desolexPanic(50); uint256 value24; if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_aw) { uint256 value25 = 0; if ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_au > 0x0) && (0x1 + 0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_au) - 0x01) < stor_expr_au)) _desolexPanic(50); if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_ax) { } else { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_au) - 0x01) < stor_expr_au)) _desolexPanic(50); } value25 = mapping_expr_az[stor_expr_ba]; } value24 = value25; } else { if (!((stor_expr_au - 0x01) < stor_expr_au)) _desolexPanic(50); value24 = mapping_expr_az[stor_expr_bd]; } value23 = value24; } value1 = value23; } else { value1 = 0; } value2 = value1 * 0x05a0; } uint256 value4 = mapping_expr_be[((block.timestamp / 0x015180) * 0x015180) - 0x015180]; if (0 == mapping_expr_be[((block.timestamp / 0x015180) * 0x015180) - 0x015180]) { if (stor_expr_bg != 0x0) { if (!(0 < stor_expr_bg)) _desolexPanic(50); } uint256 value3; if (!(stor_expr_bg == 0x0 || (((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_bh)) { uint256 value28 = 0; if ((stor_expr_bg > 0x0) && (0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!((stor_expr_bg - 0x01) < stor_expr_bg)) _desolexPanic(50); uint256 value29; if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_bi) { uint256 value30 = 0; if ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_bg > 0x0) && (0x1 + 0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_bg) - 0x01) < stor_expr_bg)) _desolexPanic(50); if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_bj) { } else { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_bg) - 0x01) < stor_expr_bg)) _desolexPanic(50); } value30 = mapping_expr_bl[stor_expr_bm]; } value29 = value30; } else { if (!((stor_expr_bg - 0x01) < stor_expr_bg)) _desolexPanic(50); value29 = mapping_expr_bl[stor_expr_bp]; } value28 = value29; } value3 = value28; } else { value3 = 0; } value4 = value3 * 0x05a0; } uint256 value5 = 0; if ((value4 != 0x0) && (value2 <= value4)) { value5 = ((mapping_expr_bq[((block.timestamp / 0x015180) * 0x015180) - 0x015180] * value2) / value4) + 0; } if ((((block.timestamp / 0x015180) * 0x015180) - 0x15180 - 0x15180 >= mapping_expr_aq[msg.sender]) && (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + array_1[keccak256(abi.encode(0, 0x03))] > 0x0)) { uint256 value7 = mapping_expr_at[msg.sender][(((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180]; if (0 == mapping_expr_at[msg.sender][(((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180]) { if (stor_expr_au != 0x0) { if (!(0 < stor_expr_au)) _desolexPanic(50); } uint256 value6; if (!(stor_expr_au == 0x0 || ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180) < stor_expr_av)) { uint256 value31 = 0; if ((stor_expr_au > 0x0) && (0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!((stor_expr_au - 0x01) < stor_expr_au)) _desolexPanic(50); uint256 value32; if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_aw) { uint256 value33 = 0; if ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_au > 0x0) && (0x1 + 0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_au) - 0x01) < stor_expr_au)) _desolexPanic(50); if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_ax) { } else { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_au) - 0x01) < stor_expr_au)) _desolexPanic(50); } value33 = mapping_expr_az[stor_expr_ba]; } value32 = value33; } else { if (!((stor_expr_au - 0x01) < stor_expr_au)) _desolexPanic(50); value32 = mapping_expr_az[stor_expr_bd]; } value31 = value32; } value6 = value31; } else { value6 = 0; } value7 = value6 * 0x05a0; } uint256 value9 = mapping_expr_be[(((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180]; if (0 == mapping_expr_be[(((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180]) { if (stor_expr_bg != 0x0) { if (!(0 < stor_expr_bg)) _desolexPanic(50); } uint256 value8; if (!(stor_expr_bg == 0x0 || ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180) < stor_expr_bh)) { uint256 value34 = 0; if ((stor_expr_bg > 0x0) && (0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!((stor_expr_bg - 0x01) < stor_expr_bg)) _desolexPanic(50); uint256 value35; if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_bi) { uint256 value36 = 0; if ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_bg > 0x0) && (0x1 + 0x0 < array_1[keccak256(abi.encode(0, 0x03))])) { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_bg) - 0x01) < stor_expr_bg)) _desolexPanic(50); if ((((block.timestamp / 0x015180) * 0x015180) - 0x015180) < stor_expr_bj) { } else { if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_bg) - 0x01) < stor_expr_bg)) _desolexPanic(50); } value36 = mapping_expr_bl[stor_expr_bm]; } value35 = value36; } else { if (!((stor_expr_bg - 0x01) < stor_expr_bg)) _desolexPanic(50); value35 = mapping_expr_bl[stor_expr_bp]; } value34 = value35; } value8 = value34; } else { value8 = 0; } value9 = value8 * 0x05a0; } uint256 value10 = value5; if ((value9 != 0x0) && (value7 <= value9)) { value10 = ((mapping_expr_bq[(((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180] * value7) / value9) + value5; } } value11 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + array_1[keccak256(abi.encode(0, 0x03))]; value12 = (((block.timestamp / 0x015180) * 0x015180) - 0x015180) - 0x015180; value13 = value5; } value14 = value13; } var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_01af8bac(); // staticcall require(success0); require(__desolex_internal_59ab_5055_arg1 - __desolex_internal_59ab_5055_arg0 >= 0x20); require(__desolex_internal_53ad_315f_arg0 == (__desolex_internal_53ad_315f_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success1); require(__desolex_internal_59ab_514c_arg1 - __desolex_internal_59ab_514c_arg0 >= 0x20); require(__desolex_internal_53ad_315f_arg0 == (__desolex_internal_53ad_315f_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success2, bytes memory returnData2) = __desolex_internal_50dc_505a_arg0.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), account0)); // staticcall balanceOf require(success2); require(__desolex_internal_5994_51b9_arg1 - __desolex_internal_5994_51b9_arg0 >= 0x20); uint256 accountBalance = abi.decode(returnData2, (uint256)); var_a = var_a; (bool success3, bytes memory returnData3) = address(var_a).viewPrices(); // staticcall require(success3); require(__desolex_internal_5af7_522a_arg1 - __desolex_internal_5af7_522a_arg0 >= 0xa0); var_a = var_a; (bool success4, bytes memory returnData4) = address(var_a).Unknown_01af8bac(); // staticcall require(success4); var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(__desolex_internal_59ab_529e_arg1 - __desolex_internal_59ab_529e_arg0 >= 0x20); require(__desolex_internal_53ad_315f_arg0 == (__desolex_internal_53ad_315f_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value22 = var_n; if (__desolex_internal_50dc_505a_arg0 == (0xffffffffffffffffffffffffffffffffffffffff & value21)) { } else { value22 = var_o; } (bool success5, bytes memory returnData5) = address(var_b.length).totalSupply(); // staticcall require(success5); require(__desolex_internal_5994_532f_arg1 - __desolex_internal_5994_532f_arg0 >= 0x20); uint256 tokenSupply = abi.decode(returnData5, (uint256)); } function Unknown_4a275485(uint256 arg0) public returns (uint256) { if (0x0 == arg0) { return 0; } var_c = var_c; (bool success0, bytes memory returnData0) = address(var_c).Unknown_4a275485(arg0); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0x20)); return var_d.length; } function upgradeToAndCall(address newImplementation, bytes memory data) public payable { if (data.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (data.length + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (data.length + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (data.length + 0x1f))) + 0x1f)); require(!(((0x04 + data) + data + 0x20) > msg.data.length)); if (address(0xe4afb902f1c6b10bb017562774c499cb0a67db46) != address(this)) { require((0xffffffffffffffffffffffffffffffffffffffff & address(stor_expr_bv)) == 0xe4afb902f1c6b10bb017562774c499cb0a67db46, UUPSUnauthorizedCallContext()); var_e = var_e; var_e = msg.sender; require(bytes1(mapping_expr_bw[var_e][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); (bool success0, bytes memory returnData0) = newImplementation.proxiableUUID(); // staticcall if (!success0) { require(success0, ERC1967InvalidImplementation()); var_e = var_e; require(var_a == var_e, UUPSUnsupportedProxiableUUID()); require(0x0 != (0xffffffffffffffffffffffffffffffffffffffff & 0x0ea1).code.length, ERC1967InvalidImplementation()); stor_expr_bv = (address(0x0ea1)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bv); emit Upgraded(0x0ea1); if (var_g != 0x0) { uint256 value0 = 0; while (true) { if (value0 >= var_s) { break; } value0 = 0x20 + value0; (bool success1, bytes memory returnData1) = address(0x0ea1).Unknown_(var_i); // delegatecall if (returnData1.length != 0) { if (!(success1)) { require(!var_j); revert FailedCall(); } bool flag0 = !var_l; if (!var_l) { flag0 = (0x0ea1 & 0xffffffffffffffffffffffffffffffffffffffff).code.length == 0x0; } require(!flag0, AddressEmptyCode()); } if (!(success1)) { require(!var_j); revert FailedCall(); } require(!(var_l == 0x0 && (0x0ea1 & 0xffffffffffffffffffffffffffffffffffffffff).code.length == 0x0), AddressEmptyCode()); } } require(!msg.value, ERC1967NonPayable()); } else { var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f)); require((var_a + returnData0.length) - var_a >= 0x20); require(0x01 != 0x0, ERC1967InvalidImplementation()); var_e = var_e; require(var_a.length == var_e, UUPSUnsupportedProxiableUUID()); require(0x0 != (0xffffffffffffffffffffffffffffffffffffffff & 0x0ea1).code.length, ERC1967InvalidImplementation()); stor_expr_bv = (address(0x0ea1)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bv); emit Upgraded(newImplementation); if (!var_n) { require(!msg.value, ERC1967NonPayable()); } else { uint256 value0 = 0; while (true) { if (value0 >= var_s) { break; } value0 = 0x20 + value0; (bool success2, bytes memory returnData2) = newImplementation.Unknown_(var_p); // delegatecall uint256 value2 = 0x60; if (returnData2.length != 0) { var_a = var_a + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value2 = var_a; } if (!(success2)) { require(!var_j); revert FailedCall(); } require(!(var_q == 0x0 && newImplementation.code.length == 0x0), AddressEmptyCode()); } } } } require(address(0xe4afb902f1c6b10bb017562774c499cb0a67db46) != address(this), UUPSUnauthorizedCallContext()); var_e = var_e; var_e = msg.sender; require(bytes1(mapping_expr_bw[var_e][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); (bool success3, bytes memory returnData3) = newImplementation.proxiableUUID(); // staticcall if (!success3) { require(success3, ERC1967InvalidImplementation()); var_e = var_e; require(var_a == var_e, UUPSUnsupportedProxiableUUID()); require(0x0 != (0xffffffffffffffffffffffffffffffffffffffff & 0x0ea1).code.length, ERC1967InvalidImplementation()); stor_expr_bv = (address(0x0ea1)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bv); emit Upgraded(0x0ea1); if (var_r != 0x0) { uint256 value0 = 0; while (true) { uint256 value3 = value0; if (value0 >= var_s) { break; } if (0x20 + value0 >= var_s) { break; } value0 = 0x20 + (0x20 + value0); value3 = 0x20 + value0; } (bool success4, bytes memory returnData4) = address(0x0ea1).Unknown_(var_i); // delegatecall if (returnData4.length != 0) { var_a = var_a + ((returnData4.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (!(success4)) { require(!var_j); revert FailedCall(); } bool flag3 = !var_l; if (!var_l) { flag3 = (0x0ea1 & 0xffffffffffffffffffffffffffffffffffffffff).code.length == 0x0; } require(!flag3, AddressEmptyCode()); } if (!(success4)) { require(!var_j); revert FailedCall(); } require(!(var_l == 0x0 && (0x0ea1 & 0xffffffffffffffffffffffffffffffffffffffff).code.length == 0x0), AddressEmptyCode()); } require(!msg.value, ERC1967NonPayable()); } else { var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData3.length + 0x1f)); require((var_a + returnData3.length) - var_a >= 0x20); require(0x01 != 0x0, ERC1967InvalidImplementation()); var_e = var_e; require(var_u == var_e, UUPSUnsupportedProxiableUUID()); require(0x0 != (0xffffffffffffffffffffffffffffffffffffffff & newImplementation).code.length, ERC1967InvalidImplementation()); stor_expr_bv = newImplementation | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bv); emit Upgraded(newImplementation); if (!var_n) { require(!msg.value, ERC1967NonPayable()); } else { uint256 value0 = 0; while (true) { uint256 value5 = value0; if (value0 >= var_s) { break; } if (0x20 + value0 >= var_s) { break; } value0 = 0x20 + (0x20 + value0); value5 = 0x20 + value0; } (bool success5, bytes memory returnData5) = newImplementation.Unknown_(var_p); // delegatecall uint256 value6 = 0x60; if (returnData5.length != 0) { var_a = var_a + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value6 = var_a; } if (!(success5)) { require(!var_j); revert FailedCall(); } require(!(var_v == 0x0 && newImplementation.code.length == 0x0), AddressEmptyCode()); } } } function proxiableUUID() public pure returns (uint256) { require(address(0xe4afb902f1c6b10bb017562774c499cb0a67db46) == address(this), UUPSUnauthorizedCallContext()); var_a = var_a; return var_a; } function Unknown_6944e6fd(address arg0, uint256 arg1) public { internal_eeb(arg1, arg0); } function pledgeInfos(uint256 index) public view returns (bool) { require(index < array_2.length); return abi.encodePacked(stor_expr_dp, stor_expr_do, !(!(bytes1(stor_expr_dn)))); } function initialize() public { bool flag0 = !(uint64(stor_expr_dq)); if (!(uint64(stor_expr_dq))) { flag0 = !(bytes1(stor_expr_dq / 0x010000000000000000)); } require(!(!flag0 && !(0x1 == (0xffffffffffffffff & (0xffffffffffffffff & stor_expr_dq)) && address(this).code.length == 0x0)), InvalidInitialization()); stor_expr_dq = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000 & stor_expr_dq); if (!(bytes1(stor_expr_dq / 0x010000000000000000))) { stor_expr_dq = 0x010000000000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff & stor_expr_dq); } uint256 value0 = 0x117e; while (true) { if (!(bytes1(stor_f0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00 / 0x010000000000000000))) { break; } value0 = 0x117e; } revert NotInitializing(); } function Unknown_83c76dee(uint256 arg0) public { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_01af8bac(); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & value0), "not auth"); if (arg0 != 0x0) { var_a = var_a; var_a = (block.timestamp / 0x015180) * 0x015180; mapping_expr_ds[(block.timestamp / 0x015180) * 0x015180] = arg0 + mapping_expr_ds[(block.timestamp / 0x015180) * 0x015180]; } } function Unknown_981e8626(bytes32 arg0) public view returns (bytes memory) { return abi.encodePacked(mGetMinedEveryDay[(block.timestamp / 0x015180) * 0x015180], mGetMinedEveryDay[((block.timestamp / 0x015180) * 0x015180) - 0x015180]); } function Unknown_acbd3da7(address arg0, uint256 arg1, uint256 arg2) public returns (bytes memory) { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_caa5412a(); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & value0), "not auth"); uint256 value1; if (0xc != arg2) { uint256 value67 = 0; if (0xd == arg2) { value67 = stor_expr_dw / 0x02; } value1 = value67; } else { value1 = stor_expr_dw; } uint256 value9; if (value1 > 0) { var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).viewPrices(); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData1.length) - var_c >= 0xa0); uint256 value68; if (0x1e != arg1) { uint256 value7; uint256 value8; if (0x3c != arg1) { uint256 value69 = 0 * ((var_c.length * value1) / var_k); uint256 value70 = 0; if (0x5a != arg1) { } else { value69 = 0x0a * ((var_c.length * value1) / var_k); value70 = 0x0a; } value7 = value69; value8 = value70; } else { value7 = 0x14 * ((var_c.length * value1) / var_k); value8 = 0x14; } value68 = value7 / 0x64; } else { value68 = (0x1e * ((var_c.length * value1) / var_k)) / 0x64; } value9 = value68; } else { value9 = 0; } var_a = var_a; var_a = arg0; uint256 value10 = mapping_expr_dy[stor_expr_dz]; if (mapping_expr_ea[arg0] != 0x0) { if (!((mapping_expr_ea[arg0] - 0x01) < mapping_expr_ea[arg0])) _desolexPanic(50); var_a = stor_expr_ec; } else { value10 = 0; } uint256 value11; if (0xc != arg2) { uint256 value71 = 0; if (0xd == arg2) { value71 = (value10 - mapping_7[arg0]) / 0x02; } value11 = value71; } else { value11 = value10 - mapping_7[arg0]; } uint256 value15; if (value11 > 0) { uint256 value72; if (0x0 != value11) { uint256 value12 = var_c.length; if (0x0 != value11) { var_a = var_a; (bool success2, bytes memory returnData2) = address(var_a).Unknown_4a275485(value11); // staticcall require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData2.length) - var_c) < 0x20)); } else { value12 = 0; } uint256 value73; if (0x1e != arg1) { uint256 value13; uint256 value14; if (0x3c != arg1) { uint256 value74 = 0 * value12; uint256 value75 = 0; if (0x5a != arg1) { } else { value74 = 0x0a * value12; value75 = 0x0a; } value13 = value74; value14 = value75; } else { value13 = 0x14 * value12; value14 = 0x14; } value73 = value13 / 0x64; } else { value73 = (0x1e * value12) / 0x64; } value72 = value73; } else { value72 = 0; } value15 = value72; } else { value15 = 0; } var_a = var_a; var_a = arg0; uint256 value16 = mapping_expr_eh[stor_expr_ei]; if (mapping_expr_t[arg0] != 0x0) { if (!((mapping_expr_t[arg0] - 0x01) < mapping_expr_t[arg0])) _desolexPanic(50); var_a = stor_expr_ei; } else { value16 = 0; } uint256 value28 = value16; if (value16 != 0x0) { if (!(0 < array_2.length)) _desolexPanic(50); if (0 == mapping_expr_cc[arg0]) { mapping_expr_cd[arg0] = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); } uint256 value21; uint256 value22; uint256 value17 = 0; if (stor_expr_cf != 0) { if (!((stor_expr_cf - 0x01) < stor_expr_cf)) _desolexPanic(50); require(!(mapping_expr_ch[stor_expr_cg] < value16), "InsufficientQuota"); uint256 value76 = mapping_expr_ci[stor_expr_cj]; if (stor_expr_cg != (stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))) { stor_expr_cf = stor_expr_cf + 0x01; stor_expr_ck = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); mapping_expr_ch[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = mapping_expr_ch[stor_expr_cg] - value16; } else { mapping_expr_ch[stor_expr_cg] = mapping_expr_ch[stor_expr_cg] - value16; value76 = 0; } value17 = value76; } uint256 value18 = 0; if (stor_expr_cm != 0) { if (!((stor_expr_cm - 0x01) < stor_expr_cm)) _desolexPanic(50); require(!(mapping_expr_co[stor_expr_cn] < value16), "InsufficientQuota"); uint256 value77 = mapping_expr_cp[stor_expr_cq]; if (stor_expr_cn != (stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))) { stor_expr_cm = stor_expr_cm + 0x01; stor_expr_cr = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); mapping_expr_co[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = mapping_expr_co[stor_expr_cn] - value16; } else { mapping_expr_co[stor_expr_cn] = mapping_expr_co[stor_expr_cn] - value16; value77 = 0; } value18 = value77; } value21 = value18; value22 = value17; uint256 value23 = mapping_expr_dj[arg0][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; if (value22 != 0x0) { value23 = (value22 * 0x05a0) + mapping_expr_dj[arg0][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; } uint256 value24 = mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; if (value21 != 0x0) { value24 = (value21 * 0x05a0) + mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; } uint256 value25 = value24 - ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c); uint256 value26 = value23 - ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c); require(!(value23 < ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c)), "p_value_lock"); require(!(value24 < ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c)), "n_value_lock"); mapping_expr_dj[arg0][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = value26; mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = value25; uint256 value27 = array_1[0 + keccak256(abi.encode(0x02))] - value16; require(!(array_1[0 + keccak256(abi.encode(0x02))] < value16), "amount_lock"); array_1[0 + keccak256(abi.encode(0x02))] = value27; unresolved_458b7f2d[(block.timestamp / 0x015180) * 0x015180] = value27; value28 = value16 - mapping_7[arg0]; } uint256 value29 = 0; if (0x1e == arg1) { value29 = 0x01; } uint256 value30 = value29; if (0x3c == arg1) { value30 = 0x02; } uint256 value31 = value30; if (0x5a == arg1) { value31 = 0x03; } if (value28 != 0x0) { uint256 value32; if (0xc != arg2) { uint256 value80 = 0; if (0xd == arg2) { value80 = value28 / 0x02; } value32 = value80; } else { value32 = value28; } if (value32 != 0x0) { var_a = var_a; (bool success3, bytes memory returnData3) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success3); var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData3.length) - var_c >= 0x20); require(var_o == (var_o & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success4, bytes memory returnData4) = address(var_a).Unknown_6acf02f1(); // staticcall require(success4); var_c = var_c + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData4.length) - var_c >= 0x20); require(var_q == (var_q & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = var_c + 0x64; uint256 value34 = 0; while (true) { if (value34 >= var_x) { break; } value34 = 0x20 + value34; (bool success5, bytes memory returnData5) = address(var_r).adfepixw(); // call uint256 value35 = 0x60; if (returnData5.length != 0) { var_c = var_c + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value35 = var_c; } uint256 value36 = success5; if (success5) { uint256 value81 = !var_aa; if (var_aa != 0x0) { require(((0x20 + value35) + var_aa) - (0x20 + value35) >= 0x20); require(var_ab == (var_ab != 0x0)); value81 = var_ac; } value36 = value81; } require(value36 != 0x0, "TransferHelper: APPROVE_FAILED"); var_a = var_a; (bool success6, bytes memory returnData6) = address(var_a).Unknown_6acf02f1(); // staticcall require(success6); var_c = var_c + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData6.length) - var_c >= 0x20); require(var_ad == (var_ad & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(value31 < 0x4)) _desolexPanic(33); require(address(var_r).code.length != 0x0); (bool success7, bytes memory returnData7) = address(var_r).lock(arg0, value31, value32); // call require(success7); } } if ((value28 - value32) > 0) { var_a = var_a; (bool success8, bytes memory returnData8) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success8); var_c = var_c + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData8.length) - var_c >= 0x20); require(var_ai == (var_ai & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success9, bytes memory returnData9) = address(var_a).Unknown_ec2e2148(); // staticcall require(success9); var_c = var_c + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData9.length) - var_c >= 0x20); require(var_aj == (var_aj & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = var_c + 0x64; uint256 value34 = 0; while (true) { if (value34 >= var_ak) { break; } value34 = 0x20 + value34; (bool success10, bytes memory returnData10) = address(var_r).adfepixw(); // call uint256 value38 = 0x60; if (returnData10.length != 0) { var_c = var_c + ((returnData10.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value38 = var_c; } uint256 value39 = success10; if (success10) { uint256 value82 = !var_al; if (var_al != 0x0) { require(((0x20 + value38) + var_al) - (0x20 + value38) >= 0x20); require(var_am == (var_am != 0x0)); value82 = var_an; } value39 = value82; } require(value39 != 0x0, "TransferHelper: TRANSFER_FAILED"); } } } if (stor_expr_es) { uint256 value40; if (0xc != arg2) { uint256 value83 = 0; if (0xd == arg2) { value83 = stor_expr_et / 0x02; } value40 = value83; } else { value40 = stor_expr_et; } if (value40 == 0x0) { if ((stor_expr_et - value40) > 0) { var_a = var_a; (bool success11, bytes memory returnData11) = address(var_a).Unknown_885202c1(); // staticcall require(success11); var_c = var_c + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData11.length) - var_c >= 0x20); require(var_ai == (var_ai & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success12, bytes memory returnData12) = address(var_a).Unknown_ec2e2148(); // staticcall require(success12); var_c = var_c + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData12.length) - var_c >= 0x20); require(var_aj == (var_aj & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = var_c + 0x64; uint256 value34 = 0; while (true) { if (value34 >= var_ak) { break; } value34 = 0x20 + value34; (bool success13, bytes memory returnData13) = address(var_r).adfepixw(); // call uint256 value42 = 0x60; if (returnData13.length != 0) { var_c = var_c + ((returnData13.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value42 = var_c; } uint256 value43 = success13; if (success13) { uint256 value84 = !var_ao; if (var_ao != 0x0) { require(((0x20 + value42) + var_ao) - (0x20 + value42) >= 0x20); require(var_am == (var_am != 0x0)); value84 = var_ap; } value43 = value84; } require(value43 != 0x0, "TransferHelper: TRANSFER_FAILED"); var_c = var_c + 0x80; if (0x02 == 0) { uint256 value44; if (0xc != arg2) { uint256 value85 = 0; if (0xd == arg2) { value85 = (value28 - mapping_5[arg0]) / 0x02; } value44 = value85; } else { value44 = value28 - mapping_5[arg0]; } uint256 value48; if (0x0 != value44) { uint256 value45 = var_c.length; if (0x0 != value44) { var_a = var_a; (bool success14, bytes memory returnData14) = address(var_a).Unknown_4a275485(value44); // staticcall require(success14); var_c = var_c + ((returnData14.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData14.length) - var_c) < 0x20)); } else { value45 = 0; } uint256 value86; if (0x1e != arg1) { uint256 value46; uint256 value47; if (0x3c != arg1) { uint256 value87 = 0 * value45; uint256 value88 = 0; if (0x5a != arg1) { } else { value87 = 0x0a * value45; value88 = 0x0a; } value46 = value87; value47 = value88; } else { value46 = 0x14 * value45; value47 = 0x14; } value86 = value46 / 0x64; } else { value86 = (0x1e * value45) / 0x64; } value48 = value86; } else { value48 = 0; } var_a = var_a; (bool success15, bytes memory returnData15) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success15); var_c = var_c + ((returnData15.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData15.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value49 = var_c.length; if (0 != (value28 - mapping_5[arg0])) { var_a = var_a; (bool success16, bytes memory returnData16) = address(var_a).Unknown_e5028be6(value28 - mapping_5[arg0]); // staticcall require(success16); var_c = var_c + ((returnData16.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData16.length) - var_c) < 0x20)); } else { value49 = 0; } var_c = 0xc0 + var_c; if (!(0 < var_c.length)) _desolexPanic(50); uint256 value50; if (0xc != arg2) { uint256 value89 = 0; if (0xd == arg2) { value89 = stor_expr_ew / 0x02; } value50 = value89; } else { value50 = stor_expr_ew; } if (0x0 != value50) { uint256 value51 = var_c.length; if (0x0 != value50) { var_a = var_a; (bool success17, bytes memory returnData17) = address(var_a).Unknown_4a275485(value50); // staticcall require(success17); var_c = var_c + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData17.length) - var_c) < 0x20)); } else { value51 = 0; } if (0x1e != arg1) { uint256 value52; uint256 value53; if (0x3c != arg1) { uint256 value90 = 0 * value51; uint256 value91 = 0; if (0x5a != arg1) { } else { value90 = 0x0a * value51; value91 = 0x0a; } value52 = value90; value53 = value91; } else { value52 = 0x14 * value51; value53 = 0x14; } var_a = var_a; address(var_a).Unknown_2ae4fd34(); // staticcall } else { var_a = var_a; (bool success19, bytes memory returnData19) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success19); var_c = var_c + ((returnData19.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData19.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value54 = var_c.length; if (0 != mapping_5[arg0]) { var_a = var_a; (bool success20, bytes memory returnData20) = address(var_a).Unknown_e5028be6(mapping_5[arg0]); // staticcall require(success20); var_c = var_c + ((returnData20.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData20.length) - var_c) < 0x20)); } else { value54 = 0; } var_c = 0xc0 + var_c; if (!(0x01 < var_c.length)) _desolexPanic(50); var_a = var_a; (bool success21, bytes memory returnData21) = address(var_a).Unknown_885202c1(); // staticcall require(success21); var_c = var_c + ((returnData21.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData21.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = 0xc0 + var_c; if (!(0x02 < var_c.length)) _desolexPanic(50); uint256 value56 = 0; uint256 value57 = var_c + 0x20; uint256 value58 = var_c + 0x40; uint256 value59 = (var_c + (var_c.length << 0x05)) + 0x40; while (true) { mapping_5[arg0] = 0; stor_expr_ex = 0; mapping_7[arg0] = 0; stor_expr_ey = 0; if (!(value56 < var_c.length)) { break; } uint256 value34 = 0; while (true) { if (!(value34 < var_cc)) { break; } value34 = 0x20 + value34; value56 = 0x01 + value56; value57 = 0x20 + value57; value58 = 0x20 + value58; value59 = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_ca) + value59); } } return abi.encodePacked(0x20, var_c.length); } } else { var_a = var_a; (bool success22, bytes memory returnData22) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success22); var_c = var_c + ((returnData22.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData22.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); uint256 value61 = var_c.length; if (0 != mapping_5[arg0]) { var_a = var_a; (bool success23, bytes memory returnData23) = address(var_a).Unknown_e5028be6(mapping_5[arg0]); // staticcall require(success23); var_c = var_c + ((returnData23.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData23.length) - var_c) < 0x20)); } else { value61 = 0; } var_c = 0xc0 + var_c; if (!(0x01 < var_c.length)) _desolexPanic(50); var_a = var_a; (bool success24, bytes memory returnData24) = address(var_a).Unknown_885202c1(); // staticcall require(success24); var_c = var_c + ((returnData24.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData24.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = 0xc0 + var_c; if (!(0x02 < var_c.length)) _desolexPanic(50); uint256 value56 = 0; uint256 value57 = var_c + 0x20; uint256 value58 = var_c + 0x40; uint256 value59 = (var_c + (var_c.length << 0x05)) + 0x40; while (true) { mapping_5[arg0] = 0; stor_expr_ex = 0; mapping_7[arg0] = 0; stor_expr_ey = 0; if (!(value56 < var_c.length)) { break; } uint256 value34 = 0; while (true) { if (!(value34 < var_cc)) { break; } value34 = 0x20 + value34; value56 = 0x01 + value56; value57 = 0x20 + value57; value58 = 0x20 + value58; value59 = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_ca) + value59); } } return abi.encodePacked(0x20, var_c.length, var_c.length, (value59 - var_c) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0); } } } } } else { var_a = var_a; (bool success25, bytes memory returnData25) = address(var_a).Unknown_885202c1(); // staticcall require(success25); var_c = var_c + ((returnData25.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData25.length) - var_c >= 0x20); require(var_cj == (var_cj & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success26, bytes memory returnData26) = address(var_a).Unknown_ad8c4045(); // staticcall require(success26); var_c = var_c + ((returnData26.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData26.length) - var_c >= 0x20); require(var_q == (var_q & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = var_c + 0x64; uint256 value34 = 0; while (true) { uint256 value64 = value34; if (value34 >= var_x) { break; } if (0x20 + value34 >= var_x) { break; } value34 = 0x20 + (0x20 + value34); value64 = 0x20 + value34; } (bool success27, bytes memory returnData27) = address(var_r).adfepixw(); // call uint256 value65 = 0x60; if (returnData27.length != 0) { var_c = var_c + ((returnData27.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value65 = var_c; } uint256 value66 = success27; if (success27) { uint256 value92 = !var_cl; if (var_cl != 0x0) { require(((0x20 + value65) + var_cl) - (0x20 + value65) >= 0x20); require(var_ab == (var_ab != 0x0)); value92 = var_cm; } value66 = value92; } } } } function UPGRADE_INTERFACE_VERSION() public pure returns (bytes memory) { uint256 var_a; var_a = 0x40 + var_a; uint256 value0 = 0; while (true) { if (value0 >= var_a.length) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_a.length, var_g); } } function Unknown_adbfe300(bytes memory arg0, bytes memory arg1, bytes memory arg2, bytes memory arg3) 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(!((0x20 + ((0x04 + arg0) + (arg0.length << 0x05))) > msg.data.length)); uint256 value1 = var_a + 0x20; uint256 value0 = 0x20 + (0x04 + arg0); while (true) { if (!(value0 < (0x20 + ((0x04 + arg0) + (arg0.length << 0x05))))) { break; } require(msg.data[value0] == (address(msg.data[value0]))); value1 = 0x20 + value1; value0 = 0x20 + value0; } 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 value2 = (0x04 + arg1) + 0x20; uint256 value4 = var_a; uint256 value5 = var_a + 0x20; uint256 value6 = 0x20; uint256 value3 = ((0x04 + arg1) + (arg1.length << 0x05)) + 0x20; uint256 value7 = 0; uint256 value8 = 0x04 + arg1; uint256 value9 = msg.data.length; while (true) { if (value2 >= value3) { break; } value2 = value6 + value2; value4 = value4; value5 = value6 + value5; value6 = value6; value3 = value3; value7 = value7; value8 = value8; value9 = value9; 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 value2 = (0x04 + arg2) + 0x20; uint256 value4 = var_a; uint256 value5 = var_a + 0x20; uint256 value6 = 0x20; uint256 value3 = ((0x04 + arg2) + (arg2.length << 0x05)) + 0x20; uint256 value7 = 0; uint256 value8 = 0x04 + arg2; uint256 value9 = msg.data.length; while (true) { if (value2 >= value3) { break; } value2 = value6 + value2; value4 = value4; value5 = value6 + value5; value6 = value6; value3 = value3; value7 = value7; value8 = value8; value9 = value9; 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 value2 = (0x04 + arg3) + 0x20; uint256 value4 = var_a; uint256 value5 = var_a + 0x20; uint256 value6 = 0x20; uint256 value3 = ((0x04 + arg3) + (arg3.length << 0x05)) + 0x20; uint256 value7 = 0; uint256 value8 = 0x04 + arg3; uint256 value9 = msg.data.length; while (true) { if (value2 >= value3) { break; } value2 = value6 + value2; value4 = value4; value5 = value6 + value5; value6 = value6; value3 = value3; value7 = value7; value8 = value8; value9 = value9; var_g = var_g; var_g = msg.sender; require(bytes1(mapping_expr_ez[var_g][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); if (!(0 < array_2.length)) _desolexPanic(50); uint256 value10 = 0; while (true) { if (value10 >= var_i) { break; } if (!(value10 < var_j)) _desolexPanic(50); if (mapping_9[var_k] <= 0) { if (!(value10 < var_j)) _desolexPanic(50); mapping_9[var_k] = block.number; if (!(value10 < var_l)) _desolexPanic(50); if (!(value10 < var_m)) _desolexPanic(50); uint256 value16; if (0x1 != var_n) { uint256 value32 = var_o; if (0x3 == var_n) { if (!(value10 < var_i)) _desolexPanic(50); if (!(value10 < var_i)) _desolexPanic(50); if (!(value10 < var_l)) _desolexPanic(50); if (!(value10 < var_i)) _desolexPanic(50); stor_expr_fd = stor_expr_fd - (stor_expr_fd * ((var_o * 0x0de0b6b3a7640000) / stor_expr_fc) / 0x0de0b6b3a7640000); if (!(value10 < var_l)) _desolexPanic(50); if (!(value10 < var_i)) _desolexPanic(50); stor_expr_fc = stor_expr_fc - var_o; var_g = var_g; (bool success0, bytes memory returnData0) = address(var_g).Unknown_885202c1(); // staticcall require(success0); var_a = var_a + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData0.length) - var_a) < 0x20)); require(var_a.length == (var_a.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_g = var_g; (bool success1, bytes memory returnData1) = address(var_g).Unknown_ec2e2148(); // staticcall require(success1); var_a = var_a + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData1.length) - var_a) < 0x20)); require(var_a.length == (var_a.length & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(value10 < var_l)) _desolexPanic(50); var_a = var_a + 0x64; uint256 value12 = 0; while (true) { uint256 value13 = value12; if (value12 >= var_w) { break; } if (0x20 + value12 >= var_w) { break; } value12 = 0x20 + (0x20 + value12); value13 = 0x20 + value12; } (bool success2, bytes memory returnData2) = address(var_a.length).adfepixw(); // call uint256 value14 = 0x60; if (returnData2.length != 0) { var_a = var_a + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value14 = var_a; } uint256 value15 = success2; if (success2) { uint256 value33 = !var_ac; if (var_ac != 0x0) { require(((0x20 + value14) + var_ac) - (0x20 + value14) >= 0x20); require(var_ad == (var_ad != 0x0)); value33 = var_ae; } value15 = value33; } require(value15 != 0x0, "TransferHelper: TRANSFER_FAILED"); value32 = (stor_expr_fd * ((var_o * 0x0de0b6b3a7640000) / stor_expr_fc)) / 0x0de0b6b3a7640000; } value16 = value32; } else { if (!(value10 < var_i)) _desolexPanic(50); stor_expr_fe = stor_expr_fe - var_o; if (!(value10 < var_i)) _desolexPanic(50); if (!(value10 < var_i)) _desolexPanic(50); if (!(value10 < var_i)) _desolexPanic(50); stor_expr_ff = stor_expr_ff - (stor_expr_ff * ((var_o * 0x0de0b6b3a7640000) / stor_expr_fe) / 0x0de0b6b3a7640000); value16 = var_o; } if (!(value10 < var_m)) _desolexPanic(50); if ((0x1 == var_af) || (0x2 == var_af)) { var_g = var_g; (bool success3, bytes memory returnData3) = address(var_g).Unknown_2ae4fd34(); // staticcall require(success3); var_a = var_a + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData3.length) - var_a) < 0x20)); require(var_a.length == (var_a.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_g = var_g; (bool success4, bytes memory returnData4) = address(var_g).Unknown_ec2e2148(); // staticcall require(success4); var_a = var_a + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData4.length) - var_a) < 0x20)); require(var_a.length == (var_a.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a + 0x64; uint256 value12 = 0; while (true) { uint256 value18 = value12; if (value12 >= var_w) { break; } if (0x20 + value12 >= var_w) { break; } value12 = 0x20 + (0x20 + value12); value18 = 0x20 + value12; } (bool success5, bytes memory returnData5) = address(var_a.length).adfepixw(); // call uint256 value19 = 0x60; if (returnData5.length != 0) { var_a = var_a + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value19 = var_a; } uint256 value20 = success5; if (success5) { uint256 value34 = !var_ag; if (var_ag != 0x0) { require(((0x20 + value19) + var_ag) - (0x20 + value19) >= 0x20); require(var_ad == (var_ad != 0x0)); value34 = var_ah; } value20 = value34; } require(value20 != 0x0, "TransferHelper: TRANSFER_FAILED"); } if (!(value10 < var_i)) _desolexPanic(50); if (0 == mapping_expr_cc[address(var_p)]) { mapping_expr_cd[address(var_p)] = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); } uint256 value25; uint256 value26; uint256 value21 = 0; if (stor_expr_cf != 0) { if (!((stor_expr_cf - 0x01) < stor_expr_cf)) _desolexPanic(50); require(!(mapping_expr_ch[stor_expr_cg] < value16), "InsufficientQuota"); uint256 value35 = mapping_expr_fi[stor_expr_fj]; if (stor_expr_cg != (stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))) { stor_expr_cf = stor_expr_cf + 0x01; stor_expr_ck = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); mapping_expr_ch[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = mapping_expr_ch[stor_expr_cg] - value16; } else { mapping_expr_ch[stor_expr_cg] = mapping_expr_ch[stor_expr_cg] - value16; value35 = 0; } value21 = value35; } uint256 value22 = 0; if (stor_expr_cm != 0) { if (!((stor_expr_cm - 0x01) < stor_expr_cm)) _desolexPanic(50); require(!(mapping_expr_co[stor_expr_cn] < value16), "InsufficientQuota"); uint256 value36 = mapping_expr_cp[stor_expr_cq]; if (stor_expr_cn != (stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))) { stor_expr_cm = stor_expr_cm + 0x01; stor_expr_cr = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); mapping_expr_co[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = mapping_expr_co[stor_expr_cn] - value16; } else { mapping_expr_co[stor_expr_cn] = mapping_expr_co[stor_expr_cn] - value16; value36 = 0; } value22 = value36; } value25 = value22; value26 = value21; uint256 value27 = mapping_expr_dj[address(var_p)][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; if (value26 != 0x0) { value27 = (value26 * 0x05a0) + mapping_expr_dj[address(var_p)][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; } uint256 value28 = mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; if (value25 != 0x0) { value28 = (value25 * 0x05a0) + mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; } uint256 value29 = value28 - ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c); uint256 value30 = value27 - ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c); require(!(value27 < ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c)), "p_value_lock"); require(!(value28 < ((value16 * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c)), "n_value_lock"); mapping_expr_dj[address(var_p)][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = value30; mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = value29; uint256 value31 = stor_expr_fm - value16; require(!(stor_expr_fm < value16), "amount_lock"); stor_expr_fm = value31; unresolved_458b7f2d[(block.timestamp / 0x015180) * 0x015180] = value31; } value10 = 0x01 + value10; } } } } } function Unknown_af23c978(uint256 arg0, uint256 arg1) public returns (bytes memory) { require(arg0 < 0x5); internal_1f62(arg1, arg0); return abi.encodePacked(value15, value14, value13, lastStakeAmount[msg.sender]); } function Unknown_c7f855b9(address arg0, uint256 arg1) public payable { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_caa5412a(); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & value0), "not auth"); uint256 value1 = 0; uint256 value2 = 0; while (true) { if (!(value1 < array_2.length)) { break; } uint256 value17 = 0; if ((mapping_expr_fq[arg0] != 0x0) && (mapping_expr_fq[arg0] < ((block.timestamp / 0x015180) * 0x015180))) { bool flag1 = ((block.timestamp / 0x015180) * 0x015180) - 0x15180 >= mapping_expr_fp[arg0]; uint256 value7 = array_1[keccak256(abi.encode(value1, 0x03))]; uint256 value8 = ((block.timestamp / 0x015180) * 0x015180) - 0x015180; uint256 value9 = 0; while (true) { if (!(flag1 && value7 > 0x0)) { mapping_expr_fp[arg0] = (block.timestamp / 0x015180) * 0x015180; break; } uint256 value13 = mapping_expr_ft[arg0][value8]; if (0 == mapping_expr_ft[arg0][value8]) { if (stor_expr_au != 0x0) { if (!(0 < stor_expr_au)) _desolexPanic(50); } uint256 value12; if (!(stor_expr_au == 0x0 || __desolex_internal_4f03_4a7b_arg1 < stor_expr_av)) { bool flag4 = stor_expr_au > 0; uint256 value10 = 0; uint256 value11 = stor_expr_au; uint256 value18; while (true) { value18 = 0; if (!(flag4 && value10 < __desolex_internal_4f03_4a7b_arg0)) { break; } if (!((value11 - 0x01) < stor_expr_au)) _desolexPanic(50); if (__desolex_internal_4f03_4a7b_arg1 >= stor_expr_fu) { if (!((value11 - 0x01) < stor_expr_au)) _desolexPanic(50); break; } flag4 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value11) > 0; value10 = 0x01 + value10; value11 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value11; value18 = mapping_expr_fv[stor_expr_fw]; } value12 = value18; } else { value12 = 0; } value13 = value12 * 0x05a0; } uint256 value15 = mapping_expr_fx[value8]; if (0x0 == mapping_expr_fx[value8]) { if (stor_expr_bg != 0x0) { if (!(0 < stor_expr_bg)) _desolexPanic(50); } uint256 value14; if (!(stor_expr_bg == 0x0 || __desolex_internal_4f03_4ab8_arg1 < stor_expr_bh)) { bool flag4 = stor_expr_bg > 0; uint256 value10 = 0; uint256 value11 = stor_expr_bg; uint256 value19; while (true) { value19 = 0; if (!(flag4 && value10 < __desolex_internal_4f03_4ab8_arg0)) { break; } if (!((value11 - 0x01) < stor_expr_bg)) _desolexPanic(50); if (__desolex_internal_4f03_4ab8_arg1 >= stor_expr_fy) { if (!((value11 - 0x01) < stor_expr_bg)) _desolexPanic(50); break; } flag4 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value11) > 0; value10 = 0x01 + value10; value11 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value11; value19 = mapping_expr_fz[stor_expr_ga]; } value14 = value19; } else { value14 = 0; } value15 = value14 * 0x05a0; } uint256 value16 = value9; if ((value15 != 0x0) && (value13 <= value15)) { value16 = ((mapping_expr_gb[value8] * value13) / value15) + value9; } flag1 = !((value8 - 0x015180) < mapping_expr_fp[arg0]); value7 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value7; value8 = value8 - 0x015180; value9 = value16; } value17 = value9; } value1 = 0x01 + value1; value2 = value17 + value2; } require(value2 == arg1, "doDraw amount error"); if (!(value2 == 0x0)) { var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_01af8bac(); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData1.length) - var_c >= 0x20); require(var_f == (var_f & 0xffffffffffffffffffffffffffffffffffffffff)); var_c = var_c + 0x64; uint256 value4 = 0; while (true) { if (value4 >= __desolex_internal_562b_5ad2_arg2) { break; } value4 = 0x20 + value4; (bool success2, bytes memory returnData2) = address(var_c.length).adfepixw(); // call uint256 value5 = 0x60; if (returnData2.length != 0) { var_c = var_c + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value5 = var_c; } uint256 value6 = success2; if (success2) { uint256 value20 = !var_o; if (var_o != 0x0) { require(((0x20 + value5) + var_o) - (0x20 + value5) >= 0x20); require(__desolex_internal_5400_315f_arg0 == (__desolex_internal_5400_315f_arg0 != 0x0)); value20 = var_q; } value6 = value20; } require(value6 != 0x0, "TransferHelper: TRANSFER_FAILED"); } } } function Unknown_d2cf1ed5(uint256 arg0, uint256 arg1) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); if (arg1 != 0x0) { var_a = ((block.timestamp / 0x015180) * 0x015180) - (arg0 * 0x015180); mapping_expr_ds[((block.timestamp / 0x015180) * 0x015180) - (arg0 * 0x015180)] = arg1 + mapping_expr_ds[((block.timestamp / 0x015180) * 0x015180) - (arg0 * 0x015180)]; } } function revokeRole(bytes32 role, address account) public { var_a = var_a; var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); var_a = var_a; var_a = account; if (bytes1(hasRole[var_a][account])) { var_a = role; var_a = account; hasRole[role][account] = false; emit RoleRevoked(role, account, msg.sender); } } function Unknown_db94054d(address arg0, uint256 arg1) public { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_caa5412a(); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & value0), "not auth"); require(!(lastStakeAmount[arg0] != 0x0 && arg1 < lastStakeAmount[arg0]), "Less last amount"); lastStakeAmount[arg0] = arg1; } function Unknown_dd752e55() public { require(!((msg.data.length - 0x04) < 0x40)); require(msg.data[0x04] < 0x05); require(tx.origin == msg.sender, "not call"); if (!(0 < array_2.length)) _desolexPanic(50); uint256 var_b; var_b = 0x60 + (0x24 + var_b); uint256 value0 = 0; while (true) { if (value0 >= var_i) { break; } value0 = 0x20 + value0; (bool success0, bytes memory returnData0) = address(array_2[0]).pisnfmc(var_l, var_m, var_n); // call uint256 value1 = 0x60; if (returnData0.length != 0) { var_b = var_b + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_b; } uint256 value2 = success0; if (success0) { uint256 value15 = !var_o; if (var_o != 0x0) { require(((0x20 + value1) + var_o) - (0x20 + value1) >= 0x20); require(var_p == (var_p != 0x0)); value15 = var_q; } value2 = value15; } require(value2 != 0x0, "TransferHelper: TRANSFER_FROM_FAILED"); require(((msg.data[0x20 + 0x04]) > 0x0 && 0x0 < array_2.length), "params_error"); if (!(0 < array_2.length)) _desolexPanic(50); require(address(array_2[0]) != 0x0, "pledgeCoin error"); if (0 == mapping_expr_cc[msg.sender]) { mapping_expr_cd[msg.sender] = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); } uint256 value7; uint256 value8; uint256 value5; if (0x0 != stor_expr_ct) { if (!((stor_expr_ct - 0x01) < stor_expr_ct)) _desolexPanic(50); uint256 value18 = mapping_expr_ci[stor_expr_cv]; if (stor_expr_cw != __desolex_internal_4d39_452d_arg0) { stor_expr_ct = stor_expr_ct + 0x01; stor_expr_cx = __desolex_internal_4d39_452d_arg0; mapping_expr_cy[__desolex_internal_4d39_452d_arg0] = __desolex_internal_4d39_452d_arg1 + mapping_expr_cy[stor_expr_cw]; } else { mapping_expr_cy[stor_expr_cw] = __desolex_internal_4d39_452d_arg1 + mapping_expr_cy[stor_expr_cw]; value18 = 0; } value5 = value18; } else { stor_expr_ct = 0x01 + stor_expr_ct; stor_expr_da = __desolex_internal_4d39_452d_arg0; mapping_expr_cy[__desolex_internal_4d39_452d_arg0] = __desolex_internal_4d39_452d_arg1; value5 = 0; } uint256 value6; if (0x0 != stor_expr_db) { if (!((stor_expr_db - 0x01) < stor_expr_db)) _desolexPanic(50); uint256 value19 = mapping_expr_cp[stor_expr_dd]; if (stor_expr_de != __desolex_internal_4d39_453d_arg0) { stor_expr_db = stor_expr_db + 0x01; stor_expr_df = __desolex_internal_4d39_453d_arg0; mapping_expr_dg[__desolex_internal_4d39_453d_arg0] = __desolex_internal_4d39_453d_arg1 + mapping_expr_dg[stor_expr_de]; } else { mapping_expr_dg[stor_expr_de] = __desolex_internal_4d39_453d_arg1 + mapping_expr_dg[stor_expr_de]; value19 = 0; } value6 = value19; } else { stor_expr_db = 0x01 + stor_expr_db; stor_expr_di = __desolex_internal_4d39_453d_arg0; mapping_expr_dg[__desolex_internal_4d39_453d_arg0] = __desolex_internal_4d39_453d_arg1; value6 = 0; } value7 = value6; value8 = value5; uint256 value9 = mapping_expr_dj[msg.sender][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; if (value8 != 0x0) { value9 = (value8 * 0x05a0) + mapping_expr_dj[msg.sender][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; } uint256 value10 = mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; if (value7 != 0x0) { value10 = (value7 * 0x05a0) + mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)]; } uint256 value11 = value10 - ((msg.data[0x20 + 0x04]) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c)) / 0x3c); uint256 value12 = value9 - ((msg.data[0x20 + 0x04]) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c)) / 0x3c); value11 = ((msg.data[0x20 + 0x04]) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c)) / 0x3c) + value10; value12 = ((msg.data[0x20 + 0x04]) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c)) / 0x3c) + value9; mapping_expr_dj[msg.sender][stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = value12; mapping_expr_dk[stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)] = value11; uint256 value13 = array_1[0 + keccak256(abi.encode(0x02))] - (msg.data[0x20 + 0x04]); value13 = (msg.data[0x20 + 0x04]) + array_1[0 + keccak256(abi.encode(0x02))]; array_1[0 + keccak256(abi.encode(0x02))] = value13; unresolved_458b7f2d[(block.timestamp / 0x015180) * 0x015180] = value13; if (0x0 != (msg.data[0x20 + 0x04])) { var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_e5028be6(msg.data[0x20 + 0x04]); // staticcall require(success1); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData1.length) - var_b) < 0x20)); require(!(lastStakeAmount[msg.sender] != 0x0 && var_b.length < lastStakeAmount[msg.sender]), "Less last amount"); lastStakeAmount[msg.sender] = var_b.length; emit Event_3e451024(msg.sender, (msg.data[0x20 + 0x04]), lastStakeAmount[msg.sender], block.timestamp); var_b = 0x60 + var_b; uint256 value0 = 0; while (true) { uint256 value14 = value0; if (value0 >= var_z) { break; } if (0x20 + value0 >= var_z) { break; } value0 = 0x20 + (0x20 + value0); value14 = 0x20 + value0; } emit Event_b7e060da(msg.sender, 0x01, block.timestamp, 0x60, var_z, var_ab, var_ad); } require(!(lastStakeAmount[msg.sender] != 0x0 && (0) < lastStakeAmount[msg.sender]), "Less last amount"); lastStakeAmount[msg.sender] = 0; emit Event_3e451024(msg.sender, msg.data[0x20 + 0x04], lastStakeAmount[msg.sender], block.timestamp); var_b = 0x60 + var_b; uint256 value0 = 0; while (true) { if (value0 >= var_z) { break; } value0 = 0x20 + value0; emit Event_b7e060da(msg.sender, 0x01, block.timestamp, 0x60, var_z, var_ab, var_ab); } } } function Unknown_e5028be6(uint256 arg0) public returns (uint256) { if (0x0 == arg0) { return 0; } var_c = var_c; (bool success0, bytes memory returnData0) = address(var_c).Unknown_e5028be6(arg0); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0x20)); return var_d.length; } function Unknown_f71d1901(address arg0) public returns (bytes memory) { var_a = var_a; var_a = arg0; if (mapping_expr_t[arg0] != 0x0) { if (!((mapping_expr_t[arg0] - 0x01) < mapping_expr_t[arg0])) _desolexPanic(50); var_a = stor_expr_v; if (mapping_expr_z[stor_expr_v]) { if (0x0 != mapping_expr_z[stor_expr_v]) { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_e5028be6(mapping_expr_z[stor_expr_v]); // staticcall require(success0); uint256 var_e; var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData0.length) - var_e) < 0x20)); uint256 value1 = var_e.length; if (0x0 != mapping_expr_z[stor_expr_v]) { var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_4a275485(mapping_expr_z[stor_expr_v]); // staticcall require(success1); var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData1.length) - var_e) < 0x20)); } else { value1 = 0; } return abi.encodePacked(value1, var_e.length); } else { uint256 value2 = var_e.length; if (0x0 != mapping_expr_z[stor_expr_v]) { var_a = var_a; (bool success2, bytes memory returnData2) = address(var_a).Unknown_4a275485(mapping_expr_z[stor_expr_v]); // staticcall require(success2); var_e = var_e + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData2.length) - var_e) < 0x20)); } else { value2 = 0; } return abi.encodePacked(value2, 0); } } } else { } return abi.encodePacked(0, 0); } function internal_952(address arg0, uint256 arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); if (arg2 != address(0)) { internal_2721(arg1, arg0, arg2); return; } else { internal_265c(arg1, arg0); return; } } function internal_265c(uint256 arg0, address arg1) private { // Decompilation incomplete: helper effect provenance is conservative. var_f = var_f + 0x20; uint256 value0 = 0; while (true) { uint256 value4 = value0; if (value0 >= var_r) { break; } if (0x20 + value0 >= var_r) { break; } value0 = 0x20 + (0x20 + value0); value4 = 0x20 + value0; } (bool success0, bytes memory returnData0) = arg1.call{ value: arg0 }(""); // call uint256 value5 = 0x60; if (returnData0.length != 0) { var_f = var_f + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value5 = var_f; } require(success0, "TransferHelper: ETH_TRANSFER_FAILED"); } function internal_2721(uint256 arg0, address arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. uint256 var_f; var_f = var_f + 0x64; uint256 value0 = 0; while (true) { uint256 value1 = value0; if (value0 >= var_i) { break; } if (0x20 + value0 >= var_i) { break; } value0 = 0x20 + (0x20 + value0); value1 = 0x20 + value0; } (bool success0, bytes memory returnData0) = arg2.adfepixw(); // call uint256 value2 = 0x60; if (returnData0.length != 0) { var_f = var_f + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value2 = var_f; } uint256 value3 = success0; if (success0) { uint256 value6 = !var_o; if (var_o != 0x0) { require(((0x20 + value2) + var_o) - (0x20 + value2) >= 0x20); require(var_p == (var_p != 0x0)); value6 = var_q; } value3 = value6; } require(value3 != 0x0, "TransferHelper: TRANSFER_FAILED"); } function internal_d9f(address arg0) private { // Decompilation incomplete: helper effect provenance is conservative. var_a = var_a; var_a = arg0; uint256 value0 = mapping_expr_z[stor_expr_ac]; if (mapping_expr_t[arg0] != 0x0) { if (!((mapping_expr_t[arg0] - 0x01) < mapping_expr_t[arg0])) _desolexPanic(50); var_a = stor_expr_ac; } else { value0 = 0; } uint256 value3 = 0; uint256 value4 = 0; if (value0 != 0x0) { uint256 var_c; uint256 value1 = var_c.length; if (0x0 != value0) { var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_e5028be6(value0); // staticcall require(success0); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); } else { value1 = 0; } uint256 value2 = var_c.length; if (0x0 != value0) { var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_4a275485(value0); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData1.length) - var_c) < 0x20)); } else { value2 = 0; } value3 = value1; value4 = value2; } } function internal_eeb(uint256 arg0, uint256 arg1) private { // Decompilation incomplete: helper effect provenance is conservative. var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, AccessControlUnauthorizedAccount()); var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0x20)); require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_01af8bac(); // staticcall require(success1); var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData1.length) - var_d) < 0x20)); require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success2, bytes memory returnData2) = address(var_a).Unknown_6e315946(address(var_d.length), address(var_d.length), arg0 / 0x02); // staticcall require(success2); var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData2.length) - var_d) < 0x40)); require(((var_d.length - ((var_d.length * 0x0a) / 0x64)) > 0x0 && 0x0 < array_2.length), "params_error"); if (!(0 < array_2.length)) _desolexPanic(50); require(address(array_2[0]) != 0x0, "pledgeCoin error"); if (0 == mapping_expr_cc[arg1]) { mapping_expr_cd[arg1] = stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce); } uint256 value8; uint256 value9; uint256 value6; if (0x0 != stor_expr_ct) { if (!((stor_expr_ct - 0x01) < stor_expr_ct)) _desolexPanic(50); uint256 value18 = mapping_expr_ci[stor_expr_cv]; if (stor_expr_cw != __desolex_internal_4d39_452d_arg0) { stor_expr_ct = stor_expr_ct + 0x01; stor_expr_cx = __desolex_internal_4d39_452d_arg0; mapping_expr_cy[__desolex_internal_4d39_452d_arg0] = __desolex_internal_4d39_452d_arg1 + mapping_expr_cy[stor_expr_cw]; } else { mapping_expr_cy[stor_expr_cw] = __desolex_internal_4d39_452d_arg1 + mapping_expr_cy[stor_expr_cw]; value18 = 0; } value6 = value18; } else { stor_expr_ct = 0x01 + stor_expr_ct; stor_expr_da = __desolex_internal_4d39_452d_arg0; mapping_expr_cy[__desolex_internal_4d39_452d_arg0] = __desolex_internal_4d39_452d_arg1; value6 = 0; } uint256 value7; if (0x0 != stor_expr_db) { if (!((stor_expr_db - 0x01) < stor_expr_db)) _desolexPanic(50); uint256 value19 = mapping_expr_cp[stor_expr_dd]; if (stor_expr_de != __desolex_internal_4d39_453d_arg0) { stor_expr_db = stor_expr_db + 0x01; stor_expr_df = __desolex_internal_4d39_453d_arg0; mapping_expr_dg[__desolex_internal_4d39_453d_arg0] = __desolex_internal_4d39_453d_arg1 + mapping_expr_dg[stor_expr_de]; } else { mapping_expr_dg[stor_expr_de] = __desolex_internal_4d39_453d_arg1 + mapping_expr_dg[stor_expr_de]; value19 = 0; } value7 = value19; } else { stor_expr_db = 0x01 + stor_expr_db; stor_expr_di = __desolex_internal_4d39_453d_arg0; mapping_expr_dg[__desolex_internal_4d39_453d_arg0] = __desolex_internal_4d39_453d_arg1; value7 = 0; } value8 = value7; value9 = value6; uint256 value10 = mapping_expr_dj[arg1][(stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))]; if (value9 != 0x0) { value10 = (value9 * 0x05a0) + mapping_expr_dj[arg1][(stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))]; } uint256 value11 = mapping_expr_dk[(stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))]; if (value8 != 0x0) { value11 = (value8 * 0x05a0) + mapping_expr_dk[(stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))]; } uint256 value12 = value11 - (((var_d.length - ((var_d.length * 0x0a) / 0x64)) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c); uint256 value13 = value10 - (((var_d.length - ((var_d.length * 0x0a) / 0x64)) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c); value12 = (((var_d.length - ((var_d.length * 0x0a) / 0x64)) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c) + value11; value13 = (((var_d.length - ((var_d.length * 0x0a) / 0x64)) * (((stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce)) + 0x015180) - ((block.timestamp / 0x3c) * 0x3c))) / 0x3c) + value10; mapping_expr_dj[arg1][(stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))] = value13; mapping_expr_dk[(stor_expr_ce * (((block.timestamp / 0x3c) * 0x3c) / stor_expr_ce))] = value12; uint256 value14 = array_1[(0 + keccak256(abi.encode(0x02)))] - (var_d.length - ((var_d.length * 0x0a) / 0x64)); value14 = (var_d.length - ((var_d.length * 0x0a) / 0x64)) + array_1[(0 + keccak256(abi.encode(0x02)))]; array_1[(0 + keccak256(abi.encode(0x02)))] = value14; unresolved_458b7f2d[((block.timestamp / 0x015180) * 0x015180)] = value14; emit Event_3e451024(arg1, var_d.length - ((var_d.length * 0x0a) / 0x64), ((((arg0 / 0x02) * 0x02) * 0x5f)) / 0x64, block.timestamp); var_d = 0x60 + var_d; uint256 value15 = 0; while (true) { if (value15 >= var_r) { break; } value15 = 0x20 + value15; emit Event_b7e060da(arg1, 0x01, block.timestamp, 0x60, var_r, var_t); } } function internal_1f62(uint256 arg0, uint256 arg1) private { // Decompilation incomplete: helper effect provenance is conservative. if (!(arg1 <= 0x4)) _desolexPanic(33); uint256 value13; uint256 value14 = var_c.length - ((var_c.length * 0x0a) / 0x64); uint256 value15; uint256 value16 = arg0; if (arg1 != 0x2) { uint256 value8 = internal_3c5a(arg0, arg1); if (!(arg1 <= 0x4)) _desolexPanic(33); uint256 value10; if (arg1 != 0x3) { uint256 value17 = 0; if (arg1 == 0x1) { value17 = arg0 / 0x02; } value10 = value17; } else { value10 = value8; } var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_2ae4fd34(); // staticcall require(success0); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_27a6cf96(); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData1.length) - var_c) < 0x20)); require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success2, bytes memory returnData2) = address(var_a).Unknown_6e315946(address(var_c.length), address(var_c.length), value10); // staticcall require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData2.length) - var_c) < 0x40)); value13 = (((value8 * 0x02) * 0x5f)) / 0x64; value15 = value8; } else { var_a = var_a; (bool success3, bytes memory returnData3) = address(var_a).Unknown_5fbeac7a((arg0 - (((arg0 * 0x05) / 0x64)))); // staticcall require(success3); var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData3.length) - var_c) < 0x60)); value13 = var_f; value14 = 0; value15 = var_c.length; value16 = (arg0 - (((arg0 * 0x05) / 0x64))); } } function internal_3c5a(uint256 arg0, uint256 arg1) private returns (uint256) { // Decompilation incomplete: helper effect provenance is conservative. if (!(arg1 <= 0x4)) _desolexPanic(33); if (arg1 != 0x3) { var_f = msg.data[4:68]; var_a = var_a; (bool success0, bytes memory returnData0) = address(var_a).Unknown_27a6cf96(); // staticcall require(success0); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData0.length) - var_c >= 0x20); require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(0 < var_c.length)) _desolexPanic(50); var_a = var_a; (bool success1, bytes memory returnData1) = address(var_a).Unknown_01af8bac(); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData1.length) - var_c >= 0x20); require(var_k == (var_k & 0xffffffffffffffffffffffffffffffffffffffff)); if (!(0x01 < var_c.length)) _desolexPanic(50); var_a = var_a; uint256 value2 = 0; uint256 value3 = var_c + 0x20; uint256 value4 = (0x04 + var_c) + 0x60; while (true) { if (!(value2 < var_p)) { break; } value2 = 0x01 + value2; value3 = 0x20 + value3; value4 = 0x20 + value4; } (bool success2, bytes memory returnData2) = address(var_a).Unknown_faeba675(0x40, ((arg0 / 0x02))); // staticcall require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData2.length) - var_c >= 0x20); return var_d; } else { var_a = var_a; (bool success3, bytes memory returnData3) = address(var_a).viewPrices(); // staticcall require(success3); var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData3.length) - var_c >= 0xa0); return ((var_z * arg0) / ((var_aa))); } } 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. // 0x01ffc9a7 => supportsInterface(bytes4) // 0x141de56b => takeOutToken(address,uint256,address) // 0x1ec1d4cf => Unknown_1ec1d4cf(address,uint256,bool) // 0x21f801ff => unresolved_21f801ff() // 0x241da314 => _staticRate() // 0x24337b6e => Unknown_24337b6e(uint256,uint256,uint256) // 0x248a9ca3 => getRoleAdmin(bytes32) // 0x2f2ff15d => grantRole(bytes32,address) // 0x2f97d107 => Unknown_2f97d107() // 0x36568abe => renounceRole(bytes32,address) // 0x38aea994 => Unknown_38aea994(address,uint256,uint256) // 0x39cb81b8 => unresolved_39cb81b8() // 0x4030ea8a => userLpInfo(address) // 0x4211606a => Unknown_4211606a(uint256) // 0x458b7f2d => unresolved_458b7f2d(bytes32) // 0x4a275485 => Unknown_4a275485(uint256) // 0x4f1ef286 => upgradeToAndCall(address,bytes) // 0x52d1902d => proxiableUUID() // 0x658eacb4 => mGetMinedEveryDay(uint256) // 0x65b83e5a => mineToken() // 0x6944e6fd => Unknown_6944e6fd(address,uint256) // 0x6ed90738 => pledgeInfos(uint256) // 0x8129fc1c => initialize() // 0x83c76dee => Unknown_83c76dee(uint256) // 0x91d14854 => hasRole(bytes32,address) // 0x981e8626 => Unknown_981e8626(bytes32) // 0x9f4d1f53 => unresolved_9f4d1f53() // 0xa217fddf => DEFAULT_ADMIN_ROLE() // 0xa4d19feb => CONFIG_ROLE() // 0xacbd3da7 => Unknown_acbd3da7(address,uint256,uint256) // 0xad3cb1cc => UPGRADE_INTERFACE_VERSION() // 0xadbfe300 => Unknown_adbfe300(bytes,bytes,bytes,bytes) // 0xaf23c978 => Unknown_af23c978(uint256,uint256) // 0xc4b2237f => lastStakeAmount(address) // 0xc7f855b9 => Unknown_c7f855b9(address,uint256) // 0xd2cf1ed5 => Unknown_d2cf1ed5(uint256,uint256) // 0xd547741f => revokeRole(bytes32,address) // 0xdb94054d => Unknown_db94054d(address,uint256) // 0xdd752e55 => Unknown_dd752e55() // 0xe0d496b3 => unresolved_e0d496b3() // 0xe5028be6 => Unknown_e5028be6(uint256) // 0xf71d1901 => Unknown_f71d1901(address) // 0xf72c0d8b => UPGRADER_ROLE()}