011010

Online Solidity Decompiler

« Decompile another contract

Address

0x000000000000084e91743124a982076c59f10084 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x00000003 rz_16jun22_88961909()
0x00000008 Unknown
0x0000000c gumXZCZ()
0x0000000e Unknown
0x009952eb Unknown
0x0aebace4 Unknown
0x104971c2 Unknown
0x25fda590 Unknown
0x2ea9622e Unknown
0x363ce139 Unknown
0x3a293885 Unknown
0x42422ed9 Unknown
0x47715d18 Unknown
0x4777b3e7 Unknown
0x481c6a75 manager()
0x4955bae6 Unknown
0x4fb2e45d transferOwner(address)
0x578e4b23 Unknown
0x58d4696c Unknown
0x6adfb982 Unknown
0x737fa33d Unknown
0x7b80ec8c Unknown
0x8da5cb5b owner()
0x98061191 Unknown
0x9af73484 Unknown
0xc4d66de8 initialize(address)
0xccc39909 transferManagership(address)
0xccf12304 set_mint(uint256)
0xd6c1a7fd Unknown
0xfa7cd1d3 Unknown
0xff1cdcbf Unknown

Internal Methods

func_024C(arg0, arg1)
func_027A(arg0, arg1)
func_02AE(arg0, arg1)
func_02DC(arg0, arg1)
func_0310(arg0, arg1) returns (r0)
func_036A(arg0, arg1)
func_03BE(arg0, arg1)
func_03EC(arg0, arg1)
func_04CF(arg0, arg1)
func_04FD(arg0, arg1)
func_0531(arg0, arg1)
func_0562(arg0, arg1)
transferOwner(arg0, arg1)
func_05F6(arg0, arg1)
func_0624(arg0, arg1)
func_0668(arg0, arg1)
func_0696(arg0, arg1) returns (r0)
func_06E3(arg0, arg1)
func_0745(arg0, arg1)
func_081E(arg0, arg1)
initialize(arg0, arg1)
transferManagership(arg0, arg1)
set_mint(arg0, arg1)
func_0902(arg0, arg1)
func_0948(arg0, arg1)
func_0D13(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) returns (r0)
func_0D4E(arg0, arg3, arg4) returns (r0)
func_0F82(arg0, arg1, arg2)
func_10C2(arg0, arg1)
func_181F() returns (r0)
func_18BD(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg11) returns (r0)
manager(arg0) returns (r0)
func_1F66()
owner(arg0) returns (r0)
func_3135(arg0)
func_3331(arg0, arg1, arg2, arg3, arg4)
func_336D(arg0, arg1, arg2)
func_3377(arg0, arg1) returns (r0)
func_35F9(arg0, arg1) returns (r0)
func_360F(arg0, arg1) returns (r0, r1)
func_36F2(arg0, arg1, arg2) returns (r0)
func_371C(arg0, arg1)
func_3794(arg0, arg1, arg2, arg3, arg4)
func_3E25(arg0, arg1) returns (r0)
func_40F0(arg0) returns (r0)
func_40FE(arg0) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { stop(); } var var0 = msg.data[0x00:0x20] >> 0xe0; if (0x4955bae6 > var0) { if (0x25fda590 > var0) { if (0x0e > var0) { if (var0 == 0x03) { var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var2 = msg.data[var2:var2 + 0x20]; var3 = msg.sender == 0xdd07249e403979bd79848c27aa5454c7e66bdee7; if (!var3) { var3 = msg.sender == 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0; if (var3) { goto label_0A50; } else { goto label_0A38; } } else if (var3) { label_0A50: if (var3) { label_0A6B: if (!var3) { revert(memory[0x00:0x00]); } label_0A75: var3 = 0x000a80; var var4 = var2; func_3135(var4); label_0A80: // Error: Could not resolve jump destination! } else { label_0A57: memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { goto label_0A75; } else { revert(memory[0x00:0x00]); } } } else { label_0A38: var3 = msg.sender == 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899; if (var3) { goto label_0A6B; } else { goto label_0A57; } } } else if (var0 == 0x08) { var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_024C(var2, var3); stop(); } else if (var0 == 0x0c) { var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_027A(var2, var3); stop(); } else { stop(); } } else if (var0 == 0x0e) { var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_02AE(var2, var3); stop(); } else if (var0 == 0x9952eb) { // Dispatch table entry for 0x009952eb (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_02DC(var2, var3); stop(); } else if (var0 == 0x0aebace4) { // Dispatch table entry for 0x0aebace4 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00031b; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = func_0310(var2, var3); label_031B: var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + temp0 - temp1 + 0x20]; } else if (var0 == 0x104971c2) { // Dispatch table entry for 0x104971c2 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } func_036A(var2, var3); stop(); } else { stop(); } } else if (0x42422ed9 > var0) { if (var0 == 0x25fda590) { // Dispatch table entry for 0x25fda590 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_03BE(var2, var3); stop(); } else if (var0 == 0x2ea9622e) { // Dispatch table entry for 0x2ea9622e (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_03EC(var2, var3); stop(); } else if (var0 == 0x363ce139) { // Dispatch table entry for 0x363ce139 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x000497; var1 = func_181F(); label_0497: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = var1; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + temp2 - temp3 + 0x20]; } else if (var0 == 0x3a293885) { // Dispatch table entry for 0x3a293885 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_04CF(var2, var3); stop(); } else { stop(); } } else if (var0 == 0x42422ed9) { // Dispatch table entry for 0x42422ed9 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_04FD(var2, var3); stop(); } else if (var0 == 0x47715d18) { // Dispatch table entry for 0x47715d18 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_0531(var2, var3); stop(); } else if (var0 == 0x4777b3e7) { // Dispatch table entry for 0x4777b3e7 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_0562(var2, var3); stop(); } else if (var0 == 0x481c6a75) { // Dispatch table entry for manager() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00031b; var2 = manager(); goto label_031B; } else { stop(); } } else if (0x98061191 > var0) { if (0x6adfb982 > var0) { if (var0 == 0x4955bae6) { // Dispatch table entry for 0x4955bae6 (unknown) var1 = 0x0001f6; func_1F66(); stop(); } else if (var0 == 0x4fb2e45d) { // Dispatch table entry for transferOwner(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } transferOwner(var2, var3); stop(); } else if (var0 == 0x578e4b23) { // Dispatch table entry for 0x578e4b23 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_05F6(var2, var3); stop(); } else if (var0 == 0x58d4696c) { // Dispatch table entry for 0x58d4696c (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_0624(var2, var3); stop(); } else { stop(); } } else if (var0 == 0x6adfb982) { // Dispatch table entry for 0x6adfb982 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_0668(var2, var3); stop(); } else if (var0 == 0x737fa33d) { // Dispatch table entry for 0x737fa33d (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x000497; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = func_0696(var2, var3); goto label_0497; } else if (var0 == 0x7b80ec8c) { // Dispatch table entry for 0x7b80ec8c (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_06E3(var2, var3); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00031b; var2 = owner(); goto label_031B; } else { stop(); } } else if (0xccf12304 > var0) { if (var0 == 0x98061191) { // Dispatch table entry for 0x98061191 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } func_0745(var2, var3); stop(); } else if (var0 == 0x9af73484) { // Dispatch table entry for 0x9af73484 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_081E(var2, var3); stop(); } else if (var0 == 0xc4d66de8) { // Dispatch table entry for initialize(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } initialize(var2, var3); stop(); } else if (var0 == 0xccc39909) { // Dispatch table entry for transferManagership(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } transferManagership(var2, var3); stop(); } else { stop(); } } else if (var0 == 0xccf12304) { // Dispatch table entry for set_mint(uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } set_mint(var2, var3); stop(); } else if (var0 == 0xd6c1a7fd) { // Dispatch table entry for 0xd6c1a7fd (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_0902(var2, var3); stop(); } else if (var0 == 0xfa7cd1d3) { // Dispatch table entry for 0xfa7cd1d3 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = address(this); var2 = 0x00; var3 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var4 = 0x70a08231; var var5 = temp4 + 0x24; var var6 = 0x20; var var7 = memory[0x40:0x60]; var var8 = temp4 - var7 + 0x24; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp5; temp5, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp5; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var2 = memory[var3:var3 + 0x20]; if (!var2) { selfdestruct(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff); } var3 = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var4 = 0x2e1a7d4d; var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = (var4 & 0xffffffff) << 0xe0; var temp7 = temp6 + 0x04; memory[temp7:temp7 + 0x20] = var2; var5 = temp7 + 0x20; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp8; temp8, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp8; if (!var6) { selfdestruct(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff); } var temp9 = returndata.length; memory[0x00:0x00 + temp9] = returndata[0x00:0x00 + temp9]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp10 = returndata.length; memory[0x00:0x00 + temp10] = returndata[0x00:0x00 + temp10]; revert(memory[0x00:0x00 + returndata.length]); } } else if (var0 == 0xff1cdcbf) { // Dispatch table entry for 0xff1cdcbf (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0001f6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_0948(var2, var3); stop(); } else { stop(); } } function func_024C(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != 0x58d46ae3114fc82d80f57c9a2a322845a19418fb) { revert(memory[0x00:0x00]); } var temp0 = arg0 ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5; arg1 = temp0; var var0 = arg1 >> 0x48; var var1 = 0x00; var var2 = 0x000ade; var var3 = var0; var var4 = arg1 >> 0x38; var2 = func_3377(var3, var4); var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = 0x45544abf5936deb78490d38ec42b80757d16c014; var1 = var2; var2 = 0x00; var3 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x70a08231; var var5 = temp1 + 0x24; var var6 = 0x20; var var7 = memory[0x40:0x60]; var var8 = temp1 - var7 + 0x24; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp2; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var temp3 = memory[var3:var3 + 0x20]; var2 = temp3; var3 = 0x45544abf5936deb78490d38ec42b80757d16c014; var4 = 0x02; var5 = var0; var6 = var1; var7 = 0x000bc1; var8 = var2; var9 = 0x01; var7 = func_35F9(var8, var9); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = (var4 & 0xffffffff) << 0xe0; var temp5 = temp4 + 0x04; memory[temp5:temp5 + 0x20] = var5 & 0xffffffffffffffffffffffffffffffffffffffff; var temp6 = temp5 + 0x20; memory[temp6:temp6 + 0x20] = var6 & 0xffffffffffffffffffffffffffffffffffffffff; var temp7 = temp6 + 0x20; memory[temp7:temp7 + 0x20] = var7; var5 = temp7 + 0x20; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp8; temp8, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp8; if (!var6) { var3 = 0x00; var4 = var3; var5 = 0x000c86; var6 = var1; var7 = var0; var5, var6 = func_360F(var6, var7); var temp9 = var6; var4 = temp9; var3 = var5; var5 = 0x00; var6 = 0x000d56; var7 = 0x000d4e; var8 = var4; var9 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var10 = 0x70a08231; var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = (var10 & 0xffffffff) << 0xe0; var temp11 = temp10 + 0x04; memory[temp11:temp11 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var11 = temp11 + 0x20; var12 = 0x20; var var13 = memory[0x40:0x60]; var var14 = var11 - var13; var var15 = var13; var var16 = var9; var var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } var7 = func_0D13(var8, var9, var10, var11, var12, var13, var14, var15, var16, var17); var6 = func_0D4E(var3, var4, var7); var5 = var6; if (var5 <= (arg1 & 0xffffffff) * 0xe8d4a51000) { revert(memory[0x00:0x00]); } var6 = 0x00; var7 = var6; if (0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < var0 & 0xffffffffffffffffffffffffffffffffffffffff) { var7 = 0x00; var6 = var5; var8 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var12 = address(this); var temp12 = memory[0x40:0x60]; var13 = temp12; var14 = 0x00; memory[var13:var13 + 0x20] = var14; memory[0x40:0x60] = var13 + (var14 + 0x1f & ~0x1f) + 0x20; if (!var14) { label_0E04: var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp14 = temp13 + 0x04; var14 = temp14; memory[var14:var14 + 0x20] = var10; var temp15 = var14 + 0x20; memory[temp15:temp15 + 0x20] = var11; var temp16 = temp15 + 0x20; memory[temp16:temp16 + 0x20] = var12 & 0xffffffffffffffffffffffffffffffffffffffff; var temp17 = temp16 + 0x20; var15 = temp17; var temp18 = var15 + 0x20; memory[var15:var15 + 0x20] = temp18 - var14; var temp19 = var13; memory[temp18:temp18 + 0x20] = memory[temp19:temp19 + 0x20]; var16 = temp18 + 0x20; var var18 = memory[temp19:temp19 + 0x20]; var17 = temp19 + 0x20; var var19 = var18; var var20 = var16; var var21 = var17; var var22 = 0x00; if (var22 >= var19) { label_0E91: var temp20 = var18; var16 = temp20 + var16; var17 = temp20 & 0x1f; if (!var17) { var10 = var16; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } label_0EE2: var temp21; temp21, memory[var12:var12 + var11] = address(var16).call.gas(msg.gas).value(var15)(memory[var14:var14 + var13]); var11 = !temp21; if (!var11) { var8 = block.coinbase & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x08fc; var10 = 0x64; var temp22 = arg1; var11 = var5 - (temp22 & 0xffffffff) * 0xe8d4a51000 * ((temp22 >> 0x40) & 0xff); if (!var10) { assert(); } var temp23 = var11 / var10; var temp24 = memory[0x40:0x60]; var temp25; temp25, memory[temp24:temp24 + 0x00] = address(var8).call.gas(!temp23 * var9).value(temp23)(memory[temp24:temp24 + memory[0x40:0x60] - temp24]); var8 = !temp25; if (var8) { var temp26 = returndata.length; memory[0x00:0x00 + temp26] = returndata[0x00:0x00 + temp26]; revert(memory[0x00:0x00 + returndata.length]); } else if (!(arg1 >> 0xfc)) { label_0F96: return; } else { var8 = 0x000f96; var9 = 0x10; var10 = (arg1 >> 0xe4) & 0xffffff; func_0F82(arg1, var9, var10); goto label_0F96; } } else { var temp27 = returndata.length; memory[0x00:0x00 + temp27] = returndata[0x00:0x00 + temp27]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp28 = var17; var temp29 = var16 - temp28; memory[temp29:temp29 + 0x20] = ~(0x0100 ** (0x20 - temp28) - 0x01) & memory[temp29:temp29 + 0x20]; var10 = temp29 + 0x20; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (!var17) { goto label_0EE2; } else { revert(memory[0x00:0x00]); } } } else { label_0E81: var temp30 = var22; memory[temp30 + var20:temp30 + var20 + 0x20] = memory[temp30 + var21:temp30 + var21 + 0x20]; var22 = temp30 + 0x20; if (var22 >= var19) { goto label_0E91; } else { goto label_0E81; } } } else { label_0DF8: var temp31 = var13; var temp32 = var14; memory[temp31 + 0x20:temp31 + 0x20 + temp32] = code[code.length:code.length + temp32]; var temp33 = memory[0x40:0x60]; memory[temp33:temp33 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp34 = temp33 + 0x04; var14 = temp34; memory[var14:var14 + 0x20] = var10; var temp35 = var14 + 0x20; memory[temp35:temp35 + 0x20] = var11; var temp36 = temp35 + 0x20; memory[temp36:temp36 + 0x20] = var12 & 0xffffffffffffffffffffffffffffffffffffffff; var temp37 = temp36 + 0x20; var15 = temp37; var temp38 = var15 + 0x20; memory[var15:var15 + 0x20] = temp38 - var14; memory[temp38:temp38 + 0x20] = memory[temp31:temp31 + 0x20]; var16 = temp38 + 0x20; var18 = memory[temp31:temp31 + 0x20]; var17 = temp31 + 0x20; var19 = var18; var20 = var16; var21 = var17; var22 = 0x00; if (var22 >= var19) { goto label_0E91; } else { goto label_0E81; } } } else { var8 = 0x00; var9 = var5; var temp39 = var9; var7 = temp39; var temp40 = var8; var6 = temp40; var8 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var12 = address(this); var temp41 = memory[0x40:0x60]; var13 = temp41; var14 = 0x00; memory[var13:var13 + 0x20] = var14; memory[0x40:0x60] = var13 + (var14 + 0x1f & ~0x1f) + 0x20; if (!var14) { goto label_0E04; } else { goto label_0DF8; } } } else { var temp42 = returndata.length; memory[0x00:0x00 + temp42] = returndata[0x00:0x00 + temp42]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp43 = returndata.length; memory[0x00:0x00 + temp43] = returndata[0x00:0x00 + temp43]; revert(memory[0x00:0x00 + returndata.length]); } } function func_027A(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = msg.sender == 0xdd07249e403979bd79848c27aa5454c7e66bdee7; if (!var0) { var0 = msg.sender == 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0; if (var0) { goto label_0FF7; } else { goto label_0FDF; } } else if (var0) { label_0FF7: if (var0) { label_1012: if (!var0) { revert(memory[0x00:0x00]); } label_101C: var temp1 = arg1 ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5; var0 = temp1; if (var0 & 0xffffffffffffffffffffffff == address(var0 >> 0x60).balance) { var var1 = 0x0010e2; var var2 = arg0; func_3135(var2); label_10E2: label_10E4: return; } else if (!((arg0 >> 0xe8) & 0x0f)) { label_10D0: goto label_10E4; } else { var temp2 = memory[0x40:0x60]; var temp3 = arg0; memory[temp2 + 0x20:temp2 + 0x20 + 0x20] = temp3 & 0xffffff0000000000000000000000000000000000000000000000000000000000; var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = temp2 - temp4 + 0x03; memory[0x40:0x60] = temp2 + 0x23; var1 = 0x0010d0; var2 = (((temp3 ~ keccak256(memory[temp4 + 0x20:temp4 + 0x20 + memory[temp4:temp4 + 0x20]])) >> 0xd0) & 0xffffff) / 0x10 & 0xffffff; var var3 = 0x01; func_371C(var2, var3); goto label_10D0; } } else { label_0FFE: memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { goto label_101C; } else { revert(memory[0x00:0x00]); } } } else { label_0FDF: var0 = msg.sender == 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899; if (var0) { goto label_1012; } else { goto label_0FFE; } } } function func_02AE(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != 0x58d46ae3114fc82d80f57c9a2a322845a19418fb) { revert(memory[0x00:0x00]); } arg1 = arg0 ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5; var var0 = arg1; var var1 = 0x00; var var2 = var1; var var3 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = 0x0902f1ac; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var4 & 0xffffffff) << 0xe0; var var5 = temp0 + 0x04; var var6 = 0x60; var var7 = memory[0x40:0x60]; var var8 = var5 - var7; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp1; temp1, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp1; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x60) { revert(memory[0x00:0x00]); } var temp2 = var3; var1 = memory[temp2:temp2 + 0x20] & 0xffffffffffffffffffffffffffff; var2 = memory[temp2 + 0x20:temp2 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff; if (((arg1 >> 0xa0) & 0xff) / 0x0a & 0xff == 0x00) { var temp32 = var2; var2 = var1; var1 = temp32; if (var1 < ((arg1 >> 0xc8) & 0xffffffff) * 0x5af3107a4000) { goto label_1208; } else { goto label_11FF; } } else if (var1 < ((arg1 >> 0xc8) & 0xffffffff) * 0x5af3107a4000) { label_1208: var3 = ((arg1 >> 0xa8) & 0xffffffff) * 0xe8d4a51000; var4 = 0x00; var5 = 0x001229; var6 = var3; var7 = var1; var8 = var2; var5 = func_36F2(var6, var7, var8); var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; memory[temp3 + 0x04:temp3 + 0x04 + 0x20] = var0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp3 + 0x24:temp3 + 0x24 + 0x20] = var3; var4 = var5; var5 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var6 = 0xa9059cbb; var7 = temp3 + 0x44; var8 = 0x20; var9 = memory[0x40:0x60]; var10 = temp3 - var9 + 0x44; var11 = var9; var var12 = 0x00; var var13 = var5; var var14 = !address(var13).code.length; if (var14) { revert(memory[0x00:0x00]); } var temp4; temp4, memory[var9:var9 + var8] = address(var13).call.gas(msg.gas).value(var12)(memory[var11:var11 + var10]); var8 = !temp4; if (!var8) { var5 = memory[0x40:0x60]; var6 = returndata.length; if (var6 < 0x20) { revert(memory[0x00:0x00]); } var5 = 0x00; var6 = var5; if (((arg1 >> 0xa0) & 0xff) / 0x0a & 0xff == 0x01) { var6 = var4; var5 = 0x00; var7 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var8 = 0x022c0d9f; var9 = var5; var10 = var6; var11 = 0x45544abf5936deb78490d38ec42b80757d16c014; var temp5 = memory[0x40:0x60]; var12 = temp5; var13 = 0x00; memory[var12:var12 + 0x20] = var13; memory[0x40:0x60] = var12 + (var13 + 0x1f & ~0x1f) + 0x20; if (!var13) { label_1370: var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = (var8 & 0xffffffff) << 0xe0; var temp7 = temp6 + 0x04; var13 = temp7; memory[var13:var13 + 0x20] = var9; var temp8 = var13 + 0x20; memory[temp8:temp8 + 0x20] = var10; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x20] = var11 & 0xffffffffffffffffffffffffffffffffffffffff; var temp10 = temp9 + 0x20; var14 = temp10; var temp11 = var14 + 0x20; memory[var14:var14 + 0x20] = temp11 - var13; var temp12 = var12; memory[temp11:temp11 + 0x20] = memory[temp12:temp12 + 0x20]; var var15 = temp11 + 0x20; var var16 = temp12 + 0x20; var var17 = memory[temp12:temp12 + 0x20]; var var18 = var17; var var19 = var15; var var20 = var16; var var21 = 0x00; if (var21 >= var18) { label_13FD: var temp13 = var17; var15 = temp13 + var15; var16 = temp13 & 0x1f; if (!var16) { var9 = var15; var10 = 0x00; var11 = memory[0x40:0x60]; var12 = var9 - var11; var13 = var11; var14 = 0x00; var15 = var7; var16 = !address(var15).code.length; if (var16) { revert(memory[0x00:0x00]); } label_144E: var temp14; temp14, memory[var11:var11 + var10] = address(var15).call.gas(msg.gas).value(var14)(memory[var13:var13 + var12]); var10 = !temp14; if (var10) { var temp16 = returndata.length; memory[0x00:0x00 + temp16] = returndata[0x00:0x00 + temp16]; revert(memory[0x00:0x00 + returndata.length]); } else if (!(arg1 >> 0xfc)) { label_1496: return; } else { var7 = 0x001496; var temp15 = arg1; var8 = ((temp15 >> 0xe4) & 0xffffff) / 0x10 & 0xffffff; var9 = (temp15 >> 0xfc) & 0xff; func_371C(var8, var9); goto label_1496; } } else { var temp17 = var16; var temp18 = var15 - temp17; memory[temp18:temp18 + 0x20] = ~(0x0100 ** (0x20 - temp17) - 0x01) & memory[temp18:temp18 + 0x20]; var9 = temp18 + 0x20; var10 = 0x00; var11 = memory[0x40:0x60]; var12 = var9 - var11; var13 = var11; var14 = 0x00; var15 = var7; var16 = !address(var15).code.length; if (!var16) { goto label_144E; } else { revert(memory[0x00:0x00]); } } } else { label_13ED: var temp19 = var21; memory[temp19 + var19:temp19 + var19 + 0x20] = memory[temp19 + var20:temp19 + var20 + 0x20]; var21 = temp19 + 0x20; if (var21 >= var18) { goto label_13FD; } else { goto label_13ED; } } } else { label_1364: var temp20 = var12; var temp21 = var13; memory[temp20 + 0x20:temp20 + 0x20 + temp21] = code[code.length:code.length + temp21]; var temp22 = memory[0x40:0x60]; memory[temp22:temp22 + 0x20] = (var8 & 0xffffffff) << 0xe0; var temp23 = temp22 + 0x04; var13 = temp23; memory[var13:var13 + 0x20] = var9; var temp24 = var13 + 0x20; memory[temp24:temp24 + 0x20] = var10; var temp25 = temp24 + 0x20; memory[temp25:temp25 + 0x20] = var11 & 0xffffffffffffffffffffffffffffffffffffffff; var temp26 = temp25 + 0x20; var14 = temp26; var temp27 = var14 + 0x20; memory[var14:var14 + 0x20] = temp27 - var13; memory[temp27:temp27 + 0x20] = memory[temp20:temp20 + 0x20]; var15 = temp27 + 0x20; var17 = memory[temp20:temp20 + 0x20]; var16 = temp20 + 0x20; var18 = var17; var19 = var15; var20 = var16; var21 = 0x00; if (var21 >= var18) { goto label_13FD; } else { goto label_13ED; } } } else { var7 = var4; var8 = 0x00; var temp28 = var8; var6 = temp28; var temp29 = var7; var5 = temp29; var7 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var8 = 0x022c0d9f; var9 = var5; var10 = var6; var11 = 0x45544abf5936deb78490d38ec42b80757d16c014; var temp30 = memory[0x40:0x60]; var12 = temp30; var13 = 0x00; memory[var12:var12 + 0x20] = var13; memory[0x40:0x60] = var12 + (var13 + 0x1f & ~0x1f) + 0x20; if (!var13) { goto label_1370; } else { goto label_1364; } } } else { var temp31 = returndata.length; memory[0x00:0x00 + temp31] = returndata[0x00:0x00 + temp31]; revert(memory[0x00:0x00 + returndata.length]); } } else { label_11FF: return; } } else { var temp33 = returndata.length; memory[0x00:0x00 + temp33] = returndata[0x00:0x00 + temp33]; revert(memory[0x00:0x00 + returndata.length]); } } function func_02DC(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = msg.sender == 0xdd07249e403979bd79848c27aa5454c7e66bdee7; if (!var0) { var0 = msg.sender == 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0; if (var0) { goto label_14F6; } else { goto label_14DE; } } else if (var0) { label_14F6: if (var0) { label_1511: if (!var0) { revert(memory[0x00:0x00]); } label_151B: var temp1 = memory[0x40:0x60]; var temp2 = arg0; memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = (temp2 << 0xe8) & 0xffffff0000000000000000000000000000000000000000000000000000000000; var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = temp1 - temp3 + 0x03; memory[0x40:0x60] = temp1 + 0x23; var0 = temp2 ~ keccak256(memory[temp3 + 0x20:temp3 + 0x20 + memory[temp3:temp3 + 0x20]]); var temp4 = arg1 ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5; var var1 = temp4; if (var1 & 0xffffffffffffffffffffffff != address(var1 >> 0x60).balance) { var var2 = 0x0015f7; var temp5 = var0; var var3 = temp5 >> 0x48; var var4 = temp5 >> 0x40; var var5 = temp5 >> 0x38; var var6 = (temp5 >> 0x28) & 0x0fff; var var7 = temp5 >> 0x18; func_3794(var3, var4, var5, var6, var7); label_15F7: if (!(arg0 >> 0xfc)) { label_1626: return; } else { var2 = 0x001626; var temp6 = arg0; var3 = ((temp6 >> 0xe4) & 0xffffff) / 0x10 & 0xffffff; var4 = (temp6 >> 0xfc) & 0xff; func_371C(var3, var4); goto label_1626; } } else if (!(arg0 >> 0xfc)) { label_15C8: return; } else { var2 = 0x0015c8; var3 = 0x10; var4 = (arg0 >> 0xe4) & 0xffffff; func_10C2(var3, var4); goto label_15C8; } } else { label_14FD: memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { goto label_151B; } else { revert(memory[0x00:0x00]); } } } else { label_14DE: var0 = msg.sender == 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899; if (var0) { goto label_1511; } else { goto label_14FD; } } } function func_0310(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xff; memory[0x00:0x20] = arg0 & 0xff; memory[0x20:0x40] = 0x05; return storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_036A(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var var0 = msg.data[temp0 + 0x40:temp0 + 0x40 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x0200000000000000000000000000000000000000000000000000000000; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp1 + 0x24:temp1 + 0x24 + 0x20] = msg.sender; memory[temp1 + 0x44:temp1 + 0x44 + 0x20] = var0; var var1 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var var2 = 0x02; var var3 = temp1 + 0x64; var var4 = 0x00; var var5 = memory[0x40:0x60]; var var6 = temp1 - var5 + 0x64; var var7 = var5; var var8 = var4; var var9 = var1; var var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]); var4 = !temp2; if (!var4) { return; } var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } function func_03BE(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0xff000000000000084e91743124a982076c59f100840000000000000000000000; memory[temp0 + 0x35:temp0 + 0x35 + 0x20] = 0x17f2c5b31e6ffc755997e952174fc537025e254986b5630bbadd188e008f2e93; memory[temp0 + 0x15:temp0 + 0x15 + 0x20] = arg0; memory[msg.value:msg.value + msg.value] = address(keccak256(memory[temp0:temp0 + 0x55])).call.gas(msg.gas).value(msg.value)(memory[msg.value:msg.value + msg.value]); } function func_03EC(var arg0, var arg1) { var temp0 = arg0; arg0 = temp0 + arg1; arg1 = temp0; var var0 = arg1 + 0x20; var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp1 = arg1 + var1; var1 = temp1; if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); } var temp2 = var1; var temp3 = msg.data[temp2:temp2 + 0x20]; var1 = temp3; var var2 = var0; var0 = temp2 + 0x20; if ((var1 > 0x0100000000) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); } var temp4 = var1; var temp5 = memory[0x40:0x60]; memory[0x40:0x60] = temp5 + temp4 * 0x20 + 0x20; memory[temp5:temp5 + 0x20] = temp4; var temp6 = temp5 + 0x20; var temp7 = temp4 * 0x20; memory[temp6:temp6 + temp7] = msg.data[var0:var0 + temp7]; memory[temp6 + temp7:temp6 + temp7 + 0x20] = 0x00; arg0 = temp5; arg1 = !!msg.data[var2:var2 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var0 = 0x00; if (var0 >= memory[arg0:arg0 + 0x20]) { label_10E2: return; } else { label_17A8: var1 = arg1; var2 = 0x02; var var3 = 0x00; var var4 = arg0; var var5 = var0; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var temp8 = var3; memory[temp8:temp8 + 0x20] = memory[var5 * 0x20 + var4 + 0x20:var5 * 0x20 + var4 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp8 + 0x20:temp8 + 0x20 + 0x20] = var2; var temp9 = keccak256(memory[0x00:0x00 + temp8 + 0x40]); storage[temp9] = !!var1 | (storage[temp9] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00); var0 = var0 + 0x01; if (var0 >= memory[arg0:arg0 + 0x20]) { goto label_10E2; } else { goto label_17A8; } } } function func_04CF(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = address(this); arg1 = 0x00; var var0 = 0x0018f2; var var1 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var var2 = 0x70a08231; var var3 = temp0 + 0x24; var var4 = 0x20; var var5 = memory[0x40:0x60]; var var6 = temp0 - var5 + 0x24; var var7 = var5; var var8 = var1; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var0 = func_18BD(arg0, var1, var2, var3, var4, var5, var6, var7, var8, var9); var temp1 = var0; arg1 = temp1; var0 = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var1 = 0x2e1a7d4d; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = (var1 & 0xffffffff) << 0xe0; var temp3 = temp2 + 0x04; memory[temp3:temp3 + 0x20] = arg1; var2 = temp3 + 0x20; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp4; temp4, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp4; if (!var3) { var temp5 = memory[0x40:0x60]; var temp6 = arg1; var temp7; temp7, memory[temp5:temp5 + 0x00] = address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp6 * 0x08fc).value(temp6)(memory[temp5:temp5 + 0x00]); var0 = !temp7; if (!var0) { return; } var temp8 = returndata.length; memory[0x00:0x00 + temp8] = returndata[0x00:0x00 + temp8]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp9 = returndata.length; memory[0x00:0x00 + temp9] = returndata[0x00:0x00 + temp9]; revert(memory[0x00:0x00 + returndata.length]); } } function func_04FD(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = msg.sender == 0xdd07249e403979bd79848c27aa5454c7e66bdee7; if (!var0) { var0 = msg.sender == 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0; if (var0) { goto label_1A11; } else { goto label_19F9; } } else if (var0) { label_1A11: if (var0) { label_1A2C: if (!var0) { revert(memory[0x00:0x00]); } label_1A36: var temp1 = memory[0x40:0x60]; var temp2 = arg0; memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = (temp2 << 0xe8) & 0xffffff0000000000000000000000000000000000000000000000000000000000; var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = temp1 - temp3 + 0x03; memory[0x40:0x60] = temp1 + 0x23; var temp4 = temp2 ~ keccak256(memory[temp3 + 0x20:temp3 + 0x20 + memory[temp3:temp3 + 0x20]]); var0 = temp4; var var1 = var0 >> 0x48; var var2 = 0x00; var var3 = 0x001a9a; var var4 = var1; var var5 = var0 >> 0x38; var3 = func_3377(var4, var5); var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; memory[temp5 + 0x04:temp5 + 0x04 + 0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp5 + 0x24:temp5 + 0x24 + 0x20] = arg1; var2 = var3; var3 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var4 = 0xa9059cbb; var5 = temp5 + 0x44; var var6 = 0x20; var var7 = memory[0x40:0x60]; var var8 = temp5 - var7 + 0x44; var var9 = var7; var var10 = 0x00; var var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp6; temp6, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp6; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var3 = 0x00; var4 = var3; var5 = 0x001b66; var6 = var2; var7 = var1; var5, var6 = func_360F(var6, var7); var temp7 = var6; var4 = temp7; var temp8 = var5; var3 = temp8; var5 = 0x00; var6 = 0x001b79; var7 = arg1; var8 = var3; var9 = var4; var6 = func_36F2(var7, var8, var9); var5 = var6; var6 = 0x00; var7 = var6; if (0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < var1 & 0xffffffffffffffffffffffffffffffffffffffff) { var7 = var5; var6 = 0x00; var8 = var2 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var12 = address(this); var temp9 = memory[0x40:0x60]; var var14 = 0x00; var var13 = temp9; memory[var13:var13 + 0x20] = var14; memory[0x40:0x60] = var13 + (var14 + 0x1f & ~0x1f) + 0x20; if (!var14) { label_1C0D: var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp11 = temp10 + 0x04; var14 = temp11; memory[var14:var14 + 0x20] = var10; var temp12 = var14 + 0x20; memory[temp12:temp12 + 0x20] = var11; var temp13 = temp12 + 0x20; memory[temp13:temp13 + 0x20] = var12 & 0xffffffffffffffffffffffffffffffffffffffff; var temp14 = temp13 + 0x20; var var15 = temp14; var temp15 = var15 + 0x20; memory[var15:var15 + 0x20] = temp15 - var14; var temp16 = var13; memory[temp15:temp15 + 0x20] = memory[temp16:temp16 + 0x20]; var var16 = temp15 + 0x20; var var17 = temp16 + 0x20; var var18 = memory[temp16:temp16 + 0x20]; var var19 = var18; var var20 = var16; var var21 = var17; var var22 = 0x00; if (var22 >= var19) { label_1C9A: var temp17 = var18; var16 = temp17 + var16; var17 = temp17 & 0x1f; if (!var17) { var10 = var16; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } label_1CEB: var temp18; temp18, memory[var12:var12 + var11] = address(var16).call.gas(msg.gas).value(var15)(memory[var14:var14 + var13]); var11 = !temp18; if (!var11) { var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp19 + 0x04:temp19 + 0x04 + 0x20] = address(this); var8 = 0x01; var9 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var10 = 0x70a08231; var11 = temp19 + 0x24; var12 = 0x20; var13 = memory[0x40:0x60]; var14 = temp19 - var13 + 0x24; var15 = var13; var16 = var9; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } var temp20; temp20, memory[var13:var13 + var12] = address(var16).staticcall.gas(msg.gas)(memory[var15:var15 + var14]); var12 = !temp20; if (!var12) { var9 = memory[0x40:0x60]; var10 = returndata.length; if (var10 < 0x20) { revert(memory[0x00:0x00]); } if (memory[var9:var9 + 0x20] > var8) { return; } var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; memory[temp21 + 0x04:temp21 + 0x04 + 0x20] = 0x20; memory[temp21 + 0x24:temp21 + 0x24 + 0x20] = 0x03; memory[temp21 + 0x44:temp21 + 0x44 + 0x20] = 0x4e54460000000000000000000000000000000000000000000000000000000000; var temp22 = memory[0x40:0x60]; revert(memory[temp22:temp22 + temp21 - temp22 + 0x64]); } else { var temp23 = returndata.length; memory[0x00:0x00 + temp23] = returndata[0x00:0x00 + temp23]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp24 = returndata.length; memory[0x00:0x00 + temp24] = returndata[0x00:0x00 + temp24]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp25 = var17; var temp26 = var16 - temp25; memory[temp26:temp26 + 0x20] = ~(0x0100 ** (0x20 - temp25) - 0x01) & memory[temp26:temp26 + 0x20]; var10 = temp26 + 0x20; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (!var17) { goto label_1CEB; } else { revert(memory[0x00:0x00]); } } } else { label_1C8A: var temp27 = var22; memory[temp27 + var20:temp27 + var20 + 0x20] = memory[temp27 + var21:temp27 + var21 + 0x20]; var22 = temp27 + 0x20; if (var22 >= var19) { goto label_1C9A; } else { goto label_1C8A; } } } else { label_1C01: var temp28 = var13; var temp29 = var14; memory[temp28 + 0x20:temp28 + 0x20 + temp29] = code[code.length:code.length + temp29]; var temp30 = memory[0x40:0x60]; memory[temp30:temp30 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp31 = temp30 + 0x04; var14 = temp31; memory[var14:var14 + 0x20] = var10; var temp32 = var14 + 0x20; memory[temp32:temp32 + 0x20] = var11; var temp33 = temp32 + 0x20; memory[temp33:temp33 + 0x20] = var12 & 0xffffffffffffffffffffffffffffffffffffffff; var temp34 = temp33 + 0x20; var15 = temp34; var temp35 = var15 + 0x20; memory[var15:var15 + 0x20] = temp35 - var14; memory[temp35:temp35 + 0x20] = memory[temp28:temp28 + 0x20]; var16 = temp35 + 0x20; var18 = memory[temp28:temp28 + 0x20]; var17 = temp28 + 0x20; var19 = var18; var20 = var16; var21 = var17; var22 = 0x00; if (var22 >= var19) { goto label_1C9A; } else { goto label_1C8A; } } } else { var8 = var5; var9 = 0x00; var temp36 = var9; var7 = temp36; var temp37 = var8; var6 = temp37; var8 = var2 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var12 = address(this); var temp38 = memory[0x40:0x60]; var13 = temp38; var14 = 0x00; memory[var13:var13 + 0x20] = var14; memory[0x40:0x60] = var13 + (var14 + 0x1f & ~0x1f) + 0x20; if (!var14) { goto label_1C0D; } else { goto label_1C01; } } } else { var temp39 = returndata.length; memory[0x00:0x00 + temp39] = returndata[0x00:0x00 + temp39]; revert(memory[0x00:0x00 + returndata.length]); } } else { label_1A18: memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { goto label_1A36; } else { revert(memory[0x00:0x00]); } } } else { label_19F9: var0 = msg.sender == 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899; if (var0) { goto label_1A2C; } else { goto label_1A18; } } } function func_0531(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xff; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } if (arg0 & 0xff <= 0x00) { revert(memory[0x00:0x00]); } arg1 = 0x00; var var0 = 0x001e56; var var1 = memory[0x40:0x60]; var0 = func_40F0(var1); var temp0 = memory[0x40:0x60]; var temp1 = new(memory[temp0:temp0 + var0 - temp0]).value(0x00)(); var0 = temp1; var1 = !var0; if (!var1) { memory[0x00:0x20] = arg0 & 0xff; memory[0x20:0x40] = 0x05; var temp2 = keccak256(memory[0x00:0x40]); storage[temp2] = (var0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[temp2] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000); return; } else { var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } } function func_0562(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } arg1 = 0x00; var var0 = 0x001f01; var var1 = address(this).balance; var var2 = arg0; var0 = func_3E25(var1, var2); var temp0 = memory[0x40:0x60]; var temp1 = var0; arg1 = temp1; var temp2; temp2, memory[temp0:temp0 + 0x00] = address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!arg1 * 0x08fc).value(arg1)(memory[temp0:temp0 + 0x00]); var0 = !temp2; if (!var0) { return; } var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } function transferOwner(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } if (!(arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { revert(memory[0x00:0x00]); } storage[0x00] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x00] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000); } function func_05F6(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; arg1 = msg.sender == 0xdd07249e403979bd79848c27aa5454c7e66bdee7; if (!arg1) { arg1 = msg.sender == 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0; if (arg1) { goto label_20C1; } else { goto label_20A9; } } else if (arg1) { label_20C1: if (arg1) { label_20DC: if (!arg1) { revert(memory[0x00:0x00]); } label_20E6: var temp0 = memory[0x40:0x60]; var temp1 = arg0; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = (temp1 << 0xe8) & 0xffffff0000000000000000000000000000000000000000000000000000000000; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = temp0 - temp2 + 0x03; memory[0x40:0x60] = temp0 + 0x23; var temp3 = temp1 ~ keccak256(memory[temp2 + 0x20:temp2 + 0x20 + memory[temp2:temp2 + 0x20]]); arg1 = temp3; var var0 = 0x00215a; var var1 = arg1 >> 0x48; var var2 = arg1 >> 0x40; var var3 = arg1 >> 0x38; var var4 = (arg1 >> 0x28) & 0x0fff; var var5 = arg1 >> 0x18; func_3794(var1, var2, var3, var4, var5); label_215A: if (!(arg0 >> 0xfc)) { label_10E4: return; } else { var0 = 0x0010e4; var temp4 = arg0; var1 = ((temp4 >> 0xe4) & 0xffffff) / 0x10 & 0xffffff; var2 = (temp4 >> 0xfc) & 0xff; func_371C(var1, var2); goto label_10E4; } } else { label_20C8: memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x02; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { goto label_20E6; } else { revert(memory[0x00:0x00]); } } } else { label_20A9: arg1 = msg.sender == 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899; if (arg1) { goto label_20DC; } else { goto label_20C8; } } } function func_0624(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } arg1 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var0 = 0x84b366dc; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var0 & 0xffffffff) << 0xe0; var var1 = temp0 + 0x04; var var2 = 0x00; var var3 = memory[0x40:0x60]; var var4 = var1 - var3; var var5 = var3; var var6 = 0x00; var var7 = arg1; var var8 = !address(var7).code.length; if (var8) { revert(memory[0x00:0x00]); } var temp1; temp1, memory[var3:var3 + var2] = address(var7).call.gas(msg.gas).value(var6)(memory[var5:var5 + var4]); var2 = !temp1; if (!var2) { return; } var temp2 = returndata.length; memory[0x00:0x00 + temp2] = returndata[0x00:0x00 + temp2]; revert(memory[0x00:0x00 + returndata.length]); } function func_0668(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != 0x58d46ae3114fc82d80f57c9a2a322845a19418fb) { revert(memory[0x00:0x00]); } var temp0 = arg0 ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5; arg1 = temp0; var var0 = arg1 >> 0x48; var var1 = 0x00; var var2 = 0x002252; var var3 = var0; var var4 = arg1 >> 0x38; var2 = func_3377(var3, var4); var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = 0x45544abf5936deb78490d38ec42b80757d16c014; var1 = var2; var2 = 0x00; var3 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x70a08231; var var5 = temp1 + 0x24; var var6 = 0x20; var var7 = memory[0x40:0x60]; var var8 = temp1 - var7 + 0x24; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp2; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var temp3 = memory[var3:var3 + 0x20]; var2 = temp3; var3 = 0x45544abf5936deb78490d38ec42b80757d16c014; var4 = 0x02; var5 = var0; var6 = var1; var7 = 0x002335; var8 = var2; var9 = 0x01; var7 = func_35F9(var8, var9); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = (var4 & 0xffffffff) << 0xe0; var temp5 = temp4 + 0x04; memory[temp5:temp5 + 0x20] = var5 & 0xffffffffffffffffffffffffffffffffffffffff; var temp6 = temp5 + 0x20; memory[temp6:temp6 + 0x20] = var6 & 0xffffffffffffffffffffffffffffffffffffffff; var temp7 = temp6 + 0x20; memory[temp7:temp7 + 0x20] = var7; var5 = temp7 + 0x20; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp8; temp8, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp8; if (!var6) { var3 = 0x00; var4 = var3; var5 = 0x0023fa; var6 = var1; var7 = var0; var5, var6 = func_360F(var6, var7); var temp9 = var6; var4 = temp9; var3 = var5; var5 = 0x00; var6 = 0x002487; var7 = 0x000d4e; var8 = var4; var9 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var10 = 0x70a08231; var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = (var10 & 0xffffffff) << 0xe0; var temp11 = temp10 + 0x04; memory[temp11:temp11 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var11 = temp11 + 0x20; var12 = 0x20; var var13 = memory[0x40:0x60]; var var14 = var11 - var13; var var15 = var13; var var16 = var9; var var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } var7 = func_0D13(var8, var9, var10, var11, var12, var13, var14, var15, var16, var17); var6 = func_0D4E(var3, var4, var7); var5 = var6; var6 = 0x00; var7 = var6; if (0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < var0 & 0xffffffffffffffffffffffffffffffffffffffff) { var7 = 0x00; var6 = var5; var8 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var12 = address(this); var temp12 = memory[0x40:0x60]; var14 = 0x00; var13 = temp12; memory[var13:var13 + 0x20] = var14; memory[0x40:0x60] = var13 + (var14 + 0x1f & ~0x1f) + 0x20; if (!var14) { label_251B: var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp14 = temp13 + 0x04; var14 = temp14; memory[var14:var14 + 0x20] = var10; var temp15 = var14 + 0x20; memory[temp15:temp15 + 0x20] = var11; var temp16 = temp15 + 0x20; memory[temp16:temp16 + 0x20] = var12 & 0xffffffffffffffffffffffffffffffffffffffff; var temp17 = temp16 + 0x20; var15 = temp17; var temp18 = var15 + 0x20; memory[var15:var15 + 0x20] = temp18 - var14; var temp19 = var13; memory[temp18:temp18 + 0x20] = memory[temp19:temp19 + 0x20]; var16 = temp18 + 0x20; var17 = temp19 + 0x20; var var18 = memory[temp19:temp19 + 0x20]; var var19 = var18; var var20 = var16; var var21 = var17; var var22 = 0x00; if (var22 >= var19) { label_25A8: var temp20 = var18; var16 = temp20 + var16; var17 = temp20 & 0x1f; if (!var17) { var10 = var16; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } label_25F9: var temp21; temp21, memory[var12:var12 + var11] = address(var16).call.gas(msg.gas).value(var15)(memory[var14:var14 + var13]); var11 = !temp21; if (var11) { var temp27 = returndata.length; memory[0x00:0x00 + temp27] = returndata[0x00:0x00 + temp27]; revert(memory[0x00:0x00 + returndata.length]); } else if (var5 <= (arg1 & 0xffffffff) * 0xe8d4a51000) { label_268F: if (!(arg1 >> 0xfc)) { label_0F96: return; } else { var8 = 0x000f96; var9 = 0x10; var10 = (arg1 >> 0xe4) & 0xffffff; func_0F82(arg1, var9, var10); goto label_0F96; } } else { var temp22 = arg1; var temp23 = memory[0x40:0x60]; var temp24; temp24, memory[temp23:temp23 + 0x00] = address(block.coinbase).call.gas(msg.gas).value((((temp22 >> 0x40) & 0xff) * (var5 - (temp22 & 0xffffffff) * 0xe8d4a51000)) / 0x64)(memory[temp23:temp23 + 0x00]); var9 = returndata.length; var10 = var9; if (var10 == 0x00) { goto label_268F; } var temp25 = memory[0x40:0x60]; var9 = temp25; memory[0x40:0x60] = var9 + (returndata.length + 0x3f & ~0x1f); memory[var9:var9 + 0x20] = returndata.length; var temp26 = returndata.length; memory[var9 + 0x20:var9 + 0x20 + temp26] = returndata[0x00:0x00 + temp26]; goto label_268F; } } else { var temp28 = var17; var temp29 = var16 - temp28; memory[temp29:temp29 + 0x20] = ~(0x0100 ** (0x20 - temp28) - 0x01) & memory[temp29:temp29 + 0x20]; var10 = temp29 + 0x20; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (!var17) { goto label_25F9; } else { revert(memory[0x00:0x00]); } } } else { label_2598: var temp30 = var22; memory[temp30 + var20:temp30 + var20 + 0x20] = memory[temp30 + var21:temp30 + var21 + 0x20]; var22 = temp30 + 0x20; if (var22 >= var19) { goto label_25A8; } else { goto label_2598; } } } else { label_250F: var temp31 = var13; var temp32 = var14; memory[temp31 + 0x20:temp31 + 0x20 + temp32] = code[code.length:code.length + temp32]; var temp33 = memory[0x40:0x60]; memory[temp33:temp33 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp34 = temp33 + 0x04; var14 = temp34; memory[var14:var14 + 0x20] = var10; var temp35 = var14 + 0x20; memory[temp35:temp35 + 0x20] = var11; var temp36 = temp35 + 0x20; memory[temp36:temp36 + 0x20] = var12 & 0xffffffffffffffffffffffffffffffffffffffff; var temp37 = temp36 + 0x20; var15 = temp37; var temp38 = var15 + 0x20; memory[var15:var15 + 0x20] = temp38 - var14; memory[temp38:temp38 + 0x20] = memory[temp31:temp31 + 0x20]; var16 = temp38 + 0x20; var18 = memory[temp31:temp31 + 0x20]; var17 = temp31 + 0x20; var19 = var18; var20 = var16; var21 = var17; var22 = 0x00; if (var22 >= var19) { goto label_25A8; } else { goto label_2598; } } } else { var8 = 0x00; var9 = var5; var temp39 = var9; var7 = temp39; var temp40 = var8; var6 = temp40; var8 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var12 = address(this); var temp41 = memory[0x40:0x60]; var13 = temp41; var14 = 0x00; memory[var13:var13 + 0x20] = var14; memory[0x40:0x60] = var13 + (var14 + 0x1f & ~0x1f) + 0x20; if (!var14) { goto label_251B; } else { goto label_250F; } } } else { var temp42 = returndata.length; memory[0x00:0x00 + temp42] = returndata[0x00:0x00 + temp42]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp43 = returndata.length; memory[0x00:0x00 + temp43] = returndata[0x00:0x00 + temp43]; revert(memory[0x00:0x00 + returndata.length]); } } function func_0696(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xff; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var var0 = 0x00; memory[var0:var0 + 0x20] = arg0 & 0xff; memory[0x20:0x40] = 0x05; var temp1 = storage[keccak256(memory[var0:var0 + 0x40])]; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = temp1 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = 0x20; var var2 = 0x70a08231; var var3 = temp2 + 0x24; var var5 = memory[0x40:0x60]; var var6 = temp2 - var5 + 0x24; var var7 = var5; var var8 = var1; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp3; temp3, memory[var5:var5 + var4] = address(var8).staticcall.gas(msg.gas)(memory[var7:var7 + var6]); var4 = !temp3; if (!var4) { var1 = memory[0x40:0x60]; var2 = returndata.length; if (var2 >= 0x20) { return memory[var1:var1 + 0x20]; } else { revert(memory[0x00:0x00]); } } else { var temp4 = returndata.length; memory[0x00:0x00 + temp4] = returndata[0x00:0x00 + temp4]; revert(memory[0x00:0x00 + returndata.length]); } } function func_06E3(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp1 = memory[0x40:0x60]; memory[temp1 + 0x24:temp1 + 0x24 + 0x20] = msg.sender; memory[temp1 + 0x44:temp1 + 0x44 + 0x20] = arg1; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = temp1 - temp2 + 0x44; var var1 = temp2; memory[0x40:0x60] = temp1 + 0x64; var temp3 = var1 + 0x20; memory[temp3:temp3 + 0x20] = (memory[temp3:temp3 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | 0xa9059cbb00000000000000000000000000000000000000000000000000000000; var var2 = memory[0x40:0x60]; var var4 = temp3; var var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var5 = memory[var1:var1 + 0x20]; var var3 = var2; var var6 = var5; var var7 = var3; var var8 = var4; if (var6 < 0x20) { label_2856: var temp4 = 0x0100 ** (0x20 - var6) - 0x01; var temp5 = var7; memory[temp5:temp5 + 0x20] = (memory[var8:var8 + 0x20] & ~temp4) | (memory[temp5:temp5 + 0x20] & temp4); var temp6 = memory[0x40:0x60]; var temp7; temp7, memory[temp6:temp6 + 0x00] = address(var0).call.gas(msg.gas)(memory[temp6:temp6 + (var5 + var3) - temp6]); var1 = returndata.length; var2 = var1; if (var2 == 0x00) { label_1FD8: return; } else { var temp8 = memory[0x40:0x60]; var1 = temp8; memory[0x40:0x60] = var1 + (returndata.length + 0x3f & ~0x1f); memory[var1:var1 + 0x20] = returndata.length; var temp9 = returndata.length; memory[var1 + 0x20:var1 + 0x20 + temp9] = returndata[0x00:0x00 + temp9]; goto label_1FD8; } } else { label_2821: var temp10 = var8; var temp11 = var7; memory[temp11:temp11 + 0x20] = memory[temp10:temp10 + 0x20]; var6 = var6 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0; var7 = temp11 + 0x20; var8 = temp10 + 0x20; if (var6 < 0x20) { goto label_2856; } else { goto label_2821; } } } function func_0745(var arg0, var arg1) { var temp0 = arg0; var temp1 = temp0 + arg1; arg1 = temp0; arg0 = temp1; var var0 = arg1 + 0x20; var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp2 = arg1 + var1; var1 = temp2; if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); } var temp3 = var1; var temp4 = msg.data[temp3:temp3 + 0x20]; var1 = temp4; var temp5 = var0; var0 = temp3 + 0x20; var var2 = temp5; if ((var1 > 0x0100000000) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); } var temp6 = var2; var temp7 = arg0; arg0 = var0; var temp8 = arg1; arg1 = var1; var1 = temp8; var0 = temp7; var2 = temp6 + 0x20; var var3 = msg.data[temp6:temp6 + 0x20]; if (var3 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp9 = var1 + var3; var3 = temp9; if (var3 + 0x20 > var0) { revert(memory[0x00:0x00]); } var temp10 = var3; var temp11 = msg.data[temp10:temp10 + 0x20]; var3 = temp11; var temp12 = var2; var2 = temp10 + 0x20; var var4 = temp12; if ((var3 > 0x0100000000) | (var2 + var3 * 0x20 > var0)) { revert(memory[0x00:0x00]); } var0 = var2; var1 = var3; var2 = msg.data[var4:var4 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var3 = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var4 = 0x2e1a7d4d; var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = (var4 & 0xffffffff) << 0xe0; var temp14 = temp13 + 0x04; memory[temp14:temp14 + 0x20] = var2; var var5 = temp14 + 0x20; var var6 = 0x00; var var7 = memory[0x40:0x60]; var var8 = var5 - var7; var var9 = var7; var var10 = 0x00; var var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp15; temp15, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp15; if (!var6) { var3 = 0x00; if (var3 >= arg1) { label_2A64: return; } else { label_298A: var4 = 0x02; var5 = 0x00; var6 = arg0; var7 = arg1; var8 = var3; if (var8 >= var7) { assert(); } var temp16 = var5; memory[temp16:temp16 + 0x20] = msg.data[var8 * 0x20 + var6:var8 * 0x20 + var6 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp16 + 0x20:temp16 + 0x20 + 0x20] = var4; if (!(storage[keccak256(memory[0x00:0x00 + temp16 + 0x40])] & 0xff)) { revert(memory[0x00:0x00]); } var4 = arg0; var5 = arg1; var6 = var3; if (var6 >= var5) { assert(); } var4 = msg.data[var6 * 0x20 + var4:var6 * 0x20 + var4 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var5 = 0x08fc; var6 = var0; var7 = var1; var8 = var3; if (var8 >= var7) { assert(); } var temp17 = msg.data[var8 * 0x20 + var6:var8 * 0x20 + var6 + 0x20]; var temp18 = memory[0x40:0x60]; var temp19; temp19, memory[temp18:temp18 + 0x00] = address(var4).call.gas(!temp17 * var5).value(temp17)(memory[temp18:temp18 + memory[0x40:0x60] - temp18]); var4 = !temp19; if (!var4) { var3 = var3 + 0x01; if (var3 >= arg1) { goto label_2A64; } else { goto label_298A; } } else { var temp20 = returndata.length; memory[0x00:0x00 + temp20] = returndata[0x00:0x00 + temp20]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var temp21 = returndata.length; memory[0x00:0x00 + temp21] = returndata[0x00:0x00 + temp21]; revert(memory[0x00:0x00 + returndata.length]); } } function func_081E(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = address(this); arg1 = 0x00; var var0 = 0x002b04; var var1 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var var2 = 0x70a08231; var var3 = temp0 + 0x24; var var4 = 0x20; var var5 = memory[0x40:0x60]; var var6 = temp0 - var5 + 0x24; var var7 = var5; var var8 = var1; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var0 = func_18BD(arg0, var1, var2, var3, var4, var5, var6, var7, var8, var9); var temp1 = var0; arg1 = temp1; var0 = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var1 = 0x2e1a7d4d; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = (var1 & 0xffffffff) << 0xe0; var temp3 = temp2 + 0x04; memory[temp3:temp3 + 0x20] = arg1; var2 = temp3 + 0x20; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp4; temp4, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp4; if (!var3) { return; } var temp5 = returndata.length; memory[0x00:0x00 + temp5] = returndata[0x00:0x00 + temp5]; revert(memory[0x00:0x00 + returndata.length]); } function initialize(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; if (storage[0x04] & 0xff) { revert(memory[0x00:0x00]); } storage[0x00] = (storage[0x00] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | 0x50d1b550f854b785cedf754114e28d496c8a89c1; var temp0 = (storage[0x01] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | (arg0 & 0xffffffffffffffffffffffffffffffffffffffff); storage[0x01] = temp0; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x02; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = (storage[temp1] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) | 0x01; memory[0x00:0x20] = 0x00; memory[0x20:0x40] = 0x05; storage[0x05b8ccbb9d4d8fb16ea74ce3c29a41f1b461fbdaff4714a0d9a8eb05499746bc] = address(this) | (storage[0x05b8ccbb9d4d8fb16ea74ce3c29a41f1b461fbdaff4714a0d9a8eb05499746bc] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000); storage[0x04] = (storage[0x04] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) | 0x01; } function transferManagership(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } if (!(arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { revert(memory[0x00:0x00]); } storage[0x01] = (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x01] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000); } function set_mint(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } storage[0x03] = arg0; } function func_0902(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; memory[msg.value:msg.value + 0x20] = 0x746d084e91743124a982076c59f100843318585733ff6000526015600bf30000; arg1 = 0x06; if (!arg1) { label_2EC1: if (arg0 <= storage[0x03]) { return; } storage[0x03] = arg0; return; } else { label_2D56: var temp0 = arg0; var temp1 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0)(); var temp2 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x01)(); var temp3 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x02)(); var temp4 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x03)(); var temp5 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x04)(); var temp6 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x05)(); var temp7 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x06)(); var temp8 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x07)(); var temp9 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x08)(); var temp10 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x09)(); var temp11 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x0a)(); var temp12 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x0b)(); var temp13 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x0c)(); var temp14 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x0d)(); var temp15 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x0e)(); var temp16 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x0f)(); var temp17 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x10)(); var temp18 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x11)(); var temp19 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x12)(); var temp20 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x13)(); var temp21 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x14)(); var temp22 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x15)(); var temp23 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x16)(); var temp24 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x17)(); var temp25 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x18)(); var temp26 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x19)(); var temp27 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x1a)(); var temp28 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x1b)(); var temp29 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x1c)(); var temp30 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x1d)(); var temp31 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x1e)(); var temp32 = new(memory[msg.value:msg.value + 0x1e]).value(msg.value).salt(temp0 + 0x1f)(); arg0 = temp0 + 0x20; arg1 = arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (!arg1) { goto label_2EC1; } else { goto label_2D56; } } } function func_0948(var arg0, var arg1) { var temp0 = arg0; var temp1 = temp0 + arg1; arg1 = temp0; arg0 = temp1; var var0 = arg1 + 0x20; var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp2 = arg1 + var1; var1 = temp2; if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); } var temp3 = var1; var temp4 = msg.data[temp3:temp3 + 0x20]; var1 = temp4; var var2 = var0; var0 = temp3 + 0x20; if ((var1 > 0x0100000000) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); } var temp5 = var2; var temp6 = arg0; arg0 = var0; var temp7 = arg1; arg1 = var1; var1 = temp7; var0 = temp6; var2 = temp5 + 0x20; var var3 = msg.data[temp5:temp5 + 0x20]; if (var3 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp8 = var1 + var3; var3 = temp8; if (var3 + 0x20 > var0) { revert(memory[0x00:0x00]); } var temp9 = var3; var temp10 = msg.data[temp9:temp9 + 0x20]; var3 = temp10; var var4 = var2; var2 = temp9 + 0x20; if ((var3 > 0x0100000000) | (var2 + var3 * 0x20 > var0)) { revert(memory[0x00:0x00]); } var0 = var2; var1 = var3; if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var2 = 0x00; if (var2 >= arg1) { label_1FD8: return; } else { label_306C: var3 = 0x00; var4 = arg0; var var5 = arg1; var var6 = var2; if (var6 >= var5) { assert(); } if (msg.data[var6 * 0x20 + var4:var6 * 0x20 + var4 + 0x20] & 0xff <= var3) { revert(memory[0x00:0x00]); } var3 = var0; var4 = var1; var5 = var2; if (var5 >= var4) { assert(); } var3 = msg.data[var5 * 0x20 + var3:var5 * 0x20 + var3 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x05; var5 = 0x00; var6 = arg0; var var7 = arg1; var var8 = var2; if (var8 >= var7) { assert(); } var temp11 = var5; memory[temp11:temp11 + 0x20] = msg.data[var8 * 0x20 + var6:var8 * 0x20 + var6 + 0x20] & 0xff; memory[temp11 + 0x20:temp11 + 0x20 + 0x20] = var4; var temp12 = keccak256(memory[0x00:0x00 + temp11 + 0x40]); storage[temp12] = (var3 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[temp12] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000); var2 = var2 + 0x01; if (var2 >= arg1) { goto label_1FD8; } else { goto label_306C; } } } function func_0D13(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6, var arg7, var arg8, var arg9) returns (var r0) { var temp0; temp0, memory[arg5:arg5 + arg4] = address(arg8).staticcall.gas(msg.gas)(memory[arg7:arg7 + arg6]); arg4 = !temp0; if (!arg4) { arg1 = memory[0x40:0x60]; arg2 = returndata.length; if (arg2 < 0x20) { revert(memory[0x00:0x00]); } var temp1 = arg0; arg0 = memory[arg1:arg1 + 0x20]; arg1 = temp1; r0 = func_35F9(arg0, arg1); // Error: Could not resolve method call return address! } else { var temp2 = returndata.length; memory[0x00:0x00 + temp2] = returndata[0x00:0x00 + temp2]; revert(memory[0x00:0x00 + returndata.length]); } } function func_0D4E(var arg0, var arg1, var arg2) returns (var r0) { var var0 = arg1; var var1 = arg0; r0 = func_36F2(arg2, var0, var1); // Error: Could not resolve method call return address! } function func_0F82(var arg0, var arg1, var arg2) { arg1 = arg2 / arg1 & 0xffffff; arg2 = (arg0 >> 0xfc) & 0xff; func_371C(arg1, arg2); // Error: Could not resolve method call return address! } function func_10C2(var arg0, var arg1) { arg0 = arg1 / arg0 & 0xffffff; arg1 = 0x01; func_371C(arg0, arg1); // Error: Could not resolve method call return address! } function func_181F() returns (var r0) { return storage[0x03]; } function func_18BD(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6, var arg7, var arg8, var arg9) returns (var r0) { var temp0; temp0, memory[arg5:arg5 + arg4] = address(arg8).staticcall.gas(msg.gas)(memory[arg7:arg7 + arg6]); arg4 = !temp0; if (!arg4) { arg1 = memory[0x40:0x60]; arg2 = returndata.length; if (arg2 < 0x20) { revert(memory[0x00:0x00]); } arg1 = memory[arg1:arg1 + 0x20]; arg2 = arg0; r0 = func_3E25(arg1, arg2); // Error: Could not resolve method call return address! } else { var temp1 = returndata.length; memory[0x00:0x00 + temp1] = returndata[0x00:0x00 + temp1]; revert(memory[0x00:0x00 + returndata.length]); } } function manager() returns (var r0) { return storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_1F66() { var var0 = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var var1 = 0xd0e30db0; var var2 = msg.value; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var1 & 0xffffffff) << 0xe0; var var3 = temp0 + 0x04; var var4 = 0x00; var var5 = memory[0x40:0x60]; var var6 = var3 - var5; var var7 = var5; var var8 = var2; var var9 = var0; var var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } var temp1; temp1, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]); var4 = !temp1; if (!var4) { return; } var temp2 = returndata.length; memory[0x00:0x00 + temp2] = returndata[0x00:0x00 + temp2]; revert(memory[0x00:0x00 + returndata.length]); } function owner() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_3135(var arg0) { var temp0 = memory[0x40:0x60]; var temp1 = arg0; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = temp1 & 0xffffff0000000000000000000000000000000000000000000000000000000000; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = temp0 - temp2 + 0x03; var temp3 = temp0 + 0x23; memory[0x40:0x60] = temp3; var temp4 = keccak256(memory[temp2 + 0x20:temp2 + 0x20 + memory[temp2:temp2 + 0x20]]); memory[temp3:temp3 + 0x20] = 0x0902f1ac00000000000000000000000000000000000000000000000000000000; var var0 = temp1 ~ temp4; var var1 = var0 >> 0x0c; var var2 = 0x00; var var3 = var2; var var4 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var var5 = 0x0902f1ac; var var6 = temp0 + 0x27; var var7 = 0x60; var var8 = memory[0x40:0x60]; var var9 = temp0 - var8 + 0x27; var var10 = var8; var var11 = var4; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp5; temp5, memory[var8:var8 + var7] = address(var11).staticcall.gas(msg.gas)(memory[var10:var10 + var9]); var7 = !temp5; if (!var7) { var4 = memory[0x40:0x60]; var5 = returndata.length; if (var5 < 0x60) { revert(memory[0x00:0x00]); } var temp6 = var4; var2 = memory[temp6:temp6 + 0x20] & 0xffffffffffffffffffffffffffff; var3 = memory[temp6 + 0x20:temp6 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff; if (((var0 >> 0xac) & 0xff) / 0x10 & 0xff != 0x00) { var4 = tx.gasprice % 0x3b9aca00 * 0x5af3107a4000; var5 = var2 >= var4; if (var5) { label_327D: if (var5) { label_328D: if (var5) { label_3297: if (!var5) { label_32CC: var5 = ((var0 >> 0xb4) & 0xffffffff) * 0x09184e72a000; var6 = (arg0 >> 0xec) * 0x038d7ea4c68000; var7 = 0x00; if (var5 + var2 <= var6 + var4) { var7 = var5; var8 = 0x003337; var9 = var1; var temp7 = var0 >> 0xac; var10 = (temp7 & 0xff) / 0x10; var11 = temp7 & 0x0f; var12 = var7; var var13 = 0x003331; var var14 = var12; var var15 = var2; var var16 = var3; var13 = func_36F2(var14, var15, var16); func_3331(var9, var10, var11, var12, var13); label_3337: if (!((arg0 >> 0xe8) & 0x0f)) { label_1496: return; } else { var8 = 0x001496; var9 = ((var0 >> 0xd0) & 0xffffff) / 0x10 & 0xffffff; var10 = 0x10; var11 = (arg0 >> 0xe8) & 0xff; if (!var10) { assert(); } func_336D(var9, var10, var11); goto label_1496; } } else { var8 = (var4 + var6) - var2; var temp8 = var8; var7 = temp8; var8 = 0x003337; var9 = var1; var temp9 = var0 >> 0xac; var10 = (temp9 & 0xff) / 0x10; var11 = temp9 & 0x0f; var12 = var7; var13 = 0x003331; var14 = var12; var15 = var2; var16 = var3; var13 = func_36F2(var14, var15, var16); func_3331(var9, var10, var11, var12, var13); goto label_3337; } } else { label_329E: if (!((arg0 >> 0xe8) & 0x0f)) { label_32C1: return; } else { var5 = 0x0032c1; var6 = 0x10; var7 = (var0 >> 0xd0) & 0xffffff; func_10C2(var6, var7); goto label_32C1; } } } else { label_3294: if (block.coinbase) { goto label_32CC; } else { goto label_329E; } } } else { label_3284: var5 = block.gaslimit >= 0x01d7b08e; if (var5) { goto label_3297; } else { goto label_3294; } } } else { label_3270: var5 = var0 & 0x0fff >= block.number % 0x03e8; if (var5) { goto label_328D; } else { goto label_3284; } } } else { var temp10 = var3; var3 = var2; var2 = temp10; var4 = tx.gasprice % 0x3b9aca00 * 0x5af3107a4000; var5 = var2 >= var4; if (var5) { goto label_327D; } else { goto label_3270; } } } else { var temp11 = returndata.length; memory[0x00:0x00 + temp11] = returndata[0x00:0x00 + temp11]; revert(memory[0x00:0x00 + returndata.length]); } } function func_3331(var arg0, var arg1, var arg2, var arg3, var arg4) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = arg3; var var0 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var var1 = 0xa9059cbb; var var2 = temp0 + 0x44; var var3 = 0x20; var var4 = memory[0x40:0x60]; var var5 = temp0 - var4 + 0x44; var var6 = var4; var var7 = 0x00; var var8 = var0; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp1; temp1, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp1; if (!var3) { var0 = memory[0x40:0x60]; var1 = returndata.length; if (var1 < 0x20) { revert(memory[0x00:0x00]); } var0 = 0x00; var1 = var0; if (arg1 & 0xff == 0x01) { var1 = arg4; var0 = 0x00; var2 = 0x00; if (arg2 & 0xff != 0x00) { label_3F2F: memory[0x00:0x20] = arg2 & 0xff; memory[0x20:0x40] = 0x05; var2 = storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; if (!(tx.gasprice % 0x0a)) { label_4081: var3 = arg0; var4 = var0; var5 = var1; var6 = var2; var7 = 0x004093; var8 = memory[0x40:0x60]; var7 = func_40FE(var8); var temp2 = var7; memory[temp2:temp2 + 0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp2 + 0x20:temp2 + 0x20 + 0x20] = var4; memory[temp2 + 0x40:temp2 + 0x40 + 0x20] = var5; memory[temp2 + 0x60:temp2 + 0x60 + 0x20] = var6 & 0xffffffffffffffffffffffffffffffffffffffff; var temp3 = memory[0x40:0x60]; var temp4 = new(memory[temp3:temp3 + temp2 - temp3 + 0x80]).value(0x00)(); var3 = temp4; var4 = !var3; if (!var4) { return; } var temp5 = returndata.length; memory[0x00:0x00 + temp5] = returndata[0x00:0x00 + temp5]; revert(memory[0x00:0x00 + returndata.length]); } else { label_3F65: var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x00; var temp7 = temp6 + 0x20; memory[0x40:0x60] = temp7; memory[temp7:temp7 + 0x20] = 0x022c0d9f00000000000000000000000000000000000000000000000000000000; memory[temp6 + 0x24:temp6 + 0x24 + 0x20] = var0; memory[temp6 + 0x44:temp6 + 0x44 + 0x20] = var1; memory[temp6 + 0x64:temp6 + 0x64 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp6 + 0x84:temp6 + 0x84 + 0x20] = 0x80; var temp8 = memory[temp6:temp6 + 0x20]; memory[temp6 + 0xa4:temp6 + 0xa4 + 0x20] = temp8; var3 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x022c0d9f; var5 = var0; var6 = var1; var7 = var2; var8 = temp6; var9 = temp6 + 0x24; var var12 = temp7; var var10 = temp6 + 0x84; var var13 = temp8; var var11 = var8 + 0xc4; var var14 = var13; var var15 = var11; var var16 = var12; var var17 = 0x00; if (var17 >= var14) { label_4011: var temp9 = var13; var11 = temp9 + var11; var12 = temp9 & 0x1f; if (!var12) { var5 = var11; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } label_4062: var temp10; temp10, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp10; if (!var6) { return; } var temp11 = returndata.length; memory[0x00:0x00 + temp11] = returndata[0x00:0x00 + temp11]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp12 = var12; var temp13 = var11 - temp12; memory[temp13:temp13 + 0x20] = ~(0x0100 ** (0x20 - temp12) - 0x01) & memory[temp13:temp13 + 0x20]; var5 = temp13 + 0x20; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; var12 = !address(var11).code.length; if (!var12) { goto label_4062; } else { revert(memory[0x00:0x00]); } } } else { label_4001: var temp14 = var17; memory[temp14 + var15:temp14 + var15 + 0x20] = memory[temp14 + var16:temp14 + var16 + 0x20]; var17 = temp14 + 0x20; if (var17 >= var14) { goto label_4011; } else { goto label_4001; } } } } else { label_3F28: var2 = address(this); if (!(tx.gasprice % 0x0a)) { goto label_4081; } else { goto label_3F65; } } } else { var2 = arg4; var3 = 0x00; var1 = var3; var0 = var2; var2 = 0x00; if (arg2 & 0xff != 0x00) { goto label_3F2F; } else { goto label_3F28; } } } else { var temp15 = returndata.length; memory[0x00:0x00 + temp15] = returndata[0x00:0x00 + temp15]; revert(memory[0x00:0x00 + returndata.length]); } } function func_336D(var arg0, var arg1, var arg2) { arg1 = arg2 % arg1 & 0xff; func_371C(arg0, arg1); // Error: Could not resolve method call return address! } function func_3377(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < arg0 & 0xffffffffffffffffffffffffffffffffffffffff; if (!(arg1 & 0xff)) { var var2 = 0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f; if (var1) { label_33EE: var var3 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; if (var1) { label_3425: var temp0 = memory[0x40:0x60]; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = (var3 << 0x60) & 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000; memory[temp0 + 0x34:temp0 + 0x34 + 0x20] = (arg0 << 0x60) & 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = temp0 - temp1 + 0x28; memory[0x40:0x60] = temp0 + 0x48; var3 = keccak256(memory[temp1 + 0x20:temp1 + 0x20 + memory[temp1:temp1 + 0x20]]); if (!(arg1 & 0xff)) { label_34C4: var temp2 = memory[0x40:0x60]; var var4 = temp2; memory[0x40:0x60] = var4 + 0x40; memory[var4:var4 + 0x20] = 0x20; memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f; var temp3 = memory[0x40:0x60] + 0x20; var var5 = temp3; memory[var5:var5 + 0x20] = 0xff00000000000000000000000000000000000000000000000000000000000000; var temp4 = var5 + 0x01; memory[temp4:temp4 + 0x20] = (var2 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60; var temp5 = temp4 + 0x14; memory[temp5:temp5 + 0x20] = var3; var var6 = temp5 + 0x20; var var8 = memory[var4:var4 + 0x20]; var var7 = var4 + 0x20; var var9 = var8; var var10 = var6; var var11 = var7; if (var9 < 0x20) { label_35B0: var temp6 = 0x0100 ** (0x20 - var9) - 0x01; var temp7 = var10; memory[temp7:temp7 + 0x20] = (memory[var11:var11 + 0x20] & ~temp6) | (memory[temp7:temp7 + 0x20] & temp6); var temp8 = var8 + var6; var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = temp8 - temp9 - 0x20; memory[0x40:0x60] = temp8; return keccak256(memory[temp9 + 0x20:temp9 + 0x20 + memory[temp9:temp9 + 0x20]]) >> 0x00; } else { label_357B: var temp10 = var11; var temp11 = var10; memory[temp11:temp11 + 0x20] = memory[temp10:temp10 + 0x20]; var9 = var9 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0; var10 = temp11 + 0x20; var11 = temp10 + 0x20; label_3571: if (var9 < 0x20) { goto label_35B0; } else { goto label_357B; } } } else { label_3489: var temp12 = memory[0x40:0x60]; var4 = temp12; memory[0x40:0x60] = var4 + 0x40; memory[var4:var4 + 0x20] = 0x20; memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0xe18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303; var temp13 = memory[0x40:0x60] + 0x20; var5 = temp13; memory[var5:var5 + 0x20] = 0xff00000000000000000000000000000000000000000000000000000000000000; var temp14 = var5 + 0x01; memory[temp14:temp14 + 0x20] = (var2 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x60; var temp15 = temp14 + 0x14; memory[temp15:temp15 + 0x20] = var3; var6 = temp15 + 0x20; var temp16 = var4; var7 = temp16 + 0x20; var8 = memory[temp16:temp16 + 0x20]; var9 = var8; var10 = var6; var11 = var7; goto label_3571; } } else { label_340B: var4 = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var temp17 = memory[0x40:0x60]; memory[temp17 + 0x20:temp17 + 0x20 + 0x20] = (var3 << 0x60) & 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000; memory[temp17 + 0x34:temp17 + 0x34 + 0x20] = (var4 << 0x60) & 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000; var temp18 = memory[0x40:0x60]; memory[temp18:temp18 + 0x20] = temp17 - temp18 + 0x28; memory[0x40:0x60] = temp17 + 0x48; var3 = keccak256(memory[temp18 + 0x20:temp18 + 0x20 + memory[temp18:temp18 + 0x20]]); if (!(arg1 & 0xff)) { goto label_34C4; } else { goto label_3489; } } } else { label_33E8: var3 = arg0; if (var1) { goto label_3425; } else { goto label_340B; } } } else { var2 = 0xc0aee478e3658e2610c5f7a4a2e1777ce9e4f2ac; if (var1) { goto label_33EE; } else { goto label_33E8; } } } function func_35F9(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 <= arg0) { return arg0 - arg1; } else { revert(memory[0x00:0x00]); } } function func_360F(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; var var3 = var2; var var4 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var5 = 0x0902f1ac; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var5 & 0xffffffff) << 0xe0; var var6 = temp0 + 0x04; var var7 = 0x60; var var8 = memory[0x40:0x60]; var var9 = var6 - var8; var var10 = var8; var var11 = var4; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp1; temp1, memory[var8:var8 + var7] = address(var11).staticcall.gas(msg.gas)(memory[var10:var10 + var9]); var7 = !temp1; if (!var7) { var4 = memory[0x40:0x60]; var5 = returndata.length; if (var5 < 0x60) { revert(memory[0x00:0x00]); } var temp2 = var4; var2 = memory[temp2:temp2 + 0x20] & 0xffffffffffffffffffffffffffff; var3 = memory[temp2 + 0x20:temp2 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff; if (0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < arg1 & 0xffffffffffffffffffffffffffffffffffffffff) { r0 = var2; arg0 = var3; return r0, arg0; } else { var4 = var3; var5 = var2; r0 = var4; arg0 = var5; return r0, arg0; } } else { var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } } function func_36F2(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var temp0 = arg0; var var1 = temp0 * 0x03e5; var var2 = temp0 * arg2 * 0x03e5; var var3 = var1 + arg1 * 0x03e8; var var4 = var3; var var5 = var2; if (var4) { return var5 / var4; } else { assert(); } } function func_371C(var arg0, var arg1) { var temp0 = arg0; var var0 = temp0 + arg1; var temp1 = memory[0x40:0x60]; var var1 = temp1; memory[var1:var1 + 0x20] = 0xff000000000000084e91743124a982076c59f100840000000000000000000000; memory[var1 + 0x35:var1 + 0x35 + 0x20] = 0x17f2c5b31e6ffc755997e952174fc537025e254986b5630bbadd188e008f2e93; var var2 = var1 + 0x15; if (temp0 >= var0) { label_1FD8: return; } else { label_377A: var temp2 = arg0; memory[var2:var2 + 0x20] = temp2; memory[msg.value:msg.value + msg.value] = address(keccak256(memory[var1:var1 + 0x55])).call.gas(msg.gas).value(msg.value)(memory[msg.value:msg.value + msg.value]); arg0 = temp2 + 0x01; if (arg0 >= var0) { goto label_1FD8; } else { goto label_377A; } } } function func_3794(var arg0, var arg1, var arg2, var arg3, var arg4) { var var0 = arg3 & 0xffff >= block.number % 0x03e8; if (!var0) { var0 = block.gaslimit >= 0x01d7b08e; if (var0) { goto label_37BA; } else { goto label_37B7; } } else if (var0) { label_37BA: if (!var0) { label_37C6: var0 = 0x00; var var1 = 0x0037d4; var var2 = arg0; var var3 = arg2; var1 = func_3377(var2, var3); var0 = var1; var1 = 0x00; if (arg1 & 0xff) { memory[0x00:0x20] = arg1 & 0xff; memory[0x20:0x40] = 0x05; var temp0 = storage[keccak256(memory[0x00:0x40])]; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var var6 = 0x20; var3 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = 0x70a08231; var var7 = memory[0x40:0x60]; var var5 = temp1 + 0x24; var var8 = temp1 - var7 + 0x24; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp2; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var1 = memory[var3:var3 + 0x20]; if (var1 > 0x01) { var3 = var2 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x02; var5 = arg0; var6 = var0; var7 = 0x003adc; var8 = var1; var9 = 0x01; var7 = func_35F9(var8, var9); var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = (var4 & 0xffffffff) << 0xe0; var temp4 = temp3 + 0x04; memory[temp4:temp4 + 0x20] = var5 & 0xffffffffffffffffffffffffffffffffffffffff; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x20] = var6 & 0xffffffffffffffffffffffffffffffffffffffff; var temp6 = temp5 + 0x20; memory[temp6:temp6 + 0x20] = var7; var5 = temp6 + 0x20; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; var var12 = !address(var11).code.length; if (var12) { revert(memory[0x00:0x00]); } var temp7; temp7, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); var6 = !temp7; if (!var6) { var2 = 0x00; var3 = var2; var4 = 0x003ba3; var5 = var0; var6 = arg0; var4, var5 = func_360F(var5, var6); label_3BA3: var temp8 = var5; var3 = temp8; var2 = var4; var4 = 0x00; var5 = 0x003c2c; var6 = var3; var7 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var8 = 0x70a08231; var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = (var8 & 0xffffffff) << 0xe0; var temp10 = temp9 + 0x04; memory[temp10:temp10 + 0x20] = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = temp10 + 0x20; var10 = 0x20; var11 = memory[0x40:0x60]; var12 = var9 - var11; var var13 = var11; var var14 = var7; var var15 = !address(var14).code.length; if (var15) { revert(memory[0x00:0x00]); } var5 = func_0D13(var6, var7, var8, var9, var10, var11, var12, var13, var14, var15); var temp11 = var5; var4 = temp11; var5 = 0x00; var6 = 0x003c3d; var7 = var4; var8 = var3; var9 = var2; var6 = func_36F2(var7, var8, var9); var5 = var6; var6 = 0x00; var7 = var6; if (0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < arg0 & 0xffffffffffffffffffffffffffffffffffffffff) { var7 = 0x00; var6 = var5; if (arg4 & 0xff != 0x00) { label_3DAE: var8 = var0; var9 = var6; var10 = var7; var11 = address(this); var13 = memory[0x40:0x60]; var12 = 0x003dc0; var12 = func_40FE(var13); var temp12 = var12; memory[temp12:temp12 + 0x20] = var8 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp12 + 0x20:temp12 + 0x20 + 0x20] = var9; memory[temp12 + 0x40:temp12 + 0x40 + 0x20] = var10; memory[temp12 + 0x60:temp12 + 0x60 + 0x20] = var11 & 0xffffffffffffffffffffffffffffffffffffffff; var temp13 = memory[0x40:0x60]; var temp14 = new(memory[temp13:temp13 + temp12 - temp13 + 0x80]).value(0x00)(); var8 = temp14; var9 = !var8; if (!var9) { label_3E16: return; } else { var temp15 = returndata.length; memory[0x00:0x00 + temp15] = returndata[0x00:0x00 + temp15]; revert(memory[0x00:0x00 + returndata.length]); } } else { label_3C93: var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = 0x00; var temp17 = temp16 + 0x20; memory[0x40:0x60] = temp17; memory[temp17:temp17 + 0x20] = 0x022c0d9f00000000000000000000000000000000000000000000000000000000; memory[temp16 + 0x24:temp16 + 0x24 + 0x20] = var6; memory[temp16 + 0x44:temp16 + 0x44 + 0x20] = var7; var12 = address(this); memory[temp16 + 0x64:temp16 + 0x64 + 0x20] = var12; memory[temp16 + 0x84:temp16 + 0x84 + 0x20] = 0x80; var temp18 = memory[temp16:temp16 + 0x20]; memory[temp16 + 0xa4:temp16 + 0xa4 + 0x20] = temp18; var8 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0x022c0d9f; var10 = var6; var11 = var7; var13 = temp16; var14 = temp16 + 0x24; var15 = temp16 + 0x84; var var16 = var13 + 0xc4; var var18 = temp18; var var17 = temp17; var var19 = var18; var var20 = var16; var var21 = var17; var var22 = 0x00; if (var22 >= var19) { label_3D3E: var temp19 = var18; var16 = temp19 + var16; var17 = temp19 & 0x1f; if (!var17) { var10 = var16; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } label_3D8F: var temp20; temp20, memory[var12:var12 + var11] = address(var16).call.gas(msg.gas).value(var15)(memory[var14:var14 + var13]); var11 = !temp20; if (!var11) { goto label_3E16; } var temp21 = returndata.length; memory[0x00:0x00 + temp21] = returndata[0x00:0x00 + temp21]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp22 = var17; var temp23 = var16 - temp22; memory[temp23:temp23 + 0x20] = ~(0x0100 ** (0x20 - temp22) - 0x01) & memory[temp23:temp23 + 0x20]; var10 = temp23 + 0x20; var11 = 0x00; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (!var17) { goto label_3D8F; } else { revert(memory[0x00:0x00]); } } } else { label_3D2E: var temp24 = var22; memory[temp24 + var20:temp24 + var20 + 0x20] = memory[temp24 + var21:temp24 + var21 + 0x20]; var22 = temp24 + 0x20; if (var22 >= var19) { goto label_3D3E; } else { goto label_3D2E; } } } } else { var8 = 0x00; var9 = var5; var7 = var9; var6 = var8; if (arg4 & 0xff != 0x00) { goto label_3DAE; } else { goto label_3C93; } } } else { var temp25 = returndata.length; memory[0x00:0x00 + temp25] = returndata[0x00:0x00 + temp25]; revert(memory[0x00:0x00 + returndata.length]); } } else { label_1FD8: return; } } else { var temp26 = returndata.length; memory[0x00:0x00 + temp26] = returndata[0x00:0x00 + temp26]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp27 = memory[0x40:0x60]; memory[temp27:temp27 + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000; memory[temp27 + 0x04:temp27 + 0x04 + 0x20] = address(this); var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var3 = 0x70a08231; var4 = temp27 + 0x24; var5 = 0x20; var6 = memory[0x40:0x60]; var7 = temp27 - var6 + 0x24; var8 = var6; var9 = var2; var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } var temp28; temp28, memory[var6:var6 + var5] = address(var9).staticcall.gas(msg.gas)(memory[var8:var8 + var7]); var5 = !temp28; if (!var5) { var2 = memory[0x40:0x60]; var3 = returndata.length; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = memory[var2:var2 + 0x20]; if (var1 <= 0x01) { goto label_1FD8; } var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var3 = 0xa9059cbb; var4 = var0; var5 = 0x0038bf; var6 = var1; var7 = 0x01; var5 = func_35F9(var6, var7); var temp29 = memory[0x40:0x60]; memory[temp29 + 0x24:temp29 + 0x24 + 0x20] = var4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[temp29 + 0x44:temp29 + 0x44 + 0x20] = var5; var temp30 = memory[0x40:0x60]; memory[temp30:temp30 + 0x20] = temp29 - temp30 + 0x44; memory[0x40:0x60] = temp29 + 0x64; var temp31 = temp30 + 0x20; memory[temp31:temp31 + 0x20] = (var3 << 0xe0) | (memory[temp31:temp31 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); var3 = temp30; var4 = memory[0x40:0x60]; var5 = var4; var7 = memory[var3:var3 + 0x20]; var6 = temp31; var8 = var7; var9 = var5; var10 = var6; if (var8 < 0x20) { label_3978: var temp32 = 0x0100 ** (0x20 - var8) - 0x01; var temp33 = var9; memory[temp33:temp33 + 0x20] = (memory[var10:var10 + 0x20] & ~temp32) | (memory[temp33:temp33 + 0x20] & temp32); var temp34 = memory[0x40:0x60]; var temp35; temp35, memory[temp34:temp34 + 0x00] = address(var2).call.gas(msg.gas)(memory[temp34:temp34 + (var7 + var5) - temp34]); var3 = returndata.length; var4 = var3; if (var4 == 0x00) { label_3B94: var2 = 0x00; var3 = var2; var4 = 0x003ba3; var5 = var0; var6 = arg0; var4, var5 = func_360F(var5, var6); goto label_3BA3; } else { var temp36 = memory[0x40:0x60]; var3 = temp36; memory[0x40:0x60] = var3 + (returndata.length + 0x3f & ~0x1f); memory[var3:var3 + 0x20] = returndata.length; var temp37 = returndata.length; memory[var3 + 0x20:var3 + 0x20 + temp37] = returndata[0x00:0x00 + temp37]; goto label_3B94; } } else { label_3943: var temp38 = var10; var temp39 = var9; memory[temp39:temp39 + 0x20] = memory[temp38:temp38 + 0x20]; var8 = var8 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0; var9 = temp39 + 0x20; var10 = temp38 + 0x20; if (var8 < 0x20) { goto label_3978; } else { goto label_3943; } } } else { var temp40 = returndata.length; memory[0x00:0x00 + temp40] = returndata[0x00:0x00 + temp40]; revert(memory[0x00:0x00 + returndata.length]); } } } else { label_37C1: goto label_1FD8; } } else { label_37B7: if (block.coinbase) { goto label_37C6; } else { goto label_37C1; } } } function func_3E25(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 < arg1) { return arg0; } var var1 = arg1; return var1; } function func_40F0(var arg0) returns (var r0) { var temp0 = arg0; memory[temp0:temp0 + 0x0377] = code[0x410d:0x4484]; return temp0 + 0x0377; } function func_40FE(var arg0) returns (var r0) { var temp0 = arg0; memory[temp0:temp0 + 0x013f] = code[0x4484:0x45c3]; return temp0 + 0x013f; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 62 PUSH3 0x0001f6 000D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0001f6, if msg.data.length < 0x04 label_000E: // Incoming jump from 0x000D, if not msg.data.length < 0x04 // Inputs[1] { @0010 msg.data[0x00:0x20] } 000E 60 PUSH1 0x00 0010 35 CALLDATALOAD 0011 60 PUSH1 0xe0 0013 1C SHR 0014 80 DUP1 0015 63 PUSH4 0x4955bae6 001A 11 GT 001B 62 PUSH3 0x00011b 001F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0013 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00011b, if 0x4955bae6 > msg.data[0x00:0x20] >> 0xe0 label_0020: // Incoming jump from 0x001F, if not 0x4955bae6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0020 stack[-1] } 0020 80 DUP1 0021 63 PUSH4 0x98061191 0026 11 GT 0027 62 PUSH3 0x0000a3 002B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0000a3, if 0x98061191 > stack[-1] label_002C: // Incoming jump from 0x002B, if not 0x98061191 > stack[-1] // Inputs[1] { @002C stack[-1] } 002C 80 DUP1 002D 63 PUSH4 0xccf12304 0032 11 GT 0033 62 PUSH3 0x00006d 0037 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00006d, if 0xccf12304 > stack[-1] label_0038: // Incoming jump from 0x0037, if not 0xccf12304 > stack[-1] // Inputs[1] { @0038 stack[-1] } 0038 80 DUP1 0039 63 PUSH4 0xccf12304 003E 14 EQ 003F 62 PUSH3 0x0008ae 0043 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0008ae, if 0xccf12304 == stack[-1] label_0044: // Incoming jump from 0x0043, if not 0xccf12304 == stack[-1] // Inputs[1] { @0044 stack[-1] } 0044 80 DUP1 0045 63 PUSH4 0xd6c1a7fd 004A 14 EQ 004B 62 PUSH3 0x0008dc 004F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0008dc, if 0xd6c1a7fd == stack[-1] label_0050: // Incoming jump from 0x004F, if not 0xd6c1a7fd == stack[-1] // Inputs[1] { @0050 stack[-1] } 0050 80 DUP1 0051 63 PUSH4 0xfa7cd1d3 0056 14 EQ 0057 62 PUSH3 0x00090a 005B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00090a, if 0xfa7cd1d3 == stack[-1] label_005C: // Incoming jump from 0x005B, if not 0xfa7cd1d3 == stack[-1] // Inputs[1] { @005C stack[-1] } 005C 80 DUP1 005D 63 PUSH4 0xff1cdcbf 0062 14 EQ 0063 62 PUSH3 0x000922 0067 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000922, if 0xff1cdcbf == stack[-1] label_0068: // Incoming jump from 0x0067, if not 0xff1cdcbf == stack[-1] 0068 62 PUSH3 0x0001f6 006C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_006D: // Incoming jump from 0x0037, if 0xccf12304 > stack[-1] // Inputs[1] { @006E stack[-1] } 006D 5B JUMPDEST 006E 80 DUP1 006F 63 PUSH4 0x98061191 0074 14 EQ 0075 62 PUSH3 0x00071f 0079 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00071f, if 0x98061191 == stack[-1] label_007A: // Incoming jump from 0x0079, if not 0x98061191 == stack[-1] // Inputs[1] { @007A stack[-1] } 007A 80 DUP1 007B 63 PUSH4 0x9af73484 0080 14 EQ 0081 62 PUSH3 0x0007f8 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0007f8, if 0x9af73484 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x9af73484 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc4d66de8 008C 14 EQ 008D 62 PUSH3 0x000826 0091 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000826, if 0xc4d66de8 == stack[-1] label_0092: // Incoming jump from 0x0091, if not 0xc4d66de8 == stack[-1] // Inputs[1] { @0092 stack[-1] } 0092 80 DUP1 0093 63 PUSH4 0xccc39909 0098 14 EQ 0099 62 PUSH3 0x00086a 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00086a, if 0xccc39909 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xccc39909 == stack[-1] 009E 62 PUSH3 0x0001f6 00A2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_00A3: // Incoming jump from 0x002B, if 0x98061191 > stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A3 5B JUMPDEST 00A4 80 DUP1 00A5 63 PUSH4 0x6adfb982 00AA 11 GT 00AB 62 PUSH3 0x0000e5 00AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0000e5, if 0x6adfb982 > stack[-1] label_00B0: // Incoming jump from 0x00AF, if not 0x6adfb982 > stack[-1] // Inputs[1] { @00B0 stack[-1] } 00B0 80 DUP1 00B1 63 PUSH4 0x6adfb982 00B6 14 EQ 00B7 62 PUSH3 0x000642 00BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000642, if 0x6adfb982 == stack[-1] label_00BC: // Incoming jump from 0x00BB, if not 0x6adfb982 == stack[-1] // Inputs[1] { @00BC stack[-1] } 00BC 80 DUP1 00BD 63 PUSH4 0x737fa33d 00C2 14 EQ 00C3 62 PUSH3 0x000670 00C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000670, if 0x737fa33d == stack[-1] label_00C8: // Incoming jump from 0x00C7, if not 0x737fa33d == stack[-1] // Inputs[1] { @00C8 stack[-1] } 00C8 80 DUP1 00C9 63 PUSH4 0x7b80ec8c 00CE 14 EQ 00CF 62 PUSH3 0x0006bd 00D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0006bd, if 0x7b80ec8c == stack[-1] label_00D4: // Incoming jump from 0x00D3, if not 0x7b80ec8c == stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D4 80 DUP1 00D5 63 PUSH4 0x8da5cb5b 00DA 14 EQ 00DB 62 PUSH3 0x000707 00DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000707, if 0x8da5cb5b == stack[-1] label_00E0: // Incoming jump from 0x00DF, if not 0x8da5cb5b == stack[-1] 00E0 62 PUSH3 0x0001f6 00E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_00E5: // Incoming jump from 0x00AF, if 0x6adfb982 > stack[-1] // Inputs[1] { @00E6 stack[-1] } 00E5 5B JUMPDEST 00E6 80 DUP1 00E7 63 PUSH4 0x4955bae6 00EC 14 EQ 00ED 62 PUSH3 0x000582 00F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000582, if 0x4955bae6 == stack[-1] label_00F2: // Incoming jump from 0x00F1, if not 0x4955bae6 == stack[-1] // Inputs[1] { @00F2 stack[-1] } 00F2 80 DUP1 00F3 63 PUSH4 0x4fb2e45d 00F8 14 EQ 00F9 62 PUSH3 0x00058c 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00058c, if 0x4fb2e45d == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x4fb2e45d == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x578e4b23 0104 14 EQ 0105 62 PUSH3 0x0005d0 0109 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0005d0, if 0x578e4b23 == stack[-1] label_010A: // Incoming jump from 0x0109, if not 0x578e4b23 == stack[-1] // Inputs[1] { @010A stack[-1] } 010A 80 DUP1 010B 63 PUSH4 0x58d4696c 0110 14 EQ 0111 62 PUSH3 0x0005fe 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0005fe, if 0x58d4696c == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x58d4696c == stack[-1] 0116 62 PUSH3 0x0001f6 011A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_011B: // Incoming jump from 0x001F, if 0x4955bae6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @011C stack[-1] } 011B 5B JUMPDEST 011C 80 DUP1 011D 63 PUSH4 0x25fda590 0122 11 GT 0123 62 PUSH3 0x00019f 0127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00019f, if 0x25fda590 > stack[-1] label_0128: // Incoming jump from 0x0127, if not 0x25fda590 > stack[-1] // Inputs[1] { @0128 stack[-1] } 0128 80 DUP1 0129 63 PUSH4 0x42422ed9 012E 11 GT 012F 62 PUSH3 0x000169 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000169, if 0x42422ed9 > stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x42422ed9 > stack[-1] // Inputs[1] { @0134 stack[-1] } 0134 80 DUP1 0135 63 PUSH4 0x42422ed9 013A 14 EQ 013B 62 PUSH3 0x0004d7 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0004d7, if 0x42422ed9 == stack[-1] label_0140: // Incoming jump from 0x013F, if not 0x42422ed9 == stack[-1] // Inputs[1] { @0140 stack[-1] } 0140 80 DUP1 0141 63 PUSH4 0x47715d18 0146 14 EQ 0147 62 PUSH3 0x00050b 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00050b, if 0x47715d18 == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x47715d18 == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x4777b3e7 0152 14 EQ 0153 62 PUSH3 0x00053c 0157 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00053c, if 0x4777b3e7 == stack[-1] label_0158: // Incoming jump from 0x0157, if not 0x4777b3e7 == stack[-1] // Inputs[1] { @0158 stack[-1] } 0158 80 DUP1 0159 63 PUSH4 0x481c6a75 015E 14 EQ 015F 62 PUSH3 0x00056a 0163 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00056a, if 0x481c6a75 == stack[-1] label_0164: // Incoming jump from 0x0163, if not 0x481c6a75 == stack[-1] 0164 62 PUSH3 0x0001f6 0168 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_0169: // Incoming jump from 0x0133, if 0x42422ed9 > stack[-1] // Inputs[1] { @016A stack[-1] } 0169 5B JUMPDEST 016A 80 DUP1 016B 63 PUSH4 0x25fda590 0170 14 EQ 0171 62 PUSH3 0x000398 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000398, if 0x25fda590 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x25fda590 == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x2ea9622e 017C 14 EQ 017D 62 PUSH3 0x0003c6 0181 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0003c6, if 0x2ea9622e == stack[-1] label_0182: // Incoming jump from 0x0181, if not 0x2ea9622e == stack[-1] // Inputs[1] { @0182 stack[-1] } 0182 80 DUP1 0183 63 PUSH4 0x363ce139 0188 14 EQ 0189 62 PUSH3 0x00047f 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00047f, if 0x363ce139 == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x363ce139 == stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0x3a293885 0194 14 EQ 0195 62 PUSH3 0x0004a9 0199 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0004a9, if 0x3a293885 == stack[-1] label_019A: // Incoming jump from 0x0199, if not 0x3a293885 == stack[-1] 019A 62 PUSH3 0x0001f6 019E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_019F: // Incoming jump from 0x0127, if 0x25fda590 > stack[-1] // Inputs[1] { @01A0 stack[-1] } 019F 5B JUMPDEST 01A0 80 DUP1 01A1 60 PUSH1 0x0e 01A3 11 GT 01A4 62 PUSH3 0x0001da 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0001da, if 0x0e > stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x0e > stack[-1] // Inputs[1] { @01A9 stack[-1] } 01A9 80 DUP1 01AA 60 PUSH1 0x0e 01AC 14 EQ 01AD 62 PUSH3 0x000288 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000288, if 0x0e == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x0e == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 62 PUSH3 0x9952eb 01B7 14 EQ 01B8 62 PUSH3 0x0002b6 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0002b6, if 0x9952eb == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x9952eb == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x0aebace4 01C3 14 EQ 01C4 62 PUSH3 0x0002ea 01C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0002ea, if 0x0aebace4 == stack[-1] label_01C9: // Incoming jump from 0x01C8, if not 0x0aebace4 == stack[-1] // Inputs[1] { @01C9 stack[-1] } 01C9 80 DUP1 01CA 63 PUSH4 0x104971c2 01CF 14 EQ 01D0 62 PUSH3 0x000344 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000344, if 0x104971c2 == stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x104971c2 == stack[-1] 01D5 62 PUSH3 0x0001f6 01D9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0001f6 label_01DA: // Incoming jump from 0x01A8, if 0x0e > stack[-1] // Inputs[1] { @01DB stack[-1] } 01DA 5B JUMPDEST 01DB 80 DUP1 01DC 60 PUSH1 0x03 01DE 14 EQ 01DF 62 PUSH3 0x0001f8 01E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0001f8, if 0x03 == stack[-1] label_01E4: // Incoming jump from 0x01E3, if not 0x03 == stack[-1] // Inputs[1] { @01E4 stack[-1] } 01E4 80 DUP1 01E5 60 PUSH1 0x08 01E7 14 EQ 01E8 62 PUSH3 0x000226 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000226, if 0x08 == stack[-1] label_01ED: // Incoming jump from 0x01EC, if not 0x08 == stack[-1] // Inputs[1] { @01ED stack[-1] } 01ED 80 DUP1 01EE 60 PUSH1 0x0c 01F0 14 EQ 01F1 62 PUSH3 0x000254 01F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000254, if 0x0c == stack[-1] label_01F6: // Incoming jump from 0x00A2 // Incoming return from call to 0x036A at 0x0365 // Incoming return from call to 0x0624 at 0x061F // Incoming return from call to 0x05F6 at 0x05F1 // Incoming return from call to 0x0902 at 0x08FD // Incoming return from call to 0x0562 at 0x055D // Incoming return from call to 0x0531 at 0x052C // Incoming return from call to 0x1F66 at 0x058B // Incoming jump from 0x01D9 // Incoming jump from 0x019E // Incoming return from call to 0x02DC at 0x02D7 // Incoming return from call to 0x02DC at 0x02D7 // Incoming return from call to 0x03EC at 0x03E7 // Incoming return from call to 0x0890 at 0x088B // Incoming return from call to 0x04FD at 0x04F8 // Incoming return from call to 0x024C at 0x0247 // Incoming jump from 0x000D, if msg.data.length < 0x04 // Incoming return from call to 0x081E at 0x0819 // Incoming return from call to 0x0668 at 0x0663 // Incoming return from call to 0x02AE at 0x02A9 // Incoming return from call to 0x02AE at 0x02A9 // Incoming jump from 0x01F5, if not 0x0c == stack[-1] // Incoming jump from 0x011A // Incoming return from call to 0x027A at 0x0275 // Incoming jump from 0x00E4 // Incoming jump from 0x006C // Incoming return from call to 0x0745 at 0x0740 // Incoming return from call to 0x04CF at 0x04CA // Incoming return from call to 0x03BE at 0x03B9 // Incoming return from call to 0x05B2 at 0x05AD // Incoming return from call to 0x084C at 0x0847 // Incoming jump from 0x0168 // Incoming return from call to 0x08D4 at 0x08CF // Incoming return from call to 0x06E3 at 0x06DE // Incoming return from call to 0x0948 at 0x0943 01F6 5B JUMPDEST 01F7 00 *STOP // Stack delta = +0 // Outputs[1] { @01F7 stop(); } // Block terminates label_01F8: // Incoming jump from 0x01E3, if 0x03 == stack[-1] // Inputs[1] { @01F9 msg.value } 01F8 5B JUMPDEST 01F9 34 CALLVALUE 01FA 80 DUP1 01FB 15 ISZERO 01FC 62 PUSH3 0x000205 0200 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F9 stack[0] = msg.value } // Block ends with conditional jump to 0x000205, if !msg.value label_0201: // Incoming jump from 0x0200, if not !msg.value // Inputs[1] { @0204 memory[0x00:0x00] } 0201 60 PUSH1 0x00 0203 80 DUP1 0204 FD *REVERT // Stack delta = +0 // Outputs[1] { @0204 revert(memory[0x00:0x00]); } // Block terminates label_0205: // Incoming jump from 0x0200, if !msg.value // Inputs[1] { @020E msg.data.length } 0205 5B JUMPDEST 0206 50 POP 0207 62 PUSH3 0x0001f6 020B 60 PUSH1 0x04 020D 80 DUP1 020E 36 CALLDATASIZE 020F 03 SUB 0210 60 PUSH1 0x20 0212 81 DUP2 0213 10 LT 0214 15 ISZERO 0215 62 PUSH3 0x00021e 0219 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0207 stack[-1] = 0x0001f6 // @020B stack[0] = 0x04 // @020F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x00021e, if !(msg.data.length - 0x04 < 0x20) label_021A: // Incoming jump from 0x0219, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @021D memory[0x00:0x00] } 021A 60 PUSH1 0x00 021C 80 DUP1 021D FD *REVERT // Stack delta = +0 // Outputs[1] { @021D revert(memory[0x00:0x00]); } // Block terminates label_021E: // Incoming jump from 0x0219, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0220 stack[-2] // @0220 msg.data[stack[-2]:stack[-2] + 0x20] // } 021E 5B JUMPDEST 021F 50 POP 0220 35 CALLDATALOAD 0221 62 PUSH3 0x0009fb 0225 56 *JUMP // Stack delta = -1 // Outputs[1] { @0220 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0009fb label_0226: // Incoming jump from 0x01EC, if 0x08 == stack[-1] // Inputs[1] { @0227 msg.value } 0226 5B JUMPDEST 0227 34 CALLVALUE 0228 80 DUP1 0229 15 ISZERO 022A 62 PUSH3 0x000233 022E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0227 stack[0] = msg.value } // Block ends with conditional jump to 0x000233, if !msg.value label_022F: // Incoming jump from 0x022E, if not !msg.value // Inputs[1] { @0232 memory[0x00:0x00] } 022F 60 PUSH1 0x00 0231 80 DUP1 0232 FD *REVERT // Stack delta = +0 // Outputs[1] { @0232 revert(memory[0x00:0x00]); } // Block terminates label_0233: // Incoming jump from 0x022E, if !msg.value // Inputs[1] { @023C msg.data.length } 0233 5B JUMPDEST 0234 50 POP 0235 62 PUSH3 0x0001f6 0239 60 PUSH1 0x04 023B 80 DUP1 023C 36 CALLDATASIZE 023D 03 SUB 023E 60 PUSH1 0x20 0240 81 DUP2 0241 10 LT 0242 15 ISZERO 0243 62 PUSH3 0x00024c 0247 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0235 stack[-1] = 0x0001f6 // @0239 stack[0] = 0x04 // @023D stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00024c, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_0248: // Incoming jump from 0x0247, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @024B memory[0x00:0x00] } 0248 60 PUSH1 0x00 024A 80 DUP1 024B FD *REVERT // Stack delta = +0 // Outputs[1] { @024B revert(memory[0x00:0x00]); } // Block terminates label_024C: // Incoming call from 0x0247, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @024E msg.data[stack[-2]:stack[-2] + 0x20] // @024E stack[-2] // } 024C 5B JUMPDEST 024D 50 POP 024E 35 CALLDATALOAD 024F 62 PUSH3 0x000a83 0253 56 *JUMP // Stack delta = -1 // Outputs[1] { @024E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x000a83 label_0254: // Incoming jump from 0x01F5, if 0x0c == stack[-1] // Inputs[1] { @0255 msg.value } 0254 5B JUMPDEST 0255 34 CALLVALUE 0256 80 DUP1 0257 15 ISZERO 0258 62 PUSH3 0x000261 025C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0255 stack[0] = msg.value } // Block ends with conditional jump to 0x000261, if !msg.value label_025D: // Incoming jump from 0x025C, if not !msg.value // Inputs[1] { @0260 memory[0x00:0x00] } 025D 60 PUSH1 0x00 025F 80 DUP1 0260 FD *REVERT // Stack delta = +0 // Outputs[1] { @0260 revert(memory[0x00:0x00]); } // Block terminates label_0261: // Incoming jump from 0x025C, if !msg.value // Inputs[1] { @026A msg.data.length } 0261 5B JUMPDEST 0262 50 POP 0263 62 PUSH3 0x0001f6 0267 60 PUSH1 0x04 0269 80 DUP1 026A 36 CALLDATASIZE 026B 03 SUB 026C 60 PUSH1 0x40 026E 81 DUP2 026F 10 LT 0270 15 ISZERO 0271 62 PUSH3 0x00027a 0275 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0263 stack[-1] = 0x0001f6 // @0267 stack[0] = 0x04 // @026B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00027a, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) label_0276: // Incoming jump from 0x0275, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0279 memory[0x00:0x00] } 0276 60 PUSH1 0x00 0278 80 DUP1 0279 FD *REVERT // Stack delta = +0 // Outputs[1] { @0279 revert(memory[0x00:0x00]); } // Block terminates label_027A: // Incoming call from 0x0275, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @027C stack[-2] // @027D msg.data[stack[-2]:stack[-2] + 0x20] // @0282 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 027A 5B JUMPDEST 027B 50 POP 027C 80 DUP1 027D 35 CALLDATALOAD 027E 90 SWAP1 027F 60 PUSH1 0x20 0281 01 ADD 0282 35 CALLDATALOAD 0283 62 PUSH3 0x000fa2 0287 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @027E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0282 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x000fa2 label_0288: // Incoming jump from 0x01B1, if 0x0e == stack[-1] // Inputs[1] { @0289 msg.value } 0288 5B JUMPDEST 0289 34 CALLVALUE 028A 80 DUP1 028B 15 ISZERO 028C 62 PUSH3 0x000295 0290 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0289 stack[0] = msg.value } // Block ends with conditional jump to 0x000295, if !msg.value label_0291: // Incoming jump from 0x0290, if not !msg.value // Inputs[1] { @0294 memory[0x00:0x00] } 0291 60 PUSH1 0x00 0293 80 DUP1 0294 FD *REVERT // Stack delta = +0 // Outputs[1] { @0294 revert(memory[0x00:0x00]); } // Block terminates label_0295: // Incoming jump from 0x0290, if !msg.value // Inputs[1] { @029E msg.data.length } 0295 5B JUMPDEST 0296 50 POP 0297 62 PUSH3 0x0001f6 029B 60 PUSH1 0x04 029D 80 DUP1 029E 36 CALLDATASIZE 029F 03 SUB 02A0 60 PUSH1 0x20 02A2 81 DUP2 02A3 10 LT 02A4 15 ISZERO 02A5 62 PUSH3 0x0002ae 02A9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0297 stack[-1] = 0x0001f6 // @029B stack[0] = 0x04 // @029F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0002ae, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_02AA: // Incoming jump from 0x02A9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02AD memory[0x00:0x00] } 02AA 60 PUSH1 0x00 02AC 80 DUP1 02AD FD *REVERT // Stack delta = +0 // Outputs[1] { @02AD revert(memory[0x00:0x00]); } // Block terminates label_02AE: // Incoming call from 0x02A9, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @02B0 stack[-2] // @02B0 msg.data[stack[-2]:stack[-2] + 0x20] // } 02AE 5B JUMPDEST 02AF 50 POP 02B0 35 CALLDATALOAD 02B1 62 PUSH3 0x0010e8 02B5 56 *JUMP // Stack delta = -1 // Outputs[1] { @02B0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0010e8 label_02B6: // Incoming jump from 0x01BC, if 0x9952eb == stack[-1] // Inputs[1] { @02B7 msg.value } 02B6 5B JUMPDEST 02B7 34 CALLVALUE 02B8 80 DUP1 02B9 15 ISZERO 02BA 62 PUSH3 0x0002c3 02BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B7 stack[0] = msg.value } // Block ends with conditional jump to 0x0002c3, if !msg.value label_02BF: // Incoming jump from 0x02BE, if not !msg.value // Inputs[1] { @02C2 memory[0x00:0x00] } 02BF 60 PUSH1 0x00 02C1 80 DUP1 02C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C2 revert(memory[0x00:0x00]); } // Block terminates label_02C3: // Incoming jump from 0x02BE, if !msg.value // Inputs[1] { @02CC msg.data.length } 02C3 5B JUMPDEST 02C4 50 POP 02C5 62 PUSH3 0x0001f6 02C9 60 PUSH1 0x04 02CB 80 DUP1 02CC 36 CALLDATASIZE 02CD 03 SUB 02CE 60 PUSH1 0x40 02D0 81 DUP2 02D1 10 LT 02D2 15 ISZERO 02D3 62 PUSH3 0x0002dc 02D7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02C5 stack[-1] = 0x0001f6 // @02C9 stack[0] = 0x04 // @02CD stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0002dc, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) label_02D8: // Incoming jump from 0x02D7, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02DB memory[0x00:0x00] } 02D8 60 PUSH1 0x00 02DA 80 DUP1 02DB FD *REVERT // Stack delta = +0 // Outputs[1] { @02DB revert(memory[0x00:0x00]); } // Block terminates label_02DC: // Incoming call from 0x02D7, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @02DE stack[-2] // @02DF msg.data[stack[-2]:stack[-2] + 0x20] // @02E4 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 02DC 5B JUMPDEST 02DD 50 POP 02DE 80 DUP1 02DF 35 CALLDATALOAD 02E0 90 SWAP1 02E1 60 PUSH1 0x20 02E3 01 ADD 02E4 35 CALLDATALOAD 02E5 62 PUSH3 0x0014a1 02E9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @02E4 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0014a1 label_02EA: // Incoming jump from 0x01C8, if 0x0aebace4 == stack[-1] // Inputs[1] { @02EB msg.value } 02EA 5B JUMPDEST 02EB 34 CALLVALUE 02EC 80 DUP1 02ED 15 ISZERO 02EE 62 PUSH3 0x0002f7 02F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02EB stack[0] = msg.value } // Block ends with conditional jump to 0x0002f7, if !msg.value label_02F3: // Incoming jump from 0x02F2, if not !msg.value // Inputs[1] { @02F6 memory[0x00:0x00] } 02F3 60 PUSH1 0x00 02F5 80 DUP1 02F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F6 revert(memory[0x00:0x00]); } // Block terminates label_02F7: // Incoming jump from 0x02F2, if !msg.value // Inputs[1] { @0300 msg.data.length } 02F7 5B JUMPDEST 02F8 50 POP 02F9 62 PUSH3 0x00031b 02FD 60 PUSH1 0x04 02FF 80 DUP1 0300 36 CALLDATASIZE 0301 03 SUB 0302 60 PUSH1 0x20 0304 81 DUP2 0305 10 LT 0306 15 ISZERO 0307 62 PUSH3 0x000310 030B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02F9 stack[-1] = 0x00031b // @02FD stack[0] = 0x04 // @0301 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000310, returns to 0x031B, if !(msg.data.length - 0x04 < 0x20) label_030C: // Incoming jump from 0x030B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @030F memory[0x00:0x00] } 030C 60 PUSH1 0x00 030E 80 DUP1 030F FD *REVERT // Stack delta = +0 // Outputs[1] { @030F revert(memory[0x00:0x00]); } // Block terminates label_0310: // Incoming call from 0x030B, returns to 0x031B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0312 stack[-2] // @0312 msg.data[stack[-2]:stack[-2] + 0x20] // } 0310 5B JUMPDEST 0311 50 POP 0312 35 CALLDATALOAD 0313 60 PUSH1 0xff 0315 16 AND 0316 62 PUSH3 0x00162c 031A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0315 stack[-2] = 0xff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x00162c label_031B: // Incoming return from call to 0x28BA at 0x071E // Incoming return from call to 0x0310 at 0x030B // Incoming return from call to 0x1F4A at 0x0581 // Inputs[4] // { // @031F memory[0x40:0x60] // @0336 stack[-1] // @033A memory[0x40:0x60] // @0343 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 031B 5B JUMPDEST 031C 60 PUSH1 0x40 031E 80 DUP1 031F 51 MLOAD 0320 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0335 90 SWAP1 0336 92 SWAP3 0337 16 AND 0338 82 DUP3 0339 52 MSTORE 033A 51 MLOAD 033B 90 SWAP1 033C 81 DUP2 033D 90 SWAP1 033E 03 SUB 033F 60 PUSH1 0x20 0341 01 ADD 0342 90 SWAP1 0343 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0339 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @0343 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0344: // Incoming jump from 0x01D4, if 0x104971c2 == stack[-1] // Inputs[1] { @0345 msg.value } 0344 5B JUMPDEST 0345 34 CALLVALUE 0346 80 DUP1 0347 15 ISZERO 0348 62 PUSH3 0x000351 034C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0345 stack[0] = msg.value } // Block ends with conditional jump to 0x000351, if !msg.value label_034D: // Incoming jump from 0x034C, if not !msg.value // Inputs[1] { @0350 memory[0x00:0x00] } 034D 60 PUSH1 0x00 034F 80 DUP1 0350 FD *REVERT // Stack delta = +0 // Outputs[1] { @0350 revert(memory[0x00:0x00]); } // Block terminates label_0351: // Incoming jump from 0x034C, if !msg.value // Inputs[1] { @035A msg.data.length } 0351 5B JUMPDEST 0352 50 POP 0353 62 PUSH3 0x0001f6 0357 60 PUSH1 0x04 0359 80 DUP1 035A 36 CALLDATASIZE 035B 03 SUB 035C 60 PUSH1 0x60 035E 81 DUP2 035F 10 LT 0360 15 ISZERO 0361 62 PUSH3 0x00036a 0365 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0353 stack[-1] = 0x0001f6 // @0357 stack[0] = 0x04 // @035B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00036a, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x60) label_0366: // Incoming jump from 0x0365, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0369 memory[0x00:0x00] } 0366 60 PUSH1 0x00 0368 80 DUP1 0369 FD *REVERT // Stack delta = +0 // Outputs[1] { @0369 revert(memory[0x00:0x00]); } // Block terminates label_036A: // Incoming call from 0x0365, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0381 stack[-2] // @0382 msg.data[stack[-2]:stack[-2] + 0x20] // @038A msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0392 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 036A 5B JUMPDEST 036B 50 POP 036C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0381 81 DUP2 0382 35 CALLDATALOAD 0383 81 DUP2 0384 16 AND 0385 91 SWAP2 0386 60 PUSH1 0x20 0388 81 DUP2 0389 01 ADD 038A 35 CALLDATALOAD 038B 90 SWAP1 038C 91 SWAP2 038D 16 AND 038E 90 SWAP1 038F 60 PUSH1 0x40 0391 01 ADD 0392 35 CALLDATALOAD 0393 62 PUSH3 0x001657 0397 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0385 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @038E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0392 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x001657 label_0398: // Incoming jump from 0x0175, if 0x25fda590 == stack[-1] // Inputs[1] { @0399 msg.value } 0398 5B JUMPDEST 0399 34 CALLVALUE 039A 80 DUP1 039B 15 ISZERO 039C 62 PUSH3 0x0003a5 03A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0399 stack[0] = msg.value } // Block ends with conditional jump to 0x0003a5, if !msg.value label_03A1: // Incoming jump from 0x03A0, if not !msg.value // Inputs[1] { @03A4 memory[0x00:0x00] } 03A1 60 PUSH1 0x00 03A3 80 DUP1 03A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A4 revert(memory[0x00:0x00]); } // Block terminates label_03A5: // Incoming jump from 0x03A0, if !msg.value // Inputs[1] { @03AE msg.data.length } 03A5 5B JUMPDEST 03A6 50 POP 03A7 62 PUSH3 0x0001f6 03AB 60 PUSH1 0x04 03AD 80 DUP1 03AE 36 CALLDATASIZE 03AF 03 SUB 03B0 60 PUSH1 0x20 03B2 81 DUP2 03B3 10 LT 03B4 15 ISZERO 03B5 62 PUSH3 0x0003be 03B9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03A7 stack[-1] = 0x0001f6 // @03AB stack[0] = 0x04 // @03AF stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0003be, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_03BA: // Incoming jump from 0x03B9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @03BD memory[0x00:0x00] } 03BA 60 PUSH1 0x00 03BC 80 DUP1 03BD FD *REVERT // Stack delta = +0 // Outputs[1] { @03BD revert(memory[0x00:0x00]); } // Block terminates label_03BE: // Incoming call from 0x03B9, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @03C0 stack[-2] // @03C0 msg.data[stack[-2]:stack[-2] + 0x20] // } 03BE 5B JUMPDEST 03BF 50 POP 03C0 35 CALLDATALOAD 03C1 62 PUSH3 0x001713 03C5 56 *JUMP // Stack delta = -1 // Outputs[1] { @03C0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x001713 label_03C6: // Incoming jump from 0x0181, if 0x2ea9622e == stack[-1] // Inputs[1] { @03C7 msg.value } 03C6 5B JUMPDEST 03C7 34 CALLVALUE 03C8 80 DUP1 03C9 15 ISZERO 03CA 62 PUSH3 0x0003d3 03CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C7 stack[0] = msg.value } // Block ends with conditional jump to 0x0003d3, if !msg.value label_03CF: // Incoming jump from 0x03CE, if not !msg.value // Inputs[1] { @03D2 memory[0x00:0x00] } 03CF 60 PUSH1 0x00 03D1 80 DUP1 03D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D2 revert(memory[0x00:0x00]); } // Block terminates label_03D3: // Incoming jump from 0x03CE, if !msg.value // Inputs[1] { @03DC msg.data.length } 03D3 5B JUMPDEST 03D4 50 POP 03D5 62 PUSH3 0x0001f6 03D9 60 PUSH1 0x04 03DB 80 DUP1 03DC 36 CALLDATASIZE 03DD 03 SUB 03DE 60 PUSH1 0x40 03E0 81 DUP2 03E1 10 LT 03E2 15 ISZERO 03E3 62 PUSH3 0x0003ec 03E7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03D5 stack[-1] = 0x0001f6 // @03D9 stack[0] = 0x04 // @03DD stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0003ec, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) label_03E8: // Incoming jump from 0x03E7, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03EB memory[0x00:0x00] } 03E8 60 PUSH1 0x00 03EA 80 DUP1 03EB FD *REVERT // Stack delta = +0 // Outputs[1] { @03EB revert(memory[0x00:0x00]); } // Block terminates label_03EC: // Incoming call from 0x03E7, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @03ED stack[-2] // @03EE stack[-1] // @03F5 msg.data[stack[-2]:stack[-2] + 0x20] // } 03EC 5B JUMPDEST 03ED 81 DUP2 03EE 01 ADD 03EF 90 SWAP1 03F0 60 PUSH1 0x20 03F2 81 DUP2 03F3 01 ADD 03F4 81 DUP2 03F5 35 CALLDATALOAD 03F6 64 PUSH5 0x0100000000 03FC 81 DUP2 03FD 11 GT 03FE 15 ISZERO 03FF 62 PUSH3 0x000408 0403 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @03EF stack[-1] = stack[-2] // @03EF stack[-2] = stack[-2] + stack[-1] // @03F3 stack[0] = stack[-2] + 0x20 // @03F5 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x000408, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0404: // Incoming jump from 0x0403, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0407 memory[0x00:0x00] } 0404 60 PUSH1 0x00 0406 80 DUP1 0407 FD *REVERT // Stack delta = +0 // Outputs[1] { @0407 revert(memory[0x00:0x00]); } // Block terminates label_0408: // Incoming jump from 0x0403, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0409 stack[-3] // @040A stack[-1] // @040B stack[-4] // } 0408 5B JUMPDEST 0409 82 DUP3 040A 01 ADD 040B 83 DUP4 040C 60 PUSH1 0x20 040E 82 DUP3 040F 01 ADD 0410 11 GT 0411 15 ISZERO 0412 62 PUSH3 0x00041b 0416 57 *JUMPI // Stack delta = +0 // Outputs[1] { @040A stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x00041b, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0417: // Incoming jump from 0x0416, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @041A memory[0x00:0x00] } 0417 60 PUSH1 0x00 0419 80 DUP1 041A FD *REVERT // Stack delta = +0 // Outputs[1] { @041A revert(memory[0x00:0x00]); } // Block terminates label_041B: // Incoming jump from 0x0416, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @041C stack[-1] // @041D msg.data[stack[-1]:stack[-1] + 0x20] // @0422 stack[-2] // @0423 stack[-4] // } 041B 5B JUMPDEST 041C 80 DUP1 041D 35 CALLDATALOAD 041E 90 SWAP1 041F 60 PUSH1 0x20 0421 01 ADD 0422 91 SWAP2 0423 84 DUP5 0424 60 PUSH1 0x20 0426 83 DUP4 0427 02 MUL 0428 84 DUP5 0429 01 ADD 042A 11 GT 042B 64 PUSH5 0x0100000000 0431 83 DUP4 0432 11 GT 0433 17 OR 0434 15 ISZERO 0435 62 PUSH3 0x00043e 0439 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @041E stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0422 stack[0] = stack[-2] // @0422 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x00043e, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_043A: // Incoming jump from 0x0439, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @043D memory[0x00:0x00] } 043A 60 PUSH1 0x00 043C 80 DUP1 043D FD *REVERT // Stack delta = +0 // Outputs[1] { @043D revert(memory[0x00:0x00]); } // Block terminates label_043E: // Incoming jump from 0x0439, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @043F stack[-3] // @043F stack[-1] // @0440 stack[-2] // @044B memory[0x40:0x60] // @0465 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0470 stack[-5] // @0475 msg.data[stack[-1]:stack[-1] + 0x20] // @0478 stack[-4] // } 043E 5B JUMPDEST 043F 91 SWAP2 0440 90 SWAP1 0441 80 DUP1 0442 80 DUP1 0443 60 PUSH1 0x20 0445 02 MUL 0446 60 PUSH1 0x20 0448 01 ADD 0449 60 PUSH1 0x40 044B 51 MLOAD 044C 90 SWAP1 044D 81 DUP2 044E 01 ADD 044F 60 PUSH1 0x40 0451 52 MSTORE 0452 80 DUP1 0453 93 SWAP4 0454 92 SWAP3 0455 91 SWAP2 0456 90 SWAP1 0457 81 DUP2 0458 81 DUP2 0459 52 MSTORE 045A 60 PUSH1 0x20 045C 01 ADD 045D 83 DUP4 045E 83 DUP4 045F 60 PUSH1 0x20 0461 02 MUL 0462 80 DUP1 0463 82 DUP3 0464 84 DUP5 0465 37 CALLDATACOPY 0466 60 PUSH1 0x00 0468 92 SWAP3 0469 01 ADD 046A 91 SWAP2 046B 90 SWAP1 046C 91 SWAP2 046D 52 MSTORE 046E 50 POP 046F 92 SWAP3 0470 95 SWAP6 0471 50 POP 0472 50 POP 0473 50 POP 0474 50 POP 0475 35 CALLDATALOAD 0476 15 ISZERO 0477 15 ISZERO 0478 90 SWAP1 0479 50 POP 047A 62 PUSH3 0x001775 047E 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @0451 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0459 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0465 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @046D memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0470 stack[-5] = memory[0x40:0x60] // @0478 stack[-4] = !!msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x001775 label_047F: // Incoming jump from 0x018D, if 0x363ce139 == stack[-1] // Inputs[1] { @0480 msg.value } 047F 5B JUMPDEST 0480 34 CALLVALUE 0481 80 DUP1 0482 15 ISZERO 0483 62 PUSH3 0x00048c 0487 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0480 stack[0] = msg.value } // Block ends with conditional jump to 0x00048c, if !msg.value label_0488: // Incoming jump from 0x0487, if not !msg.value // Inputs[1] { @048B memory[0x00:0x00] } 0488 60 PUSH1 0x00 048A 80 DUP1 048B FD *REVERT // Stack delta = +0 // Outputs[1] { @048B revert(memory[0x00:0x00]); } // Block terminates label_048C: // Incoming jump from 0x0487, if !msg.value 048C 5B JUMPDEST 048D 50 POP 048E 62 PUSH3 0x000497 0492 62 PUSH3 0x00181f 0496 56 *JUMP // Stack delta = +0 // Outputs[1] { @048E stack[-1] = 0x000497 } // Block ends with call to 0x00181f, returns to 0x0497 label_0497: // Incoming return from call to 0x0696 at 0x0691 // Incoming return from call to 0x181F at 0x0496 // Inputs[4] // { // @049B memory[0x40:0x60] // @049C stack[-1] // @049F memory[0x40:0x60] // @04A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0497 5B JUMPDEST 0498 60 PUSH1 0x40 049A 80 DUP1 049B 51 MLOAD 049C 91 SWAP2 049D 82 DUP3 049E 52 MSTORE 049F 51 MLOAD 04A0 90 SWAP1 04A1 81 DUP2 04A2 90 SWAP1 04A3 03 SUB 04A4 60 PUSH1 0x20 04A6 01 ADD 04A7 90 SWAP1 04A8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @049E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04A8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_04A9: // Incoming jump from 0x0199, if 0x3a293885 == stack[-1] // Inputs[1] { @04AA msg.value } 04A9 5B JUMPDEST 04AA 34 CALLVALUE 04AB 80 DUP1 04AC 15 ISZERO 04AD 62 PUSH3 0x0004b6 04B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AA stack[0] = msg.value } // Block ends with conditional jump to 0x0004b6, if !msg.value label_04B2: // Incoming jump from 0x04B1, if not !msg.value // Inputs[1] { @04B5 memory[0x00:0x00] } 04B2 60 PUSH1 0x00 04B4 80 DUP1 04B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B5 revert(memory[0x00:0x00]); } // Block terminates label_04B6: // Incoming jump from 0x04B1, if !msg.value // Inputs[1] { @04BF msg.data.length } 04B6 5B JUMPDEST 04B7 50 POP 04B8 62 PUSH3 0x0001f6 04BC 60 PUSH1 0x04 04BE 80 DUP1 04BF 36 CALLDATASIZE 04C0 03 SUB 04C1 60 PUSH1 0x20 04C3 81 DUP2 04C4 10 LT 04C5 15 ISZERO 04C6 62 PUSH3 0x0004cf 04CA 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04B8 stack[-1] = 0x0001f6 // @04BC stack[0] = 0x04 // @04C0 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0004cf, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_04CB: // Incoming jump from 0x04CA, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04CE memory[0x00:0x00] } 04CB 60 PUSH1 0x00 04CD 80 DUP1 04CE FD *REVERT // Stack delta = +0 // Outputs[1] { @04CE revert(memory[0x00:0x00]); } // Block terminates label_04CF: // Incoming call from 0x04CA, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04D1 stack[-2] // @04D1 msg.data[stack[-2]:stack[-2] + 0x20] // } 04CF 5B JUMPDEST 04D0 50 POP 04D1 35 CALLDATALOAD 04D2 62 PUSH3 0x001825 04D6 56 *JUMP // Stack delta = -1 // Outputs[1] { @04D1 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x001825 label_04D7: // Incoming jump from 0x013F, if 0x42422ed9 == stack[-1] // Inputs[1] { @04D8 msg.value } 04D7 5B JUMPDEST 04D8 34 CALLVALUE 04D9 80 DUP1 04DA 15 ISZERO 04DB 62 PUSH3 0x0004e4 04DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D8 stack[0] = msg.value } // Block ends with conditional jump to 0x0004e4, if !msg.value label_04E0: // Incoming jump from 0x04DF, if not !msg.value // Inputs[1] { @04E3 memory[0x00:0x00] } 04E0 60 PUSH1 0x00 04E2 80 DUP1 04E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E3 revert(memory[0x00:0x00]); } // Block terminates label_04E4: // Incoming jump from 0x04DF, if !msg.value // Inputs[1] { @04ED msg.data.length } 04E4 5B JUMPDEST 04E5 50 POP 04E6 62 PUSH3 0x0001f6 04EA 60 PUSH1 0x04 04EC 80 DUP1 04ED 36 CALLDATASIZE 04EE 03 SUB 04EF 60 PUSH1 0x40 04F1 81 DUP2 04F2 10 LT 04F3 15 ISZERO 04F4 62 PUSH3 0x0004fd 04F8 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04E6 stack[-1] = 0x0001f6 // @04EA stack[0] = 0x04 // @04EE stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0004fd, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) label_04F9: // Incoming jump from 0x04F8, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04FC memory[0x00:0x00] } 04F9 60 PUSH1 0x00 04FB 80 DUP1 04FC FD *REVERT // Stack delta = +0 // Outputs[1] { @04FC revert(memory[0x00:0x00]); } // Block terminates label_04FD: // Incoming call from 0x04F8, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @04FF stack[-2] // @0500 msg.data[stack[-2]:stack[-2] + 0x20] // @0505 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 04FD 5B JUMPDEST 04FE 50 POP 04FF 80 DUP1 0500 35 CALLDATALOAD 0501 90 SWAP1 0502 60 PUSH1 0x20 0504 01 ADD 0505 35 CALLDATALOAD 0506 62 PUSH3 0x0019bc 050A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0501 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0505 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0019bc label_050B: // Incoming jump from 0x014B, if 0x47715d18 == stack[-1] // Inputs[1] { @050C msg.value } 050B 5B JUMPDEST 050C 34 CALLVALUE 050D 80 DUP1 050E 15 ISZERO 050F 62 PUSH3 0x000518 0513 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050C stack[0] = msg.value } // Block ends with conditional jump to 0x000518, if !msg.value label_0514: // Incoming jump from 0x0513, if not !msg.value // Inputs[1] { @0517 memory[0x00:0x00] } 0514 60 PUSH1 0x00 0516 80 DUP1 0517 FD *REVERT // Stack delta = +0 // Outputs[1] { @0517 revert(memory[0x00:0x00]); } // Block terminates label_0518: // Incoming jump from 0x0513, if !msg.value // Inputs[1] { @0521 msg.data.length } 0518 5B JUMPDEST 0519 50 POP 051A 62 PUSH3 0x0001f6 051E 60 PUSH1 0x04 0520 80 DUP1 0521 36 CALLDATASIZE 0522 03 SUB 0523 60 PUSH1 0x20 0525 81 DUP2 0526 10 LT 0527 15 ISZERO 0528 62 PUSH3 0x000531 052C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @051A stack[-1] = 0x0001f6 // @051E stack[0] = 0x04 // @0522 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000531, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_052D: // Incoming jump from 0x052C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0530 memory[0x00:0x00] } 052D 60 PUSH1 0x00 052F 80 DUP1 0530 FD *REVERT // Stack delta = +0 // Outputs[1] { @0530 revert(memory[0x00:0x00]); } // Block terminates label_0531: // Incoming call from 0x052C, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0533 stack[-2] // @0533 msg.data[stack[-2]:stack[-2] + 0x20] // } 0531 5B JUMPDEST 0532 50 POP 0533 35 CALLDATALOAD 0534 60 PUSH1 0xff 0536 16 AND 0537 62 PUSH3 0x001e10 053B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0536 stack[-2] = 0xff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x001e10 label_053C: // Incoming jump from 0x0157, if 0x4777b3e7 == stack[-1] // Inputs[1] { @053D msg.value } 053C 5B JUMPDEST 053D 34 CALLVALUE 053E 80 DUP1 053F 15 ISZERO 0540 62 PUSH3 0x000549 0544 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053D stack[0] = msg.value } // Block ends with conditional jump to 0x000549, if !msg.value label_0545: // Incoming jump from 0x0544, if not !msg.value // Inputs[1] { @0548 memory[0x00:0x00] } 0545 60 PUSH1 0x00 0547 80 DUP1 0548 FD *REVERT // Stack delta = +0 // Outputs[1] { @0548 revert(memory[0x00:0x00]); } // Block terminates label_0549: // Incoming jump from 0x0544, if !msg.value // Inputs[1] { @0552 msg.data.length } 0549 5B JUMPDEST 054A 50 POP 054B 62 PUSH3 0x0001f6 054F 60 PUSH1 0x04 0551 80 DUP1 0552 36 CALLDATASIZE 0553 03 SUB 0554 60 PUSH1 0x20 0556 81 DUP2 0557 10 LT 0558 15 ISZERO 0559 62 PUSH3 0x000562 055D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @054B stack[-1] = 0x0001f6 // @054F stack[0] = 0x04 // @0553 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000562, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_055E: // Incoming jump from 0x055D, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0561 memory[0x00:0x00] } 055E 60 PUSH1 0x00 0560 80 DUP1 0561 FD *REVERT // Stack delta = +0 // Outputs[1] { @0561 revert(memory[0x00:0x00]); } // Block terminates label_0562: // Incoming call from 0x055D, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0564 stack[-2] // @0564 msg.data[stack[-2]:stack[-2] + 0x20] // } 0562 5B JUMPDEST 0563 50 POP 0564 35 CALLDATALOAD 0565 62 PUSH3 0x001ece 0569 56 *JUMP // Stack delta = -1 // Outputs[1] { @0564 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x001ece label_056A: // Incoming jump from 0x0163, if 0x481c6a75 == stack[-1] // Inputs[1] { @056B msg.value } 056A 5B JUMPDEST 056B 34 CALLVALUE 056C 80 DUP1 056D 15 ISZERO 056E 62 PUSH3 0x000577 0572 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056B stack[0] = msg.value } // Block ends with conditional jump to 0x000577, if !msg.value label_0573: // Incoming jump from 0x0572, if not !msg.value // Inputs[1] { @0576 memory[0x00:0x00] } 0573 60 PUSH1 0x00 0575 80 DUP1 0576 FD *REVERT // Stack delta = +0 // Outputs[1] { @0576 revert(memory[0x00:0x00]); } // Block terminates label_0577: // Incoming jump from 0x0572, if !msg.value 0577 5B JUMPDEST 0578 50 POP 0579 62 PUSH3 0x00031b 057D 62 PUSH3 0x001f4a 0581 56 *JUMP // Stack delta = +0 // Outputs[1] { @0579 stack[-1] = 0x00031b } // Block ends with call to 0x001f4a, returns to 0x031B label_0582: // Incoming jump from 0x00F1, if 0x4955bae6 == stack[-1] 0582 5B JUMPDEST 0583 62 PUSH3 0x0001f6 0587 62 PUSH3 0x001f66 058B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0583 stack[0] = 0x0001f6 } // Block ends with call to 0x001f66, returns to 0x01F6 label_058C: // Incoming jump from 0x00FD, if 0x4fb2e45d == stack[-1] // Inputs[1] { @058D msg.value } 058C 5B JUMPDEST 058D 34 CALLVALUE 058E 80 DUP1 058F 15 ISZERO 0590 62 PUSH3 0x000599 0594 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058D stack[0] = msg.value } // Block ends with conditional jump to 0x000599, if !msg.value label_0595: // Incoming jump from 0x0594, if not !msg.value // Inputs[1] { @0598 memory[0x00:0x00] } 0595 60 PUSH1 0x00 0597 80 DUP1 0598 FD *REVERT // Stack delta = +0 // Outputs[1] { @0598 revert(memory[0x00:0x00]); } // Block terminates label_0599: // Incoming jump from 0x0594, if !msg.value // Inputs[1] { @05A2 msg.data.length } 0599 5B JUMPDEST 059A 50 POP 059B 62 PUSH3 0x0001f6 059F 60 PUSH1 0x04 05A1 80 DUP1 05A2 36 CALLDATASIZE 05A3 03 SUB 05A4 60 PUSH1 0x20 05A6 81 DUP2 05A7 10 LT 05A8 15 ISZERO 05A9 62 PUSH3 0x0005b2 05AD 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @059B stack[-1] = 0x0001f6 // @059F stack[0] = 0x04 // @05A3 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0005b2, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_05AE: // Incoming jump from 0x05AD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05B1 memory[0x00:0x00] } 05AE 60 PUSH1 0x00 05B0 80 DUP1 05B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B1 revert(memory[0x00:0x00]); } // Block terminates label_05B2: // Incoming call from 0x05AD, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05B4 msg.data[stack[-2]:stack[-2] + 0x20] // @05B4 stack[-2] // } 05B2 5B JUMPDEST 05B3 50 POP 05B4 35 CALLDATALOAD 05B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05CA 16 AND 05CB 62 PUSH3 0x001fdf 05CF 56 *JUMP // Stack delta = -1 // Outputs[1] { @05CA stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x001fdf label_05D0: // Incoming jump from 0x0109, if 0x578e4b23 == stack[-1] // Inputs[1] { @05D1 msg.value } 05D0 5B JUMPDEST 05D1 34 CALLVALUE 05D2 80 DUP1 05D3 15 ISZERO 05D4 62 PUSH3 0x0005dd 05D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D1 stack[0] = msg.value } // Block ends with conditional jump to 0x0005dd, if !msg.value label_05D9: // Incoming jump from 0x05D8, if not !msg.value // Inputs[1] { @05DC memory[0x00:0x00] } 05D9 60 PUSH1 0x00 05DB 80 DUP1 05DC FD *REVERT // Stack delta = +0 // Outputs[1] { @05DC revert(memory[0x00:0x00]); } // Block terminates label_05DD: // Incoming jump from 0x05D8, if !msg.value // Inputs[1] { @05E6 msg.data.length } 05DD 5B JUMPDEST 05DE 50 POP 05DF 62 PUSH3 0x0001f6 05E3 60 PUSH1 0x04 05E5 80 DUP1 05E6 36 CALLDATASIZE 05E7 03 SUB 05E8 60 PUSH1 0x20 05EA 81 DUP2 05EB 10 LT 05EC 15 ISZERO 05ED 62 PUSH3 0x0005f6 05F1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @05DF stack[-1] = 0x0001f6 // @05E3 stack[0] = 0x04 // @05E7 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0005f6, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_05F2: // Incoming jump from 0x05F1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05F5 memory[0x00:0x00] } 05F2 60 PUSH1 0x00 05F4 80 DUP1 05F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F5 revert(memory[0x00:0x00]); } // Block terminates label_05F6: // Incoming call from 0x05F1, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05F8 msg.data[stack[-2]:stack[-2] + 0x20] // @05F8 stack[-2] // } 05F6 5B JUMPDEST 05F7 50 POP 05F8 35 CALLDATALOAD 05F9 62 PUSH3 0x00206c 05FD 56 *JUMP // Stack delta = -1 // Outputs[1] { @05F8 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x00206c label_05FE: // Incoming jump from 0x0115, if 0x58d4696c == stack[-1] // Inputs[1] { @05FF msg.value } 05FE 5B JUMPDEST 05FF 34 CALLVALUE 0600 80 DUP1 0601 15 ISZERO 0602 62 PUSH3 0x00060b 0606 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05FF stack[0] = msg.value } // Block ends with conditional jump to 0x00060b, if !msg.value label_0607: // Incoming jump from 0x0606, if not !msg.value // Inputs[1] { @060A memory[0x00:0x00] } 0607 60 PUSH1 0x00 0609 80 DUP1 060A FD *REVERT // Stack delta = +0 // Outputs[1] { @060A revert(memory[0x00:0x00]); } // Block terminates label_060B: // Incoming jump from 0x0606, if !msg.value // Inputs[1] { @0614 msg.data.length } 060B 5B JUMPDEST 060C 50 POP 060D 62 PUSH3 0x0001f6 0611 60 PUSH1 0x04 0613 80 DUP1 0614 36 CALLDATASIZE 0615 03 SUB 0616 60 PUSH1 0x20 0618 81 DUP2 0619 10 LT 061A 15 ISZERO 061B 62 PUSH3 0x000624 061F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @060D stack[-1] = 0x0001f6 // @0611 stack[0] = 0x04 // @0615 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000624, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_0620: // Incoming jump from 0x061F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0623 memory[0x00:0x00] } 0620 60 PUSH1 0x00 0622 80 DUP1 0623 FD *REVERT // Stack delta = +0 // Outputs[1] { @0623 revert(memory[0x00:0x00]); } // Block terminates label_0624: // Incoming call from 0x061F, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0626 msg.data[stack[-2]:stack[-2] + 0x20] // @0626 stack[-2] // } 0624 5B JUMPDEST 0625 50 POP 0626 35 CALLDATALOAD 0627 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 063C 16 AND 063D 62 PUSH3 0x002189 0641 56 *JUMP // Stack delta = -1 // Outputs[1] { @063C stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x002189 label_0642: // Incoming jump from 0x00BB, if 0x6adfb982 == stack[-1] // Inputs[1] { @0643 msg.value } 0642 5B JUMPDEST 0643 34 CALLVALUE 0644 80 DUP1 0645 15 ISZERO 0646 62 PUSH3 0x00064f 064A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0643 stack[0] = msg.value } // Block ends with conditional jump to 0x00064f, if !msg.value label_064B: // Incoming jump from 0x064A, if not !msg.value // Inputs[1] { @064E memory[0x00:0x00] } 064B 60 PUSH1 0x00 064D 80 DUP1 064E FD *REVERT // Stack delta = +0 // Outputs[1] { @064E revert(memory[0x00:0x00]); } // Block terminates label_064F: // Incoming jump from 0x064A, if !msg.value // Inputs[1] { @0658 msg.data.length } 064F 5B JUMPDEST 0650 50 POP 0651 62 PUSH3 0x0001f6 0655 60 PUSH1 0x04 0657 80 DUP1 0658 36 CALLDATASIZE 0659 03 SUB 065A 60 PUSH1 0x20 065C 81 DUP2 065D 10 LT 065E 15 ISZERO 065F 62 PUSH3 0x000668 0663 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0651 stack[-1] = 0x0001f6 // @0655 stack[0] = 0x04 // @0659 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000668, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_0664: // Incoming jump from 0x0663, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0667 memory[0x00:0x00] } 0664 60 PUSH1 0x00 0666 80 DUP1 0667 FD *REVERT // Stack delta = +0 // Outputs[1] { @0667 revert(memory[0x00:0x00]); } // Block terminates label_0668: // Incoming call from 0x0663, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @066A stack[-2] // @066A msg.data[stack[-2]:stack[-2] + 0x20] // } 0668 5B JUMPDEST 0669 50 POP 066A 35 CALLDATALOAD 066B 62 PUSH3 0x0021f7 066F 56 *JUMP // Stack delta = -1 // Outputs[1] { @066A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0021f7 label_0670: // Incoming jump from 0x00C7, if 0x737fa33d == stack[-1] // Inputs[1] { @0671 msg.value } 0670 5B JUMPDEST 0671 34 CALLVALUE 0672 80 DUP1 0673 15 ISZERO 0674 62 PUSH3 0x00067d 0678 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0671 stack[0] = msg.value } // Block ends with conditional jump to 0x00067d, if !msg.value label_0679: // Incoming jump from 0x0678, if not !msg.value // Inputs[1] { @067C memory[0x00:0x00] } 0679 60 PUSH1 0x00 067B 80 DUP1 067C FD *REVERT // Stack delta = +0 // Outputs[1] { @067C revert(memory[0x00:0x00]); } // Block terminates label_067D: // Incoming jump from 0x0678, if !msg.value // Inputs[1] { @0686 msg.data.length } 067D 5B JUMPDEST 067E 50 POP 067F 62 PUSH3 0x000497 0683 60 PUSH1 0x04 0685 80 DUP1 0686 36 CALLDATASIZE 0687 03 SUB 0688 60 PUSH1 0x40 068A 81 DUP2 068B 10 LT 068C 15 ISZERO 068D 62 PUSH3 0x000696 0691 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @067F stack[-1] = 0x000497 // @0683 stack[0] = 0x04 // @0687 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000696, returns to 0x0497, if !(msg.data.length - 0x04 < 0x40) label_0692: // Incoming jump from 0x0691, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0695 memory[0x00:0x00] } 0692 60 PUSH1 0x00 0694 80 DUP1 0695 FD *REVERT // Stack delta = +0 // Outputs[1] { @0695 revert(memory[0x00:0x00]); } // Block terminates label_0696: // Incoming call from 0x0691, returns to 0x0497, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0698 stack[-2] // @0699 msg.data[stack[-2]:stack[-2] + 0x20] // @06A1 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0696 5B JUMPDEST 0697 50 POP 0698 80 DUP1 0699 35 CALLDATALOAD 069A 60 PUSH1 0xff 069C 16 AND 069D 90 SWAP1 069E 60 PUSH1 0x20 06A0 01 ADD 06A1 35 CALLDATALOAD 06A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06B7 16 AND 06B8 62 PUSH3 0x0026b0 06BC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @069D stack[-2] = 0xff & msg.data[stack[-2]:stack[-2] + 0x20] // @06B7 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0026b0 label_06BD: // Incoming jump from 0x00D3, if 0x7b80ec8c == stack[-1] // Inputs[1] { @06BE msg.value } 06BD 5B JUMPDEST 06BE 34 CALLVALUE 06BF 80 DUP1 06C0 15 ISZERO 06C1 62 PUSH3 0x0006ca 06C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06BE stack[0] = msg.value } // Block ends with conditional jump to 0x0006ca, if !msg.value label_06C6: // Incoming jump from 0x06C5, if not !msg.value // Inputs[1] { @06C9 memory[0x00:0x00] } 06C6 60 PUSH1 0x00 06C8 80 DUP1 06C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C9 revert(memory[0x00:0x00]); } // Block terminates label_06CA: // Incoming jump from 0x06C5, if !msg.value // Inputs[1] { @06D3 msg.data.length } 06CA 5B JUMPDEST 06CB 50 POP 06CC 62 PUSH3 0x0001f6 06D0 60 PUSH1 0x04 06D2 80 DUP1 06D3 36 CALLDATASIZE 06D4 03 SUB 06D5 60 PUSH1 0x40 06D7 81 DUP2 06D8 10 LT 06D9 15 ISZERO 06DA 62 PUSH3 0x0006e3 06DE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @06CC stack[-1] = 0x0001f6 // @06D0 stack[0] = 0x04 // @06D4 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0006e3, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) label_06DF: // Incoming jump from 0x06DE, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06E2 memory[0x00:0x00] } 06DF 60 PUSH1 0x00 06E1 80 DUP1 06E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E2 revert(memory[0x00:0x00]); } // Block terminates label_06E3: // Incoming call from 0x06DE, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @06FA stack[-2] // @06FB msg.data[stack[-2]:stack[-2] + 0x20] // @0701 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 06E3 5B JUMPDEST 06E4 50 POP 06E5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06FA 81 DUP2 06FB 35 CALLDATALOAD 06FC 16 AND 06FD 90 SWAP1 06FE 60 PUSH1 0x20 0700 01 ADD 0701 35 CALLDATALOAD 0702 62 PUSH3 0x002765 0706 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06FD stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @0701 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x002765 label_0707: // Incoming jump from 0x00DF, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0708 msg.value } 0707 5B JUMPDEST 0708 34 CALLVALUE 0709 80 DUP1 070A 15 ISZERO 070B 62 PUSH3 0x000714 070F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0708 stack[0] = msg.value } // Block ends with conditional jump to 0x000714, if !msg.value label_0710: // Incoming jump from 0x070F, if not !msg.value // Inputs[1] { @0713 memory[0x00:0x00] } 0710 60 PUSH1 0x00 0712 80 DUP1 0713 FD *REVERT // Stack delta = +0 // Outputs[1] { @0713 revert(memory[0x00:0x00]); } // Block terminates label_0714: // Incoming jump from 0x070F, if !msg.value 0714 5B JUMPDEST 0715 50 POP 0716 62 PUSH3 0x00031b 071A 62 PUSH3 0x0028ba 071E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0716 stack[-1] = 0x00031b } // Block ends with call to 0x0028ba, returns to 0x031B label_071F: // Incoming jump from 0x0079, if 0x98061191 == stack[-1] // Inputs[1] { @0720 msg.value } 071F 5B JUMPDEST 0720 34 CALLVALUE 0721 80 DUP1 0722 15 ISZERO 0723 62 PUSH3 0x00072c 0727 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0720 stack[0] = msg.value } // Block ends with conditional jump to 0x00072c, if !msg.value label_0728: // Incoming jump from 0x0727, if not !msg.value // Inputs[1] { @072B memory[0x00:0x00] } 0728 60 PUSH1 0x00 072A 80 DUP1 072B FD *REVERT // Stack delta = +0 // Outputs[1] { @072B revert(memory[0x00:0x00]); } // Block terminates label_072C: // Incoming jump from 0x0727, if !msg.value // Inputs[1] { @0735 msg.data.length } 072C 5B JUMPDEST 072D 50 POP 072E 62 PUSH3 0x0001f6 0732 60 PUSH1 0x04 0734 80 DUP1 0735 36 CALLDATASIZE 0736 03 SUB 0737 60 PUSH1 0x60 0739 81 DUP2 073A 10 LT 073B 15 ISZERO 073C 62 PUSH3 0x000745 0740 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @072E stack[-1] = 0x0001f6 // @0732 stack[0] = 0x04 // @0736 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000745, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x60) label_0741: // Incoming jump from 0x0740, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0744 memory[0x00:0x00] } 0741 60 PUSH1 0x00 0743 80 DUP1 0744 FD *REVERT // Stack delta = +0 // Outputs[1] { @0744 revert(memory[0x00:0x00]); } // Block terminates label_0745: // Incoming call from 0x0740, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x60) // Inputs[3] // { // @0746 stack[-2] // @0747 stack[-1] // @074E msg.data[stack[-2]:stack[-2] + 0x20] // } 0745 5B JUMPDEST 0746 81 DUP2 0747 01 ADD 0748 90 SWAP1 0749 60 PUSH1 0x20 074B 81 DUP2 074C 01 ADD 074D 81 DUP2 074E 35 CALLDATALOAD 074F 64 PUSH5 0x0100000000 0755 81 DUP2 0756 11 GT 0757 15 ISZERO 0758 62 PUSH3 0x000761 075C 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0748 stack[-1] = stack[-2] // @0748 stack[-2] = stack[-2] + stack[-1] // @074C stack[0] = stack[-2] + 0x20 // @074E stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x000761, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_075D: // Incoming jump from 0x075C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0760 memory[0x00:0x00] } 075D 60 PUSH1 0x00 075F 80 DUP1 0760 FD *REVERT // Stack delta = +0 // Outputs[1] { @0760 revert(memory[0x00:0x00]); } // Block terminates label_0761: // Incoming jump from 0x075C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0762 stack[-3] // @0763 stack[-1] // @0764 stack[-4] // } 0761 5B JUMPDEST 0762 82 DUP3 0763 01 ADD 0764 83 DUP4 0765 60 PUSH1 0x20 0767 82 DUP3 0768 01 ADD 0769 11 GT 076A 15 ISZERO 076B 62 PUSH3 0x000774 076F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0763 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x000774, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0770: // Incoming jump from 0x076F, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0773 memory[0x00:0x00] } 0770 60 PUSH1 0x00 0772 80 DUP1 0773 FD *REVERT // Stack delta = +0 // Outputs[1] { @0773 revert(memory[0x00:0x00]); } // Block terminates label_0774: // Incoming jump from 0x076F, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0775 stack[-1] // @0776 msg.data[stack[-1]:stack[-1] + 0x20] // @077B stack[-2] // @077C stack[-4] // } 0774 5B JUMPDEST 0775 80 DUP1 0776 35 CALLDATALOAD 0777 90 SWAP1 0778 60 PUSH1 0x20 077A 01 ADD 077B 91 SWAP2 077C 84 DUP5 077D 60 PUSH1 0x20 077F 83 DUP4 0780 02 MUL 0781 84 DUP5 0782 01 ADD 0783 11 GT 0784 64 PUSH5 0x0100000000 078A 83 DUP4 078B 11 GT 078C 17 OR 078D 15 ISZERO 078E 62 PUSH3 0x000797 0792 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0777 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @077B stack[0] = stack[-2] // @077B stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x000797, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0793: // Incoming jump from 0x0792, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0796 memory[0x00:0x00] } 0793 60 PUSH1 0x00 0795 80 DUP1 0796 FD *REVERT // Stack delta = +0 // Outputs[1] { @0796 revert(memory[0x00:0x00]); } // Block terminates label_0797: // Incoming jump from 0x0792, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @0798 stack[-1] // @0798 stack[-3] // @0799 stack[-5] // @079A stack[-2] // @079B stack[-4] // @07A3 msg.data[stack[-1]:stack[-1] + 0x20] // } 0797 5B JUMPDEST 0798 91 SWAP2 0799 93 SWAP4 079A 90 SWAP1 079B 92 SWAP3 079C 90 SWAP1 079D 91 SWAP2 079E 60 PUSH1 0x20 07A0 81 DUP2 07A1 01 ADD 07A2 90 SWAP1 07A3 35 CALLDATALOAD 07A4 64 PUSH5 0x0100000000 07AA 81 DUP2 07AB 11 GT 07AC 15 ISZERO 07AD 62 PUSH3 0x0007b6 07B1 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0799 stack[-5] = stack[-3] // @079B stack[-4] = stack[-2] // @079C stack[-2] = stack[-4] // @079D stack[-3] = stack[-5] // @07A2 stack[-1] = stack[-1] + 0x20 // @07A3 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0007b6, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_07B2: // Incoming jump from 0x07B1, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @07B5 memory[0x00:0x00] } 07B2 60 PUSH1 0x00 07B4 80 DUP1 07B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B5 revert(memory[0x00:0x00]); } // Block terminates label_07B6: // Incoming jump from 0x07B1, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @07B7 stack[-3] // @07B8 stack[-1] // @07B9 stack[-4] // } 07B6 5B JUMPDEST 07B7 82 DUP3 07B8 01 ADD 07B9 83 DUP4 07BA 60 PUSH1 0x20 07BC 82 DUP3 07BD 01 ADD 07BE 11 GT 07BF 15 ISZERO 07C0 62 PUSH3 0x0007c9 07C4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07B8 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0007c9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_07C5: // Incoming jump from 0x07C4, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @07C8 memory[0x00:0x00] } 07C5 60 PUSH1 0x00 07C7 80 DUP1 07C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C8 revert(memory[0x00:0x00]); } // Block terminates label_07C9: // Incoming jump from 0x07C4, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @07CA stack[-1] // @07CB msg.data[stack[-1]:stack[-1] + 0x20] // @07D0 stack[-2] // @07D1 stack[-4] // } 07C9 5B JUMPDEST 07CA 80 DUP1 07CB 35 CALLDATALOAD 07CC 90 SWAP1 07CD 60 PUSH1 0x20 07CF 01 ADD 07D0 91 SWAP2 07D1 84 DUP5 07D2 60 PUSH1 0x20 07D4 83 DUP4 07D5 02 MUL 07D6 84 DUP5 07D7 01 ADD 07D8 11 GT 07D9 64 PUSH5 0x0100000000 07DF 83 DUP4 07E0 11 GT 07E1 17 OR 07E2 15 ISZERO 07E3 62 PUSH3 0x0007ec 07E7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07CC stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @07D0 stack[0] = stack[-2] // @07D0 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0007ec, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_07E8: // Incoming jump from 0x07E7, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @07EB memory[0x00:0x00] } 07E8 60 PUSH1 0x00 07EA 80 DUP1 07EB FD *REVERT // Stack delta = +0 // Outputs[1] { @07EB revert(memory[0x00:0x00]); } // Block terminates label_07EC: // Incoming jump from 0x07E7, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @07ED stack[-3] // @07ED stack[-1] // @07EE stack[-5] // @07F0 stack[-2] // @07F0 stack[-4] // @07F2 msg.data[stack[-1]:stack[-1] + 0x20] // } 07EC 5B JUMPDEST 07ED 91 SWAP2 07EE 93 SWAP4 07EF 50 POP 07F0 91 SWAP2 07F1 50 POP 07F2 35 CALLDATALOAD 07F3 62 PUSH3 0x0028d6 07F7 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @07EE stack[-5] = stack[-3] // @07F0 stack[-4] = stack[-2] // @07F2 stack[-3] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0028d6 label_07F8: // Incoming jump from 0x0085, if 0x9af73484 == stack[-1] // Inputs[1] { @07F9 msg.value } 07F8 5B JUMPDEST 07F9 34 CALLVALUE 07FA 80 DUP1 07FB 15 ISZERO 07FC 62 PUSH3 0x000805 0800 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07F9 stack[0] = msg.value } // Block ends with conditional jump to 0x000805, if !msg.value label_0801: // Incoming jump from 0x0800, if not !msg.value // Inputs[1] { @0804 memory[0x00:0x00] } 0801 60 PUSH1 0x00 0803 80 DUP1 0804 FD *REVERT // Stack delta = +0 // Outputs[1] { @0804 revert(memory[0x00:0x00]); } // Block terminates label_0805: // Incoming jump from 0x0800, if !msg.value // Inputs[1] { @080E msg.data.length } 0805 5B JUMPDEST 0806 50 POP 0807 62 PUSH3 0x0001f6 080B 60 PUSH1 0x04 080D 80 DUP1 080E 36 CALLDATASIZE 080F 03 SUB 0810 60 PUSH1 0x20 0812 81 DUP2 0813 10 LT 0814 15 ISZERO 0815 62 PUSH3 0x00081e 0819 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0807 stack[-1] = 0x0001f6 // @080B stack[0] = 0x04 // @080F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00081e, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_081A: // Incoming jump from 0x0819, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @081D memory[0x00:0x00] } 081A 60 PUSH1 0x00 081C 80 DUP1 081D FD *REVERT // Stack delta = +0 // Outputs[1] { @081D revert(memory[0x00:0x00]); } // Block terminates label_081E: // Incoming call from 0x0819, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0820 stack[-2] // @0820 msg.data[stack[-2]:stack[-2] + 0x20] // } 081E 5B JUMPDEST 081F 50 POP 0820 35 CALLDATALOAD 0821 62 PUSH3 0x002a6c 0825 56 *JUMP // Stack delta = -1 // Outputs[1] { @0820 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x002a6c label_0826: // Incoming jump from 0x0091, if 0xc4d66de8 == stack[-1] // Inputs[1] { @0827 msg.value } 0826 5B JUMPDEST 0827 34 CALLVALUE 0828 80 DUP1 0829 15 ISZERO 082A 62 PUSH3 0x000833 082E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0827 stack[0] = msg.value } // Block ends with conditional jump to 0x000833, if !msg.value label_082F: // Incoming jump from 0x082E, if not !msg.value // Inputs[1] { @0832 memory[0x00:0x00] } 082F 60 PUSH1 0x00 0831 80 DUP1 0832 FD *REVERT // Stack delta = +0 // Outputs[1] { @0832 revert(memory[0x00:0x00]); } // Block terminates label_0833: // Incoming jump from 0x082E, if !msg.value // Inputs[1] { @083C msg.data.length } 0833 5B JUMPDEST 0834 50 POP 0835 62 PUSH3 0x0001f6 0839 60 PUSH1 0x04 083B 80 DUP1 083C 36 CALLDATASIZE 083D 03 SUB 083E 60 PUSH1 0x20 0840 81 DUP2 0841 10 LT 0842 15 ISZERO 0843 62 PUSH3 0x00084c 0847 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0835 stack[-1] = 0x0001f6 // @0839 stack[0] = 0x04 // @083D stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00084c, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_0848: // Incoming jump from 0x0847, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @084B memory[0x00:0x00] } 0848 60 PUSH1 0x00 084A 80 DUP1 084B FD *REVERT // Stack delta = +0 // Outputs[1] { @084B revert(memory[0x00:0x00]); } // Block terminates label_084C: // Incoming call from 0x0847, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @084E msg.data[stack[-2]:stack[-2] + 0x20] // @084E stack[-2] // } 084C 5B JUMPDEST 084D 50 POP 084E 35 CALLDATALOAD 084F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0864 16 AND 0865 62 PUSH3 0x002b83 0869 56 *JUMP // Stack delta = -1 // Outputs[1] { @0864 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x002b83 label_086A: // Incoming jump from 0x009D, if 0xccc39909 == stack[-1] // Inputs[1] { @086B msg.value } 086A 5B JUMPDEST 086B 34 CALLVALUE 086C 80 DUP1 086D 15 ISZERO 086E 62 PUSH3 0x000877 0872 57 *JUMPI // Stack delta = +1 // Outputs[1] { @086B stack[0] = msg.value } // Block ends with conditional jump to 0x000877, if !msg.value label_0873: // Incoming jump from 0x0872, if not !msg.value // Inputs[1] { @0876 memory[0x00:0x00] } 0873 60 PUSH1 0x00 0875 80 DUP1 0876 FD *REVERT // Stack delta = +0 // Outputs[1] { @0876 revert(memory[0x00:0x00]); } // Block terminates label_0877: // Incoming jump from 0x0872, if !msg.value // Inputs[1] { @0880 msg.data.length } 0877 5B JUMPDEST 0878 50 POP 0879 62 PUSH3 0x0001f6 087D 60 PUSH1 0x04 087F 80 DUP1 0880 36 CALLDATASIZE 0881 03 SUB 0882 60 PUSH1 0x20 0884 81 DUP2 0885 10 LT 0886 15 ISZERO 0887 62 PUSH3 0x000890 088B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0879 stack[-1] = 0x0001f6 // @087D stack[0] = 0x04 // @0881 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000890, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_088C: // Incoming jump from 0x088B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @088F memory[0x00:0x00] } 088C 60 PUSH1 0x00 088E 80 DUP1 088F FD *REVERT // Stack delta = +0 // Outputs[1] { @088F revert(memory[0x00:0x00]); } // Block terminates label_0890: // Incoming call from 0x088B, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0892 stack[-2] // @0892 msg.data[stack[-2]:stack[-2] + 0x20] // } 0890 5B JUMPDEST 0891 50 POP 0892 35 CALLDATALOAD 0893 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08A8 16 AND 08A9 62 PUSH3 0x002c71 08AD 56 *JUMP // Stack delta = -1 // Outputs[1] { @08A8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x002c71 label_08AE: // Incoming jump from 0x0043, if 0xccf12304 == stack[-1] // Inputs[1] { @08AF msg.value } 08AE 5B JUMPDEST 08AF 34 CALLVALUE 08B0 80 DUP1 08B1 15 ISZERO 08B2 62 PUSH3 0x0008bb 08B6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08AF stack[0] = msg.value } // Block ends with conditional jump to 0x0008bb, if !msg.value label_08B7: // Incoming jump from 0x08B6, if not !msg.value // Inputs[1] { @08BA memory[0x00:0x00] } 08B7 60 PUSH1 0x00 08B9 80 DUP1 08BA FD *REVERT // Stack delta = +0 // Outputs[1] { @08BA revert(memory[0x00:0x00]); } // Block terminates label_08BB: // Incoming jump from 0x08B6, if !msg.value // Inputs[1] { @08C4 msg.data.length } 08BB 5B JUMPDEST 08BC 50 POP 08BD 62 PUSH3 0x0001f6 08C1 60 PUSH1 0x04 08C3 80 DUP1 08C4 36 CALLDATASIZE 08C5 03 SUB 08C6 60 PUSH1 0x20 08C8 81 DUP2 08C9 10 LT 08CA 15 ISZERO 08CB 62 PUSH3 0x0008d4 08CF 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @08BD stack[-1] = 0x0001f6 // @08C1 stack[0] = 0x04 // @08C5 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0008d4, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_08D0: // Incoming jump from 0x08CF, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08D3 memory[0x00:0x00] } 08D0 60 PUSH1 0x00 08D2 80 DUP1 08D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @08D3 revert(memory[0x00:0x00]); } // Block terminates label_08D4: // Incoming call from 0x08CF, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @08D6 msg.data[stack[-2]:stack[-2] + 0x20] // @08D6 stack[-2] // } 08D4 5B JUMPDEST 08D5 50 POP 08D6 35 CALLDATALOAD 08D7 62 PUSH3 0x002cfe 08DB 56 *JUMP // Stack delta = -1 // Outputs[1] { @08D6 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x002cfe label_08DC: // Incoming jump from 0x004F, if 0xd6c1a7fd == stack[-1] // Inputs[1] { @08DD msg.value } 08DC 5B JUMPDEST 08DD 34 CALLVALUE 08DE 80 DUP1 08DF 15 ISZERO 08E0 62 PUSH3 0x0008e9 08E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08DD stack[0] = msg.value } // Block ends with conditional jump to 0x0008e9, if !msg.value label_08E5: // Incoming jump from 0x08E4, if not !msg.value // Inputs[1] { @08E8 memory[0x00:0x00] } 08E5 60 PUSH1 0x00 08E7 80 DUP1 08E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @08E8 revert(memory[0x00:0x00]); } // Block terminates label_08E9: // Incoming jump from 0x08E4, if !msg.value // Inputs[1] { @08F2 msg.data.length } 08E9 5B JUMPDEST 08EA 50 POP 08EB 62 PUSH3 0x0001f6 08EF 60 PUSH1 0x04 08F1 80 DUP1 08F2 36 CALLDATASIZE 08F3 03 SUB 08F4 60 PUSH1 0x20 08F6 81 DUP2 08F7 10 LT 08F8 15 ISZERO 08F9 62 PUSH3 0x000902 08FD 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @08EB stack[-1] = 0x0001f6 // @08EF stack[0] = 0x04 // @08F3 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000902, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) label_08FE: // Incoming jump from 0x08FD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0901 memory[0x00:0x00] } 08FE 60 PUSH1 0x00 0900 80 DUP1 0901 FD *REVERT // Stack delta = +0 // Outputs[1] { @0901 revert(memory[0x00:0x00]); } // Block terminates label_0902: // Incoming call from 0x08FD, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0904 msg.data[stack[-2]:stack[-2] + 0x20] // @0904 stack[-2] // } 0902 5B JUMPDEST 0903 50 POP 0904 35 CALLDATALOAD 0905 62 PUSH3 0x002d28 0909 56 *JUMP // Stack delta = -1 // Outputs[1] { @0904 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x002d28 label_090A: // Incoming jump from 0x005B, if 0xfa7cd1d3 == stack[-1] // Inputs[1] { @090B msg.value } 090A 5B JUMPDEST 090B 34 CALLVALUE 090C 80 DUP1 090D 15 ISZERO 090E 62 PUSH3 0x000917 0912 57 *JUMPI // Stack delta = +1 // Outputs[1] { @090B stack[0] = msg.value } // Block ends with conditional jump to 0x000917, if !msg.value label_0913: // Incoming jump from 0x0912, if not !msg.value // Inputs[1] { @0916 memory[0x00:0x00] } 0913 60 PUSH1 0x00 0915 80 DUP1 0916 FD *REVERT // Stack delta = +0 // Outputs[1] { @0916 revert(memory[0x00:0x00]); } // Block terminates label_0917: // Incoming jump from 0x0912, if !msg.value 0917 5B JUMPDEST 0918 50 POP 0919 62 PUSH3 0x0001f6 091D 62 PUSH3 0x002ed2 0921 56 *JUMP // Stack delta = +0 // Outputs[1] { @0919 stack[-1] = 0x0001f6 } // Block ends with unconditional jump to 0x002ed2 label_0922: // Incoming jump from 0x0067, if 0xff1cdcbf == stack[-1] // Inputs[1] { @0923 msg.value } 0922 5B JUMPDEST 0923 34 CALLVALUE 0924 80 DUP1 0925 15 ISZERO 0926 62 PUSH3 0x00092f 092A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0923 stack[0] = msg.value } // Block ends with conditional jump to 0x00092f, if !msg.value label_092B: // Incoming jump from 0x092A, if not !msg.value // Inputs[1] { @092E memory[0x00:0x00] } 092B 60 PUSH1 0x00 092D 80 DUP1 092E FD *REVERT // Stack delta = +0 // Outputs[1] { @092E revert(memory[0x00:0x00]); } // Block terminates label_092F: // Incoming jump from 0x092A, if !msg.value // Inputs[1] { @0938 msg.data.length } 092F 5B JUMPDEST 0930 50 POP 0931 62 PUSH3 0x0001f6 0935 60 PUSH1 0x04 0937 80 DUP1 0938 36 CALLDATASIZE 0939 03 SUB 093A 60 PUSH1 0x40 093C 81 DUP2 093D 10 LT 093E 15 ISZERO 093F 62 PUSH3 0x000948 0943 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0931 stack[-1] = 0x0001f6 // @0935 stack[0] = 0x04 // @0939 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x000948, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) label_0944: // Incoming jump from 0x0943, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0947 memory[0x00:0x00] } 0944 60 PUSH1 0x00 0946 80 DUP1 0947 FD *REVERT // Stack delta = +0 // Outputs[1] { @0947 revert(memory[0x00:0x00]); } // Block terminates label_0948: // Incoming call from 0x0943, returns to 0x01F6, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0949 stack[-2] // @094A stack[-1] // @0951 msg.data[stack[-2]:stack[-2] + 0x20] // } 0948 5B JUMPDEST 0949 81 DUP2 094A 01 ADD 094B 90 SWAP1 094C 60 PUSH1 0x20 094E 81 DUP2 094F 01 ADD 0950 81 DUP2 0951 35 CALLDATALOAD 0952 64 PUSH5 0x0100000000 0958 81 DUP2 0959 11 GT 095A 15 ISZERO 095B 62 PUSH3 0x000964 095F 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @094B stack[-1] = stack[-2] // @094B stack[-2] = stack[-2] + stack[-1] // @094F stack[0] = stack[-2] + 0x20 // @0951 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x000964, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0960: // Incoming jump from 0x095F, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0963 memory[0x00:0x00] } 0960 60 PUSH1 0x00 0962 80 DUP1 0963 FD *REVERT // Stack delta = +0 // Outputs[1] { @0963 revert(memory[0x00:0x00]); } // Block terminates label_0964: // Incoming jump from 0x095F, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0965 stack[-3] // @0966 stack[-1] // @0967 stack[-4] // } 0964 5B JUMPDEST 0965 82 DUP3 0966 01 ADD 0967 83 DUP4 0968 60 PUSH1 0x20 096A 82 DUP3 096B 01 ADD 096C 11 GT 096D 15 ISZERO 096E 62 PUSH3 0x000977 0972 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0966 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x000977, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0973: // Incoming jump from 0x0972, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0976 memory[0x00:0x00] } 0973 60 PUSH1 0x00 0975 80 DUP1 0976 FD *REVERT // Stack delta = +0 // Outputs[1] { @0976 revert(memory[0x00:0x00]); } // Block terminates label_0977: // Incoming jump from 0x0972, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0978 stack[-1] // @0979 msg.data[stack[-1]:stack[-1] + 0x20] // @097E stack[-2] // @097F stack[-4] // } 0977 5B JUMPDEST 0978 80 DUP1 0979 35 CALLDATALOAD 097A 90 SWAP1 097B 60 PUSH1 0x20 097D 01 ADD 097E 91 SWAP2 097F 84 DUP5 0980 60 PUSH1 0x20 0982 83 DUP4 0983 02 MUL 0984 84 DUP5 0985 01 ADD 0986 11 GT 0987 64 PUSH5 0x0100000000 098D 83 DUP4 098E 11 GT 098F 17 OR 0990 15 ISZERO 0991 62 PUSH3 0x00099a 0995 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @097A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @097E stack[0] = stack[-2] // @097E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x00099a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0996: // Incoming jump from 0x0995, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0999 memory[0x00:0x00] } 0996 60 PUSH1 0x00 0998 80 DUP1 0999 FD *REVERT // Stack delta = +0 // Outputs[1] { @0999 revert(memory[0x00:0x00]); } // Block terminates label_099A: // Incoming jump from 0x0995, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[6] // { // @099B stack[-1] // @099B stack[-3] // @099C stack[-5] // @099D stack[-2] // @099E stack[-4] // @09A6 msg.data[stack[-1]:stack[-1] + 0x20] // } 099A 5B JUMPDEST 099B 91 SWAP2 099C 93 SWAP4 099D 90 SWAP1 099E 92 SWAP3 099F 90 SWAP1 09A0 91 SWAP2 09A1 60 PUSH1 0x20 09A3 81 DUP2 09A4 01 ADD 09A5 90 SWAP1 09A6 35 CALLDATALOAD 09A7 64 PUSH5 0x0100000000 09AD 81 DUP2 09AE 11 GT 09AF 15 ISZERO 09B0 62 PUSH3 0x0009b9 09B4 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @099C stack[-5] = stack[-3] // @099E stack[-4] = stack[-2] // @099F stack[-2] = stack[-4] // @09A0 stack[-3] = stack[-5] // @09A5 stack[-1] = stack[-1] + 0x20 // @09A6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0009b9, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_09B5: // Incoming jump from 0x09B4, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @09B8 memory[0x00:0x00] } 09B5 60 PUSH1 0x00 09B7 80 DUP1 09B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @09B8 revert(memory[0x00:0x00]); } // Block terminates label_09B9: // Incoming jump from 0x09B4, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @09BA stack[-3] // @09BB stack[-1] // @09BC stack[-4] // } 09B9 5B JUMPDEST 09BA 82 DUP3 09BB 01 ADD 09BC 83 DUP4 09BD 60 PUSH1 0x20 09BF 82 DUP3 09C0 01 ADD 09C1 11 GT 09C2 15 ISZERO 09C3 62 PUSH3 0x0009cc 09C7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @09BB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0009cc, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_09C8: // Incoming jump from 0x09C7, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @09CB memory[0x00:0x00] } 09C8 60 PUSH1 0x00 09CA 80 DUP1 09CB FD *REVERT // Stack delta = +0 // Outputs[1] { @09CB revert(memory[0x00:0x00]); } // Block terminates label_09CC: // Incoming jump from 0x09C7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @09CD stack[-1] // @09CE msg.data[stack[-1]:stack[-1] + 0x20] // @09D3 stack[-2] // @09D4 stack[-4] // } 09CC 5B JUMPDEST 09CD 80 DUP1 09CE 35 CALLDATALOAD 09CF 90 SWAP1 09D0 60 PUSH1 0x20 09D2 01 ADD 09D3 91 SWAP2 09D4 84 DUP5 09D5 60 PUSH1 0x20 09D7 83 DUP4 09D8 02 MUL 09D9 84 DUP5 09DA 01 ADD 09DB 11 GT 09DC 64 PUSH5 0x0100000000 09E2 83 DUP4 09E3 11 GT 09E4 17 OR 09E5 15 ISZERO 09E6 62 PUSH3 0x0009ef 09EA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @09CF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @09D3 stack[0] = stack[-2] // @09D3 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0009ef, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_09EB: // Incoming jump from 0x09EA, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @09EE memory[0x00:0x00] } 09EB 60 PUSH1 0x00 09ED 80 DUP1 09EE FD *REVERT // Stack delta = +0 // Outputs[1] { @09EE revert(memory[0x00:0x00]); } // Block terminates label_09EF: // Incoming jump from 0x09EA, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @09F1 stack[-2] // @09F1 stack[-3] // @09F2 stack[-5] // @09F4 stack[-4] // } 09EF 5B JUMPDEST 09F0 50 POP 09F1 90 SWAP1 09F2 92 SWAP3 09F3 50 POP 09F4 90 SWAP1 09F5 50 POP 09F6 62 PUSH3 0x00303a 09FA 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @09F2 stack[-5] = stack[-3] // @09F4 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x00303a label_09FB: // Incoming jump from 0x0225 // Inputs[1] { @09FC msg.sender } 09FB 5B JUMPDEST 09FC 33 CALLER 09FD 73 PUSH20 0xdd07249e403979bd79848c27aa5454c7e66bdee7 0A12 14 EQ 0A13 80 DUP1 0A14 62 PUSH3 0x000a31 0A18 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A12 stack[0] = 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender } // Block ends with conditional jump to 0x000a31, if 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender label_0A19: // Incoming jump from 0x0A18, if not 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender // Inputs[1] { @0A1A msg.sender } 0A19 50 POP 0A1A 33 CALLER 0A1B 73 PUSH20 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 0A30 14 EQ 0A31 5B JUMPDEST 0A32 80 DUP1 0A33 62 PUSH3 0x000a50 0A37 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A30 stack[-1] = 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender } // Block ends with conditional jump to 0x000a50, if 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender label_0A38: // Incoming jump from 0x0A37, if not 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender // Incoming jump from 0x0A37, if not stack[-1] // Inputs[1] { @0A39 msg.sender } 0A38 50 POP 0A39 33 CALLER 0A3A 73 PUSH20 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 0A4F 14 EQ 0A50 5B JUMPDEST 0A51 80 DUP1 0A52 62 PUSH3 0x000a6b 0A56 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A4F stack[-1] = 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender } // Block ends with conditional jump to 0x000a6b, if 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender label_0A57: // Incoming jump from 0x0A56, if not 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender // Incoming jump from 0x0A56, if not stack[-1] // Inputs[3] // { // @0A58 msg.sender // @0A66 memory[0x00:0x40] // @0A67 storage[keccak256(memory[0x00:0x40])] // } 0A57 50 POP 0A58 33 CALLER 0A59 60 PUSH1 0x00 0A5B 90 SWAP1 0A5C 81 DUP2 0A5D 52 MSTORE 0A5E 60 PUSH1 0x02 0A60 60 PUSH1 0x20 0A62 52 MSTORE 0A63 60 PUSH1 0x40 0A65 90 SWAP1 0A66 20 SHA3 0A67 54 SLOAD 0A68 60 PUSH1 0xff 0A6A 16 AND 0A6B 5B JUMPDEST 0A6C 62 PUSH3 0x000a75 0A70 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0A5D memory[0x00:0x20] = msg.sender // @0A62 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x000a75, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0A71: // Incoming jump from 0x0A70, if not stack[-1] // Incoming jump from 0x0A70, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0A74 memory[0x00:0x00] } 0A71 60 PUSH1 0x00 0A73 80 DUP1 0A74 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A74 revert(memory[0x00:0x00]); } // Block terminates label_0A75: // Incoming jump from 0x0A70, if stack[-1] // Incoming jump from 0x0A70, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0A7A stack[-1] } 0A75 5B JUMPDEST 0A76 62 PUSH3 0x000a80 0A7A 81 DUP2 0A7B 62 PUSH3 0x003135 0A7F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A76 stack[0] = 0x000a80 // @0A7A stack[1] = stack[-1] // } // Block ends with call to 0x003135, returns to 0x0A80 label_0A80: // Incoming jump from 0x2ECD, if !(stack[-2] > storage[0x03]) // Incoming jump from 0x32CB // Incoming return from call to 0x3135 at 0x0A7F // Incoming return from call to 0x3135 at 0x0A7F // Incoming jump from 0x1207 // Inputs[1] { @0A82 stack[-2] } 0A80 5B JUMPDEST 0A81 50 POP 0A82 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A83: // Incoming jump from 0x0253 // Inputs[1] { @0A84 msg.sender } 0A83 5B JUMPDEST 0A84 33 CALLER 0A85 73 PUSH20 0x58d46ae3114fc82d80f57c9a2a322845a19418fb 0A9A 14 EQ 0A9B 62 PUSH3 0x000aa4 0A9F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x000aa4, if 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender label_0AA0: // Incoming jump from 0x0A9F, if not 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender // Inputs[1] { @0AA3 memory[0x00:0x00] } 0AA0 60 PUSH1 0x00 0AA2 80 DUP1 0AA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AA3 revert(memory[0x00:0x00]); } // Block terminates label_0AA4: // Incoming jump from 0x0A9F, if 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender // Inputs[1] { @0AC6 stack[-1] } 0AA4 5B JUMPDEST 0AA5 7F PUSH32 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 0AC6 81 DUP2 0AC7 18 XOR 0AC8 60 PUSH1 0x48 0ACA 81 DUP2 0ACB 90 SWAP1 0ACC 1C SHR 0ACD 60 PUSH1 0x00 0ACF 62 PUSH3 0x000ade 0AD3 82 DUP3 0AD4 60 PUSH1 0x38 0AD6 85 DUP6 0AD7 90 SWAP1 0AD8 1C SHR 0AD9 62 PUSH3 0x003377 0ADD 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0AC7 stack[0] = stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 // @0ACC stack[1] = (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x48 // @0ACD stack[2] = 0x00 // @0ACF stack[3] = 0x000ade // @0AD3 stack[4] = (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x48 // @0AD8 stack[5] = (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x38 // } // Block ends with call to 0x003377, returns to 0x0ADE label_0ADE: // Incoming return from call to 0x3377 at 0x0ADD // Inputs[6] // { // @0AE2 memory[0x40:0x60] // @0B21 memory[0x40:0x60] // @0B22 stack[-1] // @0B23 stack[-2] // @0B3D stack[-3] // @0B58 address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 0ADE 5B JUMPDEST 0ADF 60 PUSH1 0x40 0AE1 80 DUP1 0AE2 51 MLOAD 0AE3 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 0B04 81 DUP2 0B05 52 MSTORE 0B06 73 PUSH20 0x45544abf5936deb78490d38ec42b80757d16c014 0B1B 60 PUSH1 0x04 0B1D 82 DUP3 0B1E 01 ADD 0B1F 52 MSTORE 0B20 90 SWAP1 0B21 51 MLOAD 0B22 91 SWAP2 0B23 92 SWAP3 0B24 50 POP 0B25 60 PUSH1 0x00 0B27 91 SWAP2 0B28 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B3D 85 DUP6 0B3E 16 AND 0B3F 91 SWAP2 0B40 63 PUSH4 0x70a08231 0B45 91 SWAP2 0B46 60 PUSH1 0x24 0B48 80 DUP1 0B49 83 DUP4 0B4A 01 ADD 0B4B 92 SWAP3 0B4C 60 PUSH1 0x20 0B4E 92 SWAP3 0B4F 91 SWAP2 0B50 90 SWAP1 0B51 82 DUP3 0B52 90 SWAP1 0B53 03 SUB 0B54 01 ADD 0B55 81 DUP2 0B56 86 DUP7 0B57 80 DUP1 0B58 3B EXTCODESIZE 0B59 15 ISZERO 0B5A 80 DUP1 0B5B 15 ISZERO 0B5C 62 PUSH3 0x000b65 0B60 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @0B05 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @0B1F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x45544abf5936deb78490d38ec42b80757d16c014 // @0B23 stack[-2] = stack[-1] // @0B27 stack[-1] = 0x00 // @0B3F stack[0] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0B45 stack[1] = 0x70a08231 // @0B4B stack[2] = memory[0x40:0x60] + 0x24 // @0B4E stack[3] = 0x20 // @0B4F stack[4] = memory[0x40:0x60] // @0B54 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0B55 stack[6] = memory[0x40:0x60] // @0B56 stack[7] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0B59 stack[8] = !address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x000b65, if !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0B61: // Incoming jump from 0x0B60, if not !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @0B64 memory[0x00:0x00] } 0B61 60 PUSH1 0x00 0B63 80 DUP1 0B64 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B64 revert(memory[0x00:0x00]); } // Block terminates label_0B65: // Incoming jump from 0x0B60, if !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @0B67 msg.gas // @0B68 stack[-4] // @0B68 stack[-5] // @0B68 stack[-6] // @0B68 memory[stack[-3]:stack[-3] + stack[-4]] // @0B68 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0B68 stack[-2] // @0B68 stack[-3] // } 0B65 5B JUMPDEST 0B66 50 POP 0B67 5A GAS 0B68 FA STATICCALL 0B69 15 ISZERO 0B6A 80 DUP1 0B6B 15 ISZERO 0B6C 62 PUSH3 0x000b7a 0B70 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0B68 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0B69 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x000b7a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0B71: // Incoming jump from 0x0B70, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0B71 returndata.length // @0B75 returndata[0x00:0x00 + returndata.length] // @0B76 returndata.length // @0B79 memory[0x00:0x00 + returndata.length] // } 0B71 3D RETURNDATASIZE 0B72 60 PUSH1 0x00 0B74 80 DUP1 0B75 3E RETURNDATACOPY 0B76 3D RETURNDATASIZE 0B77 60 PUSH1 0x00 0B79 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B75 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0B79 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0B7A: // Incoming jump from 0x0B70, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0B81 memory[0x40:0x60] // @0B82 returndata.length // } 0B7A 5B JUMPDEST 0B7B 50 POP 0B7C 50 POP 0B7D 50 POP 0B7E 50 POP 0B7F 60 PUSH1 0x40 0B81 51 MLOAD 0B82 3D RETURNDATASIZE 0B83 60 PUSH1 0x20 0B85 81 DUP2 0B86 10 LT 0B87 15 ISZERO 0B88 62 PUSH3 0x000b91 0B8C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0B81 stack[-4] = memory[0x40:0x60] // @0B82 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x000b91, if !(returndata.length < 0x20) label_0B8D: // Incoming jump from 0x0B8C, if not !(returndata.length < 0x20) // Inputs[1] { @0B90 memory[0x00:0x00] } 0B8D 60 PUSH1 0x00 0B8F 80 DUP1 0B90 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B90 revert(memory[0x00:0x00]); } // Block terminates label_0B91: // Incoming jump from 0x0B8C, if !(returndata.length < 0x20) // Inputs[5] // { // @0B93 memory[stack[-2]:stack[-2] + 0x20] // @0B93 stack[-2] // @0B94 stack[-3] // @0BAD stack[-5] // @0BAE stack[-4] // } 0B91 5B JUMPDEST 0B92 50 POP 0B93 51 MLOAD 0B94 90 SWAP1 0B95 50 POP 0B96 73 PUSH20 0x45544abf5936deb78490d38ec42b80757d16c014 0BAB 60 PUSH1 0x02 0BAD 84 DUP5 0BAE 84 DUP5 0BAF 62 PUSH3 0x000bc1 0BB3 85 DUP6 0BB4 60 PUSH1 0x01 0BB6 63 PUSH4 0xffffffff 0BBB 62 PUSH3 0x0035f9 0BBF 16 AND 0BC0 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @0B94 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0B96 stack[-2] = 0x45544abf5936deb78490d38ec42b80757d16c014 // @0BAB stack[-1] = 0x02 // @0BAD stack[0] = stack[-5] // @0BAE stack[1] = stack[-4] // @0BAF stack[2] = 0x000bc1 // @0BB3 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0BB4 stack[4] = 0x01 // } // Block ends with call to 0x0035f9 & 0xffffffff, returns to 0x0BC1 label_0BC1: // Incoming return from call to 0x35F9 at 0x0BC0 // Inputs[8] // { // @0BC4 memory[0x40:0x60] // @0BC5 stack[-4] // @0BD5 stack[-3] // @0C07 stack[-2] // @0C39 stack[-1] // @0C48 memory[0x40:0x60] // @0C4F stack[-5] // @0C51 address(stack[-5]).code.length // } 0BC1 5B JUMPDEST 0BC2 60 PUSH1 0x40 0BC4 51 MLOAD 0BC5 84 DUP5 0BC6 63 PUSH4 0xffffffff 0BCB 16 AND 0BCC 60 PUSH1 0xe0 0BCE 1B SHL 0BCF 81 DUP2 0BD0 52 MSTORE 0BD1 60 PUSH1 0x04 0BD3 01 ADD 0BD4 80 DUP1 0BD5 84 DUP5 0BD6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BEB 16 AND 0BEC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C01 16 AND 0C02 81 DUP2 0C03 52 MSTORE 0C04 60 PUSH1 0x20 0C06 01 ADD 0C07 83 DUP4 0C08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C1D 16 AND 0C1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C33 16 AND 0C34 81 DUP2 0C35 52 MSTORE 0C36 60 PUSH1 0x20 0C38 01 ADD 0C39 82 DUP3 0C3A 81 DUP2 0C3B 52 MSTORE 0C3C 60 PUSH1 0x20 0C3E 01 ADD 0C3F 93 SWAP4 0C40 50 POP 0C41 50 POP 0C42 50 POP 0C43 50 POP 0C44 60 PUSH1 0x00 0C46 60 PUSH1 0x40 0C48 51 MLOAD 0C49 80 DUP1 0C4A 83 DUP4 0C4B 03 SUB 0C4C 81 DUP2 0C4D 60 PUSH1 0x00 0C4F 87 DUP8 0C50 80 DUP1 0C51 3B EXTCODESIZE 0C52 15 ISZERO 0C53 80 DUP1 0C54 15 ISZERO 0C55 62 PUSH3 0x000c5e 0C59 57 *JUMPI // Stack delta = +5 // Outputs[12] // { // @0BD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-4]) << 0xe0 // @0C03 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0C35 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0C3B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @0C3F stack[-3] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0C44 stack[-2] = 0x00 // @0C48 stack[-1] = memory[0x40:0x60] // @0C4B stack[0] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0C4C stack[1] = memory[0x40:0x60] // @0C4D stack[2] = 0x00 // @0C4F stack[3] = stack[-5] // @0C52 stack[4] = !address(stack[-5]).code.length // } // Block ends with conditional jump to 0x000c5e, if !!address(stack[-5]).code.length label_0C5A: // Incoming jump from 0x0C59, if not !!address(stack[-5]).code.length // Inputs[1] { @0C5D memory[0x00:0x00] } 0C5A 60 PUSH1 0x00 0C5C 80 DUP1 0C5D FD *REVERT // Stack delta = +0 // Outputs[1] { @0C5D revert(memory[0x00:0x00]); } // Block terminates label_0C5E: // Incoming jump from 0x0C59, if !!address(stack[-5]).code.length // Inputs[9] // { // @0C60 msg.gas // @0C61 stack[-4] // @0C61 stack[-5] // @0C61 stack[-7] // @0C61 stack[-6] // @0C61 memory[stack[-4]:stack[-4] + stack[-5]] // @0C61 stack[-3] // @0C61 stack[-2] // @0C61 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0C5E 5B JUMPDEST 0C5F 50 POP 0C60 5A GAS 0C61 F1 CALL 0C62 15 ISZERO 0C63 80 DUP1 0C64 15 ISZERO 0C65 62 PUSH3 0x000c73 0C69 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0C61 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C62 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x000c73, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0C6A: // Incoming jump from 0x0C69, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0C6A returndata.length // @0C6E returndata[0x00:0x00 + returndata.length] // @0C6F returndata.length // @0C72 memory[0x00:0x00 + returndata.length] // } 0C6A 3D RETURNDATASIZE 0C6B 60 PUSH1 0x00 0C6D 80 DUP1 0C6E 3E RETURNDATACOPY 0C6F 3D RETURNDATASIZE 0C70 60 PUSH1 0x00 0C72 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C6E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C72 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C73: // Incoming jump from 0x0C69, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0C7F stack[-6] // @0C80 stack[-7] // } 0C73 5B JUMPDEST 0C74 50 POP 0C75 50 POP 0C76 50 POP 0C77 50 POP 0C78 60 PUSH1 0x00 0C7A 80 DUP1 0C7B 62 PUSH3 0x000c86 0C7F 84 DUP5 0C80 86 DUP7 0C81 62 PUSH3 0x00360f 0C85 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C78 stack[-4] = 0x00 // @0C7A stack[-3] = 0x00 // @0C7B stack[-2] = 0x000c86 // @0C7F stack[-1] = stack[-6] // @0C80 stack[0] = stack[-7] // } // Block ends with call to 0x00360f, returns to 0x0C86 label_0C86: // Incoming return from call to 0x360F at 0x0C85 // Inputs[9] // { // @0C87 stack[-1] // @0C87 stack[-3] // @0C89 stack[-4] // @0C89 stack[-2] // @0C96 stack[-7] // @0CB2 stack[-6] // @0CB5 memory[0x40:0x60] // @0CFF memory[0x40:0x60] // @0D06 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // } 0C86 5B JUMPDEST 0C87 91 SWAP2 0C88 50 POP 0C89 91 SWAP2 0C8A 50 POP 0C8B 60 PUSH1 0x00 0C8D 62 PUSH3 0x000d56 0C91 62 PUSH3 0x000d4e 0C95 83 DUP4 0C96 88 DUP9 0C97 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CAC 16 AND 0CAD 63 PUSH4 0x70a08231 0CB2 89 DUP10 0CB3 60 PUSH1 0x40 0CB5 51 MLOAD 0CB6 82 DUP3 0CB7 63 PUSH4 0xffffffff 0CBC 16 AND 0CBD 60 PUSH1 0xe0 0CBF 1B SHL 0CC0 81 DUP2 0CC1 52 MSTORE 0CC2 60 PUSH1 0x04 0CC4 01 ADD 0CC5 80 DUP1 0CC6 82 DUP3 0CC7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CDC 16 AND 0CDD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CF2 16 AND 0CF3 81 DUP2 0CF4 52 MSTORE 0CF5 60 PUSH1 0x20 0CF7 01 ADD 0CF8 91 SWAP2 0CF9 50 POP 0CFA 50 POP 0CFB 60 PUSH1 0x20 0CFD 60 PUSH1 0x40 0CFF 51 MLOAD 0D00 80 DUP1 0D01 83 DUP4 0D02 03 SUB 0D03 81 DUP2 0D04 86 DUP7 0D05 80 DUP1 0D06 3B EXTCODESIZE 0D07 15 ISZERO 0D08 80 DUP1 0D09 15 ISZERO 0D0A 62 PUSH3 0x000d13 0D0E 57 *JUMPI // Stack delta = +11 // Outputs[17] // { // @0C87 stack[-3] = stack[-1] // @0C89 stack[-4] = stack[-2] // @0C8B stack[-2] = 0x00 // @0C8D stack[-1] = 0x000d56 // @0C91 stack[0] = 0x000d4e // @0C95 stack[1] = stack[-1] // @0CAC stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0CAD stack[3] = 0x70a08231 // @0CC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @0CF4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @0CF8 stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @0CFB stack[5] = 0x20 // @0CFF stack[6] = memory[0x40:0x60] // @0D02 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0D03 stack[8] = memory[0x40:0x60] // @0D04 stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0D07 stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // } // Block ends with conditional call to 0x000d13, returns to 0x0D4E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length label_0D0F: // Incoming jump from 0x0D0E, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // Inputs[1] { @0D12 memory[0x00:0x00] } 0D0F 60 PUSH1 0x00 0D11 80 DUP1 0D12 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D12 revert(memory[0x00:0x00]); } // Block terminates label_0D13: // Incoming call from 0x2482, returns to 0x0D4E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // Incoming call from 0x0D0E, returns to 0x0D4E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // Incoming call from 0x3C27, returns to 0x3C2C, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-11]).code.length // Inputs[8] // { // @0D15 msg.gas // @0D16 stack[-6] // @0D16 memory[stack[-3]:stack[-3] + stack[-4]] // @0D16 stack[-4] // @0D16 stack[-5] // @0D16 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D16 stack[-2] // @0D16 stack[-3] // } 0D13 5B JUMPDEST 0D14 50 POP 0D15 5A GAS 0D16 FA STATICCALL 0D17 15 ISZERO 0D18 80 DUP1 0D19 15 ISZERO 0D1A 62 PUSH3 0x000d28 0D1E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D16 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D17 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x000d28, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0D1F: // Incoming jump from 0x0D1E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D1F returndata.length // @0D23 returndata[0x00:0x00 + returndata.length] // @0D24 returndata.length // @0D27 memory[0x00:0x00 + returndata.length] // } 0D1F 3D RETURNDATASIZE 0D20 60 PUSH1 0x00 0D22 80 DUP1 0D23 3E RETURNDATACOPY 0D24 3D RETURNDATASIZE 0D25 60 PUSH1 0x00 0D27 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D23 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D27 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D28: // Incoming jump from 0x0D1E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0D2F memory[0x40:0x60] // @0D30 returndata.length // } 0D28 5B JUMPDEST 0D29 50 POP 0D2A 50 POP 0D2B 50 POP 0D2C 50 POP 0D2D 60 PUSH1 0x40 0D2F 51 MLOAD 0D30 3D RETURNDATASIZE 0D31 60 PUSH1 0x20 0D33 81 DUP2 0D34 10 LT 0D35 15 ISZERO 0D36 62 PUSH3 0x000d3f 0D3A 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0D2F stack[-4] = memory[0x40:0x60] // @0D30 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x000d3f, if !(returndata.length < 0x20) label_0D3B: // Incoming jump from 0x0D3A, if not !(returndata.length < 0x20) // Inputs[1] { @0D3E memory[0x00:0x00] } 0D3B 60 PUSH1 0x00 0D3D 80 DUP1 0D3E FD *REVERT // Stack delta = +0 // Outputs[1] { @0D3E revert(memory[0x00:0x00]); } // Block terminates label_0D3F: // Incoming jump from 0x0D3A, if !(returndata.length < 0x20) // Inputs[3] // { // @0D41 memory[stack[-2]:stack[-2] + 0x20] // @0D41 stack[-2] // @0D42 stack[-3] // } 0D3F 5B JUMPDEST 0D40 50 POP 0D41 51 MLOAD 0D42 90 SWAP1 0D43 63 PUSH4 0xffffffff 0D48 62 PUSH3 0x0035f9 0D4C 16 AND 0D4D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0D42 stack[-2] = stack[-3] // @0D42 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0035f9 & 0xffffffff label_0D4E: // Incoming return from call to 0x0D13 at 0x0D0E // Incoming return from call to 0x0D13 at 0x2482 // Inputs[2] // { // @0D4F stack[-4] // @0D50 stack[-5] // } 0D4E 5B JUMPDEST 0D4F 83 DUP4 0D50 85 DUP6 0D51 62 PUSH3 0x0036f2 0D55 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D4F stack[0] = stack[-4] // @0D50 stack[1] = stack[-5] // } // Block ends with unconditional jump to 0x0036f2 label_0D56: // Incoming return from call to 0x0D4E at 0x0D0E // Inputs[3] // { // @0D57 stack[-2] // @0D57 stack[-1] // @0D5F stack[-8] // } 0D56 5B JUMPDEST 0D57 90 SWAP1 0D58 50 POP 0D59 64 PUSH5 0xe8d4a51000 0D5F 87 DUP8 0D60 63 PUSH4 0xffffffff 0D65 16 AND 0D66 02 MUL 0D67 81 DUP2 0D68 11 GT 0D69 62 PUSH3 0x000d72 0D6D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0D57 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x000d72, if stack[-1] > (0xffffffff & stack[-8]) * 0xe8d4a51000 label_0D6E: // Incoming jump from 0x0D6D, if not stack[-1] > (0xffffffff & stack[-8]) * 0xe8d4a51000 // Inputs[1] { @0D71 memory[0x00:0x00] } 0D6E 60 PUSH1 0x00 0D70 80 DUP1 0D71 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D71 revert(memory[0x00:0x00]); } // Block terminates label_0D72: // Incoming jump from 0x0D6D, if stack[-1] > (0xffffffff & stack[-8]) * 0xe8d4a51000 // Inputs[1] { @0D8B stack[-6] } 0D72 5B JUMPDEST 0D73 60 PUSH1 0x00 0D75 80 DUP1 0D76 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D8B 88 DUP9 0D8C 16 AND 0D8D 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0DA2 10 LT 0DA3 62 PUSH3 0x000db0 0DA7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D73 stack[0] = 0x00 // @0D75 stack[1] = 0x00 // } // Block ends with conditional jump to 0x000db0, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff label_0DA8: // Incoming jump from 0x0DA7, if not 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0DAA stack[-3] } 0DA8 60 PUSH1 0x00 0DAA 83 DUP4 0DAB 62 PUSH3 0x000db4 0DAF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DA8 stack[0] = 0x00 // @0DAA stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x000db4 label_0DB0: // Incoming jump from 0x0DA7, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[6] // { // @0DB1 stack[-3] // @0DB5 stack[-1] // @0DB7 stack[-2] // @0DB9 stack[-7] // @0DD7 address(this) // @0DDC memory[0x40:0x60] // } 0DB0 5B JUMPDEST 0DB1 82 DUP3 0DB2 60 PUSH1 0x00 0DB4 5B JUMPDEST 0DB5 91 SWAP2 0DB6 50 POP 0DB7 91 SWAP2 0DB8 50 POP 0DB9 86 DUP7 0DBA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DCF 16 AND 0DD0 63 PUSH4 0x022c0d9f 0DD5 83 DUP4 0DD6 83 DUP4 0DD7 30 ADDRESS 0DD8 60 PUSH1 0x00 0DDA 60 PUSH1 0x40 0DDC 51 MLOAD 0DDD 90 SWAP1 0DDE 80 DUP1 0DDF 82 DUP3 0DE0 52 MSTORE 0DE1 80 DUP1 0DE2 60 PUSH1 0x1f 0DE4 01 ADD 0DE5 60 PUSH1 0x1f 0DE7 19 NOT 0DE8 16 AND 0DE9 60 PUSH1 0x20 0DEB 01 ADD 0DEC 82 DUP3 0DED 01 ADD 0DEE 60 PUSH1 0x40 0DF0 52 MSTORE 0DF1 80 DUP1 0DF2 15 ISZERO 0DF3 62 PUSH3 0x000e04 0DF7 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @0DB5 stack[-1] = 0x00 // @0DB7 stack[-2] = stack[-3] // @0DCF stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0DD0 stack[1] = 0x022c0d9f // @0DD5 stack[2] = stack[-3] // @0DD6 stack[3] = 0x00 // @0DD7 stack[4] = address(this) // @0DDD stack[5] = memory[0x40:0x60] // @0DDD stack[6] = 0x00 // @0DE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0DF0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + 0x00) // } // Block ends with conditional jump to 0x000e04, if !0x00 label_0DF8: // Incoming jump from 0x0DF7, if not !0x00 // Incoming jump from 0x0DF7, if not !0x00 // Inputs[10] // { // @0DFA stack[-2] // @0DFC stack[-1] // @0DFE code.length // @0E08 memory[0x40:0x60] // @0E09 stack[-6] // @0E19 stack[-5] // @0E1F stack[-4] // @0E25 stack[-3] // @0E63 memory[stack[-2]:stack[-2] + 0x20] // @0E6C memory[stack[-2]:stack[-2] + 0x20] // } 0DF8 60 PUSH1 0x20 0DFA 82 DUP3 0DFB 01 ADD 0DFC 81 DUP2 0DFD 80 DUP1 0DFE 38 CODESIZE 0DFF 83 DUP4 0E00 39 CODECOPY 0E01 01 ADD 0E02 90 SWAP1 0E03 50 POP 0E04 5B JUMPDEST 0E05 50 POP 0E06 60 PUSH1 0x40 0E08 51 MLOAD 0E09 85 DUP6 0E0A 63 PUSH4 0xffffffff 0E0F 16 AND 0E10 60 PUSH1 0xe0 0E12 1B SHL 0E13 81 DUP2 0E14 52 MSTORE 0E15 60 PUSH1 0x04 0E17 01 ADD 0E18 80 DUP1 0E19 85 DUP6 0E1A 81 DUP2 0E1B 52 MSTORE 0E1C 60 PUSH1 0x20 0E1E 01 ADD 0E1F 84 DUP5 0E20 81 DUP2 0E21 52 MSTORE 0E22 60 PUSH1 0x20 0E24 01 ADD 0E25 83 DUP4 0E26 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E3B 16 AND 0E3C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E51 16 AND 0E52 81 DUP2 0E53 52 MSTORE 0E54 60 PUSH1 0x20 0E56 01 ADD 0E57 80 DUP1 0E58 60 PUSH1 0x20 0E5A 01 ADD 0E5B 82 DUP3 0E5C 81 DUP2 0E5D 03 SUB 0E5E 82 DUP3 0E5F 52 MSTORE 0E60 83 DUP4 0E61 81 DUP2 0E62 81 DUP2 0E63 51 MLOAD 0E64 81 DUP2 0E65 52 MSTORE 0E66 60 PUSH1 0x20 0E68 01 ADD 0E69 91 SWAP2 0E6A 50 POP 0E6B 80 DUP1 0E6C 51 MLOAD 0E6D 90 SWAP1 0E6E 60 PUSH1 0x20 0E70 01 ADD 0E71 90 SWAP1 0E72 80 DUP1 0E73 83 DUP4 0E74 83 DUP4 0E75 60 PUSH1 0x00 0E77 5B JUMPDEST 0E78 83 DUP4 0E79 81 DUP2 0E7A 10 LT 0E7B 15 ISZERO 0E7C 62 PUSH3 0x000e91 0E80 57 *JUMPI // Stack delta = +8 // Outputs[16] // { // @0E00 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @0E14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-6]) << 0xe0 // @0E17 stack[-1] = 0x04 + memory[0x40:0x60] // @0E1B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @0E21 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @0E53 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E56 stack[0] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0E5F memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0E65 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0E69 stack[1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0E71 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0E71 stack[2] = 0x20 + stack[-2] // @0E72 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @0E73 stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0E74 stack[6] = 0x20 + stack[-2] // @0E75 stack[7] = 0x00 // } // Block ends with conditional jump to 0x000e91, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0E81: // Incoming jump from 0x0E80, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0E80, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0E80, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @0E81 stack[-2] // @0E82 stack[-1] // @0E84 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0E85 stack[-3] // } 0E81 81 DUP2 0E82 81 DUP2 0E83 01 ADD 0E84 51 MLOAD 0E85 83 DUP4 0E86 82 DUP3 0E87 01 ADD 0E88 52 MSTORE 0E89 60 PUSH1 0x20 0E8B 01 ADD 0E8C 62 PUSH3 0x000e77 0E90 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E88 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0E8B stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x000e77 label_0E91: // Incoming jump from 0x0E80, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0E80, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0E80, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0E96 stack[-6] // @0E96 stack[-5] // @0E98 stack[-7] // } 0E91 5B JUMPDEST 0E92 50 POP 0E93 50 POP 0E94 50 POP 0E95 50 POP 0E96 90 SWAP1 0E97 50 POP 0E98 90 SWAP1 0E99 81 DUP2 0E9A 01 ADD 0E9B 90 SWAP1 0E9C 60 PUSH1 0x1f 0E9E 16 AND 0E9F 80 DUP1 0EA0 15 ISZERO 0EA1 62 PUSH3 0x000ebf 0EA5 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0E9B stack[-7] = stack[-5] + stack[-7] // @0E9E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x000ebf, if !(0x1f & stack[-5]) label_0EA6: // Incoming jump from 0x0EA5, if not !(0x1f & stack[-5]) // Inputs[7] // { // @0EA6 stack[-1] // @0EA7 stack[-2] // @0EAA memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0EC1 stack[-8] // @0ECC memory[0x40:0x60] // @0ED3 stack[-10] // @0ED5 address(stack[-10]).code.length // } 0EA6 80 DUP1 0EA7 82 DUP3 0EA8 03 SUB 0EA9 80 DUP1 0EAA 51 MLOAD 0EAB 60 PUSH1 0x01 0EAD 83 DUP4 0EAE 60 PUSH1 0x20 0EB0 03 SUB 0EB1 61 PUSH2 0x0100 0EB4 0A EXP 0EB5 03 SUB 0EB6 19 NOT 0EB7 16 AND 0EB8 81 DUP2 0EB9 52 MSTORE 0EBA 60 PUSH1 0x20 0EBC 01 ADD 0EBD 91 SWAP2 0EBE 50 POP 0EBF 5B JUMPDEST 0EC0 50 POP 0EC1 95 SWAP6 0EC2 50 POP 0EC3 50 POP 0EC4 50 POP 0EC5 50 POP 0EC6 50 POP 0EC7 50 POP 0EC8 60 PUSH1 0x00 0ECA 60 PUSH1 0x40 0ECC 51 MLOAD 0ECD 80 DUP1 0ECE 83 DUP4 0ECF 03 SUB 0ED0 81 DUP2 0ED1 60 PUSH1 0x00 0ED3 87 DUP8 0ED4 80 DUP1 0ED5 3B EXTCODESIZE 0ED6 15 ISZERO 0ED7 80 DUP1 0ED8 15 ISZERO 0ED9 62 PUSH3 0x000ee2 0EDD 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0EB9 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0EC1 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @0EC8 stack[-7] = 0x00 // @0ECC stack[-6] = memory[0x40:0x60] // @0ECF stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @0ED0 stack[-4] = memory[0x40:0x60] // @0ED1 stack[-3] = 0x00 // @0ED3 stack[-2] = stack[-10] // @0ED6 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x000ee2, if !!address(stack[-10]).code.length label_0EDE: // Incoming jump from 0x0EDD, if not !!address(stack[-10]).code.length // Incoming jump from 0x0EDD, if not !!address(stack[-10]).code.length // Inputs[1] { @0EE1 memory[0x00:0x00] } 0EDE 60 PUSH1 0x00 0EE0 80 DUP1 0EE1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EE1 revert(memory[0x00:0x00]); } // Block terminates label_0EE2: // Incoming jump from 0x0EDD, if !!address(stack[-10]).code.length // Incoming jump from 0x0EDD, if !!address(stack[-10]).code.length // Inputs[9] // { // @0EE4 msg.gas // @0EE5 memory[stack[-4]:stack[-4] + stack[-5]] // @0EE5 stack[-4] // @0EE5 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0EE5 stack[-5] // @0EE5 stack[-3] // @0EE5 stack[-7] // @0EE5 stack[-2] // @0EE5 stack[-6] // } 0EE2 5B JUMPDEST 0EE3 50 POP 0EE4 5A GAS 0EE5 F1 CALL 0EE6 15 ISZERO 0EE7 80 DUP1 0EE8 15 ISZERO 0EE9 62 PUSH3 0x000ef7 0EED 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0EE5 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0EE6 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x000ef7, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0EEE: // Incoming jump from 0x0EED, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0EEE returndata.length // @0EF2 returndata[0x00:0x00 + returndata.length] // @0EF3 returndata.length // @0EF6 memory[0x00:0x00 + returndata.length] // } 0EEE 3D RETURNDATASIZE 0EEF 60 PUSH1 0x00 0EF1 80 DUP1 0EF2 3E RETURNDATACOPY 0EF3 3D RETURNDATASIZE 0EF4 60 PUSH1 0x00 0EF6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EF2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0EF6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0EF7: // Incoming jump from 0x0EED, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[3] // { // @0EFC block.coinbase // @0F1A stack[-13] // @0F2E stack[-7] // } 0EF7 5B JUMPDEST 0EF8 50 POP 0EF9 50 POP 0EFA 50 POP 0EFB 50 POP 0EFC 41 COINBASE 0EFD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F12 16 AND 0F13 61 PUSH2 0x08fc 0F16 60 PUSH1 0x64 0F18 60 PUSH1 0x40 0F1A 8C DUP13 0F1B 90 SWAP1 0F1C 1C SHR 0F1D 60 PUSH1 0xff 0F1F 16 AND 0F20 64 PUSH5 0xe8d4a51000 0F26 8D DUP14 0F27 63 PUSH4 0xffffffff 0F2C 16 AND 0F2D 02 MUL 0F2E 87 DUP8 0F2F 03 SUB 0F30 02 MUL 0F31 81 DUP2 0F32 62 PUSH3 0x000f38 0F36 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0F12 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & block.coinbase // @0F13 stack[-3] = 0x08fc // @0F16 stack[-2] = 0x64 // @0F30 stack[-1] = stack[-7] - (0xffffffff & stack[-13]) * 0xe8d4a51000 * (0xff & (stack[-13] >> 0x40)) // } // Block ends with conditional jump to 0x000f38, if 0x64 label_0F37: // Incoming jump from 0x0F36, if not 0x64 0F37 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0F37 assert(); } // Block terminates label_0F38: // Incoming jump from 0x0F36, if 0x64 // Inputs[8] // { // @0F39 stack[-1] // @0F39 stack[-2] // @0F3A stack[-3] // @0F41 memory[0x40:0x60] // @0F46 memory[0x40:0x60] // @0F4C stack[-4] // @0F4E memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0F4E address(stack[-4]).call.gas(!(stack[-1] / stack[-2]) * stack[-3]).value(stack[-1] / stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 0F38 5B JUMPDEST 0F39 04 DIV 0F3A 90 SWAP1 0F3B 81 DUP2 0F3C 15 ISZERO 0F3D 02 MUL 0F3E 90 SWAP1 0F3F 60 PUSH1 0x40 0F41 51 MLOAD 0F42 60 PUSH1 0x00 0F44 60 PUSH1 0x40 0F46 51 MLOAD 0F47 80 DUP1 0F48 83 DUP4 0F49 03 SUB 0F4A 81 DUP2 0F4B 85 DUP6 0F4C 88 DUP9 0F4D 88 DUP9 0F4E F1 CALL 0F4F 93 SWAP4 0F50 50 POP 0F51 50 POP 0F52 50 POP 0F53 50 POP 0F54 15 ISZERO 0F55 80 DUP1 0F56 15 ISZERO 0F57 62 PUSH3 0x000f65 0F5B 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0F4E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-4]).call.gas(!(stack[-1] / stack[-2]) * stack[-3]).value(stack[-1] / stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0F54 stack[-4] = !address(stack[-4]).call.gas(!(stack[-1] / stack[-2]) * stack[-3]).value(stack[-1] / stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x000f65, if !!address(stack[-4]).call.gas(!(stack[-1] / stack[-2]) * stack[-3]).value(stack[-1] / stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_0F5C: // Incoming jump from 0x0F5B, if not !!address(stack[-4]).call.gas(!(stack[-1] / stack[-2]) * stack[-3]).value(stack[-1] / stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[4] // { // @0F5C returndata.length // @0F60 returndata[0x00:0x00 + returndata.length] // @0F61 returndata.length // @0F64 memory[0x00:0x00 + returndata.length] // } 0F5C 3D RETURNDATASIZE 0F5D 60 PUSH1 0x00 0F5F 80 DUP1 0F60 3E RETURNDATACOPY 0F61 3D RETURNDATASIZE 0F62 60 PUSH1 0x00 0F64 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F60 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0F64 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0F65: // Incoming jump from 0x0F5B, if !!address(stack[-4]).call.gas(!(stack[-1] / stack[-2]) * stack[-3]).value(stack[-1] / stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @0F69 stack[-10] } 0F65 5B JUMPDEST 0F66 50 POP 0F67 60 PUSH1 0xfc 0F69 89 DUP10 0F6A 90 SWAP1 0F6B 1C SHR 0F6C 15 ISZERO 0F6D 62 PUSH3 0x000f96 0F71 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x000f96, if !(stack[-10] >> 0xfc) label_0F72: // Incoming jump from 0x0F71, if not !(stack[-10] >> 0xfc) // Inputs[1] { @0F7E stack[-9] } 0F72 62 PUSH3 0x000f96 0F76 60 PUSH1 0x10 0F78 62 PUSH3 0xffffff 0F7C 60 PUSH1 0xe4 0F7E 8C DUP13 0F7F 90 SWAP1 0F80 1C SHR 0F81 16 AND // Stack delta = +3 // Outputs[3] // { // @0F72 stack[0] = 0x000f96 // @0F76 stack[1] = 0x10 // @0F81 stack[2] = (stack[-9] >> 0xe4) & 0xffffff // } // Block continues label_0F82: // Incoming call from 0x0F81, returns to 0x0F96 // Incoming call from 0x26AF, returns to 0x0F96 // Inputs[3] // { // @0F83 stack[-1] // @0F83 stack[-2] // @0F8B stack[-12] // } 0F82 5B JUMPDEST 0F83 04 DIV 0F84 62 PUSH3 0xffffff 0F88 16 AND 0F89 60 PUSH1 0xfc 0F8B 8B DUP12 0F8C 90 SWAP1 0F8D 1C SHR 0F8E 60 PUSH1 0xff 0F90 16 AND 0F91 62 PUSH3 0x00371c 0F95 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0F88 stack[-2] = 0xffffff & stack[-1] / stack[-2] // @0F90 stack[-1] = 0xff & (stack[-12] >> 0xfc) // } // Block ends with unconditional jump to 0x00371c label_0F96: // Incoming jump from 0x40DC, if !!new(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x80 + (stack[-1] - memory[0x40:0x60])]).value(0x00)() // Incoming jump from 0x1DA9, if memory[stack[-2]:stack[-2] + 0x20] > stack[-3] // Incoming jump from 0x0F71, if !(stack[-10] >> 0xfc) // Incoming return from call to 0x0F82 at 0x0F81 // Incoming jump from 0x269A, if !(stack[-9] >> 0xfc) // Incoming return from call to 0x0F82 at 0x26AF // Inputs[1] { @0FA1 stack[-11] } 0F96 5B JUMPDEST 0F97 50 POP 0F98 50 POP 0F99 50 POP 0F9A 50 POP 0F9B 50 POP 0F9C 50 POP 0F9D 50 POP 0F9E 50 POP 0F9F 50 POP 0FA0 50 POP 0FA1 56 *JUMP // Stack delta = -11 // Block ends with unconditional jump to stack[-11] label_0FA2: // Incoming jump from 0x0287 // Inputs[1] { @0FA3 msg.sender } 0FA2 5B JUMPDEST 0FA3 33 CALLER 0FA4 73 PUSH20 0xdd07249e403979bd79848c27aa5454c7e66bdee7 0FB9 14 EQ 0FBA 80 DUP1 0FBB 62 PUSH3 0x000fd8 0FBF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FB9 stack[0] = 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender } // Block ends with conditional jump to 0x000fd8, if 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender label_0FC0: // Incoming jump from 0x0FBF, if not 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender // Inputs[1] { @0FC1 msg.sender } 0FC0 50 POP 0FC1 33 CALLER 0FC2 73 PUSH20 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 0FD7 14 EQ 0FD8 5B JUMPDEST 0FD9 80 DUP1 0FDA 62 PUSH3 0x000ff7 0FDE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0FD7 stack[-1] = 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender } // Block ends with conditional jump to 0x000ff7, if 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender label_0FDF: // Incoming jump from 0x0FDE, if not 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender // Incoming jump from 0x0FDE, if not stack[-1] // Inputs[1] { @0FE0 msg.sender } 0FDF 50 POP 0FE0 33 CALLER 0FE1 73 PUSH20 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 0FF6 14 EQ 0FF7 5B JUMPDEST 0FF8 80 DUP1 0FF9 62 PUSH3 0x001012 0FFD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0FF6 stack[-1] = 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender } // Block ends with conditional jump to 0x001012, if 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender label_0FFE: // Incoming jump from 0x0FFD, if not stack[-1] // Incoming jump from 0x0FFD, if not 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender // Inputs[3] // { // @0FFF msg.sender // @100D memory[0x00:0x40] // @100E storage[keccak256(memory[0x00:0x40])] // } 0FFE 50 POP 0FFF 33 CALLER 1000 60 PUSH1 0x00 1002 90 SWAP1 1003 81 DUP2 1004 52 MSTORE 1005 60 PUSH1 0x02 1007 60 PUSH1 0x20 1009 52 MSTORE 100A 60 PUSH1 0x40 100C 90 SWAP1 100D 20 SHA3 100E 54 SLOAD 100F 60 PUSH1 0xff 1011 16 AND 1012 5B JUMPDEST 1013 62 PUSH3 0x00101c 1017 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1004 memory[0x00:0x20] = msg.sender // @1009 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x00101c, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1018: // Incoming jump from 0x1017, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1017, if not stack[-1] // Inputs[1] { @101B memory[0x00:0x00] } 1018 60 PUSH1 0x00 101A 80 DUP1 101B FD *REVERT // Stack delta = +0 // Outputs[1] { @101B revert(memory[0x00:0x00]); } // Block terminates label_101C: // Incoming jump from 0x1017, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1017, if stack[-1] // Inputs[2] // { // @103E stack[-1] // @1045 address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance // } 101C 5B JUMPDEST 101D 7F PUSH32 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 103E 81 DUP2 103F 18 XOR 1040 60 PUSH1 0x60 1042 81 DUP2 1043 90 SWAP1 1044 1C SHR 1045 31 BALANCE 1046 6B PUSH12 0xffffffffffffffffffffffff 1053 82 DUP3 1054 16 AND 1055 14 EQ 1056 62 PUSH3 0x0010d7 105A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @103F stack[0] = stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 } // Block ends with conditional jump to 0x0010d7, if (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) & 0xffffffffffffffffffffffff == address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance label_105B: // Incoming jump from 0x105A, if not (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) & 0xffffffffffffffffffffffff == address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance // Inputs[1] { @105F stack[-3] } 105B 60 PUSH1 0x0f 105D 60 PUSH1 0xe8 105F 84 DUP5 1060 90 SWAP1 1061 1C SHR 1062 16 AND 1063 15 ISZERO 1064 62 PUSH3 0x0010d0 1068 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0010d0, if !((stack[-3] >> 0xe8) & 0x0f) label_1069: // Incoming jump from 0x1068, if not !((stack[-3] >> 0xe8) & 0x0f) // Inputs[5] // { // @106C memory[0x40:0x60] // @108E stack[-3] // @109A memory[0x40:0x60] // @10AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @10AF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 1069 60 PUSH1 0x40 106B 80 DUP1 106C 51 MLOAD 106D 7F PUSH32 0xffffff0000000000000000000000000000000000000000000000000000000000 108E 85 DUP6 108F 16 AND 1090 60 PUSH1 0x20 1092 80 DUP1 1093 83 DUP4 1094 01 ADD 1095 91 SWAP2 1096 90 SWAP1 1097 91 SWAP2 1098 52 MSTORE 1099 82 DUP3 109A 51 MLOAD 109B 80 DUP1 109C 83 DUP4 109D 03 SUB 109E 60 PUSH1 0x03 10A0 01 ADD 10A1 81 DUP2 10A2 52 MSTORE 10A3 60 PUSH1 0x23 10A5 90 SWAP1 10A6 92 SWAP3 10A7 01 ADD 10A8 90 SWAP1 10A9 92 SWAP3 10AA 52 MSTORE 10AB 80 DUP1 10AC 51 MLOAD 10AD 91 SWAP2 10AE 01 ADD 10AF 20 SHA3 10B0 62 PUSH3 0x0010d0 10B4 90 SWAP1 10B5 60 PUSH1 0x10 10B7 90 SWAP1 10B8 85 DUP6 10B9 18 XOR 10BA 60 PUSH1 0xd0 10BC 1C SHR 10BD 62 PUSH3 0xffffff 10C1 16 AND 10C2 5B JUMPDEST 10C3 04 DIV 10C4 62 PUSH3 0xffffff 10C8 16 AND 10C9 60 PUSH1 0x01 10CB 62 PUSH3 0x00371c 10CF 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @1098 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] & 0xffffff0000000000000000000000000000000000000000000000000000000000 // @10A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 + (memory[0x40:0x60] - memory[0x40:0x60]) // @10AA memory[0x40:0x60] = memory[0x40:0x60] + 0x23 // @10B4 stack[0] = 0x0010d0 // @10C8 stack[1] = 0xffffff & (0xffffff & ((stack[-3] ~ keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0xd0)) / 0x10 // @10C9 stack[2] = 0x01 // } // Block ends with call to 0x00371c, returns to 0x10D0 label_10D0: // Incoming jump from 0x1068, if !((stack[-3] >> 0xe8) & 0x0f) // Incoming return from call to 0x371C at 0x10CF 10D0 5B JUMPDEST 10D1 50 POP 10D2 62 PUSH3 0x0010e4 10D6 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0010e4 label_10D7: // Incoming jump from 0x105A, if (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) & 0xffffffffffffffffffffffff == address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance // Inputs[1] { @10DC stack[-3] } 10D7 5B JUMPDEST 10D8 62 PUSH3 0x0010e2 10DC 83 DUP4 10DD 62 PUSH3 0x003135 10E1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10D8 stack[0] = 0x0010e2 // @10DC stack[1] = stack[-3] // } // Block ends with call to 0x003135, returns to 0x10E2 label_10E2: // Incoming return from call to 0x3135 at 0x10E1 // Incoming return from call to 0x3135 at 0x10E1 // Incoming jump from 0x17A7, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x17A7, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1F40, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x00]).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x19B2, if !!address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-5]).value(stack[-5])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) 10E2 5B JUMPDEST 10E3 50 POP // Stack delta = -1 // Block continues label_10E4: // Incoming jump from 0x10E3 // Incoming jump from 0x2165, if !(stack[-2] >> 0xfc) // Incoming jump from 0x15CF // Incoming return from call to 0x371C at 0x2188 // Incoming jump from 0x10D6 // Inputs[1] { @10E7 stack[-3] } 10E4 5B JUMPDEST 10E5 50 POP 10E6 50 POP 10E7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_10E8: // Incoming jump from 0x02B5 // Inputs[1] { @10E9 msg.sender } 10E8 5B JUMPDEST 10E9 33 CALLER 10EA 73 PUSH20 0x58d46ae3114fc82d80f57c9a2a322845a19418fb 10FF 14 EQ 1100 62 PUSH3 0x001109 1104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x001109, if 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender label_1105: // Incoming jump from 0x1104, if not 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender // Inputs[1] { @1108 memory[0x00:0x00] } 1105 60 PUSH1 0x00 1107 80 DUP1 1108 FD *REVERT // Stack delta = +0 // Outputs[1] { @1108 revert(memory[0x00:0x00]); } // Block terminates label_1109: // Incoming jump from 0x1104, if 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender // Inputs[4] // { // @112D stack[-1] // @1157 memory[0x40:0x60] // @116B memory[0x40:0x60] // @1172 address(0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5)).code.length // } 1109 5B JUMPDEST 110A 60 PUSH1 0x00 110C 7F PUSH32 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 112D 82 DUP3 112E 18 XOR 112F 90 SWAP1 1130 50 POP 1131 60 PUSH1 0x00 1133 81 DUP2 1134 90 SWAP1 1135 50 POP 1136 60 PUSH1 0x00 1138 80 DUP1 1139 82 DUP3 113A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 114F 16 AND 1150 63 PUSH4 0x0902f1ac 1155 60 PUSH1 0x40 1157 51 MLOAD 1158 81 DUP2 1159 63 PUSH4 0xffffffff 115E 16 AND 115F 60 PUSH1 0xe0 1161 1B SHL 1162 81 DUP2 1163 52 MSTORE 1164 60 PUSH1 0x04 1166 01 ADD 1167 60 PUSH1 0x60 1169 60 PUSH1 0x40 116B 51 MLOAD 116C 80 DUP1 116D 83 DUP4 116E 03 SUB 116F 81 DUP2 1170 86 DUP7 1171 80 DUP1 1172 3B EXTCODESIZE 1173 15 ISZERO 1174 80 DUP1 1175 15 ISZERO 1176 62 PUSH3 0x00117f 117A 57 *JUMPI // Stack delta = +13 // Outputs[14] // { // @112F stack[0] = stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 // @1134 stack[1] = stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 // @1136 stack[2] = 0x00 // @1138 stack[3] = 0x00 // @114F stack[4] = 0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) // @1150 stack[5] = 0x0902f1ac // @1163 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0902f1ac) << 0xe0 // @1166 stack[6] = 0x04 + memory[0x40:0x60] // @1167 stack[7] = 0x60 // @116B stack[8] = memory[0x40:0x60] // @116E stack[9] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @116F stack[10] = memory[0x40:0x60] // @1170 stack[11] = 0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) // @1173 stack[12] = !address(0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5)).code.length // } // Block ends with conditional jump to 0x00117f, if !!address(0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5)).code.length label_117B: // Incoming jump from 0x117A, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5)).code.length // Inputs[1] { @117E memory[0x00:0x00] } 117B 60 PUSH1 0x00 117D 80 DUP1 117E FD *REVERT // Stack delta = +0 // Outputs[1] { @117E revert(memory[0x00:0x00]); } // Block terminates label_117F: // Incoming jump from 0x117A, if !!address(0xffffffffffffffffffffffffffffffffffffffff & (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5)).code.length // Inputs[8] // { // @1181 msg.gas // @1182 stack[-6] // @1182 stack[-4] // @1182 stack[-5] // @1182 stack[-3] // @1182 memory[stack[-3]:stack[-3] + stack[-4]] // @1182 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1182 stack[-2] // } 117F 5B JUMPDEST 1180 50 POP 1181 5A GAS 1182 FA STATICCALL 1183 15 ISZERO 1184 80 DUP1 1185 15 ISZERO 1186 62 PUSH3 0x001194 118A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1182 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1183 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x001194, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_118B: // Incoming jump from 0x118A, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @118B returndata.length // @118F returndata[0x00:0x00 + returndata.length] // @1190 returndata.length // @1193 memory[0x00:0x00 + returndata.length] // } 118B 3D RETURNDATASIZE 118C 60 PUSH1 0x00 118E 80 DUP1 118F 3E RETURNDATACOPY 1190 3D RETURNDATASIZE 1191 60 PUSH1 0x00 1193 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @118F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1193 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1194: // Incoming jump from 0x118A, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @119B memory[0x40:0x60] // @119C returndata.length // } 1194 5B JUMPDEST 1195 50 POP 1196 50 POP 1197 50 POP 1198 50 POP 1199 60 PUSH1 0x40 119B 51 MLOAD 119C 3D RETURNDATASIZE 119D 60 PUSH1 0x60 119F 81 DUP2 11A0 10 LT 11A1 15 ISZERO 11A2 62 PUSH3 0x0011ab 11A6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @119B stack[-4] = memory[0x40:0x60] // @119C stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0011ab, if !(returndata.length < 0x60) label_11A7: // Incoming jump from 0x11A6, if not !(returndata.length < 0x60) // Inputs[1] { @11AA memory[0x00:0x00] } 11A7 60 PUSH1 0x00 11A9 80 DUP1 11AA FD *REVERT // Stack delta = +0 // Outputs[1] { @11AA revert(memory[0x00:0x00]); } // Block terminates label_11AB: // Incoming jump from 0x11A6, if !(returndata.length < 0x60) // Inputs[6] // { // @11AD stack[-2] // @11AE memory[stack[-2]:stack[-2] + 0x20] // @11B4 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @11C7 stack[-4] // @11CA stack[-3] // @11D2 stack[-6] // } 11AB 5B JUMPDEST 11AC 50 POP 11AD 80 DUP1 11AE 51 MLOAD 11AF 60 PUSH1 0x20 11B1 90 SWAP1 11B2 91 SWAP2 11B3 01 ADD 11B4 51 MLOAD 11B5 6D PUSH14 0xffffffffffffffffffffffffffff 11C4 91 SWAP2 11C5 82 DUP3 11C6 16 AND 11C7 93 SWAP4 11C8 50 POP 11C9 16 AND 11CA 90 SWAP1 11CB 50 POP 11CC 60 PUSH1 0x0a 11CE 60 PUSH1 0xff 11D0 60 PUSH1 0xa0 11D2 86 DUP7 11D3 90 SWAP1 11D4 1C SHR 11D5 16 AND 11D6 04 DIV 11D7 60 PUSH1 0xff 11D9 16 AND 11DA 60 PUSH1 0x00 11DC 14 EQ 11DD 15 ISZERO 11DE 62 PUSH3 0x0011e4 11E2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @11C7 stack[-4] = 0xffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] // @11CA stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x0011e4, if !(0x00 == 0xff & ((stack[-6] >> 0xa0) & 0xff) / 0x0a) label_11E3: // Incoming jump from 0x11E2, if not !(0x00 == 0xff & ((stack[-6] >> 0xa0) & 0xff) / 0x0a) // Inputs[3] // { // @11E3 stack[-2] // @11E3 stack[-1] // @11EE stack[-4] // } 11E3 90 SWAP1 11E4 5B JUMPDEST 11E5 65 PUSH6 0x5af3107a4000 11EC 60 PUSH1 0xc8 11EE 85 DUP6 11EF 90 SWAP1 11F0 1C SHR 11F1 63 PUSH4 0xffffffff 11F6 16 AND 11F7 02 MUL 11F8 82 DUP3 11F9 10 LT 11FA 62 PUSH3 0x001208 11FE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @11E3 stack[-1] = stack[-2] // @11E3 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x001208, if stack[-1] < (0xffffffff & (stack[-4] >> 0xc8)) * 0x5af3107a4000 label_11FF: // Incoming jump from 0x11FE, if not stack[-2] < (0xffffffff & (stack[-4] >> 0xc8)) * 0x5af3107a4000 // Incoming jump from 0x11FE, if not stack[-1] < (0xffffffff & (stack[-4] >> 0xc8)) * 0x5af3107a4000 11FF 50 POP 1200 50 POP 1201 50 POP 1202 50 POP 1203 62 PUSH3 0x000a80 1207 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to 0x000a80 label_1208: // Incoming jump from 0x11FE, if stack[-2] < (0xffffffff & (stack[-4] >> 0xc8)) * 0x5af3107a4000 // Incoming jump from 0x11FE, if stack[-1] < (0xffffffff & (stack[-4] >> 0xc8)) * 0x5af3107a4000 // Inputs[3] // { // @1210 stack[-4] // @1222 stack[-2] // @1223 stack[-1] // } 1208 5B JUMPDEST 1209 63 PUSH4 0xffffffff 120E 60 PUSH1 0xa8 1210 85 DUP6 1211 90 SWAP1 1212 1C SHR 1213 16 AND 1214 64 PUSH5 0xe8d4a51000 121A 02 MUL 121B 60 PUSH1 0x00 121D 62 PUSH3 0x001229 1221 82 DUP3 1222 85 DUP6 1223 85 DUP6 1224 62 PUSH3 0x0036f2 1228 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @121A stack[0] = 0xe8d4a51000 * ((stack[-4] >> 0xa8) & 0xffffffff) // @121B stack[1] = 0x00 // @121D stack[2] = 0x001229 // @1221 stack[3] = 0xe8d4a51000 * ((stack[-4] >> 0xa8) & 0xffffffff) // @1222 stack[4] = stack[-2] // @1223 stack[5] = stack[-1] // } // Block ends with call to 0x0036f2, returns to 0x1229 label_1229: // Incoming return from call to 0x36F2 at 0x1228 // Inputs[7] // { // @122D memory[0x40:0x60] // @1266 stack[-6] // @1271 stack[-3] // @1275 memory[0x40:0x60] // @1276 stack[-1] // @1277 stack[-2] // @12AA address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 1229 5B JUMPDEST 122A 60 PUSH1 0x40 122C 80 DUP1 122D 51 MLOAD 122E 7F PUSH32 0xa9059cbb00000000000000000000000000000000000000000000000000000000 124F 81 DUP2 1250 52 MSTORE 1251 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1266 88 DUP9 1267 16 AND 1268 60 PUSH1 0x04 126A 82 DUP3 126B 01 ADD 126C 52 MSTORE 126D 60 PUSH1 0x24 126F 81 DUP2 1270 01 ADD 1271 85 DUP6 1272 90 SWAP1 1273 52 MSTORE 1274 90 SWAP1 1275 51 MLOAD 1276 91 SWAP2 1277 92 SWAP3 1278 50 POP 1279 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 128E 91 SWAP2 128F 63 PUSH4 0xa9059cbb 1294 91 SWAP2 1295 60 PUSH1 0x44 1297 80 DUP1 1298 82 DUP3 1299 01 ADD 129A 92 SWAP3 129B 60 PUSH1 0x20 129D 92 SWAP3 129E 90 SWAP1 129F 91 SWAP2 12A0 90 SWAP1 12A1 82 DUP3 12A2 90 SWAP1 12A3 03 SUB 12A4 01 ADD 12A5 81 DUP2 12A6 60 PUSH1 0x00 12A8 87 DUP8 12A9 80 DUP1 12AA 3B EXTCODESIZE 12AB 15 ISZERO 12AC 80 DUP1 12AD 15 ISZERO 12AE 62 PUSH3 0x0012b7 12B2 57 *JUMPI // Stack delta = +9 // Outputs[14] // { // @1250 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000 // @126C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @1273 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-3] // @1277 stack[-2] = stack[-1] // @128E stack[-1] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1294 stack[0] = 0xa9059cbb // @129A stack[1] = memory[0x40:0x60] + 0x44 // @129D stack[2] = 0x20 // @129F stack[3] = memory[0x40:0x60] // @12A4 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @12A5 stack[5] = memory[0x40:0x60] // @12A6 stack[6] = 0x00 // @12A8 stack[7] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @12AB stack[8] = !address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0012b7, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_12B3: // Incoming jump from 0x12B2, if not !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @12B6 memory[0x00:0x00] } 12B3 60 PUSH1 0x00 12B5 80 DUP1 12B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @12B6 revert(memory[0x00:0x00]); } // Block terminates label_12B7: // Incoming jump from 0x12B2, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @12B9 msg.gas // @12BA stack[-2] // @12BA stack[-6] // @12BA stack[-4] // @12BA stack[-5] // @12BA stack[-3] // @12BA stack[-7] // @12BA address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @12BA memory[stack[-4]:stack[-4] + stack[-5]] // } 12B7 5B JUMPDEST 12B8 50 POP 12B9 5A GAS 12BA F1 CALL 12BB 15 ISZERO 12BC 80 DUP1 12BD 15 ISZERO 12BE 62 PUSH3 0x0012cc 12C2 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @12BA memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @12BB stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0012cc, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_12C3: // Incoming jump from 0x12C2, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @12C3 returndata.length // @12C7 returndata[0x00:0x00 + returndata.length] // @12C8 returndata.length // @12CB memory[0x00:0x00 + returndata.length] // } 12C3 3D RETURNDATASIZE 12C4 60 PUSH1 0x00 12C6 80 DUP1 12C7 3E RETURNDATACOPY 12C8 3D RETURNDATASIZE 12C9 60 PUSH1 0x00 12CB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12C7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @12CB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_12CC: // Incoming jump from 0x12C2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @12D3 memory[0x40:0x60] // @12D4 returndata.length // } 12CC 5B JUMPDEST 12CD 50 POP 12CE 50 POP 12CF 50 POP 12D0 50 POP 12D1 60 PUSH1 0x40 12D3 51 MLOAD 12D4 3D RETURNDATASIZE 12D5 60 PUSH1 0x20 12D7 81 DUP2 12D8 10 LT 12D9 15 ISZERO 12DA 62 PUSH3 0x0012e3 12DE 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @12D3 stack[-4] = memory[0x40:0x60] // @12D4 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0012e3, if !(returndata.length < 0x20) label_12DF: // Incoming jump from 0x12DE, if not !(returndata.length < 0x20) // Inputs[1] { @12E2 memory[0x00:0x00] } 12DF 60 PUSH1 0x00 12E1 80 DUP1 12E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @12E2 revert(memory[0x00:0x00]); } // Block terminates label_12E3: // Incoming jump from 0x12DE, if !(returndata.length < 0x20) // Inputs[2] // { // @12E7 stack[-2] // @12F0 stack[-8] // } 12E3 5B JUMPDEST 12E4 50 POP 12E5 60 PUSH1 0x00 12E7 90 SWAP1 12E8 50 POP 12E9 80 DUP1 12EA 60 PUSH1 0x0a 12EC 60 PUSH1 0xff 12EE 60 PUSH1 0xa0 12F0 8A DUP11 12F1 90 SWAP1 12F2 1C SHR 12F3 16 AND 12F4 04 DIV 12F5 60 PUSH1 0xff 12F7 16 AND 12F8 60 PUSH1 0x01 12FA 14 EQ 12FB 62 PUSH3 0x001308 12FF 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @12E7 stack[-2] = 0x00 // @12E9 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x001308, if 0x01 == 0xff & ((stack[-8] >> 0xa0) & 0xff) / 0x0a label_1300: // Incoming jump from 0x12FF, if not 0x01 == 0xff & ((stack[-8] >> 0xa0) & 0xff) / 0x0a // Inputs[1] { @1300 stack[-3] } 1300 82 DUP3 1301 60 PUSH1 0x00 1303 62 PUSH3 0x00130c 1307 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1300 stack[0] = stack[-3] // @1301 stack[1] = 0x00 // } // Block ends with unconditional jump to 0x00130c label_1308: // Incoming jump from 0x12FF, if 0x01 == 0xff & ((stack[-8] >> 0xa0) & 0xff) / 0x0a // Inputs[5] // { // @130B stack[-3] // @130D stack[-1] // @130F stack[-2] // @1311 stack[-7] // @1348 memory[0x40:0x60] // } 1308 5B JUMPDEST 1309 60 PUSH1 0x00 130B 83 DUP4 130C 5B JUMPDEST 130D 91 SWAP2 130E 50 POP 130F 91 SWAP2 1310 50 POP 1311 86 DUP7 1312 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1327 16 AND 1328 63 PUSH4 0x022c0d9f 132D 83 DUP4 132E 83 DUP4 132F 73 PUSH20 0x45544abf5936deb78490d38ec42b80757d16c014 1344 60 PUSH1 0x00 1346 60 PUSH1 0x40 1348 51 MLOAD 1349 90 SWAP1 134A 80 DUP1 134B 82 DUP3 134C 52 MSTORE 134D 80 DUP1 134E 60 PUSH1 0x1f 1350 01 ADD 1351 60 PUSH1 0x1f 1353 19 NOT 1354 16 AND 1355 60 PUSH1 0x20 1357 01 ADD 1358 82 DUP3 1359 01 ADD 135A 60 PUSH1 0x40 135C 52 MSTORE 135D 80 DUP1 135E 15 ISZERO 135F 62 PUSH3 0x001370 1363 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @130D stack[-1] = stack[-3] // @130F stack[-2] = 0x00 // @1327 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @1328 stack[1] = 0x022c0d9f // @132D stack[2] = 0x00 // @132E stack[3] = stack[-3] // @132F stack[4] = 0x45544abf5936deb78490d38ec42b80757d16c014 // @1349 stack[5] = memory[0x40:0x60] // @1349 stack[6] = 0x00 // @134C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @135C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + 0x00) // } // Block ends with conditional jump to 0x001370, if !0x00 label_1364: // Incoming jump from 0x1363, if not !0x00 // Incoming jump from 0x1363, if not !0x00 // Inputs[10] // { // @1366 stack[-2] // @1368 stack[-1] // @136A code.length // @1374 memory[0x40:0x60] // @1375 stack[-6] // @1385 stack[-5] // @138B stack[-4] // @1391 stack[-3] // @13CF memory[stack[-2]:stack[-2] + 0x20] // @13D8 memory[stack[-2]:stack[-2] + 0x20] // } 1364 60 PUSH1 0x20 1366 82 DUP3 1367 01 ADD 1368 81 DUP2 1369 80 DUP1 136A 38 CODESIZE 136B 83 DUP4 136C 39 CODECOPY 136D 01 ADD 136E 90 SWAP1 136F 50 POP 1370 5B JUMPDEST 1371 50 POP 1372 60 PUSH1 0x40 1374 51 MLOAD 1375 85 DUP6 1376 63 PUSH4 0xffffffff 137B 16 AND 137C 60 PUSH1 0xe0 137E 1B SHL 137F 81 DUP2 1380 52 MSTORE 1381 60 PUSH1 0x04 1383 01 ADD 1384 80 DUP1 1385 85 DUP6 1386 81 DUP2 1387 52 MSTORE 1388 60 PUSH1 0x20 138A 01 ADD 138B 84 DUP5 138C 81 DUP2 138D 52 MSTORE 138E 60 PUSH1 0x20 1390 01 ADD 1391 83 DUP4 1392 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13A7 16 AND 13A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13BD 16 AND 13BE 81 DUP2 13BF 52 MSTORE 13C0 60 PUSH1 0x20 13C2 01 ADD 13C3 80 DUP1 13C4 60 PUSH1 0x20 13C6 01 ADD 13C7 82 DUP3 13C8 81 DUP2 13C9 03 SUB 13CA 82 DUP3 13CB 52 MSTORE 13CC 83 DUP4 13CD 81 DUP2 13CE 81 DUP2 13CF 51 MLOAD 13D0 81 DUP2 13D1 52 MSTORE 13D2 60 PUSH1 0x20 13D4 01 ADD 13D5 91 SWAP2 13D6 50 POP 13D7 80 DUP1 13D8 51 MLOAD 13D9 90 SWAP1 13DA 60 PUSH1 0x20 13DC 01 ADD 13DD 90 SWAP1 13DE 80 DUP1 13DF 83 DUP4 13E0 83 DUP4 13E1 60 PUSH1 0x00 13E3 5B JUMPDEST 13E4 83 DUP4 13E5 81 DUP2 13E6 10 LT 13E7 15 ISZERO 13E8 62 PUSH3 0x0013fd 13EC 57 *JUMPI // Stack delta = +8 // Outputs[16] // { // @136C memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @1380 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-6]) << 0xe0 // @1383 stack[-1] = 0x04 + memory[0x40:0x60] // @1387 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @138D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @13BF memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @13C2 stack[0] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @13CB memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @13D1 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @13D5 stack[1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @13DD stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @13DD stack[2] = 0x20 + stack[-2] // @13DE stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @13DF stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @13E0 stack[6] = 0x20 + stack[-2] // @13E1 stack[7] = 0x00 // } // Block ends with conditional jump to 0x0013fd, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_13ED: // Incoming jump from 0x13EC, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x13EC, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x13EC, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @13ED stack[-2] // @13EE stack[-1] // @13F0 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @13F1 stack[-3] // } 13ED 81 DUP2 13EE 81 DUP2 13EF 01 ADD 13F0 51 MLOAD 13F1 83 DUP4 13F2 82 DUP3 13F3 01 ADD 13F4 52 MSTORE 13F5 60 PUSH1 0x20 13F7 01 ADD 13F8 62 PUSH3 0x0013e3 13FC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @13F4 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @13F7 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0013e3 label_13FD: // Incoming jump from 0x13EC, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x13EC, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x13EC, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1402 stack[-6] // @1402 stack[-5] // @1404 stack[-7] // } 13FD 5B JUMPDEST 13FE 50 POP 13FF 50 POP 1400 50 POP 1401 50 POP 1402 90 SWAP1 1403 50 POP 1404 90 SWAP1 1405 81 DUP2 1406 01 ADD 1407 90 SWAP1 1408 60 PUSH1 0x1f 140A 16 AND 140B 80 DUP1 140C 15 ISZERO 140D 62 PUSH3 0x00142b 1411 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1407 stack[-7] = stack[-5] + stack[-7] // @140A stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x00142b, if !(0x1f & stack[-5]) label_1412: // Incoming jump from 0x1411, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1412 stack[-1] // @1413 stack[-2] // @1416 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @142D stack[-8] // @1438 memory[0x40:0x60] // @143F stack[-10] // @1441 address(stack[-10]).code.length // } 1412 80 DUP1 1413 82 DUP3 1414 03 SUB 1415 80 DUP1 1416 51 MLOAD 1417 60 PUSH1 0x01 1419 83 DUP4 141A 60 PUSH1 0x20 141C 03 SUB 141D 61 PUSH2 0x0100 1420 0A EXP 1421 03 SUB 1422 19 NOT 1423 16 AND 1424 81 DUP2 1425 52 MSTORE 1426 60 PUSH1 0x20 1428 01 ADD 1429 91 SWAP2 142A 50 POP 142B 5B JUMPDEST 142C 50 POP 142D 95 SWAP6 142E 50 POP 142F 50 POP 1430 50 POP 1431 50 POP 1432 50 POP 1433 50 POP 1434 60 PUSH1 0x00 1436 60 PUSH1 0x40 1438 51 MLOAD 1439 80 DUP1 143A 83 DUP4 143B 03 SUB 143C 81 DUP2 143D 60 PUSH1 0x00 143F 87 DUP8 1440 80 DUP1 1441 3B EXTCODESIZE 1442 15 ISZERO 1443 80 DUP1 1444 15 ISZERO 1445 62 PUSH3 0x00144e 1449 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1425 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @142D stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @1434 stack[-7] = 0x00 // @1438 stack[-6] = memory[0x40:0x60] // @143B stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @143C stack[-4] = memory[0x40:0x60] // @143D stack[-3] = 0x00 // @143F stack[-2] = stack[-10] // @1442 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x00144e, if !!address(stack[-10]).code.length label_144A: // Incoming jump from 0x1449, if not !!address(stack[-10]).code.length // Incoming jump from 0x1449, if not !!address(stack[-10]).code.length // Inputs[1] { @144D memory[0x00:0x00] } 144A 60 PUSH1 0x00 144C 80 DUP1 144D FD *REVERT // Stack delta = +0 // Outputs[1] { @144D revert(memory[0x00:0x00]); } // Block terminates label_144E: // Incoming jump from 0x1449, if !!address(stack[-10]).code.length // Incoming jump from 0x1449, if !!address(stack[-10]).code.length // Inputs[9] // { // @1450 msg.gas // @1451 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1451 stack[-7] // @1451 stack[-3] // @1451 stack[-5] // @1451 stack[-6] // @1451 stack[-2] // @1451 memory[stack[-4]:stack[-4] + stack[-5]] // @1451 stack[-4] // } 144E 5B JUMPDEST 144F 50 POP 1450 5A GAS 1451 F1 CALL 1452 15 ISZERO 1453 80 DUP1 1454 15 ISZERO 1455 62 PUSH3 0x001463 1459 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1451 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1452 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x001463, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_145A: // Incoming jump from 0x1459, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @145A returndata.length // @145E returndata[0x00:0x00 + returndata.length] // @145F returndata.length // @1462 memory[0x00:0x00 + returndata.length] // } 145A 3D RETURNDATASIZE 145B 60 PUSH1 0x00 145D 80 DUP1 145E 3E RETURNDATACOPY 145F 3D RETURNDATASIZE 1460 60 PUSH1 0x00 1462 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @145E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1462 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1463: // Incoming jump from 0x1459, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @146A stack[-12] } 1463 5B JUMPDEST 1464 50 POP 1465 50 POP 1466 50 POP 1467 50 POP 1468 60 PUSH1 0xfc 146A 88 DUP9 146B 90 SWAP1 146C 1C SHR 146D 15 ISZERO 146E 62 PUSH3 0x001496 1472 57 *JUMPI // Stack delta = -4 // Block ends with conditional jump to 0x001496, if !(stack[-12] >> 0xfc) label_1473: // Incoming jump from 0x1472, if not !(stack[-12] >> 0xfc) // Inputs[1] { @147F stack[-8] } 1473 62 PUSH3 0x001496 1477 60 PUSH1 0x10 1479 62 PUSH3 0xffffff 147D 60 PUSH1 0xe4 147F 8B DUP12 1480 90 SWAP1 1481 1C SHR 1482 16 AND 1483 04 DIV 1484 62 PUSH3 0xffffff 1488 16 AND 1489 60 PUSH1 0xfc 148B 8A DUP11 148C 90 SWAP1 148D 1C SHR 148E 60 PUSH1 0xff 1490 16 AND 1491 62 PUSH3 0x00371c 1495 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1473 stack[0] = 0x001496 // @1488 stack[1] = 0xffffff & ((stack[-8] >> 0xe4) & 0xffffff) / 0x10 // @1490 stack[2] = 0xff & (stack[-8] >> 0xfc) // } // Block ends with call to 0x00371c, returns to 0x1496 label_1496: // Incoming return from call to 0x336D at 0x336B // Incoming jump from 0x1472, if !(stack[-12] >> 0xfc) // Incoming return from call to 0x371C at 0x1495 // Incoming jump from 0x3345, if !((stack[-9] >> 0xe8) & 0x0f) // Inputs[1] { @14A0 stack[-10] } 1496 5B JUMPDEST 1497 50 POP 1498 50 POP 1499 50 POP 149A 50 POP 149B 50 POP 149C 50 POP 149D 50 POP 149E 50 POP 149F 50 POP 14A0 56 *JUMP // Stack delta = -10 // Block ends with unconditional jump to stack[-10] label_14A1: // Incoming jump from 0x02E9 // Inputs[1] { @14A2 msg.sender } 14A1 5B JUMPDEST 14A2 33 CALLER 14A3 73 PUSH20 0xdd07249e403979bd79848c27aa5454c7e66bdee7 14B8 14 EQ 14B9 80 DUP1 14BA 62 PUSH3 0x0014d7 14BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14B8 stack[0] = 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender } // Block ends with conditional jump to 0x0014d7, if 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender label_14BF: // Incoming jump from 0x14BE, if not 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender // Inputs[1] { @14C0 msg.sender } 14BF 50 POP 14C0 33 CALLER 14C1 73 PUSH20 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 14D6 14 EQ 14D7 5B JUMPDEST 14D8 80 DUP1 14D9 62 PUSH3 0x0014f6 14DD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @14D6 stack[-1] = 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender } // Block ends with conditional jump to 0x0014f6, if 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender label_14DE: // Incoming jump from 0x14DD, if not 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender // Incoming jump from 0x14DD, if not stack[-1] // Inputs[1] { @14DF msg.sender } 14DE 50 POP 14DF 33 CALLER 14E0 73 PUSH20 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 14F5 14 EQ 14F6 5B JUMPDEST 14F7 80 DUP1 14F8 62 PUSH3 0x001511 14FC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @14F5 stack[-1] = 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender } // Block ends with conditional jump to 0x001511, if 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender label_14FD: // Incoming jump from 0x14FC, if not stack[-1] // Incoming jump from 0x14FC, if not 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender // Inputs[3] // { // @14FE msg.sender // @150C memory[0x00:0x40] // @150D storage[keccak256(memory[0x00:0x40])] // } 14FD 50 POP 14FE 33 CALLER 14FF 60 PUSH1 0x00 1501 90 SWAP1 1502 81 DUP2 1503 52 MSTORE 1504 60 PUSH1 0x02 1506 60 PUSH1 0x20 1508 52 MSTORE 1509 60 PUSH1 0x40 150B 90 SWAP1 150C 20 SHA3 150D 54 SLOAD 150E 60 PUSH1 0xff 1510 16 AND 1511 5B JUMPDEST 1512 62 PUSH3 0x00151b 1516 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1503 memory[0x00:0x20] = msg.sender // @1508 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x00151b, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1517: // Incoming jump from 0x1516, if not stack[-1] // Incoming jump from 0x1516, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @151A memory[0x00:0x00] } 1517 60 PUSH1 0x00 1519 80 DUP1 151A FD *REVERT // Stack delta = +0 // Outputs[1] { @151A revert(memory[0x00:0x00]); } // Block terminates label_151B: // Incoming jump from 0x1516, if stack[-1] // Incoming jump from 0x1516, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[7] // { // @151F memory[0x40:0x60] // @1543 stack[-2] // @1551 memory[0x40:0x60] // @1563 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1566 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @158A stack[-1] // @1591 address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance // } 151B 5B JUMPDEST 151C 60 PUSH1 0x40 151E 80 DUP1 151F 51 MLOAD 1520 7F PUSH32 0xffffff0000000000000000000000000000000000000000000000000000000000 1541 60 PUSH1 0xe8 1543 85 DUP6 1544 90 SWAP1 1545 1B SHL 1546 16 AND 1547 60 PUSH1 0x20 1549 80 DUP1 154A 83 DUP4 154B 01 ADD 154C 91 SWAP2 154D 90 SWAP1 154E 91 SWAP2 154F 52 MSTORE 1550 82 DUP3 1551 51 MLOAD 1552 80 DUP1 1553 83 DUP4 1554 03 SUB 1555 60 PUSH1 0x03 1557 01 ADD 1558 81 DUP2 1559 52 MSTORE 155A 60 PUSH1 0x23 155C 90 SWAP1 155D 92 SWAP3 155E 01 ADD 155F 90 SWAP1 1560 92 SWAP3 1561 52 MSTORE 1562 80 DUP1 1563 51 MLOAD 1564 91 SWAP2 1565 01 ADD 1566 20 SHA3 1567 82 DUP3 1568 18 XOR 1569 7F PUSH32 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 158A 82 DUP3 158B 18 XOR 158C 60 PUSH1 0x60 158E 81 DUP2 158F 90 SWAP1 1590 1C SHR 1591 31 BALANCE 1592 6B PUSH12 0xffffffffffffffffffffffff 159F 82 DUP3 15A0 16 AND 15A1 14 EQ 15A2 15 ISZERO 15A3 62 PUSH3 0x0015d0 15A7 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @154F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-2] << 0xe8) & 0xffffff0000000000000000000000000000000000000000000000000000000000 // @1559 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1561 memory[0x40:0x60] = memory[0x40:0x60] + 0x23 // @1568 stack[0] = stack[-2] ~ keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @158B stack[1] = stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 // } // Block ends with conditional jump to 0x0015d0, if !((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) & 0xffffffffffffffffffffffff == address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance) label_15A8: // Incoming jump from 0x15A7, if not !((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) & 0xffffffffffffffffffffffff == address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance) // Inputs[1] { @15AA stack[-4] } 15A8 60 PUSH1 0xfc 15AA 84 DUP5 15AB 90 SWAP1 15AC 1C SHR 15AD 15 ISZERO 15AE 62 PUSH3 0x0015c8 15B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0015c8, if !(stack[-4] >> 0xfc) label_15B3: // Incoming jump from 0x15B2, if not !(stack[-4] >> 0xfc) // Inputs[1] { @15BF stack[-4] } 15B3 62 PUSH3 0x0015c8 15B7 60 PUSH1 0x10 15B9 62 PUSH3 0xffffff 15BD 60 PUSH1 0xe4 15BF 87 DUP8 15C0 90 SWAP1 15C1 1C SHR 15C2 16 AND 15C3 62 PUSH3 0x0010c2 15C7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15B3 stack[0] = 0x0015c8 // @15B7 stack[1] = 0x10 // @15C2 stack[2] = (stack[-4] >> 0xe4) & 0xffffff // } // Block ends with call to 0x0010c2, returns to 0x15C8 label_15C8: // Incoming jump from 0x15B2, if !(stack[-4] >> 0xfc) // Incoming return from call to 0x10C2 at 0x15C7 15C8 5B JUMPDEST 15C9 50 POP 15CA 50 POP 15CB 62 PUSH3 0x0010e4 15CF 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x0010e4 label_15D0: // Incoming jump from 0x15A7, if !((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) & 0xffffffffffffffffffffffff == address((stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x60).balance) // Inputs[1] { @15D7 stack[-2] } 15D0 5B JUMPDEST 15D1 62 PUSH3 0x0015f7 15D5 60 PUSH1 0x48 15D7 83 DUP4 15D8 90 SWAP1 15D9 1C SHR 15DA 60 PUSH1 0x40 15DC 84 DUP5 15DD 90 SWAP1 15DE 1C SHR 15DF 60 PUSH1 0x38 15E1 85 DUP6 15E2 90 SWAP1 15E3 1C SHR 15E4 61 PUSH2 0x0fff 15E7 60 PUSH1 0x28 15E9 87 DUP8 15EA 90 SWAP1 15EB 1C SHR 15EC 16 AND 15ED 60 PUSH1 0x18 15EF 87 DUP8 15F0 90 SWAP1 15F1 1C SHR 15F2 62 PUSH3 0x003794 15F6 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @15D1 stack[0] = 0x0015f7 // @15D9 stack[1] = stack[-2] >> 0x48 // @15DE stack[2] = stack[-2] >> 0x40 // @15E3 stack[3] = stack[-2] >> 0x38 // @15EC stack[4] = (stack[-2] >> 0x28) & 0x0fff // @15F1 stack[5] = stack[-2] >> 0x18 // } // Block ends with call to 0x003794, returns to 0x15F7 label_15F7: // Incoming return from call to 0x3794 at 0x15F6 // Incoming return from call to 0x3794 at 0x15F6 // Inputs[1] { @15FA stack[-4] } 15F7 5B JUMPDEST 15F8 60 PUSH1 0xfc 15FA 84 DUP5 15FB 90 SWAP1 15FC 1C SHR 15FD 15 ISZERO 15FE 62 PUSH3 0x001626 1602 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x001626, if !(stack[-4] >> 0xfc) label_1603: // Incoming jump from 0x1602, if not !(stack[-4] >> 0xfc) // Inputs[1] { @160F stack[-4] } 1603 62 PUSH3 0x001626 1607 60 PUSH1 0x10 1609 62 PUSH3 0xffffff 160D 60 PUSH1 0xe4 160F 87 DUP8 1610 90 SWAP1 1611 1C SHR 1612 16 AND 1613 04 DIV 1614 62 PUSH3 0xffffff 1618 16 AND 1619 60 PUSH1 0xfc 161B 86 DUP7 161C 90 SWAP1 161D 1C SHR 161E 60 PUSH1 0xff 1620 16 AND 1621 62 PUSH3 0x00371c 1625 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1603 stack[0] = 0x001626 // @1618 stack[1] = 0xffffff & ((stack[-4] >> 0xe4) & 0xffffff) / 0x10 // @1620 stack[2] = 0xff & (stack[-4] >> 0xfc) // } // Block ends with call to 0x00371c, returns to 0x1626 label_1626: // Incoming jump from 0x1602, if !(stack[-4] >> 0xfc) // Incoming return from call to 0x371C at 0x1625 // Inputs[1] { @162B stack[-5] } 1626 5B JUMPDEST 1627 50 POP 1628 50 POP 1629 50 POP 162A 50 POP 162B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_162C: // Incoming jump from 0x031A // Inputs[4] // { // @162F stack[-1] // @163D memory[0x00:0x40] // @163E storage[keccak256(memory[0x00:0x40])] // @1655 stack[-2] // } 162C 5B JUMPDEST 162D 60 PUSH1 0xff 162F 16 AND 1630 60 PUSH1 0x00 1632 90 SWAP1 1633 81 DUP2 1634 52 MSTORE 1635 60 PUSH1 0x05 1637 60 PUSH1 0x20 1639 52 MSTORE 163A 60 PUSH1 0x40 163C 90 SWAP1 163D 20 SHA3 163E 54 SLOAD 163F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1654 16 AND 1655 90 SWAP1 1656 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1634 memory[0x00:0x20] = 0xff & stack[-1] // @1639 memory[0x20:0x40] = 0x05 // @1655 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1657: // Incoming jump from 0x0397 // Inputs[2] // { // @165A storage[0x01] // @1671 msg.sender // } 1657 5B JUMPDEST 1658 60 PUSH1 0x01 165A 54 SLOAD 165B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1670 16 AND 1671 33 CALLER 1672 14 EQ 1673 62 PUSH3 0x00167c 1677 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00167c, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] label_1678: // Incoming jump from 0x1677, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @167B memory[0x00:0x00] } 1678 60 PUSH1 0x00 167A 80 DUP1 167B FD *REVERT // Stack delta = +0 // Outputs[1] { @167B revert(memory[0x00:0x00]); } // Block terminates label_167C: // Incoming jump from 0x1677, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[7] // { // @1680 memory[0x40:0x60] // @16B6 stack[-3] // @16BE msg.sender // @16C8 stack[-1] // @16CC memory[0x40:0x60] // @16CE stack[-2] // @16E8 address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 167C 5B JUMPDEST 167D 60 PUSH1 0x40 167F 80 DUP1 1680 51 MLOAD 1681 7C PUSH29 0x0200000000000000000000000000000000000000000000000000000000 169F 81 DUP2 16A0 52 MSTORE 16A1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16B6 85 DUP6 16B7 81 DUP2 16B8 16 AND 16B9 60 PUSH1 0x04 16BB 83 DUP4 16BC 01 ADD 16BD 52 MSTORE 16BE 33 CALLER 16BF 60 PUSH1 0x24 16C1 83 DUP4 16C2 01 ADD 16C3 52 MSTORE 16C4 60 PUSH1 0x44 16C6 82 DUP3 16C7 01 ADD 16C8 84 DUP5 16C9 90 SWAP1 16CA 52 MSTORE 16CB 91 SWAP2 16CC 51 MLOAD 16CD 91 SWAP2 16CE 84 DUP5 16CF 16 AND 16D0 91 SWAP2 16D1 60 PUSH1 0x02 16D3 91 SWAP2 16D4 60 PUSH1 0x64 16D6 80 DUP1 16D7 82 DUP3 16D8 01 ADD 16D9 92 SWAP3 16DA 60 PUSH1 0x00 16DC 92 SWAP3 16DD 90 SWAP1 16DE 91 SWAP2 16DF 90 SWAP1 16E0 82 DUP3 16E1 90 SWAP1 16E2 03 SUB 16E3 01 ADD 16E4 81 DUP2 16E5 83 DUP4 16E6 87 DUP8 16E7 80 DUP1 16E8 3B EXTCODESIZE 16E9 15 ISZERO 16EA 80 DUP1 16EB 15 ISZERO 16EC 62 PUSH3 0x0016f5 16F0 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @16A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0200000000000000000000000000000000000000000000000000000000 // @16BD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @16C3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = msg.sender // @16CA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @16D0 stack[0] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @16D3 stack[1] = 0x02 // @16D9 stack[2] = memory[0x40:0x60] + 0x64 // @16DC stack[3] = 0x00 // @16DE stack[4] = memory[0x40:0x60] // @16E3 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @16E4 stack[6] = memory[0x40:0x60] // @16E5 stack[7] = 0x00 // @16E6 stack[8] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @16E9 stack[9] = !address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0016f5, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_16F1: // Incoming jump from 0x16F0, if not !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @16F4 memory[0x00:0x00] } 16F1 60 PUSH1 0x00 16F3 80 DUP1 16F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @16F4 revert(memory[0x00:0x00]); } // Block terminates label_16F5: // Incoming jump from 0x16F0, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[9] // { // @16F7 msg.gas // @16F8 stack[-7] // @16F8 stack[-3] // @16F8 stack[-6] // @16F8 memory[stack[-4]:stack[-4] + stack[-5]] // @16F8 stack[-4] // @16F8 stack[-2] // @16F8 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16F8 stack[-5] // } 16F5 5B JUMPDEST 16F6 50 POP 16F7 5A GAS 16F8 F1 CALL 16F9 15 ISZERO 16FA 80 DUP1 16FB 15 ISZERO 16FC 62 PUSH3 0x00170a 1700 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @16F8 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16F9 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x00170a, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1701: // Incoming jump from 0x1700, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1701 returndata.length // @1705 returndata[0x00:0x00 + returndata.length] // @1706 returndata.length // @1709 memory[0x00:0x00 + returndata.length] // } 1701 3D RETURNDATASIZE 1702 60 PUSH1 0x00 1704 80 DUP1 1705 3E RETURNDATACOPY 1706 3D RETURNDATASIZE 1707 60 PUSH1 0x00 1709 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1705 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1709 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_170A: // Incoming jump from 0x1700, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1712 stack[-8] } 170A 5B JUMPDEST 170B 50 POP 170C 50 POP 170D 50 POP 170E 50 POP 170F 50 POP 1710 50 POP 1711 50 POP 1712 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1713: // Incoming jump from 0x03C5 // Inputs[12] // { // @1716 memory[0x40:0x60] // @1760 stack[-1] // @1766 msg.value // @1767 msg.value // @1768 msg.value // @1769 msg.value // @176A msg.value // @176E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x55] // @176F msg.gas // @1770 memory[msg.value:msg.value + msg.value] // @1770 address(keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x55])).call.gas(msg.gas).value(msg.value)(memory[msg.value:msg.value + msg.value]) // @1774 stack[-2] // } 1713 5B JUMPDEST 1714 60 PUSH1 0x40 1716 51 MLOAD 1717 7F PUSH32 0xff000000000000084e91743124a982076c59f100840000000000000000000000 1738 81 DUP2 1739 52 MSTORE 173A 7F PUSH32 0x17f2c5b31e6ffc755997e952174fc537025e254986b5630bbadd188e008f2e93 175B 60 PUSH1 0x35 175D 82 DUP3 175E 01 ADD 175F 52 MSTORE 1760 81 DUP2 1761 60 PUSH1 0x15 1763 82 DUP3 1764 01 ADD 1765 52 MSTORE 1766 34 CALLVALUE 1767 34 CALLVALUE 1768 34 CALLVALUE 1769 34 CALLVALUE 176A 34 CALLVALUE 176B 60 PUSH1 0x55 176D 86 DUP7 176E 20 SHA3 176F 5A GAS 1770 F1 CALL 1771 50 POP 1772 50 POP 1773 50 POP 1774 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1739 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff000000000000084e91743124a982076c59f100840000000000000000000000 // @175F memory[memory[0x40:0x60] + 0x35:memory[0x40:0x60] + 0x35 + 0x20] = 0x17f2c5b31e6ffc755997e952174fc537025e254986b5630bbadd188e008f2e93 // @1765 memory[memory[0x40:0x60] + 0x15:memory[0x40:0x60] + 0x15 + 0x20] = stack[-1] // @1770 memory[msg.value:msg.value + msg.value] = address(keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x55])).call.gas(msg.gas).value(msg.value)(memory[msg.value:msg.value + msg.value]) // } // Block ends with unconditional jump to stack[-2] label_1775: // Incoming jump from 0x047E // Inputs[2] // { // @1778 storage[0x01] // @178F msg.sender // } 1775 5B JUMPDEST 1776 60 PUSH1 0x01 1778 54 SLOAD 1779 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 178E 16 AND 178F 33 CALLER 1790 14 EQ 1791 62 PUSH3 0x00179a 1795 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00179a, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] label_1796: // Incoming jump from 0x1795, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @1799 memory[0x00:0x00] } 1796 60 PUSH1 0x00 1798 80 DUP1 1799 FD *REVERT // Stack delta = +0 // Outputs[1] { @1799 revert(memory[0x00:0x00]); } // Block terminates label_179A: // Incoming jump from 0x1795, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[2] // { // @179E stack[-2] // @179F memory[stack[-2]:stack[-2] + 0x20] // } 179A 5B JUMPDEST 179B 60 PUSH1 0x00 179D 5B JUMPDEST 179E 82 DUP3 179F 51 MLOAD 17A0 81 DUP2 17A1 10 LT 17A2 15 ISZERO 17A3 62 PUSH3 0x0010e2 17A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @179B stack[0] = 0x00 } // Block ends with conditional jump to 0x0010e2, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_17A8: // Incoming jump from 0x17A7, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x17A7, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @17A8 stack[-2] // @17AD stack[-3] // @17AE stack[-1] // @17B0 memory[stack[-3]:stack[-3] + 0x20] // } 17A8 81 DUP2 17A9 60 PUSH1 0x02 17AB 60 PUSH1 0x00 17AD 85 DUP6 17AE 84 DUP5 17AF 81 DUP2 17B0 51 MLOAD 17B1 81 DUP2 17B2 10 LT 17B3 62 PUSH3 0x0017b9 17B7 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @17A8 stack[0] = stack[-2] // @17A9 stack[1] = 0x02 // @17AB stack[2] = 0x00 // @17AD stack[3] = stack[-3] // @17AE stack[4] = stack[-1] // } // Block ends with conditional jump to 0x0017b9, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_17B8: // Incoming jump from 0x17B7, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 17B8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @17B8 assert(); } // Block terminates label_17B9: // Incoming jump from 0x17B7, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[9] // { // @17BC stack[-1] // @17BF stack[-2] // @17C5 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17DC stack[-3] // @17E0 stack[-4] // @17E9 memory[0x00:0x00 + 0x40 + stack[-3]] // @17EB storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // @180E stack[-5] // @1819 stack[-6] // } 17B9 5B JUMPDEST 17BA 60 PUSH1 0x20 17BC 90 SWAP1 17BD 81 DUP2 17BE 02 MUL 17BF 91 SWAP2 17C0 90 SWAP1 17C1 91 SWAP2 17C2 01 ADD 17C3 81 DUP2 17C4 01 ADD 17C5 51 MLOAD 17C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17DB 16 AND 17DC 82 DUP3 17DD 52 MSTORE 17DE 81 DUP2 17DF 01 ADD 17E0 91 SWAP2 17E1 90 SWAP1 17E2 91 SWAP2 17E3 52 MSTORE 17E4 60 PUSH1 0x40 17E6 01 ADD 17E7 60 PUSH1 0x00 17E9 20 SHA3 17EA 80 DUP1 17EB 54 SLOAD 17EC 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 180D 16 AND 180E 91 SWAP2 180F 15 ISZERO 1810 15 ISZERO 1811 91 SWAP2 1812 90 SWAP1 1813 91 SWAP2 1814 17 OR 1815 90 SWAP1 1816 55 SSTORE 1817 60 PUSH1 0x01 1819 01 ADD 181A 62 PUSH3 0x00179d 181E 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @17DD memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17E3 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // @1816 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] = !!stack[-5] | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])]) // @1819 stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x00179d label_181F: // Incoming call from 0x0496, returns to 0x0497 // Inputs[2] // { // @1822 storage[0x03] // @1823 stack[-1] // } 181F 5B JUMPDEST 1820 60 PUSH1 0x03 1822 54 SLOAD 1823 90 SWAP1 1824 56 *JUMP // Stack delta = +0 // Outputs[1] { @1823 stack[-1] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_1825: // Incoming jump from 0x04D6 // Inputs[2] // { // @1828 storage[0x01] // @183F msg.sender // } 1825 5B JUMPDEST 1826 60 PUSH1 0x01 1828 54 SLOAD 1829 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 183E 16 AND 183F 33 CALLER 1840 14 EQ 1841 62 PUSH3 0x00184a 1845 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00184a, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] label_1846: // Incoming jump from 0x1845, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @1849 memory[0x00:0x00] } 1846 60 PUSH1 0x00 1848 80 DUP1 1849 FD *REVERT // Stack delta = +0 // Outputs[1] { @1849 revert(memory[0x00:0x00]); } // Block terminates label_184A: // Incoming jump from 0x1845, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[4] // { // @184E memory[0x40:0x60] // @1872 address(this) // @1879 memory[0x40:0x60] // @18B0 address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 184A 5B JUMPDEST 184B 60 PUSH1 0x40 184D 80 DUP1 184E 51 MLOAD 184F 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1870 81 DUP2 1871 52 MSTORE 1872 30 ADDRESS 1873 60 PUSH1 0x04 1875 82 DUP3 1876 01 ADD 1877 52 MSTORE 1878 90 SWAP1 1879 51 MLOAD 187A 60 PUSH1 0x00 187C 91 SWAP2 187D 62 PUSH3 0x0018f2 1881 91 SWAP2 1882 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1897 91 SWAP2 1898 63 PUSH4 0x70a08231 189D 91 SWAP2 189E 60 PUSH1 0x24 18A0 80 DUP1 18A1 83 DUP4 18A2 01 ADD 18A3 92 SWAP3 18A4 60 PUSH1 0x20 18A6 92 SWAP3 18A7 91 SWAP2 18A8 90 SWAP1 18A9 82 DUP3 18AA 90 SWAP1 18AB 03 SUB 18AC 01 ADD 18AD 81 DUP2 18AE 86 DUP7 18AF 80 DUP1 18B0 3B EXTCODESIZE 18B1 15 ISZERO 18B2 80 DUP1 18B3 15 ISZERO 18B4 62 PUSH3 0x0018bd 18B8 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @1871 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1877 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @187C stack[0] = 0x00 // @1881 stack[1] = 0x0018f2 // @1897 stack[2] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @189D stack[3] = 0x70a08231 // @18A3 stack[4] = memory[0x40:0x60] + 0x24 // @18A6 stack[5] = 0x20 // @18A7 stack[6] = memory[0x40:0x60] // @18AC stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @18AD stack[8] = memory[0x40:0x60] // @18AE stack[9] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @18B1 stack[10] = !address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional call to 0x0018bd, returns to 0x18F2, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_18B9: // Incoming jump from 0x18B8, if not !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @18BC memory[0x00:0x00] } 18B9 60 PUSH1 0x00 18BB 80 DUP1 18BC FD *REVERT // Stack delta = +0 // Outputs[1] { @18BC revert(memory[0x00:0x00]); } // Block terminates label_18BD: // Incoming call from 0x18B8, returns to 0x18F2, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Incoming call from 0x2AFF, returns to 0x2B04, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[8] // { // @18BF msg.gas // @18C0 stack[-5] // @18C0 stack[-3] // @18C0 stack[-6] // @18C0 stack[-4] // @18C0 stack[-2] // @18C0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @18C0 memory[stack[-3]:stack[-3] + stack[-4]] // } 18BD 5B JUMPDEST 18BE 50 POP 18BF 5A GAS 18C0 FA STATICCALL 18C1 15 ISZERO 18C2 80 DUP1 18C3 15 ISZERO 18C4 62 PUSH3 0x0018d2 18C8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @18C0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @18C1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0018d2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_18C9: // Incoming jump from 0x18C8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @18C9 returndata.length // @18CD returndata[0x00:0x00 + returndata.length] // @18CE returndata.length // @18D1 memory[0x00:0x00 + returndata.length] // } 18C9 3D RETURNDATASIZE 18CA 60 PUSH1 0x00 18CC 80 DUP1 18CD 3E RETURNDATACOPY 18CE 3D RETURNDATASIZE 18CF 60 PUSH1 0x00 18D1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18CD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @18D1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_18D2: // Incoming jump from 0x18C8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @18D9 memory[0x40:0x60] // @18DA returndata.length // } 18D2 5B JUMPDEST 18D3 50 POP 18D4 50 POP 18D5 50 POP 18D6 50 POP 18D7 60 PUSH1 0x40 18D9 51 MLOAD 18DA 3D RETURNDATASIZE 18DB 60 PUSH1 0x20 18DD 81 DUP2 18DE 10 LT 18DF 15 ISZERO 18E0 62 PUSH3 0x0018e9 18E4 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @18D9 stack[-4] = memory[0x40:0x60] // @18DA stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0018e9, if !(returndata.length < 0x20) label_18E5: // Incoming jump from 0x18E4, if not !(returndata.length < 0x20) // Inputs[1] { @18E8 memory[0x00:0x00] } 18E5 60 PUSH1 0x00 18E7 80 DUP1 18E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @18E8 revert(memory[0x00:0x00]); } // Block terminates label_18E9: // Incoming jump from 0x18E4, if !(returndata.length < 0x20) // Inputs[3] // { // @18EB memory[stack[-2]:stack[-2] + 0x20] // @18EB stack[-2] // @18EC stack[-5] // } 18E9 5B JUMPDEST 18EA 50 POP 18EB 51 MLOAD 18EC 83 DUP4 18ED 62 PUSH3 0x003e25 18F1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18EB stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @18EC stack[-1] = stack[-5] // } // Block ends with unconditional jump to 0x003e25 label_18F2: // Incoming return from call to 0x18BD at 0x18B8 // Inputs[5] // { // @18F3 stack[-1] // @18F3 stack[-2] // @1928 memory[0x40:0x60] // @1946 memory[0x40:0x60] // @194F address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 18F2 5B JUMPDEST 18F3 90 SWAP1 18F4 50 POP 18F5 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 190A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 191F 16 AND 1920 63 PUSH4 0x2e1a7d4d 1925 82 DUP3 1926 60 PUSH1 0x40 1928 51 MLOAD 1929 82 DUP3 192A 63 PUSH4 0xffffffff 192F 16 AND 1930 60 PUSH1 0xe0 1932 1B SHL 1933 81 DUP2 1934 52 MSTORE 1935 60 PUSH1 0x04 1937 01 ADD 1938 80 DUP1 1939 82 DUP3 193A 81 DUP2 193B 52 MSTORE 193C 60 PUSH1 0x20 193E 01 ADD 193F 91 SWAP2 1940 50 POP 1941 50 POP 1942 60 PUSH1 0x00 1944 60 PUSH1 0x40 1946 51 MLOAD 1947 80 DUP1 1948 83 DUP4 1949 03 SUB 194A 81 DUP2 194B 60 PUSH1 0x00 194D 87 DUP8 194E 80 DUP1 194F 3B EXTCODESIZE 1950 15 ISZERO 1951 80 DUP1 1952 15 ISZERO 1953 62 PUSH3 0x00195c 1957 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @18F3 stack[-2] = stack[-1] // @191F stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1920 stack[0] = 0x2e1a7d4d // @1934 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2e1a7d4d) << 0xe0 // @193B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @193F stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @1942 stack[2] = 0x00 // @1946 stack[3] = memory[0x40:0x60] // @1949 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @194A stack[5] = memory[0x40:0x60] // @194B stack[6] = 0x00 // @194D stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1950 stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x00195c, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_1958: // Incoming jump from 0x1957, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @195B memory[0x00:0x00] } 1958 60 PUSH1 0x00 195A 80 DUP1 195B FD *REVERT // Stack delta = +0 // Outputs[1] { @195B revert(memory[0x00:0x00]); } // Block terminates label_195C: // Incoming jump from 0x1957, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @195E msg.gas // @195F stack[-2] // @195F stack[-7] // @195F stack[-4] // @195F stack[-6] // @195F memory[stack[-4]:stack[-4] + stack[-5]] // @195F stack[-3] // @195F stack[-5] // @195F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 195C 5B JUMPDEST 195D 50 POP 195E 5A GAS 195F F1 CALL 1960 15 ISZERO 1961 80 DUP1 1962 15 ISZERO 1963 62 PUSH3 0x001971 1967 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @195F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1960 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x001971, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1968: // Incoming jump from 0x1967, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1968 returndata.length // @196C returndata[0x00:0x00 + returndata.length] // @196D returndata.length // @1970 memory[0x00:0x00 + returndata.length] // } 1968 3D RETURNDATASIZE 1969 60 PUSH1 0x00 196B 80 DUP1 196C 3E RETURNDATACOPY 196D 3D RETURNDATASIZE 196E 60 PUSH1 0x00 1970 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @196C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1970 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1971: // Incoming jump from 0x1967, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[7] // { // @1977 storage[0x00] // @197A memory[0x40:0x60] // @1993 stack[-4] // @1995 stack[-5] // @199B stack[-3] // @19A5 address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-5]).value(stack[-5])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @19A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 1971 5B JUMPDEST 1972 50 POP 1973 50 POP 1974 60 PUSH1 0x00 1976 80 DUP1 1977 54 SLOAD 1978 60 PUSH1 0x40 197A 51 MLOAD 197B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1990 90 SWAP1 1991 91 SWAP2 1992 16 AND 1993 93 SWAP4 1994 50 POP 1995 84 DUP5 1996 15 ISZERO 1997 61 PUSH2 0x08fc 199A 02 MUL 199B 92 SWAP3 199C 50 POP 199D 84 DUP5 199E 91 SWAP2 199F 81 DUP2 19A0 81 DUP2 19A1 81 DUP2 19A2 85 DUP6 19A3 88 DUP9 19A4 88 DUP9 19A5 F1 CALL 19A6 93 SWAP4 19A7 50 POP 19A8 50 POP 19A9 50 POP 19AA 50 POP 19AB 15 ISZERO 19AC 80 DUP1 19AD 15 ISZERO 19AE 62 PUSH3 0x0010e2 19B2 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @19A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-5]).value(stack[-5])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @19AB stack[-4] = !address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-5]).value(stack[-5])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0010e2, if !!address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-5]).value(stack[-5])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_19B3: // Incoming jump from 0x19B2, if not !!address(storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !stack[-5]).value(stack[-5])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @19B3 returndata.length // @19B7 returndata[0x00:0x00 + returndata.length] // @19B8 returndata.length // @19BB memory[0x00:0x00 + returndata.length] // } 19B3 3D RETURNDATASIZE 19B4 60 PUSH1 0x00 19B6 80 DUP1 19B7 3E RETURNDATACOPY 19B8 3D RETURNDATASIZE 19B9 60 PUSH1 0x00 19BB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19B7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @19BB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_19BC: // Incoming jump from 0x050A // Inputs[1] { @19BD msg.sender } 19BC 5B JUMPDEST 19BD 33 CALLER 19BE 73 PUSH20 0xdd07249e403979bd79848c27aa5454c7e66bdee7 19D3 14 EQ 19D4 80 DUP1 19D5 62 PUSH3 0x0019f2 19D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19D3 stack[0] = 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender } // Block ends with conditional jump to 0x0019f2, if 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender label_19DA: // Incoming jump from 0x19D9, if not 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender // Inputs[1] { @19DB msg.sender } 19DA 50 POP 19DB 33 CALLER 19DC 73 PUSH20 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 19F1 14 EQ 19F2 5B JUMPDEST 19F3 80 DUP1 19F4 62 PUSH3 0x001a11 19F8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @19F1 stack[-1] = 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender } // Block ends with conditional jump to 0x001a11, if 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender label_19F9: // Incoming jump from 0x19F8, if not stack[-1] // Incoming jump from 0x19F8, if not 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender // Inputs[1] { @19FA msg.sender } 19F9 50 POP 19FA 33 CALLER 19FB 73 PUSH20 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 1A10 14 EQ 1A11 5B JUMPDEST 1A12 80 DUP1 1A13 62 PUSH3 0x001a2c 1A17 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A10 stack[-1] = 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender } // Block ends with conditional jump to 0x001a2c, if 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender label_1A18: // Incoming jump from 0x1A17, if not stack[-1] // Incoming jump from 0x1A17, if not 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender // Inputs[3] // { // @1A19 msg.sender // @1A27 memory[0x00:0x40] // @1A28 storage[keccak256(memory[0x00:0x40])] // } 1A18 50 POP 1A19 33 CALLER 1A1A 60 PUSH1 0x00 1A1C 90 SWAP1 1A1D 81 DUP2 1A1E 52 MSTORE 1A1F 60 PUSH1 0x02 1A21 60 PUSH1 0x20 1A23 52 MSTORE 1A24 60 PUSH1 0x40 1A26 90 SWAP1 1A27 20 SHA3 1A28 54 SLOAD 1A29 60 PUSH1 0xff 1A2B 16 AND 1A2C 5B JUMPDEST 1A2D 62 PUSH3 0x001a36 1A31 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1A1E memory[0x00:0x20] = msg.sender // @1A23 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x001a36, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1A32: // Incoming jump from 0x1A31, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1A31, if not stack[-1] // Inputs[1] { @1A35 memory[0x00:0x00] } 1A32 60 PUSH1 0x00 1A34 80 DUP1 1A35 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A35 revert(memory[0x00:0x00]); } // Block terminates label_1A36: // Incoming jump from 0x1A31, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1A31, if stack[-1] // Inputs[5] // { // @1A3A memory[0x40:0x60] // @1A5E stack[-2] // @1A6C memory[0x40:0x60] // @1A7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1A81 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 1A36 5B JUMPDEST 1A37 60 PUSH1 0x40 1A39 80 DUP1 1A3A 51 MLOAD 1A3B 7F PUSH32 0xffffff0000000000000000000000000000000000000000000000000000000000 1A5C 60 PUSH1 0xe8 1A5E 85 DUP6 1A5F 90 SWAP1 1A60 1B SHL 1A61 16 AND 1A62 60 PUSH1 0x20 1A64 80 DUP1 1A65 83 DUP4 1A66 01 ADD 1A67 91 SWAP2 1A68 90 SWAP1 1A69 91 SWAP2 1A6A 52 MSTORE 1A6B 82 DUP3 1A6C 51 MLOAD 1A6D 80 DUP1 1A6E 83 DUP4 1A6F 03 SUB 1A70 60 PUSH1 0x03 1A72 01 ADD 1A73 81 DUP2 1A74 52 MSTORE 1A75 60 PUSH1 0x23 1A77 90 SWAP1 1A78 92 SWAP3 1A79 01 ADD 1A7A 90 SWAP1 1A7B 92 SWAP3 1A7C 52 MSTORE 1A7D 80 DUP1 1A7E 51 MLOAD 1A7F 91 SWAP2 1A80 01 ADD 1A81 20 SHA3 1A82 82 DUP3 1A83 18 XOR 1A84 60 PUSH1 0x48 1A86 81 DUP2 1A87 90 SWAP1 1A88 1C SHR 1A89 60 PUSH1 0x00 1A8B 62 PUSH3 0x001a9a 1A8F 82 DUP3 1A90 60 PUSH1 0x38 1A92 85 DUP6 1A93 90 SWAP1 1A94 1C SHR 1A95 62 PUSH3 0x003377 1A99 56 *JUMP // Stack delta = +6 // Outputs[9] // { // @1A6A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (stack[-2] << 0xe8) & 0xffffff0000000000000000000000000000000000000000000000000000000000 // @1A74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1A7C memory[0x40:0x60] = memory[0x40:0x60] + 0x23 // @1A83 stack[0] = stack[-2] ~ keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1A88 stack[1] = (stack[-2] ~ keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x48 // @1A89 stack[2] = 0x00 // @1A8B stack[3] = 0x001a9a // @1A8F stack[4] = (stack[-2] ~ keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x48 // @1A94 stack[5] = (stack[-2] ~ keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x38 // } // Block ends with call to 0x003377, returns to 0x1A9A label_1A9A: // Incoming return from call to 0x3377 at 0x1A99 // Inputs[6] // { // @1A9E memory[0x40:0x60] // @1AD7 stack[-1] // @1AE2 stack[-5] // @1AE6 memory[0x40:0x60] // @1AE8 stack[-2] // @1B1B address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 1A9A 5B JUMPDEST 1A9B 60 PUSH1 0x40 1A9D 80 DUP1 1A9E 51 MLOAD 1A9F 7F PUSH32 0xa9059cbb00000000000000000000000000000000000000000000000000000000 1AC0 81 DUP2 1AC1 52 MSTORE 1AC2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AD7 83 DUP4 1AD8 16 AND 1AD9 60 PUSH1 0x04 1ADB 82 DUP3 1ADC 01 ADD 1ADD 52 MSTORE 1ADE 60 PUSH1 0x24 1AE0 81 DUP2 1AE1 01 ADD 1AE2 87 DUP8 1AE3 90 SWAP1 1AE4 52 MSTORE 1AE5 90 SWAP1 1AE6 51 MLOAD 1AE7 91 SWAP2 1AE8 92 SWAP3 1AE9 50 POP 1AEA 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1AFF 91 SWAP2 1B00 63 PUSH4 0xa9059cbb 1B05 91 SWAP2 1B06 60 PUSH1 0x44 1B08 80 DUP1 1B09 82 DUP3 1B0A 01 ADD 1B0B 92 SWAP3 1B0C 60 PUSH1 0x20 1B0E 92 SWAP3 1B0F 90 SWAP1 1B10 91 SWAP2 1B11 90 SWAP1 1B12 82 DUP3 1B13 90 SWAP1 1B14 03 SUB 1B15 01 ADD 1B16 81 DUP2 1B17 60 PUSH1 0x00 1B19 87 DUP8 1B1A 80 DUP1 1B1B 3B EXTCODESIZE 1B1C 15 ISZERO 1B1D 80 DUP1 1B1E 15 ISZERO 1B1F 62 PUSH3 0x001b28 1B23 57 *JUMPI // Stack delta = +9 // Outputs[14] // { // @1AC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000 // @1ADD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @1AE4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-5] // @1AE8 stack[-2] = stack[-1] // @1AFF stack[-1] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1B05 stack[0] = 0xa9059cbb // @1B0B stack[1] = memory[0x40:0x60] + 0x44 // @1B0E stack[2] = 0x20 // @1B10 stack[3] = memory[0x40:0x60] // @1B15 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1B16 stack[5] = memory[0x40:0x60] // @1B17 stack[6] = 0x00 // @1B19 stack[7] = 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1B1C stack[8] = !address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x001b28, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_1B24: // Incoming jump from 0x1B23, if not !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @1B27 memory[0x00:0x00] } 1B24 60 PUSH1 0x00 1B26 80 DUP1 1B27 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B27 revert(memory[0x00:0x00]); } // Block terminates label_1B28: // Incoming jump from 0x1B23, if !!address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @1B2A msg.gas // @1B2B memory[stack[-4]:stack[-4] + stack[-5]] // @1B2B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B2B stack[-5] // @1B2B stack[-4] // @1B2B stack[-7] // @1B2B stack[-3] // @1B2B stack[-6] // @1B2B stack[-2] // } 1B28 5B JUMPDEST 1B29 50 POP 1B2A 5A GAS 1B2B F1 CALL 1B2C 15 ISZERO 1B2D 80 DUP1 1B2E 15 ISZERO 1B2F 62 PUSH3 0x001b3d 1B33 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1B2B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B2C stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x001b3d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1B34: // Incoming jump from 0x1B33, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1B34 returndata.length // @1B38 returndata[0x00:0x00 + returndata.length] // @1B39 returndata.length // @1B3C memory[0x00:0x00 + returndata.length] // } 1B34 3D RETURNDATASIZE 1B35 60 PUSH1 0x00 1B37 80 DUP1 1B38 3E RETURNDATACOPY 1B39 3D RETURNDATASIZE 1B3A 60 PUSH1 0x00 1B3C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B38 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1B3C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1B3D: // Incoming jump from 0x1B33, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1B44 memory[0x40:0x60] // @1B45 returndata.length // } 1B3D 5B JUMPDEST 1B3E 50 POP 1B3F 50 POP 1B40 50 POP 1B41 50 POP 1B42 60 PUSH1 0x40 1B44 51 MLOAD 1B45 3D RETURNDATASIZE 1B46 60 PUSH1 0x20 1B48 81 DUP2 1B49 10 LT 1B4A 15 ISZERO 1B4B 62 PUSH3 0x001b54 1B4F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1B44 stack[-4] = memory[0x40:0x60] // @1B45 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x001b54, if !(returndata.length < 0x20) label_1B50: // Incoming jump from 0x1B4F, if not !(returndata.length < 0x20) // Inputs[1] { @1B53 memory[0x00:0x00] } 1B50 60 PUSH1 0x00 1B52 80 DUP1 1B53 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B53 revert(memory[0x00:0x00]); } // Block terminates label_1B54: // Incoming jump from 0x1B4F, if !(returndata.length < 0x20) // Inputs[3] // { // @1B58 stack[-2] // @1B5F stack[-3] // @1B60 stack[-4] // } 1B54 5B JUMPDEST 1B55 50 POP 1B56 60 PUSH1 0x00 1B58 90 SWAP1 1B59 50 POP 1B5A 80 DUP1 1B5B 62 PUSH3 0x001b66 1B5F 83 DUP4 1B60 85 DUP6 1B61 62 PUSH3 0x00360f 1B65 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1B58 stack[-2] = 0x00 // @1B5A stack[-1] = 0x00 // @1B5B stack[0] = 0x001b66 // @1B5F stack[1] = stack[-3] // @1B60 stack[2] = stack[-4] // } // Block ends with call to 0x00360f, returns to 0x1B66 label_1B66: // Incoming return from call to 0x360F at 0x1B65 // Inputs[5] // { // @1B67 stack[-3] // @1B67 stack[-1] // @1B69 stack[-4] // @1B69 stack[-2] // @1B71 stack[-8] // } 1B66 5B JUMPDEST 1B67 91 SWAP2 1B68 50 POP 1B69 91 SWAP2 1B6A 50 POP 1B6B 60 PUSH1 0x00 1B6D 62 PUSH3 0x001b79 1B71 87 DUP8 1B72 84 DUP5 1B73 84 DUP5 1B74 62 PUSH3 0x0036f2 1B78 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1B67 stack[-3] = stack[-1] // @1B69 stack[-4] = stack[-2] // @1B6B stack[-2] = 0x00 // @1B6D stack[-1] = 0x001b79 // @1B71 stack[0] = stack[-8] // @1B72 stack[1] = stack[-2] // @1B73 stack[2] = stack[-1] // } // Block ends with call to 0x0036f2, returns to 0x1B79 label_1B79: // Incoming return from call to 0x36F2 at 0x1B78 // Inputs[3] // { // @1B7A stack[-2] // @1B7A stack[-1] // @1B94 stack[-6] // } 1B79 5B JUMPDEST 1B7A 90 SWAP1 1B7B 50 POP 1B7C 60 PUSH1 0x00 1B7E 80 DUP1 1B7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B94 87 DUP8 1B95 16 AND 1B96 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1BAB 10 LT 1BAC 62 PUSH3 0x001bb9 1BB0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1B7A stack[-2] = stack[-1] // @1B7C stack[-1] = 0x00 // @1B7E stack[0] = 0x00 // } // Block ends with conditional jump to 0x001bb9, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff label_1BB1: // Incoming jump from 0x1BB0, if not 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1BB1 stack[-3] } 1BB1 82 DUP3 1BB2 60 PUSH1 0x00 1BB4 62 PUSH3 0x001bbd 1BB8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BB1 stack[0] = stack[-3] // @1BB2 stack[1] = 0x00 // } // Block ends with unconditional jump to 0x001bbd label_1BB9: // Incoming jump from 0x1BB0, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[6] // { // @1BBC stack[-3] // @1BBE stack[-1] // @1BC0 stack[-2] // @1BC2 stack[-6] // @1BE0 address(this) // @1BE5 memory[0x40:0x60] // } 1BB9 5B JUMPDEST 1BBA 60 PUSH1 0x00 1BBC 83 DUP4 1BBD 5B JUMPDEST 1BBE 91 SWAP2 1BBF 50 POP 1BC0 91 SWAP2 1BC1 50 POP 1BC2 85 DUP6 1BC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BD8 16 AND 1BD9 63 PUSH4 0x022c0d9f 1BDE 83 DUP4 1BDF 83 DUP4 1BE0 30 ADDRESS 1BE1 60 PUSH1 0x00 1BE3 60 PUSH1 0x40 1BE5 51 MLOAD 1BE6 90 SWAP1 1BE7 80 DUP1 1BE8 82 DUP3 1BE9 52 MSTORE 1BEA 80 DUP1 1BEB 60 PUSH1 0x1f 1BED 01 ADD 1BEE 60 PUSH1 0x1f 1BF0 19 NOT 1BF1 16 AND 1BF2 60 PUSH1 0x20 1BF4 01 ADD 1BF5 82 DUP3 1BF6 01 ADD 1BF7 60 PUSH1 0x40 1BF9 52 MSTORE 1BFA 80 DUP1 1BFB 15 ISZERO 1BFC 62 PUSH3 0x001c0d 1C00 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @1BBE stack[-1] = stack[-3] // @1BC0 stack[-2] = 0x00 // @1BD8 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1BD9 stack[1] = 0x022c0d9f // @1BDE stack[2] = 0x00 // @1BDF stack[3] = stack[-3] // @1BE0 stack[4] = address(this) // @1BE6 stack[5] = memory[0x40:0x60] // @1BE6 stack[6] = 0x00 // @1BE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1BF9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + 0x00) // } // Block ends with conditional jump to 0x001c0d, if !0x00 label_1C01: // Incoming jump from 0x1C00, if not !0x00 // Incoming jump from 0x1C00, if not !0x00 // Inputs[10] // { // @1C03 stack[-2] // @1C05 stack[-1] // @1C07 code.length // @1C11 memory[0x40:0x60] // @1C12 stack[-6] // @1C22 stack[-5] // @1C28 stack[-4] // @1C2E stack[-3] // @1C6C memory[stack[-2]:stack[-2] + 0x20] // @1C75 memory[stack[-2]:stack[-2] + 0x20] // } 1C01 60 PUSH1 0x20 1C03 82 DUP3 1C04 01 ADD 1C05 81 DUP2 1C06 80 DUP1 1C07 38 CODESIZE 1C08 83 DUP4 1C09 39 CODECOPY 1C0A 01 ADD 1C0B 90 SWAP1 1C0C 50 POP 1C0D 5B JUMPDEST 1C0E 50 POP 1C0F 60 PUSH1 0x40 1C11 51 MLOAD 1C12 85 DUP6 1C13 63 PUSH4 0xffffffff 1C18 16 AND 1C19 60 PUSH1 0xe0 1C1B 1B SHL 1C1C 81 DUP2 1C1D 52 MSTORE 1C1E 60 PUSH1 0x04 1C20 01 ADD 1C21 80 DUP1 1C22 85 DUP6 1C23 81 DUP2 1C24 52 MSTORE 1C25 60 PUSH1 0x20 1C27 01 ADD 1C28 84 DUP5 1C29 81 DUP2 1C2A 52 MSTORE 1C2B 60 PUSH1 0x20 1C2D 01 ADD 1C2E 83 DUP4 1C2F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C44 16 AND 1C45 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C5A 16 AND 1C5B 81 DUP2 1C5C 52 MSTORE 1C5D 60 PUSH1 0x20 1C5F 01 ADD 1C60 80 DUP1 1C61 60 PUSH1 0x20 1C63 01 ADD 1C64 82 DUP3 1C65 81 DUP2 1C66 03 SUB 1C67 82 DUP3 1C68 52 MSTORE 1C69 83 DUP4 1C6A 81 DUP2 1C6B 81 DUP2 1C6C 51 MLOAD 1C6D 81 DUP2 1C6E 52 MSTORE 1C6F 60 PUSH1 0x20 1C71 01 ADD 1C72 91 SWAP2 1C73 50 POP 1C74 80 DUP1 1C75 51 MLOAD 1C76 90 SWAP1 1C77 60 PUSH1 0x20 1C79 01 ADD 1C7A 90 SWAP1 1C7B 80 DUP1 1C7C 83 DUP4 1C7D 83 DUP4 1C7E 60 PUSH1 0x00 1C80 5B JUMPDEST 1C81 83 DUP4 1C82 81 DUP2 1C83 10 LT 1C84 15 ISZERO 1C85 62 PUSH3 0x001c9a 1C89 57 *JUMPI // Stack delta = +8 // Outputs[16] // { // @1C09 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @1C1D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-6]) << 0xe0 // @1C20 stack[-1] = 0x04 + memory[0x40:0x60] // @1C24 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @1C2A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @1C5C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1C5F stack[0] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C68 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1C6E memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1C72 stack[1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C7A stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @1C7A stack[2] = 0x20 + stack[-2] // @1C7B stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @1C7C stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C7D stack[6] = 0x20 + stack[-2] // @1C7E stack[7] = 0x00 // } // Block ends with conditional jump to 0x001c9a, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1C8A: // Incoming jump from 0x1C89, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1C89, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1C89, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @1C8A stack[-2] // @1C8B stack[-1] // @1C8D memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1C8E stack[-3] // } 1C8A 81 DUP2 1C8B 81 DUP2 1C8C 01 ADD 1C8D 51 MLOAD 1C8E 83 DUP4 1C8F 82 DUP3 1C90 01 ADD 1C91 52 MSTORE 1C92 60 PUSH1 0x20 1C94 01 ADD 1C95 62 PUSH3 0x001c80 1C99 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C91 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1C94 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x001c80 label_1C9A: // Incoming jump from 0x1C89, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1C89, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1C89, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1C9F stack[-6] // @1C9F stack[-5] // @1CA1 stack[-7] // } 1C9A 5B JUMPDEST 1C9B 50 POP 1C9C 50 POP 1C9D 50 POP 1C9E 50 POP 1C9F 90 SWAP1 1CA0 50 POP 1CA1 90 SWAP1 1CA2 81 DUP2 1CA3 01 ADD 1CA4 90 SWAP1 1CA5 60 PUSH1 0x1f 1CA7 16 AND 1CA8 80 DUP1 1CA9 15 ISZERO 1CAA 62 PUSH3 0x001cc8 1CAE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1CA4 stack[-7] = stack[-5] + stack[-7] // @1CA7 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x001cc8, if !(0x1f & stack[-5]) label_1CAF: // Incoming jump from 0x1CAE, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1CAF stack[-1] // @1CB0 stack[-2] // @1CB3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1CCA stack[-8] // @1CD5 memory[0x40:0x60] // @1CDC stack[-10] // @1CDE address(stack[-10]).code.length // } 1CAF 80 DUP1 1CB0 82 DUP3 1CB1 03 SUB 1CB2 80 DUP1 1CB3 51 MLOAD 1CB4 60 PUSH1 0x01 1CB6 83 DUP4 1CB7 60 PUSH1 0x20 1CB9 03 SUB 1CBA 61 PUSH2 0x0100 1CBD 0A EXP 1CBE 03 SUB 1CBF 19 NOT 1CC0 16 AND 1CC1 81 DUP2 1CC2 52 MSTORE 1CC3 60 PUSH1 0x20 1CC5 01 ADD 1CC6 91 SWAP2 1CC7 50 POP 1CC8 5B JUMPDEST 1CC9 50 POP 1CCA 95 SWAP6 1CCB 50 POP 1CCC 50 POP 1CCD 50 POP 1CCE 50 POP 1CCF 50 POP 1CD0 50 POP 1CD1 60 PUSH1 0x00 1CD3 60 PUSH1 0x40 1CD5 51 MLOAD 1CD6 80 DUP1 1CD7 83 DUP4 1CD8 03 SUB 1CD9 81 DUP2 1CDA 60 PUSH1 0x00 1CDC 87 DUP8 1CDD 80 DUP1 1CDE 3B EXTCODESIZE 1CDF 15 ISZERO 1CE0 80 DUP1 1CE1 15 ISZERO 1CE2 62 PUSH3 0x001ceb 1CE6 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1CC2 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1CCA stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @1CD1 stack[-7] = 0x00 // @1CD5 stack[-6] = memory[0x40:0x60] // @1CD8 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1CD9 stack[-4] = memory[0x40:0x60] // @1CDA stack[-3] = 0x00 // @1CDC stack[-2] = stack[-10] // @1CDF stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x001ceb, if !!address(stack[-10]).code.length label_1CE7: // Incoming jump from 0x1CE6, if not !!address(stack[-10]).code.length // Incoming jump from 0x1CE6, if not !!address(stack[-10]).code.length // Inputs[1] { @1CEA memory[0x00:0x00] } 1CE7 60 PUSH1 0x00 1CE9 80 DUP1 1CEA FD *REVERT // Stack delta = +0 // Outputs[1] { @1CEA revert(memory[0x00:0x00]); } // Block terminates label_1CEB: // Incoming jump from 0x1CE6, if !!address(stack[-10]).code.length // Incoming jump from 0x1CE6, if !!address(stack[-10]).code.length // Inputs[9] // { // @1CED msg.gas // @1CEE stack[-6] // @1CEE stack[-4] // @1CEE address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1CEE stack[-3] // @1CEE memory[stack[-4]:stack[-4] + stack[-5]] // @1CEE stack[-5] // @1CEE stack[-2] // @1CEE stack[-7] // } 1CEB 5B JUMPDEST 1CEC 50 POP 1CED 5A GAS 1CEE F1 CALL 1CEF 15 ISZERO 1CF0 80 DUP1 1CF1 15 ISZERO 1CF2 62 PUSH3 0x001d00 1CF6 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1CEE memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1CEF stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x001d00, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1CF7: // Incoming jump from 0x1CF6, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1CF7 returndata.length // @1CFB returndata[0x00:0x00 + returndata.length] // @1CFC returndata.length // @1CFF memory[0x00:0x00 + returndata.length] // } 1CF7 3D RETURNDATASIZE 1CF8 60 PUSH1 0x00 1CFA 80 DUP1 1CFB 3E RETURNDATACOPY 1CFC 3D RETURNDATASIZE 1CFD 60 PUSH1 0x00 1CFF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CFB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1CFF revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D00: // Incoming jump from 0x1CF6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[7] // { // @1D06 memory[0x40:0x60] // @1D2A address(this) // @1D31 memory[0x40:0x60] // @1D34 stack[-4] // @1D4B stack[-11] // @1D4D stack[-3] // @1D68 address(stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1D00 5B JUMPDEST 1D01 50 POP 1D02 50 POP 1D03 60 PUSH1 0x40 1D05 80 DUP1 1D06 51 MLOAD 1D07 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1D28 81 DUP2 1D29 52 MSTORE 1D2A 30 ADDRESS 1D2B 60 PUSH1 0x04 1D2D 82 DUP3 1D2E 01 ADD 1D2F 52 MSTORE 1D30 90 SWAP1 1D31 51 MLOAD 1D32 60 PUSH1 0x01 1D34 93 SWAP4 1D35 50 POP 1D36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D4B 8B DUP12 1D4C 16 AND 1D4D 92 SWAP3 1D4E 50 POP 1D4F 63 PUSH4 0x70a08231 1D54 91 SWAP2 1D55 60 PUSH1 0x24 1D57 80 DUP1 1D58 82 DUP3 1D59 01 ADD 1D5A 92 SWAP3 1D5B 60 PUSH1 0x20 1D5D 92 SWAP3 1D5E 90 SWAP1 1D5F 91 SWAP2 1D60 90 SWAP1 1D61 82 DUP3 1D62 90 SWAP1 1D63 03 SUB 1D64 01 ADD 1D65 81 DUP2 1D66 86 DUP7 1D67 80 DUP1 1D68 3B EXTCODESIZE 1D69 15 ISZERO 1D6A 80 DUP1 1D6B 15 ISZERO 1D6C 62 PUSH3 0x001d75 1D70 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @1D29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1D2F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1D34 stack[-4] = 0x01 // @1D4D stack[-3] = stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff // @1D54 stack[-2] = 0x70a08231 // @1D5A stack[-1] = memory[0x40:0x60] + 0x24 // @1D5D stack[0] = 0x20 // @1D5F stack[1] = memory[0x40:0x60] // @1D64 stack[2] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1D65 stack[3] = memory[0x40:0x60] // @1D66 stack[4] = stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff // @1D69 stack[5] = !address(stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x001d75, if !!address(stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1D71: // Incoming jump from 0x1D70, if not !!address(stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1D74 memory[0x00:0x00] } 1D71 60 PUSH1 0x00 1D73 80 DUP1 1D74 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D74 revert(memory[0x00:0x00]); } // Block terminates label_1D75: // Incoming jump from 0x1D70, if !!address(stack[-11] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @1D77 msg.gas // @1D78 stack[-5] // @1D78 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1D78 memory[stack[-3]:stack[-3] + stack[-4]] // @1D78 stack[-3] // @1D78 stack[-4] // @1D78 stack[-6] // @1D78 stack[-2] // } 1D75 5B JUMPDEST 1D76 50 POP 1D77 5A GAS 1D78 FA STATICCALL 1D79 15 ISZERO 1D7A 80 DUP1 1D7B 15 ISZERO 1D7C 62 PUSH3 0x001d8a 1D80 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1D78 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1D79 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x001d8a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1D81: // Incoming jump from 0x1D80, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1D81 returndata.length // @1D85 returndata[0x00:0x00 + returndata.length] // @1D86 returndata.length // @1D89 memory[0x00:0x00 + returndata.length] // } 1D81 3D RETURNDATASIZE 1D82 60 PUSH1 0x00 1D84 80 DUP1 1D85 3E RETURNDATACOPY 1D86 3D RETURNDATASIZE 1D87 60 PUSH1 0x00 1D89 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D85 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1D89 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D8A: // Incoming jump from 0x1D80, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1D91 memory[0x40:0x60] // @1D92 returndata.length // } 1D8A 5B JUMPDEST 1D8B 50 POP 1D8C 50 POP 1D8D 50 POP 1D8E 50 POP 1D8F 60 PUSH1 0x40 1D91 51 MLOAD 1D92 3D RETURNDATASIZE 1D93 60 PUSH1 0x20 1D95 81 DUP2 1D96 10 LT 1D97 15 ISZERO 1D98 62 PUSH3 0x001da1 1D9C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D91 stack[-4] = memory[0x40:0x60] // @1D92 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x001da1, if !(returndata.length < 0x20) label_1D9D: // Incoming jump from 0x1D9C, if not !(returndata.length < 0x20) // Inputs[1] { @1DA0 memory[0x00:0x00] } 1D9D 60 PUSH1 0x00 1D9F 80 DUP1 1DA0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DA0 revert(memory[0x00:0x00]); } // Block terminates label_1DA1: // Incoming jump from 0x1D9C, if !(returndata.length < 0x20) // Inputs[3] // { // @1DA3 stack[-2] // @1DA3 memory[stack[-2]:stack[-2] + 0x20] // @1DA4 stack[-3] // } 1DA1 5B JUMPDEST 1DA2 50 POP 1DA3 51 MLOAD 1DA4 11 GT 1DA5 62 PUSH3 0x000f96 1DA9 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x000f96, if memory[stack[-2]:stack[-2] + 0x20] > stack[-3] label_1DAA: // Incoming jump from 0x1DA9, if not memory[stack[-2]:stack[-2] + 0x20] > stack[-3] // Inputs[3] // { // @1DAD memory[0x40:0x60] // @1E06 memory[0x40:0x60] // @1E0F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1DAA 60 PUSH1 0x40 1DAC 80 DUP1 1DAD 51 MLOAD 1DAE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1DCF 81 DUP2 1DD0 52 MSTORE 1DD1 60 PUSH1 0x20 1DD3 60 PUSH1 0x04 1DD5 82 DUP3 1DD6 01 ADD 1DD7 52 MSTORE 1DD8 60 PUSH1 0x03 1DDA 60 PUSH1 0x24 1DDC 82 DUP3 1DDD 01 ADD 1DDE 52 MSTORE 1DDF 7F PUSH32 0x4e54460000000000000000000000000000000000000000000000000000000000 1E00 60 PUSH1 0x44 1E02 82 DUP3 1E03 01 ADD 1E04 52 MSTORE 1E05 90 SWAP1 1E06 51 MLOAD 1E07 90 SWAP1 1E08 81 DUP2 1E09 90 SWAP1 1E0A 03 SUB 1E0B 60 PUSH1 0x64 1E0D 01 ADD 1E0E 90 SWAP1 1E0F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1DD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1DD7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DDE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1E04 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e54460000000000000000000000000000000000000000000000000000000000 // @1E0F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1E10: // Incoming jump from 0x053B // Inputs[2] // { // @1E13 storage[0x01] // @1E2A msg.sender // } 1E10 5B JUMPDEST 1E11 60 PUSH1 0x01 1E13 54 SLOAD 1E14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E29 16 AND 1E2A 33 CALLER 1E2B 14 EQ 1E2C 62 PUSH3 0x001e35 1E30 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x001e35, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] label_1E31: // Incoming jump from 0x1E30, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @1E34 memory[0x00:0x00] } 1E31 60 PUSH1 0x00 1E33 80 DUP1 1E34 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E34 revert(memory[0x00:0x00]); } // Block terminates label_1E35: // Incoming jump from 0x1E30, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @1E38 stack[-1] } 1E35 5B JUMPDEST 1E36 60 PUSH1 0x00 1E38 81 DUP2 1E39 60 PUSH1 0xff 1E3B 16 AND 1E3C 11 GT 1E3D 62 PUSH3 0x001e46 1E41 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x001e46, if 0xff & stack[-1] > 0x00 label_1E42: // Incoming jump from 0x1E41, if not 0xff & stack[-1] > 0x00 // Inputs[1] { @1E45 memory[0x00:0x00] } 1E42 60 PUSH1 0x00 1E44 80 DUP1 1E45 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E45 revert(memory[0x00:0x00]); } // Block terminates label_1E46: // Incoming jump from 0x1E41, if 0xff & stack[-1] > 0x00 // Inputs[1] { @1E4B memory[0x40:0x60] } 1E46 5B JUMPDEST 1E47 60 PUSH1 0x00 1E49 60 PUSH1 0x40 1E4B 51 MLOAD 1E4C 62 PUSH3 0x001e56 1E50 90 SWAP1 1E51 62 PUSH3 0x0040f0 1E55 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E47 stack[0] = 0x00 // @1E50 stack[1] = 0x001e56 // @1E50 stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x0040f0, returns to 0x1E56 label_1E56: // Incoming return from call to 0x40F0 at 0x1E55 // Inputs[4] // { // @1E59 memory[0x40:0x60] // @1E5B stack[-1] // @1E60 new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() // @1E60 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1E56 5B JUMPDEST 1E57 60 PUSH1 0x40 1E59 51 MLOAD 1E5A 80 DUP1 1E5B 91 SWAP2 1E5C 03 SUB 1E5D 90 SWAP1 1E5E 60 PUSH1 0x00 1E60 F0 CREATE 1E61 80 DUP1 1E62 15 ISZERO 1E63 80 DUP1 1E64 15 ISZERO 1E65 62 PUSH3 0x001e73 1E69 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1E60 new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() // @1E60 stack[-1] = new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() // @1E62 stack[0] = !new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() // } // Block ends with conditional jump to 0x001e73, if !!new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() label_1E6A: // Incoming jump from 0x1E69, if not !!new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() // Inputs[4] // { // @1E6A returndata.length // @1E6E returndata[0x00:0x00 + returndata.length] // @1E6F returndata.length // @1E72 memory[0x00:0x00 + returndata.length] // } 1E6A 3D RETURNDATASIZE 1E6B 60 PUSH1 0x00 1E6D 80 DUP1 1E6E 3E RETURNDATACOPY 1E6F 3D RETURNDATASIZE 1E70 60 PUSH1 0x00 1E72 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E6E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1E72 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1E73: // Incoming jump from 0x1E69, if !!new(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]).value(0x00)() // Inputs[6] // { // @1E77 stack[-4] // @1E78 stack[-2] // @1E88 memory[0x00:0x40] // @1E8A storage[keccak256(memory[0x00:0x40])] // @1EC9 stack[-3] // @1ECD stack[-5] // } 1E73 5B JUMPDEST 1E74 50 POP 1E75 60 PUSH1 0xff 1E77 92 SWAP3 1E78 90 SWAP1 1E79 92 SWAP3 1E7A 16 AND 1E7B 60 PUSH1 0x00 1E7D 90 SWAP1 1E7E 81 DUP2 1E7F 52 MSTORE 1E80 60 PUSH1 0x05 1E82 60 PUSH1 0x20 1E84 52 MSTORE 1E85 60 PUSH1 0x40 1E87 90 SWAP1 1E88 20 SHA3 1E89 80 DUP1 1E8A 54 SLOAD 1E8B 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 1EAC 16 AND 1EAD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EC2 90 SWAP1 1EC3 93 SWAP4 1EC4 16 AND 1EC5 92 SWAP3 1EC6 90 SWAP1 1EC7 92 SWAP3 1EC8 17 OR 1EC9 90 SWAP1 1ECA 91 SWAP2 1ECB 55 SSTORE 1ECC 50 POP 1ECD 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1E7F memory[0x00:0x20] = 0xff & stack[-4] // @1E84 memory[0x20:0x40] = 0x05 // @1ECB storage[keccak256(memory[0x00:0x40])] = (stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-5] label_1ECE: // Incoming jump from 0x0569 // Inputs[2] // { // @1ED1 storage[0x01] // @1EE8 msg.sender // } 1ECE 5B JUMPDEST 1ECF 60 PUSH1 0x01 1ED1 54 SLOAD 1ED2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EE7 16 AND 1EE8 33 CALLER 1EE9 14 EQ 1EEA 62 PUSH3 0x001ef3 1EEE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x001ef3, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] label_1EEF: // Incoming jump from 0x1EEE, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @1EF2 memory[0x00:0x00] } 1EEF 60 PUSH1 0x00 1EF1 80 DUP1 1EF2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF2 revert(memory[0x00:0x00]); } // Block terminates label_1EF3: // Incoming jump from 0x1EEE, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[3] // { // @1EFA address(this) // @1EFA address(this).balance // @1EFB stack[-1] // } 1EF3 5B JUMPDEST 1EF4 60 PUSH1 0x00 1EF6 62 PUSH3 0x001f01 1EFA 47 SELFBALANCE 1EFB 83 DUP4 1EFC 62 PUSH3 0x003e25 1F00 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EF4 stack[0] = 0x00 // @1EF6 stack[1] = 0x001f01 // @1EFA stack[2] = address(this).balance // @1EFB stack[3] = stack[-1] // } // Block ends with call to 0x003e25, returns to 0x1F01 label_1F01: // Incoming return from call to 0x3E25 at 0x1F00 // Inputs[6] // { // @1F05 storage[0x00] // @1F08 memory[0x40:0x60] // @1F09 stack[-1] // @1F0A stack[-2] // @1F33 address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x00]).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @1F33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 1F01 5B JUMPDEST 1F02 60 PUSH1 0x00 1F04 80 DUP1 1F05 54 SLOAD 1F06 60 PUSH1 0x40 1F08 51 MLOAD 1F09 92 SWAP3 1F0A 93 SWAP4 1F0B 50 POP 1F0C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F21 16 AND 1F22 91 SWAP2 1F23 83 DUP4 1F24 15 ISZERO 1F25 61 PUSH2 0x08fc 1F28 02 MUL 1F29 91 SWAP2 1F2A 84 DUP5 1F2B 91 SWAP2 1F2C 90 SWAP1 1F2D 81 DUP2 1F2E 81 DUP2 1F2F 81 DUP2 1F30 85 DUP6 1F31 88 DUP9 1F32 88 DUP9 1F33 F1 CALL 1F34 93 SWAP4 1F35 50 POP 1F36 50 POP 1F37 50 POP 1F38 50 POP 1F39 15 ISZERO 1F3A 80 DUP1 1F3B 15 ISZERO 1F3C 62 PUSH3 0x0010e2 1F40 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1F0A stack[-2] = stack[-1] // @1F33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x00]).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @1F39 stack[-1] = !address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x00]).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0010e2, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x00]).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_1F41: // Incoming jump from 0x1F40, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x00]).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @1F41 returndata.length // @1F45 returndata[0x00:0x00 + returndata.length] // @1F46 returndata.length // @1F49 memory[0x00:0x00 + returndata.length] // } 1F41 3D RETURNDATASIZE 1F42 60 PUSH1 0x00 1F44 80 DUP1 1F45 3E RETURNDATACOPY 1F46 3D RETURNDATASIZE 1F47 60 PUSH1 0x00 1F49 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1F45 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1F49 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1F4A: // Incoming call from 0x0581, returns to 0x031B // Inputs[2] // { // @1F4D storage[0x01] // @1F64 stack[-1] // } 1F4A 5B JUMPDEST 1F4B 60 PUSH1 0x01 1F4D 54 SLOAD 1F4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F63 16 AND 1F64 81 DUP2 1F65 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F63 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] } // Block ends with unconditional jump to stack[-1] label_1F66: // Incoming call from 0x058B, returns to 0x01F6 // Inputs[4] // { // @1F97 msg.value // @1F9A memory[0x40:0x60] // @1FAE memory[0x40:0x60] // @1FB6 address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 1F66 5B JUMPDEST 1F67 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1F7C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F91 16 AND 1F92 63 PUSH4 0xd0e30db0 1F97 34 CALLVALUE 1F98 60 PUSH1 0x40 1F9A 51 MLOAD 1F9B 82 DUP3 1F9C 63 PUSH4 0xffffffff 1FA1 16 AND 1FA2 60 PUSH1 0xe0 1FA4 1B SHL 1FA5 81 DUP2 1FA6 52 MSTORE 1FA7 60 PUSH1 0x04 1FA9 01 ADD 1FAA 60 PUSH1 0x00 1FAC 60 PUSH1 0x40 1FAE 51 MLOAD 1FAF 80 DUP1 1FB0 83 DUP4 1FB1 03 SUB 1FB2 81 DUP2 1FB3 85 DUP6 1FB4 88 DUP9 1FB5 80 DUP1 1FB6 3B EXTCODESIZE 1FB7 15 ISZERO 1FB8 80 DUP1 1FB9 15 ISZERO 1FBA 62 PUSH3 0x001fc3 1FBE 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @1F91 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1F92 stack[1] = 0xd0e30db0 // @1F97 stack[2] = msg.value // @1FA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd0e30db0) << 0xe0 // @1FA9 stack[3] = 0x04 + memory[0x40:0x60] // @1FAA stack[4] = 0x00 // @1FAE stack[5] = memory[0x40:0x60] // @1FB1 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1FB2 stack[7] = memory[0x40:0x60] // @1FB3 stack[8] = msg.value // @1FB4 stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1FB7 stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x001fc3, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_1FBF: // Incoming jump from 0x1FBE, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @1FC2 memory[0x00:0x00] } 1FBF 60 PUSH1 0x00 1FC1 80 DUP1 1FC2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FC2 revert(memory[0x00:0x00]); } // Block terminates label_1FC3: // Incoming jump from 0x21F2, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Incoming jump from 0x1FBE, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @1FC5 msg.gas // @1FC6 stack[-6] // @1FC6 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1FC6 stack[-5] // @1FC6 stack[-3] // @1FC6 stack[-2] // @1FC6 memory[stack[-4]:stack[-4] + stack[-5]] // @1FC6 stack[-4] // @1FC6 stack[-7] // } 1FC3 5B JUMPDEST 1FC4 50 POP 1FC5 5A GAS 1FC6 F1 CALL 1FC7 15 ISZERO 1FC8 80 DUP1 1FC9 15 ISZERO 1FCA 62 PUSH3 0x001fd8 1FCE 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1FC6 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1FC7 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x001fd8, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1FCF: // Incoming jump from 0x1FCE, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1FCF returndata.length // @1FD3 returndata[0x00:0x00 + returndata.length] // @1FD4 returndata.length // @1FD7 memory[0x00:0x00 + returndata.length] // } 1FCF 3D RETURNDATASIZE 1FD0 60 PUSH1 0x00 1FD2 80 DUP1 1FD3 3E RETURNDATACOPY 1FD4 3D RETURNDATASIZE 1FD5 60 PUSH1 0x00 1FD7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1FD3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1FD7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1FD8: // Incoming jump from 0x306B, if !(0x00 < stack[-3]) // Incoming jump from 0x1FCE, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Incoming jump from 0x3779, if !(stack[-2] < stack[-2] + stack[-1]) // Incoming jump from 0x2897, if returndata.length == 0x00 // Incoming jump from 0x388E // Incoming jump from 0x3AAD // Incoming jump from 0x306B, if !(stack[-1] < stack[-4]) // Incoming jump from 0x37C5 // Incoming jump from 0x3779, if !(stack[-5] < stack[-3]) // Incoming jump from 0x28B9 // Inputs[1] { @1FDE stack[-6] } 1FD8 5B JUMPDEST 1FD9 50 POP 1FDA 50 POP 1FDB 50 POP 1FDC 50 POP 1FDD 50 POP 1FDE 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1FDF: // Incoming jump from 0x05CF // Inputs[2] // { // @1FE2 storage[0x00] // @1FF9 msg.sender // } 1FDF 5B JUMPDEST 1FE0 60 PUSH1 0x00 1FE2 54 SLOAD 1FE3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FF8 16 AND 1FF9 33 CALLER 1FFA 14 EQ 1FFB 62 PUSH3 0x002004 1FFF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x002004, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] label_2000: // Incoming jump from 0x1FFF, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] // Inputs[1] { @2003 memory[0x00:0x00] } 2000 60 PUSH1 0x00 2002 80 DUP1 2003 FD *REVERT // Stack delta = +0 // Outputs[1] { @2003 revert(memory[0x00:0x00]); } // Block terminates label_2004: // Incoming jump from 0x1FFF, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] // Inputs[1] { @201A stack[-1] } 2004 5B JUMPDEST 2005 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 201A 81 DUP2 201B 16 AND 201C 62 PUSH3 0x002025 2020 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x002025, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_2021: // Incoming jump from 0x2020, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @2024 memory[0x00:0x00] } 2021 60 PUSH1 0x00 2023 80 DUP1 2024 FD *REVERT // Stack delta = +0 // Outputs[1] { @2024 revert(memory[0x00:0x00]); } // Block terminates label_2025: // Incoming jump from 0x2020, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @2029 storage[0x00] // @2061 stack[-1] // @206B stack[-2] // } 2025 5B JUMPDEST 2026 60 PUSH1 0x00 2028 80 DUP1 2029 54 SLOAD 202A 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 204B 16 AND 204C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2061 92 SWAP3 2062 90 SWAP1 2063 92 SWAP3 2064 16 AND 2065 91 SWAP2 2066 90 SWAP1 2067 91 SWAP2 2068 17 OR 2069 90 SWAP1 206A 55 SSTORE 206B 56 *JUMP // Stack delta = -2 // Outputs[1] { @206A storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & storage[0x00]) } // Block ends with unconditional jump to stack[-2] label_206C: // Incoming jump from 0x05FD // Inputs[1] { @206D msg.sender } 206C 5B JUMPDEST 206D 33 CALLER 206E 73 PUSH20 0xdd07249e403979bd79848c27aa5454c7e66bdee7 2083 14 EQ 2084 80 DUP1 2085 62 PUSH3 0x0020a2 2089 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2083 stack[0] = 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender } // Block ends with conditional jump to 0x0020a2, if 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender label_208A: // Incoming jump from 0x2089, if not 0xdd07249e403979bd79848c27aa5454c7e66bdee7 == msg.sender // Inputs[1] { @208B msg.sender } 208A 50 POP 208B 33 CALLER 208C 73 PUSH20 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 20A1 14 EQ 20A2 5B JUMPDEST 20A3 80 DUP1 20A4 62 PUSH3 0x0020c1 20A8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20A1 stack[-1] = 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender } // Block ends with conditional jump to 0x0020c1, if 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender label_20A9: // Incoming jump from 0x20A8, if not stack[-1] // Incoming jump from 0x20A8, if not 0xe73c1e4d7992a4a4f19f31531ae7b5dc352b74b0 == msg.sender // Inputs[1] { @20AA msg.sender } 20A9 50 POP 20AA 33 CALLER 20AB 73 PUSH20 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 20C0 14 EQ 20C1 5B JUMPDEST 20C2 80 DUP1 20C3 62 PUSH3 0x0020dc 20C7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20C0 stack[-1] = 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender } // Block ends with conditional jump to 0x0020dc, if 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender label_20C8: // Incoming jump from 0x20C7, if not 0xdae238a5d94a39e10594fe4a7f96ef4b83c01899 == msg.sender // Incoming jump from 0x20C7, if not stack[-1] // Inputs[3] // { // @20C9 msg.sender // @20D7 memory[0x00:0x40] // @20D8 storage[keccak256(memory[0x00:0x40])] // } 20C8 50 POP 20C9 33 CALLER 20CA 60 PUSH1 0x00 20CC 90 SWAP1 20CD 81 DUP2 20CE 52 MSTORE 20CF 60 PUSH1 0x02 20D1 60 PUSH1 0x20 20D3 52 MSTORE 20D4 60 PUSH1 0x40 20D6 90 SWAP1 20D7 20 SHA3 20D8 54 SLOAD 20D9 60 PUSH1 0xff 20DB 16 AND 20DC 5B JUMPDEST 20DD 62 PUSH3 0x0020e6 20E1 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @20CE memory[0x00:0x20] = msg.sender // @20D3 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0020e6, if 0xff & storage[keccak256(memory[0x00:0x40])] label_20E2: // Incoming jump from 0x20E1, if not stack[-1] // Incoming jump from 0x20E1, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @20E5 memory[0x00:0x00] } 20E2 60 PUSH1 0x00 20E4 80 DUP1 20E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20E5 revert(memory[0x00:0x00]); } // Block terminates label_20E6: // Incoming jump from 0x20E1, if stack[-1] // Incoming jump from 0x20E1, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[5] // { // @20EA memory[0x40:0x60] // @20ED stack[-1] // @211C memory[0x40:0x60] // @212D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2130 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 20E6 5B JUMPDEST 20E7 60 PUSH1 0x40 20E9 80 DUP1 20EA 51 MLOAD 20EB 60 PUSH1 0xe8 20ED 83 DUP4 20EE 90 SWAP1 20EF 1B SHL 20F0 7F PUSH32 0xffffff0000000000000000000000000000000000000000000000000000000000 2111 16 AND 2112 60 PUSH1 0x20 2114 80 DUP1 2115 83 DUP4 2116 01 ADD 2117 91 SWAP2 2118 90 SWAP1 2119 91 SWAP2 211A 52 MSTORE 211B 82 DUP3 211C 51 MLOAD 211D 60 PUSH1 0x03 211F 81 DUP2 2120 84 DUP5 2121 03 SUB 2122 01 ADD 2123 81 DUP2 2124 52 MSTORE 2125 60 PUSH1 0x23 2127 90 SWAP1 2128 92 SWAP3 2129 01 ADD 212A 83 DUP4 212B 52 MSTORE 212C 81 DUP2 212D 51 MLOAD 212E 91 SWAP2 212F 01 ADD 2130 20 SHA3 2131 82 DUP3 2132 18 XOR 2133 90 SWAP1 2134 62 PUSH3 0x00215a 2138 90 SWAP1 2139 60 PUSH1 0x48 213B 83 DUP4 213C 90 SWAP1 213D 1C SHR 213E 90 SWAP1 213F 83 DUP4 2140 90 SWAP1 2141 1C SHR 2142 60 PUSH1 0x38 2144 84 DUP5 2145 90 SWAP1 2146 1C SHR 2147 61 PUSH2 0x0fff 214A 60 PUSH1 0x28 214C 86 DUP7 214D 90 SWAP1 214E 1C SHR 214F 16 AND 2150 60 PUSH1 0x18 2152 86 DUP7 2153 90 SWAP1 2154 1C SHR 2155 62 PUSH3 0x003794 2159 56 *JUMP // Stack delta = +7 // Outputs[10] // { // @211A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffff0000000000000000000000000000000000000000000000000000000000 & (stack[-1] << 0xe8) // @2124 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x40:0x60] - memory[0x40:0x60] + 0x03 // @212B memory[0x40:0x60] = memory[0x40:0x60] + 0x23 // @2133 stack[0] = stack[-1] ~ keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @2138 stack[1] = 0x00215a // @213E stack[2] = (stack[-1] ~ keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x48 // @2141 stack[3] = (stack[-1] ~ keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x40 // @2146 stack[4] = (stack[-1] ~ keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x38 // @214F stack[5] = ((stack[-1] ~ keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x28) & 0x0fff // @2154 stack[6] = (stack[-1] ~ keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]])) >> 0x18 // } // Block ends with call to 0x003794, returns to 0x215A label_215A: // Incoming return from call to 0x3794 at 0x2159 // Incoming return from call to 0x3794 at 0x2159 // Inputs[1] { @215D stack[-2] } 215A 5B JUMPDEST 215B 60 PUSH1 0xfc 215D 82 DUP3 215E 90 SWAP1 215F 1C SHR 2160 15 ISZERO 2161 62 PUSH3 0x0010e4 2165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0010e4, if !(stack[-2] >> 0xfc) label_2166: // Incoming jump from 0x2165, if not !(stack[-2] >> 0xfc) // Inputs[1] { @2172 stack[-2] } 2166 62 PUSH3 0x0010e4 216A 60 PUSH1 0x10 216C 62 PUSH3 0xffffff 2170 60 PUSH1 0xe4 2172 85 DUP6 2173 90 SWAP1 2174 1C SHR 2175 16 AND 2176 04 DIV 2177 62 PUSH3 0xffffff 217B 16 AND 217C 60 PUSH1 0xfc 217E 84 DUP5 217F 90 SWAP1 2180 1C SHR 2181 60 PUSH1 0xff 2183 16 AND 2184 62 PUSH3 0x00371c 2188 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2166 stack[0] = 0x0010e4 // @217B stack[1] = 0xffffff & ((stack[-2] >> 0xe4) & 0xffffff) / 0x10 // @2183 stack[2] = 0xff & (stack[-2] >> 0xfc) // } // Block ends with call to 0x00371c, returns to 0x10E4 label_2189: // Incoming jump from 0x0641 // Inputs[2] // { // @218C storage[0x01] // @21A3 msg.sender // } 2189 5B JUMPDEST 218A 60 PUSH1 0x01 218C 54 SLOAD 218D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21A2 16 AND 21A3 33 CALLER 21A4 14 EQ 21A5 62 PUSH3 0x0021ae 21A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0021ae, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] label_21AA: // Incoming jump from 0x21A9, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[1] { @21AD memory[0x00:0x00] } 21AA 60 PUSH1 0x00 21AC 80 DUP1 21AD FD *REVERT // Stack delta = +0 // Outputs[1] { @21AD revert(memory[0x00:0x00]); } // Block terminates label_21AE: // Incoming jump from 0x21A9, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] // Inputs[4] // { // @21AF stack[-1] // @21CD memory[0x40:0x60] // @21E1 memory[0x40:0x60] // @21EA address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } 21AE 5B JUMPDEST 21AF 80 DUP1 21B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21C5 16 AND 21C6 63 PUSH4 0x84b366dc 21CB 60 PUSH1 0x40 21CD 51 MLOAD 21CE 81 DUP2 21CF 63 PUSH4 0xffffffff 21D4 16 AND 21D5 60 PUSH1 0xe0 21D7 1B SHL 21D8 81 DUP2 21D9 52 MSTORE 21DA 60 PUSH1 0x04 21DC 01 ADD 21DD 60 PUSH1 0x00 21DF 60 PUSH1 0x40 21E1 51 MLOAD 21E2 80 DUP1 21E3 83 DUP4 21E4 03 SUB 21E5 81 DUP2 21E6 60 PUSH1 0x00 21E8 87 DUP8 21E9 80 DUP1 21EA 3B EXTCODESIZE 21EB 15 ISZERO 21EC 80 DUP1 21ED 15 ISZERO 21EE 62 PUSH3 0x001fc3 21F2 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @21C5 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @21C6 stack[1] = 0x84b366dc // @21D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x84b366dc) << 0xe0 // @21DC stack[2] = 0x04 + memory[0x40:0x60] // @21DD stack[3] = 0x00 // @21E1 stack[4] = memory[0x40:0x60] // @21E4 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @21E5 stack[6] = memory[0x40:0x60] // @21E6 stack[7] = 0x00 // @21E8 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @21EB stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } // Block ends with conditional jump to 0x001fc3, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length label_21F3: // Incoming jump from 0x21F2, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[1] { @21F6 memory[0x00:0x00] } 21F3 60 PUSH1 0x00 21F5 80 DUP1 21F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @21F6 revert(memory[0x00:0x00]); } // Block terminates label_21F7: // Incoming jump from 0x066F // Inputs[1] { @21F8 msg.sender } 21F7 5B JUMPDEST 21F8 33 CALLER 21F9 73 PUSH20 0x58d46ae3114fc82d80f57c9a2a322845a19418fb 220E 14 EQ 220F 62 PUSH3 0x002218 2213 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x002218, if 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender label_2214: // Incoming jump from 0x2213, if not 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender // Inputs[1] { @2217 memory[0x00:0x00] } 2214 60 PUSH1 0x00 2216 80 DUP1 2217 FD *REVERT // Stack delta = +0 // Outputs[1] { @2217 revert(memory[0x00:0x00]); } // Block terminates label_2218: // Incoming jump from 0x2213, if 0x58d46ae3114fc82d80f57c9a2a322845a19418fb == msg.sender // Inputs[1] { @223A stack[-1] } 2218 5B JUMPDEST 2219 7F PUSH32 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 223A 81 DUP2 223B 18 XOR 223C 60 PUSH1 0x48 223E 81 DUP2 223F 90 SWAP1 2240 1C SHR 2241 60 PUSH1 0x00 2243 62 PUSH3 0x002252 2247 82 DUP3 2248 60 PUSH1 0x38 224A 85 DUP6 224B 90 SWAP1 224C 1C SHR 224D 62 PUSH3 0x003377 2251 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @223B stack[0] = stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5 // @2240 stack[1] = (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x48 // @2241 stack[2] = 0x00 // @2243 stack[3] = 0x002252 // @2247 stack[4] = (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x48 // @224C stack[5] = (stack[-1] ~ 0x8f0f90cf868eda8141371c26266f31f07243e96cb9f937247e4dac44527df6f5) >> 0x38 // } // Block ends with call to 0x003377, returns to 0x2252 label_2252: // Incoming return from call to 0x3377 at 0x2251 // Inputs[6] // { // @2256 memory[0x40:0x60] // @2295 memory[0x40:0x60] // @2296 stack[-1] // @2297 stack[-2] // @22B1 stack[-3] // @22CC address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 2252 5B JUMPDEST 2253 60 PUSH1 0x40 2255 80 DUP1 2256 51 MLOAD 2257 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 2278 81 DUP2 2279 52 MSTORE 227A 73 PUSH20 0x45544abf5936deb78490d38ec42b80757d16c014 228F 60 PUSH1 0x04 2291 82 DUP3 2292 01 ADD 2293 52 MSTORE 2294 90 SWAP1 2295 51 MLOAD 2296 91 SWAP2 2297 92 SWAP3 2298 50 POP 2299 60 PUSH1 0x00 229B 91 SWAP2 229C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22B1 85 DUP6 22B2 16 AND 22B3 91 SWAP2 22B4 63 PUSH4 0x70a08231 22B9 91 SWAP2 22BA 60 PUSH1 0x24 22BC 80 DUP1 22BD 83 DUP4 22BE 01 ADD 22BF 92 SWAP3 22C0 60 PUSH1 0x20 22C2 92 SWAP3 22C3 91 SWAP2 22C4 90 SWAP1 22C5 82 DUP3 22C6 90 SWAP1 22C7 03 SUB 22C8 01 ADD 22C9 81 DUP2 22CA 86 DUP7 22CB 80 DUP1 22CC 3B EXTCODESIZE 22CD 15 ISZERO 22CE 80 DUP1 22CF 15 ISZERO 22D0 62 PUSH3 0x0022d9 22D4 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @2279 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @2293 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x45544abf5936deb78490d38ec42b80757d16c014 // @2297 stack[-2] = stack[-1] // @229B stack[-1] = 0x00 // @22B3 stack[0] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @22B9 stack[1] = 0x70a08231 // @22BF stack[2] = memory[0x40:0x60] + 0x24 // @22C2 stack[3] = 0x20 // @22C3 stack[4] = memory[0x40:0x60] // @22C8 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @22C9 stack[6] = memory[0x40:0x60] // @22CA stack[7] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @22CD stack[8] = !address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0022d9, if !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_22D5: // Incoming jump from 0x22D4, if not !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @22D8 memory[0x00:0x00] } 22D5 60 PUSH1 0x00 22D7 80 DUP1 22D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @22D8 revert(memory[0x00:0x00]); } // Block terminates label_22D9: // Incoming jump from 0x22D4, if !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @22DB msg.gas // @22DC stack[-3] // @22DC stack[-6] // @22DC stack[-4] // @22DC memory[stack[-3]:stack[-3] + stack[-4]] // @22DC stack[-5] // @22DC address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @22DC stack[-2] // } 22D9 5B JUMPDEST 22DA 50 POP 22DB 5A GAS 22DC FA STATICCALL 22DD 15 ISZERO 22DE 80 DUP1 22DF 15 ISZERO 22E0 62 PUSH3 0x0022ee 22E4 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @22DC memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @22DD stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0022ee, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_22E5: // Incoming jump from 0x22E4, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @22E5 returndata.length // @22E9 returndata[0x00:0x00 + returndata.length] // @22EA returndata.length // @22ED memory[0x00:0x00 + returndata.length] // } 22E5 3D RETURNDATASIZE 22E6 60 PUSH1 0x00 22E8 80 DUP1 22E9 3E RETURNDATACOPY 22EA 3D RETURNDATASIZE 22EB 60 PUSH1 0x00 22ED FD *REVERT // Stack delta = +0 // Outputs[2] // { // @22E9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @22ED revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_22EE: // Incoming jump from 0x22E4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @22F5 memory[0x40:0x60] // @22F6 returndata.length // } 22EE 5B JUMPDEST 22EF 50 POP 22F0 50 POP 22F1 50 POP 22F2 50 POP 22F3 60 PUSH1 0x40 22F5 51 MLOAD 22F6 3D RETURNDATASIZE 22F7 60 PUSH1 0x20 22F9 81 DUP2 22FA 10 LT 22FB 15 ISZERO 22FC 62 PUSH3 0x002305 2300 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @22F5 stack[-4] = memory[0x40:0x60] // @22F6 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x002305, if !(returndata.length < 0x20) label_2301: // Incoming jump from 0x2300, if not !(returndata.length < 0x20) // Inputs[1] { @2304 memory[0x00:0x00] } 2301 60 PUSH1 0x00 2303 80 DUP1 2304 FD *REVERT // Stack delta = +0 // Outputs[1] { @2304 revert(memory[0x00:0x00]); } // Block terminates label_2305: // Incoming jump from 0x2300, if !(returndata.length < 0x20) // Inputs[5] // { // @2307 memory[stack[-2]:stack[-2] + 0x20] // @2307 stack[-2] // @2308 stack[-3] // @2321 stack[-5] // @2322 stack[-4] // } 2305 5B JUMPDEST 2306 50 POP 2307 51 MLOAD 2308 90 SWAP1 2309 50 POP 230A 73 PUSH20 0x45544abf5936deb78490d38ec42b80757d16c014 231F 60 PUSH1 0x02 2321 84 DUP5 2322 84 DUP5 2323 62 PUSH3 0x002335 2327 85 DUP6 2328 60 PUSH1 0x01 232A 63 PUSH4 0xffffffff 232F 62 PUSH3 0x0035f9 2333 16 AND 2334 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @2308 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @230A stack[-2] = 0x45544abf5936deb78490d38ec42b80757d16c014 // @231F stack[-1] = 0x02 // @2321 stack[0] = stack[-5] // @2322 stack[1] = stack[-4] // @2323 stack[2] = 0x002335 // @2327 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @2328 stack[4] = 0x01 // } // Block ends with call to 0x0035f9 & 0xffffffff, returns to 0x2335 label_2335: // Incoming return from call to 0x35F9 at 0x2334 // Inputs[8] // { // @2338 memory[0x40:0x60] // @2339 stack[-4] // @2349 stack[-3] // @237B stack[-2] // @23AD stack[-1] // @23BC memory[0x40:0x60] // @23C3 stack[-5] // @23C5 address(stack[-5]).code.length // } 2335 5B JUMPDEST 2336 60 PUSH1 0x40 2338 51 MLOAD 2339 84 DUP5 233A 63 PUSH4 0xffffffff 233F 16 AND 2340 60 PUSH1 0xe0 2342 1B SHL 2343 81 DUP2 2344 52 MSTORE 2345 60 PUSH1 0x04 2347 01 ADD 2348 80 DUP1 2349 84 DUP5 234A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 235F 16 AND 2360 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2375 16 AND 2376 81 DUP2 2377 52 MSTORE 2378 60 PUSH1 0x20 237A 01 ADD 237B 83 DUP4 237C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2391 16 AND 2392 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23A7 16 AND 23A8 81 DUP2 23A9 52 MSTORE 23AA 60 PUSH1 0x20 23AC 01 ADD 23AD 82 DUP3 23AE 81 DUP2 23AF 52 MSTORE 23B0 60 PUSH1 0x20 23B2 01 ADD 23B3 93 SWAP4 23B4 50 POP 23B5 50 POP 23B6 50 POP 23B7 50 POP 23B8 60 PUSH1 0x00 23BA 60 PUSH1 0x40 23BC 51 MLOAD 23BD 80 DUP1 23BE 83 DUP4 23BF 03 SUB 23C0 81 DUP2 23C1 60 PUSH1 0x00 23C3 87 DUP8 23C4 80 DUP1 23C5 3B EXTCODESIZE 23C6 15 ISZERO 23C7 80 DUP1 23C8 15 ISZERO 23C9 62 PUSH3 0x0023d2 23CD 57 *JUMPI // Stack delta = +5 // Outputs[12] // { // @2344 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-4]) << 0xe0 // @2377 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @23A9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @23AF memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @23B3 stack[-3] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @23B8 stack[-2] = 0x00 // @23BC stack[-1] = memory[0x40:0x60] // @23BF stack[0] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @23C0 stack[1] = memory[0x40:0x60] // @23C1 stack[2] = 0x00 // @23C3 stack[3] = stack[-5] // @23C6 stack[4] = !address(stack[-5]).code.length // } // Block ends with conditional jump to 0x0023d2, if !!address(stack[-5]).code.length label_23CE: // Incoming jump from 0x23CD, if not !!address(stack[-5]).code.length // Inputs[1] { @23D1 memory[0x00:0x00] } 23CE 60 PUSH1 0x00 23D0 80 DUP1 23D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @23D1 revert(memory[0x00:0x00]); } // Block terminates label_23D2: // Incoming jump from 0x23CD, if !!address(stack[-5]).code.length // Inputs[9] // { // @23D4 msg.gas // @23D5 stack[-6] // @23D5 stack[-4] // @23D5 stack[-7] // @23D5 stack[-3] // @23D5 stack[-5] // @23D5 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @23D5 stack[-2] // @23D5 memory[stack[-4]:stack[-4] + stack[-5]] // } 23D2 5B JUMPDEST 23D3 50 POP 23D4 5A GAS 23D5 F1 CALL 23D6 15 ISZERO 23D7 80 DUP1 23D8 15 ISZERO 23D9 62 PUSH3 0x0023e7 23DD 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @23D5 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @23D6 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0023e7, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_23DE: // Incoming jump from 0x23DD, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @23DE returndata.length // @23E2 returndata[0x00:0x00 + returndata.length] // @23E3 returndata.length // @23E6 memory[0x00:0x00 + returndata.length] // } 23DE 3D RETURNDATASIZE 23DF 60 PUSH1 0x00 23E1 80 DUP1 23E2 3E RETURNDATACOPY 23E3 3D RETURNDATASIZE 23E4 60 PUSH1 0x00 23E6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @23E2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @23E6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_23E7: // Incoming jump from 0x23DD, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @23F3 stack[-6] // @23F4 stack[-7] // } 23E7 5B JUMPDEST 23E8 50 POP 23E9 50 POP 23EA 50 POP 23EB 50 POP 23EC 60 PUSH1 0x00 23EE 80 DUP1 23EF 62 PUSH3 0x0023fa 23F3 84 DUP5 23F4 86 DUP7 23F5 62 PUSH3 0x00360f 23F9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @23EC stack[-4] = 0x00 // @23EE stack[-3] = 0x00 // @23EF stack[-2] = 0x0023fa // @23F3 stack[-1] = stack[-6] // @23F4 stack[0] = stack[-7] // } // Block ends with call to 0x00360f, returns to 0x23FA label_23FA: // Incoming return from call to 0x360F at 0x23F9 // Inputs[9] // { // @23FB stack[-1] // @23FB stack[-3] // @23FD stack[-4] // @23FD stack[-2] // @240A stack[-7] // @2426 stack[-6] // @2429 memory[0x40:0x60] // @2473 memory[0x40:0x60] // @247A address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // } 23FA 5B JUMPDEST 23FB 91 SWAP2 23FC 50 POP 23FD 91 SWAP2 23FE 50 POP 23FF 60 PUSH1 0x00 2401 62 PUSH3 0x002487 2405 62 PUSH3 0x000d4e 2409 83 DUP4 240A 88 DUP9 240B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2420 16 AND 2421 63 PUSH4 0x70a08231 2426 89 DUP10 2427 60 PUSH1 0x40 2429 51 MLOAD 242A 82 DUP3 242B 63 PUSH4 0xffffffff 2430 16 AND 2431 60 PUSH1 0xe0 2433 1B SHL 2434 81 DUP2 2435 52 MSTORE 2436 60 PUSH1 0x04 2438 01 ADD 2439 80 DUP1 243A 82 DUP3 243B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2450 16 AND 2451 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2466 16 AND 2467 81 DUP2 2468 52 MSTORE 2469 60 PUSH1 0x20 246B 01 ADD 246C 91 SWAP2 246D 50 POP 246E 50 POP 246F 60 PUSH1 0x20 2471 60 PUSH1 0x40 2473 51 MLOAD 2474 80 DUP1 2475 83 DUP4 2476 03 SUB 2477 81 DUP2 2478 86 DUP7 2479 80 DUP1 247A 3B EXTCODESIZE 247B 15 ISZERO 247C 80 DUP1 247D 15 ISZERO 247E 62 PUSH3 0x000d13 2482 57 *JUMPI // Stack delta = +11 // Outputs[17] // { // @23FB stack[-3] = stack[-1] // @23FD stack[-4] = stack[-2] // @23FF stack[-2] = 0x00 // @2401 stack[-1] = 0x002487 // @2405 stack[0] = 0x000d4e // @2409 stack[1] = stack[-1] // @2420 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2421 stack[3] = 0x70a08231 // @2435 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @2468 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @246C stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @246F stack[5] = 0x20 // @2473 stack[6] = memory[0x40:0x60] // @2476 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2477 stack[8] = memory[0x40:0x60] // @2478 stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @247B stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // } // Block ends with conditional call to 0x000d13, returns to 0x0D4E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length label_2483: // Incoming jump from 0x2482, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-7]).code.length // Inputs[1] { @2486 memory[0x00:0x00] } 2483 60 PUSH1 0x00 2485 80 DUP1 2486 FD *REVERT // Stack delta = +0 // Outputs[1] { @2486 revert(memory[0x00:0x00]); } // Block terminates label_2487: // Incoming return from call to 0x0D4E at 0x2482 // Inputs[3] // { // @2488 stack[-2] // @2488 stack[-1] // @24A2 stack[-7] // } 2487 5B JUMPDEST 2488 90 SWAP1 2489 50 POP 248A 60 PUSH1 0x00 248C 80 DUP1 248D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24A2 88 DUP9 24A3 16 AND 24A4 73 PUSH20 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 24B9 10 LT 24BA 62 PUSH3 0x0024c7 24BE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2488 stack[-2] = stack[-1] // @248A stack[-1] = 0x00 // @248C stack[0] = 0x00 // } // Block ends with conditional jump to 0x0024c7, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff label_24BF: // Incoming jump from 0x24BE, if not 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @24C1 stack[-3] } 24BF 60 PUSH1 0x00 24C1 83 DUP4 24C2 62 PUSH3 0x0024cb 24C6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24BF stack[0] = 0x00 // @24C1 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x0024cb label_24C7: // Incoming jump from 0x24BE, if 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 < stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[6] // { // @24C8 stack[-3] // @24CC stack[-1] // @24CE stack[-2] // @24D0 stack[-7] // @24EE address(this) // @24F3 memory[0x40:0x60] // } 24C7 5B JUMPDEST 24C8 82 DUP3 24C9 60 PUSH1 0x00 24CB 5B JUMPDEST 24CC 91 SWAP2 24CD 50 POP 24CE 91 SWAP2 24CF 50 POP 24D0 86 DUP7 24D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24E6 16 AND 24E7 63 PUSH4 0x022c0d9f 24EC 83 DUP4 24ED 83 DUP4 24EE 30 ADDRESS 24EF 60 PUSH1 0x00 24F1 60 PUSH1 0x40 24F3 51 MLOAD 24F4 90 SWAP1 24F5 80 DUP1 24F6 82 DUP3 24F7 52 MSTORE 24F8 80 DUP1 24F9 60 PUSH1 0x1f 24FB 01 ADD 24FC 60 PUSH1 0x1f 24FE 19 NOT 24FF 16 AND 2500 60 PUSH1 0x20 2502 01 ADD 2503 82 DUP3 2504 01 ADD 2505 60 PUSH1 0x40 2507 52 MSTORE 2508 80 DUP1 2509 15 ISZERO 250A 62 PUSH3 0x00251b 250E 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @24CC stack[-1] = 0x00 // @24CE stack[-2] = stack[-3] // @24E6 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @24E7 stack[1] = 0x022c0d9f // @24EC stack[2] = stack[-3] // @24ED stack[3] = 0x00 // @24EE stack[4] = address(this) // @24F4 stack[5] = memory[0x40:0x60] // @24F4 stack[6] = 0x00 // @24F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2507 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + 0x00) // } // Block ends with conditional jump to 0x00251b, if !0x00 label_250F: // Incoming jump from 0x250E, if not !0x00 // Incoming jump from 0x250E, if not !0x00 // Inputs[10] // { // @2511 stack[-2] // @2513 stack[-1] // @2515 code.length // @251F memory[0x40:0x60] // @2520 stack[-6] // @2530 stack[-5] // @2536 stack[-4] // @253C stack[-3] // @257A memory[stack[-2]:stack[-2] + 0x20] // @2583 memory[stack[-2]:stack[-2] + 0x20] // } 250F 60 PUSH1 0x20 2511 82 DUP3 2512 01 ADD 2513 81 DUP2 2514 80 DUP1 2515 38 CODESIZE 2516 83 DUP4 2517 39 CODECOPY 2518 01 ADD 2519 90 SWAP1 251A 50 POP 251B 5B JUMPDEST 251C 50 POP 251D 60 PUSH1 0x40 251F 51 MLOAD 2520 85 DUP6 2521 63 PUSH4 0xffffffff 2526 16 AND 2527 60 PUSH1 0xe0 2529 1B SHL 252A 81 DUP2 252B 52 MSTORE 252C 60 PUSH1 0x04 252E 01 ADD 252F 80 DUP1 2530 85 DUP6 2531 81 DUP2 2532 52 MSTORE 2533 60 PUSH1 0x20 2535 01 ADD 2536 84 DUP5 2537 81 DUP2 2538 52 MSTORE 2539 60 PUSH1 0x20 253B 01 ADD 253C 83 DUP4 253D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2552 16 AND 2553 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2568 16 AND 2569 81 DUP2 256A 52 MSTORE 256B 60 PUSH1 0x20 256D 01 ADD 256E 80 DUP1 256F 60 PUSH1 0x20 2571 01 ADD 2572 82 DUP3 2573 81 DUP2 2574 03 SUB 2575 82 DUP3 2576 52 MSTORE 2577 83 DUP4 2578 81 DUP2 2579 81 DUP2 257A 51 MLOAD 257B 81 DUP2 257C 52 MSTORE 257D 60 PUSH1 0x20 257F 01 ADD 2580 91 SWAP2 2581 50 POP 2582 80 DUP1 2583 51 MLOAD 2584 90 SWAP1 2585 60 PUSH1 0x20 2587 01 ADD 2588 90 SWAP1 2589 80 DUP1 258A 83 DUP4 258B 83 DUP4 258C 60 PUSH1 0x00 258E 5B JUMPDEST 258F 83 DUP4 2590 81 DUP2 2591 10 LT 2592 15 ISZERO 2593 62 PUSH3 0x0025a8 2597 57 *JUMPI // Stack delta = +8 // Outputs[16] // { // @2517 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @252B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-6]) << 0xe0 // @252E stack[-1] = 0x04 + memory[0x40:0x60] // @2532 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @2538 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @256A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @256D stack[0] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2576 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @257C memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2580 stack[1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2588 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @2588 stack[2] = 0x20 + stack[-2] // @2589 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @258A stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @258B stack[6] = 0x20 + stack[-2] // @258C stack[7] = 0x00 // } // Block ends with conditional jump to 0x0025a8, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2598: // Incoming jump from 0x2597, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2597, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2597, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2598 stack[-2] // @2599 stack[-1] // @259B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @259C stack[-3] // } 2598 81 DUP2 2599 81 DUP2 259A 01 ADD 259B 51 MLOAD 259C 83 DUP4 259D 82 DUP3 259E 01 ADD 259F 52 MSTORE 25A0 60 PUSH1 0x20 25A2 01 ADD 25A3 62 PUSH3 0x00258e 25A7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @259F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25A2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x00258e label_25A8: // Incoming jump from 0x2597, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2597, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2597, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @25AD stack[-6] // @25AD stack[-5] // @25AF stack[-7] // } 25A8 5B JUMPDEST 25A9 50 POP 25AA 50 POP 25AB 50 POP 25AC 50 POP 25AD 90 SWAP1 25AE 50 POP 25AF 90 SWAP1 25B0 81 DUP2 25B1 01 ADD 25B2 90 SWAP1 25B3 60 PUSH1 0x1f 25B5 16 AND 25B6 80 DUP1 25B7 15 ISZERO 25B8 62 PUSH3 0x0025d6 25BC 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @25B2 stack[-7] = stack[-5] + stack[-7] // @25B5 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0025d6, if !(0x1f & stack[-5]) label_25BD: // Incoming jump from 0x25BC, if not !(0x1f & stack[-5]) // Inputs[7] // { // @25BD stack[-1] // @25BE stack[-2] // @25C1 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @25D8 stack[-8] // @25E3 memory[0x40:0x60] // @25EA stack[-10] // @25EC address(stack[-10]).code.length // } 25BD 80 DUP1 25BE 82 DUP3 25BF 03 SUB 25C0 80 DUP1 25C1 51 MLOAD 25C2 60 PUSH1 0x01 25C4 83 DUP4 25C5 60 PUSH1 0x20 25C7 03 SUB 25C8 61 PUSH2 0x0100 25CB 0A EXP 25CC 03 SUB 25CD 19 NOT 25CE 16 AND 25CF 81 DUP2 25D0 52 MSTORE 25D1 60 PUSH1 0x20 25D3 01 ADD 25D4 91 SWAP2 25D5 50 POP 25D6 5B JUMPDEST 25D7 50 POP 25D8 95 SWAP6 25D9 50 POP 25DA 50 POP 25DB 50 POP 25DC 50 POP 25DD 50 POP 25DE 50 POP 25DF 60 PUSH1 0x00 25E1 60 PUSH1 0x40 25E3 51 MLOAD 25E4 80 DUP1 25E5 83 DUP4 25E6 03 SUB 25E7 81 DUP2 25E8 60 PUSH1 0x00 25EA 87 DUP8 25EB 80 DUP1 25EC 3B EXTCODESIZE 25ED 15 ISZERO 25EE 80 DUP1 25EF 15 ISZERO 25F0 62 PUSH3 0x0025f9 25F4 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @25D0 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @25D8 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @25DF stack[-7] = 0x00 // @25E3 stack[-6] = memory[0x40:0x60] // @25E6 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @25E7 stack[-4] = memory[0x40:0x60] // @25E8 stack[-3] = 0x00 // @25EA stack[-2] = stack[-10] // @25ED stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x0025f9, if !!address(stack[-10]).code.length label_25F5: // Incoming jump from 0x25F4, if not !!address(stack[-10]).code.length // Incoming jump from 0x25F4, if not !!address(stack[-10]).code.length // Inputs[1] { @25F8 memory[0x00:0x00] } 25F5 60 PUSH1 0x00 25F7 80 DUP1 25F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @25F8 revert(memory[0x00:0x00]); } // Block terminates label_25F9: // Incoming jump from 0x25F4, if !!address(stack[-10]).code.length // Incoming jump from 0x25F4, if !!address(stack[-10]).code.length // Inputs[9] // { // @25FB msg.gas // @25FC stack[-2] // @25FC stack[-3] // @25FC stack[-5] // @25FC memory[stack[-4]:stack[-4] + stack[-5]] // @25FC stack[-4] // @25FC stack[-6] // @25FC stack[-7] // @25FC address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 25F9 5B JUMPDEST 25FA 50 POP 25FB 5A GAS 25FC F1 CALL 25FD 15 ISZERO 25FE 80 DUP1 25FF 15 ISZERO 2600 62 PUSH3 0x00260e 2604 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @25FC memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @25FD stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x00260e, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2605: // Incoming jump from 0x2604, if not !!address(stack[-2]).ca