Code for 0xd911…6c6f
Since block 14095522
Panoramix decompilation
# Palkeoramix decompiler. def storage: stor0 is uint32 at storage 0 stor0 is address at storage 0 stor0 is uint256 at storage 0 managers is mapping of uint256 at storage 1 stor2 is uint32 at storage 2 stor2 is address at storage 2 stor2 is uint256 at storage 2 stor3 is address at storage 3 stor4 is address at storage 4 stor5 is address at storage 5 stor6 is address at storage 6 stor7 is address at storage 7 stor8 is address at storage 8 stor9 is address at storage 9 stor10 is address at storage 10 stor11 is address at storage 11 stor12 is address at storage 12 stor13 is address at storage 13 stor14 is address at storage 14 stor15 is array of address at storage 15 stor16 is array of address at storage 16 stor17 is array of address at storage 17 stor18 is mapping of address at storage 18 stor19 is mapping of address at storage 19 stor20 is mapping of address at storage 20 stor21 is uint256 at storage 21 def managers(address _param1): # not payable require calldata.size - 4 >=′ 32 require _param1 == _param1 return managers[_param1] # # Regular functions # def _fallback(?) payable: # default function revert def unknown22133af0(uint256 _param1): # not payable require calldata.size - 4 >=′ 32 require _param1 == _param1 if address(stor0) != caller: revert with 0, 'Only owner can use this method' stor21 = _param1 def setComptroller(address _comptroller): # not payable require calldata.size - 4 >=′ 32 require _comptroller == _comptroller if address(stor0) != caller: revert with 0, 'Only owner can use this method' stor3 = _comptroller def setOwner(address _newOwner): # not payable require calldata.size - 4 >=′ 32 require _newOwner == _newOwner if address(stor0) != caller: revert with 0, 'Only owner can use this method' address(stor0) = _newOwner def unknowna16c458e(uint256 _param1): # not payable require calldata.size - 4 >=′ 32 require _param1 == address(_param1) if address(stor0) != caller: revert with 0, 'Only owner can use this method' stor4 = address(_param1) def unknowndef8d8f1(uint256 _param1): # not payable require calldata.size - 4 >=′ 32 require _param1 == address(_param1) if address(stor0) != caller: revert with 0, 'Only owner can use this method' stor6 = address(_param1) def unknownfef0b974(uint256 _param1): # not payable require calldata.size - 4 >=′ 32 require _param1 == address(_param1) if address(stor0) != caller: revert with 0, 'Only owner can use this method' stor5 = address(_param1) def depositWeth(uint256 amount): # not payable require calldata.size - 4 >=′ 32 require amount == amount if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require ext_code.size(stor14) call stor14.deposit() with: value amount wei gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] def withdrawWeth(uint256 _amount): # not payable require calldata.size - 4 >=′ 32 require _amount == _amount if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require ext_code.size(stor14) call stor14.withdraw(uint256 amount) with: gas gas_remaining wei args _amount if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] def approve(address erc20, address who, uint256 amount): # not payable require calldata.size - 4 >=′ 96 require erc20 == erc20 require who == who require amount == amount if address(stor0) != caller: revert with 0, 'Only owner can use this method' require ext_code.size(erc20) call erc20.approve(address spender, uint256 amount) with: gas gas_remaining wei args address(who), amount if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == bool(ext_call.return_data[0]) def unknownc807ea5b(): # not payable if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) def unknownd70e9018(): # not payable if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) def unknowndaa020e3(): # not payable require calldata.size - 4 >=′ 32 require cd[4] <= LOCK8605463013() require cd[4] + 35 <′ calldata.size require ('cd', 4).length <= LOCK8605463013() require cd[4] + (32 * ('cd', 4).length) + 36 <= calldata.size if address(stor0) != caller: revert with 0, 'Only owner can use this method' idx = 0 while idx < ('cd', 4).length: require cd[((32 * idx) + cd[4] + 36)] == address(cd[((32 * idx) + cd[4] + 36)]) mem[0] = address(cd[((32 * idx) + cd[4] + 36)]) mem[32] = 1 managers[address(cd[((32 * idx) + cd[4] + 36)])] = 1 idx = idx + 1 continue def unknowndf152fc7(): # not payable require calldata.size - 4 >=′ 32 require cd[4] <= LOCK8605463013() require cd[4] + 35 <′ calldata.size require ('cd', 4).length <= LOCK8605463013() require cd[4] + (32 * ('cd', 4).length) + 36 <= calldata.size if address(stor0) != caller: revert with 0, 'Only owner can use this method' idx = 0 while idx < ('cd', 4).length: require cd[((32 * idx) + cd[4] + 36)] == address(cd[((32 * idx) + cd[4] + 36)]) mem[0] = address(cd[((32 * idx) + cd[4] + 36)]) mem[32] = 1 managers[address(cd[((32 * idx) + cd[4] + 36)])] = 0 idx = idx + 1 continue def setup(): # not payable if address(stor0) != caller: revert with 0, 'Only owner can use this method' mem[96] = 0xb0772d0b00000000000000000000000000000000000000000000000000000000 require ext_code.size(stor3) static call stor3.getAllMarkets() with: gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] mem[96 len return_data.size] = ext_call.return_data[0 len return_data.size] mem[64] = ceil32(return_data.size) + 96 require return_data.size >=′ 32 require mem[96] <= LOCK8605463013() require mem[96] + 127 <′ return_data.size + 96 require mem[mem[96] + 96] <= LOCK8605463013() require ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 <= LOCK8605463013() and (32 * mem[mem[96] + 96]) + 32 >= 0 require mem[96] + (32 * mem[mem[96] + 96]) + 32 <= return_data.size ... # Decompilation aborted, sorry: ("decompilation didn't finish",) def call(address target, bytes data): # not payable require calldata.size - 4 >=′ 64 require target == target require data <= LOCK8605463013() require data + 35 <′ calldata.size require data.length <= LOCK8605463013() require data + data.length + 36 <= calldata.size if address(stor0) != caller: revert with 0, 'Only owner can use this method' mem[96 len data.length] = data[all] mem[data.length + 96] = 0 call target with: gas gas_remaining wei args data[all] if return_data.size: return bool(ext_call.success), Array(len=return_data.size, data=ext_call.return_data[0 len return_data.size]) mem[96] = bool(ext_call.success) mem[128] = 64 mem[160] = bool(ext_call.success) mem[192 len ceil32(bool(ext_call.success))] = mem[128 len ceil32(bool(ext_call.success))] if ceil32(bool(ext_call.success)) > bool(ext_call.success): mem[bool(ext_call.success) + 192] = 0 return memory from 96 len ceil32(bool(ext_call.success)) + 96 def delegatecall(address dest, bytes data): # not payable require calldata.size - 4 >=′ 64 require dest == dest require data <= LOCK8605463013() require data + 35 <′ calldata.size require data.length <= LOCK8605463013() require data + data.length + 36 <= calldata.size if address(stor0) != caller: revert with 0, 'Only owner can use this method' mem[96 len data.length] = data[all] mem[data.length + 96] = 0 delegate dest with: gas gas_remaining wei args data[all] if return_data.size: return bool(delegate.return_code), Array(len=return_data.size, data=ext_call.return_data[0 len return_data.size]) mem[96] = bool(delegate.return_code) mem[128] = 64 mem[160] = bool(delegate.return_code) mem[192 len ceil32(bool(delegate.return_code))] = mem[128 len ceil32(bool(delegate.return_code))] if ceil32(bool(delegate.return_code)) > bool(delegate.return_code): mem[bool(delegate.return_code) + 192] = 0 return memory from 96 len ceil32(bool(delegate.return_code)) + 96 def unknown2d6a279b(uint256 _param1, uint256 _param2): # not payable require calldata.size - 4 >=′ 64 require _param1 == address(_param1) require _param2 == _param2 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require ext_code.size(address(_param1)) static call address(_param1).balanceOf(address account) with: gas gas_remaining wei args this.address if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0]: if _param2: require ext_code.size(address(_param1)) call address(_param1).redeem(uint256 amount) with: gas gas_remaining wei args ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] def unknowne9a2c475(uint256 _param1, uint256 _param2): # not payable require calldata.size - 4 >=′ 64 require _param1 == _param1 require _param2 == _param2 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if eth.balance(this.address): if not _param1: if _param2 == 1: call address(stor2) with: value eth.balance(this.address) wei gas 2300 * is_zero(value) wei else: call address(stor0) with: value eth.balance(this.address) wei gas 2300 * is_zero(value) wei else: if _param1 <= eth.balance(this.address): if _param2 == 1: call address(stor2) with: value _param1 wei gas 2300 * is_zero(value) wei else: call address(stor0) with: value _param1 wei gas 2300 * is_zero(value) wei else: if _param2 == 1: call address(stor2) with: value eth.balance(this.address) wei gas 2300 * is_zero(value) wei else: call address(stor0) with: value eth.balance(this.address) wei gas 2300 * is_zero(value) wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] def unknownda481269(uint256 _param1, uint256 _param2): # not payable require calldata.size - 4 >=′ 64 require _param1 == address(_param1) require _param2 == _param2 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require ext_code.size(stor18[address(_param1)]) static call stor18[address(_param1)].balanceOf(address account) with: gas gas_remaining wei args this.address if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0]: require ext_code.size(stor4) if not _param2: call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args address(_param1), -1, this.address else: if _param2 <= ext_call.return_data[0]: call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args address(_param1), _param2, this.address else: call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args address(_param1), -1, this.address if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] def unknown11797c56(): # not payable if address(stor0) != caller: revert with 0, 'Only owner can use this method' mem[96] = 0xb0772d0b00000000000000000000000000000000000000000000000000000000 require ext_code.size(stor3) static call stor3.getAllMarkets() with: gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] mem[96 len return_data.size] = ext_call.return_data[0 len return_data.size] mem[64] = ceil32(return_data.size) + 96 require return_data.size >=′ 32 _5 = mem[96] require mem[96] <= LOCK8605463013() require mem[96] + 127 <′ return_data.size + 96 _7 = mem[mem[96] + 96] require mem[mem[96] + 96] <= LOCK8605463013() require ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 <= LOCK8605463013() and (32 * mem[mem[96] + 96]) + 32 >= 0 mem[64] = ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 mem[ceil32(return_data.size) + 96] = _7 require _5 + (32 * _7) + 32 <= return_data.size idx = 0 s = _5 + 128 t = ceil32(return_data.size) + 128 while idx < _7: require mem[s] == mem[s + 12 len 20] mem[t] = mem[s] idx = idx + 1 s = s + 32 t = t + 32 continue stor16.length = _7 if not _7: idx = 0 while stor16.length > idx: stor16[idx] = 0 idx = idx + 1 continue else: s = 0 idx = ceil32(return_data.size) + 128 while ceil32(return_data.size) + (32 * _7) + 128 > idx: stor16[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * _7) + 31) >> 5 while stor16.length > idx: stor16[idx] = 0 idx = idx + 1 continue def unknownb4df3a2c(uint256 _param1, uint256 _param2): # not payable require calldata.size - 4 >=′ 64 require _param1 == _param1 require _param2 == address(_param2) if address(_param2) == stor11: require ext_code.size(stor5) static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args stor8, stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] return (_param1 * ext_call.return_data[32] / 100 * 10^6) if address(_param2) != stor12: if address(_param2) != stor13: require ext_code.size(stor5) static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param2), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] return (_param1 * ext_call.return_data[32] / 10^18) require ext_code.size(stor5) static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param2), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] return (_param1 * ext_call.return_data[32] / 10^6) def unknown97ec8ab5(uint256 _param1, uint256 _param2, uint256 _param3): # not payable require calldata.size - 4 >=′ 96 require _param1 == _param1 require _param2 == _param2 require _param3 == address(_param3) if not address(_param3): if _param1 <= _param2 * stor21 / 100: return _param1 return (_param2 * stor21 / 100) if address(_param3) == stor10: if _param1 <= _param2 * stor21 / 100: return _param1 return (_param2 * stor21 / 100) if address(_param3) == stor11: require ext_code.size(stor5) static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args stor8, stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if _param1 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6: return _param1 return (_param2 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6) if address(_param3) != stor12: if address(_param3) != stor13: require ext_code.size(stor5) static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param3), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if _param1 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^18: return _param1 return (_param2 * stor21 / 100 * ext_call.return_data[32] / 10^18) require ext_code.size(stor5) static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param3), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if _param1 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6: return _param1 return (_param2 * stor21 / 100 * ext_call.return_data[32] / 10^6) def safeApprove(address _token, address _spender, uint256 _value): # not payable require calldata.size - 4 >=′ 96 require _token == _token require _spender == _spender require _value == _value if address(stor0) != caller: revert with 0, 'Only owner can use this method' if not _value: if ext_code.hash(_token) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(_token): revert with 0, 'SafeERC20: call to non-contract' mem[196 len 96] = approve(address spender, uint256 amount), address(_spender) << 64, 0, _value, mem[196 len 28] call _token.mem[196 len 4] with: gas gas_remaining wei args mem[200 len 64] if not return_data.size: if not ext_call.success: revert with 0, 'SafeERC20: low-level call failed' require approve(address spender, uint256 amount), address(_spender) << 64 == bool(approve(address spender, uint256 amount), address(_spender) << 64) if not approve(address spender, uint256 amount), address(_spender) << 64: revert with 0, 'SafeERC20: IERC20 operation did not succeed' else: mem[228 len return_data.size] = ext_call.return_data[0 len return_data.size] if not ext_call.success: revert with 0, 'SafeERC20: low-level call failed' if return_data.size > 0: require return_data.size >=′ 32 require mem[228] == bool(mem[228]) if not mem[228]: revert with 0, 'SafeERC20: IERC20 operation did not succeed' else: require ext_code.size(_token) static call _token.allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), _spender if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0]: revert with 0, 'SafeERC20: approve from non-zero to non-zero allowance' if ext_code.hash(_token) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(_token): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = approve(address spender, uint256 amount), address(_spender) << 64, 0, _value, mem[ceil32(return_data.size) + 196 len 28] call _token.mem[ceil32(return_data.size) + 196 len 4] with: gas gas_remaining wei args mem[ceil32(return_data.size) + 200 len 64] if not return_data.size: if not ext_call.success: revert with 0, 'SafeERC20: low-level call failed' if ext_call.return_data[0] > 0: require ext_call.return_data[0] >=′ 32 require 0, address(_spender) << 64 == bool(0, address(_spender) << 64) if not 0, address(_spender) << 64: revert with 0, 'SafeERC20: IERC20 operation did not succeed' else: mem[ceil32(return_data.size) + 228 len return_data.size] = ext_call.return_data[0 len return_data.size] if not ext_call.success: revert with 0, 'SafeERC20: low-level call failed' if return_data.size > 0: require return_data.size >=′ 32 require mem[ceil32(return_data.size) + 228] == bool(mem[ceil32(return_data.size) + 228]) if not mem[ceil32(return_data.size) + 228]: revert with 0, 'SafeERC20: IERC20 operation did not succeed' def unknown000000b9(uint256 _param1, uint256 _param2, uint256 _param3, uint256 _param4, uint256 _param5, uint256 _param6): # not payable require calldata.size - 4 >=′ 192 require calldata.size - 4 >=′ 160 require _param6 == _param6 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require _param3 == address(_param3) require ext_code.size(address(_param3)) static call address(_param3).borrowBalanceStored(address account) with: gas gas_remaining wei args address(_param1 xor 0x2924ae637c7864b0d87c31247229f8cc8ae51155 / 33) if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0] / 2 < _param2: return 5 require _param4 == address(_param4) require ext_code.size(address(_param3)) call address(_param3).liquidateBorrow(address borrower, address cTokenCollateral) with: value _param2 wei gas gas_remaining wei args address(_param1 xor 0x2924ae637c7864b0d87c31247229f8cc8ae51155 / 33), address(_param4) if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] if not _param6: return 0 require _param5 == address(_param5) if not address(_param5): if _param6 <= _param2 * stor21 / 100: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 wei gas 99000 wei else: if address(_param5) == stor10: if _param6 <= _param2 * stor21 / 100: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 wei gas 99000 wei else: require ext_code.size(stor5) if address(_param5) == stor11: static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args stor8, stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6 wei gas 99000 wei else: static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param5), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if address(_param5) == stor12: if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6 wei gas 99000 wei else: if address(_param5) != stor13: if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^18: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 10^18 wei gas 99000 wei else: if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6 wei gas 99000 wei if ext_call.success: return 200 return 201 def unknown000000bb(uint256 _param1, uint256 _param2, uint256 _param3, uint256 _param4, uint256 _param5, uint256 _param6): # not payable require calldata.size - 4 >=′ 192 require calldata.size - 4 >=′ 160 require _param6 == _param6 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require _param3 == address(_param3) require ext_code.size(address(_param3)) static call address(_param3).borrowBalanceStored(address account) with: gas gas_remaining wei args address(_param1 xor 0x2924ae637c7864b0d87c31247229f8cc8ae51155 / 33) if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0] / 2 < _param2: return 5 require _param4 == address(_param4) require ext_code.size(address(_param3)) call address(_param3).liquidateBorrow(address borrower, uint256 repayAmount, address cTokenCollateral) with: gas gas_remaining wei args address(_param1 xor 0x2924ae637c7864b0d87c31247229f8cc8ae51155 / 33), _param2, address(_param4) if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0]: return (ext_call.return_data[0] + 100) if not _param6: return 0 require _param5 == address(_param5) if not address(_param5): if _param6 <= _param2 * stor21 / 100: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 wei gas 99000 wei else: if address(_param5) == stor10: if _param6 <= _param2 * stor21 / 100: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 wei gas 99000 wei else: require ext_code.size(stor5) if address(_param5) == stor11: static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args stor8, stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6 wei gas 99000 wei else: static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param5), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if address(_param5) == stor12: if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6 wei gas 99000 wei else: if address(_param5) != stor13: if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^18: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 10^18 wei gas 99000 wei else: if _param6 <= _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6: call stor6 with: value _param6 wei gas 99000 wei else: call stor6 with: value _param2 * stor21 / 100 * ext_call.return_data[32] / 10^6 wei gas 99000 wei if ext_call.success: return 200 return 201 def unknown00000052(uint256 _param1, uint256 _param2, uint256 _param3, uint256 _param4, uint256 _param5): # not payable require calldata.size - 4 >=′ 160 require _param1 == address(_param1) require _param2 == address(_param2) require _param3 == address(_param3) require _param4 == _param4 require _param5 == _param5 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' require ext_code.size(stor19[address(_param2)]) static call stor19[address(_param2)].balanceOf(address account) with: gas gas_remaining wei args address(_param3) if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] require ext_code.size(stor20[address(_param2)]) static call stor20[address(_param2)].balanceOf(address account) with: gas gas_remaining wei args address(_param3) if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if 2 * ext_call.return_data[0] < 2 * _param4: return 1 require ext_code.size(stor4) call stor4.liquidationCall(address collateralAsset, address debtAsset, address user, uint256 debtToCover, bool receiveAToken) with: gas gas_remaining wei args address(_param1), address(_param2), address(_param3), _param4, 1 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] if not _param5: return 0 if not address(_param2): if _param5 <= _param4 * stor21 / 100: call stor6 with: value _param5 wei gas 99000 wei else: call stor6 with: value _param4 * stor21 / 100 wei gas 99000 wei else: if address(_param2) == stor10: if _param5 <= _param4 * stor21 / 100: call stor6 with: value _param5 wei gas 99000 wei else: call stor6 with: value _param4 * stor21 / 100 wei gas 99000 wei else: require ext_code.size(stor5) if address(_param2) == stor11: static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args stor8, stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if _param5 <= _param4 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6: call stor6 with: value _param5 wei gas 99000 wei else: call stor6 with: value _param4 * stor21 / 100 * ext_call.return_data[32] / 100 * 10^6 wei gas 99000 wei else: static call stor5.latestRoundData(address base, address quote) with: gas gas_remaining wei args address(_param2), stor7 if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 160 require ext_call.return_data[0] == ext_call.return_data[22 len 10] require ext_call.return_data[32] == ext_call.return_data[32] require ext_call.return_data[64] == ext_call.return_data[64] require ext_call.return_data[96] == ext_call.return_data[96] require ext_call.return_data[128] == ext_call.return_data[150 len 10] if address(_param2) == stor12: if _param5 <= _param4 * stor21 / 100 * ext_call.return_data[32] / 10^6: call stor6 with: value _param5 wei gas 99000 wei else: call stor6 with: value _param4 * stor21 / 100 * ext_call.return_data[32] / 10^6 wei gas 99000 wei else: if address(_param2) != stor13: if _param5 <= _param4 * stor21 / 100 * ext_call.return_data[32] / 10^18: call stor6 with: value _param5 wei gas 99000 wei else: call stor6 with: value _param4 * stor21 / 100 * ext_call.return_data[32] / 10^18 wei gas 99000 wei else: if _param5 <= _param4 * stor21 / 100 * ext_call.return_data[32] / 10^6: call stor6 with: value _param5 wei gas 99000 wei else: call stor6 with: value _param4 * stor21 / 100 * ext_call.return_data[32] / 10^6 wei gas 99000 wei if ext_call.success: return 200 return 201 def unknownf416c765(): # not payable if address(stor0) != caller: revert with 0, 'Only owner can use this method' mem[96] = 0xd1946dbc00000000000000000000000000000000000000000000000000000000 require ext_code.size(stor4) static call stor4.getReservesList() with: gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] mem[96 len return_data.size] = ext_call.return_data[0 len return_data.size] mem[64] = ceil32(return_data.size) + 96 require return_data.size >=′ 32 _5 = mem[96] require mem[96] <= LOCK8605463013() require mem[96] + 127 <′ return_data.size + 96 _7 = mem[mem[96] + 96] require mem[mem[96] + 96] <= LOCK8605463013() require ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 <= LOCK8605463013() and (32 * mem[mem[96] + 96]) + 32 >= 0 mem[64] = ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 mem[ceil32(return_data.size) + 96] = _7 require _5 + (32 * _7) + 32 <= return_data.size idx = 0 s = _5 + 128 t = ceil32(return_data.size) + 128 while idx < _7: require mem[s] == mem[s + 12 len 20] mem[t] = mem[s] idx = idx + 1 s = s + 32 t = t + 32 continue stor17.length = _7 if _7: s = 0 idx = ceil32(return_data.size) + 128 while ceil32(return_data.size) + (32 * _7) + 128 > idx: stor17[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue else: idx = 0 while stor17.length > idx: stor17[idx] = 0 idx = idx + 1 continue if 0 >= stor17.length: stop mem[0] = 17 mem[mem[64] + 4] = this.address mem[mem[64] + 36] = stor4 require ext_code.size(stor17) static call stor17.allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), stor4 mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _767 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_767] == mem[_767] if not mem[_767]: mem[mem[64] + 4] = this.address mem[mem[64] + 36] = stor4 require ext_code.size(stor17) static call stor17.allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), stor4 mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _784 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_784] == mem[_784] if mem[_784]: revert with 0, 'SafeERC20: approve from non-zero to non-zero allowance' if ext_code.hash(stor17) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor17): revert with 0, 'SafeERC20: call to non-contract' else: _772 = mem[64] mem[64] = mem[64] + 384 _773 = mem[64] mem[64] = mem[64] + 32 mem[_773] = 0 mem[_772] = _773 mem[_772 + 32] = 0 mem[_772 + 64] = 0 mem[_772 + 96] = 0 mem[_772 + 128] = 0 mem[_772 + 160] = 0 mem[_772 + 192] = 0 mem[_772 + 224] = 0 mem[_772 + 256] = 0 mem[_772 + 288] = 0 mem[_772 + 320] = 0 mem[_772 + 352] = 0 require ext_code.size(stor4) static call stor4.getReserveData(address asset) with: gas gas_remaining wei args stor17 mem[mem[64] len 384] = ext_call.return_data[0 len 384] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _781 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 384 _786 = mem[64] require mem[64] + 384 <= LOCK8605463013() and mem[64] + 384 >= mem[64] mem[64] = mem[64] + 384 require return_data.size >=′ 32 _791 = mem[64] require mem[64] + 32 <= LOCK8605463013() and mem[64] + 32 >= mem[64] mem[64] = mem[64] + 32 require mem[_781] == mem[_781] mem[_791] = mem[_781] mem[_786] = _791 require mem[_781 + 32] == mem[_781 + 48 len 16] mem[_786 + 32] = mem[_781 + 32] require mem[_781 + 64] == mem[_781 + 80 len 16] mem[_786 + 64] = mem[_781 + 64] require mem[_781 + 96] == mem[_781 + 112 len 16] mem[_786 + 96] = mem[_781 + 96] require mem[_781 + 128] == mem[_781 + 144 len 16] ... # Decompilation aborted, sorry: ("decompilation didn't finish",) def unknown3e3e4a10(uint256 _param1, uint256 _param2, uint256 _param3): # not payable require calldata.size - 4 >=′ 96 require _param1 == address(_param1) require _param2 == _param2 require _param3 == _param3 if address(stor0) != caller: if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' mem[100] = this.address require ext_code.size(address(_param1)) static call address(_param1).balanceOf(address account) with: gas gas_remaining wei args this.address mem[96] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 require ext_call.return_data[0] == ext_call.return_data[0] if ext_call.return_data[0]: mem[ceil32(return_data.size) + 96] = 68 if not _param2: if _param3 == 1: mem[ceil32(return_data.size) + 132 len 28] = Mask(224, 0, stor2) mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount) if ext_code.hash(address(_param1)) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(address(_param1)): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = transfer(address recipient, uint256 amount), Mask(224, 0, stor2), uint32(stor2), ext_call.return_data[0], mem[ceil32(return_data.size) + 196 len 28] else: mem[ceil32(return_data.size) + 132 len 28] = Mask(224, 0, stor0) mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount) if ext_code.hash(address(_param1)) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(address(_param1)): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = transfer(address recipient, uint256 amount), Mask(224, 0, stor0), uint32(stor0), ext_call.return_data[0], mem[ceil32(return_data.size) + 196 len 28] else: if _param2 <= ext_call.return_data[0]: if _param3 == 1: mem[ceil32(return_data.size) + 132 len 28] = Mask(224, 0, stor2) mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount) if ext_code.hash(address(_param1)) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(address(_param1)): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = transfer(address recipient, uint256 amount), Mask(224, 0, stor2), uint32(stor2), _param2, mem[ceil32(return_data.size) + 196 len 28] else: mem[ceil32(return_data.size) + 132 len 28] = Mask(224, 0, stor0) mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount) if ext_code.hash(address(_param1)) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(address(_param1)): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = transfer(address recipient, uint256 amount), Mask(224, 0, stor0), uint32(stor0), _param2, mem[ceil32(return_data.size) + 196 len 28] else: if _param3 == 1: mem[ceil32(return_data.size) + 132 len 28] = Mask(224, 0, stor2) mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount) if ext_code.hash(address(_param1)) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(address(_param1)): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = transfer(address recipient, uint256 amount), Mask(224, 0, stor2), uint32(stor2), ext_call.return_data[0], mem[ceil32(return_data.size) + 196 len 28] else: mem[ceil32(return_data.size) + 132 len 28] = Mask(224, 0, stor0) mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount) if ext_code.hash(address(_param1)) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(address(_param1)): revert with 0, 'SafeERC20: call to non-contract' mem[ceil32(return_data.size) + 196 len 96] = transfer(address recipient, uint256 amount), Mask(224, 0, stor0), uint32(stor0), ext_call.return_data[0], mem[ceil32(return_data.size) + 196 len 28] call address(_param1).mem[ceil32(return_data.size) + 196 len 4] with: gas gas_remaining wei args mem[ceil32(return_data.size) + 200 len 64] if not return_data.size: if not ext_call.success: revert with 0, 'SafeERC20: low-level call failed' if ext_call.return_data[0] > 0: require ext_call.return_data[0] >=′ 32 require 0, mem[132 len 28] == bool(0, mem[132 len 28]) if not 0, mem[132 len 28]: revert with 0, 'SafeERC20: IERC20 operation did not succeed' else: mem[ceil32(return_data.size) + 228 len return_data.size] = ext_call.return_data[0 len return_data.size] if not ext_call.success: revert with 0, 'SafeERC20: low-level call failed' if return_data.size > 0: require return_data.size >=′ 32 require mem[ceil32(return_data.size) + 228] == bool(mem[ceil32(return_data.size) + 228]) if not mem[ceil32(return_data.size) + 228]: revert with 0, 'SafeERC20: IERC20 operation did not succeed' def unknownfe935dc6() payable: mem[64] = 96 require not call.value if caller == address(stor0): idx = 0 while idx < stor16.length: mem[0] = 16 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor16[idx]) static call stor16[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _60 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _64 = mem[_60] require mem[_60] == mem[_60] if mem[_60]: mem[mem[64] + 4] = mem[_60] require ext_code.size(stor16[idx]) call stor16[idx].redeem(uint256 amount) with: gas gas_remaining wei args _64 mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _76 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_76] == mem[_76] else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor16[idx]) static call stor16[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _62 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _66 = mem[_62] require mem[_62] == mem[_62] if mem[_62]: mem[mem[64] + 4] = mem[_62] require ext_code.size(stor16[idx]) call stor16[idx].redeem(uint256 amount) with: gas gas_remaining wei args _66 mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _78 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_78] == mem[_78] idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' idx = 0 while idx < stor16.length: mem[0] = 16 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor16[idx]) static call stor16[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _61 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _65 = mem[_61] require mem[_61] == mem[_61] if mem[_61]: mem[mem[64] + 4] = mem[_61] require ext_code.size(stor16[idx]) call stor16[idx].redeem(uint256 amount) with: gas gas_remaining wei args _65 mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _77 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_77] == mem[_77] else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor16[idx]) static call stor16[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _63 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _67 = mem[_63] require mem[_63] == mem[_63] if mem[_63]: mem[mem[64] + 4] = mem[_63] require ext_code.size(stor16[idx]) call stor16[idx].redeem(uint256 amount) with: gas gas_remaining wei args _67 mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _79 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_79] == mem[_79] idx = idx + 1 continue def setTokens(): # not payable if address(stor0) != caller: revert with 0, 'Only owner can use this method' require stor16.length <= LOCK8605463013() mem[96] = stor16.length mem[64] = (32 * stor16.length) + 128 if not stor16.length: stor15.length = stor16.length mem[0] = 15 if not stor16.length: idx = 0 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _76 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _84 = mem[_76] require mem[_76] == mem[_76 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_84) idx = idx + 1 continue else: s = 0 idx = 128 while (32 * stor16.length) + 128 > idx: stor15[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * stor16.length) + 31) >> 5 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _104 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _106 = mem[_104] require mem[_104] == mem[_104 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_106) idx = idx + 1 continue else: mem[128 len 32 * stor16.length] = call.data[calldata.size len 32 * stor16.length] stor15.length = stor16.length mem[0] = 15 if not stor16.length: idx = 0 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _77 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _86 = mem[_77] require mem[_77] == mem[_77 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_86) idx = idx + 1 continue else: s = 0 idx = 128 while (32 * stor16.length) + 128 > idx: stor15[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * stor16.length) + 31) >> 5 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _105 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _107 = mem[_105] require mem[_105] == mem[_105 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_107) idx = idx + 1 continue def unknown3b51b3f2() payable: mem[64] = 96 require not call.value if caller == address(stor0): idx = 0 while idx < stor15.length: mem[0] = 15 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _668 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_668] == mem[_668] if not mem[_668]: idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _674 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_674] == mem[_674] if not mem[_674]: idx = idx + 1 continue if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if caller == address(stor0): idx = 0 while idx < stor15.length: mem[0] = 15 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _670 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_670] == mem[_670] if not mem[_670]: idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _676 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_676] == mem[_676] if not mem[_676]: idx = idx + 1 continue if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' idx = 0 while idx < stor15.length: mem[0] = 15 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _672 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_672] == mem[_672] if not mem[_672]: idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _678 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_678] == mem[_678] if not mem[_678]: idx = idx + 1 continue if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) ... # Decompilation aborted, sorry: ("decompilation didn't finish",) def unknown7197057a() payable: mem[64] = 96 require not call.value if caller == address(stor0): idx = 0 while idx < stor15.length: mem[0] = 15 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _668 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_668] == mem[_668] if not mem[_668]: idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _674 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_674] == mem[_674] if not mem[_674]: idx = idx + 1 continue if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' if caller == address(stor0): idx = 0 while idx < stor15.length: mem[0] = 15 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _670 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_670] == mem[_670] if not mem[_670]: idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _676 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_676] == mem[_676] if not mem[_676]: idx = idx + 1 continue if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' idx = 0 while idx < stor15.length: mem[0] = 15 if caller == address(stor0): mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _672 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_672] == mem[_672] if not mem[_672]: idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[mem[64] + 4] = this.address require ext_code.size(stor15[idx]) static call stor15[idx].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _678 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_678] == mem[_678] if not mem[_678]: idx = idx + 1 continue if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' ... # Decompilation aborted, sorry: ("decompilation didn't finish",) ... # Decompilation aborted, sorry: ("decompilation didn't finish",) def unknown9fc406c7() payable: mem[64] = 96 require not call.value if caller == address(stor0): idx = 0 while idx < stor17.length: if caller == address(stor0): mem[0] = stor17[idx] mem[32] = 18 mem[mem[64] + 4] = this.address require ext_code.size(stor18[stor17[idx]]) static call stor18[stor17[idx]].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _68 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_68] == mem[_68] if mem[_68]: mem[mem[64] + 4] = stor17[idx] mem[mem[64] + 36] = -1 mem[mem[64] + 68] = this.address require ext_code.size(stor4) call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args stor17[idx], -1, this.address mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _84 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_84] == mem[_84] else: if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[0] = stor17[idx] mem[32] = 18 mem[mem[64] + 4] = this.address require ext_code.size(stor18[stor17[idx]]) static call stor18[stor17[idx]].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _70 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_70] == mem[_70] if mem[_70]: mem[mem[64] + 4] = stor17[idx] mem[mem[64] + 36] = -1 mem[mem[64] + 68] = this.address require ext_code.size(stor4) call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args stor17[idx], -1, this.address mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _86 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_86] == mem[_86] idx = idx + 1 continue else: mem[0] = caller mem[32] = 1 if managers[caller] != 1: revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Only managers can use this method' idx = 0 while idx < stor17.length: if caller == address(stor0): mem[0] = stor17[idx] mem[32] = 18 mem[mem[64] + 4] = this.address require ext_code.size(stor18[stor17[idx]]) static call stor18[stor17[idx]].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _69 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_69] == mem[_69] if mem[_69]: mem[mem[64] + 4] = stor17[idx] mem[mem[64] + 36] = -1 mem[mem[64] + 68] = this.address require ext_code.size(stor4) call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args stor17[idx], -1, this.address mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _85 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_85] == mem[_85] else: if managers[caller] != 1: revert with 0, 'Only managers can use this method' mem[0] = stor17[idx] mem[32] = 18 mem[mem[64] + 4] = this.address require ext_code.size(stor18[stor17[idx]]) static call stor18[stor17[idx]].balanceOf(address account) with: gas gas_remaining wei args address(this.address) mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _71 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_71] == mem[_71] if mem[_71]: mem[mem[64] + 4] = stor17[idx] mem[mem[64] + 36] = -1 mem[mem[64] + 68] = this.address require ext_code.size(stor4) call stor4.withdraw(address token, uint256 amount, address destination) with: gas gas_remaining wei args stor17[idx], -1, this.address mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _87 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_87] == mem[_87] idx = idx + 1 continue def unknown828e7f17(): # not payable if address(stor0) != caller: revert with 0, 'Only owner can use this method' mem[96] = 0xb0772d0b00000000000000000000000000000000000000000000000000000000 require ext_code.size(stor3) static call stor3.getAllMarkets() with: gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] mem[96 len return_data.size] = ext_call.return_data[0 len return_data.size] mem[64] = ceil32(return_data.size) + 96 require return_data.size >=′ 32 _5 = mem[96] require mem[96] <= LOCK8605463013() require mem[96] + 127 <′ return_data.size + 96 _7 = mem[mem[96] + 96] require mem[mem[96] + 96] <= LOCK8605463013() require ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 <= LOCK8605463013() and (32 * mem[mem[96] + 96]) + 32 >= 0 mem[64] = ceil32(return_data.size) + (32 * mem[mem[96] + 96]) + 128 mem[ceil32(return_data.size) + 96] = _7 require _5 + (32 * _7) + 32 <= return_data.size idx = 0 s = _5 + 128 t = ceil32(return_data.size) + 128 while idx < _7: require mem[s] == mem[s + 12 len 20] mem[t] = mem[s] idx = idx + 1 s = s + 32 t = t + 32 continue stor16.length = _7 mem[0] = 16 if not _7: idx = 0 while stor16.length > idx: stor16[idx] = 0 idx = idx + 1 continue if address(stor0) != caller: revert with 0, 'Only owner can use this method' require stor16.length <= LOCK8605463013() _167 = mem[64] mem[mem[64]] = stor16.length mem[64] = mem[64] + (32 * stor16.length) + 32 if not stor16.length: _168 = mem[_167] stor15.length = mem[_167] mem[0] = 15 if not _168: idx = 0 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _318 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _337 = mem[_318] require mem[_318] == mem[_318 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_337) idx = idx + 1 continue idx = 0 while idx < stor16.length: require idx < stor15.length require idx < stor16.length mem[0] = 16 mem[mem[64] + 4] = this.address mem[mem[64] + 36] = stor16[idx] require ext_code.size(stor15[idx]) static call stor15[idx].allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), stor16[idx] mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _535 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_535] == mem[_535] if mem[_535]: idx = idx + 1 continue mem[mem[64] + 4] = this.address mem[mem[64] + 36] = stor16[idx] require ext_code.size(stor15[idx]) static call stor15[idx].allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), stor16[idx] mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _559 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_559] == mem[_559] if mem[_559]: revert with 0, 'SafeERC20: approve from non-zero to non-zero allowance' _575 = mem[64] mem[mem[64] + 36] = stor16[idx] mem[mem[64] + 68] = -1 _593 = mem[64] mem[mem[64]] = 68 mem[64] = mem[64] + 100 mem[_593 + 32] = mem[_593 + 36 len 28] or 0x95ea7b300000000000000000000000000000000000000000000000000000000 if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' _615 = mem[_593] s = 0 while s < _615: mem[_575 + s + 100] = mem[_593 + s + 32] s = s + 32 continue if ceil32(_615) > _615: mem[_575 + _615 + 100] = 0 call stor15[idx].mem[mem[64] len 4] with: gas gas_remaining wei args mem[mem[64] + 4 len _575 + _615 + -mem[64] + 96] if ext_call.success: if not return_data.size: else: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) stop s = 0 idx = _167 + 32 while _167 + (32 * _168) + 32 > idx: stor15[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * _168) + 31) >> 5 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _496 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _517 = mem[_496] require mem[_496] == mem[_496 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_517) idx = idx + 1 continue if var171001 >= stor16.length: stop if var171001 < stor15.length: if var171001 < stor16.length: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: mem[_167 + 32 len 32 * stor16.length] = call.data[calldata.size len 32 * stor16.length] _170 = mem[_167] stor15.length = mem[_167] mem[0] = 15 if not _170: idx = 0 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _320 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _339 = mem[_320] require mem[_320] == mem[_320 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_339) idx = idx + 1 continue idx = 0 while idx < stor16.length: require idx < stor15.length require idx < stor16.length mem[0] = 16 mem[mem[64] + 4] = this.address mem[mem[64] + 36] = stor16[idx] require ext_code.size(stor15[idx]) static call stor15[idx].allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), stor16[idx] mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _536 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_536] == mem[_536] if mem[_536]: idx = idx + 1 continue mem[mem[64] + 4] = this.address mem[mem[64] + 36] = stor16[idx] require ext_code.size(stor15[idx]) static call stor15[idx].allowance(address owner, address spender) with: gas gas_remaining wei args address(this.address), stor16[idx] mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _560 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 require mem[_560] == mem[_560] if mem[_560]: revert with 0, 'SafeERC20: approve from non-zero to non-zero allowance' _577 = mem[64] mem[mem[64] + 36] = stor16[idx] mem[mem[64] + 68] = -1 _595 = mem[64] mem[mem[64]] = 68 mem[64] = mem[64] + 100 mem[_595 + 32] = mem[_595 + 36 len 28] or 0x95ea7b300000000000000000000000000000000000000000000000000000000 if ext_code.hash(stor15[idx]) == 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470: revert with 0, 'SafeERC20: call to non-contract' if not ext_code.hash(stor15[idx]): revert with 0, 'SafeERC20: call to non-contract' _618 = mem[_595] s = 0 while s < _618: mem[_577 + s + 100] = mem[_595 + s + 32] s = s + 32 continue if ceil32(_618) > _618: mem[_577 + _618 + 100] = 0 call stor15[idx].mem[mem[64] len 4] with: gas gas_remaining wei args mem[mem[64] + 4 len _577 + _618 + -mem[64] + 96] if ext_call.success: if not return_data.size: else: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) stop s = 0 idx = _167 + 32 while _167 + (32 * _170) + 32 > idx: stor15[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * _170) + 31) >> 5 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _498 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _518 = mem[_498] require mem[_498] == mem[_498 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_518) idx = idx + 1 continue if var172001 >= stor16.length: stop if var172001 < stor15.length: if var172001 < stor16.length: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: s = 0 idx = ceil32(return_data.size) + 128 while ceil32(return_data.size) + (32 * _7) + 128 > idx: stor16[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * _7) + 31) >> 5 while stor16.length > idx: stor16[idx] = 0 idx = idx + 1 continue if address(stor0) != caller: revert with 0, 'Only owner can use this method' require stor16.length <= LOCK8605463013() _249 = mem[64] mem[mem[64]] = stor16.length mem[64] = mem[64] + (32 * stor16.length) + 32 if not stor16.length: _252 = mem[_249] stor15.length = mem[_249] mem[0] = 15 if not _252: idx = 0 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _500 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _519 = mem[_500] require mem[_500] == mem[_500 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_519) idx = idx + 1 continue if var171001 >= stor16.length: stop if var171001 < stor15.length: if var171001 < stor16.length: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: s = 0 idx = _249 + 32 while _249 + (32 * _252) + 32 > idx: stor15[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * _252) + 31) >> 5 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 idx = idx + 1 continue require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 ... # Decompilation aborted, sorry: ("decompilation didn't finish",) if 0 >= stor16.length: stop if 0 < stor15.length: if 0 < stor16.length: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: mem[_249 + 32 len 32 * stor16.length] = call.data[calldata.size len 32 * stor16.length] _256 = mem[_249] stor15.length = mem[_249] mem[0] = 15 if not _256: idx = 0 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: mem[0] = 16 if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 else: require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei mem[mem[64]] = ext_call.return_data[0] if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] _502 = mem[64] mem[64] = mem[64] + ceil32(return_data.size) require return_data.size >=′ 32 _521 = mem[_502] require mem[_502] == mem[_502 + 12 len 20] require idx < stor15.length mem[0] = 15 stor15[idx] = address(_521) idx = idx + 1 continue if var172001 >= stor16.length: stop if var172001 < stor15.length: if var172001 < stor16.length: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) else: s = 0 idx = _249 + 32 while _249 + (32 * _256) + 32 > idx: stor15[s] = mem[idx + 12 len 20] s = s + 1 idx = idx + 32 continue idx = Mask(251, 0, (32 * _256) + 31) >> 5 while stor15.length > idx: stor15[idx] = 0 idx = idx + 1 continue idx = 0 while idx < stor16.length: if stor16[idx] == stor9: require idx < stor15.length mem[0] = 15 stor15[idx] = stor10 idx = idx + 1 continue require ext_code.size(stor16[idx]) static call stor16[idx].underlying() with: gas gas_remaining wei if not ext_call.success: revert with ext_call.return_data[0 len return_data.size] require return_data.size >=′ 32 ... # Decompilation aborted, sorry: ("decompilation didn't finish",) if 0 >= stor16.length: stop if 0 < stor15.length: if 0 < stor16.length: ... # Decompilation aborted, sorry: ("decompilation didn't finish",) revert
Decompilation generated by Panoramix.
Raw bytecode
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