BNB Chain
0x25785eabb54b413eb9544689bab1682b2165faf1
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x25785eab…2165faf123.2 KB35.1 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x25785eabb54b413eb9544689bab1682b2165faf1
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
interface IDesolexERC20 {
function balanceOf(address account) external view returns (uint256 balance);
}
contract DesolexContract {
uint256 public constant BPS = 10000;
address public constant usdt = address(0x55d398326f99059ff775485246999027b3197955);
uint256 public constant PERIODS = 30;
uint256 public constant MAX_DEPTH = 30;
address public constant router = address(0x10ed43c718714eb63d5aa57b78b54704e256024e);
address public owner; // STORAGE[0x0] bytes 0 to 19
bool public paused; // STORAGE[0x0] bytes 20 to 20
address public alita; // STORAGE[0x1]
address public pair; // STORAGE[0x2]
uint256[] array_3; // STORAGE[0x3]
address public referralRegistry; // STORAGE[0x3]
address public nodeContract; // STORAGE[0x4]
address public ecosystemWallet; // STORAGE[0x5]
address public burnExecutor; // STORAGE[0x6]
address stor_7; // STORAGE[0x7]
uint256 public minimumAmount; // STORAGE[0x8]
uint256 public unresolved_2d5c3eb4; // STORAGE[0x9]
uint16 stor_a; // STORAGE[0xa]
uint256[5] public unresolved_df8c90d6; // STORAGE[0xb]
uint256[6] public unresolved_5e9a2975; // STORAGE[0x10]
uint256[6] public levelTeamThresholds; // STORAGE[0x16]
uint256 stor_1c; // STORAGE[0x1c]
bytes32 stor_1d; // STORAGE[0x1d] // DESOLEX_RAW_STORAGE: whole slot: uint16 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous)
mapping(address => uint256) mapping_1e; // STORAGE[0x1e]
mapping(address => bool) public blacklist; // STORAGE[0x1f]
mapping(address => bool) mapping_20; // STORAGE[0x20]
address[] array_21; // STORAGE[0x21]
mapping(address => uint256) mapping_22; // STORAGE[0x22]
uint256 public releaseOrderCount; // STORAGE[0x23]
mapping(address => uint256) mapping_24; // STORAGE[0x24]
uint256 public lastBurnDay; // STORAGE[0x25]
bytes32 stor_26; // STORAGE[0x26]
uint256 stor_expr_aa;
uint256 stor_expr_ab;
uint256 stor_expr_ad;
uint256 stor_expr_ae;
uint256 stor_expr_af;
uint256 stor_expr_ag;
uint256 stor_expr_am;
uint256 stor_expr_ap;
uint256 stor_expr_ar;
uint256 stor_expr_at;
uint256 stor_expr_au;
uint256 stor_expr_av;
uint256 stor_expr_ax;
uint256 stor_expr_ay;
uint256 stor_expr_az;
uint256 stor_expr_bb;
bytes32 stor_expr_bc;
bytes32 stor_expr_bd;
uint256 stor_expr_be;
bytes32 stor_expr_bg;
uint256 stor_expr_bi;
uint256 stor_expr_bk;
uint256 stor_expr_bm;
uint256 stor_expr_bn;
uint256 stor_expr_bo;
bytes32 stor_expr_bp;
uint256 stor_expr_bs;
uint256 stor_expr_bu;
bytes32 stor_expr_ce;
bytes32 stor_expr_cf;
bytes32 stor_expr_cg;
bytes32 stor_expr_ck;
uint256 stor_expr_cm;
uint256 stor_expr_co;
uint256 stor_expr_cp;
uint256 stor_expr_cq;
uint256 stor_expr_cr;
uint256 stor_expr_cs;
uint256 stor_expr_cu;
uint256 stor_expr_cw;
uint256 stor_expr_cx;
uint256 stor_expr_cy;
uint256 stor_expr_cz;
bytes32 stor_expr_d;
uint256 stor_expr_da;
uint256 stor_expr_db;
uint256 stor_expr_de;
uint256 stor_expr_dl;
uint256 stor_expr_dm;
uint256 stor_expr_dn;
uint256 stor_expr_dx;
uint256 stor_expr_e;
uint256 stor_expr_ea;
bytes32 stor_expr_ef;
uint256 stor_expr_ei;
bytes32 stor_expr_ej; // DESOLEX_RAW_STORAGE: whole slot: uint256 [ArithmeticUse] vs uint64 [ArithmeticUse] (ambiguous)
uint256 stor_expr_ek;
uint256 stor_expr_el;
uint256 stor_expr_em;
bool stor_expr_es_0_0;
bytes32 stor_expr_et;
bytes32 stor_expr_eu;
uint256 stor_expr_ew;
uint256 stor_expr_ez;
uint256 stor_expr_fa;
uint256 stor_expr_fb;
uint256 stor_expr_fh;
bytes32 stor_expr_fl;
bytes32 stor_expr_fm;
bytes32 stor_expr_fo;
uint256 stor_expr_fq;
address stor_expr_fs;
bytes32 stor_expr_ft; // DESOLEX_RAW_STORAGE: whole slot: uint256 [ArithmeticUse] vs uint64 [ArithmeticUse] (ambiguous)
uint256 stor_expr_fu;
uint256 stor_expr_fv;
uint256 stor_expr_fy;
uint256 stor_expr_t;
uint256 stor_expr_y;
error NotNode();
event Unpaused(address);
error ReferrerRequired();
error EnforcedPause();
event Event_c74e3ea5(uint256 indexed, uint256, uint256, uint256, uint256, uint256, uint256);
error SafeERC20FailedOperation(address);
error InvalidOrder();
error AmountTooSmall(uint256, uint256);
event AddressChanged(bytes32 indexed, address, address);
event ParameterChanged(bytes32 indexed, uint256, uint256);
error CustomError_e383ec87();
error NotOrderOwner();
event Paused(address);
error OwnableInvalidOwner(address);
event Event_6c514923(uint256 indexed, uint256, uint256, uint256);
error NodeCreationNotClosed();
event ERC20Recovered(address indexed, address indexed, uint256);
event LiquidityAdded(uint256, uint256, uint256);
event Event_83e81161(uint256 indexed, uint256 indexed, uint256, uint256);
event SellQuotaAdded(address indexed, uint256 indexed, bytes32);
error CustomError_6815150b();
error CustomError_2817cac6();
error InvalidParameter();
error AlreadySynced();
error AlreadyBurnedToday();
error ZeroAddress();
event Event_b54e1490(uint256 indexed, uint256);
event Event_e3ce05ac(uint256 indexed, address indexed, uint256);
error DependenciesNotConfigured();
event Event_995ce922();
error CustomError_2429c617();
error CustomError_f2564510();
error OnlyEOA();
error Blacklisted(address);
error InvalidPair();
error CustomError_889085ac();
error NotOperator();
error ReentrancyGuardReentrantCall();
event BlacklistUpdated(address indexed, bool);
error OwnableUnauthorizedAccount(address);
error ExpectedPause();
event Event_9ac1da82(uint256 indexed, uint256, uint256, uint256);
event OwnershipTransferred(address indexed, address indexed);
function _desolexPanic(uint256 code) private pure {
assembly ("memory-safe") {
mstore(0x00, shl(224, 0x4e487b71))
mstore(0x04, code)
revert(0x00, 0x24)
}
}
modifier onlyOwner() {
require(msg.sender == owner, OwnableUnauthorizedAccount());
_;
}
fallback() external {
// Synthetic compatibility routes preserve original selectors for unresolved names.
if ((msg.data.length >= 4) && (msg.sig == 0x045f4a6e)) {
// Route to Unknown_045f4a6e() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x0d95f57a));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x1109a836)) {
// Route to Unknown_1109a836(address) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x4d38288f));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x11abb038)) {
// Route to Unknown_11abb038(uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xb0703c6a));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x1789d235)) {
// Route to Unknown_1789d235(address) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xaf013e75));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x1b007283)) {
// Route to Unknown_1b007283() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xdc680bab));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x1f258e0e)) {
// Route to Unknown_1f258e0e(address,uint256,uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xa6b4984a));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x2155e468)) {
// Route to Unknown_2155e468() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x94cc929e));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x23d90078)) {
// Route to Unknown_23d90078() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x4ca83fc0));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x24b97601)) {
// Route to Unknown_24b97601() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xb48e3013));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x38289e9f)) {
// Route to Unknown_38289e9f(uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xec8aea40));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x3f4b7440)) {
// Route to Unknown_3f4b7440() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xe6f78b6c));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x5a193ca7)) {
// Route to Unknown_5a193ca7() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x6a382019));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x65c6dba8)) {
// Route to Unknown_65c6dba8() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x6ee562ba));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x6f76ffdf)) {
// Route to Unknown_6f76ffdf() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x64a334d7));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x705420be)) {
// Route to Unknown_705420be(address,uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x0c0d5653));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x735e0223)) {
// Route to Unknown_735e0223(address) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x9e7efd0a));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x7abb9a7b)) {
// Route to Unknown_7abb9a7b() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x41e4843a));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x7b0f72dc)) {
// Route to Unknown_7b0f72dc() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x9233d519));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x874e0fc6)) {
// Route to Unknown_874e0fc6(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xe9fd0881));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x91e482aa)) {
// Route to Unknown_91e482aa() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xb9cc480f));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x92c3e01d)) {
// Route to Unknown_92c3e01d() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x95286e80));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x94aa610d)) {
// Route to Unknown_94aa610d(bool) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x6e3d2ee7));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x9caa58b7)) {
// Route to Unknown_9caa58b7(address) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x196bb030));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x9ef8ba94)) {
// Route to Unknown_9ef8ba94() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x2e65ac91));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xabc9e946)) {
// Route to Unknown_abc9e946(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x5ed02c99));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xb2a77fed)) {
// Route to Unknown_b2a77fed(address,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x9deb9c8d));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xb58eda6d)) {
// Route to Unknown_b58eda6d() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x94b3de1b));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xd3fa06dd)) {
// Route to Unknown_d3fa06dd() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x3db947f8));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xd966a184)) {
// Route to Unknown_d966a184(uint16,uint16,uint16,uint16) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x89d0859c));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xe0017ec9)) {
// Route to Unknown_e0017ec9() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x4e87f8a0));
return;
}
revert();
}
function Unknown_045f4a6e() public view returns (uint16) {
return uint16(stor_a / 0x01000000000000);
}
function reinvestAll() public {
require(!(tx.origin != msg.sender || msg.sender.code.length != 0x0), OnlyEOA());
require(!blacklist[msg.sender], Blacklisted());
require(!paused, EnforcedPause());
require(0x2 != stor_expr_d, ReentrancyGuardReentrantCall());
stor_expr_d = 0x02;
require(0x0 != stor_expr_e, CustomError_2817cac6());
bool flag1 = !(alita);
if (alita) {
flag1 = !(pair);
}
bool flag2 = flag1;
if (!(flag1)) {
flag2 = !(referralRegistry);
}
bool flag3 = flag2;
if (!(flag2)) {
flag3 = !(nodeContract);
}
require(!(flag3 || (0xffffffffffffffffffffffffffffffffffffffff & ecosystemWallet) == 0x0), DependenciesNotConfigured());
(bool success0, bytes memory returnData0) = nodeContract.nodeCreationClosed(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
require(var_e == (var_e != 0x0));
require(var_f != 0x0, NodeCreationNotClosed());
require(!(stor_expr_e < minimumAmount), AmountTooSmall());
(bool success1, bytes memory returnData1) = address(referralRegistry / 0x01).rootAccount(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff));
bool flag5 = !(msg.sender == (address(var_f)));
if (!(msg.sender == (address(var_f)))) {
(bool success2, bytes memory returnData2) = referralRegistry.hasReferrer(msg.sender); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
require(var_k == (var_k != 0x0));
flag5 = !(var_f);
}
require(!flag5, ReferrerRequired());
(bool success3, bytes memory returnData3) = referralRegistry.getUpwardReferrers(msg.sender, 0x1e); // staticcall
require(success3);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData3.length + 0x1f));
require(!(((var_d + returnData3.length) - var_d) < 0x20));
require(!(var_d.length > 0xffffffffffffffff));
require((var_d + returnData3.length) > ((var_d + var_d.length) + 0x1f));
if (!(var_m <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_m << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_m << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_m << 0x05)) + 0x1f));
require(!(((var_d + var_d.length) + (var_o << 0x05) + 0x20) > (var_d + returnData3.length)));
if (!(((var_d + var_d.length) + 0x20) < ((var_d + var_d.length) + (var_o << 0x05) + 0x20))) {
stor_expr_e = 0;
uint256 value2 = 0x01f4;
if (nodeContract) {
(bool success4, bytes memory returnData4) = nodeContract.marsDividendBps(); // staticcall
require(success4);
var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData4.length) - var_d >= 0x20);
require(var_q == (var_q & 0xffff));
(bool success5, bytes memory returnData5) = address(nodeContract / 0x01).starDividendBps(); // staticcall
require(success5);
var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData5.length) - var_d >= 0x20);
require(var_s == (var_s & 0xffff));
value2 = (uint16(var_d.length)) + (uint16(var_d.length));
}
require((value2 + (uint16(stor_1d / 0x0100000000) + (uint16(stor_a / 0x0100000000) + ((uint16(stor_a / 0x01000000000000) * 0x0a) + (uint16(stor_a / 0x01000000000000000000) + (uint16(stor_a / 0x010000) + (uint16(stor_a)))))))) == 0x2710, InvalidParameter());
uint256 value5;
uint256 value9;
if (bytes1(stor_a / 0x010000000000000000) != 0x0) {
uint256 value33 = (uint16(stor_a / 0x01000000000000000000) * stor_expr_e) / 0x2710;
if (0 < var_t) {
bool flag6 = !(blacklist[address(var_u)]);
if (!blacklist[address(var_u)]) {
flag6 = !(stor_expr_t + mapping_1e[address(var_u)] < unresolved_2d5c3eb4);
}
if (flag6) {
uint256 value3;
if (!blacklist[address(var_u)]) {
uint256 value34 = 0;
if (!(0x6 - 0x1 < 0x6)) _desolexPanic(50);
if (!(stor_expr_y + mapping_1e[address(var_u)] < stor_expr_aa)) {
if (!(0x6 - 0x1 < 0x6)) _desolexPanic(50);
}
if (!(stor_expr_ab + mapping_1e[var_u & 0xffffffffffffffffffffffffffffffffffffffff] >= stor_expr_ad && stor_expr_ae + stor_expr_af >= stor_expr_ag)) {
}
value34 = 0x06;
value3 = value34;
} else {
value3 = 0;
}
}
if ((flag6) && ((0xff & value3) >= 0x3)) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success6, bytes memory returnData6) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value4 = success6;
if (!(success6 & (var_a == 0x01))) {
require(!((!success6) & (0x01)));
value4 = success6 & ((!returnData6.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value4 != 0x0, SafeERC20FailedOperation());
emit Event_995ce922(msg.sender, address(var_u), 0x5a1bd94dd2746836dcc8b25d604c6ef6ceeba9f0320309c26869df2c2ac60d9a, (uint16(stor_a / 0x01000000000000000000) * stor_expr_e) / 0x2710);
}
value33 = 0;
}
value5 = value33;
} else {
value5 = (uint16(stor_a / 0x01000000000000000000) * stor_expr_e) / 0x2710;
}
(bool success7, bytes memory returnData7) = alita.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success7);
var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData7.length) - var_d >= 0x20);
var_d = var_d + 0x60;
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
if (0 < var_ah) {
}
(bool success8, bytes memory returnData8) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739((((uint16(stor_a / 0x01000000000000) * stor_expr_e) * 0x0a) / 0x2710), 0, 0xa0, address(this), block.timestamp, var_ah); // call
require(success8);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData8.length + 0x1f));
require((var_d + returnData8.length) - var_d >= 0x20);
require(!(var_am > 0xffffffffffffffff));
require((var_d + returnData8.length) > ((var_d + var_am) + 0x1f));
if (!(var_bj <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f));
require(!(((var_d + var_am) + (var_ap << 0x05) + 0x20) > (var_d + returnData8.length)));
if (((var_d + var_am) + 0x20) < ((var_d + var_am) + (var_ap << 0x05) + 0x20)) {
}
uint256 value6 = IDesolexERC20(alita).balanceOf(address(this));
uint256 value7 = var_as;
if (var_as >= 0x0a) {
value7 = 0x0a;
}
if (0x0 >= value7) {
if (((value6 - var_d.length) % 0x0a) + (((value6 - var_d.length) / 0x0a) * (0x0a - value7)) + 0) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success10, bytes memory returnData10) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value8 = success10;
if (!(success10 & (var_a == 0x01))) {
require(!((!success10) & (0x01)));
value8 = success10 & ((!returnData10.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value8 != 0x0, SafeERC20FailedOperation());
}
} else {
if (!(0 < var_as)) _desolexPanic(50);
}
if (0 >= var_at) {
value9 = 0;
if (0 < (uint16(stor_1d / 0x0100000000))) {
value9 = ((uint16(stor_1d / 0x0100000000) - 0) * stor_expr_e) / 0x2710;
}
} else {
bool flag9 = !(blacklist[address(var_au)]);
if (!blacklist[address(var_au)]) {
flag9 = !(stor_expr_am + mapping_1e[address(var_au)] < unresolved_2d5c3eb4);
}
uint256 value10;
if (flag9) {
uint256 value58;
if (!blacklist[address(var_au)]) {
uint256 value59 = 0;
if (!(0x6 - 0x1 < 0x6)) _desolexPanic(50);
if (!(stor_expr_ap + mapping_1e[address(var_au)] < stor_expr_aa)) {
if (!(0x6 - 0x1 < 0x6)) _desolexPanic(50);
}
if (!(stor_expr_ar + mapping_1e[var_au & 0xffffffffffffffffffffffffffffffffffffffff] >= stor_expr_ad && stor_expr_at + stor_expr_au >= stor_expr_ag)) {
}
value59 = 0x06;
value58 = value59;
} else {
value58 = 0;
}
value10 = value58;
} else {
value10 = 0;
}
if ((0x0 == 0x0) && (flag9)) {
stor_expr_av = stor_expr_e + stor_expr_av;
}
uint256 value16 = 0;
uint256 value17 = 0;
uint256 value18 = 0;
if (bytes1(value10)) {
uint256 value12;
uint256 value13 = 0;
uint256 value14;
if (!(0x6 == (0xff & value10) && (stor_1c / 0x100000000000000000000 & 0xffff) == 0x0)) {
if (!((0xff & (0xff & value10) - (0xff & 0x1)) < 0x6)) _desolexPanic(50);
uint256 value61 = 0;
uint256 value63 = 0;
if (uint16(stor_expr_ax / (0x0100 ** (0x02 * (bytes1(bytes1(value10) - (bytes1(0x01))) % 0x10)))) > 0) {
value61 = (uint16(stor_expr_ax / (0x0100 ** (0x02 * (bytes1(bytes1(value10) - (bytes1(0x01))) % 0x10))))) - (uint16(0));
value63 = uint16(stor_expr_ax / (0x0100 ** (0x02 * (bytes1(bytes1(value10) - (bytes1(0x01))) % 0x10))));
}
value12 = value61;
value14 = value63;
} else {
uint256 value11;
value11 = uint16(stor_1d);
uint256 value62 = 0;
if (uint16(value11)) {
value62 = 0x01 + (bytes1(0));
}
value12 = value11;
value13 = value62;
value14 = 0;
}
uint256 value60 = 0;
if (uint16(value12)) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success11, bytes memory returnData11) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value15 = success11;
if (!(success11 & (var_a == 0x01))) {
require(!((!success11) & (0x01)));
value15 = success11 & ((!returnData11.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
var_d = var_d;
require(value15 != 0x0, SafeERC20FailedOperation());
emit Event_995ce922(msg.sender, address(var_au), 0x9b82d2f38fbdf13006bfa741767f793d917e063392737837b580c1c2b1e0bab3, (uint16(value12) * stor_expr_e) / 0x2710);
value60 = (uint16(value12)) + 0;
}
value16 = value60;
value17 = value13;
value18 = value14;
}
stor_expr_ay = stor_expr_e + stor_expr_ay;
uint256 value19 = 0;
if ((0x0 < 0x12) && ((0xff & value10) >= (0xff & 0x0 / 0x3 + 0x1))) {
value19 = (uint16(stor_a / 0x010000000000000000000000000000000000) * stor_expr_e) / 0x2710;
}
uint256 value20 = 0;
if ((0x0 == 0x0) && (flag9)) {
value20 = (uint16(stor_a / 0x01000000000000000000000000000000) * stor_expr_e) / 0x2710;
}
if (value20 + value19 != 0x0) {
stor_expr_az = (value20 + value19) + stor_expr_az;
uint256 value22 = 0x20 + var_d;
uint256 value23 = 0x953623aa7bdf52bec63f63ebe0516703b6b65bba1da3817ca47136f1c111703d;
if ((value20 != 0x0) && (value19 != 0x0)) {
} else {
uint256 value21 = 0xfb59ab348c9b985b58c338de98118b538ac0cdc9cce2ca7e05e581e6ccfda190;
if (0x0 == value20) {
value21 = 0x9b82d2f38fbdf13006bfa741767f793d917e063392737837b580c1c2b1e0bab3;
}
value22 = 0x20 + var_d;
value23 = value21;
}
emit SellQuotaAdded(address(var_au), value23, value20 + value19);
}
}
if (!(value9 + (0x0 + (value5 + 0x0)) == 0x0)) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success12, bytes memory returnData12) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value24 = success12;
if (!(success12 & (var_a == 0x01))) {
require(!((!success12) & (0x01)));
value24 = success12 & ((!returnData12.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value24 != 0x0, SafeERC20FailedOperation());
}
require(nodeContract.code.length != 0x0);
(bool success13, bytes memory returnData13) = nodeContract.reportInvestmentDividend(stor_expr_e); // call
require(success13);
require(nodeContract.code.length != 0x0);
(bool success14, bytes memory returnData14) = nodeContract.reportPerformance(msg.sender, stor_expr_e); // call
require(success14);
var_d = var_d + 0x60;
var_z = msg.data[4:68];
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
if (0 < var_ah) {
if (__desolex_internal_55d2_5b66_arg0 < __desolex_internal_55d2_5b66_arg2) {
}
(bool success15, bytes memory returnData15) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739(((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02), 0, 0xa0, address(this), block.timestamp); // call
require(success15);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData15.length + 0x1f));
require((var_d + returnData15.length) - var_d >= 0x20);
require(!(var_bh > 0xffffffffffffffff));
require((var_d + returnData15.length) > ((var_d + var_bh) + 0x1f));
if (!(var_bj <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f));
require(!(((var_d + var_bh) + (var_bk << 0x05) + 0x20) > (var_d + returnData15.length)));
if (((var_d + var_bh) + 0x20) < ((var_d + var_bh) + (var_bk << 0x05) + 0x20)) {
if ((0x20 + ((var_d + var_bh) + 0x20)) < ((var_d + var_bh) + (var_bk << 0x05) + 0x20)) {
}
if (!((var_d.length - 0x01) < var_d.length)) _desolexPanic(50);
(bool success16, bytes memory returnData16) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).addLiquidity(alita, 0x55d398326f99059ff775485246999027b3197955, var_bp, (uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) - ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02), 0, 0, address(this), block.timestamp); // call
require(success16);
var_d = var_d + ((returnData16.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData16.length) - var_d >= 0x60);
if (var_bp > var_d.length) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success17, bytes memory returnData17) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value25 = success17;
if (!(success17 & (var_a == 0x01))) {
require(!((!success17) & (0x01)));
value25 = success17 & ((!returnData17.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value25 != 0x0, SafeERC20FailedOperation());
}
if ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) - ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02) > var_z) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success18, bytes memory returnData18) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value26 = success18;
if (!(success18 & (var_a == 0x01))) {
require(!((!success18) & (0x01)));
value26 = success18 & ((!returnData18.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
var_d = var_d;
require(value26 != 0x0, SafeERC20FailedOperation());
}
emit LiquidityAdded(var_z, var_d.length, (var_bv));
var_d = var_d + 0xa0;
releaseOrderCount = 0x01 + releaseOrderCount;
stor_expr_bb = (stor_expr_bb & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address(var_d.length));
stor_expr_bc = var_by;
stor_expr_bd = var_bu;
stor_expr_be = (uint64(var_bz) | (stor_expr_be & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000))) | (0x010000000000000000 * (bytes1(var_ca)));
mapping_24[__desolex_internal_45c8_36d5_arg1] = mapping_24[__desolex_internal_45c8_36d5_arg1] + 0x01;
stor_expr_bg = releaseOrderCount;
mapping_1e[__desolex_internal_46cc_36e2_arg2] = __desolex_internal_46cc_36e2_arg1 + mapping_1e[__desolex_internal_46cc_36e2_arg2];
uint256 value27 = uint16(stor_a / 0x0100000000000000000000000000);
if (!(__desolex_internal_46cc_36e2_arg0)) {
value27 = uint16(stor_a / 0x010000000000000000000000);
}
stor_expr_bi = ((uint16(value27) * __desolex_internal_46cc_36e2_arg1) / 0x2710) + stor_expr_bi;
uint256 value28 = 0x8cc7f5766c4573e2b29e190c38422cc377e339dac18080957f72fdb7ae4b8ef1;
if (!(__desolex_internal_46cc_36e2_arg0)) {
value28 = 0x604e75f88ca32c2324ef833b47da7e68928c891abee9c9be1c69109a56776a47;
}
emit SellQuotaAdded(__desolex_internal_46cc_36e2_arg2, value28, (uint16(value27) * __desolex_internal_46cc_36e2_arg1) / 0x2710);
emit Event_83e81161(msg.sender, releaseOrderCount, stor_expr_e, 0x01);
stor_expr_d = 0x01;
}
if (!((var_d.length - 0x01) < var_d.length)) _desolexPanic(50);
(bool success19, bytes memory returnData19) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).addLiquidity(alita, 0x55d398326f99059ff775485246999027b3197955, var_bp, (uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) - ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02), 0, 0, address(this), block.timestamp); // call
require(success19);
var_d = var_d + ((returnData19.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData19.length) - var_d >= 0x60);
if (var_bp > var_d.length) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success20, bytes memory returnData20) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value29 = success20;
if (!(success20 & (var_a == 0x01))) {
require(!((!success20) & (0x01)));
value29 = success20 & ((!returnData20.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value29 != 0x0, SafeERC20FailedOperation());
}
if ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) - ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02) > var_z) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success21, bytes memory returnData21) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value9 + (0 + (value5 + 0)))); // call
uint256 value30 = success21;
if (!(success21 & (var_a == 0x01))) {
require(!((!success21) & (0x01)));
value30 = success21 & ((!returnData21.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
var_d = var_d;
require(value30 != 0x0, SafeERC20FailedOperation());
}
emit LiquidityAdded(var_z, var_d.length, (var_bv));
var_d = var_d + 0xa0;
releaseOrderCount = 0x01 + releaseOrderCount;
stor_expr_bb = (stor_expr_bb & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address(var_d.length));
stor_expr_bc = var_by;
stor_expr_bd = var_bu;
stor_expr_be = (uint64(var_bz) | (stor_expr_be & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000))) | (0x010000000000000000 * (bytes1(var_ca)));
mapping_24[__desolex_internal_45c8_36d5_arg1] = mapping_24[__desolex_internal_45c8_36d5_arg1] + 0x01;
stor_expr_bg = releaseOrderCount;
mapping_1e[__desolex_internal_46cc_36e2_arg2] = __desolex_internal_46cc_36e2_arg1 + mapping_1e[__desolex_internal_46cc_36e2_arg2];
uint256 value31 = uint16(stor_a / 0x0100000000000000000000000000);
if (!(__desolex_internal_46cc_36e2_arg0)) {
value31 = uint16(stor_a / 0x010000000000000000000000);
}
stor_expr_bi = ((uint16(value31) * __desolex_internal_46cc_36e2_arg1) / 0x2710) + stor_expr_bi;
uint256 value32 = 0x8cc7f5766c4573e2b29e190c38422cc377e339dac18080957f72fdb7ae4b8ef1;
if (!(__desolex_internal_46cc_36e2_arg0)) {
value32 = 0x604e75f88ca32c2324ef833b47da7e68928c891abee9c9be1c69109a56776a47;
}
emit SellQuotaAdded(__desolex_internal_46cc_36e2_arg2, value32, (uint16(value31) * __desolex_internal_46cc_36e2_arg1) / 0x2710);
emit Event_83e81161(msg.sender, releaseOrderCount, stor_expr_e, 0x01);
stor_expr_d = 0x01;
}
(bool success22, bytes memory returnData22) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739(((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02), 0, 0xa0, address(this), block.timestamp, var_ah); // call
require(success22);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData22.length + 0x1f));
require((var_d + returnData22.length) - var_d >= 0x20);
require(!(var_bh > 0xffffffffffffffff));
require((var_d + returnData22.length) > ((var_d + var_bh) + 0x1f));
if (!(var_bj <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bj << 0x05)) + 0x1f));
require(!(((var_d + var_bh) + (var_bk << 0x05) + 0x20) > (var_d + returnData22.length)));
if (((var_d + var_bh) + 0x20) < ((var_d + var_bh) + (var_bk << 0x05) + 0x20)) {
if (!((0x20 + ((var_d + var_bh) + 0x20)) >= ((var_d + var_bh) + (var_bk << 0x05) + 0x20))) {
}
if (!((var_d.length - 0x01) < var_d.length)) _desolexPanic(50);
(bool success23, bytes memory returnData23) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).addLiquidity(alita, 0x55d398326f99059ff775485246999027b3197955, var_bp, (uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) - ((uint16(stor_a / 0x010000) * stor_expr_e / 0x2710) / 0x02), 0, 0, address(this), block.timestamp); // call
require(success23);
var_d = var_d + ((returnData23.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
}
} else {
require(var_cd == (var_cd & 0xffffffffffffffffffffffffffffffffffffffff));
}
}
function Unknown_1109a836(address arg0) public view returns (bytes memory) {
internal_f31(arg0);
return abi.encodePacked(value2, value1);
}
function recoverERC20(address token, address recipient, uint256 amount) public {
require(mapping_20[msg.sender], NotOperator());
require(token != address(0), ZeroAddress());
require(recipient != address(0), ZeroAddress());
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success0, bytes memory returnData0) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, amount)); // call transfer
uint256 value0 = success0;
if (!(success0 & (var_a == 0x01))) {
require(!((!success0) & (0x01)));
value0 = success0 & ((!returnData0.length) & (address(token).code.length > 0));
}
require(value0 != 0x0, SafeERC20FailedOperation());
emit ERC20Recovered(token, recipient, amount);
}
function Unknown_11abb038(uint256 arg0, uint256 arg1) public view returns (bytes memory) {
uint256 value6 = var_a;
if (!(arg0 >= releaseOrderCount || arg1 == 0x0)) {
uint256 value0;
uint256 value4;
if ((arg1 + arg0) > releaseOrderCount) {
uint256 value10 = (arg1 + arg0) - arg0;
uint256 value12 = arg1 + arg0;
value10 = releaseOrderCount - arg0;
value12 = releaseOrderCount;
value0 = value10;
value4 = value12;
} else {
uint256 value11 = (arg1 + arg0) - arg0;
uint256 value13 = arg1 + arg0;
if (arg1 + arg0 >= arg0) {
} else {
value11 = releaseOrderCount - arg0;
value13 = releaseOrderCount;
}
value0 = value11;
value4 = value13;
}
if (!(value0 <= 0xffffffffffffffff)) _desolexPanic(65);
uint256 value3 = value0;
if (value0 != 0x0) {
var_a = var_a + 0xa0;
uint256 value2 = 0x20 + (0x20 + var_a);
uint256 value1 = value0 - 0x01;
while (true) {
if (value1 == 0) {
break;
}
var_a = var_a + 0xa0;
value2 = 0x20 + value2;
value1 = value1 - 0x01;
}
value3 = value2;
}
uint256 value5 = 0;
while (true) {
if (value5 >= value0) {
break;
}
if (!((value5 + arg0) < releaseOrderCount)) _desolexPanic(50);
var_a = var_a + 0xa0;
if (!(value5 < var_a.length)) _desolexPanic(50);
value5 = 0x01 + value5;
}
} else {
var_a = var_a + 0x20;
value6 = var_a;
}
uint256 value7 = 0;
uint256 value8 = value6 + 0x20;
uint256 value9 = (var_a + 0x20) + 0x20;
while (true) {
if (!(value7 < var_n)) {
break;
}
value7 = 0x01 + value7;
value8 = 0x20 + value8;
value9 = 0xa0 + value9;
}
return abi.encodePacked(0x20, var_n);
}
function setBlacklist(address account, bool enabled) public {
require(mapping_20[msg.sender], NotOperator());
require(account != address(0), ZeroAddress());
blacklist[account] = enabled;
emit BlacklistUpdated(account, blacklist[account]);
}
function Unknown_1789d235(address arg0) public view returns (bytes memory) {
address var_c;
var_c = 0x20 + (var_c + (0x20 * mapping_24[arg0]));
uint256 value2 = mapping_24[arg0];
uint256 value3 = keccak256(abi.encode(arg0, 0x24));
uint256 value4 = var_c + 0x20;
if (mapping_24[arg0] != 0) {
uint256 value0 = 0x20 + (var_c + 0x20);
uint256 value1 = 0x01 + (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x24)))));
while (true) {
if ((var_c + 0x20) + (0x20 * mapping_24[arg0]) <= value0) {
break;
}
value0 = 0x20 + value0;
value1 = 0x01 + value1;
}
value2 = value0;
value3 = value1;
value4 = (var_c + 0x20) + (0x20 * mapping_24[arg0]);
}
uint256 value5 = 0;
uint256 value6 = var_c + 0x20;
uint256 value7 = (var_c + 0x20) + 0x20;
while (true) {
if (!(value5 < var_c.length)) {
break;
}
value5 = 0x01 + value5;
value6 = value6 + 0x20;
value7 = 0x20 + value7;
}
return abi.encodePacked(0x20, var_c.length);
}
function Unknown_1b007283() public view returns (bool) {
return !(!(bytes1(stor_a / 0x010000000000000000)));
}
function Unknown_1f258e0e(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public {
require(mapping_20[msg.sender], NotOperator());
require(arg0 != address(0), ZeroAddress());
bool flag0 = arg1 == 0x0;
if (arg1 == 0) {
flag0 = arg3 == 0x0;
}
require(!(flag0 && arg2 == 0x0), InvalidParameter());
stor_expr_ce = arg1;
emit Event_c74e3ea5(arg0, stor_expr_ce, arg1, stor_expr_cf, arg3, stor_expr_cg, arg2);
stor_expr_cf = arg3;
stor_expr_cg = arg2;
}
function Unknown_2155e468() public view returns (uint16) {
return uint16(stor_1d / 0x010000);
}
function Unknown_23d90078() public view returns (uint16) {
return uint16(stor_1d / 0x0100000000);
}
function Unknown_24b97601() public view returns (uint16) {
return uint16(stor_a / 0x010000000000000000000000000000000000);
}
function getOperators() public view onlyOwner returns (bytes memory) {
uint256 var_a;
var_a = var_a + (0x20 + (0x20 * array_21.length));
uint256 value2 = array_21.length;
uint256 value3 = 0x21;
uint256 value4 = 0x20 + var_a;
if (array_21.length != 0x0) {
uint256 value0 = 0x20 + (0x20 + var_a);
uint256 value1 = keccak256(abi.encode(0x21)) + 0x01;
while (true) {
if ((0x20 + var_a) + (0x20 * array_21.length) <= value0) {
break;
}
value0 = 0x20 + value0;
value1 = value1 + 0x01;
}
value2 = value0;
value3 = value1;
value4 = (0x20 + var_a) + (0x20 * array_21.length);
}
uint256 value5 = 0;
uint256 value6 = var_a + 0x20;
uint256 value7 = (var_a + 0x20) + 0x20;
while (true) {
if (!(value5 < var_a.length)) {
break;
}
value5 = 0x01 + value5;
value6 = value6 + 0x20;
value7 = 0x20 + value7;
}
return abi.encodePacked(0x20, var_a.length);
}
function invest(uint256 amount) public {
require(!(tx.origin != msg.sender || msg.sender.code.length != 0x0), OnlyEOA());
require(!blacklist[msg.sender], Blacklisted());
require(!paused, EnforcedPause());
require(0x2 != stor_expr_d, ReentrancyGuardReentrantCall());
stor_expr_d = 0x02;
bool flag1 = !(alita);
if (alita) {
flag1 = !(pair);
}
bool flag2 = flag1;
if (!(flag1)) {
flag2 = !(referralRegistry);
}
bool flag3 = flag2;
if (!(flag2)) {
flag3 = !(nodeContract);
}
require(!(flag3 || (0xffffffffffffffffffffffffffffffffffffffff & ecosystemWallet) == 0x0), DependenciesNotConfigured());
(bool success0, bytes memory returnData0) = nodeContract.nodeCreationClosed(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
require(var_e == (var_e != 0x0));
require(var_f != 0x0, NodeCreationNotClosed());
require(!(amount < minimumAmount), AmountTooSmall());
(bool success1, bytes memory returnData1) = address(referralRegistry / 0x01).rootAccount(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff));
bool flag5 = !(msg.sender == (address(var_f)));
if (!(msg.sender == (address(var_f)))) {
(bool success2, bytes memory returnData2) = referralRegistry.hasReferrer(msg.sender); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
require(var_k == (var_k != 0x0));
flag5 = !(var_f);
}
require(!flag5, ReferrerRequired());
(bool success3, bytes memory returnData3) = nodeContract.isNode(msg.sender); // staticcall
require(success3);
var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData3.length) - var_d >= 0x20);
require(var_l == (var_l != 0x0));
uint256 value2 = var_f;
if (var_f != 0x0) {
value2 = !(bytes1(stor_expr_ck));
}
require(value2 == 0x0, CustomError_f2564510());
(bool success4, bytes memory returnData4) = referralRegistry.getUpwardReferrers(msg.sender, 0x1e); // staticcall
require(success4);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData4.length + 0x1f));
require(!(((var_d + returnData4.length) - var_d) < 0x20));
require(!(var_d.length > 0xffffffffffffffff));
require((var_d + returnData4.length) > ((var_d + var_d.length) + 0x1f));
if (!(var_p <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_p << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_p << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_p << 0x05)) + 0x1f));
require(!(((var_d + var_d.length) + (var_r << 0x05) + 0x20) > (var_d + returnData4.length)));
uint256 value5 = var_d;
uint256 value6 = var_d + 0x20;
uint256 value4 = ((var_d + var_d.length) + (var_r << 0x05)) + 0x20;
uint256 value3 = (var_d + var_d.length) + 0x20;
uint256 value7 = 0;
uint256 value8 = var_d;
uint256 value9 = var_d + returnData4.length;
while (true) {
if (value3 >= value4) {
break;
}
require(var_s == (var_s & 0xffffffffffffffffffffffffffffffffffffffff));
value5 = value5;
value6 = value6 + 0x20;
value4 = value4;
value3 = 0x20 + value3;
value7 = value7;
value8 = value8;
value9 = value9;
var_a = 0x23b872dd00000000000000000000000000000000000000000000000000000000;
(bool success5, bytes memory returnData5) = address(0x55d398326f99059ff775485246999027b3197955).transferFrom(msg.sender, address(this), amount); // call
uint256 value10 = success5;
if (!(success5 & (var_a == 0x01))) {
require(!((!success5) & (0x01)));
value10 = success5 & ((!returnData5.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value10 != 0x0, SafeERC20FailedOperation());
uint256 value11 = 0x01f4;
if (nodeContract) {
(bool success6, bytes memory returnData6) = nodeContract.marsDividendBps(); // staticcall
require(success6);
var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData6.length) - var_d >= 0x20);
require(var_y == (var_y & 0xffff));
(bool success7, bytes memory returnData7) = address(nodeContract / 0x01).starDividendBps(); // staticcall
require(success7);
var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData7.length) - var_d >= 0x20);
require(var_aa == (var_aa & 0xffff));
value11 = (uint16(var_d.length)) + (uint16(var_d.length));
}
require((value11 + (uint16(stor_1d / 0x0100000000) + (uint16(stor_a / 0x0100000000) + ((uint16(stor_a / 0x01000000000000) * 0x0a) + (uint16(stor_a / 0x01000000000000000000) + (uint16(stor_a / 0x010000) + (uint16(stor_a)))))))) == 0x2710, InvalidParameter());
uint256 value25;
uint256 value13;
uint256 value26 = value13;
uint256 value22;
uint256 value27 = value22;
uint256 value23;
uint256 value28 = value23;
if (bytes1(stor_a / 0x010000000000000000) != 0x0) {
uint256 value12 = 0;
uint256 value14 = (uint16(stor_a / 0x01000000000000000000) * amount) / 0x2710;
uint256 value15 = 0;
value13 = value5;
value22 = amount;
value23 = msg.sender;
uint256 value73;
while (true) {
value73 = value14;
if (value12 >= var_ab) {
break;
}
bool flag6 = !(blacklist[address(var_ac)]);
if (!blacklist[address(var_ac)]) {
flag6 = !(stor_expr_cm + mapping_1e[address(var_ac)] < unresolved_2d5c3eb4);
}
if (flag6) {
uint256 value21;
if (!blacklist[address(var_ac)]) {
uint256 value16 = 0x06;
uint256 value17 = stor_expr_co + stor_expr_cp;
uint256 value18 = stor_expr_y + mapping_1e[address(var_ac)];
uint256 value19 = 0;
uint256 value20 = var_ac;
uint256 value74;
while (true) {
value74 = 0;
if (value16 == 0x0) {
break;
}
if (!(value16 - 0x1 < 0x6)) _desolexPanic(50);
if (!(value18 < stor_expr_cq)) {
if (!(value16 - 0x1 < 0x6)) _desolexPanic(50);
}
if ((value18 >= stor_expr_cr) && (value17 >= stor_expr_cs)) {
break;
}
value16 = __desolex_internal_1818_49c0_arg0;
value17 = __desolex_internal_1818_49c0_arg1;
value18 = __desolex_internal_1818_49c0_arg2;
value19 = __desolex_internal_1818_49c0_arg3;
value20 = __desolex_internal_1818_49c0_arg4;
value74 = value16;
}
value21 = value74;
} else {
value21 = 0;
}
}
uint256 value49;
if ((flag6) && ((0xff & value21) >= 0x3)) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success8, bytes memory returnData8) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value24 = success8;
if (!(success8 & (var_a == 0x01))) {
require(!((!success8) & (0x01)));
value24 = success8 & ((!returnData8.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value24 != 0x0, SafeERC20FailedOperation());
emit Event_995ce922(address(value23), address(var_ac), 0x5a1bd94dd2746836dcc8b25d604c6ef6ceeba9f0320309c26869df2c2ac60d9a, value14);
break;
}
value12 = 0x01 + value12;
value14 = value14;
value15 = value15;
value13 = value13;
value22 = value22;
value23 = value23;
value73 = 0;
}
value25 = value73;
} else {
value25 = (uint16(stor_a / 0x01000000000000000000) * amount) / 0x2710;
value26 = value5;
value27 = amount;
value28 = msg.sender;
}
(bool success9, bytes memory returnData9) = alita.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success9);
var_d = var_d + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData9.length) - var_d >= 0x20);
var_d = var_d + 0x60;
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
uint256 value29 = 0;
uint256 value31 = var_d + 0x20;
uint256 value30 = var_am;
uint256 value32 = 0;
uint256 value33 = var_d;
uint256 value34 = ((0x04 + var_d) + 0xa0) + 0x20;
while (true) {
if (value29 >= value30) {
break;
}
value29 = __desolex_internal_55d2_5b66_arg0;
value31 = __desolex_internal_55d2_5b66_arg1;
value30 = __desolex_internal_55d2_5b66_arg2;
value32 = __desolex_internal_55d2_5b66_arg3;
value33 = __desolex_internal_55d2_5b66_arg4;
value34 = __desolex_internal_55d2_5b66_arg5;
(bool success10, bytes memory returnData10) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739((((uint16(stor_a / 0x01000000000000) * amount) * 0x0a) / 0x2710), 0, 0xa0, address(this), block.timestamp, var_am); // call
require(success10);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData10.length + 0x1f));
require((var_d + returnData10.length) - var_d >= 0x20);
require(!(var_as > 0xffffffffffffffff));
require((var_d + returnData10.length) > ((var_d + var_as) + 0x1f));
if (!(var_bp <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f));
require(!(((var_d + var_as) + (var_av << 0x05) + 0x20) > (var_d + returnData10.length)));
uint256 value37 = var_d;
uint256 value38 = var_d + 0x20;
uint256 value36 = ((var_d + var_as) + (var_av << 0x05)) + 0x20;
uint256 value35 = (var_d + var_as) + 0x20;
uint256 value39 = 0;
uint256 value40 = var_d;
uint256 value41 = var_d + returnData10.length;
while (true) {
if (value35 >= value36) {
break;
}
value37 = __desolex_internal_5bee_4c89_arg0;
value38 = __desolex_internal_5bee_4c89_arg1;
value36 = __desolex_internal_5bee_4c89_arg2;
value35 = __desolex_internal_5bee_4c89_arg3;
value39 = __desolex_internal_5bee_4c89_arg4;
value40 = __desolex_internal_5bee_4c89_arg5;
value41 = __desolex_internal_5bee_4c89_arg6;
uint256 value42 = IDesolexERC20(alita).balanceOf(address(this));
uint256 value43 = var_ay;
if (var_ay >= 0x0a) {
value43 = 0x0a;
}
if (0x0 >= value43) {
if (((value42 - var_d.length) % 0x0a) + (((value42 - var_d.length) / 0x0a) * (0x0a - value43)) + 0) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success12, bytes memory returnData12) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value44 = success12;
if (!(success12 & (var_a == 0x01))) {
require(!((!success12) & (0x01)));
value44 = success12 & ((!returnData12.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value44 != 0x0, SafeERC20FailedOperation());
}
} else {
if (!(0 < var_ay)) _desolexPanic(50);
}
uint256 value45 = 0;
uint256 value46 = 0;
uint256 value47 = 0;
uint256 value48 = 0;
while (true) {
if (value45 >= var_az) {
break;
}
bool flag9 = !(blacklist[address(var_ba)]);
if (!blacklist[address(var_ba)]) {
flag9 = !(stor_expr_cu + mapping_1e[address(var_ba)] < unresolved_2d5c3eb4);
}
uint256 value50;
if (flag9) {
uint256 value75;
if (!blacklist[address(var_ba)]) {
uint256 value16 = 0x06;
uint256 value17 = stor_expr_cw + stor_expr_cx;
uint256 value18 = stor_expr_ap + mapping_1e[address(var_ba)];
uint256 value19 = 0;
uint256 value20 = var_ba;
uint256 value76;
while (true) {
value76 = 0;
if (value16 == 0x0) {
break;
}
if (!(value16 - 0x1 < 0x6)) _desolexPanic(50);
if (!(value18 < stor_expr_cq)) {
if (!(value16 - 0x1 < 0x6)) _desolexPanic(50);
}
if ((value18 >= stor_expr_cr) && (value17 >= stor_expr_cs)) {
break;
}
value16 = __desolex_internal_1818_4f47_arg0;
value17 = __desolex_internal_1818_4f47_arg1;
value18 = __desolex_internal_1818_4f47_arg2;
value19 = __desolex_internal_1818_4f47_arg3;
value20 = __desolex_internal_1818_4f47_arg4;
value76 = value16;
}
value75 = value76;
} else {
value75 = 0;
}
value50 = value75;
} else {
value50 = 0;
}
if ((value45 == 0x0) && (flag9)) {
stor_expr_cy = amount + stor_expr_cy;
}
uint256 value56 = value46;
uint256 value57 = value47;
uint256 value58 = value48;
if (bytes1(value50)) {
uint256 value52;
uint256 value53 = value47;
uint256 value54;
if (!(0x6 == (0xff & value50) && (stor_1c / 0x100000000000000000000 & 0xffff) == (0xffff & value48))) {
if (!((0xff & (0xff & value50) - (0xff & 0x1)) < 0x6)) _desolexPanic(50);
uint256 value78 = 0;
uint256 value80 = value48;
if (uint16(stor_expr_cz / (0x0100 ** (0x02 * (bytes1(bytes1(value50) - (bytes1(0x01))) % 0x10)))) > (uint16(value48))) {
value78 = (uint16(stor_expr_cz / (0x0100 ** (0x02 * (bytes1(bytes1(value50) - (bytes1(0x01))) % 0x10))))) - (uint16(value48));
value80 = uint16(stor_expr_cz / (0x0100 ** (0x02 * (bytes1(bytes1(value50) - (bytes1(0x01))) % 0x10))));
}
value52 = value78;
value54 = value80;
} else {
uint256 value51;
if (0x0 != (0xff & value47)) {
uint256 value81 = 0;
if (0x1 == (0xff & value47)) {
value81 = uint16(stor_1d / 0x010000);
}
value51 = value81;
} else {
value51 = uint16(stor_1d);
}
uint256 value79 = value47;
if (uint16(value51)) {
value79 = 0x01 + (bytes1(value47));
}
value52 = value51;
value53 = value79;
value54 = value48;
}
uint256 value77 = value46;
if (uint16(value52)) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success13, bytes memory returnData13) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value55 = success13;
if (!(success13 & (var_a == 0x01))) {
require(!((!success13) & (0x01)));
value55 = success13 & ((!returnData13.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
var_d = var_d;
require(value55 != 0x0, SafeERC20FailedOperation());
emit Event_995ce922(msg.sender, address(var_ba), 0x9b82d2f38fbdf13006bfa741767f793d917e063392737837b580c1c2b1e0bab3, (uint16(value52) * amount) / 0x2710);
value77 = (uint16(value52)) + value46;
}
value56 = value77;
value57 = value53;
value58 = value54;
}
stor_expr_da = amount + stor_expr_da;
if (value45 < 0x12) {
}
uint256 value59 = 0;
if ((value45 < 0x12) && ((0xff & value50) >= (0xff & value45 / 0x3 + 0x1))) {
value59 = (uint16(stor_a / 0x010000000000000000000000000000000000) * amount) / 0x2710;
}
uint256 value60 = 0;
if ((value45 == 0x0) && (flag9)) {
value60 = (uint16(stor_a / 0x01000000000000000000000000000000) * amount) / 0x2710;
}
if (value60 + value59 != 0x0) {
stor_expr_db = (value60 + value59) + stor_expr_db;
uint256 value62 = 0x20 + var_d;
uint256 value63 = 0x953623aa7bdf52bec63f63ebe0516703b6b65bba1da3817ca47136f1c111703d;
if ((value60 != 0x0) && (value59 != 0x0)) {
} else {
uint256 value61 = 0xfb59ab348c9b985b58c338de98118b538ac0cdc9cce2ca7e05e581e6ccfda190;
if (0x0 == value60) {
value61 = 0x9b82d2f38fbdf13006bfa741767f793d917e063392737837b580c1c2b1e0bab3;
}
value62 = 0x20 + var_d;
value63 = value61;
}
emit SellQuotaAdded(address(var_ba), value63, value60 + value59);
}
value45 = 0x01 + value45;
value46 = value56;
value47 = value57;
value48 = value58;
if (!(value49 + (0x0 + (value25 + 0x0)) == 0x0)) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success14, bytes memory returnData14) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value64 = success14;
if (!(success14 & (var_a == 0x01))) {
require(!((!success14) & (0x01)));
value64 = success14 & ((!returnData14.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value64 != 0x0, SafeERC20FailedOperation());
}
require(nodeContract.code.length != 0x0);
(bool success15, bytes memory returnData15) = nodeContract.reportInvestmentDividend(amount); // call
require(success15);
require(nodeContract.code.length != 0x0);
(bool success16, bytes memory returnData16) = nodeContract.reportPerformance(msg.sender, amount); // call
require(success16);
var_d = var_d + 0x60;
var_af = msg.data[4:68];
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
uint256 value29 = 0;
uint256 value31 = var_d + 0x20;
uint256 value30 = var_am;
uint256 value32 = 0;
uint256 value33 = var_d;
uint256 value34 = ((0x04 + var_d) + 0xa0) + 0x20;
while (true) {
if (value29 >= value30) {
break;
}
if (__desolex_internal_55d2_5b66_arg0 >= __desolex_internal_55d2_5b66_arg2) {
break;
}
value29 = __desolex_internal_55d2_5b66_arg0;
value31 = __desolex_internal_55d2_5b66_arg1;
value30 = __desolex_internal_55d2_5b66_arg2;
value32 = __desolex_internal_55d2_5b66_arg3;
value33 = __desolex_internal_55d2_5b66_arg4;
value34 = __desolex_internal_55d2_5b66_arg5;
(bool success17, bytes memory returnData17) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739((((uint16(stor_a / 0x010000) * amount) / 0x2710) / 0x02), 0, 0xa0, address(this), block.timestamp); // call
require(success17);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData17.length + 0x1f));
require((var_d + returnData17.length) - var_d >= 0x20);
require(!(var_bn > 0xffffffffffffffff));
require((var_d + returnData17.length) > ((var_d + var_bn) + 0x1f));
if (!(var_bp <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_bp << 0x05)) + 0x1f));
require(!(((var_d + var_bn) + (var_bq << 0x05) + 0x20) > (var_d + returnData17.length)));
uint256 value37 = var_d;
uint256 value38 = var_d + 0x20;
uint256 value36 = ((var_d + var_bn) + (var_bq << 0x05)) + 0x20;
uint256 value35 = (var_d + var_bn) + 0x20;
uint256 value39 = 0;
uint256 value40 = var_d;
uint256 value41 = var_d + returnData17.length;
while (true) {
if (value35 >= value36) {
break;
}
if (__desolex_internal_5bee_43db_arg3 >= __desolex_internal_5bee_43db_arg2) {
break;
}
value37 = __desolex_internal_5bee_43db_arg0;
value38 = __desolex_internal_5bee_43db_arg1;
value36 = __desolex_internal_5bee_43db_arg2;
value35 = __desolex_internal_5bee_43db_arg3;
value39 = __desolex_internal_5bee_43db_arg4;
value40 = __desolex_internal_5bee_43db_arg5;
value41 = __desolex_internal_5bee_43db_arg6;
if (!((var_bu - 0x01) < var_bu)) _desolexPanic(50);
(bool success18, bytes memory returnData18) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).addLiquidity(alita, 0x55d398326f99059ff775485246999027b3197955, var_bv, ((uint16(stor_a / 0x010000) * amount) / 0x2710) - (((uint16(stor_a / 0x010000) * amount) / 0x2710) / 0x02), 0, 0, address(this), block.timestamp); // call
require(success18);
var_d = var_d + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(__desolex_internal_5c09_44ee_arg1 - __desolex_internal_5c09_44ee_arg0 >= 0x60);
if (var_bv > var_d.length) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success19, bytes memory returnData19) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value65 = success19;
if (!(success19 & (var_a == 0x01))) {
require(!((!success19) & (0x01)));
value65 = success19 & ((!returnData19.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value65 != 0x0, SafeERC20FailedOperation());
}
if (((uint16(stor_a / 0x010000) * amount) / 0x2710) - (((uint16(stor_a / 0x010000) * amount) / 0x2710) / 0x02) > var_af) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success20, bytes memory returnData20) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value66 = success20;
if (!(success20 & (var_a == 0x01))) {
require(!((!success20) & (0x01)));
value66 = success20 & ((!returnData20.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
var_d = var_d;
require(value66 != 0x0, SafeERC20FailedOperation());
}
emit LiquidityAdded(var_af, var_d.length, (var_cb));
var_d = var_d + 0xa0;
releaseOrderCount = 0x01 + releaseOrderCount;
stor_expr_bb = (stor_expr_bb & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address(var_d.length));
stor_expr_bc = var_ce;
stor_expr_bd = var_ca;
stor_expr_be = (uint64(var_cf) | (stor_expr_be & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000))) | (0x010000000000000000 * (bytes1(var_cg)));
mapping_24[__desolex_internal_45c8_36d5_arg1] = mapping_24[__desolex_internal_45c8_36d5_arg1] + 0x01;
stor_expr_bg = releaseOrderCount;
mapping_1e[__desolex_internal_46cc_36e2_arg2] = __desolex_internal_46cc_36e2_arg1 + mapping_1e[__desolex_internal_46cc_36e2_arg2];
uint256 value67 = uint16(stor_a / 0x0100000000000000000000000000);
if (!(__desolex_internal_46cc_36e2_arg0)) {
value67 = uint16(stor_a / 0x010000000000000000000000);
}
stor_expr_bi = ((uint16(value67) * __desolex_internal_46cc_36e2_arg1) / 0x2710) + stor_expr_bi;
uint256 value68 = 0x8cc7f5766c4573e2b29e190c38422cc377e339dac18080957f72fdb7ae4b8ef1;
if (!(__desolex_internal_46cc_36e2_arg0)) {
value68 = 0x604e75f88ca32c2324ef833b47da7e68928c891abee9c9be1c69109a56776a47;
}
emit SellQuotaAdded(__desolex_internal_46cc_36e2_arg2, value68, (uint16(value67) * __desolex_internal_46cc_36e2_arg1) / 0x2710);
emit Event_83e81161(__desolex_internal_36a7_4a2_arg4, releaseOrderCount, __desolex_internal_36a7_4a2_arg3, __desolex_internal_36a7_4a2_arg2);
stor_expr_d = 0x01;
if (!((var_bu - 0x01) < var_bu)) _desolexPanic(50);
(bool success21, bytes memory returnData21) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).addLiquidity(alita, 0x55d398326f99059ff775485246999027b3197955, var_bv, ((uint16(stor_a / 0x010000) * amount) / 0x2710) - (((uint16(stor_a / 0x010000) * amount) / 0x2710) / 0x02), 0, 0, address(this), block.timestamp); // call
require(success21);
var_d = var_d + ((returnData21.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(__desolex_internal_5c09_44ee_arg1 - __desolex_internal_5c09_44ee_arg0 >= 0x60);
if (var_bv > var_d.length) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success22, bytes memory returnData22) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value69 = success22;
if (!(success22 & (var_a == 0x01))) {
require(!((!success22) & (0x01)));
value69 = success22 & ((!returnData22.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
require(value69 != 0x0, SafeERC20FailedOperation());
}
if (((uint16(stor_a / 0x010000) * amount) / 0x2710) - (((uint16(stor_a / 0x010000) * amount) / 0x2710) / 0x02) > var_af) {
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success23, bytes memory returnData23) = address(0x55d398326f99059ff775485246999027b3197955).transfer(address(ecosystemWallet), (value49 + (0 + (value25 + 0)))); // call
uint256 value70 = success23;
if (!(success23 & (var_a == 0x01))) {
require(!((!success23) & (0x01)));
value70 = success23 & ((!returnData23.length) & (address(0x55d398326f99059ff775485246999027b3197955).code.length > 0));
}
var_d = var_d;
require(value70 != 0x0, SafeERC20FailedOperation());
}
emit LiquidityAdded(var_af, var_d.length, (var_cb));
var_d = var_d + 0xa0;
releaseOrderCount = 0x01 + releaseOrderCount;
stor_expr_bb = (stor_expr_bb & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address(var_d.length));
stor_expr_bc = var_ce;
stor_expr_bd = var_ca;
stor_expr_be = (uint64(var_cf) | (stor_expr_be & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000))) | (0x010000000000000000 * (bytes1(var_cg)));
mapping_24[__desolex_internal_45c8_36d5_arg1] = mapping_24[__desolex_internal_45c8_36d5_arg1] + 0x01;
stor_expr_bg = releaseOrderCount;
mapping_1e[__desolex_internal_46cc_36e2_arg2] = __desolex_internal_46cc_36e2_arg1 + mapping_1e[__desolex_internal_46cc_36e2_arg2];
uint256 value71 = uint16(stor_a / 0x0100000000000000000000000000);
if (!(__desolex_internal_46cc_36e2_arg0)) {
value71 = uint16(stor_a / 0x010000000000000000000000);
}
stor_expr_bi = ((uint16(value71) * __desolex_internal_46cc_36e2_arg1) / 0x2710) + stor_expr_bi;
uint256 value72 = 0x8cc7f5766c4573e2b29e190c38422cc377e339dac18080957f72fdb7ae4b8ef1;
if (!(__desolex_internal_46cc_36e2_arg0)) {
value72 = 0x604e75f88ca32c2324ef833b47da7e68928c891abee9c9be1c69109a56776a47;
}
emit SellQuotaAdded(__desolex_internal_46cc_36e2_arg2, value72, (uint16(value71) * __desolex_internal_46cc_36e2_arg1) / 0x2710);
emit Event_83e81161(__desolex_internal_36a7_4a2_arg4, releaseOrderCount, __desolex_internal_36a7_4a2_arg3, __desolex_internal_36a7_4a2_arg2);
stor_expr_d = 0x01;
}
(bool success24, bytes memory returnData24) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739((((uint16(stor_a / 0x010000) * amount) / 0x2710) / 0x02), 0, 0xa0, address(this), block.timestamp, var_am); // call
require(success24);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData24.length + 0x1f));
require((var_d + returnData24.length) - var_d >= 0x20);
require(!(var_bn > 0xffffffffffffffff));
require((var_d + returnData24.length) > ((var_d + var_bn) + 0x1f));
}
}
value49 = 0;
if (value46 < (uint16(stor_1d / 0x0100000000))) {
value49 = ((uint16(stor_1d / 0x0100000000) - value46) * amount) / 0x2710;
}
}
}
}
}
function Unknown_38289e9f(uint256 arg0, uint256 arg1) public {
require(mapping_20[msg.sender], NotOperator());
require(!(arg0 == 0x0 || arg1 < arg0), InvalidParameter());
emit ParameterChanged(0x016f230c5562a24f83b5f63e7d98f1b3ef01d26364eb2fc28790ea85e95e056e, minimumAmount, arg0);
emit ParameterChanged(0x29d360642ed86531bbd80fed9b4e00a54cfe3d672bc3fb81c05353d4445cd036, unresolved_2d5c3eb4, arg1);
minimumAmount = (arg0) ? 1 : 0;
unresolved_2d5c3eb4 = arg1;
}
function Unknown_3f4b7440() public view returns (uint16) {
return uint16(stor_a / 0x01000000000000000000);
}
function unpause() public {
require(mapping_20[msg.sender], NotOperator());
require(paused, ExpectedPause());
paused = false;
emit Unpaused(msg.sender);
}
function teamLevel(address arg0) public view returns (uint256) {
if (!blacklist[arg0]) {
uint256 value0 = 0x06;
while (true) {
if (value0 == 0x0) {
break;
}
if (!(value0 - 0x1 < 0x6)) _desolexPanic(50);
if (!(stor_expr_de + mapping_1e[arg0] < stor_expr_cq)) {
if (!(value0 - 0x1 < 0x6)) _desolexPanic(50);
}
if ((stor_expr_dl + mapping_1e[arg0] >= stor_expr_cr) && (stor_expr_dm + stor_expr_dn >= stor_expr_cs)) {
return bytes1(value0);
break;
}
value0 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value0;
}
}
return 0;
}
function burnBps() public view returns (uint16) {
return uint16(stor_7 / 0x010000000000000000000000000000000000000000);
}
function Unknown_5a193ca7() public {
internal_1891();
}
function getAccountData(address arg0) public view returns (bool) {
var_a = var_a + 0x0120;
return abi.encodePacked(var_a.length, var_am, var_an, var_ao, var_ap, var_aq, var_ar, var_as, !(!(var_at)));
}
function Unknown_65c6dba8() public view returns (uint16) {
return uint16(stor_a / 0x01000000000000000000000000000000);
}
function hasBurned() public view returns (bool) {
return !(!(bytes1(stor_26)));
}
function Unknown_6f76ffdf() public {
require(!((msg.data.length - 0x04) < 0x01a0));
require(!((msg.data.length - 0x04) < 0xa0));
require(!(((msg.data.length - 0x04) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60) < 0x0100));
require(mapping_20[msg.sender], NotOperator());
uint256 value0 = 0;
uint256 value1 = 0;
while (true) {
if (value0 >= 0x6) {
break;
}
require(0x20 * value0 + 0xa4 + 0x20 - (0x20 * value0 + 0xa4) >= 0x20);
require((msg.data[(0x20 * value0) + 0xa4]) == ((msg.data[(0x20 * value0) + 0xa4]) & 0xffff));
require(uint16(msg.data[(0x20 * value0) + 0xa4]) > (uint16(value1)), InvalidParameter());
if (!(value0 < 0x6)) _desolexPanic(50);
require(0x20 * value0 + 0xa4 + 0x20 - (0x20 * value0 + 0xa4) >= 0x20);
require((msg.data[(0x20 * value0) + 0xa4]) == ((msg.data[(0x20 * value0) + 0xa4]) & 0xffff));
value0 = 0x01 + value0;
value1 = msg.data[(0x20 * value0) + 0xa4];
}
require(0xa4 + 0x100 - (0xa4 + 0xe0) >= 0x20);
require((msg.data[0xa4 + 0xe0]) == ((msg.data[0xa4 + 0xe0]) & 0xffff));
require(0xa4 + 0xe0 - (0xa4 + 0xc0) >= 0x20);
require((msg.data[0xa4 + 0xc0]) == ((msg.data[0xa4 + 0xc0]) & 0xffff));
require(0xa4 + 0xc0 - (0xa4 + 0xa0) >= 0x20);
require((msg.data[0xa4 + 0xa0]) == ((msg.data[0xa4 + 0xa0]) & 0xffff));
require(!(uint16(msg.data[0xa4 + 0xe0]) + (uint16(msg.data[0xa4 + 0xc0]) + (uint16(msg.data[0xa4 + 0xa0]))) > 0x2710), InvalidParameter());
uint256 value2 = 0x01f4;
if (nodeContract) {
(bool success0, bytes memory returnData0) = nodeContract.marsDividendBps(); // 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 & 0xffff));
(bool success1, bytes memory returnData1) = address(nodeContract / 0x01).starDividendBps(); // 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 & 0xffff));
value2 = (uint16(var_d.length)) + (uint16(var_d.length));
}
require(0x04 + 0xa0 - (0x04 + 0x80) >= 0x20);
require((msg.data[0x04 + 0x80]) == ((msg.data[0x04 + 0x80]) & 0xffff));
require(0x04 + 0x80 - (0x04 + 0x60) >= 0x20);
require((msg.data[0x04 + 0x60]) == ((msg.data[0x04 + 0x60]) & 0xffff));
require(0x04 + 0x60 - (0x04 + 0x40) >= 0x20);
require((msg.data[0x04 + 0x40]) == ((msg.data[0x04 + 0x40]) & 0xffff));
require(0x04 + 0x40 - (0x04 + 0x20) >= 0x20);
require((msg.data[0x04 + 0x20]) == ((msg.data[0x04 + 0x20]) & 0xffff));
require(0x04 + 0x20 - 0x04 >= 0x20);
require(msg.data[0x04] == (msg.data[0x04] & 0xffff));
require((value2 + (uint16(msg.data[0xa4 + 0xe0]) + (uint16(msg.data[0xa4 + 0xc0]) + (uint16(msg.data[0xa4 + 0xa0]))) + (uint16(msg.data[0x04 + 0x80]) + ((uint16(msg.data[0x04 + 0x60]) * 0x0a) + (uint16(msg.data[0x04 + 0x40]) + (uint16(msg.data[0x04 + 0x20]) + (uint16(msg.data[0x04])))))))) == 0x2710, InvalidParameter());
require(0x04 + 0x20 - 0x04 >= 0x20);
require(msg.data[0x04] == (msg.data[0x04] & 0xffff));
stor_a = (uint16(msg.data[0x04])) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000 & stor_a);
require(0x04 + 0x40 - (0x04 + 0x20) >= 0x20);
require((msg.data[0x04 + 0x20]) == ((msg.data[0x04 + 0x20]) & 0xffff));
stor_a = (stor_a & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffff)) | (0x010000 * (uint16(msg.data[0x04 + 0x20])));
require(0x04 + 0x60 - (0x04 + 0x40) >= 0x20);
require((msg.data[0x04 + 0x40]) == ((msg.data[0x04 + 0x40]) & 0xffff));
stor_a = (stor_a & (0xffffffffffffffffffffffffffffffffffffffffff0000ffffffffffffffffff)) | (0x01000000000000000000 * (uint16(msg.data[0x04 + 0x40])));
require(0x04 + 0x80 - (0x04 + 0x60) >= 0x20);
require((msg.data[0x04 + 0x60]) == ((msg.data[0x04 + 0x60]) & 0xffff));
stor_a = (stor_a & (0xffffffffffffffffffffffffffffffffffffffffffffffff0000ffffffffffff)) | (0x01000000000000 * (uint16(msg.data[0x04 + 0x60])));
require(0x04 + 0xa0 - (0x04 + 0x80) >= 0x20);
require((msg.data[0x04 + 0x80]) == ((msg.data[0x04 + 0x80]) & 0xffff));
uint256 value3 = 0;
while (true) {
stor_a = (uint16(msg.data[0x04 + 0x80]) * 0x0100000000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffffffff & stor_a);
if (value3 >= 0x6) {
break;
}
require(0x20 * value3 + 0xa4 + 0x20 - (0x20 * value3 + 0xa4) >= 0x20);
require((msg.data[(0x20 * value3) + 0xa4]) == ((msg.data[(0x20 * value3) + 0xa4]) & 0xffff));
if (!(value3 < 0x6)) _desolexPanic(50);
stor_expr_dx = (uint16(msg.data[(0x20 * value3) + 0xa4]) * (0x0100 ** (0x02 * (value3 % 0x10)))) | (~(0xffff * (0x0100 ** (0x02 * (value3 % 0x10)))) & stor_expr_dx);
value3 = 0x01 + value3;
}
require(0xa4 + 0xe0 - (0xa4 + 0xc0) >= 0x20);
require((msg.data[0xa4 + 0xc0]) == ((msg.data[0xa4 + 0xc0]) & 0xffff));
stor_1d = (uint16(msg.data[0xa4 + 0xc0])) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000 & stor_1d);
require(0xa4 + 0x100 - (0xa4 + 0xe0) >= 0x20);
require((msg.data[0xa4 + 0xe0]) == ((msg.data[0xa4 + 0xe0]) & 0xffff));
stor_1d = (uint16(msg.data[0xa4 + 0xe0] + (msg.data[0xa4 + 0xc0] + (msg.data[0xa4 + 0xa0]))) * 0x0100000000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffffffff & (uint16(msg.data[0xa4 + 0xe0]) * 0x010000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffff00000000ffff & stor_1d));
}
function Unknown_705420be(address arg0, uint256 arg1, uint256 arg2) public view returns (bytes memory) {
internal_206e(arg2, arg1, arg0);
uint256 value9 = 0;
uint256 value10 = value8 + 0x20;
uint256 value11 = (var_c + 0x40) + 0x20;
while (true) {
if (!(value9 < var_q)) {
break;
}
value9 = 0x01 + value9;
value10 = value10 + 0x20;
value11 = 0x20 + value11;
}
uint256 value12 = 0;
uint256 value13 = value7 + 0x20;
uint256 value14 = ((var_c + 0x40) + 0x20) + 0x20;
while (true) {
if (!(value12 < var_s)) {
break;
}
value12 = 0x01 + value12;
value13 = 0x20 + value13;
value14 = 0xa0 + value14;
return abi.encodePacked(0x40, value11 - var_c, var_q, var_s);
}
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function Unknown_735e0223(address arg0) public view returns (uint256) {
return stor_expr_ef;
}
function Unknown_7abb9a7b() public {
require(!(tx.origin != msg.sender || msg.sender.code.length != 0x0), OnlyEOA());
require(!blacklist[msg.sender], Blacklisted());
require(!paused, EnforcedPause());
require(0x2 != stor_expr_d, ReentrancyGuardReentrantCall());
stor_expr_d = 0x02;
uint256 value0 = 0;
uint256 value1 = 0;
uint256 value2 = 0;
while (true) {
if (value0 >= mapping_24[msg.sender]) {
break;
}
if (!(stor_expr_ei < releaseOrderCount)) _desolexPanic(50);
bool flag1 = !(bytes1(stor_expr_ej / 0x010000000000000000) < 0x1e);
if (bytes1(stor_expr_ej / 0x010000000000000000) < 0x1e) {
flag1 = (block.timestamp / 0x015180) < (uint64(stor_expr_ej));
}
uint256 value19;
if (!flag1) {
uint256 value18 = stor_expr_ek;
if (bytes1(stor_expr_ej / 0x010000000000000000) == (0x1e - 0x01)) {
value18 = stor_expr_el - ((0x1e - 0x01) * stor_expr_ek);
}
stor_expr_ej = (bytes1(0x01 + ((stor_expr_ej / 0x010000000000000000) & (0xff))) * 0x010000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff & stor_expr_ej);
stor_expr_em = (((block.timestamp / 0x015180) + 0x01) & (0xffffffffffffffff)) | (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000 & stor_expr_em);
value19 = value18;
} else {
value19 = 0;
}
uint256 value20 = 0x01 + value1;
uint256 value21 = value19 + value2;
if (0x0 != value19) {
} else {
value20 = value1;
value21 = value2;
}
value0 = 0x01 + value0;
value1 = value20;
value2 = value21;
}
require(0x0 != value1, CustomError_2429c617());
uint256 var_d;
var_d = var_d + 0x60;
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
uint256 beforeBalance = IDesolexERC20(alita).balanceOf(address(this));
uint256 value3 = 0;
uint256 value5 = var_d + 0x20;
uint256 value4 = var_n;
uint256 value6 = 0;
uint256 value7 = var_d;
uint256 value8 = ((0x04 + var_d) + 0xa0) + 0x20;
while (true) {
if (value3 >= value4) {
break;
}
value3 = 0x01 + value3;
value5 = value5 + 0x20;
value4 = value4;
value6 = value6;
value7 = value7;
value8 = 0x20 + value8;
(bool success1, bytes memory returnData1) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739(value2, 0, 0xa0, address(this), block.timestamp, var_n); // call
require(success1);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData1.length + 0x1f));
require((var_d + returnData1.length) - var_d >= 0x20);
require(!(var_t > 0xffffffffffffffff));
require((var_d + returnData1.length) > ((var_d + var_t) + 0x1f));
if (!(var_u <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_u << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_u << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_u << 0x05)) + 0x1f));
require(!(((var_d + var_t) + (var_w << 0x05) + 0x20) > (var_d + returnData1.length)));
uint256 value11 = var_d;
uint256 value12 = var_d + 0x20;
uint256 value10 = ((var_d + var_t) + (var_w << 0x05)) + 0x20;
uint256 value9 = (var_d + var_t) + 0x20;
uint256 value13 = 0;
uint256 value14 = var_d;
uint256 value15 = var_d + returnData1.length;
while (true) {
if (value9 >= value10) {
break;
}
if ((0x20 + value9) >= value10) {
break;
}
value11 = value11;
value12 = (value12 + 0x20) + 0x20;
value10 = value10;
value9 = 0x20 + (0x20 + value9);
value13 = value13;
value14 = value14;
value15 = value15;
uint256 afterBalance = IDesolexERC20(alita).balanceOf(address(this));
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success3, bytes memory returnData3) = alita.call(abi.encodeWithSelector(bytes4(0xa9059cbb), msg.sender, (afterBalance - beforeBalance))); // call transfer
uint256 value16 = success3;
if (!(success3 & (var_a == 0x01))) {
require(!((!success3) & (0x01)));
value16 = success3 & ((!returnData3.length) & (address(alita).code.length > 0));
}
var_d = var_d;
require(value16 != 0x0, SafeERC20FailedOperation());
emit Event_9ac1da82(msg.sender, value1, value2, (afterBalance - beforeBalance));
stor_expr_d = 0x01;
uint256 afterBalance1 = IDesolexERC20(alita).balanceOf(address(this));
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success5, bytes memory returnData5) = alita.call(abi.encodeWithSelector(bytes4(0xa9059cbb), msg.sender, (afterBalance1 - beforeBalance))); // call transfer
uint256 value17 = success5;
if (!(success5 & (var_a == 0x01))) {
require(!((!success5) & (0x01)));
value17 = success5 & ((!returnData5.length) & (address(alita).code.length > 0));
}
var_d = var_d;
require(value17 != 0x0, SafeERC20FailedOperation());
emit Event_9ac1da82(msg.sender, value1, value2, (afterBalance1 - beforeBalance));
stor_expr_d = 0x01;
}
}
}
function Unknown_7b0f72dc() public view returns (uint16) {
return uint16(stor_a / 0x010000000000000000000000);
}
function pause() public {
require(mapping_20[msg.sender], NotOperator());
require(!paused, EnforcedPause());
paused = true;
emit Paused(msg.sender);
}
function Unknown_874e0fc6(uint256 arg0) public view returns (bytes memory) {
uint256 var_a;
var_a = var_a + 0xa0;
require(arg0 < releaseOrderCount, InvalidOrder());
var_a = var_a + 0xa0;
return abi.encodePacked(address(var_a.length), var_v, var_w, uint64(var_x), bytes1(var_y));
}
function releaseBps() public view returns (uint16) {
return uint16(stor_a);
}
function Unknown_91e482aa() public {
require(!((msg.data.length - 0x04) < 0xa0));
require(!(0xa4 > msg.data.length));
require(mapping_20[msg.sender], NotOperator());
uint256 value0 = 0;
uint256 value1 = 0;
while (true) {
if (value0 >= 0x5) {
break;
}
require(msg.data[(0x20 * value0) + 0x04] > value1, InvalidParameter());
unresolved_df8c90d6[value0] = msg.data[(0x20 * value0) + 0x04];
value0 = 0x01 + value0;
value1 = msg.data[(0x20 * value0) + 0x04];
}
}
function Unknown_92c3e01d() public {
internal_2600();
}
function Unknown_94aa610d(bool arg0) public {
require(mapping_20[msg.sender], NotOperator());
stor_a = (stor_a & (0xffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff)) | (0x010000000000000000 * arg0);
uint256 value0;
uint256 value1 = 0x01;
if (bytes1(stor_a / 0x010000000000000000) != 0x0) {
uint256 value2 = 0x01;
if (!(arg0)) {
value2 = 0;
}
value0 = value2;
} else {
uint256 value3 = 0x01;
if (!(arg0)) {
value3 = 0;
}
value0 = value3;
value1 = 0;
}
emit ParameterChanged(0xaeb807474ca55d54d9f832005de15cf27ce8cac3fdfc80eca46b52195cf7c118, bytes1(value1), bytes1(value0));
}
function addOperator(address arg0) public onlyOwner {
require(arg0 != address(0), ZeroAddress());
require(!mapping_20[arg0], InvalidParameter());
mapping_20[arg0] = true;
array_21.push(address(arg0));
mapping_22[arg0] = array_21.length;
}
function Unknown_9caa58b7(address arg0) public view returns (bool) {
if (blacklist[arg0]) {
return !(blacklist[arg0]);
} else {
return !(stor_expr_de + mapping_1e[arg0] < unresolved_2d5c3eb4);
}
}
function Unknown_9ef8ba94() public {
require(!((msg.data.length - 0x04) < 0x0180));
require(!(msg.data.length < 0xc4));
require(!(msg.data.length < 0x0184));
require(mapping_20[msg.sender], NotOperator());
uint256 value0 = 0;
uint256 value1 = 0;
uint256 value2 = 0;
while (true) {
if (value0 >= 0x6) {
break;
}
require(!(CALLDATALOAD(0x20 * value0 + 0x04) <= value2 || CALLDATALOAD(0x20 * value0 + 0xc4) <= value1), InvalidParameter());
if (!(value0 < 0x6)) _desolexPanic(50);
unresolved_5e9a2975[value0] = msg.data[(0x20 * value0) + 0x04];
levelTeamThresholds[value0] = msg.data[(0x20 * value0) + 0xc4];
value0 = 0x01 + value0;
value1 = msg.data[(0x20 * value0) + 0xc4];
value2 = msg.data[(0x20 * value0) + 0x04];
}
}
function Unknown_abc9e946(uint256 arg0) public view returns (uint16) {
require(arg0 < 0x6);
return uint16(stor_expr_fh / (0x0100 ** (0x02 * (arg0 % 0x10))));
}
function removeOperator(address arg0) public onlyOwner {
require(mapping_20[arg0], InvalidParameter());
if (!((mapping_22[arg0] - 0x01) == (array_21.length - 0x01))) {
if (!((array_21.length - 0x01) < array_21.length)) _desolexPanic(50);
if (!((mapping_22[arg0] - 0x01) < array_21.length)) _desolexPanic(50);
stor_expr_fl = (address(stor_expr_fm & (0xffffffffffffffffffffffffffffffffffffffff))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_fl);
mapping_22[address(stor_expr_fm)] = (mapping_22[arg0] - 0x01) + 0x01;
}
if (!(array_21.length != 0x0)) _desolexPanic(49);
stor_expr_fo = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000) & stor_expr_fo;
array_21.length = array_21.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
mapping_22[arg0] = 0;
mapping_20[arg0] = false;
}
function Unknown_b2a77fed(address arg0, uint256 arg1) public {
require(msg.sender == alita, CustomError_6815150b());
require(arg0 != address(0), ZeroAddress());
require(0x0 != arg1, InvalidParameter());
stor_expr_fq = arg1 + stor_expr_fq;
emit Event_b54e1490(arg0, arg1);
}
function Unknown_b58eda6d() public view returns (uint16) {
return uint16(stor_1d);
}
function setBurnConfig(address arg0, address arg1, uint16 arg2) public {
require(arg2 == (arg2 & 0xffff));
require(mapping_20[msg.sender], NotOperator());
require(arg0 != address(0), ZeroAddress());
require(arg1 != address(0), ZeroAddress());
require(!((arg2 & 0xffff) == 0x0 || (0xffff & arg2) > 0x3e8), InvalidParameter());
burnExecutor = arg0;
stor_7 = (arg1 | (stor_7 & (0xffffffffffffffffffff00000000000000000000000000000000000000000000))) | (0x010000000000000000000000000000000000000000 * (arg2 & (0xffff)));
}
function liquidityBps() public view returns (uint16) {
return uint16(stor_a / 0x010000);
}
function Unknown_d3fa06dd() public view returns (uint16) {
return uint16(stor_a / 0x0100000000000000000000000000);
}
function setCoreAddresses(address token, address arg1, address arg2, address arg3, address arg4) public {
require(mapping_20[msg.sender], NotOperator());
require(token != address(0), ZeroAddress());
require(arg1 != address(0), ZeroAddress());
require(arg2 != address(0), ZeroAddress());
require(arg3 != address(0), ZeroAddress());
require(arg4 != address(0), ZeroAddress());
(bool success0, bytes memory returnData0) = arg1.token0(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
require(var_e == (var_e & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success1, bytes memory returnData1) = arg1.token1(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
require(var_g == (var_g & 0xffffffffffffffffffffffffffffffffffffffff));
bool flag0 = (address(var_h)) == token;
if (address(var_h) == token) {
flag0 = (address(var_h)) == 0x55d398326f99059ff775485246999027b3197955;
}
bool flag2;
if (!(flag0)) {
flag2 = (address(var_h)) == 0x55d398326f99059ff775485246999027b3197955;
if (address(var_h) == 0x55d398326f99059ff775485246999027b3197955) {
flag2 = (address(var_h)) == token;
}
}
require((flag0 || flag2), InvalidPair());
var_d = 0x40 + var_d;
emit AddressChanged(keccak256(abi.encode(0x414c495441000000000000000000000000000000000000000000000000000000)), alita, token);
var_d = 0x40 + var_d;
emit AddressChanged(keccak256(abi.encode(0x5041495200000000000000000000000000000000000000000000000000000000)), pair, arg1);
var_d = 0x40 + var_d;
emit AddressChanged(keccak256(abi.encode(0x524546455252414c5f5245474953545259000000000000000000000000000000)), referralRegistry, arg2);
var_d = 0x40 + var_d;
emit AddressChanged(keccak256(abi.encode(0x4e4f444500000000000000000000000000000000000000000000000000000000)), nodeContract, arg3);
var_d = 0x40 + var_d;
emit AddressChanged(keccak256(abi.encode(0x45434f53595354454d0000000000000000000000000000000000000000000000)), ecosystemWallet, arg4);
alita = token;
pair = arg1;
referralRegistry = arg2;
nodeContract = arg3;
ecosystemWallet = arg4;
address(token).approve(address(0x10ed43c718714eb63d5aa57b78b54704e256024e), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // call
}
function Unknown_d966a184(uint16 arg0, uint16 arg1, uint16 arg2, uint16 arg3) public {
require(arg0 == (arg0 & 0xffff));
require(arg1 == (arg1 & 0xffff));
require(arg2 == (arg2 & 0xffff));
require(arg3 == (arg3 & 0xffff));
require(mapping_20[msg.sender], NotOperator());
stor_a = (uint16(arg3) * 0x010000000000000000000000000000000000) | (0xffffffffffffffffffffffffff0000ffffffffffffffffffffffffffffffffff & (0xffff & arg2 * 0x01000000000000000000000000000000) | (0xffffffffffffffffffffffffff00000000ffffffffffffffffffffffffffffff & ((0xffff & arg1 * 0x0100000000000000000000000000) | (0xffffffffffffffffffffffffffffffffff0000ffffffffffffffffffffffffff & (0xffff & arg0 * 0x010000000000000000000000) | (0xffffffffffffffffffffffffffffffffff00000000ffffffffffffffffffffff & stor_a)))));
}
function burnReceiver() public view returns (address) {
return stor_7;
}
function Unknown_e0017ec9() public view returns (uint16) {
return uint16(stor_a / 0x0100000000);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), OwnableInvalidOwner());
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function claimRelease(uint256 arg0) public {
internal_320a(arg0);
}
function internal_f31(address arg0) private {
// Decompilation incomplete: helper effect provenance is conservative.
uint256 value0 = 0;
uint256 value1 = 0;
uint256 value2 = 0;
while (true) {
if (value0 >= mapping_24[arg0]) {
break;
}
if (!(stor_expr_bk < releaseOrderCount)) _desolexPanic(50);
uint256 value3;
uint256 value4 = 0x01 + value2;
if (!((0xff & (0xff & stor_expr_bm / 0x10000000000000000)) >= 0x1e || block.timestamp / 0x15180 < (0xffffffffffffffff & stor_expr_bn))) {
uint256 value5 = stor_expr_bo + value1;
if (!(bytes1(stor_expr_bp / 0x010000000000000000) != 0x1d)) {
value5 = (stor_expr_bu - (0x1d * stor_expr_bs)) + value1;
}
value3 = value5;
} else {
value3 = value1;
value4 = value2;
}
value0 = 0x01 + value0;
value1 = value3;
value2 = value4;
}
}
function internal_1891() private {
// Decompilation incomplete: helper effect provenance is conservative.
require(0x2 != stor_expr_d, ReentrancyGuardReentrantCall());
stor_expr_d = 0x02;
require(msg.sender == burnExecutor, CustomError_889085ac());
bool flag0 = !(alita);
if (alita) {
flag0 = !(pair);
}
bool flag1 = flag0;
if (!(flag0)) {
flag1 = !(referralRegistry);
}
bool flag2 = flag1;
if (!(flag1)) {
flag2 = !(nodeContract);
}
require(!(flag2 || (0xffffffffffffffffffffffffffffffffffffffff & ecosystemWallet) == 0x0), DependenciesNotConfigured());
require(!(0xff & stor_26 && block.timestamp / 0x15180 == lastBurnDay), AlreadyBurnedToday());
uint256 accountBalance = IDesolexERC20(alita).balanceOf(pair);
require(0 - ((uint16(stor_7 / 0x010000000000000000000000000000000000000000) * accountBalance) / 0x2710), InvalidParameter());
require(alita.code.length != 0x0);
(bool success1, bytes memory returnData1) = alita.burnAlitaFromPair((uint16(stor_7 / 0x010000000000000000000000000000000000000000) * accountBalance) / 0x2710, address(this)); // call
require(success1);
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success2, bytes memory returnData2) = alita.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(stor_7), ((uint16(stor_7 / 0x010000000000000000000000000000000000000000) * accountBalance) / 0x2710))); // call transfer
uint256 value0 = success2;
if (!(success2 & (var_a == 0x01))) {
require(!((!success2) & (0x01)));
value0 = success2 & ((!returnData2.length) & (address(alita).code.length > 0));
}
require(value0, SafeERC20FailedOperation());
lastBurnDay = block.timestamp / 0x015180;
stor_26 = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_26);
emit Event_e3ce05ac(block.timestamp / 0x015180, stor_7, (uint16(stor_7 / 0x010000000000000000000000000000000000000000) * accountBalance) / 0x2710);
stor_expr_d = 0x01;
}
function internal_206e(uint256 arg0, uint256 arg1, address arg2) private {
// Decompilation incomplete: helper effect provenance is conservative.
uint256 var_c;
uint256 value7 = var_c;
uint256 value8 = var_c;
if (!(arg1 >= mapping_24[arg2] || arg0 == 0x0)) {
uint256 value0;
uint256 value2;
if ((arg0 + arg1) > mapping_24[arg2]) {
uint256 value15 = (arg0 + arg1) - arg1;
uint256 value17 = arg0 + arg1;
value15 = mapping_24[arg2] - arg1;
value17 = mapping_24[arg2];
value0 = value15;
value2 = value17;
} else {
uint256 value16 = (arg0 + arg1) - arg1;
uint256 value18 = arg0 + arg1;
if (!(arg0 + arg1 >= arg1)) {
value16 = mapping_24[arg2] - arg1;
value18 = mapping_24[arg2];
}
value0 = value16;
value2 = value18;
}
if (!(value0 <= 0xffffffffffffffff)) _desolexPanic(65);
var_c = var_c + (0x20 + (0x20 * value0));
uint256 value1 = value0;
if (value0 != 0x0) {
value1 = (value0 * 0x20) + (0x20 + var_c);
}
if (!(value0 <= 0xffffffffffffffff)) _desolexPanic(65);
uint256 value5 = value0;
if (value0 != 0x0) {
var_c = var_c + 0xa0;
uint256 value4 = 0x20 + (0x20 + var_c);
uint256 value3 = value0 - 0x01;
while (true) {
if (value3 == 0) {
break;
}
var_c = var_c + 0xa0;
value4 = 0x20 + value4;
value3 = value3 - 0x01;
}
value5 = value4;
}
uint256 value6 = 0;
while (true) {
if (value6 >= value0) {
break;
}
if (!((value6 + arg1) < mapping_24[arg2])) _desolexPanic(50);
if (!(value6 < var_c.length)) _desolexPanic(50);
if (!(stor_expr_ea < releaseOrderCount)) _desolexPanic(50);
var_c = var_c + 0xa0;
if (!(value6 < var_c.length)) _desolexPanic(50);
value6 = 0x01 + value6;
}
} else {
var_c = 0x40 + var_c;
value7 = var_c + 0x20;
value8 = var_c;
}
}
function internal_2600() private {
// Decompilation incomplete: helper effect provenance is conservative.
require(!(tx.origin != msg.sender || msg.sender.code.length != 0x0), OnlyEOA());
require(!blacklist[msg.sender], Blacklisted());
require(!paused, EnforcedPause());
(bool success0, bytes memory returnData0) = nodeContract.nodeCreationClosed(); // 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 != 0x0));
require(var_d.length, NodeCreationNotClosed());
require(!stor_expr_es_0_0, AlreadySynced());
(bool success1, bytes memory returnData1) = nodeContract.isNode(msg.sender); // 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 != 0x0));
require(var_d.length, NotNode());
(bool success2, bytes memory returnData2) = nodeContract.giftedTeamLevel(msg.sender); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData2.length) - var_d) < 0x20));
require(value2 == (value2 & 0xff));
uint256 value3 = stor_expr_et;
uint256 value4 = stor_expr_eu;
if (0x0 != (0xff & value2)) {
require(bytes1(var_d.length) <= 0x03, CustomError_e383ec87());
if (!((0xff & (0xff & value2) - 0x1) < 0x6)) _desolexPanic(50);
if (!((0xff & (0xff & value2) - 0x1) < 0x6)) _desolexPanic(50);
} else {
value3 = 0;
value4 = unresolved_2d5c3eb4;
}
uint256 value5 = value4 - (stor_expr_ew + mapping_1e[msg.sender]);
if (!(value4 > (stor_expr_ew + mapping_1e[msg.sender]))) {
value5 = 0;
}
uint256 value6 = value3 - (stor_expr_fa + stor_expr_ez);
if (!(value3 > (stor_expr_fa + stor_expr_ez))) {
value6 = 0;
}
stor_expr_fb = value5 + stor_expr_fb;
stor_expr_fa = value6 + stor_expr_fa;
stor_expr_es_0_0 = true;
emit Event_6c514923(msg.sender, bytes1(var_d.length), value5, value6);
}
function internal_320a(uint256 arg0) private {
// Decompilation incomplete: helper effect provenance is conservative.
require(!(tx.origin != msg.sender || msg.sender.code.length != 0x0), OnlyEOA());
require(!blacklist[msg.sender], Blacklisted());
require(!paused, EnforcedPause());
require(0x2 != stor_expr_d, ReentrancyGuardReentrantCall());
stor_expr_d = 0x02;
require(arg0 < releaseOrderCount, InvalidOrder());
require(msg.sender == (stor_expr_fs), NotOrderOwner());
bool flag1 = !(bytes1(stor_expr_ft / 0x010000000000000000) < 0x1e);
if (bytes1(stor_expr_ft / 0x010000000000000000) < 0x1e) {
flag1 = ((block.timestamp / 0x015180)) < (uint64(stor_expr_ft));
}
uint256 value14 = stor_expr_fu;
uint256 var_d;
if (!flag1) {
if (bytes1(stor_expr_ft / 0x010000000000000000) == ((0x1e - 0x01))) {
array_3[((arg0 * 0x04) + keccak256(abi.encode(0x23)))] = (bytes1(0x01 + ((array_3[((arg0 * 0x04) + keccak256(abi.encode(0x23)))] / 0x010000000000000000) & (0xff))) * 0x010000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff & array_3[((arg0 * 0x04) + keccak256(abi.encode(0x23)))]);
array_3[((arg0 * 0x04) + keccak256(abi.encode(0x23)))] = ((((block.timestamp / 0x015180)) + 0x01) & (0xffffffffffffffff)) | (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000 & array_3[((arg0 * 0x04) + keccak256(abi.encode(0x23)))]);
require(0x0 != ((stor_expr_fv - (((0x1e - 0x01) * stor_expr_fu)))), CustomError_2429c617());
var_d = var_d + 0x60;
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
uint256 beforeBalance = IDesolexERC20(alita).balanceOf(address(this));
uint256 value0 = 0;
uint256 value2 = var_d + 0x20;
uint256 value1 = var_n;
uint256 value3 = 0;
uint256 value4 = var_d;
uint256 value5 = ((0x04 + var_d) + 0xa0) + 0x20;
while (true) {
if (value0 >= value1) {
break;
}
value0 = (0x01 + value0);
value2 = (value2 + 0x20);
value1 = value1;
value3 = value3;
value4 = value4;
value5 = (0x20 + value5);
(bool success1, bytes memory returnData1) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739(((stor_expr_fv - (((0x1e - 0x01) * stor_expr_fu)))), 0, 0xa0, address(this), block.timestamp, var_n); // call
require(success1);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData1.length + 0x1f));
require((var_d + returnData1.length) - var_d >= 0x20);
require(!(var_t > 0xffffffffffffffff));
require((var_d + returnData1.length) > ((var_d + var_t) + 0x1f));
if (!(var_v <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_v << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_v << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_v << 0x05)) + 0x1f));
require(!(((var_d + var_t) + (var_w << 0x05) + 0x20) > (var_d + returnData1.length)));
uint256 value8 = var_d;
uint256 value9 = var_d + 0x20;
uint256 value7 = ((var_d + var_t) + (var_w << 0x05)) + 0x20;
uint256 value6 = (var_d + var_t) + 0x20;
uint256 value10 = 0;
uint256 value11 = var_d;
uint256 value12 = (var_d + returnData1.length);
while (true) {
if (value6 >= value7) {
break;
}
value8 = value8;
value9 = (value9 + 0x20);
value7 = value7;
value6 = (0x20 + value6);
value10 = value10;
value11 = value11;
value12 = value12;
uint256 afterBalance = IDesolexERC20(alita).balanceOf(address(this));
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success3, bytes memory returnData3) = alita.call(abi.encodeWithSelector(bytes4(0xa9059cbb), msg.sender, (afterBalance - beforeBalance))); // call transfer
uint256 value13 = success3;
if (!(success3 & (var_a == 0x01))) {
require(!((!success3) & (0x01)));
value13 = success3 & ((!returnData3.length) & (address(alita).code.length > 0));
}
require(value13 != 0x0, SafeERC20FailedOperation());
emit Event_9ac1da82(msg.sender, 0x01, ((stor_expr_fv - (((0x1e - 0x01) * stor_expr_fu)))), afterBalance - beforeBalance);
stor_expr_d = 0x01;
}
}
}
stor_expr_ft = (bytes1((0x01 + ((stor_expr_ft / 0x010000000000000000) & (0xff)))) * 0x010000000000000000) | (0xffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffff & stor_expr_ft);
stor_expr_fy = (((block.timestamp / 0x015180) + 0x01) & (0xffffffffffffffff)) | (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000 & stor_expr_fy);
} else {
value14 = 0;
}
require(0x0 != value14, CustomError_2429c617());
var_d = var_d + 0x60;
if (!(0 < var_d.length)) _desolexPanic(50);
if (!(0x01 < var_d.length)) _desolexPanic(50);
uint256 beforeBalance1 = IDesolexERC20(alita).balanceOf(address(this));
uint256 value0 = 0;
uint256 value2 = var_d + 0x20;
uint256 value1 = var_n;
uint256 value3 = 0;
uint256 value4 = var_d;
uint256 value5 = ((0x04 + var_d) + 0xa0) + 0x20;
while (true) {
if (value0 >= value1) {
break;
}
value0 = (0x01 + value0);
value2 = (value2 + 0x20);
value1 = value1;
value3 = value3;
value4 = value4;
value5 = (0x20 + value5);
(bool success5, bytes memory returnData5) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_38ed1739(((stor_expr_fv - (((0x1e - 0x01) * stor_expr_fu)))), 0, 0xa0, address(this), block.timestamp, var_n); // call
require(success5);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f));
require((var_d + returnData5.length) - var_d >= 0x20);
require(!(var_t > 0xffffffffffffffff));
require((var_d + returnData5.length) > ((var_d + var_t) + 0x1f));
if (!(var_v <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_v << 0x05)) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_v << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65);
var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_v << 0x05)) + 0x1f));
require(!(((var_d + var_t) + (var_w << 0x05) + 0x20) > (var_d + returnData5.length)));
uint256 value8 = var_d;
uint256 value9 = var_d + 0x20;
uint256 value7 = ((var_d + var_t) + (var_w << 0x05)) + 0x20;
uint256 value6 = (var_d + var_t) + 0x20;
uint256 value10 = 0;
uint256 value11 = var_d;
uint256 value12 = (var_d + returnData5.length);
while (true) {
if (value6 >= value7) {
break;
}
if ((0x20 + value6) >= value7) {
break;
}
value8 = value8;
value9 = ((value9 + 0x20) + 0x20);
value7 = value7;
value6 = (0x20 + (0x20 + value6));
value10 = value10;
value11 = value11;
value12 = value12;
uint256 afterBalance1 = IDesolexERC20(alita).balanceOf(address(this));
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success7, bytes memory returnData7) = alita.call(abi.encodeWithSelector(bytes4(0xa9059cbb), msg.sender, (afterBalance1 - beforeBalance1))); // call transfer
uint256 value15 = success7;
if (!(success7 & (var_a == 0x01))) {
require(!((!success7) & (0x01)));
value15 = success7 & ((!returnData7.length) & (address(alita).code.length > 0));
}
var_d = var_d;
require(value15 != 0x0, SafeERC20FailedOperation());
emit Event_9ac1da82(msg.sender, 0x01, value14, (afterBalance1 - beforeBalance1));
stor_expr_d = 0x01;
uint256 afterBalance2 = IDesolexERC20(alita).balanceOf(address(this));
var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
(bool success9, bytes memory returnData9) = alita.call(abi.encodeWithSelector(bytes4(0xa9059cbb), msg.sender, ((afterBalance2 - beforeBalance1)))); // call transfer
uint256 value16 = success9;
if (!(success9 & (var_a == 0x01))) {
require(!((!success9) & (0x01)));
value16 = success9 & ((!returnData9.length) & (address(alita).code.length > 0));
}
var_d = var_d;
require(value16 != 0x0, SafeERC20FailedOperation());
emit Event_9ac1da82(msg.sender, 0x01, value14, (afterBalance2 - beforeBalance1));
stor_expr_d = 0x01;
}
}
}
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.
// 0x045f4a6e => Unknown_045f4a6e()
// 0x0d1a0c3b => reinvestAll()
// 0x1109a836 => Unknown_1109a836(address)
// 0x1171bda9 => recoverERC20(address,address,uint256)
// 0x11abb038 => Unknown_11abb038(uint256,uint256)
// 0x153b0d1e => setBlacklist(address,bool)
// 0x1789d235 => Unknown_1789d235(address)
// 0x17f8dd50 => burnExecutor()
// 0x1b007283 => Unknown_1b007283()
// 0x1f258e0e => Unknown_1f258e0e(address,uint256,uint256,uint256)
// 0x2155e468 => Unknown_2155e468()
// 0x23d90078 => Unknown_23d90078()
// 0x249d39e9 => BPS()
// 0x24b97601 => Unknown_24b97601()
// 0x27a099d8 => getOperators()
// 0x2afcf480 => invest(uint256)
// 0x2d5c3eb4 => unresolved_2d5c3eb4()
// 0x2f48ab7d => usdt()
// 0x38289e9f => Unknown_38289e9f(uint256,uint256)
// 0x3f4b7440 => Unknown_3f4b7440()
// 0x3f4ba83a => unpause()
// 0x435263ef => ecosystemWallet()
// 0x48ff7389 => teamLevel(address)
// 0x4e627e62 => referralRegistry()
// 0x50ab016e => PERIODS()
// 0x53deb3d6 => burnBps()
// 0x5a193ca7 => Unknown_5a193ca7()
// 0x5c975abb => paused()
// 0x5d78650e => getAccountData(address)
// 0x5e9a2975 => unresolved_5e9a2975(uint256)
// 0x65c6dba8 => Unknown_65c6dba8()
// 0x683738da => hasBurned()
// 0x6f76ffdf => Unknown_6f76ffdf()
// 0x705420be => Unknown_705420be(address,uint256,uint256)
// 0x715018a6 => renounceOwnership()
// 0x735e0223 => Unknown_735e0223(address)
// 0x7519a60d => levelTeamThresholds(uint256)
// 0x7abb9a7b => Unknown_7abb9a7b()
// 0x7b0f72dc => Unknown_7b0f72dc()
// 0x8456cb59 => pause()
// 0x874e0fc6 => Unknown_874e0fc6(uint256)
// 0x8da5cb5b => owner()
// 0x8dcbe22e => releaseBps()
// 0x91e482aa => Unknown_91e482aa()
// 0x92c3e01d => Unknown_92c3e01d()
// 0x94aa610d => Unknown_94aa610d(bool)
// 0x958e06ff => releaseOrderCount()
// 0x9870d7fe => addOperator(address)
// 0x9caa58b7 => Unknown_9caa58b7(address)
// 0x9ef8ba94 => Unknown_9ef8ba94()
// 0xa27154ba => MAX_DEPTH()
// 0xa8aa1b31 => pair()
// 0xabc9e946 => Unknown_abc9e946(uint256)
// 0xac8a584a => removeOperator(address)
// 0xac947e2d => alita()
// 0xb237e880 => nodeContract()
// 0xb2a77fed => Unknown_b2a77fed(address,uint256)
// 0xb58eda6d => Unknown_b58eda6d()
// 0xbb0c8298 => minimumAmount()
// 0xbf22ebb2 => setBurnConfig(address,address,uint16)
// 0xc9f62af2 => liquidityBps()
// 0xd3fa06dd => Unknown_d3fa06dd()
// 0xd84e1d8e => setCoreAddresses(address,address,address,address,address)
// 0xd966a184 => Unknown_d966a184(uint16,uint16,uint16,uint16)
// 0xda1a7be9 => burnReceiver()
// 0xdf8c90d6 => unresolved_df8c90d6(uint256)
// 0xe0017ec9 => Unknown_e0017ec9()
// 0xe1bd9ccb => lastBurnDay()
// 0xf2fde38b => transferOwnership(address)
// 0xf887ea40 => router()
// 0xf9f92be4 => blacklist(address)
// 0xff8c370d => claimRelease(uint256)
}