BNB Chain
0x3007616b952457cb8e4add2c6c6571d8207c9586
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x3007616b…207c958614.0 KB60.0 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x3007616b952457cb8e4add2c6c6571d8207c9586
2,196 lines · Click a variable or keyword to highlight its references · Click a line number to copy its link; Shift-click to copy a block link
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec// Decompilation incomplete: symbolic execution reached a configured deadline for 1 of 47 entry points (170000 ms contract budget): fallback// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { uint256 public constant authorizedSigner = 1266413396351342670250382188245944338459758987442; uint256 public constant unresolved_392baa88 = 500; address public constant usdt = address(0x55d398326f99059ff775485246999027b3197955); uint256 public constant unresolved_1a312010 = 10000; address public owner; // STORAGE[0x0] address public unresolved_a0b88e2e; // STORAGE[0x1] address public tokenWallet; // STORAGE[0x2] address public unresolved_c76a3099; // STORAGE[0x3] address public router; // STORAGE[0x4] address public unresolved_419b4eab; // STORAGE[0x5] uint256 public unresolved_18a98f0b; // STORAGE[0x6] mapping(bytes32 => bool) public usedDigest; // STORAGE[0x7] mapping(uint256 => bool) public usedWithdrawIds; // STORAGE[0x8] mapping(uint256 => uint256) public claimedAmounts; // STORAGE[0x9] uint256 public unresolved_43c88bfc; // STORAGE[0xa] uint256 public unresolved_c4854978; // STORAGE[0xb] uint256 public unresolved_0d0b0eb9; // STORAGE[0xc] mapping(uint256 => uint256) mapping_d; // STORAGE[0xd] mapping(address => bool) public userRecorded; // STORAGE[0xe] uint256 public unresolved_c9eab3a0; // STORAGE[0xf] uint256 public unresolved_2fd4e122; // STORAGE[0x10] uint256 public unresolved_ac06cf62; // STORAGE[0x11] bytes32 stor_expr_at; bytes32 stor_expr_au; uint256 stor_expr_ay; address stor_expr_az; uint256 stor_expr_ba; address stor_expr_bb; uint256 stor_expr_bc; address stor_expr_bd; uint256 stor_expr_bh; address stor_expr_bi; uint256 stor_expr_bj; address stor_expr_bk; uint256 stor_expr_bl; address stor_expr_bm; uint256 stor_expr_h; address stor_expr_i; uint256 stor_expr_j; address stor_expr_k; uint256 stor_expr_l; address stor_expr_m; uint256 stor_expr_n; address stor_expr_o; uint256 stor_expr_p; address stor_expr_q; uint256 stor_expr_r; address stor_expr_s; uint256 stor_expr_t; address stor_expr_u; uint256 stor_expr_v; address stor_expr_w; uint256 stor_expr_x; address stor_expr_y; event Event_5c735a43(uint256 indexed, uint256 indexed, uint256); event Event_debf078c(uint256 indexed, uint256 indexed, uint256, uint256); event Event_7a543762(uint256 indexed, uint256 indexed); event Event_46e2dff8(address indexed, uint256 indexed); event Event_4f16c308(uint256 indexed, uint256, uint256, uint256); event Event_eff31cfd(uint256 indexed, uint256); event Event_bdbd309b(address indexed, uint256 indexed); event Exchanged(address indexed, uint256, uint256); event Event_9bc578a4(address indexed, 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, "Ownable: caller is not the owner"); _; } receive() external payable { } fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x0201c52d)) { // Route to Unknown_0201c52d(address,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x76d05c36)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x0db3b854)) { // Route to Unknown_0db3b854() after replacing only msg.sig. __desolexSelectorShim(uint32(0xbb85c9c3)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x115d103e)) { // Route to Unknown_115d103e(address,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x7fa9cac9)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x150b943d)) { // Route to Unknown_150b943d(address,address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x80ff0486)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x251bb671)) { // Route to Unknown_251bb671(bool,bytes32,address,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x307566b6)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x31420e86)) { // Route to Unknown_31420e86(uint256,address,address,address,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x9cfaf152)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x379c160a)) { // Route to Unknown_379c160a(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x8c0d4728)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x525fcca4)) { // Route to Unknown_525fcca4(uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x0ec9c378)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x77b712ec)) { // Route to Unknown_77b712ec(bool,address) after replacing only msg.sig. __desolexSelectorShim(uint32(0xb8a12460)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x7df97f33)) { // Route to Unknown_7df97f33(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x6d115151)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xb3ad9a5a)) { // Route to Unknown_b3ad9a5a(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5085baa7)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xbe78e9e1)) { // Route to Unknown_be78e9e1(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xfa6b577a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xc5431a2c)) { // Route to Unknown_c5431a2c(address,address,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0xfa5d495b)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd5074d91)) { // Route to Unknown_d5074d91(bool,bytes32,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x3c6f3bbd)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf0a08460)) { // Route to Unknown_f0a08460(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0xcff91b7e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf33690ea)) { // Route to Unknown_f33690ea(address,address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x1631f397)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf7cc80e8)) { // Route to Unknown_f7cc80e8(address,bool,bool,address,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x3943c30c)); return; } } function Unknown_f7cc80e8(address recipient, bool arg1, bool arg2, address arg3, uint256 arg4, bytes memory arg5) public payable { if (!(msg.value)) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0xc0) { if (recipient == recipient) { if (arg3 == arg3) { if (!(arg5.length > 0xffffffffffffffff)) { if (((0x04 + arg5) + 0x1f) < msg.data.length) { if (!(arg5.length > 0xffffffffffffffff)) { if (((0x04 + arg5) + arg5 + 0x20) <= msg.data.length) { if (block.timestamp <= arg4) { require(arg1, "amount zero"); require(arg2 <= arg1, "ref amount overflow"); uint256 var_j; if (!(((var_j + 0x0120) > 0xffffffffffffffff) | ((var_j + 0x0120) < var_j))) { var_j = var_j + 0x0120; var_l = 0x07; if (!usedDigest[keccak256(abi.encode(msg.sender, (recipient), arg1, arg2, (arg3), arg4, address(this), block.chainid))]) { uint256 value0 = 0; if (!(0x41 != arg5.length)) { uint256 value109; if (msg.data[((0x04 + arg5) + 0x20) + 0x40] < 0x1b) { uint256 value110 = 0; if (!((0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1b && (0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1c)) { address var_k = ecrecover(keccak256(abi.encode(msg.sender, (recipient), arg1, arg2, (arg3), arg4, address(this), block.chainid)), bytes1(0x1b + (msg.data[((0x04 + arg5) + 0x20) + 0x40])), msg.data[(0x04 + arg5) + 0x20], msg.data[((0x04 + arg5) + 0x20) + 0x20]); require(var_l); value110 = var_k; } value109 = value110; } else { uint256 value111 = 0; if (!((0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1b && (0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1c)) { address var_k = ecrecover(keccak256(abi.encode(msg.sender, (recipient), arg1, arg2, (arg3), arg4, address(this), block.chainid)), bytes1(msg.data[((0x04 + arg5) + 0x20) + 0x40]), msg.data[(0x04 + arg5) + 0x20], msg.data[((0x04 + arg5) + 0x20) + 0x20]); require(var_l); value111 = var_k; } value109 = value111; } value0 = value109; } if (0xddd3f0d30aab2fbf1acc18c46affb78267e088b2 == (address(value0))) { usedDigest[keccak256(abi.encode(msg.sender, (recipient), arg1, arg2, (arg3), arg4, address(this), block.chainid))] = true; (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).transferFrom(msg.sender, address(this), arg1); // call if (success0) { if (success0) { if (0x20 > returnData0.length) { if (!(((var_j + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j))) { var_j = var_j + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (((var_j + returnData0.length) - var_j) >= 0x20) { if (var_j.length == var_j.length) { if (var_j.length != 0x0) { address account0 = address(0); if (!arg2) { account0 = recipient; } if (!(arg2 && recipient != address(0))) { (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success1); uint256 value2 = 0; uint256 value3 = 0; uint256 value4 = var_j.length; if (success1) { uint256 value1 = returnData1.length; if (returnData1.length >= 0x20) { value1 = 0x20; } if (((var_j + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value1) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value2 = 0x20; value3 = var_j; value4 = 0; } require(value4 != 0x0, "transfer to wallet fail"); uint256 value6; uint256 value7; uint256 value8; uint256 value9; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success2, bytes memory returnData2) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success2); uint256 value5 = 0; if (success2) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value5 = var_j; } value6 = value5; value7 = value5; value8 = value5; value9 = value5; } else { value6 = 0xffffffffffffffffffffffffffffffffffffffff; value7 = arg1 - arg2; value8 = 0x55d398326f99059ff775485246999027b3197955; value9 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value10 = 0; uint256 value11 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value10 = unresolved_c9eab3a0; value11 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_h < 0x010000000000000000)) _desolexPanic(65); stor_expr_h = stor_expr_h + 0x01; if (!(stor_expr_h < stor_expr_h)) _desolexPanic(50); stor_expr_i = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_i) | (msg.sender << 0); } return; } (bool success3, bytes memory returnData3) = address(0x55d398326f99059ff775485246999027b3197955).transfer(recipient, arg2); // call if (success3) { if (!(success3)) { } } } } } } } else { if (((var_j + 0x20) > 0xffffffffffffffff) | ((var_j + 0x20) < var_j)) _desolexPanic(65); var_j = var_j + 0x20; require(((var_j + 0x20) - var_j) >= 0x20); require(var_j.length == var_j.length); require(var_j.length != 0x0, "user transfer fail"); address account1 = address(0); if (!arg2) { account1 = recipient; } if (!(arg2 && recipient != address(0))) { (bool success6, bytes memory returnData6) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success6); uint256 value22 = 0; uint256 value23 = 0; uint256 value24 = var_j.length; if (success6) { uint256 value21 = returnData6.length; if (returnData6.length >= 0x20) { value21 = 0x20; } if (((var_j + ((value21 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value21 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value21 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value21) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value22 = 0x20; value23 = var_j; value24 = 0; } require(value24 != 0x0, "transfer to wallet fail"); uint256 value26; uint256 value27; uint256 value28; uint256 value29; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success7, bytes memory returnData7) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success7); uint256 value25 = 0; if (success7) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value25 = var_j; } value26 = value25; value27 = value25; value28 = value25; value29 = value25; } else { value26 = 0xffffffffffffffffffffffffffffffffffffffff; value27 = arg1 - arg2; value28 = 0x55d398326f99059ff775485246999027b3197955; value29 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value30 = 0; uint256 value31 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value30 = unresolved_c9eab3a0; value31 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_j < 0x010000000000000000)) _desolexPanic(65); stor_expr_j = stor_expr_j + 0x01; if (!(stor_expr_j < stor_expr_j)) _desolexPanic(50); stor_expr_k = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_k) | (msg.sender << 0); } return; } (bool success8, bytes memory returnData8) = address(0x55d398326f99059ff775485246999027b3197955).transfer(recipient, arg2); // call require(success8); if (!(success8)) { require(0 != 0x0, "transfer to wallet fail"); (bool success9, bytes memory returnData9) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success9); uint256 value33 = 0; uint256 value34 = 0; uint256 value35 = var_j.length; if (success9) { uint256 value32 = returnData9.length; if (returnData9.length >= 0x20) { value32 = 0x20; } if (((var_j + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value32) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value33 = 0x20; value34 = var_j; value35 = 0; } require(value35 != 0x0, "transfer to wallet fail"); uint256 value37; uint256 value38; uint256 value39; uint256 value40; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success10, bytes memory returnData10) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success10); uint256 value36 = 0; if (success10) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value36 = var_j; } value37 = value36; value38 = value36; value39 = value36; value40 = value36; } else { value37 = 0xffffffffffffffffffffffffffffffffffffffff; value38 = arg1 - arg2; value39 = 0x55d398326f99059ff775485246999027b3197955; value40 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value41 = 0; uint256 value42 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value41 = unresolved_c9eab3a0; value42 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_l < 0x010000000000000000)) _desolexPanic(65); stor_expr_l = stor_expr_l + 0x01; if (!(stor_expr_l < stor_expr_l)) _desolexPanic(50); stor_expr_m = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_m) | (msg.sender << 0); } return; } if (0x20 > returnData8.length) { if (((var_j + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData8.length) - var_j) >= 0x20); require(var_j.length == var_j.length); require(var_j.length != 0x0, "transfer to wallet fail"); (bool success11, bytes memory returnData11) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success11); uint256 value44 = 0; uint256 value45 = 0; uint256 value46 = var_j.length; if (success11) { uint256 value43 = returnData11.length; if (returnData11.length >= 0x20) { value43 = 0x20; } if (((var_j + ((value43 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value43 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value43 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value43) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value44 = 0x20; value45 = var_j; value46 = 0; } require(value46 != 0x0, "transfer to wallet fail"); uint256 value48; uint256 value49; uint256 value50; uint256 value51; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success12, bytes memory returnData12) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success12); uint256 value47 = 0; if (success12) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value47 = var_j; } value48 = value47; value49 = value47; value50 = value47; value51 = value47; } else { value48 = 0xffffffffffffffffffffffffffffffffffffffff; value49 = arg1 - arg2; value50 = 0x55d398326f99059ff775485246999027b3197955; value51 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value52 = 0; uint256 value53 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value52 = unresolved_c9eab3a0; value53 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_n < 0x010000000000000000)) _desolexPanic(65); stor_expr_n = stor_expr_n + 0x01; if (!(stor_expr_n < stor_expr_n)) _desolexPanic(50); stor_expr_o = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_o) | (msg.sender << 0); } } else { if (((var_j + 0x20) > 0xffffffffffffffff) | ((var_j + 0x20) < var_j)) _desolexPanic(65); var_j = var_j + 0x20; require(((var_j + 0x20) - var_j) >= 0x20); require(var_j.length == var_j.length); require(var_j.length != 0x0, "transfer to wallet fail"); (bool success13, bytes memory returnData13) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success13); uint256 value55 = 0; uint256 value56 = 0; uint256 value57 = var_j.length; if (success13) { uint256 value54 = returnData13.length; if (returnData13.length >= 0x20) { value54 = 0x20; } if (((var_j + ((value54 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value54 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value54 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value54) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value55 = 0x20; value56 = var_j; value57 = 0; } require(value57 != 0x0, "transfer to wallet fail"); uint256 value59; uint256 value60; uint256 value61; uint256 value62; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success14, bytes memory returnData14) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success14); uint256 value58 = 0; if (success14) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value58 = var_j; } value59 = value58; value60 = value58; value61 = value58; value62 = value58; } else { value59 = 0xffffffffffffffffffffffffffffffffffffffff; value60 = arg1 - arg2; value61 = 0x55d398326f99059ff775485246999027b3197955; value62 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value63 = 0; uint256 value64 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value63 = unresolved_c9eab3a0; value64 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_p < 0x010000000000000000)) _desolexPanic(65); stor_expr_p = stor_expr_p + 0x01; if (!(stor_expr_p < stor_expr_p)) _desolexPanic(50); stor_expr_q = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_q) | (msg.sender << 0); } } return; } } else { require(0 != 0x0, "user transfer fail"); address account2 = address(0); if (!arg2) { account2 = recipient; } if (!(arg2 && recipient != address(0))) { (bool success15, bytes memory returnData15) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success15); uint256 value66 = 0; uint256 value67 = 0; uint256 value68 = var_j.length; if (success15) { uint256 value65 = returnData15.length; if (returnData15.length >= 0x20) { value65 = 0x20; } if (((var_j + ((value65 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value65 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value65 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value65) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value66 = 0x20; value67 = var_j; value68 = 0; } require(value68 != 0x0, "transfer to wallet fail"); uint256 value70; uint256 value71; uint256 value72; uint256 value73; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success16, bytes memory returnData16) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success16); uint256 value69 = 0; if (success16) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value69 = var_j; } value70 = value69; value71 = value69; value72 = value69; value73 = value69; } else { value70 = 0xffffffffffffffffffffffffffffffffffffffff; value71 = arg1 - arg2; value72 = 0x55d398326f99059ff775485246999027b3197955; value73 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value74 = 0; uint256 value75 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value74 = unresolved_c9eab3a0; value75 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_r < 0x010000000000000000)) _desolexPanic(65); stor_expr_r = stor_expr_r + 0x01; if (!(stor_expr_r < stor_expr_r)) _desolexPanic(50); stor_expr_s = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_s) | (msg.sender << 0); } return; } (bool success17, bytes memory returnData17) = address(0x55d398326f99059ff775485246999027b3197955).transfer(recipient, arg2); // call require(success17); if (!(success17)) { require(0 != 0x0, "transfer to wallet fail"); (bool success18, bytes memory returnData18) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success18); uint256 value77 = 0; uint256 value78 = 0; uint256 value79 = var_j.length; if (success18) { uint256 value76 = returnData18.length; if (returnData18.length >= 0x20) { value76 = 0x20; } if (((var_j + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value76) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value77 = 0x20; value78 = var_j; value79 = 0; } require(value79 != 0x0, "transfer to wallet fail"); uint256 value81; uint256 value82; uint256 value83; uint256 value84; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success19, bytes memory returnData19) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success19); uint256 value80 = 0; if (success19) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value80 = var_j; } value81 = value80; value82 = value80; value83 = value80; value84 = value80; } else { value81 = 0xffffffffffffffffffffffffffffffffffffffff; value82 = arg1 - arg2; value83 = 0x55d398326f99059ff775485246999027b3197955; value84 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value85 = 0; uint256 value86 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value85 = unresolved_c9eab3a0; value86 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_t < 0x010000000000000000)) _desolexPanic(65); stor_expr_t = stor_expr_t + 0x01; if (!(stor_expr_t < stor_expr_t)) _desolexPanic(50); stor_expr_u = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_u) | (msg.sender << 0); } return; } if (0x20 > returnData17.length) { if (((var_j + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData17.length) - var_j) >= 0x20); require(var_j.length == var_j.length); require(var_j.length != 0x0, "transfer to wallet fail"); (bool success20, bytes memory returnData20) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success20); uint256 value88 = 0; uint256 value89 = 0; uint256 value90 = var_j.length; if (success20) { uint256 value87 = returnData20.length; if (returnData20.length >= 0x20) { value87 = 0x20; } if (((var_j + ((value87 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value87 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value87 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value87) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value88 = 0x20; value89 = var_j; value90 = 0; } require(value90 != 0x0, "transfer to wallet fail"); uint256 value92; uint256 value93; uint256 value94; uint256 value95; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success21, bytes memory returnData21) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success21); uint256 value91 = 0; if (success21) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value91 = var_j; } value92 = value91; value93 = value91; value94 = value91; value95 = value91; } else { value92 = 0xffffffffffffffffffffffffffffffffffffffff; value93 = arg1 - arg2; value94 = 0x55d398326f99059ff775485246999027b3197955; value95 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value96 = 0; uint256 value97 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value96 = unresolved_c9eab3a0; value97 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_v < 0x010000000000000000)) _desolexPanic(65); stor_expr_v = stor_expr_v + 0x01; if (!(stor_expr_v < stor_expr_v)) _desolexPanic(50); stor_expr_w = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_w) | (msg.sender << 0); } } else { if (((var_j + 0x20) > 0xffffffffffffffff) | ((var_j + 0x20) < var_j)) _desolexPanic(65); var_j = var_j + 0x20; require(((var_j + 0x20) - var_j) >= 0x20); require(var_j.length == var_j.length); require(var_j.length != 0x0, "transfer to wallet fail"); (bool success22, bytes memory returnData22) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, arg1 - arg2); // call require(success22); uint256 value99 = 0; uint256 value100 = 0; uint256 value101 = var_j.length; if (success22) { uint256 value98 = returnData22.length; if (returnData22.length >= 0x20) { value98 = 0x20; } if (((var_j + ((value98 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value98 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value98 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value98) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { value99 = 0x20; value100 = var_j; value101 = 0; } require(value101 != 0x0, "transfer to wallet fail"); uint256 value103; uint256 value104; uint256 value105; uint256 value106; if (arg3 != address(0)) { require(tokenWallet.code.length); (bool success23, bytes memory returnData23) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg3, arg1 - arg2); // call require(success23); uint256 value102 = 0; if (success23) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value102 = var_j; } value103 = value102; value104 = value102; value105 = value102; value106 = value102; } else { value103 = 0xffffffffffffffffffffffffffffffffffffffff; value104 = arg1 - arg2; value105 = 0x55d398326f99059ff775485246999027b3197955; value106 = arg3; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value107 = 0; uint256 value108 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value107 = unresolved_c9eab3a0; value108 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_x < 0x010000000000000000)) _desolexPanic(65); stor_expr_x = stor_expr_x + 0x01; if (!(stor_expr_x < stor_expr_x)) _desolexPanic(50); stor_expr_y = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_y) | (msg.sender << 0); } } return; } } } } } } } } } } } } } } } function Unknown_f33690ea(address arg0, address arg1) public onlyOwner { require((!(!(arg0))), "token zero"); require((!(!(arg1))), "recipient zero"); (bool success0, bytes memory returnData0) = tokenWallet.balance(arg0); // staticcall require(success0); uint256 value1 = 0; uint256 var_c; uint256 value2 = var_c.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value0) - var_c) >= 0x20); } else { value1 = var_c; value2 = 0; } require(value2 != 0x0, "wallet no balance"); require(tokenWallet.code.length); (bool success1, bytes memory returnData1) = tokenWallet.withdraw(arg0, arg1, value2); // call require(success1); if (!(success1)) { return; } if (!(var_c <= 0xffffffffffffffff)) _desolexPanic(65); require(!(0)); } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function Unknown_f0a08460(address arg0) public onlyOwner { emit Event_bdbd309b(unresolved_419b4eab, arg0); unresolved_419b4eab = arg0; } function Unknown_d5074d91(bool arg0, bytes32 arg1, uint256 arg2, bytes memory arg3) public { require(((0x04 + arg3) + 0x1f) < msg.data.length); require(((0x04 + arg3) + arg3 + 0x20) <= msg.data.length); require(arg1 != 0x0, "id zero"); require(arg0, "amount zero"); require((!(block.timestamp > arg2)), "expired"); var_b = 0x08; require(!usedWithdrawIds[arg1], "already used"); require(arg3 == 0x41, "bad sig length"); uint256 var_j; if (((var_j + 0xe0) > 0xffffffffffffffff) | ((var_j + 0xe0) < var_j)) _desolexPanic(65); var_j = var_j + 0xe0; uint256 value0 = 0; if (!(0x41 != arg3.length)) { uint256 value5; if (msg.data[((0x04 + arg3) + 0x20) + 0x40] < 0x1b) { uint256 value6 = 0; if (!((0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg3) + 0x20) + 0x40))) != 0x1b && (0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg3) + 0x20) + 0x40))) != 0x1c)) { address var_a = ecrecover(keccak256(abi.encode(msg.sender, arg0, arg1, arg2, address(this), block.chainid)), bytes1(0x1b + (msg.data[((0x04 + arg3) + 0x20) + 0x40])), msg.data[(0x04 + arg3) + 0x20], msg.data[((0x04 + arg3) + 0x20) + 0x20]); require(var_b); value6 = var_a; } value5 = value6; } else { uint256 value7 = 0; if (!((0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg3) + 0x20) + 0x40))) != 0x1b && (0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg3) + 0x20) + 0x40))) != 0x1c)) { address var_a = ecrecover(keccak256(abi.encode(msg.sender, arg0, arg1, arg2, address(this), block.chainid)), bytes1(msg.data[((0x04 + arg3) + 0x20) + 0x40]), msg.data[(0x04 + arg3) + 0x20], msg.data[((0x04 + arg3) + 0x20) + 0x20]); require(var_b); value7 = var_a; } value5 = value7; } value0 = value5; } require(0xddd3f0d30aab2fbf1acc18c46affb78267e088b2 == (address(value0)), "invalid signature"); usedWithdrawIds[arg1] = true; claimedAmounts[arg1] = arg0; (bool success0, bytes memory returnData0) = tokenWallet.balance(0x55d398326f99059ff775485246999027b3197955); // staticcall require(success0); uint256 value2 = 0; uint256 value3 = var_j.length; if (success0) { uint256 value1 = returnData0.length; if (0x20 <= returnData0.length) { value1 = 0x20; } if (((var_j + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value1) - var_j) >= 0x20); } else { value2 = var_j; value3 = 0; } require(value3 >= arg0, "insufficient reserve"); require(tokenWallet.code.length); (bool success1, bytes memory returnData1) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, msg.sender, arg0); // call require(success1); uint256 value4 = 0; if (success1) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(!(0)); } else { value4 = var_j; } emit Event_debf078c(msg.sender, arg1, arg0, arg2); } function Unknown_c5431a2c(address arg0, address arg1, bool arg2) public onlyOwner { require((!(!(arg0))), "token zero"); require((!(!(arg1))), "recipient zero"); require(arg2, "amount zero"); require(tokenWallet.code.length); (bool success0, bytes memory returnData0) = tokenWallet.withdraw(arg0, arg1, arg2); // call require(success0); if (!(success0)) { return; } if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); require(!(0)); } function Unknown_be78e9e1(uint256 arg0) public view returns (bytes memory) { uint256 value0 = 0; uint256 var_a; uint256 value1 = var_a + 0x20; uint256 value2 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0d)))); while (true) { if (value0 >= mapping_d[arg0]) { break; } value0 = 0x01 + value0; value1 = value1 + 0x20; value2 = 0x01 + value2; } if (((var_a + (((value1 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((value1 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); uint256 value3 = 0; uint256 value4 = var_a + 0x20; uint256 value5 = (var_a + 0x20) + 0x20; while (true) { var_a = var_a + (((value1 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (value3 >= var_a.length) { break; } value3 = 0x01 + value3; value4 = 0x20 + value4; value5 = 0x20 + value5; } return abi.encodePacked(0x20, var_a.length); } function Unknown_b3ad9a5a(address arg0) public onlyOwner { require(arg0 != address(0), "gv zero"); emit Event_46e2dff8(unresolved_a0b88e2e, arg0); unresolved_a0b88e2e = arg0; } function setTokenWallet(address newAddress) public onlyOwner { tokenWallet = newAddress; } function setShareRate(uint256 arg0, uint256 arg1, uint256 arg2) public onlyOwner { unresolved_43c88bfc = (arg0) ? 1 : 0; unresolved_c4854978 = (arg1) ? 1 : 0; unresolved_0d0b0eb9 = (arg2) ? 1 : 0; require(arg0 + arg1 + arg2 == 0x2710, "rate sum not 100%"); } function Unknown_7df97f33(uint256 arg0) public onlyOwner { require(arg0 <= (unresolved_c4854978 + unresolved_0d0b0eb9), "retain too high"); unresolved_18a98f0b = (arg0) ? 1 : 0; } function Unknown_77b712ec(bool arg0, address recipient) public onlyOwner { require(arg0, "batchSize zero"); while (true) { if (!(arg0 && unresolved_c9eab3a0 >= unresolved_2fd4e122)) { (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall require(success0); uint256 value1 = 0xffffffffffffffffffffffffffffffffffffffff; uint256 var_c; uint256 value2 = var_c.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value0) - var_c) >= 0x20); } else { value1 = var_c; value2 = 0; } if (value2 == 0) { return; } (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).transfer(recipient, value2); // call require(success1); if (!(success1)) { return; } if (returnData1.length < 0x20) { if (((var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData1.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } bool transferSucceeded = abi.decode(returnData1, (bool)); require(!(transferSucceeded - transferSucceeded)); return; break; } if (unresolved_ac06cf62 >= mapping_d[unresolved_2fd4e122]) { if (unresolved_2fd4e122 > (unresolved_2fd4e122 + 0x01)) { _desolexPanic(17); break; } unresolved_2fd4e122 = unresolved_2fd4e122 + 0x01; unresolved_ac06cf62 = 0; } else { uint256 value3 = unresolved_ac06cf62; while (true) { if (!(value3 < mapping_d[unresolved_2fd4e122] && arg0 || value3 >= mapping_d[unresolved_2fd4e122] && unresolved_ac06cf62 < mapping_d[unresolved_2fd4e122])) { break; } if (value3 >= mapping_d[unresolved_2fd4e122]) { _desolexPanic(50); break; } (bool success2, bytes memory returnData2) = address(0x55d398326f99059ff775485246999027b3197955).allowance(address(stor_expr_at >> 0), address(this)); // staticcall if (!success2) { revert(); break; } uint256 value5 = 0; uint256 value6 = var_c.length; if (success2) { uint256 value4 = returnData2.length; if (0x20 <= returnData2.length) { value4 = 0x20; } if (((var_c + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value4) - var_c) >= 0x20); } else { value5 = var_c; value6 = 0; } (bool success3, bytes memory returnData3) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(stor_expr_at >> 0)); // staticcall if (!success3) { revert(); break; } uint256 value8 = 0; uint256 value9 = var_c.length; if (success3) { uint256 value7 = returnData3.length; if (0x20 <= returnData3.length) { value7 = 0x20; } if (((var_c + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value7) - var_c) >= 0x20); } else { value8 = var_c; value9 = 0; } uint256 value10 = value9; if (value6 < value9) { value10 = value6; } if (value10 != 0x0) { (bool success4, bytes memory returnData4) = address(0x55d398326f99059ff775485246999027b3197955).transferFrom(address(stor_expr_at >> 0), address(this), value10); // call if (!success4) { revert(); break; } if (success4) { if (0x20 > returnData4.length) { if (((var_c + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) { _desolexPanic(65); break; } var_c = var_c + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (((var_c + returnData4.length) - var_c) < 0x20) { revert(); break; } } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) { _desolexPanic(65); break; } var_c = var_c + 0x20; if (((var_c + 0x20) - var_c) < 0x20) { revert(); break; } } if (var_c.length - var_c.length != 0) { revert(); break; } if (var_c.length == 0) { revert("transferFrom user failed"); break; } } else { revert("transferFrom user failed"); break; } if (0x0 > 0x0 + value10) { _desolexPanic(17); break; } if (arg0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff > arg0) { _desolexPanic(17); break; } } if (unresolved_ac06cf62 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } unresolved_ac06cf62 = 0x01 + unresolved_ac06cf62; value3 = unresolved_ac06cf62; } } } } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(owner, address(0)); owner = address(0); } function Unknown_525fcca4(uint256 arg0, uint256 arg1) public view returns (address) { require(arg1 < mapping_d[arg0]); if (!((arg1 < mapping_d[arg0]))) _desolexPanic(50); return address(stor_expr_au >> 0); } function withdrawAllToken(address token, address arg1) public onlyOwner { uint256 value0 = 0; if (!(token)) { value0 = 0xffffffffffffffffffffffffffffffffffffffff; } require(token != address(0) && arg1 != address(0)); (bool success0, bytes memory returnData0) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success0); uint256 value2 = 0; uint256 var_c; uint256 value3 = var_c.length; if (success0) { uint256 value1 = returnData0.length; if (0x20 <= returnData0.length) { value1 = 0x20; } if (((var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value1) - var_c) >= 0x20); } else { value2 = var_c; value3 = 0; } require(value3 != 0x0); (bool success1, bytes memory returnData1) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg1, value3)); // call transfer require(success1); if (!(success1)) { return; } if (returnData1.length < 0x20) { if (((var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData1.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } bool transferSucceeded = abi.decode(returnData1, (bool)); require(!(transferSucceeded - transferSucceeded)); } function Unknown_379c160a(address arg0) public returns (uint256) { (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).allowance(arg0, address(this)); // staticcall require(success0); uint256 value1 = 0x24; uint256 var_d; uint256 value2 = var_d.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + value0) - var_d) >= 0x20); } else { value1 = var_d; value2 = 0; } (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(arg0); // staticcall require(success1); uint256 value4 = 0; uint256 value5 = var_d.length; if (success1) { uint256 value3 = returnData1.length; if (0x20 <= returnData1.length) { value3 = 0x20; } if (((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_d + value3) - var_d) >= 0x20); } else { value4 = var_d; value5 = 0; } uint256 value6 = value5; if (value2 < value5) { value6 = value2; } return value6; } function Unknown_31420e86(uint256 amount, address arg1, address arg2, address recipient, uint256 arg4, bytes memory arg5) public payable { if (!(msg.value)) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0xc0) { if (arg1 == arg1) { if (arg2 == arg2) { if (recipient == recipient) { if (!(arg5.length > 0xffffffffffffffff)) { if (((0x04 + arg5) + 0x1f) < msg.data.length) { if (!(arg5.length > 0xffffffffffffffff)) { if (((0x04 + arg5) + arg5 + 0x20) <= msg.data.length) { if (!(block.timestamp > arg4)) { if (amount != 0x0) { require(arg1 != address(0) && recipient != address(0), "zero recipient"); uint256 var_j; if (!(((var_j + 0x0120) > 0xffffffffffffffff) | ((var_j + 0x0120) < var_j))) { var_j = var_j + 0x0120; var_l = 0x07; if (!usedDigest[keccak256(abi.encode(msg.sender, amount, (arg1), (arg2), (recipient), arg4, address(this), block.chainid))]) { uint256 value0 = 0; if (!(0x41 != arg5.length)) { uint256 value62; if (msg.data[((0x04 + arg5) + 0x20) + 0x40] < 0x1b) { uint256 value63 = 0; if (!((0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1b && (0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1c)) { address var_k = ecrecover(keccak256(abi.encode(msg.sender, amount, (arg1), (arg2), (recipient), arg4, address(this), block.chainid)), bytes1(0x1b + (msg.data[((0x04 + arg5) + 0x20) + 0x40])), msg.data[(0x04 + arg5) + 0x20], msg.data[((0x04 + arg5) + 0x20) + 0x20]); require(var_l); value63 = var_k; } value62 = value63; } else { uint256 value64 = 0; if (!((0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1b && (0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg5) + 0x20) + 0x40))) != 0x1c)) { address var_k = ecrecover(keccak256(abi.encode(msg.sender, amount, (arg1), (arg2), (recipient), arg4, address(this), block.chainid)), bytes1(msg.data[((0x04 + arg5) + 0x20) + 0x40]), msg.data[(0x04 + arg5) + 0x20], msg.data[((0x04 + arg5) + 0x20) + 0x20]); require(var_l); value64 = var_k; } value62 = value64; } value0 = value62; } if ((value0 & 0xffffffffffffffffffffffffffffffffffffffff) == 0xddd3f0d30aab2fbf1acc18c46affb78267e088b2) { usedDigest[keccak256(abi.encode(msg.sender, amount, (arg1), (arg2), (recipient), arg4, address(this), block.chainid))] = true; (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).transferFrom(msg.sender, address(this), amount); // call if (success0) { if (!(success0)) { require(0 != 0x0, "user transferFrom fail"); if ((((amount * unresolved_0d0b0eb9) / amount) == unresolved_0d0b0eb9) | !amount) { if (((amount * unresolved_c4854978) / 0x2710) <= (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710))) { (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).transfer(tokenWallet, (amount * unresolved_43c88bfc) / 0x2710); // call if (success1) { if (!(success1)) { require(0 != 0x0, "transfer to wallet fail"); if (tokenWallet.code.length != 0) { (bool success2, bytes memory returnData2) = tokenWallet.withdraw(0x55d398326f99059ff775485246999027b3197955, arg1, (amount * unresolved_43c88bfc) / 0x2710); // call if (success2) { uint256 value1 = 0; if (success2) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value1 = var_j; } if (!(arg2)) { if ((((amount * unresolved_18a98f0b) / amount) == unresolved_18a98f0b) | !amount) { if (((amount * unresolved_18a98f0b) / 0x2710) < (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710))) { if (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) <= (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710))) { if ((amount * unresolved_18a98f0b) / 0x2710 == 0) { if ((unresolved_c76a3099 != address(0)) && ((0xffffffffffffffffffffffffffffffffffffffff & router) != 0x0)) { if (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >= 0x02) { if (!(((var_j + 0x60) > 0xffffffffffffffff) | ((var_j + 0x60) < var_j))) { var_j = var_j + 0x60; var_t = msg.data[4:68]; if (var_j.length != 0x0) { if (0x01 < var_j.length) { (bool success3, bytes memory returnData3) = unresolved_c76a3099.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf if (success3) { uint256 value3 = 0; uint256 value8 = var_j.length; if (success3) { uint256 value2 = returnData3.length; if (0x20 <= returnData3.length) { value2 = 0x20; } if (((var_j + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value2) - var_j) >= 0x20); } else { value3 = var_j; value8 = 0; } (bool success4, bytes memory returnData4) = address(0x55d398326f99059ff775485246999027b3197955).approve(address(router), 0); // call require(success4); uint256 value4 = 0; uint256 value5; if (success4) { uint256 value65 = var_j.length; if (0x20 > returnData4.length) { if (((var_j + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData4.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_y == var_y); value65 = var_y; } value5 = value65; } else { value4 = var_j; value5 = 0; } require(value5 != 0x0, "approve0"); (bool success5, bytes memory returnData5) = address(0x55d398326f99059ff775485246999027b3197955).approve(address(router), (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01)); // call require(success5); uint256 value6 = 0; uint256 value7; if (success5) { uint256 value66 = var_j.length; if (0x20 > returnData5.length) { if (((var_j + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData5.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_ab == var_ab); value66 = var_ab; } value7 = value66; } else { value6 = var_j; value7 = 0; } require(value7 != 0x0, "approve"); require(router.code.length); if (0 >= var_j.length) { (bool success6, bytes memory returnData6) = router.Unknown_5c11d795(((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01, 0, 0xa0, address(this), block.timestamp, var_j.length); // call if (success6) { uint256 value9 = 0; if (success6) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value9 = var_j; } (bool success7, bytes memory returnData7) = unresolved_c76a3099.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf if (success7) { if (!(success7)) { require(0 - value8, "swap nem zero"); (bool success8, bytes memory returnData8) = unresolved_c76a3099.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success8); uint256 value11 = 0; uint256 value12 = var_j.length; if (success8) { uint256 value10 = returnData8.length; if (0x20 <= returnData8.length) { value10 = 0x20; } if (((var_j + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value10) - var_j) >= 0x20); } else { value11 = var_j; value12 = 0; } uint256 value13 = 0; uint256 value14 = value12; if ((0 - value8) <= value12) { value13 = value12; value14 = 0 - value8; } require(value14 > 0x0de0b6b3a7640000, "nem too small"); (bool success9, bytes memory returnData9) = unresolved_c76a3099.call(abi.encodeWithSelector(bytes4(0x095ea7b3), address(router), 0)); // call approve require(success9); uint256 value15 = 0; uint256 value16; if (success9) { uint256 value70 = var_j.length; if (0x20 > returnData9.length) { if (((var_j + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData9.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_y == var_y); value70 = var_y; } value16 = value70; } else { value15 = var_j; value16 = 0; } require(value16 != 0x0, "approve0"); (bool success10, bytes memory returnData10) = unresolved_c76a3099.call(abi.encodeWithSelector(bytes4(0x095ea7b3), address(router), (value14 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000))); // call approve require(success10); uint256 value17 = 0; uint256 value18; if (success10) { uint256 value71 = var_j.length; if (0x20 > returnData10.length) { if (((var_j + ((returnData10.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData10.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData10.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData10.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_ab == var_ab); value71 = var_ab; } value18 = value71; } else { value17 = var_j; value18 = 0; } require(value18 != 0x0, "approve"); (bool success11, bytes memory returnData11) = address(0x55d398326f99059ff775485246999027b3197955).approve(address(router), 0); // call require(success11); uint256 value19 = 0; uint256 value20; if (success11) { uint256 value72 = var_j.length; if (0x20 > returnData11.length) { if (((var_j + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData11.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_y == var_y); value72 = var_y; } value20 = value72; } else { value19 = var_j; value20 = 0; } require(value20 != 0x0, "approve0"); (bool success12, bytes memory returnData12) = address(0x55d398326f99059ff775485246999027b3197955).approve(address(router), (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) - (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01))); // call require(success12); uint256 value21 = 0; uint256 value22; if (success12) { uint256 value73 = var_j.length; if (0x20 > returnData12.length) { if (((var_j + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData12.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_ab == var_ab); value73 = var_ab; } value22 = value73; } else { value21 = var_j; value22 = 0; } require(value22 != 0x0, "approve"); (bool success13, bytes memory returnData13) = router.call(abi.encodeWithSelector(bytes4(0xe8e33700), unresolved_c76a3099, 0x55d398326f99059ff775485246999027b3197955, value14 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000, (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710)) - (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01), 0, 0, recipient, block.timestamp)); // call addLiquidity require(success13); uint256 value24 = 0; uint256 value25 = var_j.length; uint256 value26 = var_au; uint256 value27 = var_t; if (success13) { uint256 value23 = returnData13.length; if (0x60 <= returnData13.length) { value23 = 0x60; } if (((var_j + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value23) - var_j) >= 0x60); } else { value24 = var_j; value25 = 0; value26 = 0; value27 = 0; } require(value26 != 0x0, "lp zero"); emit Event_4f16c308(recipient, value27, value25, value26); if (!(unresolved_419b4eab)) { require(unresolved_a0b88e2e.code.length); (bool success14, bytes memory returnData14) = unresolved_a0b88e2e.release(msg.sender, amount); // call require(success14); uint256 value28 = 0; if (success14) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value28 = var_j; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value29 = 0; uint256 value30 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value29 = unresolved_c9eab3a0; value30 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_ay < 0x010000000000000000)) _desolexPanic(65); stor_expr_ay = stor_expr_ay + 0x01; if (!(stor_expr_ay < stor_expr_ay)) _desolexPanic(50); stor_expr_az = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_az) | (msg.sender << 0); } } else { (bool success15, bytes memory returnData15) = unresolved_c76a3099.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success15); uint256 value32 = 0; uint256 value33 = var_j.length; if (success15) { uint256 value31 = returnData15.length; if (0x20 <= returnData15.length) { value31 = 0x20; } if (((var_j + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value31) - var_j) >= 0x20); } else { value32 = var_j; value33 = 0; } (bool success16, bytes memory returnData16) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall require(success16); uint256 value35 = 0; uint256 value36 = var_j.length; if (success16) { uint256 value34 = returnData16.length; if (0x20 <= returnData16.length) { value34 = 0x20; } if (((var_j + ((value34 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value34 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value34 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value34) - var_j) >= 0x20); } else { value35 = var_j; value36 = 0; } address account0 = address(0); uint256 value39 = 0; uint256 value40 = value33 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000; if (value33 > 0xde0b6b3a7640000) { (bool success17, bytes memory returnData17) = unresolved_c76a3099.call(abi.encodeWithSelector(bytes4(0xa9059cbb), unresolved_c76a3099, value33 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000)); // call transfer require(success17); uint256 value37 = 0; uint256 value38 = var_j.length; if (success17) { if (0x20 > returnData17.length) { if (((var_j + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData17.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData17.length) - var_j) >= 0x20); } else { if (((var_j + 0x20) > 0xffffffffffffffff) | ((var_j + 0x20) < var_j)) _desolexPanic(65); var_j = var_j + 0x20; require(((var_j + 0x20) - var_j) >= 0x20); } require(var_j.length == var_j.length); } else { value37 = var_j; value38 = 0; } require(value38 != 0x0, "dust nem"); } else { account0 = unresolved_c76a3099; value39 = value33; value40 = 0; } uint256 value43 = 0x04; if (value36 != 0x0) { (bool success18, bytes memory returnData18) = address(0x55d398326f99059ff775485246999027b3197955).transfer(unresolved_419b4eab, value36); // call require(success18); uint256 value41 = 0; uint256 value42 = var_j.length; if (success18) { if (0x20 > returnData18.length) { if (((var_j + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData18.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData18.length) - var_j) >= 0x20); } else { if (((var_j + 0x20) > 0xffffffffffffffff) | ((var_j + 0x20) < var_j)) _desolexPanic(65); var_j = var_j + 0x20; require(((var_j + 0x20) - var_j) >= 0x20); } require(var_j.length == var_j.length); } else { value41 = var_j; value42 = 0; } require(value42 != 0x0, "dust usdt"); } else { value43 = 0x55d398326f99059ff775485246999027b3197955; } uint256 value74 = 0; if (value40 != 0x0) { flag4 = value36 != 0x0; } if ((value40 != 0x0) || (value36 != 0x0)) { emit Event_9bc578a4(unresolved_419b4eab, value36, value40); require(unresolved_a0b88e2e.code.length); (bool success19, bytes memory returnData19) = unresolved_a0b88e2e.release(msg.sender, amount); // call require(success19); uint256 value44 = 0; if (success19) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value44 = var_j; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value45 = 0; uint256 value46 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value45 = unresolved_c9eab3a0; value46 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_ba < 0x010000000000000000)) _desolexPanic(65); stor_expr_ba = stor_expr_ba + 0x01; if (!(stor_expr_ba < stor_expr_ba)) _desolexPanic(50); stor_expr_bb = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bb) | (msg.sender << 0); } } else { require(unresolved_a0b88e2e.code.length); (bool success20, bytes memory returnData20) = unresolved_a0b88e2e.release(msg.sender, amount); // call require(success20); uint256 value47 = 0; if (success20) { if (!(var_j <= 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j; require(0x0 == 0x0); } else { value47 = var_j; } if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value48 = 0; uint256 value49 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value48 = unresolved_c9eab3a0; value49 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_bc < 0x010000000000000000)) _desolexPanic(65); stor_expr_bc = stor_expr_bc + 0x01; if (!(stor_expr_bc < stor_expr_bc)) _desolexPanic(50); stor_expr_bd = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bd) | (msg.sender << 0); } } } emit Exchanged(msg.sender, amount, amount); return; } uint256 value50 = returnData7.length; if (0x20 <= returnData7.length) { value50 = 0x20; } if (!(((var_j + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j))) { var_j = var_j + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (((var_j + value50) - var_j) >= 0x20) { if ((var_j.length - value8) <= var_j.length) { if (var_j.length - value8 != 0) { if (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) - (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01) <= (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710))) { (bool success21, bytes memory returnData21) = unresolved_c76a3099.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf if (success21) { uint256 value52 = 0; uint256 value53 = var_j.length; if (success21) { uint256 value51 = returnData21.length; if (0x20 <= returnData21.length) { value51 = 0x20; } if (((var_j + ((value51 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((value51 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((value51 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + value51) - var_j) >= 0x20); } else { value52 = var_j; value53 = 0; } uint256 value54 = 0; uint256 value55 = value53; if ((var_j.length - value8) <= value53) { value54 = value53; value55 = var_j.length - value8; } if (value55 > 0x0de0b6b3a7640000) { if ((value55 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000) <= value55) { (bool success22, bytes memory returnData22) = unresolved_c76a3099.call(abi.encodeWithSelector(bytes4(0x095ea7b3), address(router), 0)); // call approve require(success22); uint256 value56 = 0; uint256 value57; if (success22) { uint256 value67 = var_j.length; if (0x20 > returnData22.length) { if (((var_j + ((returnData22.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData22.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData22.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData22.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_y == var_y); value67 = var_y; } value57 = value67; } else { value56 = var_j; value57 = 0; } require(value57 != 0x0, "approve0"); (bool success23, bytes memory returnData23) = unresolved_c76a3099.call(abi.encodeWithSelector(bytes4(0x095ea7b3), address(router), (value55 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000))); // call approve require(success23); uint256 value58 = 0; uint256 value59; if (success23) { uint256 value68 = var_j.length; if (0x20 > returnData23.length) { if (((var_j + ((returnData23.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData23.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData23.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData23.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_ab == var_ab); value68 = var_ab; } value59 = value68; } else { value58 = var_j; value59 = 0; } require(value59 != 0x0, "approve"); (bool success24, bytes memory returnData24) = address(0x55d398326f99059ff775485246999027b3197955).approve(address(router), 0); // call if (success24) { uint256 value60 = 0; uint256 value61; if (success24) { uint256 value69 = var_j.length; if (0x20 > returnData24.length) { if (((var_j + ((returnData24.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((returnData24.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((returnData24.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + returnData24.length) - var_j) >= 0x20); require(var_j.length == var_j.length); } else { if (((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_j)) _desolexPanic(65); var_j = var_j + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_j + 0x20) - var_j) >= 0x20); require(var_y == var_y); value69 = var_y; } value61 = value69; } else { value60 = var_j; value61 = 0; } if (value61 != 0x0) { (bool success25, bytes memory returnData25) = address(0x55d398326f99059ff775485246999027b3197955).approve(address(router), (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) - (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01))); // call if (success25 && !(success25)) { require(0 != 0x0, "approve"); router.addLiquidity(unresolved_c76a3099, 0x55d398326f99059ff775485246999027b3197955, value55 + 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000, (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710)) - (((amount * unresolved_c4854978) / 0x2710) + ((amount * unresolved_0d0b0eb9) / 0x2710) - ((amount * unresolved_18a98f0b) / 0x2710) >> 0x01), 0, 0, recipient, block.timestamp); // call } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } function Unknown_251bb671(bool arg0, bytes32 arg1, address recipient, uint256 arg3, bytes memory arg4) public { require(((0x04 + arg4) + 0x1f) < msg.data.length); require(((0x04 + arg4) + arg4 + 0x20) <= msg.data.length); require((!(block.timestamp > arg3)), "expired"); require(arg0, "amount zero"); require(arg1 != 0x0, "orderId zero"); require((!(!(recipient))), "recipient zero"); uint256 var_i; if (((var_i + 0x0100) > 0xffffffffffffffff) | ((var_i + 0x0100) < var_i)) _desolexPanic(65); var_i = var_i + 0x0100; var_k = 0x07; require(!usedDigest[keccak256(abi.encode(msg.sender, arg0, arg1, (recipient), arg3, address(this), block.chainid))], "sig replay"); uint256 value0 = 0; if (!(0x41 != arg4.length)) { uint256 value7; if (msg.data[((0x04 + arg4) + 0x20) + 0x40] < 0x1b) { uint256 value8 = 0; if (!((0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg4) + 0x20) + 0x40))) != 0x1b && (0xff & 0x1b + BYTE(0x0, CALLDATALOAD(((0x04 + arg4) + 0x20) + 0x40))) != 0x1c)) { address var_j = ecrecover(keccak256(abi.encode(msg.sender, arg0, arg1, (recipient), arg3, address(this), block.chainid)), bytes1(0x1b + (msg.data[((0x04 + arg4) + 0x20) + 0x40])), msg.data[(0x04 + arg4) + 0x20], msg.data[((0x04 + arg4) + 0x20) + 0x20]); require(var_k); value8 = var_j; } value7 = value8; } else { uint256 value9 = 0; if (!((0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg4) + 0x20) + 0x40))) != 0x1b && (0xff & BYTE(0x0, CALLDATALOAD(((0x04 + arg4) + 0x20) + 0x40))) != 0x1c)) { address var_j = ecrecover(keccak256(abi.encode(msg.sender, arg0, arg1, (recipient), arg3, address(this), block.chainid)), bytes1(msg.data[((0x04 + arg4) + 0x20) + 0x40]), msg.data[(0x04 + arg4) + 0x20], msg.data[((0x04 + arg4) + 0x20) + 0x20]); require(var_k); value9 = var_j; } value7 = value9; } value0 = value7; } require(0xddd3f0d30aab2fbf1acc18c46affb78267e088b2 == (address(value0)), "invalid signature"); usedDigest[keccak256(abi.encode(msg.sender, arg0, arg1, (recipient), arg3, address(this), block.chainid))] = true; (bool success0, bytes memory returnData0) = unresolved_a0b88e2e.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, recipient, arg0)); // call transferFrom require(success0); if (!(success0)) { require(0, "gv transferFrom fail"); if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value1 = 0; uint256 value2 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value1 = unresolved_c9eab3a0; value2 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_bh < 0x010000000000000000)) _desolexPanic(65); stor_expr_bh = stor_expr_bh + 0x01; if (!(stor_expr_bh < stor_expr_bh)) _desolexPanic(50); stor_expr_bi = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bi) | (msg.sender << 0); } emit Event_5c735a43(msg.sender, arg1, arg0); return; } if (0x20 > returnData0.length) { if (((var_i + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_i + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_i)) _desolexPanic(65); var_i = var_i + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_i + returnData0.length) - var_i) >= 0x20); require(var_i.length == var_i.length); require(var_i.length != 0x0, "gv transferFrom fail"); if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value3 = 0; uint256 value4 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value3 = unresolved_c9eab3a0; value4 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_bj < 0x010000000000000000)) _desolexPanic(65); stor_expr_bj = stor_expr_bj + 0x01; if (!(stor_expr_bj < stor_expr_bj)) _desolexPanic(50); stor_expr_bk = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bk) | (msg.sender << 0); } } else { if (((var_i + 0x20) > 0xffffffffffffffff) | ((var_i + 0x20) < var_i)) _desolexPanic(65); var_i = var_i + 0x20; require(((var_i + 0x20) - var_i) >= 0x20); require(var_i.length == var_i.length); require(var_i.length != 0x0, "gv transferFrom fail"); if (!userRecorded[msg.sender]) { userRecorded[msg.sender] = true; uint256 value5 = 0; uint256 value6 = keccak256(abi.encode((unresolved_c9eab3a0 + 0x01), 0x0d)); if (!(mapping_d[unresolved_c9eab3a0] < 0x01f4)) { unresolved_c9eab3a0 = unresolved_c9eab3a0 + 0x01; } else { value5 = unresolved_c9eab3a0; value6 = keccak256(abi.encode(unresolved_c9eab3a0, 0x0d)); } if (!(stor_expr_bl < 0x010000000000000000)) _desolexPanic(65); stor_expr_bl = stor_expr_bl + 0x01; if (!(stor_expr_bl < stor_expr_bl)) _desolexPanic(50); stor_expr_bm = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_bm) | (msg.sender << 0); } } emit Event_5c735a43(msg.sender, arg1, arg0); } function withdrawBNB() public onlyOwner { require(address(this).balance != 0x0); (bool success0, bytes memory returnData0) = owner.call{ value: address(this).balance }(""); // call if (returnData0.length != 0x0) { if (!(returnData0.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); require(success0, "bnb withdraw fail"); return; } require(success0, "bnb withdraw fail"); } function Unknown_150b943d(address arg0, address arg1) public onlyOwner { require(arg0 != address(0) && arg1 != address(0), "lp cfg zero"); unresolved_c76a3099 = arg0; router = arg1; emit Event_7a543762(arg0, router); } function Unknown_115d103e(address arg0, bool arg1) public onlyOwner { require(tokenWallet.code.length); (bool success0, bytes memory returnData0) = tokenWallet.setAdmin(arg0, arg1); // call require(success0); if (success0) { if (!(var_d <= 0xffffffffffffffff)) _desolexPanic(65); require(!(0)); } } function Unknown_0db3b854() public onlyOwner { unresolved_2fd4e122 = 0; unresolved_ac06cf62 = 0; } function Unknown_0201c52d(address arg0, bool arg1) public onlyOwner { require(arg0 != address(0), "to zero"); require(arg1, "amount zero"); require(unresolved_a0b88e2e.code.length); (bool success0, bytes memory returnData0) = unresolved_a0b88e2e.release(arg0, arg1); // call require(success0); uint256 value0 = 0x20; if (success0) { if (!(var_d <= 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d; } else { value0 = var_d; } emit Event_eff31cfd(arg0, arg1); } function withdrawToken(address token, address arg1, uint256 arg2) public onlyOwner { uint256 value0 = 0; bool flag0 = !(!(arg1)); if (!(token)) { value0 = 0xffffffffffffffffffffffffffffffffffffffff; flag0 = !(!(token)); } require(flag0 && arg2 != 0x0, "invalid param"); (bool success0, bytes memory returnData0) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success0); uint256 value2 = 0; uint256 var_c; uint256 value3 = var_c.length; if (success0) { uint256 value1 = returnData0.length; if (0x20 <= returnData0.length) { value1 = 0x20; } if (((var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value1) - var_c) >= 0x20); } else { value2 = var_c; value3 = 0; } require(value3 >= arg2, "insufficient"); (bool success1, bytes memory returnData1) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), arg1, arg2)); // call transfer require(success1); if (!(success1)) { return; } if (returnData1.length < 0x20) { if (((var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData1.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } bool transferSucceeded = abi.decode(returnData1, (bool)); require(!(transferSucceeded - transferSucceeded)); } 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. // 0x01e33667 => withdrawToken(address,address,uint256) // 0x0201c52d => Unknown_0201c52d(address,bool) // 0x0d0b0eb9 => unresolved_0d0b0eb9() // 0x0db3b854 => Unknown_0db3b854() // 0x115d103e => Unknown_115d103e(address,bool) // 0x150b943d => Unknown_150b943d(address,address) // 0x18a98f0b => unresolved_18a98f0b() // 0x1a312010 => unresolved_1a312010() // 0x1d111d13 => withdrawBNB() // 0x251bb671 => Unknown_251bb671(bool,bytes32,address,uint256,bytes) // 0x29657b25 => usedWithdrawIds(uint256) // 0x2f48ab7d => usdt() // 0x2fd4e122 => unresolved_2fd4e122() // 0x31420e86 => Unknown_31420e86(uint256,address,address,address,uint256,bytes) // 0x379c160a => Unknown_379c160a(address) // 0x392baa88 => unresolved_392baa88() // 0x3aeebedb => withdrawAllToken(address,address) // 0x419b4eab => unresolved_419b4eab() // 0x43c88bfc => unresolved_43c88bfc() // 0x525fcca4 => Unknown_525fcca4(uint256,uint256) // 0x715018a6 => renounceOwnership() // 0x77b712ec => Unknown_77b712ec(bool,address) // 0x7df97f33 => Unknown_7df97f33(uint256) // 0x89782d2e => usedDigest(bytes32) // 0x8da5cb5b => owner() // 0x92192565 => setShareRate(uint256,uint256,uint256) // 0x98ffbcb5 => userRecorded(address) // 0x9f666d84 => claimedAmounts(uint256) // 0xa0b88e2e => unresolved_a0b88e2e() // 0xa621344a => setTokenWallet(address) // 0xac06cf62 => unresolved_ac06cf62() // 0xb3ad9a5a => Unknown_b3ad9a5a(address) // 0xbe78e9e1 => Unknown_be78e9e1(uint256) // 0xbff99c6c => tokenWallet() // 0xc4854978 => unresolved_c4854978() // 0xc5431a2c => Unknown_c5431a2c(address,address,bool) // 0xc76a3099 => unresolved_c76a3099() // 0xc771909c => authorizedSigner() // 0xc9eab3a0 => unresolved_c9eab3a0() // 0xd5074d91 => Unknown_d5074d91(bool,bytes32,uint256,bytes) // 0xf0a08460 => Unknown_f0a08460(address) // 0xf2fde38b => transferOwnership(address) // 0xf33690ea => Unknown_f33690ea(address,address) // 0xf7cc80e8 => Unknown_f7cc80e8(address,bool,bool,address,uint256,bytes) // 0xf887ea40 => router()}