Ethereum
0x6ee4a5cf335d3ed3df6dc7fdeed75e0c0735d2fd
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputEthereum · 0x6ee4a5cf…0735d2fd23.8 KB131.7 s
This result is permanently available athttps://decompiler.exvul.com/ethereum/0x6ee4a5cf335d3ed3df6dc7fdeed75e0c0735d2fd
2,385 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 64 entry points (170000 ms contract budget): f3da275d// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { bool public constant isController = true; uint256 public constant unresolved_d141d9fc = 1000000000000000000000000000000000000; uint256 stor_0; // STORAGE[0x0] address public admin; // STORAGE[0x1] mapping(bytes32 => bool) public unresolved_ae493409; // STORAGE[0x3] mapping(address => uint256) mapping_4; // STORAGE[0x4] mapping(address => bool) mapping_5; // STORAGE[0x5] bytes32 stor_6; // STORAGE[0x6] // DESOLEX_RAW_STORAGE: packed overlap: stor_6_0_19 address bytes 0..19 vs getDonkeyAddress address bytes 0..19 mapping(address => bool) public isPauseGuardian; // STORAGE[0x7] mapping(address => bool) public isMintPaused; // STORAGE[0x8] mapping(address => bool) public isBorrowPaused; // STORAGE[0x9] mapping(address => bool) public unresolved_b84375f2; // STORAGE[0xa] bool public transferGuardianPaused; // STORAGE[0xb] bytes 0 to 0 bool public seizeGuardianPaused; // STORAGE[0xb] bytes 1 to 1 mapping(address => uint256) public getLiquidationIncentiveOf; // STORAGE[0xc] mapping(address => uint256) public borrowCaps; // STORAGE[0xd] uint256 public closeFactorMantissa; // STORAGE[0xe] uint256 public unresolved_aeb18540; // STORAGE[0xf] address[] public allMarkets; // STORAGE[0x10] uint256 public unresolved_ae3c2b3c; // STORAGE[0x11] mapping(address => bool) public unresolved_7c1df719; // STORAGE[0x12] mapping(address => uint256) public unresolved_a7ad64fc; // STORAGE[0x13] mapping(address => uint256) public unresolved_c4b70610; // STORAGE[0x14] mapping(address => mapping(address => uint256)) public unresolved_9eea63a2; // STORAGE[0x15] mapping(address => mapping(address => uint256)) public unresolved_fd72410d; // STORAGE[0x16] mapping(address => uint256) public getCurrentMyDonkey; // STORAGE[0x17] mapping(address => bool) public unresolved_aadefd18; // STORAGE[0x18] mapping(address => bool) public isStakingContract; // STORAGE[0x19] mapping(address => uint256) public unresolved_3acc4eba; // STORAGE[0x1a] mapping(address => bool) mapping_expr_am; mapping(address => bool) mapping_expr_bs; mapping(address => bool) mapping_expr_dg; mapping(address => bool) mapping_expr_dj; mapping(address => bool) mapping_expr_dm; mapping(address => bool) mapping_expr_dp; mapping(address => bool) mapping_expr_dq; address stor_expr_ao; uint256 stor_expr_bb; bytes32 stor_expr_bc; address stor_expr_di; address stor_expr_dk; uint256 stor_expr_ds; bytes32 stor_expr_dt; bytes32 stor_expr_dv; bytes32 stor_expr_dw; event NewPriceOracle(address); event Event_3e44537d(uint256 indexed, address indexed, uint256, uint256); event MarketExited(address, address); event NewCloseFactor(uint256, uint256); event NewCollateralFactor(address, uint256, uint256); event NewAdmin(address); event NewBorrowCap(address indexed, uint256); event MarketListed(address); event Failure(uint256, uint256, uint256); event ActionPaused(address, string, bool); event MarketEntered(address, address); event NewGuardian(address); fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x33643592)) { // Route to Unknown_33643592(bytes,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x174b56b0)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x4321c741)) { // Route to Unknown_4321c741() after replacing only msg.sig. __desolexSelectorShim(uint32(0x1021a8d4)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x499ba641)) { // Route to Unknown_499ba641(bytes,bytes,bool,bool,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x29872fce)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x5b1500ca)) { // Route to Unknown_5b1500ca(address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x1cefc026)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x85353faf)) { // Route to Unknown_85353faf(bytes,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x20cb0caf)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xa78da04f)) { // Route to Unknown_a78da04f(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x0db30c7e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xc20ae451)) { // Route to Unknown_c20ae451(address,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x88846b88)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xcea4c2b2)) { // Route to Unknown_cea4c2b2(bytes,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x7ded0dce)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd5f8583e)) { // Route to Unknown_d5f8583e(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x23e938c4)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd97efd6b)) { // Route to Unknown_d97efd6b(bytes,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x02f4b138)); return; } revert(); } function _setCloseFactor(uint256 arg0) public payable returns (uint256) { require(msg.sender == admin, "E1"); emit NewCloseFactor(closeFactorMantissa, arg0); closeFactorMantissa = arg0; return 0; } function repayBorrowAllowed(address arg0, address arg1) public payable returns (uint256) { require(mapping_5[arg0], "E86"); uint256 var_c; var_c = 0x20 + var_c; var_c = 0x20 + var_c; require(arg0.code.length != 0x0); (bool success0, bytes memory returnData0) = arg0.borrowIndex(); // staticcall require(success0); require(!(returnData0.length < 0x20)); var_c = 0x40 + var_c; if (!(uint32(unresolved_c4b70610[arg0] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number)) { if (!(block.number - (0xffffffff & unresolved_c4b70610[arg0] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[arg0] > 0x0)) { if (block.number - (uint32(unresolved_c4b70610[arg0] / 0x0100000000000000000000000000000000000000000000000000000000)) == 0) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; unresolved_fd72410d[arg0][arg1] = var_c.length; if (var_c.length != 0) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x40 + var_c; if (!(var_n <= var_n)) { } } return 0; } else { var_c = 0x40 + var_c; var_a = var_a; if (block.number < 0x0100000000) { unresolved_c4b70610[arg0] = (uint224(unresolved_c4b70610[arg0])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; unresolved_fd72410d[arg0][arg1] = var_c.length; if (var_c.length != 0) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x40 + var_c; if (!(var_n <= var_n)) { } } return 0; } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { if (!(value1 < var_c.length)) { break; } value1 = 0x20 + value1; } if (0x1f & (var_c.length)) { } revert("block number exceeds 32 bits"); } } } } else { require(arg0.code.length != 0x0); (bool success1, bytes memory returnData1) = arg0.totalBorrows(); // staticcall require(success1); require(!(returnData1.length < 0x20)); var_c = 0x40 + var_c; uint256 value4 = 0x0de0b6b3a7640000 * var_c.length; if (!(var_c.length == 0x0 || 0x0de0b6b3a7640000 == 0x0)) { if (var_c.length != 0x0) { if (!(0x0de0b6b3a7640000 * var_c.length / var_c.length == 0x0de0b6b3a7640000)) { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { uint256 value3 = value1; if (!(value1 < var_c.length)) { break; } if (!((0x20 + value1) < var_c.length)) { break; } value1 = 0x20 + (0x20 + value1); value3 = 0x20 + value1; } if (0x1f & (var_c.length)) { } revert("multiplication overflow"); } } } } else { value4 = 0; } var_c = 0x40 + var_c; if (!(var_c.length != 0x0)) { } var_c = 0x40 + var_c; } } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { if (!(value1 < var_c.length)) { break; } value1 = 0x20 + value1; } if (0x1f & (var_c.length)) { } revert("subtraction underflow"); } } } function Unknown_33643592(bytes memory arg0, bool arg1) public payable returns (bool) { require(arg0 <= 0x100000000); require(!(((0x04 + arg0) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg0.length > 0x0100000000) | ((0x20 + (0x04 + arg0)) + (arg0.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require((0x1 == isPauseGuardian[msg.sender] || msg.sender == admin), "E1"); uint256 value0 = 0; while (true) { if (!(value0 < arg0.length)) { break; } if (!(value0 < arg0.length)) { break; } unresolved_aadefd18[address((0x20 * value0) + (0x20 + arg0))] = arg1; value0 = 0x01 + value0; } return arg1; } function setPauseGuardian(address account, bool enabled) public payable returns (uint256) { require(msg.sender == admin, "E1"); isPauseGuardian[account] = enabled; emit NewGuardian(account); return 0; } function setMintPaused(address account, bool enabled) public payable returns (bool) { bool flag0 = msg.sender == admin; if (msg.sender != admin) { flag0 = 0x01 == (!(!(isPauseGuardian[msg.sender]))); } require(flag0, "E1"); require(mapping_5[account], "E86"); isMintPaused[account] = enabled; emit ActionPaused(account, 0x60, isMintPaused[account], 0x04, 0x4d696e7400000000000000000000000000000000000000000000000000000000); return enabled; } function getBlockNumber() public view returns (uint256) { return block.number; } function Unknown_4321c741() public view returns (address) { return address(stor_6); } function initialize(address arg0, address arg1) public payable { bool value0 = bytes1(stor_0 / 0x0100); if (!(bytes1(stor_0 / 0x0100))) { value0 = !(address(this).code.length); } require((value0 != 0x0 || (0xff & stor_0) == 0x0), "Initializable: contract is already initialized"); if (!(bytes1(stor_0 / 0x0100))) { stor_0 = 0x01 | ((0x0100 | (stor_0 & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff))) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } admin = arg0; stor_6 = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_6) | arg1; if (!(bytes1(stor_0 / 0x0100))) { stor_0 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff) & stor_0; } } function Unknown_499ba641(bytes memory arg0, bytes memory arg1, bool arg2, bool arg3, uint256 arg4) public payable { require(arg0 <= 0x100000000); require(!(((0x04 + arg0) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg0.length > 0x0100000000) | ((0x20 + (0x04 + arg0)) + (arg0.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require(arg1 <= 0x100000000); require(!(((0x04 + arg1) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg1.length > 0x0100000000) | ((0x20 + (0x04 + arg1)) + (arg1.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); var_a = var_a + (0x20 + (0x20 * arg1.length)); if (0 >= var_f) { if (arg4 == 0) { require(block.number > unresolved_aeb18540, "E95"); } else { require(isStakingContract[msg.sender]); } if (0 < var_f) { require(mapping_5[address(var_i)], "E86"); if (!arg2) { if (arg3) { var_a = 0x40 + var_a; if (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000) > (block.number)) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; if (0x20 < var_a.length) { if (0x40 < var_a.length) { } value0 = 0x40; } if (0x1f & (var_a.length)) { } revert("subtraction underflow"); } } bool flag0 = (block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) > 0; if ((block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) > 0) { flag0 = unresolved_7c1df719[address(var_i)] > 0; } if (!flag0) { if (block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000)) != 0) { var_a = 0x40 + var_a; var_g = var_g; if (!(block.number < 0x100000000)) { } unresolved_a7ad64fc[address(var_i)] = (uint224(unresolved_a7ad64fc[address(var_i)])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); } } else { require(address(var_i).code.length != 0x0); (bool success0, bytes memory returnData0) = var_i.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success0); require(!(returnData0.length < 0x20)); uint256 tokenSupply = abi.decode(returnData0, (uint256)); var_a = 0x40 + var_a; uint256 value1 = unresolved_7c1df719[address(var_i)] * (block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))); if (!((block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) == 0x0 || !unresolved_7c1df719[address(var_i)])) { if (((block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) != 0x0) && (!(unresolved_7c1df719[address(var_i)] * (block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) / (block.number - (uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) == unresolved_7c1df719[address(var_i)]))) { } } else { value1 = 0; } var_a = 0x20 + var_a; } if (0 < var_x) { var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = var_a + 0x20; unresolved_9eea63a2[address(var_i)][address(var_y)] = var_a.length; } } } else { var_a = 0x20 + var_a; var_a = 0x20 + var_a; require(address(var_i).code.length != 0x0); (bool success1, bytes memory returnData1) = address(var_i).borrowIndex(); // staticcall require(success1); require(!(returnData1.length < 0x20)); var_a = 0x40 + var_a; if (!(uint32(unresolved_c4b70610[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000) <= (block.number))) { } bool flag2 = (block.number - (uint32(unresolved_c4b70610[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) > 0; if ((block.number - (uint32(unresolved_c4b70610[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000))) > 0) { flag2 = unresolved_7c1df719[address(var_i)] > 0; } if (flag2) { require(address(var_i).code.length != 0x0); (bool success2, bytes memory returnData2) = address(var_i).totalBorrows(); // staticcall require(success2); require(!(returnData2.length < 0x20)); if ((var_a.length == 0x0) || (0x0de0b6b3a7640000 == 0x0)) { var_a = 0x40 + var_a; if (!(var_ac)) { } } } } } } else { if (0 < var_f) { require(unresolved_3acc4eba[address(var_ag)] < block.number); } } } function _setPriceOracle(address arg0) public payable returns (uint256) { require(msg.sender == admin, "E1"); stor_0 = (stor_0 & (0xffffffffffffffffffff0000000000000000000000000000000000000000ffff)) | (arg0 * 0x010000); emit NewPriceOracle(arg0); return 0; } function getAccountLiquidity(address arg0, bool arg1) public payable returns (bytes memory) { var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = 0x20 + (var_a + (0x20 * mapping_4[arg0])); if (mapping_4[arg0] == 0) { if (0 >= var_a.length) { uint256 value0 = var_s - var_t; uint256 value1 = 0; if (var_t > var_s) { value0 = 0; value1 = var_t - var_s; } return abi.encodePacked(0, value1, value0); } else { require(address(var_y).code.length != 0x0); (bool success0, bytes memory returnData0) = address(var_y).getAccountSnapshot(arg0); // staticcall require(success0); require(!(returnData0.length < 0x80)); require(value2 == 0x0, "E82"); var_a = var_a + 0x20; var_a = 0x20 + var_a; require(address(var_y).code.length != 0x0); (bool success1, bytes memory returnData1) = address(var_y).underlyingSymbol(); // staticcall require(success1); require(!(returnData1.length < 0x20)); require(address(stor_0 / 0x010000).code.length != 0x0); (bool success2, bytes memory returnData2) = address(stor_0 / 0x010000).getUnderlyingPrice(var_a.length); // staticcall require(success2); require(!(returnData2.length < 0x20)); require(value7 != 0x0, "E94"); var_a = var_a + 0x20; var_a = 0x20 + var_a; } } else { } } function Unknown_5b1500ca(address recipient, uint256 arg1) public payable { require(msg.sender == admin, "E1"); require(address(stor_6).code.length != 0x0); (bool success0, bytes memory returnData0) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success0); require(!(returnData0.length < 0x20)); uint256 accountBalance = abi.decode(returnData0, (uint256)); if ((arg1 != 0x0) && (arg1 <= accountBalance)) { require(address(stor_6).code.length != 0x0); (bool success1, bytes memory returnData1) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, arg1)); // call transfer require(success1); require(!(returnData1.length < 0x20)); require(0 == 0x0, "E96"); } require(arg1 == 0x0, "E96"); } function liquidateBorrowAllowed(address arg0, address arg1, address arg2, address arg3, uint256 arg4) public payable returns (uint256) { bool flag0 = !(mapping_5[arg0]); if (mapping_5[arg0]) { flag0 = !(mapping_5[arg1]); } if (!flag0) { uint256 value0 = 0; if (mapping_5[arg1]) { if (!mapping_expr_am[arg3]) { mapping_expr_am[arg3] = true; mapping_4[arg3] = mapping_4[arg3] + 0x01; stor_expr_ao = arg1; emit MarketEntered(stor_expr_ao, arg3); } } else { value0 = 0x04; } if (value0 <= 0xa) { require(value0 == 0x0, "E89"); bool flag1 = !(unresolved_b84375f2[arg1]); if (unresolved_b84375f2[arg1]) { flag1 = !(unresolved_b84375f2[arg0]); } require(flag1, "E97"); var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + (var_e + (0x20 * mapping_4[arg2])); if (mapping_4[arg2] == 0) { if (0 >= var_e.length) { uint256 value1 = var_s - var_t; uint256 value2 = 0; if (var_t > var_s) { value1 = 0; value2 = var_t - var_s; } if (value1 != 0x0) { require(arg0.code.length != 0x0); (bool success0, bytes memory returnData0) = arg0.borrowBalanceStored(arg2); // staticcall require(success0); require(!(returnData0.length < 0x20)); var_e = var_e + 0x20; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x40 + var_e; if ((var_ab == 0x0) || (value3 == 0x0)) { uint256 value4 = 0; if (arg4 > (var_e.length / 0x0de0b6b3a7640000)) { value4 = 0x0a; } // duplicate declaration of value4 omitted } } else { return 0x02; } } else { require(address(var_ae).code.length != 0x0); (bool success1, bytes memory returnData1) = address(var_ae).getAccountSnapshot(arg2); // staticcall require(success1); require(!(returnData1.length < 0x80)); require(value5 == 0x0, "E82"); var_e = var_e + 0x20; var_e = 0x20 + var_e; require(address(var_ae).code.length != 0x0); (bool success2, bytes memory returnData2) = address(var_ae).underlyingSymbol(); // staticcall require(success2); require(!(returnData2.length < 0x20)); require(address(stor_0 / 0x010000).code.length != 0x0); (bool success3, bytes memory returnData3) = address(stor_0 / 0x010000).getUnderlyingPrice(var_e.length); // staticcall require(success3); require(!(returnData3.length < 0x20)); require(value10 != 0x0, "E94"); var_e = var_e + 0x20; var_e = 0x20 + var_e; } } else { } } } else { return 0x04; } } function _setMarketBorrowCaps(address[] memory arg0, uint256[] memory arg1) public payable { require(arg0 <= 0x100000000); require(!(((0x04 + arg0) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg0.length > 0x0100000000) | ((0x20 + (0x04 + arg0)) + (arg0.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require(arg1 <= 0x100000000); require(!(((0x04 + arg1) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg1.length > 0x0100000000) | ((0x20 + (0x04 + arg1)) + (arg1.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require(msg.sender == admin, "E1"); require((arg0.length != 0x0 && arg0 == arg1), "E84"); uint256 value0 = 0; while (true) { if (value0 >= arg0.length) { break; } if (!(value0 < arg1.length)) { break; } if (value0 >= arg0.length) { break; } borrowCaps[arg0[value0]] = arg1[value0]; if (value0 >= arg0.length) { break; } if (!(value0 < arg1.length)) { break; } emit NewBorrowCap(arg0[value0], arg1[value0]); value0 = 0x01 + value0; } } function setAdmin(address newAddress) public payable { require(msg.sender == admin, "E1"); admin = newAddress; emit NewAdmin(address(newAddress | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & admin))); } function Unknown_85353faf(bytes memory arg0, bytes memory arg1) public payable returns (uint256) { require(arg0 <= 0x100000000); require(!(((0x04 + arg0) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg0.length > 0x0100000000) | ((0x20 + (0x04 + arg0)) + (arg0.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require(arg1 <= 0x100000000); require(!(((0x04 + arg1) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg1.length > 0x0100000000) | ((0x20 + (0x04 + arg1)) + (arg1.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require(msg.sender == admin, "E1"); uint256 value0 = 0; while (true) { if (!(value0 < arg0.length)) { break; } if (!(value0 < arg1.length)) { break; } if (!(value0 < arg0.length)) { break; } getLiquidationIncentiveOf[address((0x20 * value0) + (0x20 + arg0))] = (0x20 * value0) + (0x20 + arg1); value0 = 0x01 + value0; } return 0; } function getAccountAssets(address arg0) public view returns (bytes memory) { address var_c; var_c = 0x20 + (var_c + (0x20 * mapping_4[arg0])); uint256 value2 = mapping_4[arg0]; uint256 value3 = keccak256(abi.encode(arg0, 0x04)); uint256 value4 = var_c + 0x20; if (mapping_4[arg0] != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x04))))) + 0x01; while (true) { if ((var_c + 0x20) + (0x20 * mapping_4[arg0]) <= value0) { break; } value0 = 0x20 + value0; value1 = value1 + 0x01; } value2 = (value0) ? 1 : 0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * mapping_4[arg0]); } uint256 value5 = 0; while (true) { if (!(value5 < (var_c.length * 0x20))) { break; } value5 = 0x20 + value5; } return abi.encodePacked(0x20, var_c.length); } function markets(address account) public view returns (bool) { return abi.encodePacked(!(!(mapping_5[account])), stor_expr_bb, !(!(bytes1(stor_expr_bc)))); } function _supportMarket(address arg0) public payable returns (uint256) { if ((!(msg.sender == admin)) && ((0x1 <= 0xa) && (0x12 <= 0x13))) { emit Failure(0x01, 0x12, 0); return 0x01; } if (!mapping_5[arg0]) { require(arg0.code.length != 0x0); (bool success0, bytes memory returnData0) = arg0.isDToken(); // staticcall require(success0); require(!(returnData0.length < 0x20)); uint256 value0 = 0; while (true) { uint256 var_f; var_f = var_f + 0x60; mapping_5[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & mapping_5[arg0]) | var_f.length; stor_expr_bb = var_g; stor_expr_bc = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_expr_bc) | (!(!(var_h))); if (value0 >= allMarkets.length) { break; } if (value0 >= allMarkets.length) { break; } require(!(address(allMarkets[value0]) == arg0), "E83"); value0 = 0x01 + value0; } allMarkets.push(address(arg0)); emit MarketListed(arg0); return 0; } else { if ((0x5 <= 0xa) && (0x11 <= 0x13)) { emit Failure(0x05, 0x11, 0); return 0x05; } } } function Unknown_a78da04f(uint256 arg0) public payable returns (uint256) { require(msg.sender == admin, "E1"); unresolved_aeb18540 = arg0; return arg0; } function getAllMarkets() public view returns (bytes memory) { uint256 var_a; var_a = var_a + (0x20 + (0x20 * allMarkets.length)); if (allMarkets.length != 0x0) { uint256 value1 = 0x20 + (0x20 + var_a); uint256 value2 = keccak256(abi.encode(0x10)) + 0x01; while (true) { if ((0x20 + var_a) + (0x20 * allMarkets.length) <= value1) { break; } value1 = 0x20 + value1; value2 = value2 + 0x01; } } uint256 value0 = 0; while (true) { if (!(value0 < (var_a.length * 0x20))) { break; } value0 = 0x20 + value0; } return abi.encodePacked(0x20, var_a.length); } function setBorrowPaused(address account, bool enabled) public payable returns (bool) { require(mapping_5[account], "E86"); bool flag0 = msg.sender == admin; if (msg.sender != admin) { flag0 = 0x01 == (!(!(isPauseGuardian[msg.sender]))); } require(flag0, "E1"); isBorrowPaused[account] = enabled; emit ActionPaused(account, 0x60, isBorrowPaused[account], 0x06, 0x426f72726f770000000000000000000000000000000000000000000000000000); return enabled; } function getDonkeyAddress() public view returns (address) { return address(stor_6); } function transferAllowed(address token, address arg1, address arg2, uint256 arg3) public payable returns (uint256) { require(!transferGuardianPaused, "E87"); require(mapping_5[token], "E86"); if (mapping_expr_bs[arg1]) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x20 + var_c; } if (0 != 0) { return 0; } if (!(uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number)) { if (!(block.number - (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[token] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000)) == 0) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; unresolved_9eea63a2[token][arg1] = var_c.length; } else { var_c = 0x40 + var_c; var_a = var_a; if (block.number < 0x0100000000) { unresolved_a7ad64fc[token] = (uint224(unresolved_a7ad64fc[token])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; unresolved_9eea63a2[token][arg1] = var_c.length; } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x20 + value0; } if (0x1f & (var_c.length)) { } revert("block number exceeds 32 bits"); } } } } else { require(token.code.length != 0x0); (bool success0, bytes memory returnData0) = token.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success0); require(!(returnData0.length < 0x20)); uint256 tokenSupply = abi.decode(returnData0, (uint256)); if (!(block.number == (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) || !unresolved_7c1df719[token])) { if (block.number != (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) { if (unresolved_7c1df719[token] * (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) / (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) == unresolved_7c1df719[token]) { var_c = 0x20 + var_c; if (tokenSupply > 0) { var_c = 0x20 + var_c; } else { var_c = 0x20 + var_c; var_c = var_c + 0x20; var_c = 0x20 + var_c; var_c = 0x40 + var_c; } } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x20 + value0; } if (0x1f & (var_c.length)) { } revert("multiplication overflow"); } } } } else { var_c = 0x20 + var_c; if (tokenSupply > 0) { var_c = 0x20 + var_c; } else { var_c = 0x20 + var_c; var_c = var_c + 0x20; var_c = 0x20 + var_c; var_c = 0x40 + var_c; } } } } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x20 + value0; } if (0x1f & (var_c.length)) { } revert("subtraction underflow"); } } } function Unknown_c20ae451(address arg0, bytes memory arg1) public payable { require(arg1 <= 0x100000000); require(!(((0x04 + arg1) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg1.length > 0x0100000000) | ((0x20 + (0x04 + arg1)) + (arg1.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); uint256 var_a; var_a = var_a + (0x20 + (0x20 * arg1.length)); require(block.number > unresolved_aeb18540, "E95"); var_a = 0x40 + var_a; if (0 < var_a.length) { uint256 value0 = 0; while (true) { if (value0 >= var_g) { break; } if (value0 >= var_g) { break; } require(unresolved_3acc4eba[address(var_i)] < (block.number)); value0 = 0x01 + value0; } require(block.number > unresolved_aeb18540, "E95"); uint256 value1 = 0; uint256 value3 = 0; uint256 value4 = 0x01; uint256 value5 = 0x01; uint256 value2 = var_a; uint256 value6 = var_a; while (true) { if (value1 >= var_k) { break; } if (value1 >= var_k) { break; } require(mapping_5[address(var_l)], "E86"); if (value5 == 0x0) { if (!(value4 == 0x0)) { var_a = 0x40 + var_a; if (uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value8 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value8 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("subtraction underflow"); } } if (!(block.number - (0xffffffff & unresolved_a7ad64fc[var_l] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[var_l] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[var_l] / 0x0100000000000000000000000000000000000000000000000000000000)) != 0) { var_a = 0x40 + var_a; var_h = var_h; if (!(block.number < 0x100000000)) { } unresolved_a7ad64fc[var_l] = (uint224(unresolved_a7ad64fc[var_l])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); } } else { require(address(var_l).code.length != 0x0); address var_ab = ecrecover(0x18160ddd00000000000000000000000000000000000000000000000000000000); require(success); require(!(ret0.length < 0x20)); uint256 tokenSupply = abi.decode(__desolex_call_data_3974, (uint256)); var_a = 0x40 + var_a; uint256 value9 = unresolved_7c1df719[var_l] * (block.number - (uint32(unresolved_a7ad64fc[var_l] / 0x0100000000000000000000000000000000000000000000000000000000))); if (!((block.number - (uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000))) == 0x0 || !unresolved_7c1df719[address(var_l)])) { if (((block.number - (uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000))) != 0x0) && (!(unresolved_7c1df719[address(var_l)] * (block.number - (uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000))) / (block.number - (uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000))) == unresolved_7c1df719[address(var_l)]))) { } } else { value9 = 0; } var_a = 0x20 + var_a; } uint256 value10 = 0; while (true) { if (!(value10 < var_a.length)) { break; } if (value10 >= var_ac) { break; } var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = var_a + 0x20; unresolved_9eea63a2[var_l][address(var_ad)] = var_a.length; if (!(var_ab == 0x0 && var_ab != 0x0)) { var_a = 0x20 + var_a; } else { var_a = 0x20 + var_a; } var_a = 0x20 + var_a; var_a = 0x40 + var_a; if (var_ah > var_ai) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value11 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value11 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("subtraction underflow"); } } require(address(var_l).code.length != 0x0); require(success); require(!(ret0.length < 0x20)); uint256 accountBalance = abi.decode(__desolex_call_data_3990, (uint256)); var_a = 0x40 + var_a; uint256 value13 = var_as * accountBalance; if (!(accountBalance == 0x0 || var_as == 0x0)) { if (accountBalance != 0x0) { if (!(var_as * accountBalance / accountBalance == var_as)) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value12 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value12 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("multiplication overflow"); } } } } else { value13 = 0; } var_a = 0x40 + var_a; if (!((value13 / 0xc097ce7bc90715b34b9f1000000000) + getCurrentMyDonkey[address(var_ad)] >= getCurrentMyDonkey[address(var_ad)])) { } getCurrentMyDonkey[address(var_ad)] = (value13 / 0xc097ce7bc90715b34b9f1000000000) + getCurrentMyDonkey[address(var_ad)]; emit Event_3e44537d(var_l, address(var_ad), value13 / 0xc097ce7bc90715b34b9f1000000000, var_a.length); if (value10 >= var_ac) { break; } if (value10 >= var_ac) { break; } require(address(stor_6).code.length != 0x0); (bool success0, bytes memory returnData0) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success0); require(!(returnData0.length < 0x20)); uint256 accountBalance1 = abi.decode(returnData0, (uint256)); if (!(getCurrentMyDonkey[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & var_ba)] != 0x0 && getCurrentMyDonkey[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & var_ba)] <= accountBalance1)) { if (value10 >= var_ac) { break; } getCurrentMyDonkey[address(var_bb)] = getCurrentMyDonkey[address(var_ad)]; } else { require(address(stor_6).code.length != 0x0); (bool success1, bytes memory returnData1) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(var_ad), getCurrentMyDonkey[address(var_ad)])); // call transfer require(success1); require(!(returnData1.length < 0x20)); if (value10 >= var_ac) { break; } getCurrentMyDonkey[address(var_bb)] = 0; } value10 = 0x01 + value10; } } } else { var_a = 0x20 + var_a; var_a = 0x20 + var_a; require(address(var_l).code.length != 0x0); require(success); require(!(ret0.length < 0x20)); var_a = 0x40 + var_a; if (!(uint32(unresolved_c4b70610[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000) <= block.number)) { } if ((block.number - (0xffffffff & unresolved_c4b70610[var_l] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0) && (unresolved_7c1df719[var_l] > 0x0)) { require(address(var_l).code.length != 0x0); require(success); require(!(ret0.length < 0x20)); if ((var_a.length == 0x0) || (0x0de0b6b3a7640000 == 0x0)) { var_a = 0x40 + var_a; if (!(var_bc)) { } } break; } if (block.number - (uint32(unresolved_c4b70610[var_l] / 0x0100000000000000000000000000000000000000000000000000000000)) == 0) { uint256 value15 = 0; while (true) { if (!(value15 < var_a.length)) { break; } if (value15 >= var_ac) { break; } var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = var_a + 0x20; unresolved_fd72410d[address(var_l)][address(var_bf)] = var_a.length; if (var_a.length != 0) { var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = 0x40 + var_a; if (!(var_bg <= var_bh)) { } } if (value15 >= var_ac) { break; } if (value15 >= var_ac) { break; } require(address(stor_6).code.length != 0x0); (bool success2, bytes memory returnData2) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success2); require(!(returnData2.length < 0x20)); uint256 accountBalance4 = abi.decode(returnData2, (uint256)); bool flag10 = getCurrentMyDonkey[address(var_bf)] != 0x0; if (getCurrentMyDonkey[address(var_bf)] != 0x0) { flag10 = !(getCurrentMyDonkey[address(var_bf)] > accountBalance4); } uint256 value19 = getCurrentMyDonkey[address(var_bf)]; if (flag10) { require(address(stor_6).code.length != 0x0); (bool success3, bytes memory returnData3) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(var_bf), getCurrentMyDonkey[address(var_bf)])); // call transfer require(success3); require(!(returnData3.length < 0x20)); value19 = 0; } if (value15 >= var_ac) { break; } getCurrentMyDonkey[address(var_bi)] = value19; value15 = 0x01 + value15; } if (!(value4 == 0x0)) { var_a = 0x40 + var_a; if (!(uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000) <= block.number)) { } if (!(block.number - (0xffffffff & unresolved_a7ad64fc[var_l] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[var_l] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[var_l] / 0x0100000000000000000000000000000000000000000000000000000000)) != 0) { var_a = 0x40 + var_a; var_h = var_h; if (!(block.number < 0x100000000)) { } unresolved_a7ad64fc[var_l] = (uint224(unresolved_a7ad64fc[var_l])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); } } else { require(address(var_l).code.length != 0x0); address var_ab = ecrecover(0x18160ddd00000000000000000000000000000000000000000000000000000000); require(success); require(!(ret0.length < 0x20)); uint256 tokenSupply1 = abi.decode(__desolex_call_data_3897, (uint256)); var_a = 0x40 + var_a; } uint256 value10 = 0; while (true) { if (!(value10 < var_a.length)) { break; } if (value10 >= var_ac) { break; } var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = var_a + 0x20; unresolved_9eea63a2[var_l][address(var_ad)] = var_a.length; if (!(var_ab == 0x0 && var_ab != 0x0)) { var_a = 0x20 + var_a; } else { var_a = 0x20 + var_a; } var_a = 0x20 + var_a; var_a = 0x40 + var_a; if (var_ah > var_ai) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value16 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value16 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("subtraction underflow"); } } require(address(var_l).code.length != 0x0); require(success); require(!(ret0.length < 0x20)); uint256 accountBalance2 = abi.decode(__desolex_call_data_3913, (uint256)); var_a = 0x40 + var_a; uint256 value18 = var_as * accountBalance2; if (!(accountBalance2 == 0x0 || var_as == 0x0)) { if (accountBalance2 != 0x0) { if (!(var_as * accountBalance2 / accountBalance2 == var_as)) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value17 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value17 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("multiplication overflow"); } } } } else { value18 = 0; } var_a = 0x40 + var_a; if (!((value18 / 0xc097ce7bc90715b34b9f1000000000) + getCurrentMyDonkey[address(var_ad)] >= getCurrentMyDonkey[address(var_ad)])) { } getCurrentMyDonkey[address(var_ad)] = (value18 / 0xc097ce7bc90715b34b9f1000000000) + getCurrentMyDonkey[address(var_ad)]; emit Event_3e44537d(var_l, address(var_ad), value18 / 0xc097ce7bc90715b34b9f1000000000, var_a.length); if (value10 >= var_ac) { break; } if (value10 >= var_ac) { break; } require(address(stor_6).code.length != 0x0); (bool success4, bytes memory returnData4) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success4); require(!(returnData4.length < 0x20)); uint256 accountBalance3 = abi.decode(returnData4, (uint256)); if (!(getCurrentMyDonkey[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & var_ba)] != 0x0 && getCurrentMyDonkey[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & var_ba)] <= accountBalance3)) { if (value10 >= var_ac) { break; } getCurrentMyDonkey[address(var_bb)] = getCurrentMyDonkey[address(var_ad)]; } else { require(address(stor_6).code.length != 0x0); (bool success5, bytes memory returnData5) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(var_ad), getCurrentMyDonkey[address(var_ad)])); // call transfer require(success5); require(!(returnData5.length < 0x20)); if (value10 >= var_ac) { break; } getCurrentMyDonkey[address(var_bb)] = 0; } value10 = 0x01 + value10; } } } else { var_a = 0x40 + var_a; var_h = var_h; if (!(block.number < 0x100000000)) { } uint256 value15 = 0; while (true) { unresolved_c4b70610[var_l] = (uint224(unresolved_c4b70610[var_l])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); if (!(value15 < var_a.length)) { break; } if (value15 >= var_ac) { break; } var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = var_a + 0x20; unresolved_fd72410d[address(var_l)][address(var_bf)] = var_a.length; if (var_a.length != 0) { var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = 0x40 + var_a; if (!(var_bg <= var_bh)) { } } if (value15 >= var_ac) { break; } if (value15 >= var_ac) { break; } require(address(stor_6).code.length != 0x0); (bool success6, bytes memory returnData6) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success6); require(!(returnData6.length < 0x20)); uint256 accountBalance7 = abi.decode(returnData6, (uint256)); bool flag15 = getCurrentMyDonkey[address(var_bf)] != 0x0; if (getCurrentMyDonkey[address(var_bf)] != 0x0) { flag15 = !(getCurrentMyDonkey[address(var_bf)] > accountBalance7); } uint256 value23 = getCurrentMyDonkey[address(var_bf)]; if (flag15) { require(address(stor_6).code.length != 0x0); (bool success7, bytes memory returnData7) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(var_bf), getCurrentMyDonkey[address(var_bf)])); // call transfer require(success7); require(!(returnData7.length < 0x20)); value23 = 0; } if (value15 >= var_ac) { break; } getCurrentMyDonkey[address(var_bi)] = value23; value15 = 0x01 + value15; } if (!(value4 == 0x0)) { var_a = 0x40 + var_a; if (!(uint32(unresolved_a7ad64fc[address(var_l)] / 0x0100000000000000000000000000000000000000000000000000000000) <= block.number)) { } if (!(block.number - (0xffffffff & unresolved_a7ad64fc[var_l] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[var_l] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[var_l] / 0x0100000000000000000000000000000000000000000000000000000000)) != 0) { var_a = 0x40 + var_a; var_h = var_h; if (!(block.number < 0x100000000)) { } unresolved_a7ad64fc[var_l] = (uint224(unresolved_a7ad64fc[var_l])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); } } else { require(address(var_l).code.length != 0x0); address var_ab = ecrecover(0x18160ddd00000000000000000000000000000000000000000000000000000000); require(success); require(!(ret0.length < 0x20)); uint256 tokenSupply2 = abi.decode(__desolex_call_data_3758, (uint256)); var_a = 0x40 + var_a; } uint256 value10 = 0; while (true) { if (!(value10 < var_a.length)) { break; } if (value10 >= var_ac) { break; } var_a = 0x20 + var_a; var_a = 0x20 + var_a; var_a = var_a + 0x20; unresolved_9eea63a2[var_l][address(var_ad)] = var_a.length; if (!(var_ab == 0x0 && var_ab != 0x0)) { var_a = 0x20 + var_a; } else { var_a = 0x20 + var_a; } var_a = 0x20 + var_a; var_a = 0x40 + var_a; if (var_ah > var_ai) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value20 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value20 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("subtraction underflow"); } } require(address(var_l).code.length != 0x0); require(success); require(!(ret0.length < 0x20)); uint256 accountBalance5 = abi.decode(__desolex_call_data_3774, (uint256)); var_a = 0x40 + var_a; uint256 value22 = var_as * accountBalance5; if (!(accountBalance5 == 0x0 || var_as == 0x0)) { if (accountBalance5 != 0x0) { if (!(var_as * accountBalance5 / accountBalance5 == var_as)) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value7 = 0x20; while (true) { uint256 value21 = value7; if (!(value7 < var_a.length)) { break; } if (!((0x20 + value7) < var_a.length)) { break; } value7 = 0x20 + (0x20 + value7); value21 = 0x20 + value7; } if (0x1f & (var_a.length)) { } revert("multiplication overflow"); } } } } else { value22 = 0; } var_a = 0x40 + var_a; if (!((value22 / 0xc097ce7bc90715b34b9f1000000000) + getCurrentMyDonkey[address(var_ad)] >= getCurrentMyDonkey[address(var_ad)])) { } getCurrentMyDonkey[address(var_ad)] = (value22 / 0xc097ce7bc90715b34b9f1000000000) + getCurrentMyDonkey[address(var_ad)]; emit Event_3e44537d(var_l, address(var_ad), value22 / 0xc097ce7bc90715b34b9f1000000000, var_a.length); if (value10 >= var_ac) { break; } if (value10 >= var_ac) { break; } require(address(stor_6).code.length != 0x0); (bool success8, bytes memory returnData8) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success8); require(!(returnData8.length < 0x20)); uint256 accountBalance6 = abi.decode(returnData8, (uint256)); if (!(getCurrentMyDonkey[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & var_ba)] != 0x0 && getCurrentMyDonkey[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & var_ba)] <= accountBalance6)) { if (value10 >= var_ac) { break; } getCurrentMyDonkey[address(var_bb)] = getCurrentMyDonkey[address(var_ad)]; } else { require(address(stor_6).code.length != 0x0); (bool success9, bytes memory returnData9) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(var_ad), getCurrentMyDonkey[address(var_ad)])); // call transfer require(success9); require(!(returnData9.length < 0x20)); if (value10 >= var_ac) { break; } getCurrentMyDonkey[address(var_bb)] = 0; } value10 = 0x01 + value10; } } } } value1 = 0x01 + value1; value3 = value3; value4 = value4; value5 = value5; value2 = value2; value6 = value6; } } } function liquidateCalculateSeizeTokens(address arg0, address arg1, uint256 arg2) public payable returns (bytes memory) { require(address(arg0).code.length != 0x0); (bool success0, bytes memory returnData0) = address(arg0).underlyingSymbol(); // staticcall require(success0); require(!(returnData0.length < 0x20)); require(address(stor_0 / 0x010000).code.length != 0x0); uint256 var_c; (bool success1, bytes memory returnData1) = address(stor_0 / 0x010000).getUnderlyingPrice(var_c.length); // staticcall require(success1); require(!(returnData1.length < 0x20)); require(address(arg1).code.length != 0x0); (bool success2, bytes memory returnData2) = address(arg1).underlyingSymbol(); // staticcall require(success2); require(!(returnData2.length < 0x20)); require(address(stor_0 / 0x010000).code.length != 0x0); (bool success3, bytes memory returnData3) = address(stor_0 / 0x010000).getUnderlyingPrice(var_c.length); // staticcall require(success3); require(!(returnData3.length < 0x20)); if (!(value1 == 0x0 || value3 == 0x0)) { require(address(arg1).code.length != 0x0); (bool success4, bytes memory returnData4) = address(arg1).exchangeRateStored(); // staticcall require(success4); require(!(returnData4.length < 0x20)); var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; var_c = 0x20 + var_c; } return abi.encodePacked(0x08, 0); } function claimDonkeyBehalfOf(address arg0, bool arg1) public payable returns (bool) { require(isStakingContract[msg.sender], "E1"); uint256 var_d; var_d = 0x40 + var_d; if (0 < var_d.length) { var_d = 0x20 + (var_d + (0x20 * allMarkets.length)); uint256 value0 = allMarkets.length; if (allMarkets.length != 0x0) { value0 = (allMarkets.length * 0x20) + (0x20 + var_d); } if (0 >= allMarkets.length) { return false; var_d = var_d + 0x20; if (0 != 0) { var_h = this.code[24346:24346]; } if (0 >= var_d.length) { if (0 >= var_d.length) { if (!arg1) { require(block.number > unresolved_aeb18540, "E95"); } else { require(isStakingContract[msg.sender]); } if (0 >= var_d.length) { return true; } else { require(mapping_5[address(var_k)], "E86"); var_d = 0x20 + var_d; var_d = 0x20 + var_d; require(address(var_k).code.length != 0x0); (bool success0, bytes memory returnData0) = address(var_k).borrowIndex(); // staticcall require(success0); require(!(returnData0.length < 0x20)); var_d = 0x40 + var_d; if (!(uint32(unresolved_c4b70610[address(var_k)] / 0x0100000000000000000000000000000000000000000000000000000000) <= (block.number))) { } bool flag2 = (block.number - (uint32(unresolved_c4b70610[address(var_k)] / 0x0100000000000000000000000000000000000000000000000000000000))) > 0; if ((block.number - (uint32(unresolved_c4b70610[address(var_k)] / 0x0100000000000000000000000000000000000000000000000000000000))) > 0) { flag2 = unresolved_7c1df719[address(var_k)] > 0; } if (flag2) { require(address(var_k).code.length != 0x0); (bool success1, bytes memory returnData1) = address(var_k).totalBorrows(); // staticcall require(success1); require(!(returnData1.length < 0x20)); if ((var_d.length == 0x0) || (0x0de0b6b3a7640000 == 0x0)) { var_d = 0x40 + var_d; if (!(var_v)) { } } } } } else { if (0 < var_d.length) { require(unresolved_3acc4eba[address(var_h)] < block.number); } } } else { } } else { uint256 value4 = 0; if ((unresolved_9eea63a2[address(allMarkets[0])][arg0] > 0) || (unresolved_fd72410d[address(allMarkets[0])][arg0] > 0)) { if ((0 < allMarkets.length) && (0 < var_d.length)) { } value4 = 0x01; } } } } function redeemVerify(uint256 arg0, uint256 arg1) public pure { require(!(arg1 == 0x0 && arg0 > 0x0), "redeemTokens zero"); } function Unknown_cea4c2b2(bytes memory arg0, bytes memory arg1) public payable { require(arg0 <= 0x100000000); require(!(((0x04 + arg0) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg0.length > 0x0100000000) | ((0x20 + (0x04 + arg0)) + (arg0.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); require(arg1 <= 0x100000000); require(!(((0x04 + arg1) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg1.length > 0x0100000000) | ((0x20 + (0x04 + arg1)) + (arg1.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); var_a = var_a + (0x20 + (0x20 * arg1.length)); require(msg.sender == admin, "E1"); if (0 < var_f) { if (0 < var_g) { if (!unresolved_7c1df719[address(var_i)]) { if (var_h != 0x0) { require(mapping_5[address(var_i)], "E86"); if ((!(uint224(unresolved_a7ad64fc[address(var_i)])) && !(uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000)))) { var_a = 0x40 + var_a; var_j = var_j; if (!(block.number < 0x100000000)) { } unresolved_a7ad64fc[address(var_i)] = (unresolved_a7ad64fc[address(var_i)] & (0xffffffff00000000000000000000000000000000000000000000000000000000) | (uint224(var_a.length)) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(var_s))); } if ((!(uint224(unresolved_c4b70610[address(var_i)])) && !(uint32(unresolved_c4b70610[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000)))) { var_a = 0x40 + var_a; var_j = var_j; if (block.number >= 0x0100000000) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; if (0x20 < var_a.length) { if (0x40 < var_a.length) { } value0 = 0x40; } if (0x1f & (var_a.length)) { } revert("block number exceeds 32 bits"); } } unresolved_c4b70610[address(var_i)] = (unresolved_c4b70610[address(var_i)] & (0xffffffff00000000000000000000000000000000000000000000000000000000) | (uint224(var_a.length)) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(var_s))); } } if (!(unresolved_7c1df719[address(var_i)] == var_h)) { unresolved_7c1df719[address(var_i)] = var_h; } } else { var_a = 0x20 + var_a; var_a = 0x20 + var_a; require(address(var_i).code.length != 0x0); (bool success0, bytes memory returnData0) = address(var_i).borrowIndex(); // staticcall require(success0); require(!(returnData0.length < 0x20)); var_a = 0x40 + var_a; if (!(uint32(unresolved_a7ad64fc[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000) <= block.number)) { } if (!(block.number - (0xffffffff & unresolved_a7ad64fc[var_i] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[var_i] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[var_i] / 0x0100000000000000000000000000000000000000000000000000000000)) != 0) { var_a = 0x40 + var_a; var_j = var_j; if (!(block.number < 0x100000000)) { } unresolved_a7ad64fc[var_i] = (uint224(unresolved_a7ad64fc[var_i])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); } } else { require(address(var_i).code.length != 0x0); (bool success1, bytes memory returnData1) = var_i.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success1); require(!(returnData1.length < 0x20)); uint256 tokenSupply = abi.decode(returnData1, (uint256)); var_a = 0x40 + var_a; } var_a = 0x40 + var_a; if (uint32(unresolved_c4b70610[address(var_i)] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value2 = 0x20; if (0x20 < var_a.length) { if (0x40 < var_a.length) { } value2 = 0x40; } if (0x1f & (var_a.length)) { } revert("subtraction underflow"); } } if (!(block.number - (0xffffffff & unresolved_c4b70610[var_i] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[var_i] > 0x0)) { if (block.number - (uint32(unresolved_c4b70610[var_i] / 0x0100000000000000000000000000000000000000000000000000000000)) != 0) { var_a = 0x40 + var_a; var_j = var_j; if (!(block.number < 0x100000000)) { if (!var_ah) { if (0x1f & var_ah) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value3 = 0x20; if (0x20 < var_ah) { if (0x40 < var_ah) { } value3 = 0x40; } if (0x1f & var_ah) { } revert("block number exceeds 32 bits"); } } unresolved_c4b70610[var_i] = (uint224(unresolved_c4b70610[var_i])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); } if (!(unresolved_7c1df719[address(var_i)] == var_h)) { unresolved_7c1df719[address(var_i)] = var_h; } } else { require(address(var_i).code.length != 0x0); (bool success2, bytes memory returnData2) = address(var_i).totalBorrows(); // staticcall require(success2); require(!(returnData2.length < 0x20)); var_a = 0x40 + var_a; uint256 value6 = 0x0de0b6b3a7640000 * var_a.length; if (!(var_a.length == 0x0 || 0x0de0b6b3a7640000 == 0x0)) { if (var_a.length != 0x0) { if (!(0x0de0b6b3a7640000 * var_a.length / var_a.length == 0x0de0b6b3a7640000)) { if (var_a.length == 0) { if (0x1f & (var_a.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value5 = 0x20; if (0x20 < var_a.length) { if (0x40 < var_a.length) { } value5 = 0x40; } if (0x1f & (var_a.length)) { } revert("multiplication overflow"); } } } } else { value6 = 0; } var_a = 0x40 + var_a; if (!(var_ap)) { } } } } } } function Unknown_d5f8583e(address arg0) public view returns (uint256) { return getCurrentMyDonkey[arg0]; } function Unknown_d97efd6b(bytes memory arg0, bool arg1) public payable returns (bool) { require(arg0 <= 0x100000000); require(!(((0x04 + arg0) + 0x20) > (0x04 + (msg.data.length - 0x04)))); require(!((arg0.length > 0x0100000000) | ((0x20 + (0x04 + arg0)) + (arg0.length * 0x20) > (0x04 + (msg.data.length - 0x04))))); bool flag0 = msg.sender == admin; if (msg.sender != admin) { flag0 = 0x01 == (!(!(isPauseGuardian[msg.sender]))); } require(flag0, "E1"); uint256 value0 = 0; while (true) { if (!(value0 < arg0.length)) { break; } if (!(value0 < arg0.length)) { break; } unresolved_b84375f2[address((0x20 * value0) + (0x20 + arg0))] = arg1; value0 = 0x01 + value0; } return arg1; } function borrowAllowed(address arg0, address arg1, uint256 arg2) public payable returns (uint256) { require(!unresolved_b84375f2[arg0], "E90"); require(!isBorrowPaused[arg0], "E91"); require(mapping_5[arg0], "E86"); if (!mapping_expr_dg[arg1]) { require(arg0 == msg.sender, "E1"); if (mapping_5[arg0]) { if (!mapping_expr_dg[arg1]) { mapping_expr_dg[arg1] = true; mapping_4[arg1] = mapping_4[arg1] + 0x01; stor_expr_di = arg0; emit MarketEntered(stor_expr_di, arg1); } require(mapping_expr_dj[arg1], "E89"); } else { return 0x04; require(mapping_expr_dj[arg1], "E89"); } } if (borrowCaps[arg0] == 0) { var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + (var_e + (0x20 * mapping_4[arg1])); } else { require(arg0.code.length != 0x0); (bool success0, bytes memory returnData0) = arg0.totalBorrows(); // staticcall require(success0); require(!(returnData0.length < 0x20)); var_e = 0x40 + var_e; if (arg2 + value0 >= value0) { require((arg2 + var_e.length) < borrowCaps[arg0], "E92"); var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = 0x20 + (var_e + (0x20 * mapping_4[arg1])); } else { if (var_e.length == 0) { if (0x1f & (var_e.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { if (!(value1 < var_e.length)) { break; } value1 = 0x20 + value1; } if (0x1f & (var_e.length)) { } revert("addition overflow"); } } } } function accountAssets(address arg0, uint256 arg1) public view returns (address) { if (arg1 < mapping_4[arg0]) { return stor_expr_dk; } } function _setCollateralFactor(address arg0, uint256 arg1) public payable returns (uint256) { require(msg.sender == admin, "E1"); if ((!mapping_5[arg0]) && ((0x4 <= 0xa) && (0x7 <= 0x13))) { emit Failure(0x04, 0x07, 0); return 0x04; } uint256 var_f; var_f = 0x20 + var_f; var_f = 0x20 + var_f; var_f = var_f + 0x20; if ((var_f.length < var_f.length) && ((0x3 <= 0xa) && (0x8 <= 0x13))) { emit Failure(0x03, 0x08, 0); return 0x03; } bool flag0 = arg1; if (arg1 != 0x0) { require(arg0.code.length != 0x0); (bool success0, bytes memory returnData0) = arg0.underlyingSymbol(); // staticcall require(success0); require(!(returnData0.length < 0x20)); require(address(stor_0 / 0x010000).code.length != 0x0); (bool success1, bytes memory returnData1) = address(stor_0 / 0x010000).getUnderlyingPrice(var_f.length); // staticcall require(success1); require(!(returnData1.length < 0x20)); flag0 = !var_f.length; } if (!flag0) { emit NewCollateralFactor(arg0, stor_expr_bb, arg1); stor_expr_bb = (arg1) ? 1 : 0; return 0; } else { if ((0x8 <= 0xa) && (0x9 <= 0x13)) { emit Failure(0x08, 0x09, 0); return 0x08; } } } function redeemAllowed(address token, address arg1, uint256 arg2) public payable { require(!unresolved_b84375f2[token], "E85"); require(mapping_5[token], "E86"); if (mapping_expr_dm[arg1]) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = 0x20 + var_c; } require(0x0 == 0x0, "E40"); if (!(uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number)) { if (!(block.number - (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[token] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000)) == 0) { var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; unresolved_9eea63a2[token][arg1] = var_c.length; } else { var_c = 0x40 + var_c; var_a = var_a; if (block.number < 0x0100000000) { unresolved_a7ad64fc[token] = (uint224(unresolved_a7ad64fc[token])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); var_c = 0x20 + var_c; var_c = 0x20 + var_c; var_c = var_c + 0x20; unresolved_9eea63a2[token][arg1] = var_c.length; } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x20 + value0; } if (0x1f & (var_c.length)) { } revert("block number exceeds 32 bits"); } } } } else { require(token.code.length != 0x0); (bool success0, bytes memory returnData0) = token.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success0); require(!(returnData0.length < 0x20)); uint256 tokenSupply = abi.decode(returnData0, (uint256)); if (!(block.number == (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) || !unresolved_7c1df719[token])) { if (block.number != (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) { if (unresolved_7c1df719[token] * (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) / (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) == unresolved_7c1df719[token]) { var_c = 0x20 + var_c; if (tokenSupply > 0) { var_c = 0x20 + var_c; } else { var_c = 0x20 + var_c; var_c = var_c + 0x20; var_c = 0x20 + var_c; var_c = 0x40 + var_c; } } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x20 + value0; } if (0x1f & (var_c.length)) { } revert("multiplication overflow"); } } } } else { var_c = 0x20 + var_c; if (tokenSupply > 0) { var_c = 0x20 + var_c; } else { var_c = 0x20 + var_c; var_c = var_c + 0x20; var_c = 0x20 + var_c; var_c = 0x40 + var_c; } } } } else { if (var_c.length == 0) { if (0x1f & (var_c.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value0 = 0x20; while (true) { if (!(value0 < var_c.length)) { break; } value0 = 0x20 + value0; } if (0x1f & (var_c.length)) { } revert("subtraction underflow"); } } } function seizeAllowed(address token, address arg1, address arg2, address arg3) public payable { require(!unresolved_aadefd18[token], "E98"); require(mapping_5[token], "E86"); require(mapping_5[arg1], "E86"); require(arg1.code.length != 0x0); (bool success0, bytes memory returnData0) = arg1.controller(); // staticcall require(success0); require(!(returnData0.length < 0x20)); require(token.code.length != 0x0); (bool success1, bytes memory returnData1) = token.controller(); // staticcall require(success1); require(!(returnData1.length < 0x20)); require((0xffffffffffffffffffffffffffffffffffffffff & value1) == (0xffffffffffffffffffffffffffffffffffffffff & value0), "E93"); if (!(uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number)) { if (!(block.number - (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[token] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000)) == 0) { var_d = 0x20 + var_d; var_d = 0x20 + var_d; var_d = var_d + 0x20; unresolved_9eea63a2[token][arg3] = var_d.length; } else { var_d = 0x40 + var_d; var_a = var_a; if (block.number < 0x0100000000) { unresolved_a7ad64fc[token] = (uint224(unresolved_a7ad64fc[token])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); var_d = 0x20 + var_d; var_d = 0x20 + var_d; var_d = var_d + 0x20; unresolved_9eea63a2[token][arg3] = var_d.length; } else { if (var_d.length == 0) { if (0x1f & (var_d.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value2 = 0x20; while (true) { if (!(value2 < var_d.length)) { break; } value2 = 0x20 + value2; } if (0x1f & (var_d.length)) { } revert("block number exceeds 32 bits"); } } } } else { require(token.code.length != 0x0); (bool success2, bytes memory returnData2) = token.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success2); require(!(returnData2.length < 0x20)); uint256 tokenSupply = abi.decode(returnData2, (uint256)); if (!(block.number == (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) || !unresolved_7c1df719[token])) { if (block.number != (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) { if (unresolved_7c1df719[token] * (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) / (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) == unresolved_7c1df719[token]) { var_d = 0x20 + var_d; if (tokenSupply > 0) { var_d = 0x20 + var_d; } else { var_d = 0x20 + var_d; var_d = var_d + 0x20; var_d = 0x20 + var_d; var_d = 0x40 + var_d; } } else { if (var_d.length == 0) { if (0x1f & (var_d.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value2 = 0x20; while (true) { if (!(value2 < var_d.length)) { break; } value2 = 0x20 + value2; } if (0x1f & (var_d.length)) { } revert("multiplication overflow"); } } } } else { var_d = 0x20 + var_d; if (tokenSupply > 0) { var_d = 0x20 + var_d; } else { var_d = 0x20 + var_d; var_d = var_d + 0x20; var_d = 0x20 + var_d; var_d = 0x40 + var_d; } } } } else { if (var_d.length == 0) { if (0x1f & (var_d.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value2 = 0x20; while (true) { if (!(value2 < var_d.length)) { break; } value2 = 0x20 + value2; } if (0x1f & (var_d.length)) { } revert("subtraction underflow"); } } } function exitMarket(address arg0) public payable returns (uint256) { require(address(msg.sender).code.length != 0x0); (bool success0, bytes memory returnData0) = address(msg.sender).getAccountSnapshot(arg0); // staticcall require(success0); require(!(returnData0.length < 0x80)); require(value0 == 0x0, "E82"); if ((var_c != 0) && ((0x7 <= 0xa) && (0x2 <= 0x13))) { emit Failure(0x07, 0x02, 0); return 0x07; } require(mapping_5[msg.sender], "E86"); if (mapping_expr_dp[arg0]) { var_i = 0x20 + var_i; var_i = 0x20 + var_i; var_i = 0x20 + var_i; var_i = 0x20 + var_i; } if (0 != 0) { if ((0x09 <= 0xa) && (0x03 <= 0x13)) { emit Failure(0x09, 0x03, 0); } return 0x09; } if (!mapping_expr_dq[arg0]) { return 0; } mapping_expr_dq[arg0] = false; var_i = 0x20 + (var_i + (0x20 * mapping_4[arg0])); uint256 value5 = mapping_4[arg0]; uint256 value6 = keccak256(abi.encode(arg0, 0x04)); uint256 value7 = var_i + 0x20; if (mapping_4[arg0] != 0) { uint256 value3 = 0x20 + (var_i + 0x20); uint256 value4 = (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x04))))) + 0x01; while (true) { if ((var_i + 0x20) + (0x20 * mapping_4[arg0]) <= value3) { break; } value3 = 0x20 + value3; value4 = value4 + 0x01; } value5 = value3; value6 = value4; value7 = (var_i + 0x20) + (0x20 * mapping_4[arg0]); } uint256 value8 = 0; uint256 value9; while (true) { value9 = var_i.length; if (value8 >= var_i.length) { break; } if (value8 >= var_i.length) { break; } if (address(var_v) == (msg.sender)) { break; } value8 = 0x01 + value8; value9 = value8; } if (value9 < var_i.length) { if ((mapping_4[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < mapping_4[arg0]) { if (value9 < mapping_4[arg0]) { stor_expr_ds = (address(stor_expr_dt / 0x01)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_ds); mapping_4[arg0] = mapping_4[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (!(mapping_4[arg0] > (mapping_4[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) { emit MarketExited(msg.sender, arg0); return 0; } else { uint256 value11 = (mapping_4[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x04))))); uint256 value10 = (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x04))))) + mapping_4[arg0]; while (true) { uint256 value12 = value10; if (value10 <= value11) { break; } stor_expr_dv = 0; if (value10 <= (0x01 + value11)) { break; } stor_expr_dw = 0; value11 = 0x01 + (0x01 + value11); value10 = value10; value12 = value10; emit MarketExited(msg.sender, arg0); return 0; } } } } } } function mintAllowed(address token, address arg1) public payable { require(!isMintPaused[token], "E88"); require(mapping_5[token], "E86"); uint256 value0 = 0; if (mapping_5[token]) { if (!mapping_expr_dg[arg1]) { mapping_expr_dg[arg1] = true; mapping_4[arg1] = mapping_4[arg1] + 0x01; stor_expr_di = token; emit MarketEntered(stor_expr_di, arg1); } } else { value0 = 0x04; } if (value0 <= 0xa) { require(value0 == 0x0, "E89"); if (!(uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000) > block.number)) { if (!(block.number - (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) > 0x0 && unresolved_7c1df719[token] > 0x0)) { if (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000)) == 0) { var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = var_e + 0x20; unresolved_9eea63a2[token][arg1] = var_e.length; } else { var_e = 0x40 + var_e; var_a = var_a; if (block.number < 0x0100000000) { unresolved_a7ad64fc[token] = (uint224(unresolved_a7ad64fc[token])) | (0x0100000000000000000000000000000000000000000000000000000000 * (uint32(block.number))); var_e = 0x20 + var_e; var_e = 0x20 + var_e; var_e = var_e + 0x20; unresolved_9eea63a2[token][arg1] = var_e.length; } else { if (var_e.length == 0) { if (0x1f & (var_e.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { if (!(value1 < var_e.length)) { break; } value1 = 0x20 + value1; } if (0x1f & (var_e.length)) { } revert("block number exceeds 32 bits"); } } } } else { require(token.code.length != 0x0); (bool success0, bytes memory returnData0) = token.staticcall(abi.encodeWithSelector(bytes4(0x18160ddd))); // staticcall totalSupply require(success0); require(!(returnData0.length < 0x20)); uint256 tokenSupply = abi.decode(returnData0, (uint256)); if (!(block.number == (0xffffffff & unresolved_a7ad64fc[token] / 0x100000000000000000000000000000000000000000000000000000000) || !unresolved_7c1df719[token])) { if (block.number != (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) { if (unresolved_7c1df719[token] * (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) / (block.number - (uint32(unresolved_a7ad64fc[token] / 0x0100000000000000000000000000000000000000000000000000000000))) == unresolved_7c1df719[token]) { var_e = 0x20 + var_e; if (tokenSupply > 0) { var_e = 0x20 + var_e; } else { var_e = 0x20 + var_e; var_e = var_e + 0x20; var_e = 0x20 + var_e; var_e = 0x40 + var_e; } } else { if (var_e.length == 0) { if (0x1f & (var_e.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { if (!(value1 < var_e.length)) { break; } value1 = 0x20 + value1; } if (0x1f & (var_e.length)) { } revert("multiplication overflow"); } } } } else { var_e = 0x20 + var_e; if (tokenSupply > 0) { var_e = 0x20 + var_e; } else { var_e = 0x20 + var_e; var_e = var_e + 0x20; var_e = 0x20 + var_e; var_e = 0x40 + var_e; } } } } else { if (var_e.length == 0) { if (0x1f & (var_e.length)) { } revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } else { uint256 value1 = 0x20; while (true) { if (!(value1 < var_e.length)) { break; } value1 = 0x20 + value1; } if (0x1f & (var_e.length)) { } revert("subtraction underflow"); } } } } function claimDonkey(address arg0) public view { require(block.number > unresolved_aeb18540, "E95"); uint256 var_a; var_a = var_a + (0x20 + (0x20 * allMarkets.length)); if (allMarkets.length == 0) { require(block.number > unresolved_aeb18540, "E95"); var_a = 0x40 + var_a; if (0 < var_a.length) { } } } 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. // 0x06df2719 => isStakingContract(address) // 0x317b0b77 => _setCloseFactor(uint256) // 0x3205e017 => repayBorrowAllowed(address,address) // 0x33643592 => Unknown_33643592(bytes,bool) // 0x35577962 => setPauseGuardian(address,bool) // 0x3acc4eba => unresolved_3acc4eba(address) // 0x3e0cdfd3 => setMintPaused(address,bool) // 0x4261f4d8 => isPauseGuardian(address) // 0x42cbb15c => getBlockNumber() // 0x4321c741 => Unknown_4321c741() // 0x485cc955 => initialize(address,address) // 0x499ba641 => Unknown_499ba641(bytes,bytes,bool,bool,uint256) // 0x4a584432 => borrowCaps(address) // 0x4e1647fb => isController() // 0x52d84d1e => allMarkets(uint256) // 0x55ee1fe1 => _setPriceOracle(address) // 0x56e64fd6 => getAccountLiquidity(address,bool) // 0x5b1500ca => Unknown_5b1500ca(address,uint256) // 0x5fc7e71e => liquidateBorrowAllowed(address,address,address,address,uint256) // 0x607ef6c1 => _setMarketBorrowCaps(address[],uint256[]) // 0x6e26a5e3 => getLiquidationIncentiveOf(address) // 0x704b6c02 => setAdmin(address) // 0x7c1df719 => unresolved_7c1df719(address) // 0x85353faf => Unknown_85353faf(bytes,bytes) // 0x87f76303 => transferGuardianPaused() // 0x88568109 => getAccountAssets(address) // 0x8e8f294b => markets(address) // 0x8f8997f6 => isMintPaused(address) // 0x9eea63a2 => unresolved_9eea63a2(address,address) // 0xa76b3fda => _supportMarket(address) // 0xa78da04f => Unknown_a78da04f(uint256) // 0xa7ad64fc => unresolved_a7ad64fc(address) // 0xa8a9c063 => getCurrentMyDonkey(address) // 0xaadefd18 => unresolved_aadefd18(address) // 0xac0b0bb7 => seizeGuardianPaused() // 0xae3c2b3c => unresolved_ae3c2b3c() // 0xae45a73b => isBorrowPaused(address) // 0xae493409 => unresolved_ae493409(address) // 0xaeb18540 => unresolved_aeb18540() // 0xb0772d0b => getAllMarkets() // 0xb6606d1c => setBorrowPaused(address,bool) // 0xb84375f2 => unresolved_b84375f2(address) // 0xba8f4c44 => getDonkeyAddress() // 0xbdcdc258 => transferAllowed(address,address,address,uint256) // 0xc20ae451 => Unknown_c20ae451(address,bytes) // 0xc488847b => liquidateCalculateSeizeTokens(address,address,uint256) // 0xc4b70610 => unresolved_c4b70610(address) // 0xcc3ddb54 => claimDonkeyBehalfOf(address,bool) // 0xcc80e51a => redeemVerify(uint256,uint256) // 0xcea4c2b2 => Unknown_cea4c2b2(bytes,bytes) // 0xd141d9fc => unresolved_d141d9fc() // 0xd5f8583e => Unknown_d5f8583e(address) // 0xd97efd6b => Unknown_d97efd6b(bytes,bool) // 0xda3d454c => borrowAllowed(address,address,uint256) // 0xdce15449 => accountAssets(address,uint256) // 0xe4028eee => _setCollateralFactor(address,uint256) // 0xe8755446 => closeFactorMantissa() // 0xeabe7d91 => redeemAllowed(address,address,uint256) // 0xeafe967b => seizeAllowed(address,address,address,address) // 0xede4edd0 => exitMarket(address) // 0xf196980a => mintAllowed(address,address) // 0xf3da275d => claimDonkey(address) // 0xf851a440 => admin() // 0xfd72410d => unresolved_fd72410d(address,address)}