Online Solidity Decompiler

« Decompile another contract

Address

0xdaae81c0077e8917a2eb63bb66ef701ff4781bb0 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x00fdd58e balanceOf(address,uint256)
0x01ffc9a7 supportsInterface(bytes4)
0x0e89341c uri(uint256)
0x156e29f6 mint(address,uint256,uint256)
0x2eb2c2d6 safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)
0x34d722c9 minterAddress()
0x4e1273f4 balanceOfBatch(address[],uint256[])
0x5cfeed1a Unknown
0x839f8ca3 setTokenId(uint256,bytes32)
0xa22cb465 setApprovalForAll(address,bool)
0xe985e9c5 isApprovedForAll(address,address)
0xf242432a safeTransferFrom(address,address,uint256,uint256,bytes)
0xfab03a55 Unknown

Internal Methods

func_00E8(arg0, arg1) returns (r0)
func_0118(arg0) returns (r0)
func_0148(arg0) returns (r0)
func_0178(arg0, arg1, arg2)
func_0194(arg0, arg1, arg2, arg3, arg4)
func_01CE(arg0, arg1) returns (r0)
func_01FE(arg1) returns (r0)
func_022E(arg0, arg1)
func_024A(arg0, arg1)
func_0266(arg0, arg1) returns (r0)
func_0296(arg0, arg1, arg2, arg3, arg4)
func_02B2(arg1) returns (r0)
func_0705(arg0, arg1) returns (r0)
func_09CD(arg0) returns (r0)
func_1039(arg0, arg1) returns (r0)
func_1099(arg0, arg1, arg2, arg3, arg4, arg6)
func_12DC(arg0, arg1, arg2, arg3)
func_1368(arg0, arg1, arg2, arg3, arg4, arg6)
func_14C3() returns (r0)
func_14CB(arg0, arg1, arg2, arg3, arg4, arg5)
func_14D3(arg0, arg1, arg2) returns (r0)
func_152E(arg0, arg1) returns (r0)
func_1583(arg0, arg1, arg2, arg3, arg4, arg5)
func_1753(arg0) returns (r0)
func_17C3(arg0, arg1, arg2, arg3, arg4, arg5)
func_1993(arg0) returns (r0)
func_19A6(arg0, arg1) returns (r0)
func_19BB(arg0, arg1) returns (r0)
func_19DA(arg0) returns (r0)
func_1A3E(arg0, arg1) returns (r0)
func_1A5D(arg0) returns (r0)
func_1AC1(arg0, arg1) returns (r0)
func_1AD6(arg0, arg1) returns (r0)
func_1AEB(arg0, arg1) returns (r0)
func_1B00(arg0, arg1) returns (r0)
func_1B15(arg0, arg1) returns (r0)
func_1B34(arg0) returns (r0)
func_1B69(arg0, arg1) returns (r0)
func_1B7E(arg0, arg1) returns (r0, r1)
func_1BBA(arg0, arg1) returns (r0, r1, r2, r3, r4)
func_1C79(arg0, arg1) returns (r0, r1, r2, r3, r4)
func_1D08(arg0, arg1) returns (r0, r1)
func_1D44(arg0, arg1) returns (r0, r1)
func_1D80(arg0, arg1) returns (r0, r1, r2)
func_1DCF(arg0, arg1) returns (r0, r1)
func_1E3B(arg0, arg1) returns (r0)
func_1E64(arg0, arg1) returns (r0)
func_1E8D(arg0, arg1) returns (r0)
func_1EB6(arg0, arg1) returns (r0)
func_1EDF(arg0, arg1) returns (r0, r1)
func_1F1B(arg0, arg1) returns (r0)
func_1F33(arg0, arg1)
func_1F42(arg0, arg1) returns (r0)
func_1FA0(arg0, arg1)
func_1FAF(arg0, arg1)
func_1FBE(arg0, arg1) returns (r0)
func_1FF7(arg0, arg1) returns (r0)
func_2030(arg0, arg1) returns (r0)
func_20BE(arg0) returns (r0)
func_2124(arg0) returns (r0)
func_218A(arg0) returns (r0)
func_21F0(arg0) returns (r0)
func_2256(arg0) returns (r0)
func_2296(arg0) returns (r0)
func_22FC(arg0) returns (r0)
func_2362(arg0) returns (r0)
func_23C8(arg0) returns (r0)
func_242E(arg0) returns (r0)
func_246E(arg0) returns (r0)
func_24D4(arg0) returns (r0)
func_253A(arg0) returns (r0)
func_25A0(arg0) returns (r0)
func_2606(arg0) returns (r0)
func_266C(arg0) returns (r0)
func_26D2(arg0) returns (r0)
func_2738(arg0, arg1)
func_2747(arg0, arg1)
func_2756(arg0, arg1) returns (r0)
func_2778(arg0, arg1) returns (r0)
func_2793(arg0, arg1, arg2, arg3, arg4, arg5) returns (r0)
func_27FB(arg0, arg1, arg2, arg3, arg4, arg5) returns (r0)
func_2855(arg0, arg1) returns (r0)
func_2877(arg0, arg1, arg2) returns (r0)
func_28AE(arg0, arg1) returns (r0)
func_28C9(arg0, arg1) returns (r0)
func_28E4(arg0, arg1) returns (r0)
func_2906(arg0) returns (r0)
func_2926(arg0) returns (r0)
func_2946(arg0) returns (r0)
func_2966(arg0) returns (r0)
func_2986(arg0) returns (r0)
func_29A6(arg0) returns (r0)
func_29C6(arg0) returns (r0)
func_29E6(arg0) returns (r0)
func_2A06(arg0) returns (r0)
func_2A26(arg0) returns (r0)
func_2A46(arg0) returns (r0)
func_2A66(arg0) returns (r0)
func_2A86(arg0) returns (r0)
func_2AA6(arg0) returns (r0)
func_2AC6(arg0) returns (r0)
func_2AE6(arg0) returns (r0)
func_2B06(arg0, arg1) returns (r0)
func_2B21(arg0, arg1, arg2) returns (r0)
func_2B77(arg0) returns (r0)
func_2B9F(arg0) returns (r0)
func_2BC7(arg0) returns (r0)
func_2BF3(arg0) returns (r0)
func_2C03(arg0) returns (r0)
func_2C18(arg0) returns (r0)
func_2C23(arg0) returns (r0)
func_2C2E(arg0) returns (r0)
func_2C39(arg0) returns (r0)
func_2C46(arg0, arg1) returns (r0)
func_2C57(arg0, arg1) returns (r0)
func_2C68(arg0, arg1) returns (r0)
func_2C79(arg0, arg1) returns (r0)
func_2C84(arg0) returns (r0)
func_2C96(arg0) returns (r0)
func_2CA2(arg0) returns (r0)
func_2CAC(arg0) returns (r0)
func_2CD8(arg0) returns (r0)
func_2CF8(arg0) returns (r0)
func_2D02(arg0, arg1, arg2)
func_2D11(arg0, arg1, arg2)
func_2D44(arg0) returns (r0)
func_2D55(arg0) returns (r0)
func_2D62() returns (r0)
func_2E18(arg0)
func_2E2F(arg0)
func_2E46(arg0)
func_2E5D(arg0)
func_2E74(arg0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = msg.value; if (var0) { revert(memory[0x00:0x00]); } if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var0 = msg.data[0x00:0x20] >> 0xe0; if (0x4e1273f4 > var0) { if (var0 == 0xfdd58e) { // Dispatch table entry for balanceOf(address,uint256) var var1 = 0x00ed; var var2 = 0x00e8; var var4 = 0x04; var var3 = var4 + (msg.data.length - var4); var2, var3 = func_1D44(var3, var4); var1 = func_00E8(var2, var3); var temp0 = var1; var1 = 0x00fa; var2 = temp0; var3 = memory[0x40:0x60]; var1 = func_2B06(var2, var3); var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + var1 - temp1]; } else if (var0 == 0x01ffc9a7) { // Dispatch table entry for supportsInterface(bytes4) var1 = 0x011d; var2 = 0x0118; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1E64(var3, var4); var1 = func_0118(var2); var temp2 = var1; var1 = 0x012a; var3 = memory[0x40:0x60]; var2 = temp2; var1 = func_28AE(var2, var3); var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + var1 - temp3]; } else if (var0 == 0x0e89341c) { // Dispatch table entry for uri(uint256) var1 = 0x014d; var2 = 0x0148; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1EB6(var3, var4); var1 = func_0148(var2); var temp4 = var1; var1 = 0x015a; var2 = temp4; var3 = memory[0x40:0x60]; var1 = func_28E4(var2, var3); var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + var1 - temp5]; } else if (var0 == 0x156e29f6) { // Dispatch table entry for mint(address,uint256,uint256) var1 = 0x017d; var2 = 0x0178; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3, var4 = func_1D80(var3, var4); func_0178(var2, var3, var4); stop(); } else if (var0 == 0x2eb2c2d6) { // Dispatch table entry for safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) var1 = 0x0199; var2 = 0x0194; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var var5; var var6; var2, var3, var4, var5, var6 = func_1BBA(var3, var4); func_0194(var2, var3, var4, var5, var6); stop(); } else if (var0 == 0x34d722c9) { // Dispatch table entry for minterAddress() var1 = 0x01a3; var2 = func_09CD(); var temp6 = var2; var2 = 0x01b0; var3 = temp6; var4 = memory[0x40:0x60]; var2 = func_2778(var3, var4); var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + var2 - temp7]; } else { revert(memory[0x00:0x00]); } } else if (0xa22cb465 > var0) { if (var0 == 0x4e1273f4) { // Dispatch table entry for balanceOfBatch(address[],uint256[]) var1 = 0x01d3; var2 = 0x01ce; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_1DCF(var3, var4); var1 = func_01CE(var2, var3); var temp8 = var1; var1 = 0x01e0; var2 = temp8; var3 = memory[0x40:0x60]; var1 = func_2855(var2, var3); var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + var1 - temp9]; } else if (var0 == 0x5cfeed1a) { // Dispatch table entry for 0x5cfeed1a (unknown) var1 = 0x0203; var2 = 0x01fe; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1E3B(var3, var4); var2 = func_01FE(var2); var temp10 = var2; var2 = 0x0210; var3 = temp10; var4 = memory[0x40:0x60]; var2 = func_28E4(var3, var4); var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + var2 - temp11]; } else if (var0 == 0x839f8ca3) { // Dispatch table entry for setTokenId(uint256,bytes32) var1 = 0x0233; var2 = 0x022e; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_1EDF(var3, var4); func_022E(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xa22cb465) { // Dispatch table entry for setApprovalForAll(address,bool) var1 = 0x024f; var2 = 0x024a; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_1D08(var3, var4); func_024A(var2, var3); stop(); } else if (var0 == 0xe985e9c5) { // Dispatch table entry for isApprovedForAll(address,address) var1 = 0x026b; var2 = 0x0266; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_1B7E(var3, var4); var1 = func_0266(var2, var3); var temp12 = var1; var1 = 0x0278; var2 = temp12; var3 = memory[0x40:0x60]; var1 = func_28AE(var2, var3); var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + var1 - temp13]; } else if (var0 == 0xf242432a) { // Dispatch table entry for safeTransferFrom(address,address,uint256,uint256,bytes) var1 = 0x029b; var2 = 0x0296; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3, var4, var5, var6 = func_1C79(var3, var4); func_0296(var2, var3, var4, var5, var6); stop(); } else if (var0 == 0xfab03a55) { // Dispatch table entry for 0xfab03a55 (unknown) var1 = 0x02b7; var2 = 0x02b2; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1EB6(var3, var4); var2 = func_02B2(var2); var temp14 = var2; var2 = 0x02c4; var3 = temp14; var4 = memory[0x40:0x60]; var2 = func_28C9(var3, var4); var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + var2 - temp15]; } else { revert(memory[0x00:0x00]); } } function func_00E8(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != var0 & 0xffffffffffffffffffffffffffffffffffffffff) { memory[0x00:0x20] = arg1; memory[0x20:0x40] = 0x01; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])]; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var1 = 0x0335; var var2 = temp1 + 0x04; var1 = func_2946(var2); var temp2 = memory[0x40:0x60]; revert(memory[temp2:temp2 + var1 - temp2]); } } function func_0118(var arg0) returns (var r0) { memory[0x00:0x20] = arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_0148(var arg0) returns (var r0) { var var0 = 0x60; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x04; memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])]; memory[0x20:0x40] = 0x03; var temp0 = keccak256(memory[0x00:0x40]); var var1 = temp0; var var2 = 0x60; var temp1 = storage[var1]; var temp2 = (!(temp1 & 0x01) * 0x0100 - 0x01 & temp1) / 0x02; var temp3 = memory[0x40:0x60]; memory[0x40:0x60] = temp3 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20; var var3 = temp3; var var4 = var1; var var5 = temp2; memory[var3:var3 + 0x20] = var5; var var6 = var3 + 0x20; var var7 = var4; var temp4 = storage[var7]; var var8 = (!(temp4 & 0x01) * 0x0100 - 0x01 & temp4) / 0x02; if (!var8) { label_04C1: var2 = var3; if (memory[var2:var2 + 0x20] > 0x00) { var3 = 0x051d; var5 = memory[0x40:0x60] + 0x20; var4 = var1; var3 = func_2756(var4, var5); var temp5 = memory[0x40:0x60]; var temp6 = var3; memory[temp5:temp5 + 0x20] = temp6 - temp5 - 0x20; memory[0x40:0x60] = temp6; return temp5; } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var4 = temp7 + 0x04; var3 = 0x0503; var3 = func_2AC6(var4); var temp8 = memory[0x40:0x60]; revert(memory[temp8:temp8 + var3 - temp8]); } } else if (0x1f < var8) { var temp9 = var6; var temp10 = temp9 + var8; var6 = temp10; memory[0x00:0x20] = var7; var temp11 = keccak256(memory[0x00:0x20]); memory[temp9:temp9 + 0x20] = storage[temp11]; var7 = temp11 + 0x01; var8 = temp9 + 0x20; if (var6 <= var8) { goto label_04B8; } label_04A4: var temp12 = var7; var temp13 = var8; memory[temp13:temp13 + 0x20] = storage[temp12]; var7 = temp12 + 0x01; var8 = temp13 + 0x20; if (var6 > var8) { goto label_04A4; } label_04B8: var temp14 = var6; var temp15 = temp14 + (var8 - temp14 & 0x1f); var8 = temp14; var6 = temp15; goto label_04C1; } else { var temp16 = var6; memory[temp16:temp16 + 0x20] = storage[var7] / 0x0100 * 0x0100; var6 = temp16 + 0x20; var8 = var8; goto label_04C1; } } function func_0178(var arg0, var arg1, var arg2) { if (msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81) { var var0 = 0x0604; var var1 = arg0; var var2 = arg1; var var3 = arg2; var temp0 = memory[0x40:0x60]; var var4 = temp0; memory[0x40:0x60] = var4 + 0x40; memory[var4:var4 + 0x20] = 0x03; memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0x3078300000000000000000000000000000000000000000000000000000000000; func_12DC(var1, var2, var3, var4); return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp1 + 0x04; var0 = 0x05ba; var0 = func_2A26(var1); var temp2 = memory[0x40:0x60]; revert(memory[temp2:temp2 + var0 - temp2]); } } function func_0194(var arg0, var arg1, var arg2, var arg3, var arg4) { if (memory[arg2:arg2 + 0x20] != memory[arg3:arg3 + 0x20]) { var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp13 + 0x04; var0 = 0x0644; var0 = func_2A86(var1); var temp14 = memory[0x40:0x60]; revert(memory[temp14:temp14 + var0 - temp14]); } else if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff != 0xffffffffffffffffffffffffffffffffffffffff & 0x00) { var var0 = 0x06c5; var0 = func_14C3(); var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff == var0 & 0xffffffffffffffffffffffffffffffffffffffff; if (var0) { label_070B: if (var0) { var0 = 0x00; var var1 = 0x0754; var1 = func_14C3(); var temp0 = var1; var0 = temp0; var1 = 0x0764; var var2 = var0; var var3 = arg0; var var4 = arg1; var var5 = arg2; var var6 = arg3; var var7 = arg4; func_14CB(var2, var3, var4, var5, var6, var7); var1 = 0x00; if (var1 >= memory[arg2:arg2 + 0x20]) { label_0938: var1 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var3 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb; var5 = 0x09af; var6 = arg2; var7 = arg3; var var8 = memory[0x40:0x60]; var5 = func_2877(var6, var7, var8); var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + var5 - temp1], [stack[-2], stack[-3], stack[-4], stack[-5]]); var1 = 0x09c5; var2 = var0; var3 = arg0; var4 = arg1; var5 = arg2; var6 = arg3; var7 = arg4; func_1583(var2, var3, var4, var5, var6, var7); return; } else { label_0774: var2 = 0x00; var3 = arg2; var4 = var1; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } var2 = memory[var4 * 0x20 + 0x20 + var3:var4 * 0x20 + 0x20 + var3 + 0x20]; var3 = 0x00; var4 = arg3; var5 = var1; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var temp2 = memory[var5 * 0x20 + 0x20 + var4:var5 * 0x20 + 0x20 + var4 + 0x20]; var3 = temp2; var4 = 0x0820; var temp3 = memory[0x40:0x60]; memory[0x40:0x60] = temp3 + 0x60; memory[temp3:temp3 + 0x20] = 0x2a; memory[temp3 + 0x20:temp3 + 0x20 + 0x2a] = code[0x2e8c:0x2eb6]; memory[0x00:0x20] = var2; memory[0x20:0x40] = 0x01; var temp4 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp4; var5 = storage[keccak256(memory[0x00:0x40])]; var6 = var3; var7 = temp3; var4 = func_14D3(var5, var6, var7); var temp5 = var2; memory[0x00:0x20] = temp5; memory[0x20:0x40] = 0x01; var temp6 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp6; storage[keccak256(memory[0x00:0x40])] = var4; var4 = 0x08d7; memory[0x00:0x20] = temp5; memory[0x20:0x40] = 0x01; var temp7 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp7; var5 = storage[keccak256(memory[0x00:0x40])]; var6 = var3; var4 = func_152E(var5, var6); memory[0x00:0x20] = var2; memory[0x20:0x40] = 0x01; var temp8 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp8; storage[keccak256(memory[0x00:0x40])] = var4; var1 = var1 + 0x01; if (var1 >= memory[arg2:arg2 + 0x20]) { goto label_0938; } else { goto label_0774; } } } else { var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x0741; var1 = temp9 + 0x04; var0 = func_29E6(var1); var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + var0 - temp10]); } } else { var0 = 0x070a; var1 = arg0; var2 = 0x0705; var2 = func_14C3(); var0 = func_0705(var1, var2); goto label_070B; } } else { var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp11 + 0x04; var0 = 0x06b4; var0 = func_29C6(var1); var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + var0 - temp12]); } } function func_01CE(var arg0, var arg1) returns (var r0) { var var0 = 0x60; if (memory[arg0:arg0 + 0x20] == memory[arg1:arg1 + 0x20]) { var var1 = 0x60; var var2 = memory[arg0:arg0 + 0x20]; var var3 = var2 > 0xffffffffffffffff; if (var3) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; var temp1 = var2; var3 = temp1; var2 = temp0; memory[var2:var2 + 0x20] = var3; memory[0x40:0x60] = var2 + var3 * 0x20 + 0x20; if (!var3) { var1 = var2; var2 = 0x00; if (var2 >= memory[arg0:arg0 + 0x20]) { label_0BAF: return var1; } else { label_0A93: var3 = 0xffffffffffffffffffffffffffffffffffffffff & 0x00; var var4 = arg0; var var5 = var2; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } if (memory[var5 * 0x20 + 0x20 + var4:var5 * 0x20 + 0x20 + var4 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff != var3) { var3 = 0x01; var4 = 0x00; var5 = arg1; var var6 = var2; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var temp2 = var4; memory[temp2:temp2 + 0x20] = memory[var6 * 0x20 + 0x20 + var5:var6 * 0x20 + 0x20 + var5 + 0x20]; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = var3; var3 = keccak256(memory[0x00:0x00 + temp3 + 0x20]); var4 = 0x00; var5 = arg0; var6 = var2; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var temp4 = var4; memory[temp4:temp4 + 0x20] = memory[var6 * 0x20 + 0x20 + var5:var6 * 0x20 + 0x20 + var5 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x20] = var3; var3 = storage[keccak256(memory[0x00:0x00 + temp5 + 0x20])]; var4 = var1; var5 = var2; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } memory[var5 * 0x20 + 0x20 + var4:var5 * 0x20 + 0x20 + var4 + 0x20] = var3; var2 = var2 + 0x01; if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_0BAF; } else { goto label_0A93; } } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var4 = temp6 + 0x04; var3 = 0x0b0c; var3 = func_2966(var4); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + var3 - temp7]); } } } else { var temp8 = var3 * 0x20; memory[var2 + 0x20:var2 + 0x20 + temp8] = msg.data[msg.data.length:msg.data.length + temp8]; var1 = var2; var2 = 0x00; if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_0BAF; } else { goto label_0A93; } } } else { var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var2 = temp9 + 0x04; var1 = 0x0a2e; var1 = func_2A66(var2); var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + var1 - temp10]); } } function func_01FE(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x03; memory[0x00:0x20] = arg0; var temp0 = keccak256(memory[0x00:0x40]); var temp1 = storage[temp0]; var temp2 = (!(temp1 & 0x01) * 0x0100 - 0x01 & temp1) / 0x02; var temp3 = memory[0x40:0x60]; memory[0x40:0x60] = temp3 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20; arg0 = temp3; var var0 = temp0; var var1 = temp2; memory[arg0:arg0 + 0x20] = var1; var var2 = arg0 + 0x20; var var3 = var0; var temp4 = storage[var3]; var var4 = (!(temp4 & 0x01) * 0x0100 - 0x01 & temp4) / 0x02; if (!var4) { label_0C62: return arg0; } else if (0x1f < var4) { var temp5 = var2; var temp6 = temp5 + var4; var2 = temp6; memory[0x00:0x20] = var3; var temp7 = keccak256(memory[0x00:0x20]); memory[temp5:temp5 + 0x20] = storage[temp7]; var3 = temp7 + 0x01; var4 = temp5 + 0x20; if (var2 <= var4) { goto label_0C59; } label_0C45: var temp8 = var3; var temp9 = var4; memory[temp9:temp9 + 0x20] = storage[temp8]; var3 = temp8 + 0x01; var4 = temp9 + 0x20; if (var2 > var4) { goto label_0C45; } label_0C59: var temp10 = var2; var temp11 = temp10 + (var4 - temp10 & 0x1f); var4 = temp10; var2 = temp11; goto label_0C62; } else { var temp12 = var2; memory[temp12:temp12 + 0x20] = storage[var3] / 0x0100 * 0x0100; var2 = temp12 + 0x20; var4 = var4; goto label_0C62; } } function func_022E(var arg0, var arg1) { if (msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x04; if (storage[keccak256(memory[0x00:0x40])] == 0x00 << 0x00) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x04; storage[keccak256(memory[0x00:0x40])] = arg1; return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var1 = temp0 + 0x04; var var0 = 0x0d47; var0 = func_2A06(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp2 + 0x04; var0 = 0x0cef; var0 = func_2AE6(var1); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var0 - temp3]); } } function func_024A(var arg0, var arg1) { var var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0x0d8b; var1 = func_14C3(); if (var1 & 0xffffffffffffffffffffffffffffffffffffffff != var0) { var0 = arg1; var1 = 0x02; var var2 = 0x00; var var3 = 0x0def; var3 = func_14C3(); var temp0 = var2; memory[temp0:temp0 + 0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; var temp1 = temp0 + 0x20; memory[temp1:temp1 + 0x20] = var1; var temp2 = keccak256(memory[0x00:0x00 + temp1 + 0x20]); var temp3 = arg0; memory[0x00:0x20] = temp3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp2; var temp4 = keccak256(memory[0x00:0x40]); storage[temp4] = !!var0 | (storage[temp4] & ~0xff); var0 = temp3 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = 0x0e9c; var1 = func_14C3(); var1 = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31; var3 = 0x0ee1; var var5 = memory[0x40:0x60]; var var4 = arg1; var3 = func_28AE(var4, var5); var temp5 = memory[0x40:0x60]; log(memory[temp5:temp5 + var3 - temp5], [stack[-2], stack[-3], stack[-4]]); return; } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp6 + 0x04; var0 = 0x0dd9; var0 = func_2A46(var1); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + var0 - temp7]); } } function func_0266(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x02; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_0296(var arg0, var arg1, var arg2, var arg3, var arg4) { if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff != 0xffffffffffffffffffffffffffffffffffffffff & 0x00) { var var0 = 0x0ff9; var0 = func_14C3(); var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff == var0 & 0xffffffffffffffffffffffffffffffffffffffff; if (var0) { label_103F: if (var0) { var0 = 0x00; var var1 = 0x1088; var1 = func_14C3(); var temp0 = var1; var0 = temp0; var1 = 0x10a8; var var2 = var0; var var3 = arg0; var var4 = arg1; var var5 = 0x1099; var var6 = arg2; var5 = func_1753(var6); func_1099(arg3, arg4, var2, var3, var4, var5); var1 = 0x1125; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + 0x60; memory[temp1:temp1 + 0x20] = 0x2a; memory[temp1 + 0x20:temp1 + 0x20 + 0x2a] = code[0x2e8c:0x2eb6]; memory[0x00:0x20] = arg2; memory[0x20:0x40] = 0x01; var temp2 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp2; var2 = storage[keccak256(memory[0x00:0x40])]; var3 = arg3; var4 = temp1; var1 = func_14D3(var2, var3, var4); var temp3 = arg2; memory[0x00:0x20] = temp3; memory[0x20:0x40] = 0x01; var temp4 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp4; storage[keccak256(memory[0x00:0x40])] = var1; var1 = 0x11dc; memory[0x00:0x20] = temp3; memory[0x20:0x40] = 0x01; var temp5 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp5; var2 = storage[keccak256(memory[0x00:0x40])]; var3 = arg3; var1 = func_152E(var2, var3); memory[0x00:0x20] = arg2; memory[0x20:0x40] = 0x01; var temp6 = keccak256(memory[0x00:0x40]); var temp7 = arg1; memory[0x00:0x20] = temp7 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp6; storage[keccak256(memory[0x00:0x40])] = var1; var1 = temp7 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var3 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62; var5 = 0x12a6; var6 = arg2; var var7 = arg3; var var8 = memory[0x40:0x60]; var5 = func_2B21(var6, var7, var8); var temp8 = memory[0x40:0x60]; log(memory[temp8:temp8 + var5 - temp8], [stack[-2], stack[-3], stack[-4], stack[-5]]); var1 = 0x12bc; var2 = var0; var3 = arg0; var4 = arg1; var5 = arg2; var6 = arg3; var7 = arg4; func_17C3(var2, var3, var4, var5, var6, var7); return; } else { var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp9 + 0x04; var0 = 0x1075; var0 = func_29A6(var1); var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + var0 - temp10]); } } else { var0 = 0x103e; var1 = arg0; var2 = 0x1039; var2 = func_14C3(); var0 = func_1039(var1, var2); goto label_103F; } } else { var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp11 + 0x04; var0 = 0x0fe8; var0 = func_29C6(var1); var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + var0 - temp12]); } } function func_02B2(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x04; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } function func_0705(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x02; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_09CD() returns (var r0) { return 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81; } function func_1039(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x02; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_1099(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) { var var0 = 0x10a2; var var1 = arg0; var0 = func_1753(var1); var1 = arg1; func_14CB(arg2, arg3, arg4, arg5, var0, var1); // Error: Could not resolve method call return address! } function func_12DC(var arg0, var arg1, var arg2, var arg3) { if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != 0xffffffffffffffffffffffffffffffffffffffff & 0x00) { var var0 = 0x00; var var1 = 0x1356; var1 = func_14C3(); var temp0 = var1; var0 = temp0; var1 = 0x1377; var var2 = var0; var var3 = 0x00; var var4 = arg0; var var5 = 0x1368; var var6 = arg1; var5 = func_1753(var6); func_1368(arg2, arg3, var2, var3, var4, var5); var1 = 0x13da; memory[0x00:0x20] = arg1; memory[0x20:0x40] = 0x01; var temp1 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp1; var2 = storage[keccak256(memory[0x00:0x40])]; var3 = arg2; var1 = func_152E(var2, var3); memory[0x00:0x20] = arg1; memory[0x20:0x40] = 0x01; var temp2 = keccak256(memory[0x00:0x40]); var temp3 = arg0; memory[0x00:0x20] = temp3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp2; storage[keccak256(memory[0x00:0x40])] = var1; var1 = temp3 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0xffffffffffffffffffffffffffffffffffffffff & 0x00; var3 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62; var5 = 0x14a5; var6 = arg1; var var8 = memory[0x40:0x60]; var var7 = arg2; var5 = func_2B21(var6, var7, var8); var temp4 = memory[0x40:0x60]; log(memory[temp4:temp4 + var5 - temp4], [stack[-2], stack[-3], stack[-4], stack[-5]]); var1 = 0x14bc; var2 = var0; var3 = 0x00; var4 = arg0; var5 = arg1; var6 = arg2; var7 = arg3; func_17C3(var2, var3, var4, var5, var6, var7); return; } else { var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x1343; var1 = temp5 + 0x04; var0 = func_2AA6(var1); var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + var0 - temp6]); } } function func_1368(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) { var var0 = 0x1371; var var1 = arg0; var0 = func_1753(var1); var1 = arg1; func_14CB(arg2, arg3, arg4, arg5, var0, var1); // Error: Could not resolve method call return address! } function func_14C3() returns (var r0) { return msg.sender; } function func_14CB(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) {} function func_14D3(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = arg2; if (arg1 <= arg0) { return arg0 - arg1; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = var1; var1 = 0x1512; var var2 = temp1; var var3 = temp0 + 0x04; var1 = func_28E4(var2, var3); var temp2 = memory[0x40:0x60]; revert(memory[temp2:temp2 + var1 - temp2]); } function func_152E(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var temp0 = arg0; var var1 = temp0 + arg1; if (var1 >= temp0) { return var1; } var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var3 = temp1 + 0x04; var var2 = 0x1570; var2 = func_2986(var3); var temp2 = memory[0x40:0x60]; revert(memory[temp2:temp2 + var2 - temp2]); } function func_1583(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) { var var0 = 0x15a2; var var1 = arg2 & 0xffffffffffffffffffffffffffffffffffffffff; var0 = func_1993(var1); if (!var0) { label_174B: return; } else { var0 = arg2 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = 0xbc197c81; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var1 & 0xffffffff) << 0xe0; var var2 = 0x15e8; var var3 = arg0; var var4 = arg1; var var5 = arg3; var var6 = arg4; var var8 = temp0 + 0x04; var var7 = arg5; var2 = func_2793(var3, var4, var5, var6, var7, var8); var3 = 0x20; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; 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]); if (!temp1) { label_1633: if (!var0) { var0 = 0x163f; var0 = func_2D62(); if (var0) { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = 0x167e; var3 = temp4 + 0x04; var2 = var0; var1 = func_28E4(var2, var3); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + var1 - temp5]); } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp6 + 0x04; var0 = 0x16b9; var0 = func_2906(var1); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + var0 - temp7]); } } else if (arg5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0)) { goto label_174B; } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp2 + 0x04; var0 = 0x1740; var0 = func_2926(var1); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var0 - temp3]); } } else { var temp8 = memory[0x40:0x60]; var temp9 = returndata.length; memory[0x40:0x60] = temp8 + (temp9 + 0x1f & ~0x1f); var0 = 0x1630; var2 = temp8; var1 = var2 + temp9; var0 = func_1E8D(var1, var2); var1 = 0x01; goto label_1633; } } } function func_1753(var arg0) returns (var r0) { var var0 = 0x60; var var1 = var0; var var2 = 0x01; var var3 = var2 > 0xffffffffffffffff; if (var3) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; var temp1 = var2; var2 = temp0; var3 = temp1; memory[var2:var2 + 0x20] = var3; memory[0x40:0x60] = var2 + var3 * 0x20 + 0x20; if (!var3) { var temp2 = var2; var1 = temp2; var2 = arg0; var3 = var1; var var4 = 0x00; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } label_17AE: memory[var4 * 0x20 + 0x20 + var3:var4 * 0x20 + 0x20 + var3 + 0x20] = var2; return var1; } else { var temp3 = var2; var temp4 = var3 * 0x20; memory[temp3 + 0x20:temp3 + 0x20 + temp4] = msg.data[msg.data.length:msg.data.length + temp4]; var1 = temp3; var2 = arg0; var3 = var1; var4 = 0x00; if (var4 < memory[var3:var3 + 0x20]) { goto label_17AE; } else { assert(); } } } function func_17C3(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) { var var0 = 0x17e2; var var1 = arg2 & 0xffffffffffffffffffffffffffffffffffffffff; var0 = func_1993(var1); if (!var0) { label_198B: return; } else { var0 = arg2 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = 0xf23a6e61; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var1 & 0xffffffff) << 0xe0; var var2 = 0x1828; var var3 = arg0; var var4 = arg1; var var5 = arg3; var var6 = arg4; var var8 = temp0 + 0x04; var var7 = arg5; var2 = func_27FB(var3, var4, var5, var6, var7, var8); var3 = 0x20; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; 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]); if (!temp1) { label_1873: if (!var0) { var0 = 0x187f; var0 = func_2D62(); if (var0) { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = 0x18be; var3 = temp4 + 0x04; var2 = var0; var1 = func_28E4(var2, var3); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + var1 - temp5]); } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp6 + 0x04; var0 = 0x18f9; var0 = func_2906(var1); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + var0 - temp7]); } } else if (arg5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0)) { goto label_198B; } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp2 + 0x04; var0 = 0x1980; var0 = func_2926(var1); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var0 - temp3]); } } else { var temp8 = memory[0x40:0x60]; var temp9 = returndata.length; memory[0x40:0x60] = temp8 + (temp9 + 0x1f & ~0x1f); var0 = 0x1870; var2 = temp8; var1 = var2 + temp9; var0 = func_1E8D(var1, var2); var1 = 0x01; goto label_1873; } } } function func_1993(var arg0) returns (var r0) { return address(arg0).code.length > 0x00; } function func_19A6(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x19b5; var var2 = var0; func_2E18(var2); return var0; } function func_19BB(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var var1 = msg.data[arg1:arg1 + 0x20]; var var2 = 0x19df; var var3 = 0x19da; var var4 = var1; var3 = func_2B77(var4); var2 = func_19DA(var3); var temp0 = var2; var0 = temp0; var temp1 = var1; memory[var0:var0 + 0x20] = temp1; var temp2 = arg1 + 0x20; arg1 = temp2; var2 = var0 + 0x20; var3 = arg1; if (var3 + temp1 * 0x20 > arg0) { revert(memory[0x00:0x00]); } var4 = 0x00; if (var4 >= var1) { label_1A34: return var0; } else { label_1A10: var var5 = var3; var var6 = 0x1a1a; var var7 = arg0; var var8 = var5; var6 = func_19A6(var7, var8); var temp3 = var2; memory[temp3:temp3 + 0x20] = var6; var2 = temp3 + 0x20; var3 = var3 + 0x20; var4 = var4 + 0x01; if (var4 >= var1) { goto label_1A34; } else { goto label_1A10; } } } function func_19DA(var arg0) returns (var r0) { var temp0 = memory[0x40:0x60]; var var0 = temp0; var temp1 = var0 + arg0; var var1 = temp1; if ((var1 > 0xffffffffffffffff) | (var1 < var0)) { revert(memory[0x00:0x00]); } memory[0x40:0x60] = var1; return var0; } function func_1A3E(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var var1 = msg.data[arg1:arg1 + 0x20]; var var2 = 0x1a62; var var3 = 0x1a5d; var var4 = var1; var3 = func_2B9F(var4); var2 = func_1A5D(var3); var temp0 = var2; var0 = temp0; var temp1 = var1; memory[var0:var0 + 0x20] = temp1; var temp2 = arg1 + 0x20; arg1 = temp2; var2 = var0 + 0x20; var3 = arg1; if (var3 + temp1 * 0x20 > arg0) { revert(memory[0x00:0x00]); } var4 = 0x00; if (var4 >= var1) { label_1AB7: return var0; } else { label_1A93: var var5 = var3; var var6 = 0x1a9d; var var7 = arg0; var var8 = var5; var6 = func_1B69(var7, var8); var temp3 = var2; memory[temp3:temp3 + 0x20] = var6; var2 = temp3 + 0x20; var3 = var3 + 0x20; var4 = var4 + 0x01; if (var4 >= var1) { goto label_1AB7; } else { goto label_1A93; } } } function func_1A5D(var arg0) returns (var r0) { var temp0 = memory[0x40:0x60]; var var0 = temp0; var temp1 = var0 + arg0; var var1 = temp1; if ((var1 > 0xffffffffffffffff) | (var1 < var0)) { revert(memory[0x00:0x00]); } memory[0x40:0x60] = var1; return var0; } function func_1AC1(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1ad0; var var2 = var0; func_2E2F(var2); return var0; } function func_1AD6(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1ae5; var var2 = var0; func_2E46(var2); return var0; } function func_1AEB(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1afa; var var2 = var0; func_2E5D(var2); return var0; } function func_1B00(var arg0, var arg1) returns (var r0) { var var0 = memory[arg1:arg1 + 0x20]; var var1 = 0x1b0f; var var2 = var0; func_2E5D(var2); return var0; } function func_1B15(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var var1 = msg.data[arg1:arg1 + 0x20]; var var2 = 0x1b39; var var3 = 0x1b34; var var4 = var1; var3 = func_2BC7(var4); var2 = func_1B34(var3); var temp0 = var2; var0 = temp0; var temp1 = var1; memory[var0:var0 + 0x20] = temp1; var2 = arg1 + 0x20; var3 = var0 + 0x20; if (var2 + temp1 > arg0) { revert(memory[0x00:0x00]); } var4 = 0x1b60; var var5 = var1; var var6 = var3; var var7 = var2; func_2D02(var5, var6, var7); return var0; } function func_1B34(var arg0) returns (var r0) { var temp0 = memory[0x40:0x60]; var var0 = temp0; var temp1 = var0 + arg0; var var1 = temp1; if ((var1 > 0xffffffffffffffff) | (var1 < var0)) { revert(memory[0x00:0x00]); } memory[0x40:0x60] = var1; return var0; } function func_1B69(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1b78; var var2 = var0; func_2E74(var2); return var0; } function func_1B7E(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x1b9f; var var4 = arg0; var var5 = arg1 + var2; var3 = func_19A6(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1bb0; var4 = arg0; var5 = arg1 + var2; var3 = func_19A6(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_1BBA(var arg0, var arg1) returns (var r0, var arg0, var arg1, var r3, var r4) { r3 = 0x00; r4 = r3; var var2 = 0x00; var var3 = var2; var var4 = 0x00; if (arg0 - arg1 i< 0xa0) { revert(memory[0x00:0x00]); } var var5 = 0x00; var var6 = 0x1be0; var var7 = arg0; var var8 = arg1 + var5; var6 = func_19A6(var7, var8); r3 = var6; var5 = 0x20; var6 = 0x1bf1; var7 = arg0; var8 = arg1 + var5; var6 = func_19A6(var7, var8); r4 = var6; var5 = msg.data[arg1 + 0x40:arg1 + 0x40 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x1c1a; var7 = arg0; var8 = arg1 + var5; var6 = func_1A3E(var7, var8); var2 = var6; var5 = msg.data[arg1 + 0x60:arg1 + 0x60 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x1c43; var7 = arg0; var8 = arg1 + var5; var6 = func_1A3E(var7, var8); var3 = var6; var5 = msg.data[arg1 + 0x80:arg1 + 0x80 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x1c6c; var7 = arg0; var8 = arg1 + var5; var6 = func_1B15(var7, var8); var temp0 = r4; r4 = var6; arg0 = temp0; var temp1 = r3; r3 = var3; r0 = temp1; arg1 = var2; return r0, arg0, arg1, r3, r4; } function func_1C79(var arg0, var arg1) returns (var r0, var arg0, var arg1, var r3, var r4) { r3 = 0x00; r4 = r3; var var2 = 0x00; var var3 = var2; var var4 = 0x00; if (arg0 - arg1 i< 0xa0) { revert(memory[0x00:0x00]); } var var5 = 0x00; var var6 = 0x1c9f; var var7 = arg0; var var8 = arg1 + var5; var6 = func_19A6(var7, var8); r3 = var6; var5 = 0x20; var6 = 0x1cb0; var7 = arg0; var8 = arg1 + var5; var6 = func_19A6(var7, var8); r4 = var6; var5 = 0x40; var6 = 0x1cc1; var7 = arg0; var8 = arg1 + var5; var6 = func_1B69(var7, var8); var2 = var6; var5 = 0x60; var6 = 0x1cd2; var7 = arg0; var8 = arg1 + var5; var6 = func_1B69(var7, var8); var3 = var6; var5 = msg.data[arg1 + 0x80:arg1 + 0x80 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x1cfb; var7 = arg0; var8 = arg1 + var5; var6 = func_1B15(var7, var8); var temp0 = r4; r4 = var6; arg0 = temp0; var temp1 = r3; r3 = var3; r0 = temp1; arg1 = var2; return r0, arg0, arg1, r3, r4; } function func_1D08(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x1d29; var var4 = arg0; var var5 = arg1 + var2; var3 = func_19A6(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1d3a; var4 = arg0; var5 = arg1 + var2; var3 = func_1AC1(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_1D44(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x1d65; var var4 = arg0; var var5 = arg1 + var2; var3 = func_19A6(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1d76; var4 = arg0; var5 = arg1 + var2; var3 = func_1B69(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_1D80(var arg0, var arg1) returns (var r0, var arg0, var arg1) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; if (arg0 - arg1 i< 0x60) { revert(memory[0x00:0x00]); } var var3 = 0x00; var var4 = 0x1da3; var var5 = arg0; var var6 = arg1 + var3; var4 = func_19A6(var5, var6); var0 = var4; var3 = 0x20; var4 = 0x1db4; var5 = arg0; var6 = arg1 + var3; var4 = func_1B69(var5, var6); var1 = var4; var3 = 0x40; var4 = 0x1dc5; var5 = arg0; var6 = arg1 + var3; var4 = func_1B69(var5, var6); arg1 = var4; arg0 = var1; r0 = var0; return r0, arg0, arg1; } function func_1DCF(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = msg.data[arg1:arg1 + 0x20]; if (var2 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var var3 = 0x1e08; var var4 = arg0; var var5 = arg1 + var2; var3 = func_19BB(var4, var5); var0 = var3; var2 = msg.data[arg1 + 0x20:arg1 + 0x20 + 0x20]; if (var2 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var3 = 0x1e31; var4 = arg0; var5 = arg1 + var2; var3 = func_1A3E(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_1E3B(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = 0x00; var var2 = 0x1e5b; var var3 = arg0; var var4 = arg1 + var1; return func_1AD6(var3, var4); } function func_1E64(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = 0x00; var var2 = 0x1e84; var var3 = arg0; var var4 = arg1 + var1; return func_1AEB(var3, var4); } function func_1E8D(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = 0x00; var var2 = 0x1ead; var var3 = arg0; var var4 = arg1 + var1; return func_1B00(var3, var4); } function func_1EB6(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = 0x00; var var2 = 0x1ed6; var var3 = arg0; var var4 = arg1 + var1; return func_1B69(var3, var4); } function func_1EDF(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x1f00; var var4 = arg0; var var5 = arg1 + var2; var3 = func_1B69(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1f11; var4 = arg0; var5 = arg1 + var2; var3 = func_1AD6(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_1F1B(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1f27; var var2 = arg0; var var3 = arg1; func_2738(var2, var3); return arg0 + 0x20; } function func_1F33(var arg0, var arg1) { var var0 = 0x1f3c; var var1 = arg1; var0 = func_2C84(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1F42(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1f4d; var var2 = arg1; var1 = func_2C18(var2); var2 = 0x1f57; var var3 = var1; var var4 = arg0; var2 = func_2C46(var3, var4); arg0 = var2; var2 = 0x1f62; var3 = arg1; var2 = func_2BF3(var3); var3 = var2; var4 = 0x00; if (var4 >= var1) { label_1F93: return arg0; } else { label_1F6F: var var5 = memory[var3:var3 + 0x20]; var var6 = 0x1f7a; var var7 = arg0; var var8 = var5; var6 = func_1F1B(var7, var8); arg0 = var6; var6 = 0x1f85; var7 = var3; var6 = func_2C39(var7); var3 = var6; var4 = var4 + 0x01; if (var4 >= var1) { goto label_1F93; } else { goto label_1F6F; } } } function func_1FA0(var arg0, var arg1) { var var0 = 0x1fa9; var var1 = arg1; var0 = func_2C96(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1FAF(var arg0, var arg1) { var var0 = 0x1fb8; var var1 = arg1; var0 = func_2CA2(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1FBE(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1fc9; var var2 = arg1; var1 = func_2C23(var2); var2 = 0x1fd3; var var3 = var1; var var4 = arg0; var2 = func_2C57(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x1fe3; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_2D11(var3, var4, var5); var2 = 0x1fec; var3 = var1; var2 = func_2D44(var3); return arg0 + var2; } function func_1FF7(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2002; var var2 = arg1; var1 = func_2C2E(var2); var2 = 0x200c; var var3 = var1; var var4 = arg0; var2 = func_2C68(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x201c; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_2D11(var3, var4, var5); var2 = 0x2025; var3 = var1; var2 = func_2D44(var3); return arg0 + var2; } function func_2030(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = storage[arg1]; var var2 = var1 & 0x01; if (var2 == 0x00) { var var3 = var1 / 0x02 & 0x7f; var var4 = 0x205e; var var5 = var3; var var6 = arg0; var4 = func_2C79(var5, var6); var temp0 = var4; arg0 = temp0; memory[arg0:arg0 + 0x20] = var1 & ~0xff; var0 = arg0 + var3; label_20B6: return var0; } else if (var2 == 0x01) { var3 = var1 / 0x02; var4 = 0x2080; var5 = var3; var6 = arg0; var4 = func_2C79(var5, var6); arg0 = var4; var4 = 0x208b; var5 = arg1; var4 = func_2C03(var5); var5 = 0x00; if (var5 >= var3) { label_20AD: var0 = arg0 + var3; goto label_20B6; } else { label_2097: var temp1 = var4; var temp2 = var5; memory[arg0 + temp2:arg0 + temp2 + 0x20] = storage[temp1]; var4 = temp1 + 0x01; var5 = temp2 + 0x20; if (var5 >= var3) { goto label_20AD; } else { goto label_2097; } } } else { goto label_20B6; } } function func_20BE(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x20cb; var var2 = 0x34; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x526563656976657220696d706c656d656e746572000000000000000000000000; return temp0 + 0x40; } function func_2124(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2131; var var2 = 0x28; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6420746f6b656e73000000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_218A(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2197; var var2 = 0x2b; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_21F0(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x21fd; var var2 = 0x31; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a2062617463682062616c616e636520717565727920666f72; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x20746865207a65726f2061646472657373000000000000000000000000000000; return temp0 + 0x40; } function func_2256(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2263; var var2 = 0x1b; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000; return temp0 + 0x20; } function func_2296(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x22a3; var var2 = 0x29; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x20617070726f7665640000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_22FC(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2309; var var2 = 0x25; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6472657373000000000000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_2362(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x236f; var var2 = 0x32; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000; return temp0 + 0x40; } function func_23C8(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x23d5; var var2 = 0x26; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x5065706556323a2063616e206f6e6c792073657420746f6b656e204944207369; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x67206f6e63650000000000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_242E(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x243b; var var2 = 0x0c; var var3 = arg0; var1 = func_2C79(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x697066733a2f2f697066732f0000000000000000000000000000000000000000; return temp0 + 0x0c; } function func_246E(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x247b; var var2 = 0x29; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x5065706556323a2043616e206f6e6c79206d696e742066726f6d206d696e7465; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x7220616464726573730000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_24D4(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x24e1; var var2 = 0x29; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x20666f722073656c660000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_253A(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2547; var var2 = 0x29; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_25A0(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x25ad; var var2 = 0x28; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6d69736d61746368000000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_2606(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2613; var var2 = 0x21; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000; return temp0 + 0x40; } function func_266C(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2679; var var2 = 0x2f; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x5065706556323a2043616e206f6e6c792072657475726e2055524920666f7220; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6b6e6f776e20746f6b656e204944730000000000000000000000000000000000; return temp0 + 0x40; } function func_26D2(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x26df; var var2 = 0x31; var var3 = arg0; var1 = func_2C68(var2, var3); var temp0 = var1; memory[temp0:temp0 + 0x20] = 0x5065706556323a2043616e206f6e6c792073657420746f6b656e204944206672; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6f6d206d696e7465722061646472657373000000000000000000000000000000; return temp0 + 0x40; } function func_2738(var arg0, var arg1) { var var0 = 0x2741; var var1 = arg1; var0 = func_2CF8(var1); memory[arg0:arg0 + 0x20] = var0; } function func_2747(var arg0, var arg1) { var var0 = 0x2750; var var1 = arg1; var0 = func_2CF8(var1); memory[arg0:arg0 + 0x20] = var0; } function func_2756(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2761; var var2 = arg1; var1 = func_242E(var2); var temp0 = var1; arg1 = temp0; var1 = 0x276d; var2 = arg1; var var3 = arg0; return func_2030(var2, var3); } function func_2778(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x278d; var var2 = temp0; var var3 = arg0; func_1F33(var2, var3); return var0; } function func_2793(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) { var temp0 = arg5; var var0 = temp0 + 0xa0; var var1 = 0x27a8; var var2 = temp0; var var3 = arg0; func_1F33(var2, var3); var1 = 0x27b5; var2 = arg5 + 0x20; var3 = arg1; func_1F33(var2, var3); var temp1 = arg5; memory[temp1 + 0x40:temp1 + 0x40 + 0x20] = var0 - temp1; var1 = 0x27c7; var2 = var0; var3 = arg2; var1 = func_1F42(var2, var3); var temp2 = var1; var0 = temp2; var temp3 = arg5; memory[temp3 + 0x60:temp3 + 0x60 + 0x20] = var0 - temp3; var1 = 0x27db; var2 = var0; var3 = arg3; var1 = func_1F42(var2, var3); var temp4 = var1; var0 = temp4; var temp5 = arg5; memory[temp5 + 0x80:temp5 + 0x80 + 0x20] = var0 - temp5; var1 = 0x27ef; var2 = var0; var3 = arg4; return func_1FBE(var2, var3); } function func_27FB(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) { var temp0 = arg5; var var0 = temp0 + 0xa0; var var1 = 0x2810; var var2 = temp0; var var3 = arg0; func_1F33(var2, var3); var1 = 0x281d; var2 = arg5 + 0x20; var3 = arg1; func_1F33(var2, var3); var1 = 0x282a; var2 = arg5 + 0x40; var3 = arg2; func_2747(var2, var3); var1 = 0x2837; var2 = arg5 + 0x60; var3 = arg3; func_2747(var2, var3); var temp1 = arg5; memory[temp1 + 0x80:temp1 + 0x80 + 0x20] = var0 - temp1; var1 = 0x2849; var2 = var0; var3 = arg4; return func_1FBE(var2, var3); } function func_2855(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x286f; var var2 = var0; var var3 = arg0; return func_1F42(var2, var3); } function func_2877(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg2; var var0 = temp0 + 0x40; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2891; var var2 = var0; var var3 = arg0; var1 = func_1F42(var2, var3); var temp1 = var1; var0 = temp1; var temp2 = arg2; memory[temp2 + 0x20:temp2 + 0x20 + 0x20] = var0 - temp2; var1 = 0x28a5; var2 = var0; var3 = arg1; return func_1F42(var2, var3); } function func_28AE(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x28c3; var var2 = temp0; var var3 = arg0; func_1FA0(var2, var3); return var0; } function func_28C9(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x28de; var var2 = temp0; var var3 = arg0; func_1FAF(var2, var3); return var0; } function func_28E4(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x28fe; var var2 = var0; var var3 = arg0; return func_1FF7(var2, var3); } function func_2906(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x291f; var var2 = var0; return func_20BE(var2); } function func_2926(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x293f; var var2 = var0; return func_2124(var2); } function func_2946(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x295f; var var2 = var0; return func_218A(var2); } function func_2966(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x297f; var var2 = var0; return func_21F0(var2); } function func_2986(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x299f; var var2 = var0; return func_2256(var2); } function func_29A6(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x29bf; var var2 = var0; return func_2296(var2); } function func_29C6(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x29df; var var2 = var0; return func_22FC(var2); } function func_29E6(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x29ff; var var2 = var0; return func_2362(var2); } function func_2A06(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2a1f; var var2 = var0; return func_23C8(var2); } function func_2A26(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2a3f; var var2 = var0; return func_246E(var2); } function func_2A46(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2a5f; var var2 = var0; return func_24D4(var2); } function func_2A66(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2a7f; var var2 = var0; return func_253A(var2); } function func_2A86(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2a9f; var var2 = var0; return func_25A0(var2); } function func_2AA6(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2abf; var var2 = var0; return func_2606(var2); } function func_2AC6(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2adf; var var2 = var0; return func_266C(var2); } function func_2AE6(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2aff; var var2 = var0; return func_26D2(var2); } function func_2B06(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x2b1b; var var2 = temp0; var var3 = arg0; func_2747(var2, var3); return var0; } function func_2B21(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg2; var var0 = temp0 + 0x40; var var1 = 0x2b36; var var2 = temp0; var var3 = arg0; func_2747(var2, var3); var1 = 0x2b43; var2 = arg2 + 0x20; var3 = arg1; func_2747(var2, var3); return var0; } function func_2B77(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { return arg0 * 0x20 + 0x20; } else { revert(memory[0x00:0x00]); } } function func_2B9F(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { return arg0 * 0x20 + 0x20; } else { revert(memory[0x00:0x00]); } } function func_2BC7(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { return (arg0 + 0x1f & ~0x1f) + 0x20; } else { revert(memory[0x00:0x00]); } } function func_2BF3(var arg0) returns (var r0) { return arg0 + 0x20; } function func_2C03(var arg0) returns (var r0) { memory[0x00:0x20] = arg0; return keccak256(memory[0x00:0x20]); } function func_2C18(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_2C23(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_2C2E(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_2C39(var arg0) returns (var r0) { return arg0 + 0x20; } function func_2C46(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_2C57(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_2C68(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_2C79(var arg0, var arg1) returns (var r0) { return arg1; } function func_2C84(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2c8f; var var2 = arg0; return func_2CD8(var2); } function func_2C96(var arg0) returns (var r0) { return !!arg0; } function func_2CA2(var arg0) returns (var r0) { return arg0; } function func_2CAC(var arg0) returns (var r0) { return arg0 & 0xffffffff00000000000000000000000000000000000000000000000000000000; } function func_2CD8(var arg0) returns (var r0) { return arg0 & 0xffffffffffffffffffffffffffffffffffffffff; } function func_2CF8(var arg0) returns (var r0) { return arg0; } function func_2D02(var arg0, var arg1, var arg2) { var temp0 = arg0; var temp1 = arg1; memory[temp1:temp1 + temp0] = msg.data[arg2:arg2 + temp0]; memory[temp1 + temp0:temp1 + temp0 + 0x20] = 0x00; } function func_2D11(var arg0, var arg1, var arg2) { var var0 = 0x00; if (var0 >= arg0) { label_2D2F: if (var0 <= arg0) { return; } memory[arg1 + arg0:arg1 + arg0 + 0x20] = 0x00; return; } else { label_2D1D: var temp0 = var0; memory[arg1 + temp0:arg1 + temp0 + 0x20] = memory[arg2 + temp0:arg2 + temp0 + 0x20]; var0 = temp0 + 0x20; if (var0 >= arg0) { goto label_2D2F; } else { goto label_2D1D; } } } function func_2D44(var arg0) returns (var r0) { return arg0 + 0x1f & ~0x1f; } function func_2D55(var arg0) returns (var r0) { return arg0 >> 0xe0; } function func_2D62() returns (var r0) { var var0 = 0x00; if (returndata.length < 0x44) { goto label_2E15; } memory[0x00:0x04] = returndata[0x00:0x04]; var var1 = 0x2d83; var var2 = memory[0x00:0x20]; var1 = func_2D55(var2); if (var1 != 0x08c379a0) { goto label_2E15; } var temp0 = memory[0x40:0x60]; var2 = temp0; var temp1 = returndata.length - 0x04; memory[var2:var2 + temp1] = returndata[0x04:0x04 + temp1]; var temp2 = memory[var2:var2 + 0x20]; var var3 = temp2; if ((var3 > 0xffffffffffffffff) | (var3 + 0x24 > returndata.length)) { goto label_2E15; } var var4 = var2 + var3; var var5 = memory[var4:var4 + 0x20]; if (var5 > 0xffffffffffffffff) { goto label_2E15; } var var6 = var4 + 0x20 + var5; if (var6 > var2 + returndata.length) { goto label_2E15; } var var7 = 0x2e03; var var8 = var5; var7 = func_2D44(var8); memory[0x40:0x60] = var4 + 0x20 + var7; var0 = var4; label_2E15: return var0; } function func_2E18(var arg0) { var var0 = 0x2e21; var var1 = arg0; var0 = func_2C84(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_2E2F(var arg0) { var var0 = 0x2e38; var var1 = arg0; var0 = func_2C96(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_2E46(var arg0) { var var0 = 0x2e4f; var var1 = arg0; var0 = func_2CA2(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_2E5D(var arg0) { var var0 = 0x2e66; var var1 = arg0; var0 = func_2CAC(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_2E74(var arg0) { var var0 = 0x2e7d; var var1 = arg0; var0 = func_2CF8(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x00ce 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00ce, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x4e1273f4 0026 11 GT 0027 61 PUSH2 0x008c 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x008c, if 0x4e1273f4 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x4e1273f4 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa22cb465 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xa22cb465 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xa22cb465 003C 14 EQ 003D 61 PUSH2 0x0235 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0235, if 0xa22cb465 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x0251 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0251, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x0281 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0281, if 0xf242432a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf242432a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xfab03a55 005D 14 EQ 005E 61 PUSH2 0x029d 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029d, if 0xfab03a55 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xfab03a55 == stack[-1] 0062 61 PUSH2 0x00ce 0065 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ce label_0066: // Incoming jump from 0x0035, if 0xa22cb465 > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x4e1273f4 006D 14 EQ 006E 61 PUSH2 0x01b9 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b9, if 0x4e1273f4 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x5cfeed1a 0078 14 EQ 0079 61 PUSH2 0x01e9 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e9, if 0x5cfeed1a == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x5cfeed1a == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x839f8ca3 0083 14 EQ 0084 61 PUSH2 0x0219 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0219, if 0x839f8ca3 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x839f8ca3 == stack[-1] 0088 61 PUSH2 0x00ce 008B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00ce label_008C: // Incoming jump from 0x002A, if 0x4e1273f4 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @008D stack[-1] } 008C 5B JUMPDEST 008D 80 DUP1 008E 62 PUSH3 0xfdd58e 0092 14 EQ 0093 61 PUSH2 0x00d3 0096 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0xfdd58e == stack[-1] label_0097: // Incoming jump from 0x0096, if not 0xfdd58e == stack[-1] // Inputs[1] { @0097 stack[-1] } 0097 80 DUP1 0098 63 PUSH4 0x01ffc9a7 009D 14 EQ 009E 61 PUSH2 0x0103 00A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0103, if 0x01ffc9a7 == stack[-1] label_00A2: // Incoming jump from 0x00A1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @00A2 stack[-1] } 00A2 80 DUP1 00A3 63 PUSH4 0x0e89341c 00A8 14 EQ 00A9 61 PUSH2 0x0133 00AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0133, if 0x0e89341c == stack[-1] label_00AD: // Incoming jump from 0x00AC, if not 0x0e89341c == stack[-1] // Inputs[1] { @00AD stack[-1] } 00AD 80 DUP1 00AE 63 PUSH4 0x156e29f6 00B3 14 EQ 00B4 61 PUSH2 0x0163 00B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0163, if 0x156e29f6 == stack[-1] label_00B8: // Incoming jump from 0x00B7, if not 0x156e29f6 == stack[-1] // Inputs[1] { @00B8 stack[-1] } 00B8 80 DUP1 00B9 63 PUSH4 0x2eb2c2d6 00BE 14 EQ 00BF 61 PUSH2 0x017f 00C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017f, if 0x2eb2c2d6 == stack[-1] label_00C3: // Incoming jump from 0x00C2, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @00C3 stack[-1] } 00C3 80 DUP1 00C4 63 PUSH4 0x34d722c9 00C9 14 EQ 00CA 61 PUSH2 0x019b 00CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019b, if 0x34d722c9 == stack[-1] label_00CE: // Incoming jump from 0x00CD, if not 0x34d722c9 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0065 // Incoming jump from 0x008B // Inputs[1] { @00D2 memory[0x00:0x00] } 00CE 5B JUMPDEST 00CF 60 PUSH1 0x00 00D1 80 DUP1 00D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D2 revert(memory[0x00:0x00]); } // Block terminates label_00D3: // Incoming jump from 0x0096, if 0xfdd58e == stack[-1] // Inputs[1] { @00DA msg.data.length } 00D3 5B JUMPDEST 00D4 61 PUSH2 0x00ed 00D7 60 PUSH1 0x04 00D9 80 DUP1 00DA 36 CALLDATASIZE 00DB 03 SUB 00DC 81 DUP2 00DD 01 ADD 00DE 90 SWAP1 00DF 61 PUSH2 0x00e8 00E2 91 SWAP2 00E3 90 SWAP1 00E4 61 PUSH2 0x1d44 00E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00D4 stack[0] = 0x00ed // @00E2 stack[1] = 0x00e8 // @00E3 stack[2] = 0x04 + (msg.data.length - 0x04) // @00E3 stack[3] = 0x04 // } // Block ends with call to 0x1d44, returns to 0x00E8 label_00E8: // Incoming return from call to 0x1D44 at 0x00E7 00E8 5B JUMPDEST 00E9 61 PUSH2 0x02cd 00EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02cd label_00ED: // Incoming return from call to 0x00E8 at 0x00E7 // Inputs[2] // { // @00F0 memory[0x40:0x60] // @00F4 stack[-1] // } 00ED 5B JUMPDEST 00EE 60 PUSH1 0x40 00F0 51 MLOAD 00F1 61 PUSH2 0x00fa 00F4 91 SWAP2 00F5 90 SWAP1 00F6 61 PUSH2 0x2b06 00F9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00F4 stack[-1] = 0x00fa // @00F5 stack[1] = memory[0x40:0x60] // @00F5 stack[0] = stack[-1] // } // Block ends with call to 0x2b06, returns to 0x00FA label_00FA: // Incoming return from call to 0x2B06 at 0x00F9 // Inputs[3] // { // @00FD memory[0x40:0x60] // @00FF stack[-1] // @0102 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00FA 5B JUMPDEST 00FB 60 PUSH1 0x40 00FD 51 MLOAD 00FE 80 DUP1 00FF 91 SWAP2 0100 03 SUB 0101 90 SWAP1 0102 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0102 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0103: // Incoming jump from 0x00A1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @010A msg.data.length } 0103 5B JUMPDEST 0104 61 PUSH2 0x011d 0107 60 PUSH1 0x04 0109 80 DUP1 010A 36 CALLDATASIZE 010B 03 SUB 010C 81 DUP2 010D 01 ADD 010E 90 SWAP1 010F 61 PUSH2 0x0118 0112 91 SWAP2 0113 90 SWAP1 0114 61 PUSH2 0x1e64 0117 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0104 stack[0] = 0x011d // @0112 stack[1] = 0x0118 // @0113 stack[2] = 0x04 + (msg.data.length - 0x04) // @0113 stack[3] = 0x04 // } // Block ends with call to 0x1e64, returns to 0x0118 label_0118: // Incoming return from call to 0x1E64 at 0x0117 0118 5B JUMPDEST 0119 61 PUSH2 0x0397 011C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0397 label_011D: // Incoming return from call to 0x0118 at 0x0117 // Inputs[2] // { // @0120 memory[0x40:0x60] // @0124 stack[-1] // } 011D 5B JUMPDEST 011E 60 PUSH1 0x40 0120 51 MLOAD 0121 61 PUSH2 0x012a 0124 91 SWAP2 0125 90 SWAP1 0126 61 PUSH2 0x28ae 0129 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0124 stack[-1] = 0x012a // @0125 stack[1] = memory[0x40:0x60] // @0125 stack[0] = stack[-1] // } // Block ends with call to 0x28ae, returns to 0x012A label_012A: // Incoming return from call to 0x28AE at 0x0129 // Inputs[3] // { // @012D memory[0x40:0x60] // @012F stack[-1] // @0132 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 012A 5B JUMPDEST 012B 60 PUSH1 0x40 012D 51 MLOAD 012E 80 DUP1 012F 91 SWAP2 0130 03 SUB 0131 90 SWAP1 0132 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0132 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0133: // Incoming jump from 0x00AC, if 0x0e89341c == stack[-1] // Inputs[1] { @013A msg.data.length } 0133 5B JUMPDEST 0134 61 PUSH2 0x014d 0137 60 PUSH1 0x04 0139 80 DUP1 013A 36 CALLDATASIZE 013B 03 SUB 013C 81 DUP2 013D 01 ADD 013E 90 SWAP1 013F 61 PUSH2 0x0148 0142 91 SWAP2 0143 90 SWAP1 0144 61 PUSH2 0x1eb6 0147 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0134 stack[0] = 0x014d // @0142 stack[1] = 0x0148 // @0143 stack[2] = 0x04 + (msg.data.length - 0x04) // @0143 stack[3] = 0x04 // } // Block ends with call to 0x1eb6, returns to 0x0148 label_0148: // Incoming return from call to 0x1EB6 at 0x0147 0148 5B JUMPDEST 0149 61 PUSH2 0x03fe 014C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03fe label_014D: // Incoming return from call to 0x0148 at 0x0147 // Inputs[2] // { // @0150 memory[0x40:0x60] // @0154 stack[-1] // } 014D 5B JUMPDEST 014E 60 PUSH1 0x40 0150 51 MLOAD 0151 61 PUSH2 0x015a 0154 91 SWAP2 0155 90 SWAP1 0156 61 PUSH2 0x28e4 0159 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0154 stack[-1] = 0x015a // @0155 stack[1] = memory[0x40:0x60] // @0155 stack[0] = stack[-1] // } // Block ends with call to 0x28e4, returns to 0x015A label_015A: // Incoming return from call to 0x28E4 at 0x0159 // Inputs[3] // { // @015D memory[0x40:0x60] // @015F stack[-1] // @0162 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 015A 5B JUMPDEST 015B 60 PUSH1 0x40 015D 51 MLOAD 015E 80 DUP1 015F 91 SWAP2 0160 03 SUB 0161 90 SWAP1 0162 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0162 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0163: // Incoming jump from 0x00B7, if 0x156e29f6 == stack[-1] // Inputs[1] { @016A msg.data.length } 0163 5B JUMPDEST 0164 61 PUSH2 0x017d 0167 60 PUSH1 0x04 0169 80 DUP1 016A 36 CALLDATASIZE 016B 03 SUB 016C 81 DUP2 016D 01 ADD 016E 90 SWAP1 016F 61 PUSH2 0x0178 0172 91 SWAP2 0173 90 SWAP1 0174 61 PUSH2 0x1d80 0177 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0164 stack[0] = 0x017d // @0172 stack[1] = 0x0178 // @0173 stack[2] = 0x04 + (msg.data.length - 0x04) // @0173 stack[3] = 0x04 // } // Block ends with call to 0x1d80, returns to 0x0178 label_0178: // Incoming return from call to 0x1D80 at 0x0177 0178 5B JUMPDEST 0179 61 PUSH2 0x0535 017C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0535 label_017D: // Incoming return from call to 0x0178 at 0x0177 017D 5B JUMPDEST 017E 00 *STOP // Stack delta = +0 // Outputs[1] { @017E stop(); } // Block terminates label_017F: // Incoming jump from 0x00C2, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0186 msg.data.length } 017F 5B JUMPDEST 0180 61 PUSH2 0x0199 0183 60 PUSH1 0x04 0185 80 DUP1 0186 36 CALLDATASIZE 0187 03 SUB 0188 81 DUP2 0189 01 ADD 018A 90 SWAP1 018B 61 PUSH2 0x0194 018E 91 SWAP2 018F 90 SWAP1 0190 61 PUSH2 0x1bba 0193 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0180 stack[0] = 0x0199 // @018E stack[1] = 0x0194 // @018F stack[2] = 0x04 + (msg.data.length - 0x04) // @018F stack[3] = 0x04 // } // Block ends with call to 0x1bba, returns to 0x0194 label_0194: // Incoming return from call to 0x1BBA at 0x0193 0194 5B JUMPDEST 0195 61 PUSH2 0x0609 0198 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0609 label_0199: // Incoming return from call to 0x0194 at 0x0193 0199 5B JUMPDEST 019A 00 *STOP // Stack delta = +0 // Outputs[1] { @019A stop(); } // Block terminates label_019B: // Incoming jump from 0x00CD, if 0x34d722c9 == stack[-1] 019B 5B JUMPDEST 019C 61 PUSH2 0x01a3 019F 61 PUSH2 0x09cd 01A2 56 *JUMP // Stack delta = +1 // Outputs[1] { @019C stack[0] = 0x01a3 } // Block ends with call to 0x09cd, returns to 0x01A3 label_01A3: // Incoming return from call to 0x09CD at 0x01A2 // Inputs[2] // { // @01A6 memory[0x40:0x60] // @01AA stack[-1] // } 01A3 5B JUMPDEST 01A4 60 PUSH1 0x40 01A6 51 MLOAD 01A7 61 PUSH2 0x01b0 01AA 91 SWAP2 01AB 90 SWAP1 01AC 61 PUSH2 0x2778 01AF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01AA stack[-1] = 0x01b0 // @01AB stack[1] = memory[0x40:0x60] // @01AB stack[0] = stack[-1] // } // Block ends with call to 0x2778, returns to 0x01B0 label_01B0: // Incoming return from call to 0x2778 at 0x01AF // Inputs[3] // { // @01B3 memory[0x40:0x60] // @01B5 stack[-1] // @01B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01B0 5B JUMPDEST 01B1 60 PUSH1 0x40 01B3 51 MLOAD 01B4 80 DUP1 01B5 91 SWAP2 01B6 03 SUB 01B7 90 SWAP1 01B8 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01B9: // Incoming jump from 0x0071, if 0x4e1273f4 == stack[-1] // Inputs[1] { @01C0 msg.data.length } 01B9 5B JUMPDEST 01BA 61 PUSH2 0x01d3 01BD 60 PUSH1 0x04 01BF 80 DUP1 01C0 36 CALLDATASIZE 01C1 03 SUB 01C2 81 DUP2 01C3 01 ADD 01C4 90 SWAP1 01C5 61 PUSH2 0x01ce 01C8 91 SWAP2 01C9 90 SWAP1 01CA 61 PUSH2 0x1dcf 01CD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01BA stack[0] = 0x01d3 // @01C8 stack[1] = 0x01ce // @01C9 stack[2] = 0x04 + (msg.data.length - 0x04) // @01C9 stack[3] = 0x04 // } // Block ends with call to 0x1dcf, returns to 0x01CE label_01CE: // Incoming return from call to 0x1DCF at 0x01CD 01CE 5B JUMPDEST 01CF 61 PUSH2 0x09f1 01D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09f1 label_01D3: // Incoming return from call to 0x01CE at 0x01CD // Inputs[2] // { // @01D6 memory[0x40:0x60] // @01DA stack[-1] // } 01D3 5B JUMPDEST 01D4 60 PUSH1 0x40 01D6 51 MLOAD 01D7 61 PUSH2 0x01e0 01DA 91 SWAP2 01DB 90 SWAP1 01DC 61 PUSH2 0x2855 01DF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01DA stack[-1] = 0x01e0 // @01DB stack[1] = memory[0x40:0x60] // @01DB stack[0] = stack[-1] // } // Block ends with call to 0x2855, returns to 0x01E0 label_01E0: // Incoming return from call to 0x2855 at 0x01DF // Inputs[3] // { // @01E3 memory[0x40:0x60] // @01E5 stack[-1] // @01E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01E0 5B JUMPDEST 01E1 60 PUSH1 0x40 01E3 51 MLOAD 01E4 80 DUP1 01E5 91 SWAP2 01E6 03 SUB 01E7 90 SWAP1 01E8 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01E8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01E9: // Incoming jump from 0x007C, if 0x5cfeed1a == stack[-1] // Inputs[1] { @01F0 msg.data.length } 01E9 5B JUMPDEST 01EA 61 PUSH2 0x0203 01ED 60 PUSH1 0x04 01EF 80 DUP1 01F0 36 CALLDATASIZE 01F1 03 SUB 01F2 81 DUP2 01F3 01 ADD 01F4 90 SWAP1 01F5 61 PUSH2 0x01fe 01F8 91 SWAP2 01F9 90 SWAP1 01FA 61 PUSH2 0x1e3b 01FD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01EA stack[0] = 0x0203 // @01F8 stack[1] = 0x01fe // @01F9 stack[2] = 0x04 + (msg.data.length - 0x04) // @01F9 stack[3] = 0x04 // } // Block ends with call to 0x1e3b, returns to 0x01FE label_01FE: // Incoming return from call to 0x1E3B at 0x01FD 01FE 5B JUMPDEST 01FF 61 PUSH2 0x0bba 0202 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bba label_0203: // Incoming return from call to 0x01FE at 0x01FD // Inputs[2] // { // @0206 memory[0x40:0x60] // @020A stack[-1] // } 0203 5B JUMPDEST 0204 60 PUSH1 0x40 0206 51 MLOAD 0207 61 PUSH2 0x0210 020A 91 SWAP2 020B 90 SWAP1 020C 61 PUSH2 0x28e4 020F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @020A stack[-1] = 0x0210 // @020B stack[1] = memory[0x40:0x60] // @020B stack[0] = stack[-1] // } // Block ends with call to 0x28e4, returns to 0x0210 label_0210: // Incoming return from call to 0x28E4 at 0x020F // Inputs[3] // { // @0213 memory[0x40:0x60] // @0215 stack[-1] // @0218 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0210 5B JUMPDEST 0211 60 PUSH1 0x40 0213 51 MLOAD 0214 80 DUP1 0215 91 SWAP2 0216 03 SUB 0217 90 SWAP1 0218 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0218 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0219: // Incoming jump from 0x0087, if 0x839f8ca3 == stack[-1] // Inputs[1] { @0220 msg.data.length } 0219 5B JUMPDEST 021A 61 PUSH2 0x0233 021D 60 PUSH1 0x04 021F 80 DUP1 0220 36 CALLDATASIZE 0221 03 SUB 0222 81 DUP2 0223 01 ADD 0224 90 SWAP1 0225 61 PUSH2 0x022e 0228 91 SWAP2 0229 90 SWAP1 022A 61 PUSH2 0x1edf 022D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @021A stack[0] = 0x0233 // @0228 stack[1] = 0x022e // @0229 stack[2] = 0x04 + (msg.data.length - 0x04) // @0229 stack[3] = 0x04 // } // Block ends with call to 0x1edf, returns to 0x022E label_022E: // Incoming return from call to 0x1EDF at 0x022D 022E 5B JUMPDEST 022F 61 PUSH2 0x0c6a 0232 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c6a label_0233: // Incoming return from call to 0x022E at 0x022D 0233 5B JUMPDEST 0234 00 *STOP // Stack delta = +0 // Outputs[1] { @0234 stop(); } // Block terminates label_0235: // Incoming jump from 0x0040, if 0xa22cb465 == stack[-1] // Inputs[1] { @023C msg.data.length } 0235 5B JUMPDEST 0236 61 PUSH2 0x024f 0239 60 PUSH1 0x04 023B 80 DUP1 023C 36 CALLDATASIZE 023D 03 SUB 023E 81 DUP2 023F 01 ADD 0240 90 SWAP1 0241 61 PUSH2 0x024a 0244 91 SWAP2 0245 90 SWAP1 0246 61 PUSH2 0x1d08 0249 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0236 stack[0] = 0x024f // @0244 stack[1] = 0x024a // @0245 stack[2] = 0x04 + (msg.data.length - 0x04) // @0245 stack[3] = 0x04 // } // Block ends with call to 0x1d08, returns to 0x024A label_024A: // Incoming return from call to 0x1D08 at 0x0249 024A 5B JUMPDEST 024B 61 PUSH2 0x0d6c 024E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d6c label_024F: // Incoming return from call to 0x024A at 0x0249 024F 5B JUMPDEST 0250 00 *STOP // Stack delta = +0 // Outputs[1] { @0250 stop(); } // Block terminates label_0251: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0258 msg.data.length } 0251 5B JUMPDEST 0252 61 PUSH2 0x026b 0255 60 PUSH1 0x04 0257 80 DUP1 0258 36 CALLDATASIZE 0259 03 SUB 025A 81 DUP2 025B 01 ADD 025C 90 SWAP1 025D 61 PUSH2 0x0266 0260 91 SWAP2 0261 90 SWAP1 0262 61 PUSH2 0x1b7e 0265 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0252 stack[0] = 0x026b // @0260 stack[1] = 0x0266 // @0261 stack[2] = 0x04 + (msg.data.length - 0x04) // @0261 stack[3] = 0x04 // } // Block ends with call to 0x1b7e, returns to 0x0266 label_0266: // Incoming return from call to 0x1B7E at 0x0265 0266 5B JUMPDEST 0267 61 PUSH2 0x0eed 026A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eed label_026B: // Incoming return from call to 0x0266 at 0x0265 // Inputs[2] // { // @026E memory[0x40:0x60] // @0272 stack[-1] // } 026B 5B JUMPDEST 026C 60 PUSH1 0x40 026E 51 MLOAD 026F 61 PUSH2 0x0278 0272 91 SWAP2 0273 90 SWAP1 0274 61 PUSH2 0x28ae 0277 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0272 stack[-1] = 0x0278 // @0273 stack[1] = memory[0x40:0x60] // @0273 stack[0] = stack[-1] // } // Block ends with call to 0x28ae, returns to 0x0278 label_0278: // Incoming return from call to 0x28AE at 0x0277 // Inputs[3] // { // @027B memory[0x40:0x60] // @027D stack[-1] // @0280 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0278 5B JUMPDEST 0279 60 PUSH1 0x40 027B 51 MLOAD 027C 80 DUP1 027D 91 SWAP2 027E 03 SUB 027F 90 SWAP1 0280 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0280 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0281: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @0288 msg.data.length } 0281 5B JUMPDEST 0282 61 PUSH2 0x029b 0285 60 PUSH1 0x04 0287 80 DUP1 0288 36 CALLDATASIZE 0289 03 SUB 028A 81 DUP2 028B 01 ADD 028C 90 SWAP1 028D 61 PUSH2 0x0296 0290 91 SWAP2 0291 90 SWAP1 0292 61 PUSH2 0x1c79 0295 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0282 stack[0] = 0x029b // @0290 stack[1] = 0x0296 // @0291 stack[2] = 0x04 + (msg.data.length - 0x04) // @0291 stack[3] = 0x04 // } // Block ends with call to 0x1c79, returns to 0x0296 label_0296: // Incoming return from call to 0x1C79 at 0x0295 0296 5B JUMPDEST 0297 61 PUSH2 0x0f81 029A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f81 label_029B: // Incoming return from call to 0x0296 at 0x0295 029B 5B JUMPDEST 029C 00 *STOP // Stack delta = +0 // Outputs[1] { @029C stop(); } // Block terminates label_029D: // Incoming jump from 0x0061, if 0xfab03a55 == stack[-1] // Inputs[1] { @02A4 msg.data.length } 029D 5B JUMPDEST 029E 61 PUSH2 0x02b7 02A1 60 PUSH1 0x04 02A3 80 DUP1 02A4 36 CALLDATASIZE 02A5 03 SUB 02A6 81 DUP2 02A7 01 ADD 02A8 90 SWAP1 02A9 61 PUSH2 0x02b2 02AC 91 SWAP2 02AD 90 SWAP1 02AE 61 PUSH2 0x1eb6 02B1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @029E stack[0] = 0x02b7 // @02AC stack[1] = 0x02b2 // @02AD stack[2] = 0x04 + (msg.data.length - 0x04) // @02AD stack[3] = 0x04 // } // Block ends with call to 0x1eb6, returns to 0x02B2 label_02B2: // Incoming return from call to 0x1EB6 at 0x02B1 02B2 5B JUMPDEST 02B3 61 PUSH2 0x12c4 02B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12c4 label_02B7: // Incoming return from call to 0x02B2 at 0x02B1 // Inputs[2] // { // @02BA memory[0x40:0x60] // @02BE stack[-1] // } 02B7 5B JUMPDEST 02B8 60 PUSH1 0x40 02BA 51 MLOAD 02BB 61 PUSH2 0x02c4 02BE 91 SWAP2 02BF 90 SWAP1 02C0 61 PUSH2 0x28c9 02C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02BE stack[-1] = 0x02c4 // @02BF stack[1] = memory[0x40:0x60] // @02BF stack[0] = stack[-1] // } // Block ends with call to 0x28c9, returns to 0x02C4 label_02C4: // Incoming return from call to 0x28C9 at 0x02C3 // Inputs[3] // { // @02C7 memory[0x40:0x60] // @02C9 stack[-1] // @02CC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02C4 5B JUMPDEST 02C5 60 PUSH1 0x40 02C7 51 MLOAD 02C8 80 DUP1 02C9 91 SWAP2 02CA 03 SUB 02CB 90 SWAP1 02CC F3 *RETURN // Stack delta = -1 // Outputs[1] { @02CC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02CD: // Incoming jump from 0x00EC // Inputs[1] { @02E7 stack[-2] } 02CD 5B JUMPDEST 02CE 60 PUSH1 0x00 02D0 80 DUP1 02D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02E6 16 AND 02E7 83 DUP4 02E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02FD 16 AND 02FE 14 EQ 02FF 15 ISZERO 0300 61 PUSH2 0x033e 0303 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CE stack[0] = 0x00 } // Block ends with conditional jump to 0x033e, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0304: // Incoming jump from 0x0303, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0306 memory[0x40:0x60] } 0304 60 PUSH1 0x40 0306 51 MLOAD 0307 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0328 81 DUP2 0329 52 MSTORE 032A 60 PUSH1 0x04 032C 01 ADD 032D 61 PUSH2 0x0335 0330 90 SWAP1 0331 61 PUSH2 0x2946 0334 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0329 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0330 stack[0] = 0x0335 // @0330 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2946, returns to 0x0335 label_0335: // Incoming return from call to 0x2946 at 0x0334 // Inputs[3] // { // @0338 memory[0x40:0x60] // @033A stack[-1] // @033D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0335 5B JUMPDEST 0336 60 PUSH1 0x40 0338 51 MLOAD 0339 80 DUP1 033A 91 SWAP2 033B 03 SUB 033C 90 SWAP1 033D FD *REVERT // Stack delta = -1 // Outputs[1] { @033D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_033E: // Incoming jump from 0x0303, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @0343 stack[-2] // @0351 memory[0x00:0x40] // @0354 stack[-3] // @038E memory[0x00:0x40] // @038F storage[keccak256(memory[0x00:0x40])] // @0390 stack[-1] // @0392 stack[-4] // } 033E 5B JUMPDEST 033F 60 PUSH1 0x01 0341 60 PUSH1 0x00 0343 83 DUP4 0344 81 DUP2 0345 52 MSTORE 0346 60 PUSH1 0x20 0348 01 ADD 0349 90 SWAP1 034A 81 DUP2 034B 52 MSTORE 034C 60 PUSH1 0x20 034E 01 ADD 034F 60 PUSH1 0x00 0351 20 SHA3 0352 60 PUSH1 0x00 0354 84 DUP5 0355 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 036A 16 AND 036B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0380 16 AND 0381 81 DUP2 0382 52 MSTORE 0383 60 PUSH1 0x20 0385 01 ADD 0386 90 SWAP1 0387 81 DUP2 0388 52 MSTORE 0389 60 PUSH1 0x20 038B 01 ADD 038C 60 PUSH1 0x00 038E 20 SHA3 038F 54 SLOAD 0390 90 SWAP1 0391 50 POP 0392 92 SWAP3 0393 91 SWAP2 0394 50 POP 0395 50 POP 0396 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0345 memory[0x00:0x20] = stack[-2] // @034B memory[0x20:0x40] = 0x01 // @0382 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0388 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0392 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0397: // Incoming jump from 0x011C // Inputs[4] // { // @039D stack[-1] // @03E9 memory[0x00:0x40] // @03ED storage[keccak256(memory[0x00:0x40])] // @03FA stack[-2] // } 0397 5B JUMPDEST 0398 60 PUSH1 0x00 039A 80 DUP1 039B 60 PUSH1 0x00 039D 83 DUP4 039E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 03BB 19 NOT 03BC 16 AND 03BD 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 03DA 19 NOT 03DB 16 AND 03DC 81 DUP2 03DD 52 MSTORE 03DE 60 PUSH1 0x20 03E0 01 ADD 03E1 90 SWAP1 03E2 81 DUP2 03E3 52 MSTORE 03E4 60 PUSH1 0x20 03E6 01 ADD 03E7 60 PUSH1 0x00 03E9 20 SHA3 03EA 60 PUSH1 0x00 03EC 90 SWAP1 03ED 54 SLOAD 03EE 90 SWAP1 03EF 61 PUSH2 0x0100 03F2 0A EXP 03F3 90 SWAP1 03F4 04 DIV 03F5 60 PUSH1 0xff 03F7 16 AND 03F8 90 SWAP1 03F9 50 POP 03FA 91 SWAP2 03FB 90 SWAP1 03FC 50 POP 03FD 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @03DD memory[0x00:0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // @03E3 memory[0x20:0x40] = 0x00 // @03FA stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_03FE: // Incoming jump from 0x014C // Inputs[7] // { // @040B stack[-1] // @0419 memory[0x00:0x40] // @041A storage[keccak256(memory[0x00:0x40])] // @0428 memory[0x00:0x40] // @042F storage[keccak256(memory[0x00:0x40])] // @0450 memory[0x40:0x60] // @0463 storage[keccak256(memory[0x00:0x40])] // } 03FE 5B JUMPDEST 03FF 60 PUSH1 0x60 0401 60 PUSH1 0x00 0403 60 PUSH1 0x03 0405 60 PUSH1 0x00 0407 60 PUSH1 0x04 0409 60 PUSH1 0x00 040B 86 DUP7 040C 81 DUP2 040D 52 MSTORE 040E 60 PUSH1 0x20 0410 01 ADD 0411 90 SWAP1 0412 81 DUP2 0413 52 MSTORE 0414 60 PUSH1 0x20 0416 01 ADD 0417 60 PUSH1 0x00 0419 20 SHA3 041A 54 SLOAD 041B 81 DUP2 041C 52 MSTORE 041D 60 PUSH1 0x20 041F 01 ADD 0420 90 SWAP1 0421 81 DUP2 0422 52 MSTORE 0423 60 PUSH1 0x20 0425 01 ADD 0426 60 PUSH1 0x00 0428 20 SHA3 0429 90 SWAP1 042A 50 POP 042B 60 PUSH1 0x60 042D 81 DUP2 042E 80 DUP1 042F 54 SLOAD 0430 60 PUSH1 0x01 0432 81 DUP2 0433 60 PUSH1 0x01 0435 16 AND 0436 15 ISZERO 0437 61 PUSH2 0x0100 043A 02 MUL 043B 03 SUB 043C 16 AND 043D 60 PUSH1 0x02 043F 90 SWAP1 0440 04 DIV 0441 80 DUP1 0442 60 PUSH1 0x1f 0444 01 ADD 0445 60 PUSH1 0x20 0447 80 DUP1 0448 91 SWAP2 0449 04 DIV 044A 02 MUL 044B 60 PUSH1 0x20 044D 01 ADD 044E 60 PUSH1 0x40 0450 51 MLOAD 0451 90 SWAP1 0452 81 DUP2 0453 01 ADD 0454 60 PUSH1 0x40 0456 52 MSTORE 0457 80 DUP1 0458 92 SWAP3 0459 91 SWAP2 045A 90 SWAP1 045B 81 DUP2 045C 81 DUP2 045D 52 MSTORE 045E 60 PUSH1 0x20 0460 01 ADD 0461 82 DUP3 0462 80 DUP1 0463 54 SLOAD 0464 60 PUSH1 0x01 0466 81 DUP2 0467 60 PUSH1 0x01 0469 16 AND 046A 15 ISZERO 046B 61 PUSH2 0x0100 046E 02 MUL 046F 03 SUB 0470 16 AND 0471 60 PUSH1 0x02 0473 90 SWAP1 0474 04 DIV 0475 80 DUP1 0476 15 ISZERO 0477 61 PUSH2 0x04c1 047A 57 *JUMPI // Stack delta = +9 // Outputs[15] // { // @03FF stack[0] = 0x60 // @040D memory[0x00:0x20] = stack[-1] // @0413 memory[0x20:0x40] = 0x04 // @041C memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @0422 memory[0x20:0x40] = 0x03 // @0429 stack[1] = keccak256(memory[0x00:0x40]) // @042B stack[2] = 0x60 // @0456 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @0458 stack[3] = memory[0x40:0x60] // @0459 stack[4] = keccak256(memory[0x00:0x40]) // @045A stack[5] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @045D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @0460 stack[6] = 0x20 + memory[0x40:0x60] // @0461 stack[7] = keccak256(memory[0x00:0x40]) // @0474 stack[8] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x04c1, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_047B: // Incoming jump from 0x047A, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @047B stack[-1] } 047B 80 DUP1 047C 60 PUSH1 0x1f 047E 10 LT 047F 61 PUSH2 0x0496 0482 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0496, if 0x1f < stack[-1] label_0483: // Incoming jump from 0x0482, if not 0x1f < stack[-1] // Inputs[4] // { // @0487 stack[-2] // @0488 storage[stack[-2]] // @048B stack[-3] // @048D stack[-1] // } 0483 61 PUSH2 0x0100 0486 80 DUP1 0487 83 DUP4 0488 54 SLOAD 0489 04 DIV 048A 02 MUL 048B 83 DUP4 048C 52 MSTORE 048D 91 SWAP2 048E 60 PUSH1 0x20 0490 01 ADD 0491 91 SWAP2 0492 61 PUSH2 0x04c1 0495 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @048C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0491 stack[-1] = stack[-1] // @0491 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04c1 label_0496: // Incoming jump from 0x0482, if 0x1f < stack[-1] // Inputs[5] // { // @0497 stack[-3] // @0498 stack[-1] // @049A stack[-2] // @04A2 memory[0x00:0x20] // @04A6 storage[keccak256(memory[0x00:0x20])] // } 0496 5B JUMPDEST 0497 82 DUP3 0498 01 ADD 0499 91 SWAP2 049A 90 SWAP1 049B 60 PUSH1 0x00 049D 52 MSTORE 049E 60 PUSH1 0x20 04A0 60 PUSH1 0x00 04A2 20 SHA3 04A3 90 SWAP1 04A4 5B JUMPDEST 04A5 81 DUP2 04A6 54 SLOAD 04A7 81 DUP2 04A8 52 MSTORE 04A9 90 SWAP1 04AA 60 PUSH1 0x01 04AC 01 ADD 04AD 90 SWAP1 04AE 60 PUSH1 0x20 04B0 01 ADD 04B1 80 DUP1 04B2 83 DUP4 04B3 11 GT 04B4 61 PUSH2 0x04a4 04B7 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0499 stack[-3] = stack[-3] + stack[-1] // @049D memory[0x00:0x20] = stack[-2] // @04A8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04AD stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04B0 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04a4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04B8: // Incoming jump from 0x04B7, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04B7, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04B8 stack[-3] // @04B9 stack[-1] // } 04B8 82 DUP3 04B9 90 SWAP1 04BA 03 SUB 04BB 60 PUSH1 0x1f 04BD 16 AND 04BE 82 DUP3 04BF 01 ADD 04C0 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04C0 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04C0 stack[-1] = stack[-3] // } // Block continues label_04C1: // Incoming jump from 0x04C0 // Incoming jump from 0x047A, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x0495 // Inputs[3] // { // @04C7 stack[-7] // @04C7 stack[-6] // @04CC memory[stack[-6]:stack[-6] + 0x20] // } 04C1 5B JUMPDEST 04C2 50 POP 04C3 50 POP 04C4 50 POP 04C5 50 POP 04C6 50 POP 04C7 90 SWAP1 04C8 50 POP 04C9 60 PUSH1 0x00 04CB 81 DUP2 04CC 51 MLOAD 04CD 11 GT 04CE 61 PUSH2 0x050c 04D1 57 *JUMPI // Stack delta = -6 // Outputs[1] { @04C7 stack[-7] = stack[-6] } // Block ends with conditional jump to 0x050c, if memory[stack[-6]:stack[-6] + 0x20] > 0x00 label_04D2: // Incoming jump from 0x04D1, if not memory[stack[-6]:stack[-6] + 0x20] > 0x00 // Inputs[1] { @04D4 memory[0x40:0x60] } 04D2 60 PUSH1 0x40 04D4 51 MLOAD 04D5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 04F6 81 DUP2 04F7 52 MSTORE 04F8 60 PUSH1 0x04 04FA 01 ADD 04FB 61 PUSH2 0x0503 04FE 90 SWAP1 04FF 61 PUSH2 0x2ac6 0502 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @04FE stack[0] = 0x0503 // @04FE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2ac6, returns to 0x0503 label_0503: // Incoming return from call to 0x2AC6 at 0x0502 // Inputs[3] // { // @0506 memory[0x40:0x60] // @0508 stack[-1] // @050B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0503 5B JUMPDEST 0504 60 PUSH1 0x40 0506 51 MLOAD 0507 80 DUP1 0508 91 SWAP2 0509 03 SUB 050A 90 SWAP1 050B FD *REVERT // Stack delta = -1 // Outputs[1] { @050B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_050C: // Incoming jump from 0x04D1, if memory[stack[-6]:stack[-6] + 0x20] > 0x00 // Inputs[2] // { // @050D stack[-2] // @0510 memory[0x40:0x60] // } 050C 5B JUMPDEST 050D 81 DUP2 050E 60 PUSH1 0x40 0510 51 MLOAD 0511 60 PUSH1 0x20 0513 01 ADD 0514 61 PUSH2 0x051d 0517 91 SWAP2 0518 90 SWAP1 0519 61 PUSH2 0x2756 051C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0517 stack[0] = 0x051d // @0518 stack[1] = stack[-2] // @0518 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x2756, returns to 0x051D label_051D: // Incoming return from call to 0x2756 at 0x051C // Inputs[5] // { // @0520 memory[0x40:0x60] // @0524 stack[-1] // @052D stack[-4] // @0531 stack[-6] // @0532 stack[-5] // } 051D 5B JUMPDEST 051E 60 PUSH1 0x40 0520 51 MLOAD 0521 60 PUSH1 0x20 0523 81 DUP2 0524 83 DUP4 0525 03 SUB 0526 03 SUB 0527 81 DUP2 0528 52 MSTORE 0529 90 SWAP1 052A 60 PUSH1 0x40 052C 52 MSTORE 052D 92 SWAP3 052E 50 POP 052F 50 POP 0530 50 POP 0531 91 SWAP2 0532 90 SWAP1 0533 50 POP 0534 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @0528 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @052C memory[0x40:0x60] = stack[-1] // @0531 stack[-6] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-6] label_0535: // Incoming jump from 0x017C // Inputs[1] { @056D msg.sender } 0535 5B JUMPDEST 0536 7F PUSH32 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 0557 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 056C 16 AND 056D 33 CALLER 056E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0583 16 AND 0584 14 EQ 0585 61 PUSH2 0x05c3 0588 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c3, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 label_0589: // Incoming jump from 0x0588, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 // Inputs[1] { @058B memory[0x40:0x60] } 0589 60 PUSH1 0x40 058B 51 MLOAD 058C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05AD 81 DUP2 05AE 52 MSTORE 05AF 60 PUSH1 0x04 05B1 01 ADD 05B2 61 PUSH2 0x05ba 05B5 90 SWAP1 05B6 61 PUSH2 0x2a26 05B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05B5 stack[0] = 0x05ba // @05B5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a26, returns to 0x05BA label_05BA: // Incoming return from call to 0x2A26 at 0x05B9 // Inputs[3] // { // @05BD memory[0x40:0x60] // @05BF stack[-1] // @05C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05BA 5B JUMPDEST 05BB 60 PUSH1 0x40 05BD 51 MLOAD 05BE 80 DUP1 05BF 91 SWAP2 05C0 03 SUB 05C1 90 SWAP1 05C2 FD *REVERT // Stack delta = -1 // Outputs[1] { @05C2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_05C3: // Incoming jump from 0x0588, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 // Inputs[4] // { // @05C7 stack[-3] // @05C8 stack[-2] // @05C9 stack[-1] // @05CC memory[0x40:0x60] // } 05C3 5B JUMPDEST 05C4 61 PUSH2 0x0604 05C7 83 DUP4 05C8 83 DUP4 05C9 83 DUP4 05CA 60 PUSH1 0x40 05CC 51 MLOAD 05CD 80 DUP1 05CE 60 PUSH1 0x40 05D0 01 ADD 05D1 60 PUSH1 0x40 05D3 52 MSTORE 05D4 80 DUP1 05D5 60 PUSH1 0x03 05D7 81 DUP2 05D8 52 MSTORE 05D9 60 PUSH1 0x20 05DB 01 ADD 05DC 7F PUSH32 0x3078300000000000000000000000000000000000000000000000000000000000 05FD 81 DUP2 05FE 52 MSTORE 05FF 50 POP 0600 61 PUSH2 0x12dc 0603 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @05C4 stack[0] = 0x0604 // @05C7 stack[1] = stack[-3] // @05C8 stack[2] = stack[-2] // @05C9 stack[3] = stack[-1] // @05CC stack[4] = memory[0x40:0x60] // @05D3 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @05D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 // @05FE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3078300000000000000000000000000000000000000000000000000000000000 // } // Block ends with call to 0x12dc, returns to 0x0604 label_0604: // Incoming return from call to 0x12DC at 0x0603 // Inputs[1] { @0608 stack[-4] } 0604 5B JUMPDEST 0605 50 POP 0606 50 POP 0607 50 POP 0608 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0609: // Incoming jump from 0x0198 // Inputs[4] // { // @060A stack[-2] // @060B memory[stack[-2]:stack[-2] + 0x20] // @060C stack[-3] // @060D memory[stack[-3]:stack[-3] + 0x20] // } 0609 5B JUMPDEST 060A 81 DUP2 060B 51 MLOAD 060C 83 DUP4 060D 51 MLOAD 060E 14 EQ 060F 61 PUSH2 0x064d 0612 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064d, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] label_0613: // Incoming jump from 0x0612, if not memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0615 memory[0x40:0x60] } 0613 60 PUSH1 0x40 0615 51 MLOAD 0616 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0637 81 DUP2 0638 52 MSTORE 0639 60 PUSH1 0x04 063B 01 ADD 063C 61 PUSH2 0x0644 063F 90 SWAP1 0640 61 PUSH2 0x2a86 0643 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0638 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @063F stack[0] = 0x0644 // @063F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a86, returns to 0x0644 label_0644: // Incoming return from call to 0x2A86 at 0x0643 // Inputs[3] // { // @0647 memory[0x40:0x60] // @0649 stack[-1] // @064C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0644 5B JUMPDEST 0645 60 PUSH1 0x40 0647 51 MLOAD 0648 80 DUP1 0649 91 SWAP2 064A 03 SUB 064B 90 SWAP1 064C FD *REVERT // Stack delta = -1 // Outputs[1] { @064C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_064D: // Incoming jump from 0x0612, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0666 stack[-4] } 064D 5B JUMPDEST 064E 60 PUSH1 0x00 0650 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0665 16 AND 0666 84 DUP5 0667 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 067C 16 AND 067D 14 EQ 067E 15 ISZERO 067F 61 PUSH2 0x06bd 0682 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06bd, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0683: // Incoming jump from 0x0682, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0685 memory[0x40:0x60] } 0683 60 PUSH1 0x40 0685 51 MLOAD 0686 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 06A7 81 DUP2 06A8 52 MSTORE 06A9 60 PUSH1 0x04 06AB 01 ADD 06AC 61 PUSH2 0x06b4 06AF 90 SWAP1 06B0 61 PUSH2 0x29c6 06B3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @06AF stack[0] = 0x06b4 // @06AF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29c6, returns to 0x06B4 label_06B4: // Incoming return from call to 0x29C6 at 0x06B3 // Inputs[3] // { // @06B7 memory[0x40:0x60] // @06B9 stack[-1] // @06BC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 06B4 5B JUMPDEST 06B5 60 PUSH1 0x40 06B7 51 MLOAD 06B8 80 DUP1 06B9 91 SWAP2 06BA 03 SUB 06BB 90 SWAP1 06BC FD *REVERT // Stack delta = -1 // Outputs[1] { @06BC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_06BD: // Incoming jump from 0x0682, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) 06BD 5B JUMPDEST 06BE 61 PUSH2 0x06c5 06C1 61 PUSH2 0x14c3 06C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @06BE stack[0] = 0x06c5 } // Block ends with call to 0x14c3, returns to 0x06C5 label_06C5: // Incoming return from call to 0x14C3 at 0x06C4 // Inputs[2] // { // @06DB stack[-1] // @06DC stack[-6] // } 06C5 5B JUMPDEST 06C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06DB 16 AND 06DC 85 DUP6 06DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06F2 16 AND 06F3 14 EQ 06F4 80 DUP1 06F5 61 PUSH2 0x070b 06F8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06F3 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] } // Block ends with conditional jump to 0x070b, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_06F9: // Incoming jump from 0x06F8, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @06FD stack[-6] } 06F9 50 POP 06FA 61 PUSH2 0x070a 06FD 85 DUP6 06FE 61 PUSH2 0x0705 0701 61 PUSH2 0x14c3 0704 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06FA stack[-1] = 0x070a // @06FD stack[0] = stack[-6] // @06FE stack[1] = 0x0705 // } // Block ends with call to 0x14c3, returns to 0x0705 label_0705: // Incoming return from call to 0x14C3 at 0x0704 0705 5B JUMPDEST 0706 61 PUSH2 0x0eed 0709 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eed label_070A: // Incoming return from call to 0x0705 at 0x0704 070A 5B JUMPDEST // Stack delta = +0 // Block continues label_070B: // Incoming jump from 0x070A // Incoming jump from 0x06F8, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @070F stack[-1] } 070B 5B JUMPDEST 070C 61 PUSH2 0x074a 070F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x074a, if stack[-1] label_0710: // Incoming jump from 0x070F, if not stack[-1] // Inputs[1] { @0712 memory[0x40:0x60] } 0710 60 PUSH1 0x40 0712 51 MLOAD 0713 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0734 81 DUP2 0735 52 MSTORE 0736 60 PUSH1 0x04 0738 01 ADD 0739 61 PUSH2 0x0741 073C 90 SWAP1 073D 61 PUSH2 0x29e6 0740 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0735 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @073C stack[0] = 0x0741 // @073C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29e6, returns to 0x0741 label_0741: // Incoming return from call to 0x29E6 at 0x0740 // Inputs[3] // { // @0744 memory[0x40:0x60] // @0746 stack[-1] // @0749 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0741 5B JUMPDEST 0742 60 PUSH1 0x40 0744 51 MLOAD 0745 80 DUP1 0746 91 SWAP2 0747 03 SUB 0748 90 SWAP1 0749 FD *REVERT // Stack delta = -1 // Outputs[1] { @0749 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_074A: // Incoming jump from 0x070F, if stack[-1] 074A 5B JUMPDEST 074B 60 PUSH1 0x00 074D 61 PUSH2 0x0754 0750 61 PUSH2 0x14c3 0753 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @074B stack[0] = 0x00 // @074D stack[1] = 0x0754 // } // Block ends with call to 0x14c3, returns to 0x0754 label_0754: // Incoming return from call to 0x14C3 at 0x0753 // Inputs[7] // { // @0755 stack[-2] // @0755 stack[-1] // @075B stack[-7] // @075C stack[-6] // @075D stack[-5] // @075E stack[-4] // @075F stack[-3] // } 0754 5B JUMPDEST 0755 90 SWAP1 0756 50 POP 0757 61 PUSH2 0x0764 075A 81 DUP2 075B 87 DUP8 075C 87 DUP8 075D 87 DUP8 075E 87 DUP8 075F 87 DUP8 0760 61 PUSH2 0x14cb 0763 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0755 stack[-2] = stack[-1] // @0757 stack[-1] = 0x0764 // @075A stack[0] = stack[-1] // @075B stack[1] = stack[-7] // @075C stack[2] = stack[-6] // @075D stack[3] = stack[-5] // @075E stack[4] = stack[-4] // @075F stack[5] = stack[-3] // } // Block ends with call to 0x14cb, returns to 0x0764 label_0764: // Incoming return from call to 0x14CB at 0x0763 // Inputs[2] // { // @076B stack[-4] // @076C memory[stack[-4]:stack[-4] + 0x20] // } 0764 5B JUMPDEST 0765 60 PUSH1 0x00 0767 80 DUP1 0768 90 SWAP1 0769 50 POP 076A 5B JUMPDEST 076B 84 DUP5 076C 51 MLOAD 076D 81 DUP2 076E 10 LT 076F 15 ISZERO 0770 61 PUSH2 0x0938 0773 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0768 stack[0] = 0x00 } // Block ends with conditional jump to 0x0938, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_0774: // Incoming jump from 0x0773, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0773, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @0776 stack[-5] // @0777 stack[-1] // @0779 memory[stack[-5]:stack[-5] + 0x20] // } 0774 60 PUSH1 0x00 0776 85 DUP6 0777 82 DUP3 0778 81 DUP2 0779 51 MLOAD 077A 81 DUP2 077B 10 LT 077C 61 PUSH2 0x0781 077F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0774 stack[0] = 0x00 // @0776 stack[1] = stack[-5] // @0777 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0781, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_0780: // Incoming jump from 0x077F, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 0780 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0780 assert(); } // Block terminates label_0781: // Incoming jump from 0x077F, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @0784 stack[-1] // @0788 stack[-2] // @0789 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @078A stack[-3] // @078E stack[-7] // @078F stack[-4] // @0791 memory[stack[-7]:stack[-7] + 0x20] // } 0781 5B JUMPDEST 0782 60 PUSH1 0x20 0784 02 MUL 0785 60 PUSH1 0x20 0787 01 ADD 0788 01 ADD 0789 51 MLOAD 078A 90 SWAP1 078B 50 POP 078C 60 PUSH1 0x00 078E 85 DUP6 078F 83 DUP4 0790 81 DUP2 0791 51 MLOAD 0792 81 DUP2 0793 10 LT 0794 61 PUSH2 0x0799 0797 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @078A stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @078C stack[-2] = 0x00 // @078E stack[-1] = stack[-7] // @078F stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0799, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_0798: // Incoming jump from 0x0797, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 0798 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0798 assert(); } // Block terminates label_0799: // Incoming jump from 0x0797, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[10] // { // @079C stack[-1] // @07A0 stack[-2] // @07A1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @07A2 stack[-3] // @07AA memory[0x40:0x60] // @07C5 stack[-4] // @07D3 memory[0x00:0x40] // @07D6 stack[-11] // @0810 memory[0x00:0x40] // @0811 storage[keccak256(memory[0x00:0x40])] // } 0799 5B JUMPDEST 079A 60 PUSH1 0x20 079C 02 MUL 079D 60 PUSH1 0x20 079F 01 ADD 07A0 01 ADD 07A1 51 MLOAD 07A2 90 SWAP1 07A3 50 POP 07A4 61 PUSH2 0x0820 07A7 81 DUP2 07A8 60 PUSH1 0x40 07AA 51 MLOAD 07AB 80 DUP1 07AC 60 PUSH1 0x60 07AE 01 ADD 07AF 60 PUSH1 0x40 07B1 52 MSTORE 07B2 80 DUP1 07B3 60 PUSH1 0x2a 07B5 81 DUP2 07B6 52 MSTORE 07B7 60 PUSH1 0x20 07B9 01 ADD 07BA 61 PUSH2 0x2e8c 07BD 60 PUSH1 0x2a 07BF 91 SWAP2 07C0 39 CODECOPY 07C1 60 PUSH1 0x01 07C3 60 PUSH1 0x00 07C5 86 DUP7 07C6 81 DUP2 07C7 52 MSTORE 07C8 60 PUSH1 0x20 07CA 01 ADD 07CB 90 SWAP1 07CC 81 DUP2 07CD 52 MSTORE 07CE 60 PUSH1 0x20 07D0 01 ADD 07D1 60 PUSH1 0x00 07D3 20 SHA3 07D4 60 PUSH1 0x00 07D6 8D DUP14 07D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07EC 16 AND 07ED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0802 16 AND 0803 81 DUP2 0804 52 MSTORE 0805 60 PUSH1 0x20 0807 01 ADD 0808 90 SWAP1 0809 81 DUP2 080A 52 MSTORE 080B 60 PUSH1 0x20 080D 01 ADD 080E 60 PUSH1 0x00 0810 20 SHA3 0811 54 SLOAD 0812 61 PUSH2 0x14d3 0815 90 SWAP1 0816 92 SWAP3 0817 91 SWAP2 0818 90 SWAP1 0819 63 PUSH4 0xffffffff 081E 16 AND 081F 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @07A2 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @07A4 stack[-2] = 0x0820 // @07B1 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @07B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2a // @07C0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x2a] = code[0x2e8c:0x2eb6] // @07C7 memory[0x00:0x20] = stack[-4] // @07CD memory[0x20:0x40] = 0x01 // @0804 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-11] // @080A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0816 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @0817 stack[0] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0818 stack[1] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x14d3, returns to 0x0820 label_0820: // Incoming return from call to 0x14D3 at 0x081F // Inputs[10] // { // @0825 stack[-3] // @0833 memory[0x00:0x40] // @0836 stack[-10] // @0870 memory[0x00:0x40] // @0871 stack[-1] // @0878 stack[-2] // @088B memory[0x00:0x40] // @088E stack[-9] // @08C8 memory[0x00:0x40] // @08C9 storage[keccak256(memory[0x00:0x40])] // } 0820 5B JUMPDEST 0821 60 PUSH1 0x01 0823 60 PUSH1 0x00 0825 84 DUP5 0826 81 DUP2 0827 52 MSTORE 0828 60 PUSH1 0x20 082A 01 ADD 082B 90 SWAP1 082C 81 DUP2 082D 52 MSTORE 082E 60 PUSH1 0x20 0830 01 ADD 0831 60 PUSH1 0x00 0833 20 SHA3 0834 60 PUSH1 0x00 0836 8B DUP12 0837 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 084C 16 AND 084D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0862 16 AND 0863 81 DUP2 0864 52 MSTORE 0865 60 PUSH1 0x20 0867 01 ADD 0868 90 SWAP1 0869 81 DUP2 086A 52 MSTORE 086B 60 PUSH1 0x20 086D 01 ADD 086E 60 PUSH1 0x00 0870 20 SHA3 0871 81 DUP2 0872 90 SWAP1 0873 55 SSTORE 0874 50 POP 0875 61 PUSH2 0x08d7 0878 81 DUP2 0879 60 PUSH1 0x01 087B 60 PUSH1 0x00 087D 85 DUP6 087E 81 DUP2 087F 52 MSTORE 0880 60 PUSH1 0x20 0882 01 ADD 0883 90 SWAP1 0884 81 DUP2 0885 52 MSTORE 0886 60 PUSH1 0x20 0888 01 ADD 0889 60 PUSH1 0x00 088B 20 SHA3 088C 60 PUSH1 0x00 088E 8B DUP12 088F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08A4 16 AND 08A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BA 16 AND 08BB 81 DUP2 08BC 52 MSTORE 08BD 60 PUSH1 0x20 08BF 01 ADD 08C0 90 SWAP1 08C1 81 DUP2 08C2 52 MSTORE 08C3 60 PUSH1 0x20 08C5 01 ADD 08C6 60 PUSH1 0x00 08C8 20 SHA3 08C9 54 SLOAD 08CA 61 PUSH2 0x152e 08CD 90 SWAP1 08CE 91 SWAP2 08CF 90 SWAP1 08D0 63 PUSH4 0xffffffff 08D5 16 AND 08D6 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @0827 memory[0x00:0x20] = stack[-3] // @082D memory[0x20:0x40] = 0x01 // @0864 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-10] // @086A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0873 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0875 stack[-1] = 0x08d7 // @087F memory[0x00:0x20] = stack[-3] // @0885 memory[0x20:0x40] = 0x01 // @08BC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @08C2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @08CE stack[0] = storage[keccak256(memory[0x00:0x40])] // @08CF stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x152e, returns to 0x08D7 label_08D7: // Incoming return from call to 0x152E at 0x08D6 // Inputs[6] // { // @08DC stack[-3] // @08EA memory[0x00:0x40] // @08ED stack[-9] // @0927 memory[0x00:0x40] // @0928 stack[-1] // @092E stack[-4] // } 08D7 5B JUMPDEST 08D8 60 PUSH1 0x01 08DA 60 PUSH1 0x00 08DC 84 DUP5 08DD 81 DUP2 08DE 52 MSTORE 08DF 60 PUSH1 0x20 08E1 01 ADD 08E2 90 SWAP1 08E3 81 DUP2 08E4 52 MSTORE 08E5 60 PUSH1 0x20 08E7 01 ADD 08E8 60 PUSH1 0x00 08EA 20 SHA3 08EB 60 PUSH1 0x00 08ED 8A DUP11 08EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0903 16 AND 0904 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0919 16 AND 091A 81 DUP2 091B 52 MSTORE 091C 60 PUSH1 0x20 091E 01 ADD 091F 90 SWAP1 0920 81 DUP2 0921 52 MSTORE 0922 60 PUSH1 0x20 0924 01 ADD 0925 60 PUSH1 0x00 0927 20 SHA3 0928 81 DUP2 0929 90 SWAP1 092A 55 SSTORE 092B 50 POP 092C 50 POP 092D 50 POP 092E 80 DUP1 092F 60 PUSH1 0x01 0931 01 ADD 0932 90 SWAP1 0933 50 POP 0934 61 PUSH2 0x076a 0937 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @08DE memory[0x00:0x20] = stack[-3] // @08E4 memory[0x20:0x40] = 0x01 // @091B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @0921 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @092A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0932 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x076a label_0938: // Incoming jump from 0x0773, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0773, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[6] // { // @093A stack[-6] // @0951 stack[-7] // @0968 stack[-2] // @09A0 stack[-5] // @09A1 stack[-4] // @09A4 memory[0x40:0x60] // } 0938 5B JUMPDEST 0939 50 POP 093A 84 DUP5 093B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0950 16 AND 0951 86 DUP7 0952 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0967 16 AND 0968 82 DUP3 0969 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 097E 16 AND 097F 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 09A0 87 DUP8 09A1 87 DUP8 09A2 60 PUSH1 0x40 09A4 51 MLOAD 09A5 61 PUSH2 0x09af 09A8 92 SWAP3 09A9 91 SWAP2 09AA 90 SWAP1 09AB 61 PUSH2 0x2877 09AE 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @0950 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @0967 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @097E stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @097F stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @09A8 stack[3] = 0x09af // @09A9 stack[4] = stack[-5] // @09AA stack[6] = memory[0x40:0x60] // @09AA stack[5] = stack[-4] // } // Block ends with call to 0x2877, returns to 0x09AF label_09AF: // Incoming return from call to 0x2877 at 0x09AE // Inputs[13] // { // @09B2 memory[0x40:0x60] // @09B4 stack[-1] // @09B7 stack[-5] // @09B7 stack[-4] // @09B7 stack[-2] // @09B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @09B7 stack[-3] // @09BB stack[-6] // @09BC stack[-11] // @09BD stack[-10] // @09BE stack[-9] // @09BF stack[-8] // @09C0 stack[-7] // } 09AF 5B JUMPDEST 09B0 60 PUSH1 0x40 09B2 51 MLOAD 09B3 80 DUP1 09B4 91 SWAP2 09B5 03 SUB 09B6 90 SWAP1 09B7 A4 LOG4 09B8 61 PUSH2 0x09c5 09BB 81 DUP2 09BC 87 DUP8 09BD 87 DUP8 09BE 87 DUP8 09BF 87 DUP8 09C0 87 DUP8 09C1 61 PUSH2 0x1583 09C4 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @09B7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @09B8 stack[-5] = 0x09c5 // @09BB stack[-4] = stack[-6] // @09BC stack[-3] = stack[-11] // @09BD stack[-2] = stack[-10] // @09BE stack[-1] = stack[-9] // @09BF stack[0] = stack[-8] // @09C0 stack[1] = stack[-7] // } // Block ends with call to 0x1583, returns to 0x09C5 label_09C5: // Incoming return from call to 0x1583 at 0x09C4 // Inputs[1] { @09CC stack[-7] } 09C5 5B JUMPDEST 09C6 50 POP 09C7 50 POP 09C8 50 POP 09C9 50 POP 09CA 50 POP 09CB 50 POP 09CC 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_09CD: // Incoming call from 0x01A2, returns to 0x01A3 // Inputs[1] { @09EF stack[-1] } 09CD 5B JUMPDEST 09CE 7F PUSH32 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 09EF 81 DUP2 09F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @09CE stack[0] = 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 } // Block ends with unconditional jump to stack[-1] label_09F1: // Incoming jump from 0x01D2 // Inputs[4] // { // @09F4 stack[-1] // @09F5 memory[stack[-1]:stack[-1] + 0x20] // @09F6 stack[-2] // @09F7 memory[stack[-2]:stack[-2] + 0x20] // } 09F1 5B JUMPDEST 09F2 60 PUSH1 0x60 09F4 81 DUP2 09F5 51 MLOAD 09F6 83 DUP4 09F7 51 MLOAD 09F8 14 EQ 09F9 61 PUSH2 0x0a37 09FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09F2 stack[0] = 0x60 } // Block ends with conditional jump to 0x0a37, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_09FD: // Incoming jump from 0x09FC, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @09FF memory[0x40:0x60] } 09FD 60 PUSH1 0x40 09FF 51 MLOAD 0A00 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A21 81 DUP2 0A22 52 MSTORE 0A23 60 PUSH1 0x04 0A25 01 ADD 0A26 61 PUSH2 0x0a2e 0A29 90 SWAP1 0A2A 61 PUSH2 0x2a66 0A2D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A29 stack[0] = 0x0a2e // @0A29 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a66, returns to 0x0A2E label_0A2E: // Incoming return from call to 0x2A66 at 0x0A2D // Inputs[3] // { // @0A31 memory[0x40:0x60] // @0A33 stack[-1] // @0A36 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A2E 5B JUMPDEST 0A2F 60 PUSH1 0x40 0A31 51 MLOAD 0A32 80 DUP1 0A33 91 SWAP2 0A34 03 SUB 0A35 90 SWAP1 0A36 FD *REVERT // Stack delta = -1 // Outputs[1] { @0A36 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0A37: // Incoming jump from 0x09FC, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @0A3A stack[-3] // @0A3B memory[stack[-3]:stack[-3] + 0x20] // } 0A37 5B JUMPDEST 0A38 60 PUSH1 0x60 0A3A 83 DUP4 0A3B 51 MLOAD 0A3C 67 PUSH8 0xffffffffffffffff 0A45 81 DUP2 0A46 11 GT 0A47 80 DUP1 0A48 15 ISZERO 0A49 61 PUSH2 0x0a51 0A4C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A38 stack[0] = 0x60 // @0A3B stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @0A46 stack[2] = memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x0a51, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_0A4D: // Incoming jump from 0x0A4C, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0A50 memory[0x00:0x00] } 0A4D 60 PUSH1 0x00 0A4F 80 DUP1 0A50 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A50 revert(memory[0x00:0x00]); } // Block terminates label_0A51: // Incoming jump from 0x0A4C, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @0A55 memory[0x40:0x60] // @0A56 stack[-2] // } 0A51 5B JUMPDEST 0A52 50 POP 0A53 60 PUSH1 0x40 0A55 51 MLOAD 0A56 90 SWAP1 0A57 80 DUP1 0A58 82 DUP3 0A59 52 MSTORE 0A5A 80 DUP1 0A5B 60 PUSH1 0x20 0A5D 02 MUL 0A5E 60 PUSH1 0x20 0A60 01 ADD 0A61 82 DUP3 0A62 01 ADD 0A63 60 PUSH1 0x40 0A65 52 MSTORE 0A66 80 DUP1 0A67 15 ISZERO 0A68 61 PUSH2 0x0a80 0A6B 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0A56 stack[-2] = memory[0x40:0x60] // @0A56 stack[-1] = stack[-2] // @0A59 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0A65 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x0a80, if !stack[-2] label_0A6C: // Incoming jump from 0x0A6B, if not !stack[-2] // Inputs[7] // { // @0A6C stack[-2] // @0A72 stack[-1] // @0A75 msg.data.length // @0A77 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0A82 stack[-3] // @0A8A stack[-6] // @0A8B memory[stack[-6]:stack[-6] + 0x20] // } 0A6C 81 DUP2 0A6D 60 PUSH1 0x20 0A6F 01 ADD 0A70 60 PUSH1 0x20 0A72 82 DUP3 0A73 02 MUL 0A74 80 DUP1 0A75 36 CALLDATASIZE 0A76 83 DUP4 0A77 37 CALLDATACOPY 0A78 80 DUP1 0A79 82 DUP3 0A7A 01 ADD 0A7B 91 SWAP2 0A7C 50 POP 0A7D 50 POP 0A7E 90 SWAP1 0A7F 50 POP 0A80 5B JUMPDEST 0A81 50 POP 0A82 90 SWAP1 0A83 50 POP 0A84 60 PUSH1 0x00 0A86 80 DUP1 0A87 90 SWAP1 0A88 50 POP 0A89 5B JUMPDEST 0A8A 84 DUP5 0A8B 51 MLOAD 0A8C 81 DUP2 0A8D 10 LT 0A8E 15 ISZERO 0A8F 61 PUSH2 0x0baf 0A92 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0A77 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0A82 stack[-3] = stack[-2] // @0A87 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0baf, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_0A93: // Incoming jump from 0x0A92, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x0A92, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0A92, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @0AAB stack[-5] // @0AAC stack[-1] // @0AAE memory[stack[-5]:stack[-5] + 0x20] // } 0A93 60 PUSH1 0x00 0A95 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AAA 16 AND 0AAB 85 DUP6 0AAC 82 DUP3 0AAD 81 DUP2 0AAE 51 MLOAD 0AAF 81 DUP2 0AB0 10 LT 0AB1 61 PUSH2 0x0ab6 0AB4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0AAA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @0AAB stack[1] = stack[-5] // @0AAC stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0ab6, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_0AB5: // Incoming jump from 0x0AB4, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 0AB5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0AB5 assert(); } // Block terminates label_0AB6: // Incoming jump from 0x0AB4, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @0AB9 stack[-1] // @0ABD stack[-2] // @0ABE memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0AD5 stack[-3] // } 0AB6 5B JUMPDEST 0AB7 60 PUSH1 0x20 0AB9 02 MUL 0ABA 60 PUSH1 0x20 0ABC 01 ADD 0ABD 01 ADD 0ABE 51 MLOAD 0ABF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AD4 16 AND 0AD5 14 EQ 0AD6 15 ISZERO 0AD7 61 PUSH2 0x0b15 0ADA 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0b15, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3]) label_0ADB: // Incoming jump from 0x0ADA, if not !(0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3]) // Inputs[1] { @0ADD memory[0x40:0x60] } 0ADB 60 PUSH1 0x40 0ADD 51 MLOAD 0ADE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0AFF 81 DUP2 0B00 52 MSTORE 0B01 60 PUSH1 0x04 0B03 01 ADD 0B04 61 PUSH2 0x0b0c 0B07 90 SWAP1 0B08 61 PUSH2 0x2966 0B0B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B00 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B07 stack[0] = 0x0b0c // @0B07 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2966, returns to 0x0B0C label_0B0C: // Incoming return from call to 0x2966 at 0x0B0B // Inputs[3] // { // @0B0F memory[0x40:0x60] // @0B11 stack[-1] // @0B14 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0B0C 5B JUMPDEST 0B0D 60 PUSH1 0x40 0B0F 51 MLOAD 0B10 80 DUP1 0B11 91 SWAP2 0B12 03 SUB 0B13 90 SWAP1 0B14 FD *REVERT // Stack delta = -1 // Outputs[1] { @0B14 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0B15: // Incoming jump from 0x0ADA, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3]) // Inputs[3] // { // @0B1A stack[-4] // @0B1B stack[-1] // @0B1D memory[stack[-4]:stack[-4] + 0x20] // } 0B15 5B JUMPDEST 0B16 60 PUSH1 0x01 0B18 60 PUSH1 0x00 0B1A 85 DUP6 0B1B 83 DUP4 0B1C 81 DUP2 0B1D 51 MLOAD 0B1E 81 DUP2 0B1F 10 LT 0B20 61 PUSH2 0x0b25 0B23 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0B16 stack[0] = 0x01 // @0B18 stack[1] = 0x00 // @0B1A stack[2] = stack[-4] // @0B1B stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0b25, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_0B24: // Incoming jump from 0x0B23, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 0B24 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B24 assert(); } // Block terminates label_0B25: // Incoming jump from 0x0B23, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[9] // { // @0B28 stack[-1] // @0B2C stack[-2] // @0B2D memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B2E stack[-3] // @0B33 stack[-4] // @0B3B memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0B3E stack[-9] // @0B3F stack[-5] // @0B41 memory[stack[-9]:stack[-9] + 0x20] // } 0B25 5B JUMPDEST 0B26 60 PUSH1 0x20 0B28 02 MUL 0B29 60 PUSH1 0x20 0B2B 01 ADD 0B2C 01 ADD 0B2D 51 MLOAD 0B2E 81 DUP2 0B2F 52 MSTORE 0B30 60 PUSH1 0x20 0B32 01 ADD 0B33 90 SWAP1 0B34 81 DUP2 0B35 52 MSTORE 0B36 60 PUSH1 0x20 0B38 01 ADD 0B39 60 PUSH1 0x00 0B3B 20 SHA3 0B3C 60 PUSH1 0x00 0B3E 86 DUP7 0B3F 83 DUP4 0B40 81 DUP2 0B41 51 MLOAD 0B42 81 DUP2 0B43 10 LT 0B44 61 PUSH2 0x0b49 0B47 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @0B2F memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B35 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0B3B stack[-4] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @0B3C stack[-3] = 0x00 // @0B3E stack[-2] = stack[-9] // @0B3F stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x0b49, if stack[-5] < memory[stack[-9]:stack[-9] + 0x20] label_0B48: // Incoming jump from 0x0B47, if not stack[-5] < memory[stack[-9]:stack[-9] + 0x20] 0B48 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B48 assert(); } // Block terminates label_0B49: // Incoming jump from 0x0B47, if stack[-5] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[10] // { // @0B4C stack[-1] // @0B50 stack[-2] // @0B51 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B7E stack[-3] // @0B83 stack[-4] // @0B8B memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0B8C storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @0B8D stack[-6] // @0B8E stack[-5] // @0B90 memory[stack[-6]:stack[-6] + 0x20] // } 0B49 5B JUMPDEST 0B4A 60 PUSH1 0x20 0B4C 02 MUL 0B4D 60 PUSH1 0x20 0B4F 01 ADD 0B50 01 ADD 0B51 51 MLOAD 0B52 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B67 16 AND 0B68 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B7D 16 AND 0B7E 81 DUP2 0B7F 52 MSTORE 0B80 60 PUSH1 0x20 0B82 01 ADD 0B83 90 SWAP1 0B84 81 DUP2 0B85 52 MSTORE 0B86 60 PUSH1 0x20 0B88 01 ADD 0B89 60 PUSH1 0x00 0B8B 20 SHA3 0B8C 54 SLOAD 0B8D 82 DUP3 0B8E 82 DUP3 0B8F 81 DUP2 0B90 51 MLOAD 0B91 81 DUP2 0B92 10 LT 0B93 61 PUSH2 0x0b98 0B96 57 *JUMPI // Stack delta = -1 // Outputs[5] // { // @0B7F memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B85 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0B8C stack[-4] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @0B8D stack[-3] = stack[-6] // @0B8E stack[-2] = stack[-5] // } // Block ends with conditional jump to 0x0b98, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_0B97: // Incoming jump from 0x0B96, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 0B97 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B97 assert(); } // Block terminates label_0B98: // Incoming jump from 0x0B96, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @0B9B stack[-1] // @0B9F stack[-2] // @0BA0 stack[-3] // @0BA5 stack[-4] // } 0B98 5B JUMPDEST 0B99 60 PUSH1 0x20 0B9B 02 MUL 0B9C 60 PUSH1 0x20 0B9E 01 ADD 0B9F 01 ADD 0BA0 81 DUP2 0BA1 81 DUP2 0BA2 52 MSTORE 0BA3 50 POP 0BA4 50 POP 0BA5 80 DUP1 0BA6 60 PUSH1 0x01 0BA8 01 ADD 0BA9 90 SWAP1 0BAA 50 POP 0BAB 61 PUSH2 0x0a89 0BAE 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0BA2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @0BA9 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x0a89 label_0BAF: // Incoming jump from 0x0A92, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x0A92, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0A92, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @0BB1 stack[-2] // @0BB2 stack[-3] // @0BB5 stack[-6] // @0BB6 stack[-5] // } 0BAF 5B JUMPDEST 0BB0 50 POP 0BB1 80 DUP1 0BB2 91 SWAP2 0BB3 50 POP 0BB4 50 POP 0BB5 92 SWAP3 0BB6 91 SWAP2 0BB7 50 POP 0BB8 50 POP 0BB9 56 *JUMP // Stack delta = -5 // Outputs[1] { @0BB5 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0BBA: // Incoming jump from 0x0202 // Inputs[5] // { // @0BC0 stack[-1] // @0BC8 memory[0x00:0x40] // @0BD0 storage[keccak256(memory[0x00:0x40])] // @0BF1 memory[0x40:0x60] // @0C04 storage[keccak256(memory[0x00:0x40])] // } 0BBA 5B JUMPDEST 0BBB 60 PUSH1 0x03 0BBD 60 PUSH1 0x20 0BBF 52 MSTORE 0BC0 80 DUP1 0BC1 60 PUSH1 0x00 0BC3 52 MSTORE 0BC4 60 PUSH1 0x40 0BC6 60 PUSH1 0x00 0BC8 20 SHA3 0BC9 60 PUSH1 0x00 0BCB 91 SWAP2 0BCC 50 POP 0BCD 90 SWAP1 0BCE 50 POP 0BCF 80 DUP1 0BD0 54 SLOAD 0BD1 60 PUSH1 0x01 0BD3 81 DUP2 0BD4 60 PUSH1 0x01 0BD6 16 AND 0BD7 15 ISZERO 0BD8 61 PUSH2 0x0100 0BDB 02 MUL 0BDC 03 SUB 0BDD 16 AND 0BDE 60 PUSH1 0x02 0BE0 90 SWAP1 0BE1 04 DIV 0BE2 80 DUP1 0BE3 60 PUSH1 0x1f 0BE5 01 ADD 0BE6 60 PUSH1 0x20 0BE8 80 DUP1 0BE9 91 SWAP2 0BEA 04 DIV 0BEB 02 MUL 0BEC 60 PUSH1 0x20 0BEE 01 ADD 0BEF 60 PUSH1 0x40 0BF1 51 MLOAD 0BF2 90 SWAP1 0BF3 81 DUP2 0BF4 01 ADD 0BF5 60 PUSH1 0x40 0BF7 52 MSTORE 0BF8 80 DUP1 0BF9 92 SWAP3 0BFA 91 SWAP2 0BFB 90 SWAP1 0BFC 81 DUP2 0BFD 81 DUP2 0BFE 52 MSTORE 0BFF 60 PUSH1 0x20 0C01 01 ADD 0C02 82 DUP3 0C03 80 DUP1 0C04 54 SLOAD 0C05 60 PUSH1 0x01 0C07 81 DUP2 0C08 60 PUSH1 0x01 0C0A 16 AND 0C0B 15 ISZERO 0C0C 61 PUSH2 0x0100 0C0F 02 MUL 0C10 03 SUB 0C11 16 AND 0C12 60 PUSH1 0x02 0C14 90 SWAP1 0C15 04 DIV 0C16 80 DUP1 0C17 15 ISZERO 0C18 61 PUSH2 0x0c62 0C1B 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0BBF memory[0x20:0x40] = 0x03 // @0BC3 memory[0x00:0x20] = stack[-1] // @0BF7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @0BF9 stack[-1] = memory[0x40:0x60] // @0BFA stack[0] = keccak256(memory[0x00:0x40]) // @0BFB stack[1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @0BFE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @0C01 stack[2] = 0x20 + memory[0x40:0x60] // @0C02 stack[3] = keccak256(memory[0x00:0x40]) // @0C15 stack[4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x0c62, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_0C1C: // Incoming jump from 0x0C1B, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @0C1C stack[-1] } 0C1C 80 DUP1 0C1D 60 PUSH1 0x1f 0C1F 10 LT 0C20 61 PUSH2 0x0c37 0C23 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c37, if 0x1f < stack[-1] label_0C24: // Incoming jump from 0x0C23, if not 0x1f < stack[-1] // Inputs[4] // { // @0C28 stack[-2] // @0C29 storage[stack[-2]] // @0C2C stack[-3] // @0C2E stack[-1] // } 0C24 61 PUSH2 0x0100 0C27 80 DUP1 0C28 83 DUP4 0C29 54 SLOAD 0C2A 04 DIV 0C2B 02 MUL 0C2C 83 DUP4 0C2D 52 MSTORE 0C2E 91 SWAP2 0C2F 60 PUSH1 0x20 0C31 01 ADD 0C32 91 SWAP2 0C33 61 PUSH2 0x0c62 0C36 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C2D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0C32 stack[-1] = stack[-1] // @0C32 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0c62 label_0C37: // Incoming jump from 0x0C23, if 0x1f < stack[-1] // Inputs[5] // { // @0C38 stack[-3] // @0C39 stack[-1] // @0C3B stack[-2] // @0C43 memory[0x00:0x20] // @0C47 storage[keccak256(memory[0x00:0x20])] // } 0C37 5B JUMPDEST 0C38 82 DUP3 0C39 01 ADD 0C3A 91 SWAP2 0C3B 90 SWAP1 0C3C 60 PUSH1 0x00 0C3E 52 MSTORE 0C3F 60 PUSH1 0x20 0C41 60 PUSH1 0x00 0C43 20 SHA3 0C44 90 SWAP1 0C45 5B JUMPDEST 0C46 81 DUP2 0C47 54 SLOAD 0C48 81 DUP2 0C49 52 MSTORE 0C4A 90 SWAP1 0C4B 60 PUSH1 0x01 0C4D 01 ADD 0C4E 90 SWAP1 0C4F 60 PUSH1 0x20 0C51 01 ADD 0C52 80 DUP1 0C53 83 DUP4 0C54 11 GT 0C55 61 PUSH2 0x0c45 0C58 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0C3A stack[-3] = stack[-3] + stack[-1] // @0C3E memory[0x00:0x20] = stack[-2] // @0C49 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0C4E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0C51 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0c45, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0C59: // Incoming jump from 0x0C58, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0C58, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0C59 stack[-3] // @0C5A stack[-1] // } 0C59 82 DUP3 0C5A 90 SWAP1 0C5B 03 SUB 0C5C 60 PUSH1 0x1f 0C5E 16 AND 0C5F 82 DUP3 0C60 01 ADD 0C61 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0C61 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0C61 stack[-1] = stack[-3] // } // Block continues label_0C62: // Incoming jump from 0x0C61 // Incoming jump from 0x0C36 // Incoming jump from 0x0C1B, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @0C68 stack[-7] } 0C62 5B JUMPDEST 0C63 50 POP 0C64 50 POP 0C65 50 POP 0C66 50 POP 0C67 50 POP 0C68 81 DUP2 0C69 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0C6A: // Incoming jump from 0x0232 // Inputs[1] { @0CA2 msg.sender } 0C6A 5B JUMPDEST 0C6B 7F PUSH32 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 0C8C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CA1 16 AND 0CA2 33 CALLER 0CA3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CB8 16 AND 0CB9 14 EQ 0CBA 61 PUSH2 0x0cf8 0CBD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cf8, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 label_0CBE: // Incoming jump from 0x0CBD, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 // Inputs[1] { @0CC0 memory[0x40:0x60] } 0CBE 60 PUSH1 0x40 0CC0 51 MLOAD 0CC1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0CE2 81 DUP2 0CE3 52 MSTORE 0CE4 60 PUSH1 0x04 0CE6 01 ADD 0CE7 61 PUSH2 0x0cef 0CEA 90 SWAP1 0CEB 61 PUSH2 0x2ae6 0CEE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0CEA stack[0] = 0x0cef // @0CEA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2ae6, returns to 0x0CEF label_0CEF: // Incoming return from call to 0x2AE6 at 0x0CEE // Inputs[3] // { // @0CF2 memory[0x40:0x60] // @0CF4 stack[-1] // @0CF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0CEF 5B JUMPDEST 0CF0 60 PUSH1 0x40 0CF2 51 MLOAD 0CF3 80 DUP1 0CF4 91 SWAP2 0CF5 03 SUB 0CF6 90 SWAP1 0CF7 FD *REVERT // Stack delta = -1 // Outputs[1] { @0CF7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0CF8: // Incoming jump from 0x0CBD, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000d947d16ca291c4d444293da56332820bd8e32a81 // Inputs[3] // { // @0D01 stack[-2] // @0D0F memory[0x00:0x40] // @0D10 storage[keccak256(memory[0x00:0x40])] // } 0CF8 5B JUMPDEST 0CF9 60 PUSH1 0x00 0CFB 80 DUP1 0CFC 1B SHL 0CFD 60 PUSH1 0x04 0CFF 60 PUSH1 0x00 0D01 84 DUP5 0D02 81 DUP2 0D03 52 MSTORE 0D04 60 PUSH1 0x20 0D06 01 ADD 0D07 90 SWAP1 0D08 81 DUP2 0D09 52 MSTORE 0D0A 60 PUSH1 0x20 0D0C 01 ADD 0D0D 60 PUSH1 0x00 0D0F 20 SHA3 0D10 54 SLOAD 0D11 14 EQ 0D12 61 PUSH2 0x0d50 0D15 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D03 memory[0x00:0x20] = stack[-2] // @0D09 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0d50, if storage[keccak256(memory[0x00:0x40])] == 0x00 << 0x00 label_0D16: // Incoming jump from 0x0D15, if not storage[keccak256(memory[0x00:0x40])] == 0x00 << 0x00 // Inputs[1] { @0D18 memory[0x40:0x60] } 0D16 60 PUSH1 0x40 0D18 51 MLOAD 0D19 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D3A 81 DUP2 0D3B 52 MSTORE 0D3C 60 PUSH1 0x04 0D3E 01 ADD 0D3F 61 PUSH2 0x0d47 0D42 90 SWAP1 0D43 61 PUSH2 0x2a06 0D46 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D3B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D42 stack[0] = 0x0d47 // @0D42 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a06, returns to 0x0D47 label_0D47: // Incoming return from call to 0x2A06 at 0x0D46 // Inputs[3] // { // @0D4A memory[0x40:0x60] // @0D4C stack[-1] // @0D4F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0D47 5B JUMPDEST 0D48 60 PUSH1 0x40 0D4A 51 MLOAD 0D4B 80 DUP1 0D4C 91 SWAP2 0D4D 03 SUB 0D4E 90 SWAP1 0D4F FD *REVERT // Stack delta = -1 // Outputs[1] { @0D4F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0D50: // Incoming jump from 0x0D15, if storage[keccak256(memory[0x00:0x40])] == 0x00 << 0x00 // Inputs[4] // { // @0D51 stack[-1] // @0D56 stack[-2] // @0D64 memory[0x00:0x40] // @0D6B stack[-3] // } 0D50 5B JUMPDEST 0D51 80 DUP1 0D52 60 PUSH1 0x04 0D54 60 PUSH1 0x00 0D56 84 DUP5 0D57 81 DUP2 0D58 52 MSTORE 0D59 60 PUSH1 0x20 0D5B 01 ADD 0D5C 90 SWAP1 0D5D 81 DUP2 0D5E 52 MSTORE 0D5F 60 PUSH1 0x20 0D61 01 ADD 0D62 60 PUSH1 0x00 0D64 20 SHA3 0D65 81 DUP2 0D66 90 SWAP1 0D67 55 SSTORE 0D68 50 POP 0D69 50 POP 0D6A 50 POP 0D6B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0D58 memory[0x00:0x20] = stack[-2] // @0D5E memory[0x20:0x40] = 0x04 // @0D67 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_0D6C: // Incoming jump from 0x024E // Inputs[1] { @0D6D stack[-2] } 0D6C 5B JUMPDEST 0D6D 81 DUP2 0D6E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D83 16 AND 0D84 61 PUSH2 0x0d8b 0D87 61 PUSH2 0x14c3 0D8A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D83 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0D84 stack[1] = 0x0d8b // } // Block ends with call to 0x14c3, returns to 0x0D8B label_0D8B: // Incoming return from call to 0x14C3 at 0x0D8A // Inputs[2] // { // @0DA1 stack[-1] // @0DA2 stack[-2] // } 0D8B 5B JUMPDEST 0D8C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DA1 16 AND 0DA2 14 EQ 0DA3 15 ISZERO 0DA4 61 PUSH2 0x0de2 0DA7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0de2, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) label_0DA8: // Incoming jump from 0x0DA7, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) // Inputs[1] { @0DAA memory[0x40:0x60] } 0DA8 60 PUSH1 0x40 0DAA 51 MLOAD 0DAB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0DCC 81 DUP2 0DCD 52 MSTORE 0DCE 60 PUSH1 0x04 0DD0 01 ADD 0DD1 61 PUSH2 0x0dd9 0DD4 90 SWAP1 0DD5 61 PUSH2 0x2a46 0DD8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DCD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0DD4 stack[0] = 0x0dd9 // @0DD4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a46, returns to 0x0DD9 label_0DD9: // Incoming return from call to 0x2A46 at 0x0DD8 // Inputs[3] // { // @0DDC memory[0x40:0x60] // @0DDE stack[-1] // @0DE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0DD9 5B JUMPDEST 0DDA 60 PUSH1 0x40 0DDC 51 MLOAD 0DDD 80 DUP1 0DDE 91 SWAP2 0DDF 03 SUB 0DE0 90 SWAP1 0DE1 FD *REVERT // Stack delta = -1 // Outputs[1] { @0DE1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0DE2: // Incoming jump from 0x0DA7, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) // Inputs[1] { @0DE3 stack[-1] } 0DE2 5B JUMPDEST 0DE3 80 DUP1 0DE4 60 PUSH1 0x02 0DE6 60 PUSH1 0x00 0DE8 61 PUSH2 0x0def 0DEB 61 PUSH2 0x14c3 0DEE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DE3 stack[0] = stack[-1] // @0DE4 stack[1] = 0x02 // @0DE6 stack[2] = 0x00 // @0DE8 stack[3] = 0x0def // } // Block ends with call to 0x14c3, returns to 0x0DEF label_0DEF: // Incoming return from call to 0x14C3 at 0x0DEE // Inputs[8] // { // @0E05 stack[-1] // @0E1C stack[-2] // @0E21 stack[-3] // @0E29 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0E2C stack[-6] // @0E66 memory[0x00:0x40] // @0E6E storage[keccak256(memory[0x00:0x40])] // @0E76 stack[-4] // } 0DEF 5B JUMPDEST 0DF0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E05 16 AND 0E06 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E1B 16 AND 0E1C 81 DUP2 0E1D 52 MSTORE 0E1E 60 PUSH1 0x20 0E20 01 ADD 0E21 90 SWAP1 0E22 81 DUP2 0E23 52 MSTORE 0E24 60 PUSH1 0x20 0E26 01 ADD 0E27 60 PUSH1 0x00 0E29 20 SHA3 0E2A 60 PUSH1 0x00 0E2C 84 DUP5 0E2D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E42 16 AND 0E43 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E58 16 AND 0E59 81 DUP2 0E5A 52 MSTORE 0E5B 60 PUSH1 0x20 0E5D 01 ADD 0E5E 90 SWAP1 0E5F 81 DUP2 0E60 52 MSTORE 0E61 60 PUSH1 0x20 0E63 01 ADD 0E64 60 PUSH1 0x00 0E66 20 SHA3 0E67 60 PUSH1 0x00 0E69 61 PUSH2 0x0100 0E6C 0A EXP 0E6D 81 DUP2 0E6E 54 SLOAD 0E6F 81 DUP2 0E70 60 PUSH1 0xff 0E72 02 MUL 0E73 19 NOT 0E74 16 AND 0E75 90 SWAP1 0E76 83 DUP4 0E77 15 ISZERO 0E78 15 ISZERO 0E79 02 MUL 0E7A 17 OR 0E7B 90 SWAP1 0E7C 55 SSTORE 0E7D 50 POP 0E7E 81 DUP2 0E7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E94 16 AND 0E95 61 PUSH2 0x0e9c 0E98 61 PUSH2 0x14c3 0E9B 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0E1D memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0E23 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0E5A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @0E60 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @0E7C storage[keccak256(memory[0x00:0x40])] = !!stack[-4] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0E94 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @0E95 stack[-3] = 0x0e9c // } // Block ends with call to 0x14c3, returns to 0x0E9C label_0E9C: // Incoming return from call to 0x14C3 at 0x0E9B // Inputs[3] // { // @0EB2 stack[-1] // @0ED4 stack[-3] // @0ED7 memory[0x40:0x60] // } 0E9C 5B JUMPDEST 0E9D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EB2 16 AND 0EB3 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0ED4 83 DUP4 0ED5 60 PUSH1 0x40 0ED7 51 MLOAD 0ED8 61 PUSH2 0x0ee1 0EDB 91 SWAP2 0EDC 90 SWAP1 0EDD 61 PUSH2 0x28ae 0EE0 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0EB2 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0EB3 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @0EDB stack[1] = 0x0ee1 // @0EDC stack[3] = memory[0x40:0x60] // @0EDC stack[2] = stack[-3] // } // Block ends with call to 0x28ae, returns to 0x0EE1 label_0EE1: // Incoming return from call to 0x28AE at 0x0EE0 // Inputs[7] // { // @0EE4 memory[0x40:0x60] // @0EE6 stack[-1] // @0EE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0EE9 stack[-3] // @0EE9 stack[-4] // @0EE9 stack[-2] // @0EEC stack[-7] // } 0EE1 5B JUMPDEST 0EE2 60 PUSH1 0x40 0EE4 51 MLOAD 0EE5 80 DUP1 0EE6 91 SWAP2 0EE7 03 SUB 0EE8 90 SWAP1 0EE9 A3 LOG3 0EEA 50 POP 0EEB 50 POP 0EEC 56 *JUMP // Stack delta = -7 // Outputs[1] { @0EE9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_0EED: // Incoming jump from 0x0709 // Incoming jump from 0x103D // Incoming jump from 0x026A // Inputs[6] // { // @0EF4 stack[-2] // @0F2E memory[0x00:0x40] // @0F31 stack[-1] // @0F6B memory[0x00:0x40] // @0F6F storage[keccak256(memory[0x00:0x40])] // @0F7C stack[-3] // } 0EED 5B JUMPDEST 0EEE 60 PUSH1 0x00 0EF0 60 PUSH1 0x02 0EF2 60 PUSH1 0x00 0EF4 84 DUP5 0EF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F0A 16 AND 0F0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F20 16 AND 0F21 81 DUP2 0F22 52 MSTORE 0F23 60 PUSH1 0x20 0F25 01 ADD 0F26 90 SWAP1 0F27 81 DUP2 0F28 52 MSTORE 0F29 60 PUSH1 0x20 0F2B 01 ADD 0F2C 60 PUSH1 0x00 0F2E 20 SHA3 0F2F 60 PUSH1 0x00 0F31 83 DUP4 0F32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F47 16 AND 0F48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F5D 16 AND 0F5E 81 DUP2 0F5F 52 MSTORE 0F60 60 PUSH1 0x20 0F62 01 ADD 0F63 90 SWAP1 0F64 81 DUP2 0F65 52 MSTORE 0F66 60 PUSH1 0x20 0F68 01 ADD 0F69 60 PUSH1 0x00 0F6B 20 SHA3 0F6C 60 PUSH1 0x00 0F6E 90 SWAP1 0F6F 54 SLOAD 0F70 90 SWAP1 0F71 61 PUSH2 0x0100 0F74 0A EXP 0F75 90 SWAP1 0F76 04 DIV 0F77 60 PUSH1 0xff 0F79 16 AND 0F7A 90 SWAP1 0F7B 50 POP 0F7C 92 SWAP3 0F7D 91 SWAP2 0F7E 50 POP 0F7F 50 POP 0F80 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0F22 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0F28 memory[0x20:0x40] = 0x02 // @0F5F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0F65 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0F7C stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0F81: // Incoming jump from 0x029A // Inputs[1] { @0F9A stack[-4] } 0F81 5B JUMPDEST 0F82 60 PUSH1 0x00 0F84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F99 16 AND 0F9A 84 DUP5 0F9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FB0 16 AND 0FB1 14 EQ 0FB2 15 ISZERO 0FB3 61 PUSH2 0x0ff1 0FB6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ff1, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0FB7: // Incoming jump from 0x0FB6, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0FB9 memory[0x40:0x60] } 0FB7 60 PUSH1 0x40 0FB9 51 MLOAD 0FBA 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0FDB 81 DUP2 0FDC 52 MSTORE 0FDD 60 PUSH1 0x04 0FDF 01 ADD 0FE0 61 PUSH2 0x0fe8 0FE3 90 SWAP1 0FE4 61 PUSH2 0x29c6 0FE7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FDC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0FE3 stack[0] = 0x0fe8 // @0FE3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29c6, returns to 0x0FE8 label_0FE8: // Incoming return from call to 0x29C6 at 0x0FE7 // Inputs[3] // { // @0FEB memory[0x40:0x60] // @0FED stack[-1] // @0FF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0FE8 5B JUMPDEST 0FE9 60 PUSH1 0x40 0FEB 51 MLOAD 0FEC 80 DUP1 0FED 91 SWAP2 0FEE 03 SUB 0FEF 90 SWAP1 0FF0 FD *REVERT // Stack delta = -1 // Outputs[1] { @0FF0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0FF1: // Incoming jump from 0x0FB6, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) 0FF1 5B JUMPDEST 0FF2 61 PUSH2 0x0ff9 0FF5 61 PUSH2 0x14c3 0FF8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FF2 stack[0] = 0x0ff9 } // Block ends with call to 0x14c3, returns to 0x0FF9 label_0FF9: // Incoming return from call to 0x14C3 at 0x0FF8 // Inputs[2] // { // @100F stack[-1] // @1010 stack[-6] // } 0FF9 5B JUMPDEST 0FFA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 100F 16 AND 1010 85 DUP6 1011 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1026 16 AND 1027 14 EQ 1028 80 DUP1 1029 61 PUSH2 0x103f 102C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1027 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] } // Block ends with conditional jump to 0x103f, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_102D: // Incoming jump from 0x102C, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @1031 stack[-6] } 102D 50 POP 102E 61 PUSH2 0x103e 1031 85 DUP6 1032 61 PUSH2 0x1039 1035 61 PUSH2 0x14c3 1038 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @102E stack[-1] = 0x103e // @1031 stack[0] = stack[-6] // @1032 stack[1] = 0x1039 // } // Block ends with call to 0x14c3, returns to 0x1039 label_1039: // Incoming return from call to 0x14C3 at 0x1038 1039 5B JUMPDEST 103A 61 PUSH2 0x0eed 103D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eed label_103E: // Incoming return from call to 0x1039 at 0x1038 103E 5B JUMPDEST // Stack delta = +0 // Block continues label_103F: // Incoming jump from 0x102C, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x103E // Inputs[1] { @1043 stack[-1] } 103F 5B JUMPDEST 1040 61 PUSH2 0x107e 1043 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x107e, if stack[-1] label_1044: // Incoming jump from 0x1043, if not stack[-1] // Inputs[1] { @1046 memory[0x40:0x60] } 1044 60 PUSH1 0x40 1046 51 MLOAD 1047 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1068 81 DUP2 1069 52 MSTORE 106A 60 PUSH1 0x04 106C 01 ADD 106D 61 PUSH2 0x1075 1070 90 SWAP1 1071 61 PUSH2 0x29a6 1074 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1069 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1070 stack[0] = 0x1075 // @1070 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29a6, returns to 0x1075 label_1075: // Incoming return from call to 0x29A6 at 0x1074 // Inputs[3] // { // @1078 memory[0x40:0x60] // @107A stack[-1] // @107D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1075 5B JUMPDEST 1076 60 PUSH1 0x40 1078 51 MLOAD 1079 80 DUP1 107A 91 SWAP2 107B 03 SUB 107C 90 SWAP1 107D FD *REVERT // Stack delta = -1 // Outputs[1] { @107D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_107E: // Incoming jump from 0x1043, if stack[-1] 107E 5B JUMPDEST 107F 60 PUSH1 0x00 1081 61 PUSH2 0x1088 1084 61 PUSH2 0x14c3 1087 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @107F stack[0] = 0x00 // @1081 stack[1] = 0x1088 // } // Block ends with call to 0x14c3, returns to 0x1088 label_1088: // Incoming return from call to 0x14C3 at 0x1087 // Inputs[5] // { // @1089 stack[-1] // @1089 stack[-2] // @108F stack[-7] // @1090 stack[-6] // @1094 stack[-5] // } 1088 5B JUMPDEST 1089 90 SWAP1 108A 50 POP 108B 61 PUSH2 0x10a8 108E 81 DUP2 108F 87 DUP8 1090 87 DUP8 1091 61 PUSH2 0x1099 1094 88 DUP9 1095 61 PUSH2 0x1753 1098 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1089 stack[-2] = stack[-1] // @108B stack[-1] = 0x10a8 // @108E stack[0] = stack[-1] // @108F stack[1] = stack[-7] // @1090 stack[2] = stack[-6] // @1091 stack[3] = 0x1099 // @1094 stack[4] = stack[-5] // } // Block ends with call to 0x1753, returns to 0x1099 label_1099: // Incoming return from call to 0x1753 at 0x1098 // Inputs[1] { @109D stack[-8] } 1099 5B JUMPDEST 109A 61 PUSH2 0x10a2 109D 88 DUP9 109E 61 PUSH2 0x1753 10A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @109A stack[0] = 0x10a2 // @109D stack[1] = stack[-8] // } // Block ends with call to 0x1753, returns to 0x10A2 label_10A2: // Incoming return from call to 0x1753 at 0x10A1 // Inputs[1] { @10A3 stack[-8] } 10A2 5B JUMPDEST 10A3 87 DUP8 10A4 61 PUSH2 0x14cb 10A7 56 *JUMP // Stack delta = +1 // Outputs[1] { @10A3 stack[0] = stack[-8] } // Block ends with unconditional jump to 0x14cb label_10A8: // Incoming return from call to 0x1099 at 0x1098 // Inputs[7] // { // @10AC stack[-3] // @10AF memory[0x40:0x60] // @10CA stack[-4] // @10D8 memory[0x00:0x40] // @10DB stack[-6] // @1115 memory[0x00:0x40] // @1116 storage[keccak256(memory[0x00:0x40])] // } 10A8 5B JUMPDEST 10A9 61 PUSH2 0x1125 10AC 83 DUP4 10AD 60 PUSH1 0x40 10AF 51 MLOAD 10B0 80 DUP1 10B1 60 PUSH1 0x60 10B3 01 ADD 10B4 60 PUSH1 0x40 10B6 52 MSTORE 10B7 80 DUP1 10B8 60 PUSH1 0x2a 10BA 81 DUP2 10BB 52 MSTORE 10BC 60 PUSH1 0x20 10BE 01 ADD 10BF 61 PUSH2 0x2e8c 10C2 60 PUSH1 0x2a 10C4 91 SWAP2 10C5 39 CODECOPY 10C6 60 PUSH1 0x01 10C8 60 PUSH1 0x00 10CA 88 DUP9 10CB 81 DUP2 10CC 52 MSTORE 10CD 60 PUSH1 0x20 10CF 01 ADD 10D0 90 SWAP1 10D1 81 DUP2 10D2 52 MSTORE 10D3 60 PUSH1 0x20 10D5 01 ADD 10D6 60 PUSH1 0x00 10D8 20 SHA3 10D9 60 PUSH1 0x00 10DB 8A DUP11 10DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10F1 16 AND 10F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1107 16 AND 1108 81 DUP2 1109 52 MSTORE 110A 60 PUSH1 0x20 110C 01 ADD 110D 90 SWAP1 110E 81 DUP2 110F 52 MSTORE 1110 60 PUSH1 0x20 1112 01 ADD 1113 60 PUSH1 0x00 1115 20 SHA3 1116 54 SLOAD 1117 61 PUSH2 0x14d3 111A 90 SWAP1 111B 92 SWAP3 111C 91 SWAP2 111D 90 SWAP1 111E 63 PUSH4 0xffffffff 1123 16 AND 1124 56 *JUMP // Stack delta = +4 // Outputs[11] // { // @10A9 stack[0] = 0x1125 // @10B6 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @10BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2a // @10C5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x2a] = code[0x2e8c:0x2eb6] // @10CC memory[0x00:0x20] = stack[-4] // @10D2 memory[0x20:0x40] = 0x01 // @1109 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @110F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @111B stack[1] = storage[keccak256(memory[0x00:0x40])] // @111C stack[2] = stack[-3] // @111D stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x14d3, returns to 0x1125 label_1125: // Incoming return from call to 0x14D3 at 0x1124 // Inputs[10] // { // @112A stack[-5] // @1138 memory[0x00:0x40] // @113B stack[-7] // @1175 memory[0x00:0x40] // @1176 stack[-1] // @117D stack[-4] // @1190 memory[0x00:0x40] // @1193 stack[-6] // @11CD memory[0x00:0x40] // @11CE storage[keccak256(memory[0x00:0x40])] // } 1125 5B JUMPDEST 1126 60 PUSH1 0x01 1128 60 PUSH1 0x00 112A 86 DUP7 112B 81 DUP2 112C 52 MSTORE 112D 60 PUSH1 0x20 112F 01 ADD 1130 90 SWAP1 1131 81 DUP2 1132 52 MSTORE 1133 60 PUSH1 0x20 1135 01 ADD 1136 60 PUSH1 0x00 1138 20 SHA3 1139 60 PUSH1 0x00 113B 88 DUP9 113C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1151 16 AND 1152 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1167 16 AND 1168 81 DUP2 1169 52 MSTORE 116A 60 PUSH1 0x20 116C 01 ADD 116D 90 SWAP1 116E 81 DUP2 116F 52 MSTORE 1170 60 PUSH1 0x20 1172 01 ADD 1173 60 PUSH1 0x00 1175 20 SHA3 1176 81 DUP2 1177 90 SWAP1 1178 55 SSTORE 1179 50 POP 117A 61 PUSH2 0x11dc 117D 83 DUP4 117E 60 PUSH1 0x01 1180 60 PUSH1 0x00 1182 87 DUP8 1183 81 DUP2 1184 52 MSTORE 1185 60 PUSH1 0x20 1187 01 ADD 1188 90 SWAP1 1189 81 DUP2 118A 52 MSTORE 118B 60 PUSH1 0x20 118D 01 ADD 118E 60 PUSH1 0x00 1190 20 SHA3 1191 60 PUSH1 0x00 1193 88 DUP9 1194 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11A9 16 AND 11AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11BF 16 AND 11C0 81 DUP2 11C1 52 MSTORE 11C2 60 PUSH1 0x20 11C4 01 ADD 11C5 90 SWAP1 11C6 81 DUP2 11C7 52 MSTORE 11C8 60 PUSH1 0x20 11CA 01 ADD 11CB 60 PUSH1 0x00 11CD 20 SHA3 11CE 54 SLOAD 11CF 61 PUSH2 0x152e 11D2 90 SWAP1 11D3 91 SWAP2 11D4 90 SWAP1 11D5 63 PUSH4 0xffffffff 11DA 16 AND 11DB 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @112C memory[0x00:0x20] = stack[-5] // @1132 memory[0x20:0x40] = 0x01 // @1169 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @116F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1178 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @117A stack[-1] = 0x11dc // @1184 memory[0x00:0x20] = stack[-5] // @118A memory[0x20:0x40] = 0x01 // @11C1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @11C7 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @11D3 stack[0] = storage[keccak256(memory[0x00:0x40])] // @11D4 stack[1] = stack[-4] // } // Block ends with call to 0xffffffff & 0x152e, returns to 0x11DC label_11DC: // Incoming return from call to 0x152E at 0x11DB // Inputs[9] // { // @11E1 stack[-5] // @11EF memory[0x00:0x40] // @11F2 stack[-6] // @122C memory[0x00:0x40] // @122D stack[-1] // @1248 stack[-7] // @125F stack[-2] // @1298 stack[-4] // @129B memory[0x40:0x60] // } 11DC 5B JUMPDEST 11DD 60 PUSH1 0x01 11DF 60 PUSH1 0x00 11E1 86 DUP7 11E2 81 DUP2 11E3 52 MSTORE 11E4 60 PUSH1 0x20 11E6 01 ADD 11E7 90 SWAP1 11E8 81 DUP2 11E9 52 MSTORE 11EA 60 PUSH1 0x20 11EC 01 ADD 11ED 60 PUSH1 0x00 11EF 20 SHA3 11F0 60 PUSH1 0x00 11F2 87 DUP8 11F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1208 16 AND 1209 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 121E 16 AND 121F 81 DUP2 1220 52 MSTORE 1221 60 PUSH1 0x20 1223 01 ADD 1224 90 SWAP1 1225 81 DUP2 1226 52 MSTORE 1227 60 PUSH1 0x20 1229 01 ADD 122A 60 PUSH1 0x00 122C 20 SHA3 122D 81 DUP2 122E 90 SWAP1 122F 55 SSTORE 1230 50 POP 1231 84 DUP5 1232 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1247 16 AND 1248 86 DUP7 1249 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 125E 16 AND 125F 82 DUP3 1260 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1275 16 AND 1276 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1297 87 DUP8 1298 87 DUP8 1299 60 PUSH1 0x40 129B 51 MLOAD 129C 61 PUSH2 0x12a6 129F 92 SWAP3 12A0 91 SWAP2 12A1 90 SWAP1 12A2 61 PUSH2 0x2b21 12A5 56 *JUMP // Stack delta = +7 // Outputs[13] // { // @11E3 memory[0x00:0x20] = stack[-5] // @11E9 memory[0x20:0x40] = 0x01 // @1220 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1226 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @122F storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1247 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @125E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @1275 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1276 stack[2] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @129F stack[3] = 0x12a6 // @12A0 stack[4] = stack[-5] // @12A1 stack[5] = stack[-4] // @12A1 stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x2b21, returns to 0x12A6 label_12A6: // Incoming return from call to 0x2B21 at 0x12A5 // Inputs[13] // { // @12A9 memory[0x40:0x60] // @12AB stack[-1] // @12AE stack[-3] // @12AE stack[-4] // @12AE stack[-2] // @12AE stack[-5] // @12AE memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @12B2 stack[-6] // @12B3 stack[-11] // @12B4 stack[-10] // @12B5 stack[-9] // @12B6 stack[-8] // @12B7 stack[-7] // } 12A6 5B JUMPDEST 12A7 60 PUSH1 0x40 12A9 51 MLOAD 12AA 80 DUP1 12AB 91 SWAP2 12AC 03 SUB 12AD 90 SWAP1 12AE A4 LOG4 12AF 61 PUSH2 0x12bc 12B2 81 DUP2 12B3 87 DUP8 12B4 87 DUP8 12B5 87 DUP8 12B6 87 DUP8 12B7 87 DUP8 12B8 61 PUSH2 0x17c3 12BB 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @12AE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @12AF stack[-5] = 0x12bc // @12B2 stack[-4] = stack[-6] // @12B3 stack[-3] = stack[-11] // @12B4 stack[-2] = stack[-10] // @12B5 stack[-1] = stack[-9] // @12B6 stack[0] = stack[-8] // @12B7 stack[1] = stack[-7] // } // Block ends with call to 0x17c3, returns to 0x12BC label_12BC: // Incoming return from call to 0x17C3 at 0x12BB // Inputs[1] { @12C3 stack[-7] } 12BC 5B JUMPDEST 12BD 50 POP 12BE 50 POP 12BF 50 POP 12C0 50 POP 12C1 50 POP 12C2 50 POP 12C3 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_12C4: // Incoming jump from 0x02B6 // Inputs[4] // { // @12CA stack[-1] // @12D2 memory[0x00:0x40] // @12D9 storage[keccak256(memory[0x00:0x40])] // @12DA stack[-2] // } 12C4 5B JUMPDEST 12C5 60 PUSH1 0x04 12C7 60 PUSH1 0x20 12C9 52 MSTORE 12CA 80 DUP1 12CB 60 PUSH1 0x00 12CD 52 MSTORE 12CE 60 PUSH1 0x40 12D0 60 PUSH1 0x00 12D2 20 SHA3 12D3 60 PUSH1 0x00 12D5 91 SWAP2 12D6 50 POP 12D7 90 SWAP1 12D8 50 POP 12D9 54 SLOAD 12DA 81 DUP2 12DB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @12C9 memory[0x20:0x40] = 0x04 // @12CD memory[0x00:0x20] = stack[-1] // @12D9 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_12DC: // Incoming call from 0x0603, returns to 0x0604 // Inputs[1] { @12F5 stack[-4] } 12DC 5B JUMPDEST 12DD 60 PUSH1 0x00 12DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12F4 16 AND 12F5 84 DUP5 12F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 130B 16 AND 130C 14 EQ 130D 15 ISZERO 130E 61 PUSH2 0x134c 1311 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x134c, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1312: // Incoming jump from 0x1311, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1314 memory[0x40:0x60] } 1312 60 PUSH1 0x40 1314 51 MLOAD 1315 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1336 81 DUP2 1337 52 MSTORE 1338 60 PUSH1 0x04 133A 01 ADD 133B 61 PUSH2 0x1343 133E 90 SWAP1 133F 61 PUSH2 0x2aa6 1342 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1337 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @133E stack[0] = 0x1343 // @133E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2aa6, returns to 0x1343 label_1343: // Incoming return from call to 0x2AA6 at 0x1342 // Inputs[3] // { // @1346 memory[0x40:0x60] // @1348 stack[-1] // @134B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1343 5B JUMPDEST 1344 60 PUSH1 0x40 1346 51 MLOAD 1347 80 DUP1 1348 91 SWAP2 1349 03 SUB 134A 90 SWAP1 134B FD *REVERT // Stack delta = -1 // Outputs[1] { @134B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_134C: // Incoming jump from 0x1311, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) 134C 5B JUMPDEST 134D 60 PUSH1 0x00 134F 61 PUSH2 0x1356 1352 61 PUSH2 0x14c3 1355 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @134D stack[0] = 0x00 // @134F stack[1] = 0x1356 // } // Block ends with call to 0x14c3, returns to 0x1356 label_1356: // Incoming return from call to 0x14C3 at 0x1355 // Inputs[4] // { // @1357 stack[-2] // @1357 stack[-1] // @135F stack[-6] // @1363 stack[-5] // } 1356 5B JUMPDEST 1357 90 SWAP1 1358 50 POP 1359 61 PUSH2 0x1377 135C 81 DUP2 135D 60 PUSH1 0x00 135F 87 DUP8 1360 61 PUSH2 0x1368 1363 88 DUP9 1364 61 PUSH2 0x1753 1367 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1357 stack[-2] = stack[-1] // @1359 stack[-1] = 0x1377 // @135C stack[0] = stack[-1] // @135D stack[1] = 0x00 // @135F stack[2] = stack[-6] // @1360 stack[3] = 0x1368 // @1363 stack[4] = stack[-5] // } // Block ends with call to 0x1753, returns to 0x1368 label_1368: // Incoming return from call to 0x1753 at 0x1367 // Inputs[1] { @136C stack[-8] } 1368 5B JUMPDEST 1369 61 PUSH2 0x1371 136C 88 DUP9 136D 61 PUSH2 0x1753 1370 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1369 stack[0] = 0x1371 // @136C stack[1] = stack[-8] // } // Block ends with call to 0x1753, returns to 0x1371 label_1371: // Incoming return from call to 0x1753 at 0x1370 // Inputs[1] { @1372 stack[-8] } 1371 5B JUMPDEST 1372 87 DUP8 1373 61 PUSH2 0x14cb 1376 56 *JUMP // Stack delta = +1 // Outputs[1] { @1372 stack[0] = stack[-8] } // Block ends with unconditional jump to 0x14cb label_1377: // Incoming return from call to 0x1368 at 0x1367 // Inputs[6] // { // @137B stack[-3] // @1380 stack[-4] // @138E memory[0x00:0x40] // @1391 stack[-5] // @13CB memory[0x00:0x40] // @13CC storage[keccak256(memory[0x00:0x40])] // } 1377 5B JUMPDEST 1378 61 PUSH2 0x13da 137B 83 DUP4 137C 60 PUSH1 0x01 137E 60 PUSH1 0x00 1380 87 DUP8 1381 81 DUP2 1382 52 MSTORE 1383 60 PUSH1 0x20 1385 01 ADD 1386 90 SWAP1 1387 81 DUP2 1388 52 MSTORE 1389 60 PUSH1 0x20 138B 01 ADD 138C 60 PUSH1 0x00 138E 20 SHA3 138F 60 PUSH1 0x00 1391 88 DUP9 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 90 SWAP1 13C4 81 DUP2 13C5 52 MSTORE 13C6 60 PUSH1 0x20 13C8 01 ADD 13C9 60 PUSH1 0x00 13CB 20 SHA3 13CC 54 SLOAD 13CD 61 PUSH2 0x152e 13D0 90 SWAP1 13D1 91 SWAP2 13D2 90 SWAP1 13D3 63 PUSH4 0xffffffff 13D8 16 AND 13D9 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1378 stack[0] = 0x13da // @1382 memory[0x00:0x20] = stack[-4] // @1388 memory[0x20:0x40] = 0x01 // @13BF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @13C5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13D1 stack[1] = storage[keccak256(memory[0x00:0x40])] // @13D2 stack[2] = stack[-3] // } // Block ends with call to 0xffffffff & 0x152e, returns to 0x13DA label_13DA: // Incoming return from call to 0x152E at 0x13D9 // Inputs[8] // { // @13DF stack[-5] // @13ED memory[0x00:0x40] // @13F0 stack[-6] // @142A memory[0x00:0x40] // @142B stack[-1] // @145E stack[-2] // @1497 stack[-4] // @149A memory[0x40:0x60] // } 13DA 5B JUMPDEST 13DB 60 PUSH1 0x01 13DD 60 PUSH1 0x00 13DF 86 DUP7 13E0 81 DUP2 13E1 52 MSTORE 13E2 60 PUSH1 0x20 13E4 01 ADD 13E5 90 SWAP1 13E6 81 DUP2 13E7 52 MSTORE 13E8 60 PUSH1 0x20 13EA 01 ADD 13EB 60 PUSH1 0x00 13ED 20 SHA3 13EE 60 PUSH1 0x00 13F0 87 DUP8 13F1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1406 16 AND 1407 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 141C 16 AND 141D 81 DUP2 141E 52 MSTORE 141F 60 PUSH1 0x20 1421 01 ADD 1422 90 SWAP1 1423 81 DUP2 1424 52 MSTORE 1425 60 PUSH1 0x20 1427 01 ADD 1428 60 PUSH1 0x00 142A 20 SHA3 142B 81 DUP2 142C 90 SWAP1 142D 55 SSTORE 142E 50 POP 142F 84 DUP5 1430 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1445 16 AND 1446 60 PUSH1 0x00 1448 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 145D 16 AND 145E 82 DUP3 145F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1474 16 AND 1475 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1496 87 DUP8 1497 87 DUP8 1498 60 PUSH1 0x40 149A 51 MLOAD 149B 61 PUSH2 0x14a5 149E 92 SWAP3 149F 91 SWAP2 14A0 90 SWAP1 14A1 61 PUSH2 0x2b21 14A4 56 *JUMP // Stack delta = +7 // Outputs[13] // { // @13E1 memory[0x00:0x20] = stack[-5] // @13E7 memory[0x20:0x40] = 0x01 // @141E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1424 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @142D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1445 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @145D stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @1474 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1475 stack[2] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @149E stack[3] = 0x14a5 // @149F stack[4] = stack[-5] // @14A0 stack[5] = stack[-4] // @14A0 stack[6] = memory[0x40:0x60] // } // Block ends with call to 0x2b21, returns to 0x14A5 label_14A5: // Incoming return from call to 0x2B21 at 0x14A4 // Inputs[12] // { // @14A8 memory[0x40:0x60] // @14AA stack[-1] // @14AD stack[-5] // @14AD stack[-3] // @14AD stack[-2] // @14AD stack[-4] // @14AD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @14B1 stack[-6] // @14B4 stack[-10] // @14B5 stack[-9] // @14B6 stack[-8] // @14B7 stack[-7] // } 14A5 5B JUMPDEST 14A6 60 PUSH1 0x40 14A8 51 MLOAD 14A9 80 DUP1 14AA 91 SWAP2 14AB 03 SUB 14AC 90 SWAP1 14AD A4 LOG4 14AE 61 PUSH2 0x14bc 14B1 81 DUP2 14B2 60 PUSH1 0x00 14B4 87 DUP8 14B5 87 DUP8 14B6 87 DUP8 14B7 87 DUP8 14B8 61 PUSH2 0x17c3 14BB 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @14AD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @14AE stack[-5] = 0x14bc // @14B1 stack[-4] = stack[-6] // @14B2 stack[-3] = 0x00 // @14B4 stack[-2] = stack[-10] // @14B5 stack[-1] = stack[-9] // @14B6 stack[0] = stack[-8] // @14B7 stack[1] = stack[-7] // } // Block ends with call to 0x17c3, returns to 0x14BC label_14BC: // Incoming return from call to 0x17C3 at 0x14BB // Inputs[1] { @14C2 stack[-6] } 14BC 5B JUMPDEST 14BD 50 POP 14BE 50 POP 14BF 50 POP 14C0 50 POP 14C1 50 POP 14C2 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_14C3: // Incoming call from 0x0D8A, returns to 0x0D8B // Incoming call from 0x0753, returns to 0x0754 // Incoming call from 0x1355, returns to 0x1356 // Incoming call from 0x1087, returns to 0x1088 // Incoming call from 0x0E9B, returns to 0x0E9C // Incoming call from 0x0FF8, returns to 0x0FF9 // Incoming call from 0x0DEE, returns to 0x0DEF // Incoming call from 0x1038, returns to 0x1039 // Incoming call from 0x0704, returns to 0x0705 // Incoming call from 0x06C4, returns to 0x06C5 // Inputs[2] // { // @14C6 msg.sender // @14C9 stack[-1] // } 14C3 5B JUMPDEST 14C4 60 PUSH1 0x00 14C6 33 CALLER 14C7 90 SWAP1 14C8 50 POP 14C9 90 SWAP1 14CA 56 *JUMP // Stack delta = +0 // Outputs[1] { @14C9 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_14CB: // Incoming jump from 0x1376 // Incoming jump from 0x10A7 // Incoming call from 0x0763, returns to 0x0764 // Inputs[1] { @14D2 stack[-7] } 14CB 5B JUMPDEST 14CC 50 POP 14CD 50 POP 14CE 50 POP 14CF 50 POP 14D0 50 POP 14D1 50 POP 14D2 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_14D3: // Incoming call from 0x1124, returns to 0x1125 // Incoming call from 0x081F, returns to 0x0820 // Inputs[3] // { // @14D6 stack[-3] // @14D7 stack[-2] // @14DA stack[-1] // } 14D3 5B JUMPDEST 14D4 60 PUSH1 0x00 14D6 83 DUP4 14D7 83 DUP4 14D8 11 GT 14D9 15 ISZERO 14DA 82 DUP3 14DB 90 SWAP1 14DC 61 PUSH2 0x151b 14DF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14D4 stack[0] = 0x00 // @14DB stack[1] = stack[-1] // } // Block ends with conditional jump to 0x151b, if !(stack[-2] > stack[-3]) label_14E0: // Incoming jump from 0x14DF, if not !(stack[-2] > stack[-3]) // Inputs[2] // { // @14E2 memory[0x40:0x60] // @150C stack[-1] // } 14E0 60 PUSH1 0x40 14E2 51 MLOAD 14E3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1504 81 DUP2 1505 52 MSTORE 1506 60 PUSH1 0x04 1508 01 ADD 1509 61 PUSH2 0x1512 150C 91 SWAP2 150D 90 SWAP1 150E 61 PUSH2 0x28e4 1511 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1505 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @150C stack[-1] = 0x1512 // @150D stack[1] = 0x04 + memory[0x40:0x60] // @150D stack[0] = stack[-1] // } // Block ends with call to 0x28e4, returns to 0x1512 label_1512: // Incoming return from call to 0x28E4 at 0x1511 // Inputs[3] // { // @1515 memory[0x40:0x60] // @1517 stack[-1] // @151A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1512 5B JUMPDEST 1513 60 PUSH1 0x40 1515 51 MLOAD 1516 80 DUP1 1517 91 SWAP2 1518 03 SUB 1519 90 SWAP1 151A FD *REVERT // Stack delta = -1 // Outputs[1] { @151A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_151B: // Incoming jump from 0x14DF, if !(stack[-2] > stack[-3]) // Inputs[4] // { // @151F stack[-4] // @1520 stack[-5] // @1525 stack[-2] // @1528 stack[-6] // } 151B 5B JUMPDEST 151C 50 POP 151D 60 PUSH1 0x00 151F 83 DUP4 1520 85 DUP6 1521 03 SUB 1522 90 SWAP1 1523 50 POP 1524 80 DUP1 1525 91 SWAP2 1526 50 POP 1527 50 POP 1528 93 SWAP4 1529 92 SWAP3 152A 50 POP 152B 50 POP 152C 50 POP 152D 56 *JUMP // Stack delta = -5 // Outputs[1] { @1528 stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_152E: // Incoming call from 0x08D6, returns to 0x08D7 // Incoming call from 0x13D9, returns to 0x13DA // Incoming call from 0x11DB, returns to 0x11DC // Inputs[2] // { // @1532 stack[-1] // @1533 stack[-2] // } 152E 5B JUMPDEST 152F 60 PUSH1 0x00 1531 80 DUP1 1532 82 DUP3 1533 84 DUP5 1534 01 ADD 1535 90 SWAP1 1536 50 POP 1537 83 DUP4 1538 81 DUP2 1539 10 LT 153A 15 ISZERO 153B 61 PUSH2 0x1579 153E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @152F stack[0] = 0x00 // @1535 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x1579, if !(stack[-2] + stack[-1] < stack[-2]) label_153F: // Incoming jump from 0x153E, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @1541 memory[0x40:0x60] } 153F 60 PUSH1 0x40 1541 51 MLOAD 1542 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1563 81 DUP2 1564 52 MSTORE 1565 60 PUSH1 0x04 1567 01 ADD 1568 61 PUSH2 0x1570 156B 90 SWAP1 156C 61 PUSH2 0x2986 156F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1564 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @156B stack[0] = 0x1570 // @156B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2986, returns to 0x1570 label_1570: // Incoming return from call to 0x2986 at 0x156F // Inputs[3] // { // @1573 memory[0x40:0x60] // @1575 stack[-1] // @1578 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1570 5B JUMPDEST 1571 60 PUSH1 0x40 1573 51 MLOAD 1574 80 DUP1 1575 91 SWAP2 1576 03 SUB 1577 90 SWAP1 1578 FD *REVERT // Stack delta = -1 // Outputs[1] { @1578 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1579: // Incoming jump from 0x153E, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @157A stack[-1] // @157B stack[-2] // @157E stack[-5] // @157F stack[-4] // } 1579 5B JUMPDEST 157A 80 DUP1 157B 91 SWAP2 157C 50 POP 157D 50 POP 157E 92 SWAP3 157F 91 SWAP2 1580 50 POP 1581 50 POP 1582 56 *JUMP // Stack delta = -4 // Outputs[1] { @157E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1583: // Incoming call from 0x09C4, returns to 0x09C5 // Inputs[1] { @1587 stack[-4] } 1583 5B JUMPDEST 1584 61 PUSH2 0x15a2 1587 84 DUP5 1588 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 159D 16 AND 159E 61 PUSH2 0x1993 15A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1584 stack[0] = 0x15a2 // @159D stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // } // Block ends with call to 0x1993, returns to 0x15A2 label_15A2: // Incoming return from call to 0x1993 at 0x15A1 // Inputs[1] { @15A3 stack[-1] } 15A2 5B JUMPDEST 15A3 15 ISZERO 15A4 61 PUSH2 0x174b 15A7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x174b, if !stack[-1] label_15A8: // Incoming jump from 0x15A7, if not !stack[-1] // Inputs[7] // { // @15A8 stack[-4] // @15C4 stack[-6] // @15C5 stack[-5] // @15C6 stack[-3] // @15C7 stack[-2] // @15C8 stack[-1] // @15CB memory[0x40:0x60] // } 15A8 83 DUP4 15A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15BE 16 AND 15BF 63 PUSH4 0xbc197c81 15C4 87 DUP8 15C5 87 DUP8 15C6 86 DUP7 15C7 86 DUP7 15C8 86 DUP7 15C9 60 PUSH1 0x40 15CB 51 MLOAD 15CC 86 DUP7 15CD 63 PUSH4 0xffffffff 15D2 16 AND 15D3 60 PUSH1 0xe0 15D5 1B SHL 15D6 81 DUP2 15D7 52 MSTORE 15D8 60 PUSH1 0x04 15DA 01 ADD 15DB 61 PUSH2 0x15e8 15DE 95 SWAP6 15DF 94 SWAP5 15E0 93 SWAP4 15E1 92 SWAP3 15E2 91 SWAP2 15E3 90 SWAP1 15E4 61 PUSH2 0x2793 15E7 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @15BE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @15BF stack[1] = 0xbc197c81 // @15D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xbc197c81) << 0xe0 // @15DE stack[2] = 0x15e8 // @15DF stack[3] = stack[-6] // @15E0 stack[4] = stack[-5] // @15E1 stack[5] = stack[-3] // @15E2 stack[6] = stack[-2] // @15E3 stack[7] = stack[-1] // @15E3 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2793, returns to 0x15E8 label_15E8: // Incoming return from call to 0x2793 at 0x15E7 // Inputs[4] // { // @15ED memory[0x40:0x60] // @15EF stack[-1] // @15F4 stack[-3] // @15F6 address(stack[-3]).code.length // } 15E8 5B JUMPDEST 15E9 60 PUSH1 0x20 15EB 60 PUSH1 0x40 15ED 51 MLOAD 15EE 80 DUP1 15EF 83 DUP4 15F0 03 SUB 15F1 81 DUP2 15F2 60 PUSH1 0x00 15F4 87 DUP8 15F5 80 DUP1 15F6 3B EXTCODESIZE 15F7 15 ISZERO 15F8 80 DUP1 15F9 15 ISZERO 15FA 61 PUSH2 0x1602 15FD 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @15E9 stack[0] = 0x20 // @15ED stack[1] = memory[0x40:0x60] // @15F0 stack[2] = stack[-1] - memory[0x40:0x60] // @15F1 stack[3] = memory[0x40:0x60] // @15F2 stack[4] = 0x00 // @15F4 stack[5] = stack[-3] // @15F7 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1602, if !!address(stack[-3]).code.length label_15FE: // Incoming jump from 0x15FD, if not !!address(stack[-3]).code.length // Inputs[1] { @1601 memory[0x00:0x00] } 15FE 60 PUSH1 0x00 1600 80 DUP1 1601 FD *REVERT // Stack delta = +0 // Outputs[1] { @1601 revert(memory[0x00:0x00]); } // Block terminates label_1602: // Incoming jump from 0x15FD, if !!address(stack[-3]).code.length // Inputs[10] // { // @1604 msg.gas // @1605 stack[-7] // @1605 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1605 stack[-6] // @1605 stack[-4] // @1605 stack[-5] // @1605 stack[-3] // @1605 stack[-2] // @1605 memory[stack[-4]:stack[-4] + stack[-5]] // @1606 stack[-10] // } 1602 5B JUMPDEST 1603 50 POP 1604 5A GAS 1605 F1 CALL 1606 92 SWAP3 1607 50 POP 1608 50 POP 1609 50 POP 160A 80 DUP1 160B 15 ISZERO 160C 61 PUSH2 0x1633 160F 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1605 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1606 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1633, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1610: // Incoming jump from 0x160F, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1613 memory[0x40:0x60] // @1614 returndata.length // } 1610 50 POP 1611 60 PUSH1 0x40 1613 51 MLOAD 1614 3D RETURNDATASIZE 1615 60 PUSH1 0x1f 1617 19 NOT 1618 60 PUSH1 0x1f 161A 82 DUP3 161B 01 ADD 161C 16 AND 161D 82 DUP3 161E 01 ADD 161F 80 DUP1 1620 60 PUSH1 0x40 1622 52 MSTORE 1623 50 POP 1624 81 DUP2 1625 01 ADD 1626 90 SWAP1 1627 61 PUSH2 0x1630 162A 91 SWAP2 162B 90 SWAP1 162C 61 PUSH2 0x1e8d 162F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1622 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @162A stack[-1] = 0x1630 // @162B stack[1] = memory[0x40:0x60] // @162B stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1e8d, returns to 0x1630 label_1630: // Incoming return from call to 0x1E8D at 0x162F 1630 5B JUMPDEST 1631 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @1631 stack[0] = 0x01 } // Block continues label_1633: // Incoming jump from 0x1631 // Incoming jump from 0x160F, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1637 stack[-1] } 1633 5B JUMPDEST 1634 61 PUSH2 0x16c2 1637 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16c2, if stack[-1] label_1638: // Incoming jump from 0x1637, if not stack[-1] 1638 61 PUSH2 0x163f 163B 61 PUSH2 0x2d62 163E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1638 stack[0] = 0x163f } // Block ends with call to 0x2d62, returns to 0x163F label_163F: // Incoming return from call to 0x2D62 at 0x163E // Inputs[1] { @1640 stack[-1] } 163F 5B JUMPDEST 1640 80 DUP1 1641 61 PUSH2 0x164a 1644 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x164a, if stack[-1] label_1645: // Incoming jump from 0x1644, if not stack[-1] 1645 50 POP 1646 61 PUSH2 0x1687 1649 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1687 label_164A: // Incoming jump from 0x1644, if stack[-1] // Inputs[2] // { // @164B stack[-1] // @164E memory[0x40:0x60] // } 164A 5B JUMPDEST 164B 80 DUP1 164C 60 PUSH1 0x40 164E 51 MLOAD 164F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1670 81 DUP2 1671 52 MSTORE 1672 60 PUSH1 0x04 1674 01 ADD 1675 61 PUSH2 0x167e 1678 91 SWAP2 1679 90 SWAP1 167A 61 PUSH2 0x28e4 167D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1671 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1678 stack[0] = 0x167e // @1679 stack[1] = stack[-1] // @1679 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28e4, returns to 0x167E label_167E: // Incoming return from call to 0x28E4 at 0x167D // Inputs[3] // { // @1681 memory[0x40:0x60] // @1683 stack[-1] // @1686 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 167E 5B JUMPDEST 167F 60 PUSH1 0x40 1681 51 MLOAD 1682 80 DUP1 1683 91 SWAP2 1684 03 SUB 1685 90 SWAP1 1686 FD *REVERT // Stack delta = -1 // Outputs[1] { @1686 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1687: // Incoming jump from 0x1649 // Inputs[1] { @168A memory[0x40:0x60] } 1687 5B JUMPDEST 1688 60 PUSH1 0x40 168A 51 MLOAD 168B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 16AC 81 DUP2 16AD 52 MSTORE 16AE 60 PUSH1 0x04 16B0 01 ADD 16B1 61 PUSH2 0x16b9 16B4 90 SWAP1 16B5 61 PUSH2 0x2906 16B8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @16B4 stack[0] = 0x16b9 // @16B4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2906, returns to 0x16B9 label_16B9: // Incoming return from call to 0x2906 at 0x16B8 // Inputs[3] // { // @16BC memory[0x40:0x60] // @16BE stack[-1] // @16C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 16B9 5B JUMPDEST 16BA 60 PUSH1 0x40 16BC 51 MLOAD 16BD 80 DUP1 16BE 91 SWAP2 16BF 03 SUB 16C0 90 SWAP1 16C1 FD *REVERT // Stack delta = -1 // Outputs[1] { @16C1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_16C2: // Incoming jump from 0x1637, if stack[-1] // Inputs[1] { @16EA stack[-1] } 16C2 5B JUMPDEST 16C3 63 PUSH4 0xbc197c81 16C8 60 PUSH1 0xe0 16CA 1B SHL 16CB 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 16E8 19 NOT 16E9 16 AND 16EA 81 DUP2 16EB 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1708 19 NOT 1709 16 AND 170A 14 EQ 170B 61 PUSH2 0x1749 170E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1749, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0) label_170F: // Incoming jump from 0x170E, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0) // Inputs[1] { @1711 memory[0x40:0x60] } 170F 60 PUSH1 0x40 1711 51 MLOAD 1712 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1733 81 DUP2 1734 52 MSTORE 1735 60 PUSH1 0x04 1737 01 ADD 1738 61 PUSH2 0x1740 173B 90 SWAP1 173C 61 PUSH2 0x2926 173F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1734 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @173B stack[0] = 0x1740 // @173B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2926, returns to 0x1740 label_1740: // Incoming return from call to 0x2926 at 0x173F // Inputs[3] // { // @1743 memory[0x40:0x60] // @1745 stack[-1] // @1748 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1740 5B JUMPDEST 1741 60 PUSH1 0x40 1743 51 MLOAD 1744 80 DUP1 1745 91 SWAP2 1746 03 SUB 1747 90 SWAP1 1748 FD *REVERT // Stack delta = -1 // Outputs[1] { @1748 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1749: // Incoming jump from 0x170E, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xbc197c81 << 0xe0) 1749 5B JUMPDEST 174A 50 POP // Stack delta = -1 // Block continues label_174B: // Incoming jump from 0x174A // Incoming jump from 0x15A7, if !stack[-1] // Inputs[1] { @1752 stack[-7] } 174B 5B JUMPDEST 174C 50 POP 174D 50 POP 174E 50 POP 174F 50 POP 1750 50 POP 1751 50 POP 1752 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1753: // Incoming call from 0x1367, returns to 0x1368 // Incoming call from 0x1370, returns to 0x1371 // Incoming call from 0x1098, returns to 0x1099 // Incoming call from 0x10A1, returns to 0x10A2 1753 5B JUMPDEST 1754 60 PUSH1 0x60 1756 80 DUP1 1757 60 PUSH1 0x01 1759 67 PUSH8 0xffffffffffffffff 1762 81 DUP2 1763 11 GT 1764 80 DUP1 1765 15 ISZERO 1766 61 PUSH2 0x176e 1769 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1754 stack[0] = 0x60 // @1756 stack[1] = 0x60 // @1757 stack[2] = 0x01 // @1763 stack[3] = 0x01 > 0xffffffffffffffff // } // Block ends with conditional jump to 0x176e, if !(0x01 > 0xffffffffffffffff) label_176A: // Incoming jump from 0x1769, if not !(0x01 > 0xffffffffffffffff) // Inputs[1] { @176D memory[0x00:0x00] } 176A 60 PUSH1 0x00 176C 80 DUP1 176D FD *REVERT // Stack delta = +0 // Outputs[1] { @176D revert(memory[0x00:0x00]); } // Block terminates label_176E: // Incoming jump from 0x1769, if !(0x01 > 0xffffffffffffffff) // Inputs[2] // { // @1772 memory[0x40:0x60] // @1773 stack[-2] // } 176E 5B JUMPDEST 176F 50 POP 1770 60 PUSH1 0x40 1772 51 MLOAD 1773 90 SWAP1 1774 80 DUP1 1775 82 DUP3 1776 52 MSTORE 1777 80 DUP1 1778 60 PUSH1 0x20 177A 02 MUL 177B 60 PUSH1 0x20 177D 01 ADD 177E 82 DUP3 177F 01 ADD 1780 60 PUSH1 0x40 1782 52 MSTORE 1783 80 DUP1 1784 15 ISZERO 1785 61 PUSH2 0x179d 1788 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1773 stack[-2] = memory[0x40:0x60] // @1773 stack[-1] = stack[-2] // @1776 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1782 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x179d, if !stack[-2] label_1789: // Incoming jump from 0x1788, if not !stack[-2] // Inputs[7] // { // @1789 stack[-2] // @178F stack[-1] // @1792 msg.data.length // @1794 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @179F stack[-3] // @17A1 stack[-5] // @17A6 memory[stack[-2]:stack[-2] + 0x20] // } 1789 81 DUP2 178A 60 PUSH1 0x20 178C 01 ADD 178D 60 PUSH1 0x20 178F 82 DUP3 1790 02 MUL 1791 80 DUP1 1792 36 CALLDATASIZE 1793 83 DUP4 1794 37 CALLDATACOPY 1795 80 DUP1 1796 82 DUP3 1797 01 ADD 1798 91 SWAP2 1799 50 POP 179A 50 POP 179B 90 SWAP1 179C 50 POP 179D 5B JUMPDEST 179E 50 POP 179F 90 SWAP1 17A0 50 POP 17A1 82 DUP3 17A2 81 DUP2 17A3 60 PUSH1 0x00 17A5 81 DUP2 17A6 51 MLOAD 17A7 81 DUP2 17A8 10 LT 17A9 61 PUSH2 0x17ae 17AC 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @1794 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @179F stack[-3] = stack[-2] // @17A1 stack[-2] = stack[-5] // @17A2 stack[-1] = stack[-2] // @17A3 stack[0] = 0x00 // } // Block ends with conditional jump to 0x17ae, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_17AD: // Incoming jump from 0x17AC, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x17AC, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 17AD FE *ASSERT // Stack delta = +0 // Outputs[1] { @17AD assert(); } // Block terminates label_17AE: // Incoming jump from 0x17AC, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x17AC, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[7] // { // @17B1 stack[-1] // @17B5 stack[-2] // @17B6 stack[-3] // @17BB stack[-4] // @17BC stack[-5] // @17BF stack[-7] // @17C0 stack[-6] // } 17AE 5B JUMPDEST 17AF 60 PUSH1 0x20 17B1 02 MUL 17B2 60 PUSH1 0x20 17B4 01 ADD 17B5 01 ADD 17B6 81 DUP2 17B7 81 DUP2 17B8 52 MSTORE 17B9 50 POP 17BA 50 POP 17BB 80 DUP1 17BC 91 SWAP2 17BD 50 POP 17BE 50 POP 17BF 91 SWAP2 17C0 90 SWAP1 17C1 50 POP 17C2 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @17B8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @17BF stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_17C3: // Incoming call from 0x12BB, returns to 0x12BC // Incoming call from 0x14BB, returns to 0x14BC // Inputs[1] { @17C7 stack[-4] } 17C3 5B JUMPDEST 17C4 61 PUSH2 0x17e2 17C7 84 DUP5 17C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17DD 16 AND 17DE 61 PUSH2 0x1993 17E1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @17C4 stack[0] = 0x17e2 // @17DD stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // } // Block ends with call to 0x1993, returns to 0x17E2 label_17E2: // Incoming return from call to 0x1993 at 0x17E1 // Inputs[1] { @17E3 stack[-1] } 17E2 5B JUMPDEST 17E3 15 ISZERO 17E4 61 PUSH2 0x198b 17E7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x198b, if !stack[-1] label_17E8: // Incoming jump from 0x17E7, if not !stack[-1] // Inputs[7] // { // @17E8 stack[-4] // @1804 stack[-6] // @1805 stack[-5] // @1806 stack[-3] // @1807 stack[-2] // @1808 stack[-1] // @180B memory[0x40:0x60] // } 17E8 83 DUP4 17E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17FE 16 AND 17FF 63 PUSH4 0xf23a6e61 1804 87 DUP8 1805 87 DUP8 1806 86 DUP7 1807 86 DUP7 1808 86 DUP7 1809 60 PUSH1 0x40 180B 51 MLOAD 180C 86 DUP7 180D 63 PUSH4 0xffffffff 1812 16 AND 1813 60 PUSH1 0xe0 1815 1B SHL 1816 81 DUP2 1817 52 MSTORE 1818 60 PUSH1 0x04 181A 01 ADD 181B 61 PUSH2 0x1828 181E 95 SWAP6 181F 94 SWAP5 1820 93 SWAP4 1821 92 SWAP3 1822 91 SWAP2 1823 90 SWAP1 1824 61 PUSH2 0x27fb 1827 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @17FE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @17FF stack[1] = 0xf23a6e61 // @1817 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xf23a6e61) << 0xe0 // @181E stack[2] = 0x1828 // @181F stack[3] = stack[-6] // @1820 stack[4] = stack[-5] // @1821 stack[5] = stack[-3] // @1822 stack[6] = stack[-2] // @1823 stack[7] = stack[-1] // @1823 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x27fb, returns to 0x1828 label_1828: // Incoming return from call to 0x27FB at 0x1827 // Inputs[4] // { // @182D memory[0x40:0x60] // @182F stack[-1] // @1834 stack[-3] // @1836 address(stack[-3]).code.length // } 1828 5B JUMPDEST 1829 60 PUSH1 0x20 182B 60 PUSH1 0x40 182D 51 MLOAD 182E 80 DUP1 182F 83 DUP4 1830 03 SUB 1831 81 DUP2 1832 60 PUSH1 0x00 1834 87 DUP8 1835 80 DUP1 1836 3B EXTCODESIZE 1837 15 ISZERO 1838 80 DUP1 1839 15 ISZERO 183A 61 PUSH2 0x1842 183D 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1829 stack[0] = 0x20 // @182D stack[1] = memory[0x40:0x60] // @1830 stack[2] = stack[-1] - memory[0x40:0x60] // @1831 stack[3] = memory[0x40:0x60] // @1832 stack[4] = 0x00 // @1834 stack[5] = stack[-3] // @1837 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1842, if !!address(stack[-3]).code.length label_183E: // Incoming jump from 0x183D, if not !!address(stack[-3]).code.length // Inputs[1] { @1841 memory[0x00:0x00] } 183E 60 PUSH1 0x00 1840 80 DUP1 1841 FD *REVERT // Stack delta = +0 // Outputs[1] { @1841 revert(memory[0x00:0x00]); } // Block terminates label_1842: // Incoming jump from 0x183D, if !!address(stack[-3]).code.length // Inputs[10] // { // @1844 msg.gas // @1845 stack[-4] // @1845 stack[-7] // @1845 stack[-6] // @1845 stack[-3] // @1845 memory[stack[-4]:stack[-4] + stack[-5]] // @1845 stack[-5] // @1845 stack[-2] // @1845 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1846 stack[-10] // } 1842 5B JUMPDEST 1843 50 POP 1844 5A GAS 1845 F1 CALL 1846 92 SWAP3 1847 50 POP 1848 50 POP 1849 50 POP 184A 80 DUP1 184B 15 ISZERO 184C 61 PUSH2 0x1873 184F 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1845 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1846 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1873, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1850: // Incoming jump from 0x184F, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1853 memory[0x40:0x60] // @1854 returndata.length // } 1850 50 POP 1851 60 PUSH1 0x40 1853 51 MLOAD 1854 3D RETURNDATASIZE 1855 60 PUSH1 0x1f 1857 19 NOT 1858 60 PUSH1 0x1f 185A 82 DUP3 185B 01 ADD 185C 16 AND 185D 82 DUP3 185E 01 ADD 185F 80 DUP1 1860 60 PUSH1 0x40 1862 52 MSTORE 1863 50 POP 1864 81 DUP2 1865 01 ADD 1866 90 SWAP1 1867 61 PUSH2 0x1870 186A 91 SWAP2 186B 90 SWAP1 186C 61 PUSH2 0x1e8d 186F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1862 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @186A stack[-1] = 0x1870 // @186B stack[1] = memory[0x40:0x60] // @186B stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1e8d, returns to 0x1870 label_1870: // Incoming return from call to 0x1E8D at 0x186F 1870 5B JUMPDEST 1871 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @1871 stack[0] = 0x01 } // Block continues label_1873: // Incoming jump from 0x1871 // Incoming jump from 0x184F, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1877 stack[-1] } 1873 5B JUMPDEST 1874 61 PUSH2 0x1902 1877 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1902, if stack[-1] label_1878: // Incoming jump from 0x1877, if not stack[-1] 1878 61 PUSH2 0x187f 187B 61 PUSH2 0x2d62 187E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1878 stack[0] = 0x187f } // Block ends with call to 0x2d62, returns to 0x187F label_187F: // Incoming return from call to 0x2D62 at 0x187E // Inputs[1] { @1880 stack[-1] } 187F 5B JUMPDEST 1880 80 DUP1 1881 61 PUSH2 0x188a 1884 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x188a, if stack[-1] label_1885: // Incoming jump from 0x1884, if not stack[-1] 1885 50 POP 1886 61 PUSH2 0x18c7 1889 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x18c7 label_188A: // Incoming jump from 0x1884, if stack[-1] // Inputs[2] // { // @188B stack[-1] // @188E memory[0x40:0x60] // } 188A 5B JUMPDEST 188B 80 DUP1 188C 60 PUSH1 0x40 188E 51 MLOAD 188F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 18B0 81 DUP2 18B1 52 MSTORE 18B2 60 PUSH1 0x04 18B4 01 ADD 18B5 61 PUSH2 0x18be 18B8 91 SWAP2 18B9 90 SWAP1 18BA 61 PUSH2 0x28e4 18BD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @18B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @18B8 stack[0] = 0x18be // @18B9 stack[1] = stack[-1] // @18B9 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28e4, returns to 0x18BE label_18BE: // Incoming return from call to 0x28E4 at 0x18BD // Inputs[3] // { // @18C1 memory[0x40:0x60] // @18C3 stack[-1] // @18C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 18BE 5B JUMPDEST 18BF 60 PUSH1 0x40 18C1 51 MLOAD 18C2 80 DUP1 18C3 91 SWAP2 18C4 03 SUB 18C5 90 SWAP1 18C6 FD *REVERT // Stack delta = -1 // Outputs[1] { @18C6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_18C7: // Incoming jump from 0x1889 // Inputs[1] { @18CA memory[0x40:0x60] } 18C7 5B JUMPDEST 18C8 60 PUSH1 0x40 18CA 51 MLOAD 18CB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 18EC 81 DUP2 18ED 52 MSTORE 18EE 60 PUSH1 0x04 18F0 01 ADD 18F1 61 PUSH2 0x18f9 18F4 90 SWAP1 18F5 61 PUSH2 0x2906 18F8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @18F4 stack[0] = 0x18f9 // @18F4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2906, returns to 0x18F9 label_18F9: // Incoming return from call to 0x2906 at 0x18F8 // Inputs[3] // { // @18FC memory[0x40:0x60] // @18FE stack[-1] // @1901 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 18F9 5B JUMPDEST 18FA 60 PUSH1 0x40 18FC 51 MLOAD 18FD 80 DUP1 18FE 91 SWAP2 18FF 03 SUB 1900 90 SWAP1 1901 FD *REVERT // Stack delta = -1 // Outputs[1] { @1901 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1902: // Incoming jump from 0x1877, if stack[-1] // Inputs[1] { @192A stack[-1] } 1902 5B JUMPDEST 1903 63 PUSH4 0xf23a6e61 1908 60 PUSH1 0xe0 190A 1B SHL 190B 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1928 19 NOT 1929 16 AND 192A 81 DUP2 192B 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1948 19 NOT 1949 16 AND 194A 14 EQ 194B 61 PUSH2 0x1989 194E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1989, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0) label_194F: // Incoming jump from 0x194E, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0) // Inputs[1] { @1951 memory[0x40:0x60] } 194F 60 PUSH1 0x40 1951 51 MLOAD 1952 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1973 81 DUP2 1974 52 MSTORE 1975 60 PUSH1 0x04 1977 01 ADD 1978 61 PUSH2 0x1980 197B 90 SWAP1 197C 61 PUSH2 0x2926 197F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1974 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @197B stack[0] = 0x1980 // @197B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2926, returns to 0x1980 label_1980: // Incoming return from call to 0x2926 at 0x197F // Inputs[3] // { // @1983 memory[0x40:0x60] // @1985 stack[-1] // @1988 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1980 5B JUMPDEST 1981 60 PUSH1 0x40 1983 51 MLOAD 1984 80 DUP1 1985 91 SWAP2 1986 03 SUB 1987 90 SWAP1 1988 FD *REVERT // Stack delta = -1 // Outputs[1] { @1988 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1989: // Incoming jump from 0x194E, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0xf23a6e61 << 0xe0) 1989 5B JUMPDEST 198A 50 POP // Stack delta = -1 // Block continues label_198B: // Incoming jump from 0x17E7, if !stack[-1] // Incoming jump from 0x198A // Inputs[1] { @1992 stack[-7] } 198B 5B JUMPDEST 198C 50 POP 198D 50 POP 198E 50 POP 198F 50 POP 1990 50 POP 1991 50 POP 1992 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1993: // Incoming call from 0x17E1, returns to 0x17E2 // Incoming call from 0x15A1, returns to 0x15A2 // Inputs[3] // { // @1997 stack[-1] // @1998 address(stack[-1]).code.length // @19A2 stack[-2] // } 1993 5B JUMPDEST 1994 60 PUSH1 0x00 1996 80 DUP1 1997 82 DUP3 1998 3B EXTCODESIZE 1999 90 SWAP1 199A 50 POP 199B 60 PUSH1 0x00 199D 81 DUP2 199E 11 GT 199F 91 SWAP2 19A0 50 POP 19A1 50 POP 19A2 91 SWAP2 19A3 90 SWAP1 19A4 50 POP 19A5 56 *JUMP // Stack delta = -1 // Outputs[1] { @19A2 stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_19A6: // Incoming call from 0x1DA2, returns to 0x1DA3 // Incoming call from 0x1D28, returns to 0x1D29 // Incoming call from 0x1D64, returns to 0x1D65 // Incoming call from 0x1A19, returns to 0x1A1A // Incoming call from 0x1C9E, returns to 0x1C9F // Incoming call from 0x1BF0, returns to 0x1BF1 // Incoming call from 0x1CAF, returns to 0x1CB0 // Incoming call from 0x1BAF, returns to 0x1BB0 // Incoming call from 0x1BDF, returns to 0x1BE0 // Incoming call from 0x1B9E, returns to 0x1B9F // Inputs[2] // { // @19A9 stack[-1] // @19AA msg.data[stack[-1]:stack[-1] + 0x20] // } 19A6 5B JUMPDEST 19A7 60 PUSH1 0x00 19A9 81 DUP2 19AA 35 CALLDATALOAD 19AB 90 SWAP1 19AC 50 POP 19AD 61 PUSH2 0x19b5 19B0 81 DUP2 19B1 61 PUSH2 0x2e18 19B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19AB stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @19AD stack[1] = 0x19b5 // @19B0 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2e18, returns to 0x19B5 label_19B5: // Incoming return from call to 0x2E18 at 0x19B4 // Inputs[3] // { // @19B6 stack[-4] // @19B6 stack[-1] // @19B7 stack[-3] // } 19B5 5B JUMPDEST 19B6 92 SWAP3 19B7 91 SWAP2 19B8 50 POP 19B9 50 POP 19BA 56 *JUMP // Stack delta = -3 // Outputs[1] { @19B6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_19BB: // Incoming call from 0x1E07, returns to 0x1E08 // Inputs[2] // { // @19BE stack[-2] // @19C1 stack[-1] // } 19BB 5B JUMPDEST 19BC 60 PUSH1 0x00 19BE 82 DUP3 19BF 60 PUSH1 0x1f 19C1 83 DUP4 19C2 01 ADD 19C3 12 SLT 19C4 61 PUSH2 0x19cc 19C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19BC stack[0] = 0x00 } // Block ends with conditional jump to 0x19cc, if stack[-1] + 0x1f i< stack[-2] label_19C8: // Incoming jump from 0x19C7, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @19CB memory[0x00:0x00] } 19C8 60 PUSH1 0x00 19CA 80 DUP1 19CB FD *REVERT // Stack delta = +0 // Outputs[1] { @19CB revert(memory[0x00:0x00]); } // Block terminates label_19CC: // Incoming jump from 0x19C7, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @19CD stack[-2] // @19CE msg.data[stack[-2]:stack[-2] + 0x20] // } 19CC 5B JUMPDEST 19CD 81 DUP2 19CE 35 CALLDATALOAD 19CF 61 PUSH2 0x19df 19D2 61 PUSH2 0x19da 19D5 82 DUP3 19D6 61 PUSH2 0x2b77 19D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19CE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @19CF stack[1] = 0x19df // @19D2 stack[2] = 0x19da // @19D5 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2b77, returns to 0x19DA label_19DA: // Incoming return from call to 0x2B77 at 0x19D9 19DA 5B JUMPDEST 19DB 61 PUSH2 0x2b4a 19DE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2b4a label_19DF: // Incoming return from call to 0x19DA at 0x19D9 // Inputs[5] // { // @19E0 stack[-1] // @19E0 stack[-3] // @19E3 stack[-2] // @19E8 stack[-4] // @19F3 stack[-5] // } 19DF 5B JUMPDEST 19E0 91 SWAP2 19E1 50 POP 19E2 81 DUP2 19E3 81 DUP2 19E4 83 DUP4 19E5 52 MSTORE 19E6 60 PUSH1 0x20 19E8 84 DUP5 19E9 01 ADD 19EA 93 SWAP4 19EB 50 POP 19EC 60 PUSH1 0x20 19EE 81 DUP2 19EF 01 ADD 19F0 90 SWAP1 19F1 50 POP 19F2 83 DUP4 19F3 85 DUP6 19F4 60 PUSH1 0x20 19F6 84 DUP5 19F7 02 MUL 19F8 82 DUP3 19F9 01 ADD 19FA 11 GT 19FB 15 ISZERO 19FC 61 PUSH2 0x1a04 19FF 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @19E0 stack[-3] = stack[-1] // @19E5 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @19EA stack[-4] = stack[-4] + 0x20 // @19F0 stack[-1] = stack[-1] + 0x20 // @19F2 stack[0] = stack[-4] + 0x20 // } // Block ends with conditional jump to 0x1a04, if !(stack[-4] + 0x20 + stack[-2] * 0x20 > stack[-5]) label_1A00: // Incoming jump from 0x19FF, if not !(stack[-4] + 0x20 + stack[-2] * 0x20 > stack[-5]) // Inputs[1] { @1A03 memory[0x00:0x00] } 1A00 60 PUSH1 0x00 1A02 80 DUP1 1A03 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A03 revert(memory[0x00:0x00]); } // Block terminates label_1A04: // Incoming jump from 0x19FF, if !(stack[-4] + 0x20 + stack[-2] * 0x20 > stack[-5]) // Inputs[1] { @1A08 stack[-3] } 1A04 5B JUMPDEST 1A05 60 PUSH1 0x00 1A07 5B JUMPDEST 1A08 83 DUP4 1A09 81 DUP2 1A0A 10 LT 1A0B 15 ISZERO 1A0C 61 PUSH2 0x1a34 1A0F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A05 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a34, if !(0x00 < stack[-3]) label_1A10: // Incoming jump from 0x1A0F, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1A0F, if not !(0x00 < stack[-3]) // Inputs[2] // { // @1A10 stack[-2] // @1A14 stack[-7] // } 1A10 81 DUP2 1A11 61 PUSH2 0x1a1a 1A14 88 DUP9 1A15 82 DUP3 1A16 61 PUSH2 0x19a6 1A19 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A10 stack[0] = stack[-2] // @1A11 stack[1] = 0x1a1a // @1A14 stack[2] = stack[-7] // @1A15 stack[3] = stack[-2] // } // Block ends with call to 0x19a6, returns to 0x1A1A label_1A1A: // Incoming return from call to 0x19A6 at 0x1A19 // Inputs[4] // { // @1A1B stack[-5] // @1A1C stack[-1] // @1A25 stack[-4] // @1A2C stack[-3] // } 1A1A 5B JUMPDEST 1A1B 84 DUP5 1A1C 52 MSTORE 1A1D 60 PUSH1 0x20 1A1F 84 DUP5 1A20 01 ADD 1A21 93 SWAP4 1A22 50 POP 1A23 60 PUSH1 0x20 1A25 83 DUP4 1A26 01 ADD 1A27 92 SWAP3 1A28 50 POP 1A29 50 POP 1A2A 60 PUSH1 0x01 1A2C 81 DUP2 1A2D 01 ADD 1A2E 90 SWAP1 1A2F 50 POP 1A30 61 PUSH2 0x1a07 1A33 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1A1C memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @1A21 stack[-5] = stack[-5] + 0x20 // @1A27 stack[-4] = stack[-4] + 0x20 // @1A2E stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x1a07 label_1A34: // Incoming jump from 0x1A0F, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1A0F, if !(0x00 < stack[-3]) // Inputs[3] // { // @1A39 stack[-8] // @1A39 stack[-5] // @1A3A stack[-7] // } 1A34 5B JUMPDEST 1A35 50 POP 1A36 50 POP 1A37 50 POP 1A38 50 POP 1A39 92 SWAP3 1A3A 91 SWAP2 1A3B 50 POP 1A3C 50 POP 1A3D 56 *JUMP // Stack delta = -7 // Outputs[1] { @1A39 stack[-8] = stack[-5] } // Block ends with unconditional jump to stack[-8] label_1A3E: // Incoming call from 0x1C19, returns to 0x1C1A // Incoming call from 0x1E30, returns to 0x1E31 // Incoming call from 0x1C42, returns to 0x1C43 // Inputs[2] // { // @1A41 stack[-2] // @1A44 stack[-1] // } 1A3E 5B JUMPDEST 1A3F 60 PUSH1 0x00 1A41 82 DUP3 1A42 60 PUSH1 0x1f 1A44 83 DUP4 1A45 01 ADD 1A46 12 SLT 1A47 61 PUSH2 0x1a4f 1A4A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A3F stack[0] = 0x00 } // Block ends with conditional jump to 0x1a4f, if stack[-1] + 0x1f i< stack[-2] label_1A4B: // Incoming jump from 0x1A4A, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1A4E memory[0x00:0x00] } 1A4B 60 PUSH1 0x00 1A4D 80 DUP1 1A4E FD *REVERT // Stack delta = +0 // Outputs[1] { @1A4E revert(memory[0x00:0x00]); } // Block terminates label_1A4F: // Incoming jump from 0x1A4A, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1A50 stack[-2] // @1A51 msg.data[stack[-2]:stack[-2] + 0x20] // } 1A4F 5B JUMPDEST 1A50 81 DUP2 1A51 35 CALLDATALOAD 1A52 61 PUSH2 0x1a62 1A55 61 PUSH2 0x1a5d 1A58 82 DUP3 1A59 61 PUSH2 0x2b9f 1A5C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A51 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A52 stack[1] = 0x1a62 // @1A55 stack[2] = 0x1a5d // @1A58 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2b9f, returns to 0x1A5D label_1A5D: // Incoming return from call to 0x2B9F at 0x1A5C 1A5D 5B JUMPDEST 1A5E 61 PUSH2 0x2b4a 1A61 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2b4a label_1A62: // Incoming return from call to 0x1A5D at 0x1A5C // Inputs[5] // { // @1A63 stack[-3] // @1A63 stack[-1] // @1A66 stack[-2] // @1A6B stack[-4] // @1A76 stack[-5] // } 1A62 5B JUMPDEST 1A63 91 SWAP2 1A64 50 POP 1A65 81 DUP2 1A66 81 DUP2 1A67 83 DUP4 1A68 52 MSTORE 1A69 60 PUSH1 0x20 1A6B 84 DUP5 1A6C 01 ADD 1A6D 93 SWAP4 1A6E 50 POP 1A6F 60 PUSH1 0x20 1A71 81 DUP2 1A72 01 ADD 1A73 90 SWAP1 1A74 50 POP 1A75 83 DUP4 1A76 85 DUP6 1A77 60 PUSH1 0x20 1A79 84 DUP5 1A7A 02 MUL 1A7B 82 DUP3 1A7C 01 ADD 1A7D 11 GT 1A7E 15 ISZERO 1A7F 61 PUSH2 0x1a87 1A82 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @1A63 stack[-3] = stack[-1] // @1A68 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1A6D stack[-4] = stack[-4] + 0x20 // @1A73 stack[-1] = stack[-1] + 0x20 // @1A75 stack[0] = stack[-4] + 0x20 // } // Block ends with conditional jump to 0x1a87, if !(stack[-4] + 0x20 + stack[-2] * 0x20 > stack[-5]) label_1A83: // Incoming jump from 0x1A82, if not !(stack[-4] + 0x20 + stack[-2] * 0x20 > stack[-5]) // Inputs[1] { @1A86 memory[0x00:0x00] } 1A83 60 PUSH1 0x00 1A85 80 DUP1 1A86 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A86 revert(memory[0x00:0x00]); } // Block terminates label_1A87: // Incoming jump from 0x1A82, if !(stack[-4] + 0x20 + stack[-2] * 0x20 > stack[-5]) // Inputs[1] { @1A8B stack[-3] } 1A87 5B JUMPDEST 1A88 60 PUSH1 0x00 1A8A 5B JUMPDEST 1A8B 83 DUP4 1A8C 81 DUP2 1A8D 10 LT 1A8E 15 ISZERO 1A8F 61 PUSH2 0x1ab7 1A92 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A88 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ab7, if !(0x00 < stack[-3]) label_1A93: // Incoming jump from 0x1A92, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1A92, if not !(0x00 < stack[-3]) // Inputs[2] // { // @1A93 stack[-2] // @1A97 stack[-7] // } 1A93 81 DUP2 1A94 61 PUSH2 0x1a9d 1A97 88 DUP9 1A98 82 DUP3 1A99 61 PUSH2 0x1b69 1A9C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A93 stack[0] = stack[-2] // @1A94 stack[1] = 0x1a9d // @1A97 stack[2] = stack[-7] // @1A98 stack[3] = stack[-2] // } // Block ends with call to 0x1b69, returns to 0x1A9D label_1A9D: // Incoming return from call to 0x1B69 at 0x1A9C // Inputs[4] // { // @1A9E stack[-5] // @1A9F stack[-1] // @1AA8 stack[-4] // @1AAF stack[-3] // } 1A9D 5B JUMPDEST 1A9E 84 DUP5 1A9F 52 MSTORE 1AA0 60 PUSH1 0x20 1AA2 84 DUP5 1AA3 01 ADD 1AA4 93 SWAP4 1AA5 50 POP 1AA6 60 PUSH1 0x20 1AA8 83 DUP4 1AA9 01 ADD 1AAA 92 SWAP3 1AAB 50 POP 1AAC 50 POP 1AAD 60 PUSH1 0x01 1AAF 81 DUP2 1AB0 01 ADD 1AB1 90 SWAP1 1AB2 50 POP 1AB3 61 PUSH2 0x1a8a 1AB6 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1A9F memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @1AA4 stack[-5] = stack[-5] + 0x20 // @1AAA stack[-4] = stack[-4] + 0x20 // @1AB1 stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x1a8a label_1AB7: // Incoming jump from 0x1A92, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1A92, if !(0x00 < stack[-3]) // Inputs[3] // { // @1ABC stack[-8] // @1ABC stack[-5] // @1ABD stack[-7] // } 1AB7 5B JUMPDEST 1AB8 50 POP 1AB9 50 POP 1ABA 50 POP 1ABB 50 POP 1ABC 92 SWAP3 1ABD 91 SWAP2 1ABE 50 POP 1ABF 50 POP 1AC0 56 *JUMP // Stack delta = -7 // Outputs[1] { @1ABC stack[-8] = stack[-5] } // Block ends with unconditional jump to stack[-8] label_1AC1: // Incoming call from 0x1D39, returns to 0x1D3A // Inputs[2] // { // @1AC4 stack[-1] // @1AC5 msg.data[stack[-1]:stack[-1] + 0x20] // } 1AC1 5B JUMPDEST 1AC2 60 PUSH1 0x00 1AC4 81 DUP2 1AC5 35 CALLDATALOAD 1AC6 90 SWAP1 1AC7 50 POP 1AC8 61 PUSH2 0x1ad0 1ACB 81 DUP2 1ACC 61 PUSH2 0x2e2f 1ACF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AC6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AC8 stack[1] = 0x1ad0 // @1ACB stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2e2f, returns to 0x1AD0 label_1AD0: // Incoming return from call to 0x2E2F at 0x1ACF // Inputs[3] // { // @1AD1 stack[-1] // @1AD1 stack[-4] // @1AD2 stack[-3] // } 1AD0 5B JUMPDEST 1AD1 92 SWAP3 1AD2 91 SWAP2 1AD3 50 POP 1AD4 50 POP 1AD5 56 *JUMP // Stack delta = -3 // Outputs[1] { @1AD1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1AD6: // Incoming call from 0x1E5A, returns to 0x1E5B // Incoming call from 0x1F10, returns to 0x1F11 // Inputs[2] // { // @1AD9 stack[-1] // @1ADA msg.data[stack[-1]:stack[-1] + 0x20] // } 1AD6 5B JUMPDEST 1AD7 60 PUSH1 0x00 1AD9 81 DUP2 1ADA 35 CALLDATALOAD 1ADB 90 SWAP1 1ADC 50 POP 1ADD 61 PUSH2 0x1ae5 1AE0 81 DUP2 1AE1 61 PUSH2 0x2e46 1AE4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1ADB stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1ADD stack[1] = 0x1ae5 // @1AE0 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2e46, returns to 0x1AE5 label_1AE5: // Incoming return from call to 0x2E46 at 0x1AE4 // Inputs[3] // { // @1AE6 stack[-1] // @1AE6 stack[-4] // @1AE7 stack[-3] // } 1AE5 5B JUMPDEST 1AE6 92 SWAP3 1AE7 91 SWAP2 1AE8 50 POP 1AE9 50 POP 1AEA 56 *JUMP // Stack delta = -3 // Outputs[1] { @1AE6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1AEB: // Incoming call from 0x1E83, returns to 0x1E84 // Inputs[2] // { // @1AEE stack[-1] // @1AEF msg.data[stack[-1]:stack[-1] + 0x20] // } 1AEB 5B JUMPDEST 1AEC 60 PUSH1 0x00 1AEE 81 DUP2 1AEF 35 CALLDATALOAD 1AF0 90 SWAP1 1AF1 50 POP 1AF2 61 PUSH2 0x1afa 1AF5 81 DUP2 1AF6 61 PUSH2 0x2e5d 1AF9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AF0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AF2 stack[1] = 0x1afa // @1AF5 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2e5d, returns to 0x1AFA label_1AFA: // Incoming return from call to 0x2E5D at 0x1AF9 // Inputs[3] // { // @1AFB stack[-4] // @1AFB stack[-1] // @1AFC stack[-3] // } 1AFA 5B JUMPDEST 1AFB 92 SWAP3 1AFC 91 SWAP2 1AFD 50 POP 1AFE 50 POP 1AFF 56 *JUMP // Stack delta = -3 // Outputs[1] { @1AFB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1B00: // Incoming call from 0x1EAC, returns to 0x1EAD // Inputs[2] // { // @1B03 stack[-1] // @1B04 memory[stack[-1]:stack[-1] + 0x20] // } 1B00 5B JUMPDEST 1B01 60 PUSH1 0x00 1B03 81 DUP2 1B04 51 MLOAD 1B05 90 SWAP1 1B06 50 POP 1B07 61 PUSH2 0x1b0f 1B0A 81 DUP2 1B0B 61 PUSH2 0x2e5d 1B0E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B05 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @1B07 stack[1] = 0x1b0f // @1B0A stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2e5d, returns to 0x1B0F label_1B0F: // Incoming return from call to 0x2E5D at 0x1B0E // Inputs[3] // { // @1B10 stack[-1] // @1B10 stack[-4] // @1B11 stack[-3] // } 1B0F 5B JUMPDEST 1B10 92 SWAP3 1B11 91 SWAP2 1B12 50 POP 1B13 50 POP 1B14 56 *JUMP // Stack delta = -3 // Outputs[1] { @1B10 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1B15: // Incoming call from 0x1C6B, returns to 0x1C6C // Incoming call from 0x1CFA, returns to 0x1CFB // Inputs[2] // { // @1B18 stack[-2] // @1B1B stack[-1] // } 1B15 5B JUMPDEST 1B16 60 PUSH1 0x00 1B18 82 DUP3 1B19 60 PUSH1 0x1f 1B1B 83 DUP4 1B1C 01 ADD 1B1D 12 SLT 1B1E 61 PUSH2 0x1b26 1B21 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B16 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b26, if stack[-1] + 0x1f i< stack[-2] label_1B22: // Incoming jump from 0x1B21, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1B25 memory[0x00:0x00] } 1B22 60 PUSH1 0x00 1B24 80 DUP1 1B25 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B25 revert(memory[0x00:0x00]); } // Block terminates label_1B26: // Incoming jump from 0x1B21, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1B27 stack[-2] // @1B28 msg.data[stack[-2]:stack[-2] + 0x20] // } 1B26 5B JUMPDEST 1B27 81 DUP2 1B28 35 CALLDATALOAD 1B29 61 PUSH2 0x1b39 1B2C 61 PUSH2 0x1b34 1B2F 82 DUP3 1B30 61 PUSH2 0x2bc7 1B33 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B28 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B29 stack[1] = 0x1b39 // @1B2C stack[2] = 0x1b34 // @1B2F stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2bc7, returns to 0x1B34 label_1B34: // Incoming return from call to 0x2BC7 at 0x1B33 1B34 5B JUMPDEST 1B35 61 PUSH2 0x2b4a 1B38 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2b4a label_1B39: // Incoming return from call to 0x1B34 at 0x1B33 // Inputs[5] // { // @1B3A stack[-1] // @1B3A stack[-3] // @1B3C stack[-2] // @1B41 stack[-4] // @1B47 stack[-5] // } 1B39 5B JUMPDEST 1B3A 91 SWAP2 1B3B 50 POP 1B3C 80 DUP1 1B3D 82 DUP3 1B3E 52 MSTORE 1B3F 60 PUSH1 0x20 1B41 83 DUP4 1B42 01 ADD 1B43 60 PUSH1 0x20 1B45 83 DUP4 1B46 01 ADD 1B47 85 DUP6 1B48 83 DUP4 1B49 83 DUP4 1B4A 01 ADD 1B4B 11 GT 1B4C 15 ISZERO 1B4D 61 PUSH2 0x1b55 1B50 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1B3A stack[-3] = stack[-1] // @1B3E memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1B42 stack[-1] = stack[-4] + 0x20 // @1B46 stack[0] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1b55, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) label_1B51: // Incoming jump from 0x1B50, if not !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[1] { @1B54 memory[0x00:0x00] } 1B51 60 PUSH1 0x00 1B53 80 DUP1 1B54 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B54 revert(memory[0x00:0x00]); } // Block terminates label_1B55: // Incoming jump from 0x1B50, if !(stack[-4] + 0x20 + stack[-2] > stack[-5]) // Inputs[3] // { // @1B59 stack[-3] // @1B5A stack[-1] // @1B5B stack[-2] // } 1B55 5B JUMPDEST 1B56 61 PUSH2 0x1b60 1B59 83 DUP4 1B5A 82 DUP3 1B5B 84 DUP5 1B5C 61 PUSH2 0x2d02 1B5F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B56 stack[0] = 0x1b60 // @1B59 stack[1] = stack[-3] // @1B5A stack[2] = stack[-1] // @1B5B stack[3] = stack[-2] // } // Block ends with call to 0x2d02, returns to 0x1B60 label_1B60: // Incoming return from call to 0x2D02 at 0x1B5F // Inputs[3] // { // @1B64 stack[-4] // @1B64 stack[-7] // @1B65 stack[-6] // } 1B60 5B JUMPDEST 1B61 50 POP 1B62 50 POP 1B63 50 POP 1B64 92 SWAP3 1B65 91 SWAP2 1B66 50 POP 1B67 50 POP 1B68 56 *JUMP // Stack delta = -6 // Outputs[1] { @1B64 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] label_1B69: // Incoming call from 0x1DB3, returns to 0x1DB4 // Incoming call from 0x1CC0, returns to 0x1CC1 // Incoming call from 0x1CD1, returns to 0x1CD2 // Incoming call from 0x1EFF, returns to 0x1F00 // Incoming call from 0x1D75, returns to 0x1D76 // Incoming call from 0x1ED5, returns to 0x1ED6 // Incoming call from 0x1DC4, returns to 0x1DC5 // Incoming call from 0x1A9C, returns to 0x1A9D // Inputs[2] // { // @1B6C stack[-1] // @1B6D msg.data[stack[-1]:stack[-1] + 0x20] // } 1B69 5B JUMPDEST 1B6A 60 PUSH1 0x00 1B6C 81 DUP2 1B6D 35 CALLDATALOAD 1B6E 90 SWAP1 1B6F 50 POP 1B70 61 PUSH2 0x1b78 1B73 81 DUP2 1B74 61 PUSH2 0x2e74 1B77 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B6E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1B70 stack[1] = 0x1b78 // @1B73 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2e74, returns to 0x1B78 label_1B78: // Incoming return from call to 0x2E74 at 0x1B77 // Inputs[3] // { // @1B79 stack[-1] // @1B79 stack[-4] // @1B7A stack[-3] // } 1B78 5B JUMPDEST 1B79 92 SWAP3 1B7A 91 SWAP2 1B7B 50 POP 1B7C 50 POP 1B7D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1B79 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1B7E: // Incoming call from 0x0265, returns to 0x0266 // Inputs[2] // { // @1B84 stack[-1] // @1B85 stack[-2] // } 1B7E 5B JUMPDEST 1B7F 60 PUSH1 0x00 1B81 80 DUP1 1B82 60 PUSH1 0x40 1B84 83 DUP4 1B85 85 DUP6 1B86 03 SUB 1B87 12 SLT 1B88 15 ISZERO 1B89 61 PUSH2 0x1b91 1B8C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B7F stack[0] = 0x00 // @1B81 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b91, if !(stack[-2] - stack[-1] i< 0x40) label_1B8D: // Incoming jump from 0x1B8C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B90 memory[0x00:0x00] } 1B8D 60 PUSH1 0x00 1B8F 80 DUP1 1B90 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B90 revert(memory[0x00:0x00]); } // Block terminates label_1B91: // Incoming jump from 0x1B8C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B97 stack[-4] // @1B99 stack[-3] // } 1B91 5B JUMPDEST 1B92 60 PUSH1 0x00 1B94 61 PUSH2 0x1b9f 1B97 85 DUP6 1B98 82 DUP3 1B99 86 DUP7 1B9A 01 ADD 1B9B 61 PUSH2 0x19a6 1B9E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B92 stack[0] = 0x00 // @1B94 stack[1] = 0x1b9f // @1B97 stack[2] = stack[-4] // @1B9A stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x19a6, returns to 0x1B9F label_1B9F: // Incoming return from call to 0x19A6 at 0x1B9E // Inputs[4] // { // @1BA0 stack[-1] // @1BA0 stack[-4] // @1BA8 stack[-6] // @1BAA stack[-5] // } 1B9F 5B JUMPDEST 1BA0 92 SWAP3 1BA1 50 POP 1BA2 50 POP 1BA3 60 PUSH1 0x20 1BA5 61 PUSH2 0x1bb0 1BA8 85 DUP6 1BA9 82 DUP3 1BAA 86 DUP7 1BAB 01 ADD 1BAC 61 PUSH2 0x19a6 1BAF 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1BA0 stack[-4] = stack[-1] // @1BA3 stack[-2] = 0x20 // @1BA5 stack[-1] = 0x1bb0 // @1BA8 stack[0] = stack[-6] // @1BAB stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x19a6, returns to 0x1BB0 label_1BB0: // Incoming return from call to 0x19A6 at 0x1BAF // Inputs[6] // { // @1BB1 stack[-3] // @1BB1 stack[-1] // @1BB4 stack[-6] // @1BB6 stack[-4] // @1BB6 stack[-7] // @1BB7 stack[-5] // } 1BB0 5B JUMPDEST 1BB1 91 SWAP2 1BB2 50 POP 1BB3 50 POP 1BB4 92 SWAP3 1BB5 50 POP 1BB6 92 SWAP3 1BB7 90 SWAP1 1BB8 50 POP 1BB9 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1BB4 stack[-6] = stack[-1] // @1BB6 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1BBA: // Incoming call from 0x0193, returns to 0x0194 // Inputs[2] // { // @1BC5 stack[-1] // @1BC6 stack[-2] // } 1BBA 5B JUMPDEST 1BBB 60 PUSH1 0x00 1BBD 80 DUP1 1BBE 60 PUSH1 0x00 1BC0 80 DUP1 1BC1 60 PUSH1 0x00 1BC3 60 PUSH1 0xa0 1BC5 86 DUP7 1BC6 88 DUP9 1BC7 03 SUB 1BC8 12 SLT 1BC9 15 ISZERO 1BCA 61 PUSH2 0x1bd2 1BCD 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1BBB stack[0] = 0x00 // @1BBD stack[1] = 0x00 // @1BBE stack[2] = 0x00 // @1BC0 stack[3] = 0x00 // @1BC1 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1bd2, if !(stack[-2] - stack[-1] i< 0xa0) label_1BCE: // Incoming jump from 0x1BCD, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1BD1 memory[0x00:0x00] } 1BCE 60 PUSH1 0x00 1BD0 80 DUP1 1BD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BD1 revert(memory[0x00:0x00]); } // Block terminates label_1BD2: // Incoming jump from 0x1BCD, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1BD8 stack[-7] // @1BDA stack[-6] // } 1BD2 5B JUMPDEST 1BD3 60 PUSH1 0x00 1BD5 61 PUSH2 0x1be0 1BD8 88 DUP9 1BD9 82 DUP3 1BDA 89 DUP10 1BDB 01 ADD 1BDC 61 PUSH2 0x19a6 1BDF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BD3 stack[0] = 0x00 // @1BD5 stack[1] = 0x1be0 // @1BD8 stack[2] = stack[-7] // @1BDB stack[3] = stack[-6] + 0x00 // } // Block ends with call to 0x19a6, returns to 0x1BE0 label_1BE0: // Incoming return from call to 0x19A6 at 0x1BDF // Inputs[4] // { // @1BE1 stack[-1] // @1BE1 stack[-7] // @1BE9 stack[-9] // @1BEB stack[-8] // } 1BE0 5B JUMPDEST 1BE1 95 SWAP6 1BE2 50 POP 1BE3 50 POP 1BE4 60 PUSH1 0x20 1BE6 61 PUSH2 0x1bf1 1BE9 88 DUP9 1BEA 82 DUP3 1BEB 89 DUP10 1BEC 01 ADD 1BED 61 PUSH2 0x19a6 1BF0 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1BE1 stack[-7] = stack[-1] // @1BE4 stack[-2] = 0x20 // @1BE6 stack[-1] = 0x1bf1 // @1BE9 stack[0] = stack[-9] // @1BEC stack[1] = stack[-8] + 0x20 // } // Block ends with call to 0x19a6, returns to 0x1BF1 label_1BF1: // Incoming return from call to 0x19A6 at 0x1BF0 // Inputs[4] // { // @1BF2 stack[-1] // @1BF2 stack[-6] // @1BF7 stack[-8] // @1BF9 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // } 1BF1 5B JUMPDEST 1BF2 94 SWAP5 1BF3 50 POP 1BF4 50 POP 1BF5 60 PUSH1 0x40 1BF7 86 DUP7 1BF8 01 ADD 1BF9 35 CALLDATALOAD 1BFA 67 PUSH8 0xffffffffffffffff 1C03 81 DUP2 1C04 11 GT 1C05 15 ISZERO 1C06 61 PUSH2 0x1c0e 1C09 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1BF2 stack[-6] = stack[-1] // @1BF9 stack[-2] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x1c0e, if !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > 0xffffffffffffffff) label_1C0A: // Incoming jump from 0x1C09, if not !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1C0D memory[0x00:0x00] } 1C0A 60 PUSH1 0x00 1C0C 80 DUP1 1C0D FD *REVERT // Stack delta = +0 // Outputs[1] { @1C0D revert(memory[0x00:0x00]); } // Block terminates label_1C0E: // Incoming jump from 0x1C09, if !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C12 stack[-8] // @1C13 stack[-1] // @1C14 stack[-7] // } 1C0E 5B JUMPDEST 1C0F 61 PUSH2 0x1c1a 1C12 88 DUP9 1C13 82 DUP3 1C14 89 DUP10 1C15 01 ADD 1C16 61 PUSH2 0x1a3e 1C19 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C0F stack[0] = 0x1c1a // @1C12 stack[1] = stack[-8] // @1C15 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1a3e, returns to 0x1C1A label_1C1A: // Incoming return from call to 0x1A3E at 0x1C19 // Inputs[4] // { // @1C1B stack[-1] // @1C1B stack[-5] // @1C20 stack[-8] // @1C22 msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // } 1C1A 5B JUMPDEST 1C1B 93 SWAP4 1C1C 50 POP 1C1D 50 POP 1C1E 60 PUSH1 0x60 1C20 86 DUP7 1C21 01 ADD 1C22 35 CALLDATALOAD 1C23 67 PUSH8 0xffffffffffffffff 1C2C 81 DUP2 1C2D 11 GT 1C2E 15 ISZERO 1C2F 61 PUSH2 0x1c37 1C32 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C1B stack[-5] = stack[-1] // @1C22 stack[-2] = msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1c37, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > 0xffffffffffffffff) label_1C33: // Incoming jump from 0x1C32, if not !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1C36 memory[0x00:0x00] } 1C33 60 PUSH1 0x00 1C35 80 DUP1 1C36 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C36 revert(memory[0x00:0x00]); } // Block terminates label_1C37: // Incoming jump from 0x1C32, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C3B stack[-8] // @1C3C stack[-1] // @1C3D stack[-7] // } 1C37 5B JUMPDEST 1C38 61 PUSH2 0x1c43 1C3B 88 DUP9 1C3C 82 DUP3 1C3D 89 DUP10 1C3E 01 ADD 1C3F 61 PUSH2 0x1a3e 1C42 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C38 stack[0] = 0x1c43 // @1C3B stack[1] = stack[-8] // @1C3E stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1a3e, returns to 0x1C43 label_1C43: // Incoming return from call to 0x1A3E at 0x1C42 // Inputs[4] // { // @1C44 stack[-1] // @1C44 stack[-4] // @1C49 stack[-8] // @1C4B msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } 1C43 5B JUMPDEST 1C44 92 SWAP3 1C45 50 POP 1C46 50 POP 1C47 60 PUSH1 0x80 1C49 86 DUP7 1C4A 01 ADD 1C4B 35 CALLDATALOAD 1C4C 67 PUSH8 0xffffffffffffffff 1C55 81 DUP2 1C56 11 GT 1C57 15 ISZERO 1C58 61 PUSH2 0x1c60 1C5B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C44 stack[-4] = stack[-1] // @1C4B stack[-2] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1c60, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) label_1C5C: // Incoming jump from 0x1C5B, if not !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1C5F memory[0x00:0x00] } 1C5C 60 PUSH1 0x00 1C5E 80 DUP1 1C5F FD *REVERT // Stack delta = +0 // Outputs[1] { @1C5F revert(memory[0x00:0x00]); } // Block terminates label_1C60: // Incoming jump from 0x1C5B, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C64 stack[-8] // @1C65 stack[-1] // @1C66 stack[-7] // } 1C60 5B JUMPDEST 1C61 61 PUSH2 0x1c6c 1C64 88 DUP9 1C65 82 DUP3 1C66 89 DUP10 1C67 01 ADD 1C68 61 PUSH2 0x1b15 1C6B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C61 stack[0] = 0x1c6c // @1C64 stack[1] = stack[-8] // @1C67 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1b15, returns to 0x1C6C label_1C6C: // Incoming return from call to 0x1B15 at 0x1C6B // Inputs[9] // { // @1C6D stack[-3] // @1C6D stack[-1] // @1C70 stack[-6] // @1C71 stack[-9] // @1C73 stack[-4] // @1C73 stack[-7] // @1C74 stack[-10] // @1C75 stack[-5] // @1C76 stack[-8] // } 1C6C 5B JUMPDEST 1C6D 91 SWAP2 1C6E 50 POP 1C6F 50 POP 1C70 92 SWAP3 1C71 95 SWAP6 1C72 50 POP 1C73 92 SWAP3 1C74 95 SWAP6 1C75 90 SWAP1 1C76 93 SWAP4 1C77 50 POP 1C78 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1C70 stack[-6] = stack[-1] // @1C71 stack[-9] = stack[-6] // @1C73 stack[-7] = stack[-4] // @1C74 stack[-10] = stack[-7] // @1C76 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1C79: // Incoming call from 0x0295, returns to 0x0296 // Inputs[2] // { // @1C84 stack[-1] // @1C85 stack[-2] // } 1C79 5B JUMPDEST 1C7A 60 PUSH1 0x00 1C7C 80 DUP1 1C7D 60 PUSH1 0x00 1C7F 80 DUP1 1C80 60 PUSH1 0x00 1C82 60 PUSH1 0xa0 1C84 86 DUP7 1C85 88 DUP9 1C86 03 SUB 1C87 12 SLT 1C88 15 ISZERO 1C89 61 PUSH2 0x1c91 1C8C 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1C7A stack[0] = 0x00 // @1C7C stack[1] = 0x00 // @1C7D stack[2] = 0x00 // @1C7F stack[3] = 0x00 // @1C80 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1c91, if !(stack[-2] - stack[-1] i< 0xa0) label_1C8D: // Incoming jump from 0x1C8C, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1C90 memory[0x00:0x00] } 1C8D 60 PUSH1 0x00 1C8F 80 DUP1 1C90 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C90 revert(memory[0x00:0x00]); } // Block terminates label_1C91: // Incoming jump from 0x1C8C, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1C97 stack[-7] // @1C99 stack[-6] // } 1C91 5B JUMPDEST 1C92 60 PUSH1 0x00 1C94 61 PUSH2 0x1c9f 1C97 88 DUP9 1C98 82 DUP3 1C99 89 DUP10 1C9A 01 ADD 1C9B 61 PUSH2 0x19a6 1C9E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C92 stack[0] = 0x00 // @1C94 stack[1] = 0x1c9f // @1C97 stack[2] = stack[-7] // @1C9A stack[3] = stack[-6] + 0x00 // } // Block ends with call to 0x19a6, returns to 0x1C9F label_1C9F: // Incoming return from call to 0x19A6 at 0x1C9E // Inputs[4] // { // @1CA0 stack[-7] // @1CA0 stack[-1] // @1CA8 stack[-9] // @1CAA stack[-8] // } 1C9F 5B JUMPDEST 1CA0 95 SWAP6 1CA1 50 POP 1CA2 50 POP 1CA3 60 PUSH1 0x20 1CA5 61 PUSH2 0x1cb0 1CA8 88 DUP9 1CA9 82 DUP3 1CAA 89 DUP10 1CAB 01 ADD 1CAC 61 PUSH2 0x19a6 1CAF 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1CA0 stack[-7] = stack[-1] // @1CA3 stack[-2] = 0x20 // @1CA5 stack[-1] = 0x1cb0 // @1CA8 stack[0] = stack[-9] // @1CAB stack[1] = stack[-8] + 0x20 // } // Block ends with call to 0x19a6, returns to 0x1CB0 label_1CB0: // Incoming return from call to 0x19A6 at 0x1CAF // Inputs[4] // { // @1CB1 stack[-1] // @1CB1 stack[-6] // @1CB9 stack[-9] // @1CBB stack[-8] // } 1CB0 5B JUMPDEST 1CB1 94 SWAP5 1CB2 50 POP 1CB3 50 POP 1CB4 60 PUSH1 0x40 1CB6 61 PUSH2 0x1cc1 1CB9 88 DUP9 1CBA 82 DUP3 1CBB 89 DUP10 1CBC 01 ADD 1CBD 61 PUSH2 0x1b69 1CC0 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1CB1 stack[-6] = stack[-1] // @1CB4 stack[-2] = 0x40 // @1CB6 stack[-1] = 0x1cc1 // @1CB9 stack[0] = stack[-9] // @1CBC stack[1] = stack[-8] + 0x40 // } // Block ends with call to 0x1b69, returns to 0x1CC1 label_1CC1: // Incoming return from call to 0x1B69 at 0x1CC0 // Inputs[4] // { // @1CC2 stack[-1] // @1CC2 stack[-5] // @1CCA stack[-9] // @1CCC stack[-8] // } 1CC1 5B JUMPDEST 1CC2 93 SWAP4 1CC3 50 POP 1CC4 50 POP 1CC5 60 PUSH1 0x60 1CC7 61 PUSH2 0x1cd2 1CCA 88 DUP9 1CCB 82 DUP3 1CCC 89 DUP10 1CCD 01 ADD 1CCE 61 PUSH2 0x1b69 1CD1 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1CC2 stack[-5] = stack[-1] // @1CC5 stack[-2] = 0x60 // @1CC7 stack[-1] = 0x1cd2 // @1CCA stack[0] = stack[-9] // @1CCD stack[1] = stack[-8] + 0x60 // } // Block ends with call to 0x1b69, returns to 0x1CD2 label_1CD2: // Incoming return from call to 0x1B69 at 0x1CD1 // Inputs[4] // { // @1CD3 stack[-1] // @1CD3 stack[-4] // @1CD8 stack[-8] // @1CDA msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } 1CD2 5B JUMPDEST 1CD3 92 SWAP3 1CD4 50 POP 1CD5 50 POP 1CD6 60 PUSH1 0x80 1CD8 86 DUP7 1CD9 01 ADD 1CDA 35 CALLDATALOAD 1CDB 67 PUSH8 0xffffffffffffffff 1CE4 81 DUP2 1CE5 11 GT 1CE6 15 ISZERO 1CE7 61 PUSH2 0x1cef 1CEA 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1CD3 stack[-4] = stack[-1] // @1CDA stack[-2] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1cef, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) label_1CEB: // Incoming jump from 0x1CEA, if not !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1CEE memory[0x00:0x00] } 1CEB 60 PUSH1 0x00 1CED 80 DUP1 1CEE FD *REVERT // Stack delta = +0 // Outputs[1] { @1CEE revert(memory[0x00:0x00]); } // Block terminates label_1CEF: // Incoming jump from 0x1CEA, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1CF3 stack[-8] // @1CF4 stack[-1] // @1CF5 stack[-7] // } 1CEF 5B JUMPDEST 1CF0 61 PUSH2 0x1cfb 1CF3 88 DUP9 1CF4 82 DUP3 1CF5 89 DUP10 1CF6 01 ADD 1CF7 61 PUSH2 0x1b15 1CFA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CF0 stack[0] = 0x1cfb // @1CF3 stack[1] = stack[-8] // @1CF6 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1b15, returns to 0x1CFB label_1CFB: // Incoming return from call to 0x1B15 at 0x1CFA // Inputs[9] // { // @1CFC stack[-1] // @1CFC stack[-3] // @1CFF stack[-6] // @1D00 stack[-9] // @1D02 stack[-7] // @1D02 stack[-4] // @1D03 stack[-10] // @1D04 stack[-5] // @1D05 stack[-8] // } 1CFB 5B JUMPDEST 1CFC 91 SWAP2 1CFD 50 POP 1CFE 50 POP 1CFF 92 SWAP3 1D00 95 SWAP6 1D01 50 POP 1D02 92 SWAP3 1D03 95 SWAP6 1D04 90 SWAP1 1D05 93 SWAP4 1D06 50 POP 1D07 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1CFF stack[-6] = stack[-1] // @1D00 stack[-9] = stack[-6] // @1D02 stack[-7] = stack[-4] // @1D03 stack[-10] = stack[-7] // @1D05 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1D08: // Incoming call from 0x0249, returns to 0x024A // Inputs[2] // { // @1D0E stack[-1] // @1D0F stack[-2] // } 1D08 5B JUMPDEST 1D09 60 PUSH1 0x00 1D0B 80 DUP1 1D0C 60 PUSH1 0x40 1D0E 83 DUP4 1D0F 85 DUP6 1D10 03 SUB 1D11 12 SLT 1D12 15 ISZERO 1D13 61 PUSH2 0x1d1b 1D16 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D09 stack[0] = 0x00 // @1D0B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d1b, if !(stack[-2] - stack[-1] i< 0x40) label_1D17: // Incoming jump from 0x1D16, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D1A memory[0x00:0x00] } 1D17 60 PUSH1 0x00 1D19 80 DUP1 1D1A FD *REVERT // Stack delta = +0 // Outputs[1] { @1D1A revert(memory[0x00:0x00]); } // Block terminates label_1D1B: // Incoming jump from 0x1D16, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D21 stack[-4] // @1D23 stack[-3] // } 1D1B 5B JUMPDEST 1D1C 60 PUSH1 0x00 1D1E 61 PUSH2 0x1d29 1D21 85 DUP6 1D22 82 DUP3 1D23 86 DUP7 1D24 01 ADD 1D25 61 PUSH2 0x19a6 1D28 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D1C stack[0] = 0x00 // @1D1E stack[1] = 0x1d29 // @1D21 stack[2] = stack[-4] // @1D24 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x19a6, returns to 0x1D29 label_1D29: // Incoming return from call to 0x19A6 at 0x1D28 // Inputs[4] // { // @1D2A stack[-1] // @1D2A stack[-4] // @1D32 stack[-6] // @1D34 stack[-5] // } 1D29 5B JUMPDEST 1D2A 92 SWAP3 1D2B 50 POP 1D2C 50 POP 1D2D 60 PUSH1 0x20 1D2F 61 PUSH2 0x1d3a 1D32 85 DUP6 1D33 82 DUP3 1D34 86 DUP7 1D35 01 ADD 1D36 61 PUSH2 0x1ac1 1D39 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1D2A stack[-4] = stack[-1] // @1D2D stack[-2] = 0x20 // @1D2F stack[-1] = 0x1d3a // @1D32 stack[0] = stack[-6] // @1D35 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1ac1, returns to 0x1D3A label_1D3A: // Incoming return from call to 0x1AC1 at 0x1D39 // Inputs[6] // { // @1D3B stack[-1] // @1D3B stack[-3] // @1D3E stack[-6] // @1D40 stack[-4] // @1D40 stack[-7] // @1D41 stack[-5] // } 1D3A 5B JUMPDEST 1D3B 91 SWAP2 1D3C 50 POP 1D3D 50 POP 1D3E 92 SWAP3 1D3F 50 POP 1D40 92 SWAP3 1D41 90 SWAP1 1D42 50 POP 1D43 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1D3E stack[-6] = stack[-1] // @1D40 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1D44: // Incoming call from 0x00E7, returns to 0x00E8 // Inputs[2] // { // @1D4A stack[-1] // @1D4B stack[-2] // } 1D44 5B JUMPDEST 1D45 60 PUSH1 0x00 1D47 80 DUP1 1D48 60 PUSH1 0x40 1D4A 83 DUP4 1D4B 85 DUP6 1D4C 03 SUB 1D4D 12 SLT 1D4E 15 ISZERO 1D4F 61 PUSH2 0x1d57 1D52 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D45 stack[0] = 0x00 // @1D47 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d57, if !(stack[-2] - stack[-1] i< 0x40) label_1D53: // Incoming jump from 0x1D52, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D56 memory[0x00:0x00] } 1D53 60 PUSH1 0x00 1D55 80 DUP1 1D56 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D56 revert(memory[0x00:0x00]); } // Block terminates label_1D57: // Incoming jump from 0x1D52, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D5D stack[-4] // @1D5F stack[-3] // } 1D57 5B JUMPDEST 1D58 60 PUSH1 0x00 1D5A 61 PUSH2 0x1d65 1D5D 85 DUP6 1D5E 82 DUP3 1D5F 86 DUP7 1D60 01 ADD 1D61 61 PUSH2 0x19a6 1D64 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D58 stack[0] = 0x00 // @1D5A stack[1] = 0x1d65 // @1D5D stack[2] = stack[-4] // @1D60 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x19a6, returns to 0x1D65 label_1D65: // Incoming return from call to 0x19A6 at 0x1D64 // Inputs[4] // { // @1D66 stack[-4] // @1D66 stack[-1] // @1D6E stack[-6] // @1D70 stack[-5] // } 1D65 5B JUMPDEST 1D66 92 SWAP3 1D67 50 POP 1D68 50 POP 1D69 60 PUSH1 0x20 1D6B 61 PUSH2 0x1d76 1D6E 85 DUP6 1D6F 82 DUP3 1D70 86 DUP7 1D71 01 ADD 1D72 61 PUSH2 0x1b69 1D75 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1D66 stack[-4] = stack[-1] // @1D69 stack[-2] = 0x20 // @1D6B stack[-1] = 0x1d76 // @1D6E stack[0] = stack[-6] // @1D71 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1b69, returns to 0x1D76 label_1D76: // Incoming return from call to 0x1B69 at 0x1D75 // Inputs[6] // { // @1D77 stack[-3] // @1D77 stack[-1] // @1D7A stack[-6] // @1D7C stack[-7] // @1D7C stack[-4] // @1D7D stack[-5] // } 1D76 5B JUMPDEST 1D77 91 SWAP2 1D78 50 POP 1D79 50 POP 1D7A 92 SWAP3 1D7B 50 POP 1D7C 92 SWAP3 1D7D 90 SWAP1 1D7E 50 POP 1D7F 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1D7A stack[-6] = stack[-1] // @1D7C stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1D80: // Incoming call from 0x0177, returns to 0x0178 // Inputs[2] // { // @1D88 stack[-1] // @1D89 stack[-2] // } 1D80 5B JUMPDEST 1D81 60 PUSH1 0x00 1D83 80 DUP1 1D84 60 PUSH1 0x00 1D86 60 PUSH1 0x60 1D88 84 DUP5 1D89 86 DUP7 1D8A 03 SUB 1D8B 12 SLT 1D8C 15 ISZERO 1D8D 61 PUSH2 0x1d95 1D90 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D81 stack[0] = 0x00 // @1D83 stack[1] = 0x00 // @1D84 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1d95, if !(stack[-2] - stack[-1] i< 0x60) label_1D91: // Incoming jump from 0x1D90, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1D94 memory[0x00:0x00] } 1D91 60 PUSH1 0x00 1D93 80 DUP1 1D94 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D94 revert(memory[0x00:0x00]); } // Block terminates label_1D95: // Incoming jump from 0x1D90, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1D9B stack[-5] // @1D9D stack[-4] // } 1D95 5B JUMPDEST 1D96 60 PUSH1 0x00 1D98 61 PUSH2 0x1da3 1D9B 86 DUP7 1D9C 82 DUP3 1D9D 87 DUP8 1D9E 01 ADD 1D9F 61 PUSH2 0x19a6 1DA2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D96 stack[0] = 0x00 // @1D98 stack[1] = 0x1da3 // @1D9B stack[2] = stack[-5] // @1D9E stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x19a6, returns to 0x1DA3 label_1DA3: // Incoming return from call to 0x19A6 at 0x1DA2 // Inputs[4] // { // @1DA4 stack[-1] // @1DA4 stack[-5] // @1DAC stack[-7] // @1DAE stack[-6] // } 1DA3 5B JUMPDEST 1DA4 93 SWAP4 1DA5 50 POP 1DA6 50 POP 1DA7 60 PUSH1 0x20 1DA9 61 PUSH2 0x1db4 1DAC 86 DUP7 1DAD 82 DUP3 1DAE 87 DUP8 1DAF 01 ADD 1DB0 61 PUSH2 0x1b69 1DB3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1DA4 stack[-5] = stack[-1] // @1DA7 stack[-2] = 0x20 // @1DA9 stack[-1] = 0x1db4 // @1DAC stack[0] = stack[-7] // @1DAF stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x1b69, returns to 0x1DB4 label_1DB4: // Incoming return from call to 0x1B69 at 0x1DB3 // Inputs[4] // { // @1DB5 stack[-1] // @1DB5 stack[-4] // @1DBD stack[-7] // @1DBF stack[-6] // } 1DB4 5B JUMPDEST 1DB5 92 SWAP3 1DB6 50 POP 1DB7 50 POP 1DB8 60 PUSH1 0x40 1DBA 61 PUSH2 0x1dc5 1DBD 86 DUP7 1DBE 82 DUP3 1DBF 87 DUP8 1DC0 01 ADD 1DC1 61 PUSH2 0x1b69 1DC4 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1DB5 stack[-4] = stack[-1] // @1DB8 stack[-2] = 0x40 // @1DBA stack[-1] = 0x1dc5 // @1DBD stack[0] = stack[-7] // @1DC0 stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x1b69, returns to 0x1DC5 label_1DC5: // Incoming return from call to 0x1B69 at 0x1DC4 // Inputs[7] // { // @1DC6 stack[-3] // @1DC6 stack[-1] // @1DC9 stack[-6] // @1DCB stack[-4] // @1DCB stack[-7] // @1DCD stack[-8] // @1DCD stack[-5] // } 1DC5 5B JUMPDEST 1DC6 91 SWAP2 1DC7 50 POP 1DC8 50 POP 1DC9 92 SWAP3 1DCA 50 POP 1DCB 92 SWAP3 1DCC 50 POP 1DCD 92 SWAP3 1DCE 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1DC9 stack[-6] = stack[-1] // @1DCB stack[-7] = stack[-4] // @1DCD stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_1DCF: // Incoming call from 0x01CD, returns to 0x01CE // Inputs[2] // { // @1DD5 stack[-1] // @1DD6 stack[-2] // } 1DCF 5B JUMPDEST 1DD0 60 PUSH1 0x00 1DD2 80 DUP1 1DD3 60 PUSH1 0x40 1DD5 83 DUP4 1DD6 85 DUP6 1DD7 03 SUB 1DD8 12 SLT 1DD9 15 ISZERO 1DDA 61 PUSH2 0x1de2 1DDD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DD0 stack[0] = 0x00 // @1DD2 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1de2, if !(stack[-2] - stack[-1] i< 0x40) label_1DDE: // Incoming jump from 0x1DDD, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DE1 memory[0x00:0x00] } 1DDE 60 PUSH1 0x00 1DE0 80 DUP1 1DE1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DE1 revert(memory[0x00:0x00]); } // Block terminates label_1DE2: // Incoming jump from 0x1DDD, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DE5 stack[-3] // @1DE7 msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] // } 1DE2 5B JUMPDEST 1DE3 60 PUSH1 0x00 1DE5 83 DUP4 1DE6 01 ADD 1DE7 35 CALLDATALOAD 1DE8 67 PUSH8 0xffffffffffffffff 1DF1 81 DUP2 1DF2 11 GT 1DF3 15 ISZERO 1DF4 61 PUSH2 0x1dfc 1DF7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DE7 stack[0] = msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] } // Block ends with conditional jump to 0x1dfc, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) label_1DF8: // Incoming jump from 0x1DF7, if not !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1DFB memory[0x00:0x00] } 1DF8 60 PUSH1 0x00 1DFA 80 DUP1 1DFB FD *REVERT // Stack delta = +0 // Outputs[1] { @1DFB revert(memory[0x00:0x00]); } // Block terminates label_1DFC: // Incoming jump from 0x1DF7, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E00 stack[-5] // @1E01 stack[-1] // @1E02 stack[-4] // } 1DFC 5B JUMPDEST 1DFD 61 PUSH2 0x1e08 1E00 85 DUP6 1E01 82 DUP3 1E02 86 DUP7 1E03 01 ADD 1E04 61 PUSH2 0x19bb 1E07 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DFD stack[0] = 0x1e08 // @1E00 stack[1] = stack[-5] // @1E03 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x19bb, returns to 0x1E08 label_1E08: // Incoming return from call to 0x19BB at 0x1E07 // Inputs[4] // { // @1E09 stack[-4] // @1E09 stack[-1] // @1E0E stack[-5] // @1E10 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 1E08 5B JUMPDEST 1E09 92 SWAP3 1E0A 50 POP 1E0B 50 POP 1E0C 60 PUSH1 0x20 1E0E 83 DUP4 1E0F 01 ADD 1E10 35 CALLDATALOAD 1E11 67 PUSH8 0xffffffffffffffff 1E1A 81 DUP2 1E1B 11 GT 1E1C 15 ISZERO 1E1D 61 PUSH2 0x1e25 1E20 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1E09 stack[-4] = stack[-1] // @1E10 stack[-2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1e25, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_1E21: // Incoming jump from 0x1E20, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1E24 memory[0x00:0x00] } 1E21 60 PUSH1 0x00 1E23 80 DUP1 1E24 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E24 revert(memory[0x00:0x00]); } // Block terminates label_1E25: // Incoming jump from 0x1E20, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E29 stack[-5] // @1E2A stack[-1] // @1E2B stack[-4] // } 1E25 5B JUMPDEST 1E26 61 PUSH2 0x1e31 1E29 85 DUP6 1E2A 82 DUP3 1E2B 86 DUP7 1E2C 01 ADD 1E2D 61 PUSH2 0x1a3e 1E30 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E26 stack[0] = 0x1e31 // @1E29 stack[1] = stack[-5] // @1E2C stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1a3e, returns to 0x1E31 label_1E31: // Incoming return from call to 0x1A3E at 0x1E30 // Inputs[6] // { // @1E32 stack[-1] // @1E32 stack[-3] // @1E35 stack[-6] // @1E37 stack[-7] // @1E37 stack[-4] // @1E38 stack[-5] // } 1E31 5B JUMPDEST 1E32 91 SWAP2 1E33 50 POP 1E34 50 POP 1E35 92 SWAP3 1E36 50 POP 1E37 92 SWAP3 1E38 90 SWAP1 1E39 50 POP 1E3A 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1E35 stack[-6] = stack[-1] // @1E37 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1E3B: // Incoming call from 0x01FD, returns to 0x01FE // Inputs[2] // { // @1E40 stack[-1] // @1E41 stack[-2] // } 1E3B 5B JUMPDEST 1E3C 60 PUSH1 0x00 1E3E 60 PUSH1 0x20 1E40 82 DUP3 1E41 84 DUP5 1E42 03 SUB 1E43 12 SLT 1E44 15 ISZERO 1E45 61 PUSH2 0x1e4d 1E48 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E3C stack[0] = 0x00 } // Block ends with conditional jump to 0x1e4d, if !(stack[-2] - stack[-1] i< 0x20) label_1E49: // Incoming jump from 0x1E48, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E4C memory[0x00:0x00] } 1E49 60 PUSH1 0x00 1E4B 80 DUP1 1E4C FD *REVERT // Stack delta = +0 // Outputs[1] { @1E4C revert(memory[0x00:0x00]); } // Block terminates label_1E4D: // Incoming jump from 0x1E48, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E53 stack[-3] // @1E55 stack[-2] // } 1E4D 5B JUMPDEST 1E4E 60 PUSH1 0x00 1E50 61 PUSH2 0x1e5b 1E53 84 DUP5 1E54 82 DUP3 1E55 85 DUP6 1E56 01 ADD 1E57 61 PUSH2 0x1ad6 1E5A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E4E stack[0] = 0x00 // @1E50 stack[1] = 0x1e5b // @1E53 stack[2] = stack[-3] // @1E56 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1ad6, returns to 0x1E5B label_1E5B: // Incoming return from call to 0x1AD6 at 0x1E5A // Inputs[4] // { // @1E5C stack[-1] // @1E5C stack[-3] // @1E5F stack[-6] // @1E60 stack[-5] // } 1E5B 5B JUMPDEST 1E5C 91 SWAP2 1E5D 50 POP 1E5E 50 POP 1E5F 92 SWAP3 1E60 91 SWAP2 1E61 50 POP 1E62 50 POP 1E63 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E5F stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1E64: // Incoming call from 0x0117, returns to 0x0118 // Inputs[2] // { // @1E69 stack[-1] // @1E6A stack[-2] // } 1E64 5B JUMPDEST 1E65 60 PUSH1 0x00 1E67 60 PUSH1 0x20 1E69 82 DUP3 1E6A 84 DUP5 1E6B 03 SUB 1E6C 12 SLT 1E6D 15 ISZERO 1E6E 61 PUSH2 0x1e76 1E71 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E65 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e76, if !(stack[-2] - stack[-1] i< 0x20) label_1E72: // Incoming jump from 0x1E71, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E75 memory[0x00:0x00] } 1E72 60 PUSH1 0x00 1E74 80 DUP1 1E75 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E75 revert(memory[0x00:0x00]); } // Block terminates label_1E76: // Incoming jump from 0x1E71, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E7C stack[-3] // @1E7E stack[-2] // } 1E76 5B JUMPDEST 1E77 60 PUSH1 0x00 1E79 61 PUSH2 0x1e84 1E7C 84 DUP5 1E7D 82 DUP3 1E7E 85 DUP6 1E7F 01 ADD 1E80 61 PUSH2 0x1aeb 1E83 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E77 stack[0] = 0x00 // @1E79 stack[1] = 0x1e84 // @1E7C stack[2] = stack[-3] // @1E7F stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1aeb, returns to 0x1E84 label_1E84: // Incoming return from call to 0x1AEB at 0x1E83 // Inputs[4] // { // @1E85 stack[-1] // @1E85 stack[-3] // @1E88 stack[-6] // @1E89 stack[-5] // } 1E84 5B JUMPDEST 1E85 91 SWAP2 1E86 50 POP 1E87 50 POP 1E88 92 SWAP3 1E89 91 SWAP2 1E8A 50 POP 1E8B 50 POP 1E8C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E88 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1E8D: // Incoming call from 0x186F, returns to 0x1870 // Incoming call from 0x162F, returns to 0x1630 // Inputs[2] // { // @1E92 stack[-1] // @1E93 stack[-2] // } 1E8D 5B JUMPDEST 1E8E 60 PUSH1 0x00 1E90 60 PUSH1 0x20 1E92 82 DUP3 1E93 84 DUP5 1E94 03 SUB 1E95 12 SLT 1E96 15 ISZERO 1E97 61 PUSH2 0x1e9f 1E9A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E8E stack[0] = 0x00 } // Block ends with conditional jump to 0x1e9f, if !(stack[-2] - stack[-1] i< 0x20) label_1E9B: // Incoming jump from 0x1E9A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E9E memory[0x00:0x00] } 1E9B 60 PUSH1 0x00 1E9D 80 DUP1 1E9E FD *REVERT // Stack delta = +0 // Outputs[1] { @1E9E revert(memory[0x00:0x00]); } // Block terminates label_1E9F: // Incoming jump from 0x1E9A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1EA5 stack[-3] // @1EA7 stack[-2] // } 1E9F 5B JUMPDEST 1EA0 60 PUSH1 0x00 1EA2 61 PUSH2 0x1ead 1EA5 84 DUP5 1EA6 82 DUP3 1EA7 85 DUP6 1EA8 01 ADD 1EA9 61 PUSH2 0x1b00 1EAC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EA0 stack[0] = 0x00 // @1EA2 stack[1] = 0x1ead // @1EA5 stack[2] = stack[-3] // @1EA8 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1b00, returns to 0x1EAD label_1EAD: // Incoming return from call to 0x1B00 at 0x1EAC // Inputs[4] // { // @1EAE stack[-3] // @1EAE stack[-1] // @1EB1 stack[-6] // @1EB2 stack[-5] // } 1EAD 5B JUMPDEST 1EAE 91 SWAP2 1EAF 50 POP 1EB0 50 POP 1EB1 92 SWAP3 1EB2 91 SWAP2 1EB3 50 POP 1EB4 50 POP 1EB5 56 *JUMP // Stack delta = -5 // Outputs[1] { @1EB1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1EB6: // Incoming call from 0x02B1, returns to 0x02B2 // Incoming call from 0x0147, returns to 0x0148 // Inputs[2] // { // @1EBB stack[-1] // @1EBC stack[-2] // } 1EB6 5B JUMPDEST 1EB7 60 PUSH1 0x00 1EB9 60 PUSH1 0x20 1EBB 82 DUP3 1EBC 84 DUP5 1EBD 03 SUB 1EBE 12 SLT 1EBF 15 ISZERO 1EC0 61 PUSH2 0x1ec8 1EC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EB7 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ec8, if !(stack[-2] - stack[-1] i< 0x20) label_1EC4: // Incoming jump from 0x1EC3, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1EC7 memory[0x00:0x00] } 1EC4 60 PUSH1 0x00 1EC6 80 DUP1 1EC7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EC7 revert(memory[0x00:0x00]); } // Block terminates label_1EC8: // Incoming jump from 0x1EC3, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1ECE stack[-3] // @1ED0 stack[-2] // } 1EC8 5B JUMPDEST 1EC9 60 PUSH1 0x00 1ECB 61 PUSH2 0x1ed6 1ECE 84 DUP5 1ECF 82 DUP3 1ED0 85 DUP6 1ED1 01 ADD 1ED2 61 PUSH2 0x1b69 1ED5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EC9 stack[0] = 0x00 // @1ECB stack[1] = 0x1ed6 // @1ECE stack[2] = stack[-3] // @1ED1 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1b69, returns to 0x1ED6 label_1ED6: // Incoming return from call to 0x1B69 at 0x1ED5 // Inputs[4] // { // @1ED7 stack[-1] // @1ED7 stack[-3] // @1EDA stack[-6] // @1EDB stack[-5] // } 1ED6 5B JUMPDEST 1ED7 91 SWAP2 1ED8 50 POP 1ED9 50 POP 1EDA 92 SWAP3 1EDB 91 SWAP2 1EDC 50 POP 1EDD 50 POP 1EDE 56 *JUMP // Stack delta = -5 // Outputs[1] { @1EDA stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1EDF: // Incoming call from 0x022D, returns to 0x022E // Inputs[2] // { // @1EE5 stack[-1] // @1EE6 stack[-2] // } 1EDF 5B JUMPDEST 1EE0 60 PUSH1 0x00 1EE2 80 DUP1 1EE3 60 PUSH1 0x40 1EE5 83 DUP4 1EE6 85 DUP6 1EE7 03 SUB 1EE8 12 SLT 1EE9 15 ISZERO 1EEA 61 PUSH2 0x1ef2 1EED 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EE0 stack[0] = 0x00 // @1EE2 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ef2, if !(stack[-2] - stack[-1] i< 0x40) label_1EEE: // Incoming jump from 0x1EED, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1EF1 memory[0x00:0x00] } 1EEE 60 PUSH1 0x00 1EF0 80 DUP1 1EF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF1 revert(memory[0x00:0x00]); } // Block terminates label_1EF2: // Incoming jump from 0x1EED, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1EF8 stack[-4] // @1EFA stack[-3] // } 1EF2 5B JUMPDEST 1EF3 60 PUSH1 0x00 1EF5 61 PUSH2 0x1f00 1EF8 85 DUP6 1EF9 82 DUP3 1EFA 86 DUP7 1EFB 01 ADD 1EFC 61 PUSH2 0x1b69 1EFF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EF3 stack[0] = 0x00 // @1EF5 stack[1] = 0x1f00 // @1EF8 stack[2] = stack[-4] // @1EFB stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1b69, returns to 0x1F00 label_1F00: // Incoming return from call to 0x1B69 at 0x1EFF // Inputs[4] // { // @1F01 stack[-1] // @1F01 stack[-4] // @1F09 stack[-6] // @1F0B stack[-5] // } 1F00 5B JUMPDEST 1F01 92 SWAP3 1F02 50 POP 1F03 50 POP 1F04 60 PUSH1 0x20 1F06 61 PUSH2 0x1f11 1F09 85 DUP6 1F0A 82 DUP3 1F0B 86 DUP7 1F0C 01 ADD 1F0D 61 PUSH2 0x1ad6 1F10 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1F01 stack[-4] = stack[-1] // @1F04 stack[-2] = 0x20 // @1F06 stack[-1] = 0x1f11 // @1F09 stack[0] = stack[-6] // @1F0C stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1ad6, returns to 0x1F11 label_1F11: // Incoming return from call to 0x1AD6 at 0x1F10 // Inputs[6] // { // @1F12 stack[-3] // @1F12 stack[-1] // @1F15 stack[-6] // @1F17 stack[-4] // @1F17 stack[-7] // @1F18 stack[-5] // } 1F11 5B JUMPDEST 1F12 91 SWAP2 1F13 50 POP 1F14 50 POP 1F15 92 SWAP3 1F16 50 POP 1F17 92 SWAP3 1F18 90 SWAP1 1F19 50 POP 1F1A 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1F15 stack[-6] = stack[-1] // @1F17 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1F1B: // Incoming call from 0x1F79, returns to 0x1F7A // Inputs[2] // { // @1F21 stack[-2] // @1F22 stack[-1] // } 1F1B 5B JUMPDEST 1F1C 60 PUSH1 0x00 1F1E 61 PUSH2 0x1f27 1F21 83 DUP4 1F22 83 DUP4 1F23 61 PUSH2 0x2738 1F26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F1C stack[0] = 0x00 // @1F1E stack[1] = 0x1f27 // @1F21 stack[2] = stack[-2] // @1F22 stack[3] = stack[-1] // } // Block ends with call to 0x2738, returns to 0x1F27 label_1F27: // Incoming return from call to 0x2738 at 0x1F26 // Inputs[3] // { // @1F2A stack[-3] // @1F2C stack[-1] // @1F2E stack[-4] // } 1F27 5B JUMPDEST 1F28 60 PUSH1 0x20 1F2A 83 DUP4 1F2B 01 ADD 1F2C 90 SWAP1 1F2D 50 POP 1F2E 92 SWAP3 1F2F 91 SWAP2 1F30 50 POP 1F31 50 POP 1F32 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F2E stack[-4] = stack[-3] + 0x20 } // Block ends with unconditional jump to stack[-4] label_1F33: // Incoming call from 0x27A7, returns to 0x27A8 // Incoming call from 0x27B4, returns to 0x27B5 // Incoming call from 0x280F, returns to 0x2810 // Incoming call from 0x281C, returns to 0x281D // Incoming call from 0x278C, returns to 0x278D // Inputs[1] { @1F37 stack[-1] } 1F33 5B JUMPDEST 1F34 61 PUSH2 0x1f3c 1F37 81 DUP2 1F38 61 PUSH2 0x2c84 1F3B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F34 stack[0] = 0x1f3c // @1F37 stack[1] = stack[-1] // } // Block ends with call to 0x2c84, returns to 0x1F3C label_1F3C: // Incoming return from call to 0x2C84 at 0x1F3B // Inputs[3] // { // @1F3D stack[-3] // @1F3E stack[-1] // @1F41 stack[-4] // } 1F3C 5B JUMPDEST 1F3D 82 DUP3 1F3E 52 MSTORE 1F3F 50 POP 1F40 50 POP 1F41 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F3E memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1F42: // Incoming call from 0x27DA, returns to 0x27DB // Incoming call from 0x286E, returns to 0x286F // Incoming call from 0x2890, returns to 0x2891 // Incoming call from 0x28A4, returns to 0x28A5 // Incoming call from 0x27C6, returns to 0x27C7 // Inputs[1] { @1F48 stack[-1] } 1F42 5B JUMPDEST 1F43 60 PUSH1 0x00 1F45 61 PUSH2 0x1f4d 1F48 82 DUP3 1F49 61 PUSH2 0x2c18 1F4C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F43 stack[0] = 0x00 // @1F45 stack[1] = 0x1f4d // @1F48 stack[2] = stack[-1] // } // Block ends with call to 0x2c18, returns to 0x1F4D label_1F4D: // Incoming return from call to 0x2C18 at 0x1F4C // Inputs[2] // { // @1F51 stack[-1] // @1F52 stack[-4] // } 1F4D 5B JUMPDEST 1F4E 61 PUSH2 0x1f57 1F51 81 DUP2 1F52 85 DUP6 1F53 61 PUSH2 0x2c46 1F56 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F4E stack[0] = 0x1f57 // @1F51 stack[1] = stack[-1] // @1F52 stack[2] = stack[-4] // } // Block ends with call to 0x2c46, returns to 0x1F57 label_1F57: // Incoming return from call to 0x2C46 at 0x1F56 // Inputs[3] // { // @1F58 stack[-5] // @1F58 stack[-1] // @1F5D stack[-4] // } 1F57 5B JUMPDEST 1F58 93 SWAP4 1F59 50 POP 1F5A 61 PUSH2 0x1f62 1F5D 83 DUP4 1F5E 61 PUSH2 0x2bf3 1F61 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F58 stack[-5] = stack[-1] // @1F5A stack[-1] = 0x1f62 // @1F5D stack[0] = stack[-4] // } // Block ends with call to 0x2bf3, returns to 0x1F62 label_1F62: // Incoming return from call to 0x2BF3 at 0x1F61 // Inputs[2] // { // @1F63 stack[-1] // @1F67 stack[-2] // } 1F62 5B JUMPDEST 1F63 80 DUP1 1F64 60 PUSH1 0x00 1F66 5B JUMPDEST 1F67 83 DUP4 1F68 81 DUP2 1F69 10 LT 1F6A 15 ISZERO 1F6B 61 PUSH2 0x1f93 1F6E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F63 stack[0] = stack[-1] // @1F64 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f93, if !(0x00 < stack[-2]) label_1F6F: // Incoming jump from 0x1F6E, if not !(0x00 < stack[-2]) // Incoming jump from 0x1F6E, if not !(stack[-1] < stack[-4]) // Inputs[3] // { // @1F6F stack[-2] // @1F70 memory[stack[-2]:stack[-2] + 0x20] // @1F74 stack[-7] // } 1F6F 81 DUP2 1F70 51 MLOAD 1F71 61 PUSH2 0x1f7a 1F74 88 DUP9 1F75 82 DUP3 1F76 61 PUSH2 0x1f1b 1F79 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F70 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1F71 stack[1] = 0x1f7a // @1F74 stack[2] = stack[-7] // @1F75 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f1b, returns to 0x1F7A label_1F7A: // Incoming return from call to 0x1F1B at 0x1F79 // Inputs[3] // { // @1F7B stack[-9] // @1F7B stack[-1] // @1F80 stack[-4] // } 1F7A 5B JUMPDEST 1F7B 97 SWAP8 1F7C 50 POP 1F7D 61 PUSH2 0x1f85 1F80 83 DUP4 1F81 61 PUSH2 0x2c39 1F84 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F7B stack[-9] = stack[-1] // @1F7D stack[-1] = 0x1f85 // @1F80 stack[0] = stack[-4] // } // Block ends with call to 0x2c39, returns to 0x1F85 label_1F85: // Incoming return from call to 0x2C39 at 0x1F84 // Inputs[3] // { // @1F86 stack[-1] // @1F86 stack[-4] // @1F8B stack[-3] // } 1F85 5B JUMPDEST 1F86 92 SWAP3 1F87 50 POP 1F88 50 POP 1F89 60 PUSH1 0x01 1F8B 81 DUP2 1F8C 01 ADD 1F8D 90 SWAP1 1F8E 50 POP 1F8F 61 PUSH2 0x1f66 1F92 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F86 stack[-4] = stack[-1] // @1F8D stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x1f66 label_1F93: // Incoming jump from 0x1F6E, if !(0x00 < stack[-2]) // Incoming jump from 0x1F6E, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1F95 stack[-7] // @1F96 stack[-5] // @1F9B stack[-8] // } 1F93 5B JUMPDEST 1F94 50 POP 1F95 85 DUP6 1F96 93 SWAP4 1F97 50 POP 1F98 50 POP 1F99 50 POP 1F9A 50 POP 1F9B 92 SWAP3 1F9C 91 SWAP2 1F9D 50 POP 1F9E 50 POP 1F9F 56 *JUMP // Stack delta = -7 // Outputs[1] { @1F9B stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1FA0: // Incoming call from 0x28C2, returns to 0x28C3 // Inputs[1] { @1FA4 stack[-1] } 1FA0 5B JUMPDEST 1FA1 61 PUSH2 0x1fa9 1FA4 81 DUP2 1FA5 61 PUSH2 0x2c96 1FA8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FA1 stack[0] = 0x1fa9 // @1FA4 stack[1] = stack[-1] // } // Block ends with call to 0x2c96, returns to 0x1FA9 label_1FA9: // Incoming return from call to 0x2C96 at 0x1FA8 // Inputs[3] // { // @1FAA stack[-3] // @1FAB stack[-1] // @1FAE stack[-4] // } 1FA9 5B JUMPDEST 1FAA 82 DUP3 1FAB 52 MSTORE 1FAC 50 POP 1FAD 50 POP 1FAE 56 *JUMP // Stack delta = -4 // Outputs[1] { @1FAB memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1FAF: // Incoming call from 0x28DD, returns to 0x28DE // Inputs[1] { @1FB3 stack[-1] } 1FAF 5B JUMPDEST 1FB0 61 PUSH2 0x1fb8 1FB3 81 DUP2 1FB4 61 PUSH2 0x2ca2 1FB7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FB0 stack[0] = 0x1fb8 // @1FB3 stack[1] = stack[-1] // } // Block ends with call to 0x2ca2, returns to 0x1FB8 label_1FB8: // Incoming return from call to 0x2CA2 at 0x1FB7 // Inputs[3] // { // @1FB9 stack[-3] // @1FBA stack[-1] // @1FBD stack[-4] // } 1FB8 5B JUMPDEST 1FB9 82 DUP3 1FBA 52 MSTORE 1FBB 50 POP 1FBC 50 POP 1FBD 56 *JUMP // Stack delta = -4 // Outputs[1] { @1FBA memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1FBE: // Incoming call from 0x27EE, returns to 0x27EF // Incoming call from 0x2848, returns to 0x2849 // Inputs[1] { @1FC4 stack[-1] } 1FBE 5B JUMPDEST 1FBF 60 PUSH1 0x00 1FC1 61 PUSH2 0x1fc9 1FC4 82 DUP3 1FC5 61 PUSH2 0x2c23 1FC8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FBF stack[0] = 0x00 // @1FC1 stack[1] = 0x1fc9 // @1FC4 stack[2] = stack[-1] // } // Block ends with call to 0x2c23, returns to 0x1FC9 label_1FC9: // Incoming return from call to 0x2C23 at 0x1FC8 // Inputs[2] // { // @1FCD stack[-1] // @1FCE stack[-4] // } 1FC9 5B JUMPDEST 1FCA 61 PUSH2 0x1fd3 1FCD 81 DUP2 1FCE 85 DUP6 1FCF 61 PUSH2 0x2c57 1FD2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FCA stack[0] = 0x1fd3 // @1FCD stack[1] = stack[-1] // @1FCE stack[2] = stack[-4] // } // Block ends with call to 0x2c57, returns to 0x1FD3 label_1FD3: // Incoming return from call to 0x2C57 at 0x1FD2 // Inputs[4] // { // @1FD4 stack[-1] // @1FD4 stack[-5] // @1FD9 stack[-2] // @1FDD stack[-4] // } 1FD3 5B JUMPDEST 1FD4 93 SWAP4 1FD5 50 POP 1FD6 61 PUSH2 0x1fe3 1FD9 81 DUP2 1FDA 85 DUP6 1FDB 60 PUSH1 0x20 1FDD 86 DUP7 1FDE 01 ADD 1FDF 61 PUSH2 0x2d11 1FE2 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1FD4 stack[-5] = stack[-1] // @1FD6 stack[-1] = 0x1fe3 // @1FD9 stack[0] = stack[-2] // @1FDA stack[1] = stack[-1] // @1FDE stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x2d11, returns to 0x1FE3 label_1FE3: // Incoming return from call to 0x2D11 at 0x1FE2 // Inputs[1] { @1FE7 stack[-1] } 1FE3 5B JUMPDEST 1FE4 61 PUSH2 0x1fec 1FE7 81 DUP2 1FE8 61 PUSH2 0x2d44 1FEB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FE4 stack[0] = 0x1fec // @1FE7 stack[1] = stack[-1] // } // Block ends with call to 0x2d44, returns to 0x1FEC label_1FEC: // Incoming return from call to 0x2D44 at 0x1FEB // Inputs[4] // { // @1FED stack[-5] // @1FEE stack[-1] // @1FEF stack[-3] // @1FF2 stack[-6] // } 1FEC 5B JUMPDEST 1FED 84 DUP5 1FEE 01 ADD 1FEF 91 SWAP2 1FF0 50 POP 1FF1 50 POP 1FF2 92 SWAP3 1FF3 91 SWAP2 1FF4 50 POP 1FF5 50 POP 1FF6 56 *JUMP // Stack delta = -5 // Outputs[1] { @1FF2 stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_1FF7: // Incoming call from 0x28FD, returns to 0x28FE // Inputs[1] { @1FFD stack[-1] } 1FF7 5B JUMPDEST 1FF8 60 PUSH1 0x00 1FFA 61 PUSH2 0x2002 1FFD 82 DUP3 1FFE 61 PUSH2 0x2c2e 2001 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FF8 stack[0] = 0x00 // @1FFA stack[1] = 0x2002 // @1FFD stack[2] = stack[-1] // } // Block ends with call to 0x2c2e, returns to 0x2002 label_2002: // Incoming return from call to 0x2C2E at 0x2001 // Inputs[2] // { // @2006 stack[-1] // @2007 stack[-4] // } 2002 5B JUMPDEST 2003 61 PUSH2 0x200c 2006 81 DUP2 2007 85 DUP6 2008 61 PUSH2 0x2c68 200B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2003 stack[0] = 0x200c // @2006 stack[1] = stack[-1] // @2007 stack[2] = stack[-4] // } // Block ends with call to 0x2c68, returns to 0x200C label_200C: // Incoming return from call to 0x2C68 at 0x200B // Inputs[4] // { // @200D stack[-1] // @200D stack[-5] // @2012 stack[-2] // @2016 stack[-4] // } 200C 5B JUMPDEST 200D 93 SWAP4 200E 50 POP 200F 61 PUSH2 0x201c 2012 81 DUP2 2013 85 DUP6 2014 60 PUSH1 0x20 2016 86 DUP7 2017 01 ADD 2018 61 PUSH2 0x2d11 201B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @200D stack[-5] = stack[-1] // @200F stack[-1] = 0x201c // @2012 stack[0] = stack[-2] // @2013 stack[1] = stack[-1] // @2017 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x2d11, returns to 0x201C label_201C: // Incoming return from call to 0x2D11 at 0x201B // Inputs[1] { @2020 stack[-1] } 201C 5B JUMPDEST 201D 61 PUSH2 0x2025 2020 81 DUP2 2021 61 PUSH2 0x2d44 2024 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @201D stack[0] = 0x2025 // @2020 stack[1] = stack[-1] // } // Block ends with call to 0x2d44, returns to 0x2025 label_2025: // Incoming return from call to 0x2D44 at 0x2024 // Inputs[4] // { // @2026 stack[-5] // @2027 stack[-1] // @2028 stack[-3] // @202B stack[-6] // } 2025 5B JUMPDEST 2026 84 DUP5 2027 01 ADD 2028 91 SWAP2 2029 50 POP 202A 50 POP 202B 92 SWAP3 202C 91 SWAP2 202D 50 POP 202E 50 POP 202F 56 *JUMP // Stack delta = -5 // Outputs[1] { @202B stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_2030: // Incoming call from 0x276C, returns to 0x276D // Inputs[2] // { // @2033 stack[-1] // @2034 storage[stack[-1]] // } 2030 5B JUMPDEST 2031 60 PUSH1 0x00 2033 81 DUP2 2034 54 SLOAD 2035 60 PUSH1 0x01 2037 81 DUP2 2038 16 AND 2039 60 PUSH1 0x00 203B 81 DUP2 203C 14 EQ 203D 61 PUSH2 0x204d 2040 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2031 stack[0] = 0x00 // @2034 stack[1] = storage[stack[-1]] // @2038 stack[2] = storage[stack[-1]] & 0x01 // } // Block ends with conditional jump to 0x204d, if storage[stack[-1]] & 0x01 == 0x00 label_2041: // Incoming jump from 0x2040, if not storage[stack[-1]] & 0x01 == 0x00 // Inputs[1] { @2043 stack[-1] } 2041 60 PUSH1 0x01 2043 81 DUP2 2044 14 EQ 2045 61 PUSH2 0x2072 2048 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2072, if stack[-1] == 0x01 label_2049: // Incoming jump from 0x2048, if not stack[-1] == 0x01 2049 61 PUSH2 0x20b6 204C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x20b6 label_204D: // Incoming jump from 0x2040, if storage[stack[-1]] & 0x01 == 0x00 // Inputs[2] // { // @2052 stack[-2] // @2059 stack[-5] // } 204D 5B JUMPDEST 204E 60 PUSH1 0x7f 2050 60 PUSH1 0x02 2052 83 DUP4 2053 04 DIV 2054 16 AND 2055 61 PUSH2 0x205e 2058 81 DUP2 2059 87 DUP8 205A 61 PUSH2 0x2c79 205D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2054 stack[0] = stack[-2] / 0x02 & 0x7f // @2055 stack[1] = 0x205e // @2058 stack[2] = stack[-2] / 0x02 & 0x7f // @2059 stack[3] = stack[-5] // } // Block ends with call to 0x2c79, returns to 0x205E label_205E: // Incoming return from call to 0x2C79 at 0x205D // Inputs[5] // { // @205F stack[-1] // @205F stack[-7] // @2064 stack[-4] // @2068 stack[-2] // @206B stack[-5] // } 205E 5B JUMPDEST 205F 95 SWAP6 2060 50 POP 2061 60 PUSH1 0xff 2063 19 NOT 2064 83 DUP4 2065 16 AND 2066 86 DUP7 2067 52 MSTORE 2068 80 DUP1 2069 86 DUP7 206A 01 ADD 206B 93 SWAP4 206C 50 POP 206D 50 POP 206E 61 PUSH2 0x20b6 2071 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @205F stack[-7] = stack[-1] // @2067 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] & ~0xff // @206B stack[-5] = stack[-1] + stack[-2] // } // Block ends with unconditional jump to 0x20b6 label_2072: // Incoming jump from 0x2048, if stack[-1] == 0x01 // Inputs[2] // { // @2075 stack[-2] // @207B stack[-5] // } 2072 5B JUMPDEST 2073 60 PUSH1 0x02 2075 82 DUP3 2076 04 DIV 2077 61 PUSH2 0x2080 207A 81 DUP2 207B 87 DUP8 207C 61 PUSH2 0x2c79 207F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2076 stack[0] = stack[-2] / 0x02 // @2077 stack[1] = 0x2080 // @207A stack[2] = stack[-2] / 0x02 // @207B stack[3] = stack[-5] // } // Block ends with call to 0x2c79, returns to 0x2080 label_2080: // Incoming return from call to 0x2C79 at 0x207F // Inputs[3] // { // @2081 stack[-1] // @2081 stack[-7] // @2086 stack[-6] // } 2080 5B JUMPDEST 2081 95 SWAP6 2082 50 POP 2083 61 PUSH2 0x208b 2086 85 DUP6 2087 61 PUSH2 0x2c03 208A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2081 stack[-7] = stack[-1] // @2083 stack[-1] = 0x208b // @2086 stack[0] = stack[-6] // } // Block ends with call to 0x2c03, returns to 0x208B label_208B: // Incoming return from call to 0x2C03 at 0x208A // Inputs[1] { @208F stack[-2] } 208B 5B JUMPDEST 208C 60 PUSH1 0x00 208E 5B JUMPDEST 208F 82 DUP3 2090 81 DUP2 2091 10 LT 2092 15 ISZERO 2093 61 PUSH2 0x20ad 2096 57 *JUMPI // Stack delta = +1 // Outputs[1] { @208C stack[0] = 0x00 } // Block ends with conditional jump to 0x20ad, if !(0x00 < stack[-2]) label_2097: // Incoming jump from 0x2096, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x2096, if not !(0x00 < stack[-2]) // Inputs[4] // { // @2097 stack[-2] // @2098 storage[stack[-2]] // @2099 stack[-1] // @209A stack[-8] // } 2097 81 DUP2 2098 54 SLOAD 2099 81 DUP2 209A 89 DUP10 209B 01 ADD 209C 52 MSTORE 209D 60 PUSH1 0x01 209F 82 DUP3 20A0 01 ADD 20A1 91 SWAP2 20A2 50 POP 20A3 60 PUSH1 0x20 20A5 81 DUP2 20A6 01 ADD 20A7 90 SWAP1 20A8 50 POP 20A9 61 PUSH2 0x208e 20AC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @209C memory[stack[-8] + stack[-1]:stack[-8] + stack[-1] + 0x20] = storage[stack[-2]] // @20A1 stack[-2] = stack[-2] + 0x01 // @20A7 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x208e label_20AD: // Incoming jump from 0x2096, if !(stack[-1] < stack[-3]) // Incoming jump from 0x2096, if !(0x00 < stack[-2]) // Inputs[3] // { // @20AE stack[-3] // @20AF stack[-8] // @20B1 stack[-6] // } 20AD 5B JUMPDEST 20AE 82 DUP3 20AF 88 DUP9 20B0 01 ADD 20B1 95 SWAP6 20B2 50 POP 20B3 50 POP 20B4 50 POP 20B5 50 POP // Stack delta = -3 // Outputs[1] { @20B1 stack[-6] = stack[-8] + stack[-3] } // Block continues label_20B6: // Incoming jump from 0x2071 // Incoming jump from 0x20B5 // Incoming jump from 0x204C // Inputs[3] // { // @20B9 stack[-3] // @20B9 stack[-6] // @20BA stack[-5] // } 20B6 5B JUMPDEST 20B7 50 POP 20B8 50 POP 20B9 92 SWAP3 20BA 91 SWAP2 20BB 50 POP 20BC 50 POP 20BD 56 *JUMP // Stack delta = -5 // Outputs[1] { @20B9 stack[-6] = stack[-3] } // Block ends with unconditional jump to stack[-6] label_20BE: // Incoming call from 0x291E, returns to 0x291F // Inputs[1] { @20C6 stack[-1] } 20BE 5B JUMPDEST 20BF 60 PUSH1 0x00 20C1 61 PUSH2 0x20cb 20C4 60 PUSH1 0x34 20C6 83 DUP4 20C7 61 PUSH2 0x2c68 20CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20BF stack[0] = 0x00 // @20C1 stack[1] = 0x20cb // @20C4 stack[2] = 0x34 // @20C6 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x20CB label_20CB: // Incoming return from call to 0x2C68 at 0x20CA // Inputs[4] // { // @20CC stack[-1] // @20CC stack[-3] // @211E stack[-2] // @2120 stack[-4] // } 20CB 5B JUMPDEST 20CC 91 SWAP2 20CD 50 POP 20CE 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 20EF 60 PUSH1 0x00 20F1 83 DUP4 20F2 01 ADD 20F3 52 MSTORE 20F4 7F PUSH32 0x526563656976657220696d706c656d656e746572000000000000000000000000 2115 60 PUSH1 0x20 2117 83 DUP4 2118 01 ADD 2119 52 MSTORE 211A 60 PUSH1 0x40 211C 82 DUP3 211D 01 ADD 211E 90 SWAP1 211F 50 POP 2120 91 SWAP2 2121 90 SWAP1 2122 50 POP 2123 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @20F3 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @2119 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x526563656976657220696d706c656d656e746572000000000000000000000000 // @2120 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_2124: // Incoming call from 0x293E, returns to 0x293F // Inputs[1] { @212C stack[-1] } 2124 5B JUMPDEST 2125 60 PUSH1 0x00 2127 61 PUSH2 0x2131 212A 60 PUSH1 0x28 212C 83 DUP4 212D 61 PUSH2 0x2c68 2130 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2125 stack[0] = 0x00 // @2127 stack[1] = 0x2131 // @212A stack[2] = 0x28 // @212C stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2131 label_2131: // Incoming return from call to 0x2C68 at 0x2130 // Inputs[4] // { // @2132 stack[-3] // @2132 stack[-1] // @2184 stack[-2] // @2186 stack[-4] // } 2131 5B JUMPDEST 2132 91 SWAP2 2133 50 POP 2134 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 2155 60 PUSH1 0x00 2157 83 DUP4 2158 01 ADD 2159 52 MSTORE 215A 7F PUSH32 0x6420746f6b656e73000000000000000000000000000000000000000000000000 217B 60 PUSH1 0x20 217D 83 DUP4 217E 01 ADD 217F 52 MSTORE 2180 60 PUSH1 0x40 2182 82 DUP3 2183 01 ADD 2184 90 SWAP1 2185 50 POP 2186 91 SWAP2 2187 90 SWAP1 2188 50 POP 2189 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2159 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @217F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6420746f6b656e73000000000000000000000000000000000000000000000000 // @2186 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_218A: // Incoming call from 0x295E, returns to 0x295F // Inputs[1] { @2192 stack[-1] } 218A 5B JUMPDEST 218B 60 PUSH1 0x00 218D 61 PUSH2 0x2197 2190 60 PUSH1 0x2b 2192 83 DUP4 2193 61 PUSH2 0x2c68 2196 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @218B stack[0] = 0x00 // @218D stack[1] = 0x2197 // @2190 stack[2] = 0x2b // @2192 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2197 label_2197: // Incoming return from call to 0x2C68 at 0x2196 // Inputs[4] // { // @2198 stack[-1] // @2198 stack[-3] // @21EA stack[-2] // @21EC stack[-4] // } 2197 5B JUMPDEST 2198 91 SWAP2 2199 50 POP 219A 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 21BB 60 PUSH1 0x00 21BD 83 DUP4 21BE 01 ADD 21BF 52 MSTORE 21C0 7F PUSH32 0x65726f2061646472657373000000000000000000000000000000000000000000 21E1 60 PUSH1 0x20 21E3 83 DUP4 21E4 01 ADD 21E5 52 MSTORE 21E6 60 PUSH1 0x40 21E8 82 DUP3 21E9 01 ADD 21EA 90 SWAP1 21EB 50 POP 21EC 91 SWAP2 21ED 90 SWAP1 21EE 50 POP 21EF 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @21BF memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @21E5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000 // @21EC stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_21F0: // Incoming call from 0x297E, returns to 0x297F // Inputs[1] { @21F8 stack[-1] } 21F0 5B JUMPDEST 21F1 60 PUSH1 0x00 21F3 61 PUSH2 0x21fd 21F6 60 PUSH1 0x31 21F8 83 DUP4 21F9 61 PUSH2 0x2c68 21FC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21F1 stack[0] = 0x00 // @21F3 stack[1] = 0x21fd // @21F6 stack[2] = 0x31 // @21F8 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x21FD label_21FD: // Incoming return from call to 0x2C68 at 0x21FC // Inputs[4] // { // @21FE stack[-3] // @21FE stack[-1] // @2250 stack[-2] // @2252 stack[-4] // } 21FD 5B JUMPDEST 21FE 91 SWAP2 21FF 50 POP 2200 7F PUSH32 0x455243313135353a2062617463682062616c616e636520717565727920666f72 2221 60 PUSH1 0x00 2223 83 DUP4 2224 01 ADD 2225 52 MSTORE 2226 7F PUSH32 0x20746865207a65726f2061646472657373000000000000000000000000000000 2247 60 PUSH1 0x20 2249 83 DUP4 224A 01 ADD 224B 52 MSTORE 224C 60 PUSH1 0x40 224E 82 DUP3 224F 01 ADD 2250 90 SWAP1 2251 50 POP 2252 91 SWAP2 2253 90 SWAP1 2254 50 POP 2255 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2225 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a2062617463682062616c616e636520717565727920666f72 // @224B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x20746865207a65726f2061646472657373000000000000000000000000000000 // @2252 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_2256: // Incoming call from 0x299E, returns to 0x299F // Inputs[1] { @225E stack[-1] } 2256 5B JUMPDEST 2257 60 PUSH1 0x00 2259 61 PUSH2 0x2263 225C 60 PUSH1 0x1b 225E 83 DUP4 225F 61 PUSH2 0x2c68 2262 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2257 stack[0] = 0x00 // @2259 stack[1] = 0x2263 // @225C stack[2] = 0x1b // @225E stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2263 label_2263: // Incoming return from call to 0x2C68 at 0x2262 // Inputs[4] // { // @2264 stack[-1] // @2264 stack[-3] // @2290 stack[-2] // @2292 stack[-4] // } 2263 5B JUMPDEST 2264 91 SWAP2 2265 50 POP 2266 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 2287 60 PUSH1 0x00 2289 83 DUP4 228A 01 ADD 228B 52 MSTORE 228C 60 PUSH1 0x20 228E 82 DUP3 228F 01 ADD 2290 90 SWAP1 2291 50 POP 2292 91 SWAP2 2293 90 SWAP1 2294 50 POP 2295 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @228B memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @2292 stack[-4] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_2296: // Incoming call from 0x29BE, returns to 0x29BF // Inputs[1] { @229E stack[-1] } 2296 5B JUMPDEST 2297 60 PUSH1 0x00 2299 61 PUSH2 0x22a3 229C 60 PUSH1 0x29 229E 83 DUP4 229F 61 PUSH2 0x2c68 22A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2297 stack[0] = 0x00 // @2299 stack[1] = 0x22a3 // @229C stack[2] = 0x29 // @229E stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x22A3 label_22A3: // Incoming return from call to 0x2C68 at 0x22A2 // Inputs[4] // { // @22A4 stack[-1] // @22A4 stack[-3] // @22F6 stack[-2] // @22F8 stack[-4] // } 22A3 5B JUMPDEST 22A4 91 SWAP2 22A5 50 POP 22A6 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 22C7 60 PUSH1 0x00 22C9 83 DUP4 22CA 01 ADD 22CB 52 MSTORE 22CC 7F PUSH32 0x20617070726f7665640000000000000000000000000000000000000000000000 22ED 60 PUSH1 0x20 22EF 83 DUP4 22F0 01 ADD 22F1 52 MSTORE 22F2 60 PUSH1 0x40 22F4 82 DUP3 22F5 01 ADD 22F6 90 SWAP1 22F7 50 POP 22F8 91 SWAP2 22F9 90 SWAP1 22FA 50 POP 22FB 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @22CB memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 // @22F1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x20617070726f7665640000000000000000000000000000000000000000000000 // @22F8 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_22FC: // Incoming call from 0x29DE, returns to 0x29DF // Inputs[1] { @2304 stack[-1] } 22FC 5B JUMPDEST 22FD 60 PUSH1 0x00 22FF 61 PUSH2 0x2309 2302 60 PUSH1 0x25 2304 83 DUP4 2305 61 PUSH2 0x2c68 2308 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22FD stack[0] = 0x00 // @22FF stack[1] = 0x2309 // @2302 stack[2] = 0x25 // @2304 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2309 label_2309: // Incoming return from call to 0x2C68 at 0x2308 // Inputs[4] // { // @230A stack[-3] // @230A stack[-1] // @235C stack[-2] // @235E stack[-4] // } 2309 5B JUMPDEST 230A 91 SWAP2 230B 50 POP 230C 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 232D 60 PUSH1 0x00 232F 83 DUP4 2330 01 ADD 2331 52 MSTORE 2332 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 2353 60 PUSH1 0x20 2355 83 DUP4 2356 01 ADD 2357 52 MSTORE 2358 60 PUSH1 0x40 235A 82 DUP3 235B 01 ADD 235C 90 SWAP1 235D 50 POP 235E 91 SWAP2 235F 90 SWAP1 2360 50 POP 2361 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2331 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @2357 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6472657373000000000000000000000000000000000000000000000000000000 // @235E stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_2362: // Incoming call from 0x29FE, returns to 0x29FF // Inputs[1] { @236A stack[-1] } 2362 5B JUMPDEST 2363 60 PUSH1 0x00 2365 61 PUSH2 0x236f 2368 60 PUSH1 0x32 236A 83 DUP4 236B 61 PUSH2 0x2c68 236E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2363 stack[0] = 0x00 // @2365 stack[1] = 0x236f // @2368 stack[2] = 0x32 // @236A stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x236F label_236F: // Incoming return from call to 0x2C68 at 0x236E // Inputs[4] // { // @2370 stack[-1] // @2370 stack[-3] // @23C2 stack[-2] // @23C4 stack[-4] // } 236F 5B JUMPDEST 2370 91 SWAP2 2371 50 POP 2372 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 2393 60 PUSH1 0x00 2395 83 DUP4 2396 01 ADD 2397 52 MSTORE 2398 7F PUSH32 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 23B9 60 PUSH1 0x20 23BB 83 DUP4 23BC 01 ADD 23BD 52 MSTORE 23BE 60 PUSH1 0x40 23C0 82 DUP3 23C1 01 ADD 23C2 90 SWAP1 23C3 50 POP 23C4 91 SWAP2 23C5 90 SWAP1 23C6 50 POP 23C7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2397 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 // @23BD memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 // @23C4 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_23C8: // Incoming call from 0x2A1E, returns to 0x2A1F // Inputs[1] { @23D0 stack[-1] } 23C8 5B JUMPDEST 23C9 60 PUSH1 0x00 23CB 61 PUSH2 0x23d5 23CE 60 PUSH1 0x26 23D0 83 DUP4 23D1 61 PUSH2 0x2c68 23D4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23C9 stack[0] = 0x00 // @23CB stack[1] = 0x23d5 // @23CE stack[2] = 0x26 // @23D0 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x23D5 label_23D5: // Incoming return from call to 0x2C68 at 0x23D4 // Inputs[4] // { // @23D6 stack[-1] // @23D6 stack[-3] // @2428 stack[-2] // @242A stack[-4] // } 23D5 5B JUMPDEST 23D6 91 SWAP2 23D7 50 POP 23D8 7F PUSH32 0x5065706556323a2063616e206f6e6c792073657420746f6b656e204944207369 23F9 60 PUSH1 0x00 23FB 83 DUP4 23FC 01 ADD 23FD 52 MSTORE 23FE 7F PUSH32 0x67206f6e63650000000000000000000000000000000000000000000000000000 241F 60 PUSH1 0x20 2421 83 DUP4 2422 01 ADD 2423 52 MSTORE 2424 60 PUSH1 0x40 2426 82 DUP3 2427 01 ADD 2428 90 SWAP1 2429 50 POP 242A 91 SWAP2 242B 90 SWAP1 242C 50 POP 242D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @23FD memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x5065706556323a2063616e206f6e6c792073657420746f6b656e204944207369 // @2423 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x67206f6e63650000000000000000000000000000000000000000000000000000 // @242A stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_242E: // Incoming call from 0x2760, returns to 0x2761 // Inputs[1] { @2436 stack[-1] } 242E 5B JUMPDEST 242F 60 PUSH1 0x00 2431 61 PUSH2 0x243b 2434 60 PUSH1 0x0c 2436 83 DUP4 2437 61 PUSH2 0x2c79 243A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @242F stack[0] = 0x00 // @2431 stack[1] = 0x243b // @2434 stack[2] = 0x0c // @2436 stack[3] = stack[-1] // } // Block ends with call to 0x2c79, returns to 0x243B label_243B: // Incoming return from call to 0x2C79 at 0x243A // Inputs[4] // { // @243C stack[-3] // @243C stack[-1] // @2468 stack[-2] // @246A stack[-4] // } 243B 5B JUMPDEST 243C 91 SWAP2 243D 50 POP 243E 7F PUSH32 0x697066733a2f2f697066732f0000000000000000000000000000000000000000 245F 60 PUSH1 0x00 2461 83 DUP4 2462 01 ADD 2463 52 MSTORE 2464 60 PUSH1 0x0c 2466 82 DUP3 2467 01 ADD 2468 90 SWAP1 2469 50 POP 246A 91 SWAP2 246B 90 SWAP1 246C 50 POP 246D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2463 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x697066733a2f2f697066732f0000000000000000000000000000000000000000 // @246A stack[-4] = stack[-1] + 0x0c // } // Block ends with unconditional jump to stack[-4] label_246E: // Incoming call from 0x2A3E, returns to 0x2A3F // Inputs[1] { @2476 stack[-1] } 246E 5B JUMPDEST 246F 60 PUSH1 0x00 2471 61 PUSH2 0x247b 2474 60 PUSH1 0x29 2476 83 DUP4 2477 61 PUSH2 0x2c68 247A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @246F stack[0] = 0x00 // @2471 stack[1] = 0x247b // @2474 stack[2] = 0x29 // @2476 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x247B label_247B: // Incoming return from call to 0x2C68 at 0x247A // Inputs[4] // { // @247C stack[-1] // @247C stack[-3] // @24CE stack[-2] // @24D0 stack[-4] // } 247B 5B JUMPDEST 247C 91 SWAP2 247D 50 POP 247E 7F PUSH32 0x5065706556323a2043616e206f6e6c79206d696e742066726f6d206d696e7465 249F 60 PUSH1 0x00 24A1 83 DUP4 24A2 01 ADD 24A3 52 MSTORE 24A4 7F PUSH32 0x7220616464726573730000000000000000000000000000000000000000000000 24C5 60 PUSH1 0x20 24C7 83 DUP4 24C8 01 ADD 24C9 52 MSTORE 24CA 60 PUSH1 0x40 24CC 82 DUP3 24CD 01 ADD 24CE 90 SWAP1 24CF 50 POP 24D0 91 SWAP2 24D1 90 SWAP1 24D2 50 POP 24D3 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @24A3 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x5065706556323a2043616e206f6e6c79206d696e742066726f6d206d696e7465 // @24C9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7220616464726573730000000000000000000000000000000000000000000000 // @24D0 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_24D4: // Incoming call from 0x2A5E, returns to 0x2A5F // Inputs[1] { @24DC stack[-1] } 24D4 5B JUMPDEST 24D5 60 PUSH1 0x00 24D7 61 PUSH2 0x24e1 24DA 60 PUSH1 0x29 24DC 83 DUP4 24DD 61 PUSH2 0x2c68 24E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24D5 stack[0] = 0x00 // @24D7 stack[1] = 0x24e1 // @24DA stack[2] = 0x29 // @24DC stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x24E1 label_24E1: // Incoming return from call to 0x2C68 at 0x24E0 // Inputs[4] // { // @24E2 stack[-1] // @24E2 stack[-3] // @2534 stack[-2] // @2536 stack[-4] // } 24E1 5B JUMPDEST 24E2 91 SWAP2 24E3 50 POP 24E4 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 2505 60 PUSH1 0x00 2507 83 DUP4 2508 01 ADD 2509 52 MSTORE 250A 7F PUSH32 0x20666f722073656c660000000000000000000000000000000000000000000000 252B 60 PUSH1 0x20 252D 83 DUP4 252E 01 ADD 252F 52 MSTORE 2530 60 PUSH1 0x40 2532 82 DUP3 2533 01 ADD 2534 90 SWAP1 2535 50 POP 2536 91 SWAP2 2537 90 SWAP1 2538 50 POP 2539 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2509 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @252F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x20666f722073656c660000000000000000000000000000000000000000000000 // @2536 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_253A: // Incoming call from 0x2A7E, returns to 0x2A7F // Inputs[1] { @2542 stack[-1] } 253A 5B JUMPDEST 253B 60 PUSH1 0x00 253D 61 PUSH2 0x2547 2540 60 PUSH1 0x29 2542 83 DUP4 2543 61 PUSH2 0x2c68 2546 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @253B stack[0] = 0x00 // @253D stack[1] = 0x2547 // @2540 stack[2] = 0x29 // @2542 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2547 label_2547: // Incoming return from call to 0x2C68 at 0x2546 // Inputs[4] // { // @2548 stack[-3] // @2548 stack[-1] // @259A stack[-2] // @259C stack[-4] // } 2547 5B JUMPDEST 2548 91 SWAP2 2549 50 POP 254A 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 256B 60 PUSH1 0x00 256D 83 DUP4 256E 01 ADD 256F 52 MSTORE 2570 7F PUSH32 0x206d69736d617463680000000000000000000000000000000000000000000000 2591 60 PUSH1 0x20 2593 83 DUP4 2594 01 ADD 2595 52 MSTORE 2596 60 PUSH1 0x40 2598 82 DUP3 2599 01 ADD 259A 90 SWAP1 259B 50 POP 259C 91 SWAP2 259D 90 SWAP1 259E 50 POP 259F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @256F memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @2595 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000 // @259C stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_25A0: // Incoming call from 0x2A9E, returns to 0x2A9F // Inputs[1] { @25A8 stack[-1] } 25A0 5B JUMPDEST 25A1 60 PUSH1 0x00 25A3 61 PUSH2 0x25ad 25A6 60 PUSH1 0x28 25A8 83 DUP4 25A9 61 PUSH2 0x2c68 25AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @25A1 stack[0] = 0x00 // @25A3 stack[1] = 0x25ad // @25A6 stack[2] = 0x28 // @25A8 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x25AD label_25AD: // Incoming return from call to 0x2C68 at 0x25AC // Inputs[4] // { // @25AE stack[-1] // @25AE stack[-3] // @2600 stack[-2] // @2602 stack[-4] // } 25AD 5B JUMPDEST 25AE 91 SWAP2 25AF 50 POP 25B0 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 25D1 60 PUSH1 0x00 25D3 83 DUP4 25D4 01 ADD 25D5 52 MSTORE 25D6 7F PUSH32 0x6d69736d61746368000000000000000000000000000000000000000000000000 25F7 60 PUSH1 0x20 25F9 83 DUP4 25FA 01 ADD 25FB 52 MSTORE 25FC 60 PUSH1 0x40 25FE 82 DUP3 25FF 01 ADD 2600 90 SWAP1 2601 50 POP 2602 91 SWAP2 2603 90 SWAP1 2604 50 POP 2605 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @25D5 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 // @25FB memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6d69736d61746368000000000000000000000000000000000000000000000000 // @2602 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_2606: // Incoming call from 0x2ABE, returns to 0x2ABF // Inputs[1] { @260E stack[-1] } 2606 5B JUMPDEST 2607 60 PUSH1 0x00 2609 61 PUSH2 0x2613 260C 60 PUSH1 0x21 260E 83 DUP4 260F 61 PUSH2 0x2c68 2612 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2607 stack[0] = 0x00 // @2609 stack[1] = 0x2613 // @260C stack[2] = 0x21 // @260E stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2613 label_2613: // Incoming return from call to 0x2C68 at 0x2612 // Inputs[4] // { // @2614 stack[-3] // @2614 stack[-1] // @2666 stack[-2] // @2668 stack[-4] // } 2613 5B JUMPDEST 2614 91 SWAP2 2615 50 POP 2616 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 2637 60 PUSH1 0x00 2639 83 DUP4 263A 01 ADD 263B 52 MSTORE 263C 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 265D 60 PUSH1 0x20 265F 83 DUP4 2660 01 ADD 2661 52 MSTORE 2662 60 PUSH1 0x40 2664 82 DUP3 2665 01 ADD 2666 90 SWAP1 2667 50 POP 2668 91 SWAP2 2669 90 SWAP1 266A 50 POP 266B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @263B memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @2661 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @2668 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_266C: // Incoming call from 0x2ADE, returns to 0x2ADF // Inputs[1] { @2674 stack[-1] } 266C 5B JUMPDEST 266D 60 PUSH1 0x00 266F 61 PUSH2 0x2679 2672 60 PUSH1 0x2f 2674 83 DUP4 2675 61 PUSH2 0x2c68 2678 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @266D stack[0] = 0x00 // @266F stack[1] = 0x2679 // @2672 stack[2] = 0x2f // @2674 stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x2679 label_2679: // Incoming return from call to 0x2C68 at 0x2678 // Inputs[4] // { // @267A stack[-1] // @267A stack[-3] // @26CC stack[-2] // @26CE stack[-4] // } 2679 5B JUMPDEST 267A 91 SWAP2 267B 50 POP 267C 7F PUSH32 0x5065706556323a2043616e206f6e6c792072657475726e2055524920666f7220 269D 60 PUSH1 0x00 269F 83 DUP4 26A0 01 ADD 26A1 52 MSTORE 26A2 7F PUSH32 0x6b6e6f776e20746f6b656e204944730000000000000000000000000000000000 26C3 60 PUSH1 0x20 26C5 83 DUP4 26C6 01 ADD 26C7 52 MSTORE 26C8 60 PUSH1 0x40 26CA 82 DUP3 26CB 01 ADD 26CC 90 SWAP1 26CD 50 POP 26CE 91 SWAP2 26CF 90 SWAP1 26D0 50 POP 26D1 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @26A1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x5065706556323a2043616e206f6e6c792072657475726e2055524920666f7220 // @26C7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6b6e6f776e20746f6b656e204944730000000000000000000000000000000000 // @26CE stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_26D2: // Incoming call from 0x2AFE, returns to 0x2AFF // Inputs[1] { @26DA stack[-1] } 26D2 5B JUMPDEST 26D3 60 PUSH1 0x00 26D5 61 PUSH2 0x26df 26D8 60 PUSH1 0x31 26DA 83 DUP4 26DB 61 PUSH2 0x2c68 26DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26D3 stack[0] = 0x00 // @26D5 stack[1] = 0x26df // @26D8 stack[2] = 0x31 // @26DA stack[3] = stack[-1] // } // Block ends with call to 0x2c68, returns to 0x26DF label_26DF: // Incoming return from call to 0x2C68 at 0x26DE // Inputs[4] // { // @26E0 stack[-3] // @26E0 stack[-1] // @2732 stack[-2] // @2734 stack[-4] // } 26DF 5B JUMPDEST 26E0 91 SWAP2 26E1 50 POP 26E2 7F PUSH32 0x5065706556323a2043616e206f6e6c792073657420746f6b656e204944206672 2703 60 PUSH1 0x00 2705 83 DUP4 2706 01 ADD 2707 52 MSTORE 2708 7F PUSH32 0x6f6d206d696e7465722061646472657373000000000000000000000000000000 2729 60 PUSH1 0x20 272B 83 DUP4 272C 01 ADD 272D 52 MSTORE 272E 60 PUSH1 0x40 2730 82 DUP3 2731 01 ADD 2732 90 SWAP1 2733 50 POP 2734 91 SWAP2 2735 90 SWAP1 2736 50 POP 2737 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2707 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x5065706556323a2043616e206f6e6c792073657420746f6b656e204944206672 // @272D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6f6d206d696e7465722061646472657373000000000000000000000000000000 // @2734 stack[-4] = stack[-1] + 0x40 // } // Block ends with unconditional jump to stack[-4] label_2738: // Incoming call from 0x1F26, returns to 0x1F27 // Inputs[1] { @273C stack[-1] } 2738 5B JUMPDEST 2739 61 PUSH2 0x2741 273C 81 DUP2 273D 61 PUSH2 0x2cf8 2740 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2739 stack[0] = 0x2741 // @273C stack[1] = stack[-1] // } // Block ends with call to 0x2cf8, returns to 0x2741 label_2741: // Incoming return from call to 0x2CF8 at 0x2740 // Inputs[3] // { // @2742 stack[-3] // @2743 stack[-1] // @2746 stack[-4] // } 2741 5B JUMPDEST 2742 82 DUP3 2743 52 MSTORE 2744 50 POP 2745 50 POP 2746 56 *JUMP // Stack delta = -4 // Outputs[1] { @2743 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2747: // Incoming call from 0x2B42, returns to 0x2B43 // Incoming call from 0x2B1A, returns to 0x2B1B // Incoming call from 0x2B35, returns to 0x2B36 // Incoming call from 0x2836, returns to 0x2837 // Incoming call from 0x2829, returns to 0x282A // Inputs[1] { @274B stack[-1] } 2747 5B JUMPDEST 2748 61 PUSH2 0x2750 274B 81 DUP2 274C 61 PUSH2 0x2cf8 274F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2748 stack[0] = 0x2750 // @274B stack[1] = stack[-1] // } // Block ends with call to 0x2cf8, returns to 0x2750 label_2750: // Incoming return from call to 0x2CF8 at 0x274F // Inputs[3] // { // @2751 stack[-3] // @2752 stack[-1] // @2755 stack[-4] // } 2750 5B JUMPDEST 2751 82 DUP3 2752 52 MSTORE 2753 50 POP 2754 50 POP 2755 56 *JUMP // Stack delta = -4 // Outputs[1] { @2752 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2756: // Incoming call from 0x051C, returns to 0x051D // Inputs[1] { @275C stack[-1] } 2756 5B JUMPDEST 2757 60 PUSH1 0x00 2759 61 PUSH2 0x2761 275C 82 DUP3 275D 61 PUSH2 0x242e 2760 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2757 stack[0] = 0x00 // @2759 stack[1] = 0x2761 // @275C stack[2] = stack[-1] // } // Block ends with call to 0x242e, returns to 0x2761 label_2761: // Incoming return from call to 0x242E at 0x2760 // Inputs[3] // { // @2762 stack[-3] // @2762 stack[-1] // @2768 stack[-4] // } 2761 5B JUMPDEST 2762 91 SWAP2 2763 50 POP 2764 61 PUSH2 0x276d 2767 82 DUP3 2768 84 DUP5 2769 61 PUSH2 0x2030 276C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2762 stack[-3] = stack[-1] // @2764 stack[-1] = 0x276d // @2767 stack[0] = stack[-1] // @2768 stack[1] = stack[-4] // } // Block ends with call to 0x2030, returns to 0x276D label_276D: // Incoming return from call to 0x2030 at 0x276C // Inputs[5] // { // @276E stack[-3] // @276E stack[-1] // @2771 stack[-2] // @2773 stack[-5] // @2774 stack[-4] // } 276D 5B JUMPDEST 276E 91 SWAP2 276F 50 POP 2770 81 DUP2 2771 90 SWAP1 2772 50 POP 2773 92 SWAP3 2774 91 SWAP2 2775 50 POP 2776 50 POP 2777 56 *JUMP // Stack delta = -4 // Outputs[1] { @2773 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2778: // Incoming call from 0x01AF, returns to 0x01B0 // Inputs[2] // { // @277D stack[-1] // @2788 stack[-2] // } 2778 5B JUMPDEST 2779 60 PUSH1 0x00 277B 60 PUSH1 0x20 277D 82 DUP3 277E 01 ADD 277F 90 SWAP1 2780 50 POP 2781 61 PUSH2 0x278d 2784 60 PUSH1 0x00 2786 83 DUP4 2787 01 ADD 2788 84 DUP5 2789 61 PUSH2 0x1f33 278C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @277F stack[0] = stack[-1] + 0x20 // @2781 stack[1] = 0x278d // @2787 stack[2] = stack[-1] + 0x00 // @2788 stack[3] = stack[-2] // } // Block ends with call to 0x1f33, returns to 0x278D label_278D: // Incoming return from call to 0x1F33 at 0x278C // Inputs[3] // { // @278E stack[-1] // @278E stack[-4] // @278F stack[-3] // } 278D 5B JUMPDEST 278E 92 SWAP3 278F 91 SWAP2 2790 50 POP 2791 50 POP 2792 56 *JUMP // Stack delta = -3 // Outputs[1] { @278E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2793: // Incoming call from 0x15E7, returns to 0x15E8 // Inputs[2] // { // @2798 stack[-1] // @27A3 stack[-6] // } 2793 5B JUMPDEST 2794 60 PUSH1 0x00 2796 60 PUSH1 0xa0 2798 82 DUP3 2799 01 ADD 279A 90 SWAP1 279B 50 POP 279C 61 PUSH2 0x27a8 279F 60 PUSH1 0x00 27A1 83 DUP4 27A2 01 ADD 27A3 88 DUP9 27A4 61 PUSH2 0x1f33 27A7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @279A stack[0] = stack[-1] + 0xa0 // @279C stack[1] = 0x27a8 // @27A2 stack[2] = stack[-1] + 0x00 // @27A3 stack[3] = stack[-6] // } // Block ends with call to 0x1f33, returns to 0x27A8 label_27A8: // Incoming return from call to 0x1F33 at 0x27A7 // Inputs[2] // { // @27AE stack[-2] // @27B0 stack[-6] // } 27A8 5B JUMPDEST 27A9 61 PUSH2 0x27b5 27AC 60 PUSH1 0x20 27AE 83 DUP4 27AF 01 ADD 27B0 87 DUP8 27B1 61 PUSH2 0x1f33 27B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27A9 stack[0] = 0x27b5 // @27AF stack[1] = stack[-2] + 0x20 // @27B0 stack[2] = stack[-6] // } // Block ends with call to 0x1f33, returns to 0x27B5 label_27B5: // Incoming return from call to 0x1F33 at 0x27B4 // Inputs[3] // { // @27B6 stack[-2] // @27B7 stack[-1] // @27C2 stack[-5] // } 27B5 5B JUMPDEST 27B6 81 DUP2 27B7 81 DUP2 27B8 03 SUB 27B9 60 PUSH1 0x40 27BB 83 DUP4 27BC 01 ADD 27BD 52 MSTORE 27BE 61 PUSH2 0x27c7 27C1 81 DUP2 27C2 86 DUP7 27C3 61 PUSH2 0x1f42 27C6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @27BD memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = stack[-1] - stack[-2] // @27BE stack[0] = 0x27c7 // @27C1 stack[1] = stack[-1] // @27C2 stack[2] = stack[-5] // } // Block ends with call to 0x1f42, returns to 0x27C7 label_27C7: // Incoming return from call to 0x1F42 at 0x27C6 // Inputs[4] // { // @27C8 stack[-2] // @27C8 stack[-1] // @27CA stack[-3] // @27D6 stack[-5] // } 27C7 5B JUMPDEST 27C8 90 SWAP1 27C9 50 POP 27CA 81 DUP2 27CB 81 DUP2 27CC 03 SUB 27CD 60 PUSH1 0x60 27CF 83 DUP4 27D0 01 ADD 27D1 52 MSTORE 27D2 61 PUSH2 0x27db 27D5 81 DUP2 27D6 85 DUP6 27D7 61 PUSH2 0x1f42 27DA 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @27C8 stack[-2] = stack[-1] // @27D1 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = stack[-1] - stack[-3] // @27D2 stack[-1] = 0x27db // @27D5 stack[0] = stack[-1] // @27D6 stack[1] = stack[-5] // } // Block ends with call to 0x1f42, returns to 0x27DB label_27DB: // Incoming return from call to 0x1F42 at 0x27DA // Inputs[4] // { // @27DC stack[-2] // @27DC stack[-1] // @27DE stack[-3] // @27EA stack[-4] // } 27DB 5B JUMPDEST 27DC 90 SWAP1 27DD 50 POP 27DE 81 DUP2 27DF 81 DUP2 27E0 03 SUB 27E1 60 PUSH1 0x80 27E3 83 DUP4 27E4 01 ADD 27E5 52 MSTORE 27E6 61 PUSH2 0x27ef 27E9 81 DUP2 27EA 84 DUP5 27EB 61 PUSH2 0x1fbe 27EE 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @27DC stack[-2] = stack[-1] // @27E5 memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] = stack[-1] - stack[-3] // @27E6 stack[-1] = 0x27ef // @27E9 stack[0] = stack[-1] // @27EA stack[1] = stack[-4] // } // Block ends with call to 0x1fbe, returns to 0x27EF label_27EF: // Incoming return from call to 0x1FBE at 0x27EE // Inputs[4] // { // @27F0 stack[-1] // @27F0 stack[-2] // @27F2 stack[-9] // @27F3 stack[-8] // } 27EF 5B JUMPDEST 27F0 90 SWAP1 27F1 50 POP 27F2 96 SWAP7 27F3 95 SWAP6 27F4 50 POP 27F5 50 POP 27F6 50 POP 27F7 50 POP 27F8 50 POP 27F9 50 POP 27FA 56 *JUMP // Stack delta = -8 // Outputs[1] { @27F2 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_27FB: // Incoming call from 0x1827, returns to 0x1828 // Inputs[2] // { // @2800 stack[-1] // @280B stack[-6] // } 27FB 5B JUMPDEST 27FC 60 PUSH1 0x00 27FE 60 PUSH1 0xa0 2800 82 DUP3 2801 01 ADD 2802 90 SWAP1 2803 50 POP 2804 61 PUSH2 0x2810 2807 60 PUSH1 0x00 2809 83 DUP4 280A 01 ADD 280B 88 DUP9 280C 61 PUSH2 0x1f33 280F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2802 stack[0] = stack[-1] + 0xa0 // @2804 stack[1] = 0x2810 // @280A stack[2] = stack[-1] + 0x00 // @280B stack[3] = stack[-6] // } // Block ends with call to 0x1f33, returns to 0x2810 label_2810: // Incoming return from call to 0x1F33 at 0x280F // Inputs[2] // { // @2816 stack[-2] // @2818 stack[-6] // } 2810 5B JUMPDEST 2811 61 PUSH2 0x281d 2814 60 PUSH1 0x20 2816 83 DUP4 2817 01 ADD 2818 87 DUP8 2819 61 PUSH2 0x1f33 281C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2811 stack[0] = 0x281d // @2817 stack[1] = stack[-2] + 0x20 // @2818 stack[2] = stack[-6] // } // Block ends with call to 0x1f33, returns to 0x281D label_281D: // Incoming return from call to 0x1F33 at 0x281C // Inputs[2] // { // @2823 stack[-2] // @2825 stack[-5] // } 281D 5B JUMPDEST 281E 61 PUSH2 0x282a 2821 60 PUSH1 0x40 2823 83 DUP4 2824 01 ADD 2825 86 DUP7 2826 61 PUSH2 0x2747 2829 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @281E stack[0] = 0x282a // @2824 stack[1] = stack[-2] + 0x40 // @2825 stack[2] = stack[-5] // } // Block ends with call to 0x2747, returns to 0x282A label_282A: // Incoming return from call to 0x2747 at 0x2829 // Inputs[2] // { // @2830 stack[-2] // @2832 stack[-4] // } 282A 5B JUMPDEST 282B 61 PUSH2 0x2837 282E 60 PUSH1 0x60 2830 83 DUP4 2831 01 ADD 2832 85 DUP6 2833 61 PUSH2 0x2747 2836 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @282B stack[0] = 0x2837 // @2831 stack[1] = stack[-2] + 0x60 // @2832 stack[2] = stack[-4] // } // Block ends with call to 0x2747, returns to 0x2837 label_2837: // Incoming return from call to 0x2747 at 0x2836 // Inputs[3] // { // @2838 stack[-2] // @2839 stack[-1] // @2844 stack[-3] // } 2837 5B JUMPDEST 2838 81 DUP2 2839 81 DUP2 283A 03 SUB 283B 60 PUSH1 0x80 283D 83 DUP4 283E 01 ADD 283F 52 MSTORE 2840 61 PUSH2 0x2849 2843 81 DUP2 2844 84 DUP5 2845 61 PUSH2 0x1fbe 2848 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @283F memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] = stack[-1] - stack[-2] // @2840 stack[0] = 0x2849 // @2843 stack[1] = stack[-1] // @2844 stack[2] = stack[-3] // } // Block ends with call to 0x1fbe, returns to 0x2849 label_2849: // Incoming return from call to 0x1FBE at 0x2848 // Inputs[4] // { // @284A stack[-1] // @284A stack[-2] // @284C stack[-9] // @284D stack[-8] // } 2849 5B JUMPDEST 284A 90 SWAP1 284B 50 POP 284C 96 SWAP7 284D 95 SWAP6 284E 50 POP 284F 50 POP 2850 50 POP 2851 50 POP 2852 50 POP 2853 50 POP 2854 56 *JUMP // Stack delta = -8 // Outputs[1] { @284C stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_2855: // Incoming call from 0x01DF, returns to 0x01E0 // Inputs[2] // { // @285A stack[-1] // @286A stack[-2] // } 2855 5B JUMPDEST 2856 60 PUSH1 0x00 2858 60 PUSH1 0x20 285A 82 DUP3 285B 01 ADD 285C 90 SWAP1 285D 50 POP 285E 81 DUP2 285F 81 DUP2 2860 03 SUB 2861 60 PUSH1 0x00 2863 83 DUP4 2864 01 ADD 2865 52 MSTORE 2866 61 PUSH2 0x286f 2869 81 DUP2 286A 84 DUP5 286B 61 PUSH2 0x1f42 286E 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @285C stack[0] = stack[-1] + 0x20 // @2865 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2866 stack[1] = 0x286f // @2869 stack[2] = stack[-1] + 0x20 // @286A stack[3] = stack[-2] // } // Block ends with call to 0x1f42, returns to 0x286F label_286F: // Incoming return from call to 0x1F42 at 0x286E // Inputs[4] // { // @2870 stack[-2] // @2870 stack[-1] // @2872 stack[-5] // @2873 stack[-4] // } 286F 5B JUMPDEST 2870 90 SWAP1 2871 50 POP 2872 92 SWAP3 2873 91 SWAP2 2874 50 POP 2875 50 POP 2876 56 *JUMP // Stack delta = -4 // Outputs[1] { @2872 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2877: // Incoming call from 0x09AE, returns to 0x09AF // Inputs[2] // { // @287C stack[-1] // @288C stack[-3] // } 2877 5B JUMPDEST 2878 60 PUSH1 0x00 287A 60 PUSH1 0x40 287C 82 DUP3 287D 01 ADD 287E 90 SWAP1 287F 50 POP 2880 81 DUP2 2881 81 DUP2 2882 03 SUB 2883 60 PUSH1 0x00 2885 83 DUP4 2886 01 ADD 2887 52 MSTORE 2888 61 PUSH2 0x2891 288B 81 DUP2 288C 85 DUP6 288D 61 PUSH2 0x1f42 2890 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @287E stack[0] = stack[-1] + 0x40 // @2887 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x40) - stack[-1] // @2888 stack[1] = 0x2891 // @288B stack[2] = stack[-1] + 0x40 // @288C stack[3] = stack[-3] // } // Block ends with call to 0x1f42, returns to 0x2891 label_2891: // Incoming return from call to 0x1F42 at 0x2890 // Inputs[4] // { // @2892 stack[-1] // @2892 stack[-2] // @2894 stack[-3] // @28A0 stack[-4] // } 2891 5B JUMPDEST 2892 90 SWAP1 2893 50 POP 2894 81 DUP2 2895 81 DUP2 2896 03 SUB 2897 60 PUSH1 0x20 2899 83 DUP4 289A 01 ADD 289B 52 MSTORE 289C 61 PUSH2 0x28a5 289F 81 DUP2 28A0 84 DUP5 28A1 61 PUSH2 0x1f42 28A4 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2892 stack[-2] = stack[-1] // @289B memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @289C stack[-1] = 0x28a5 // @289F stack[0] = stack[-1] // @28A0 stack[1] = stack[-4] // } // Block ends with call to 0x1f42, returns to 0x28A5 label_28A5: // Incoming return from call to 0x1F42 at 0x28A4 // Inputs[4] // { // @28A6 stack[-1] // @28A6 stack[-2] // @28A8 stack[-6] // @28A9 stack[-5] // } 28A5 5B JUMPDEST 28A6 90 SWAP1 28A7 50 POP 28A8 93 SWAP4 28A9 92 SWAP3 28AA 50 POP 28AB 50 POP 28AC 50 POP 28AD 56 *JUMP // Stack delta = -5 // Outputs[1] { @28A8 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_28AE: // Incoming call from 0x0277, returns to 0x0278 // Incoming call from 0x0129, returns to 0x012A // Incoming call from 0x0EE0, returns to 0x0EE1 // Inputs[2] // { // @28B3 stack[-1] // @28BE stack[-2] // } 28AE 5B JUMPDEST 28AF 60 PUSH1 0x00 28B1 60 PUSH1 0x20 28B3 82 DUP3 28B4 01 ADD 28B5 90 SWAP1 28B6 50 POP 28B7 61 PUSH2 0x28c3 28BA 60 PUSH1 0x00 28BC 83 DUP4 28BD 01 ADD 28BE 84 DUP5 28BF 61 PUSH2 0x1fa0 28C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @28B5 stack[0] = stack[-1] + 0x20 // @28B7 stack[1] = 0x28c3 // @28BD stack[2] = stack[-1] + 0x00 // @28BE stack[3] = stack[-2] // } // Block ends with call to 0x1fa0, returns to 0x28C3 label_28C3: // Incoming return from call to 0x1FA0 at 0x28C2 // Inputs[3] // { // @28C4 stack[-1] // @28C4 stack[-4] // @28C5 stack[-3] // } 28C3 5B JUMPDEST 28C4 92 SWAP3 28C5 91 SWAP2 28C6 50 POP 28C7 50 POP 28C8 56 *JUMP // Stack delta = -3 // Outputs[1] { @28C4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_28C9: // Incoming call from 0x02C3, returns to 0x02C4 // Inputs[2] // { // @28CE stack[-1] // @28D9 stack[-2] // } 28C9 5B JUMPDEST 28CA 60 PUSH1 0x00 28CC 60 PUSH1 0x20 28CE 82 DUP3 28CF 01 ADD 28D0 90 SWAP1 28D1 50 POP 28D2 61 PUSH2 0x28de 28D5 60 PUSH1 0x00 28D7 83 DUP4 28D8 01 ADD 28D9 84 DUP5 28DA 61 PUSH2 0x1faf 28DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @28D0 stack[0] = stack[-1] + 0x20 // @28D2 stack[1] = 0x28de // @28D8 stack[2] = stack[-1] + 0x00 // @28D9 stack[3] = stack[-2] // } // Block ends with call to 0x1faf, returns to 0x28DE label_28DE: // Incoming return from call to 0x1FAF at 0x28DD // Inputs[3] // { // @28DF stack[-1] // @28DF stack[-4] // @28E0 stack[-3] // } 28DE 5B JUMPDEST 28DF 92 SWAP3 28E0 91 SWAP2 28E1 50 POP 28E2 50 POP 28E3 56 *JUMP // Stack delta = -3 // Outputs[1] { @28DF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_28E4: // Incoming call from 0x1511, returns to 0x1512 // Incoming call from 0x020F, returns to 0x0210 // Incoming call from 0x167D, returns to 0x167E // Incoming call from 0x18BD, returns to 0x18BE // Incoming call from 0x0159, returns to 0x015A // Inputs[2] // { // @28E9 stack[-1] // @28F9 stack[-2] // } 28E4 5B JUMPDEST 28E5 60 PUSH1 0x00 28E7 60 PUSH1 0x20 28E9 82 DUP3 28EA 01 ADD 28EB 90 SWAP1 28EC 50 POP 28ED 81 DUP2 28EE 81 DUP2 28EF 03 SUB 28F0 60 PUSH1 0x00 28F2 83 DUP4 28F3 01 ADD 28F4 52 MSTORE 28F5 61 PUSH2 0x28fe 28F8 81 DUP2 28F9 84 DUP5 28FA 61 PUSH2 0x1ff7 28FD 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @28EB stack[0] = stack[-1] + 0x20 // @28F4 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @28F5 stack[1] = 0x28fe // @28F8 stack[2] = stack[-1] + 0x20 // @28F9 stack[3] = stack[-2] // } // Block ends with call to 0x1ff7, returns to 0x28FE label_28FE: // Incoming return from call to 0x1FF7 at 0x28FD // Inputs[4] // { // @28FF stack[-2] // @28FF stack[-1] // @2901 stack[-5] // @2902 stack[-4] // } 28FE 5B JUMPDEST 28FF 90 SWAP1 2900 50 POP 2901 92 SWAP3 2902 91 SWAP2 2903 50 POP 2904 50 POP 2905 56 *JUMP // Stack delta = -4 // Outputs[1] { @2901 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2906: // Incoming call from 0x18F8, returns to 0x18F9 // Incoming call from 0x16B8, returns to 0x16B9 // Inputs[1] { @290B stack[-1] } 2906 5B JUMPDEST 2907 60 PUSH1 0x00 2909 60 PUSH1 0x20 290B 82 DUP3 290C 01 ADD 290D 90 SWAP1 290E 50 POP 290F 81 DUP2 2910 81 DUP2 2911 03 SUB 2912 60 PUSH1 0x00 2914 83 DUP4 2915 01 ADD 2916 52 MSTORE 2917 61 PUSH2 0x291f 291A 81 DUP2 291B 61 PUSH2 0x20be 291E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @290D stack[0] = stack[-1] + 0x20 // @2916 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2917 stack[1] = 0x291f // @291A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x20be, returns to 0x291F label_291F: // Incoming return from call to 0x20BE at 0x291E // Inputs[4] // { // @2920 stack[-2] // @2920 stack[-1] // @2922 stack[-4] // @2923 stack[-3] // } 291F 5B JUMPDEST 2920 90 SWAP1 2921 50 POP 2922 91 SWAP2 2923 90 SWAP1 2924 50 POP 2925 56 *JUMP // Stack delta = -3 // Outputs[1] { @2922 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2926: // Incoming call from 0x173F, returns to 0x1740 // Incoming call from 0x197F, returns to 0x1980 // Inputs[1] { @292B stack[-1] } 2926 5B JUMPDEST 2927 60 PUSH1 0x00 2929 60 PUSH1 0x20 292B 82 DUP3 292C 01 ADD 292D 90 SWAP1 292E 50 POP 292F 81 DUP2 2930 81 DUP2 2931 03 SUB 2932 60 PUSH1 0x00 2934 83 DUP4 2935 01 ADD 2936 52 MSTORE 2937 61 PUSH2 0x293f 293A 81 DUP2 293B 61 PUSH2 0x2124 293E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @292D stack[0] = stack[-1] + 0x20 // @2936 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2937 stack[1] = 0x293f // @293A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2124, returns to 0x293F label_293F: // Incoming return from call to 0x2124 at 0x293E // Inputs[4] // { // @2940 stack[-2] // @2940 stack[-1] // @2942 stack[-4] // @2943 stack[-3] // } 293F 5B JUMPDEST 2940 90 SWAP1 2941 50 POP 2942 91 SWAP2 2943 90 SWAP1 2944 50 POP 2945 56 *JUMP // Stack delta = -3 // Outputs[1] { @2942 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2946: // Incoming call from 0x0334, returns to 0x0335 // Inputs[1] { @294B stack[-1] } 2946 5B JUMPDEST 2947 60 PUSH1 0x00 2949 60 PUSH1 0x20 294B 82 DUP3 294C 01 ADD 294D 90 SWAP1 294E 50 POP 294F 81 DUP2 2950 81 DUP2 2951 03 SUB 2952 60 PUSH1 0x00 2954 83 DUP4 2955 01 ADD 2956 52 MSTORE 2957 61 PUSH2 0x295f 295A 81 DUP2 295B 61 PUSH2 0x218a 295E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @294D stack[0] = stack[-1] + 0x20 // @2956 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2957 stack[1] = 0x295f // @295A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x218a, returns to 0x295F label_295F: // Incoming return from call to 0x218A at 0x295E // Inputs[4] // { // @2960 stack[-1] // @2960 stack[-2] // @2962 stack[-4] // @2963 stack[-3] // } 295F 5B JUMPDEST 2960 90 SWAP1 2961 50 POP 2962 91 SWAP2 2963 90 SWAP1 2964 50 POP 2965 56 *JUMP // Stack delta = -3 // Outputs[1] { @2962 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2966: // Incoming call from 0x0B0B, returns to 0x0B0C // Inputs[1] { @296B stack[-1] } 2966 5B JUMPDEST 2967 60 PUSH1 0x00 2969 60 PUSH1 0x20 296B 82 DUP3 296C 01 ADD 296D 90 SWAP1 296E 50 POP 296F 81 DUP2 2970 81 DUP2 2971 03 SUB 2972 60 PUSH1 0x00 2974 83 DUP4 2975 01 ADD 2976 52 MSTORE 2977 61 PUSH2 0x297f 297A 81 DUP2 297B 61 PUSH2 0x21f0 297E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @296D stack[0] = stack[-1] + 0x20 // @2976 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2977 stack[1] = 0x297f // @297A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x21f0, returns to 0x297F label_297F: // Incoming return from call to 0x21F0 at 0x297E // Inputs[4] // { // @2980 stack[-2] // @2980 stack[-1] // @2982 stack[-4] // @2983 stack[-3] // } 297F 5B JUMPDEST 2980 90 SWAP1 2981 50 POP 2982 91 SWAP2 2983 90 SWAP1 2984 50 POP 2985 56 *JUMP // Stack delta = -3 // Outputs[1] { @2982 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2986: // Incoming call from 0x156F, returns to 0x1570 // Inputs[1] { @298B stack[-1] } 2986 5B JUMPDEST 2987 60 PUSH1 0x00 2989 60 PUSH1 0x20 298B 82 DUP3 298C 01 ADD 298D 90 SWAP1 298E 50 POP 298F 81 DUP2 2990 81 DUP2 2991 03 SUB 2992 60 PUSH1 0x00 2994 83 DUP4 2995 01 ADD 2996 52 MSTORE 2997 61 PUSH2 0x299f 299A 81 DUP2 299B 61 PUSH2 0x2256 299E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @298D stack[0] = stack[-1] + 0x20 // @2996 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2997 stack[1] = 0x299f // @299A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2256, returns to 0x299F label_299F: // Incoming return from call to 0x2256 at 0x299E // Inputs[4] // { // @29A0 stack[-1] // @29A0 stack[-2] // @29A2 stack[-4] // @29A3 stack[-3] // } 299F 5B JUMPDEST 29A0 90 SWAP1 29A1 50 POP 29A2 91 SWAP2 29A3 90 SWAP1 29A4 50 POP 29A5 56 *JUMP // Stack delta = -3 // Outputs[1] { @29A2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_29A6: // Incoming call from 0x1074, returns to 0x1075 // Inputs[1] { @29AB stack[-1] } 29A6 5B JUMPDEST 29A7 60 PUSH1 0x00 29A9 60 PUSH1 0x20 29AB 82 DUP3 29AC 01 ADD 29AD 90 SWAP1 29AE 50 POP 29AF 81 DUP2 29B0 81 DUP2 29B1 03 SUB 29B2 60 PUSH1 0x00 29B4 83 DUP4 29B5 01 ADD 29B6 52 MSTORE 29B7 61 PUSH2 0x29bf 29BA 81 DUP2 29BB 61 PUSH2 0x2296 29BE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @29AD stack[0] = stack[-1] + 0x20 // @29B6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @29B7 stack[1] = 0x29bf // @29BA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2296, returns to 0x29BF label_29BF: // Incoming return from call to 0x2296 at 0x29BE // Inputs[4] // { // @29C0 stack[-2] // @29C0 stack[-1] // @29C2 stack[-4] // @29C3 stack[-3] // } 29BF 5B JUMPDEST 29C0 90 SWAP1 29C1 50 POP 29C2 91 SWAP2 29C3 90 SWAP1 29C4 50 POP 29C5 56 *JUMP // Stack delta = -3 // Outputs[1] { @29C2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_29C6: // Incoming call from 0x06B3, returns to 0x06B4 // Incoming call from 0x0FE7, returns to 0x0FE8 // Inputs[1] { @29CB stack[-1] } 29C6 5B JUMPDEST 29C7 60 PUSH1 0x00 29C9 60 PUSH1 0x20 29CB 82 DUP3 29CC 01 ADD 29CD 90 SWAP1 29CE 50 POP 29CF 81 DUP2 29D0 81 DUP2 29D1 03 SUB 29D2 60 PUSH1 0x00 29D4 83 DUP4 29D5 01 ADD 29D6 52 MSTORE 29D7 61 PUSH2 0x29df 29DA 81 DUP2 29DB 61 PUSH2 0x22fc 29DE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @29CD stack[0] = stack[-1] + 0x20 // @29D6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @29D7 stack[1] = 0x29df // @29DA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x22fc, returns to 0x29DF label_29DF: // Incoming return from call to 0x22FC at 0x29DE // Inputs[4] // { // @29E0 stack[-1] // @29E0 stack[-2] // @29E2 stack[-4] // @29E3 stack[-3] // } 29DF 5B JUMPDEST 29E0 90 SWAP1 29E1 50 POP 29E2 91 SWAP2 29E3 90 SWAP1 29E4 50 POP 29E5 56 *JUMP // Stack delta = -3 // Outputs[1] { @29E2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_29E6: // Incoming call from 0x0740, returns to 0x0741 // Inputs[1] { @29EB stack[-1] } 29E6 5B JUMPDEST 29E7 60 PUSH1 0x00 29E9 60 PUSH1 0x20 29EB 82 DUP3 29EC 01 ADD 29ED 90 SWAP1 29EE 50 POP 29EF 81 DUP2 29F0 81 DUP2 29F1 03 SUB 29F2 60 PUSH1 0x00 29F4 83 DUP4 29F5 01 ADD 29F6 52 MSTORE 29F7 61 PUSH2 0x29ff 29FA 81 DUP2 29FB 61 PUSH2 0x2362 29FE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @29ED stack[0] = stack[-1] + 0x20 // @29F6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @29F7 stack[1] = 0x29ff // @29FA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2362, returns to 0x29FF label_29FF: // Incoming return from call to 0x2362 at 0x29FE // Inputs[4] // { // @2A00 stack[-2] // @2A00 stack[-1] // @2A02 stack[-4] // @2A03 stack[-3] // } 29FF 5B JUMPDEST 2A00 90 SWAP1 2A01 50 POP 2A02 91 SWAP2 2A03 90 SWAP1 2A04 50 POP 2A05 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A02 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A06: // Incoming call from 0x0D46, returns to 0x0D47 // Inputs[1] { @2A0B stack[-1] } 2A06 5B JUMPDEST 2A07 60 PUSH1 0x00 2A09 60 PUSH1 0x20 2A0B 82 DUP3 2A0C 01 ADD 2A0D 90 SWAP1 2A0E 50 POP 2A0F 81 DUP2 2A10 81 DUP2 2A11 03 SUB 2A12 60 PUSH1 0x00 2A14 83 DUP4 2A15 01 ADD 2A16 52 MSTORE 2A17 61 PUSH2 0x2a1f 2A1A 81 DUP2 2A1B 61 PUSH2 0x23c8 2A1E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2A0D stack[0] = stack[-1] + 0x20 // @2A16 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2A17 stack[1] = 0x2a1f // @2A1A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x23c8, returns to 0x2A1F label_2A1F: // Incoming return from call to 0x23C8 at 0x2A1E // Inputs[4] // { // @2A20 stack[-1] // @2A20 stack[-2] // @2A22 stack[-4] // @2A23 stack[-3] // } 2A1F 5B JUMPDEST 2A20 90 SWAP1 2A21 50 POP 2A22 91 SWAP2 2A23 90 SWAP1 2A24 50 POP 2A25 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A22 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A26: // Incoming call from 0x05B9, returns to 0x05BA // Inputs[1] { @2A2B stack[-1] } 2A26 5B JUMPDEST 2A27 60 PUSH1 0x00 2A29 60 PUSH1 0x20 2A2B 82 DUP3 2A2C 01 ADD 2A2D 90 SWAP1 2A2E 50 POP 2A2F 81 DUP2 2A30 81 DUP2 2A31 03 SUB 2A32 60 PUSH1 0x00 2A34 83 DUP4 2A35 01 ADD 2A36 52 MSTORE 2A37 61 PUSH2 0x2a3f 2A3A 81 DUP2 2A3B 61 PUSH2 0x246e 2A3E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2A2D stack[0] = stack[-1] + 0x20 // @2A36 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2A37 stack[1] = 0x2a3f // @2A3A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x246e, returns to 0x2A3F label_2A3F: // Incoming return from call to 0x246E at 0x2A3E // Inputs[4] // { // @2A40 stack[-2] // @2A40 stack[-1] // @2A42 stack[-4] // @2A43 stack[-3] // } 2A3F 5B JUMPDEST 2A40 90 SWAP1 2A41 50 POP 2A42 91 SWAP2 2A43 90 SWAP1 2A44 50 POP 2A45 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A42 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A46: // Incoming call from 0x0DD8, returns to 0x0DD9 // Inputs[1] { @2A4B stack[-1] } 2A46 5B JUMPDEST 2A47 60 PUSH1 0x00 2A49 60 PUSH1 0x20 2A4B 82 DUP3 2A4C 01 ADD 2A4D 90 SWAP1 2A4E 50 POP 2A4F 81 DUP2 2A50 81 DUP2 2A51 03 SUB 2A52 60 PUSH1 0x00 2A54 83 DUP4 2A55 01 ADD 2A56 52 MSTORE 2A57 61 PUSH2 0x2a5f 2A5A 81 DUP2 2A5B 61 PUSH2 0x24d4 2A5E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2A4D stack[0] = stack[-1] + 0x20 // @2A56 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2A57 stack[1] = 0x2a5f // @2A5A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x24d4, returns to 0x2A5F label_2A5F: // Incoming return from call to 0x24D4 at 0x2A5E // Inputs[4] // { // @2A60 stack[-1] // @2A60 stack[-2] // @2A62 stack[-4] // @2A63 stack[-3] // } 2A5F 5B JUMPDEST 2A60 90 SWAP1 2A61 50 POP 2A62 91 SWAP2 2A63 90 SWAP1 2A64 50 POP 2A65 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A62 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A66: // Incoming call from 0x0A2D, returns to 0x0A2E // Inputs[1] { @2A6B stack[-1] } 2A66 5B JUMPDEST 2A67 60 PUSH1 0x00 2A69 60 PUSH1 0x20 2A6B 82 DUP3 2A6C 01 ADD 2A6D 90 SWAP1 2A6E 50 POP 2A6F 81 DUP2 2A70 81 DUP2 2A71 03 SUB 2A72 60 PUSH1 0x00 2A74 83 DUP4 2A75 01 ADD 2A76 52 MSTORE 2A77 61 PUSH2 0x2a7f 2A7A 81 DUP2 2A7B 61 PUSH2 0x253a 2A7E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2A6D stack[0] = stack[-1] + 0x20 // @2A76 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2A77 stack[1] = 0x2a7f // @2A7A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x253a, returns to 0x2A7F label_2A7F: // Incoming return from call to 0x253A at 0x2A7E // Inputs[4] // { // @2A80 stack[-1] // @2A80 stack[-2] // @2A82 stack[-4] // @2A83 stack[-3] // } 2A7F 5B JUMPDEST 2A80 90 SWAP1 2A81 50 POP 2A82 91 SWAP2 2A83 90 SWAP1 2A84 50 POP 2A85 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A82 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A86: // Incoming call from 0x0643, returns to 0x0644 // Inputs[1] { @2A8B stack[-1] } 2A86 5B JUMPDEST 2A87 60 PUSH1 0x00 2A89 60 PUSH1 0x20 2A8B 82 DUP3 2A8C 01 ADD 2A8D 90 SWAP1 2A8E 50 POP 2A8F 81 DUP2 2A90 81 DUP2 2A91 03 SUB 2A92 60 PUSH1 0x00 2A94 83 DUP4 2A95 01 ADD 2A96 52 MSTORE 2A97 61 PUSH2 0x2a9f 2A9A 81 DUP2 2A9B 61 PUSH2 0x25a0 2A9E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2A8D stack[0] = stack[-1] + 0x20 // @2A96 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2A97 stack[1] = 0x2a9f // @2A9A stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x25a0, returns to 0x2A9F label_2A9F: // Incoming return from call to 0x25A0 at 0x2A9E // Inputs[4] // { // @2AA0 stack[-1] // @2AA0 stack[-2] // @2AA2 stack[-4] // @2AA3 stack[-3] // } 2A9F 5B JUMPDEST 2AA0 90 SWAP1 2AA1 50 POP 2AA2 91 SWAP2 2AA3 90 SWAP1 2AA4 50 POP 2AA5 56 *JUMP // Stack delta = -3 // Outputs[1] { @2AA2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2AA6: // Incoming call from 0x1342, returns to 0x1343 // Inputs[1] { @2AAB stack[-1] } 2AA6 5B JUMPDEST 2AA7 60 PUSH1 0x00 2AA9 60 PUSH1 0x20 2AAB 82 DUP3 2AAC 01 ADD 2AAD 90 SWAP1 2AAE 50 POP 2AAF 81 DUP2 2AB0 81 DUP2 2AB1 03 SUB 2AB2 60 PUSH1 0x00 2AB4 83 DUP4 2AB5 01 ADD 2AB6 52 MSTORE 2AB7 61 PUSH2 0x2abf 2ABA 81 DUP2 2ABB 61 PUSH2 0x2606 2ABE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2AAD stack[0] = stack[-1] + 0x20 // @2AB6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2AB7 stack[1] = 0x2abf // @2ABA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2606, returns to 0x2ABF label_2ABF: // Incoming return from call to 0x2606 at 0x2ABE // Inputs[4] // { // @2AC0 stack[-1] // @2AC0 stack[-2] // @2AC2 stack[-4] // @2AC3 stack[-3] // } 2ABF 5B JUMPDEST 2AC0 90 SWAP1 2AC1 50 POP 2AC2 91 SWAP2 2AC3 90 SWAP1 2AC4 50 POP 2AC5 56 *JUMP // Stack delta = -3 // Outputs[1] { @2AC2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2AC6: // Incoming call from 0x0502, returns to 0x0503 // Inputs[1] { @2ACB stack[-1] } 2AC6 5B JUMPDEST 2AC7 60 PUSH1 0x00 2AC9 60 PUSH1 0x20 2ACB 82 DUP3 2ACC 01 ADD 2ACD 90 SWAP1 2ACE 50 POP 2ACF 81 DUP2 2AD0 81 DUP2 2AD1 03 SUB 2AD2 60 PUSH1 0x00 2AD4 83 DUP4 2AD5 01 ADD 2AD6 52 MSTORE 2AD7 61 PUSH2 0x2adf 2ADA 81 DUP2 2ADB 61 PUSH2 0x266c 2ADE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2ACD stack[0] = stack[-1] + 0x20 // @2AD6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2AD7 stack[1] = 0x2adf // @2ADA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x266c, returns to 0x2ADF label_2ADF: // Incoming return from call to 0x266C at 0x2ADE // Inputs[4] // { // @2AE0 stack[-2] // @2AE0 stack[-1] // @2AE2 stack[-4] // @2AE3 stack[-3] // } 2ADF 5B JUMPDEST 2AE0 90 SWAP1 2AE1 50 POP 2AE2 91 SWAP2 2AE3 90 SWAP1 2AE4 50 POP 2AE5 56 *JUMP // Stack delta = -3 // Outputs[1] { @2AE2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2AE6: // Incoming call from 0x0CEE, returns to 0x0CEF // Inputs[1] { @2AEB stack[-1] } 2AE6 5B JUMPDEST 2AE7 60 PUSH1 0x00 2AE9 60 PUSH1 0x20 2AEB 82 DUP3 2AEC 01 ADD 2AED 90 SWAP1 2AEE 50 POP 2AEF 81 DUP2 2AF0 81 DUP2 2AF1 03 SUB 2AF2 60 PUSH1 0x00 2AF4 83 DUP4 2AF5 01 ADD 2AF6 52 MSTORE 2AF7 61 PUSH2 0x2aff 2AFA 81 DUP2 2AFB 61 PUSH2 0x26d2 2AFE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2AED stack[0] = stack[-1] + 0x20 // @2AF6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2AF7 stack[1] = 0x2aff // @2AFA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x26d2, returns to 0x2AFF label_2AFF: // Incoming return from call to 0x26D2 at 0x2AFE // Inputs[4] // { // @2B00 stack[-1] // @2B00 stack[-2] // @2B02 stack[-4] // @2B03 stack[-3] // } 2AFF 5B JUMPDEST 2B00 90 SWAP1 2B01 50 POP 2B02 91 SWAP2 2B03 90 SWAP1 2B04 50 POP 2B05 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B02 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2B06: // Incoming call from 0x00F9, returns to 0x00FA // Inputs[2] // { // @2B0B stack[-1] // @2B16 stack[-2] // } 2B06 5B JUMPDEST 2B07 60 PUSH1 0x00 2B09 60 PUSH1 0x20 2B0B 82 DUP3 2B0C 01 ADD 2B0D 90 SWAP1 2B0E 50 POP 2B0F 61 PUSH2 0x2b1b 2B12 60 PUSH1 0x00 2B14 83 DUP4 2B15 01 ADD 2B16 84 DUP5 2B17 61 PUSH2 0x2747 2B1A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2B0D stack[0] = stack[-1] + 0x20 // @2B0F stack[1] = 0x2b1b // @2B15 stack[2] = stack[-1] + 0x00 // @2B16 stack[3] = stack[-2] // } // Block ends with call to 0x2747, returns to 0x2B1B label_2B1B: // Incoming return from call to 0x2747 at 0x2B1A // Inputs[3] // { // @2B1C stack[-1] // @2B1C stack[-4] // @2B1D stack[-3] // } 2B1B 5B JUMPDEST 2B1C 92 SWAP3 2B1D 91 SWAP2 2B1E 50 POP 2B1F 50 POP 2B20 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B1C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2B21: // Incoming call from 0x14A4, returns to 0x14A5 // Incoming call from 0x12A5, returns to 0x12A6 // Inputs[2] // { // @2B26 stack[-1] // @2B31 stack[-3] // } 2B21 5B JUMPDEST 2B22 60 PUSH1 0x00 2B24 60 PUSH1 0x40 2B26 82 DUP3 2B27 01 ADD 2B28 90 SWAP1 2B29 50 POP 2B2A 61 PUSH2 0x2b36 2B2D 60 PUSH1 0x00 2B2F 83 DUP4 2B30 01 ADD 2B31 85 DUP6 2B32 61 PUSH2 0x2747 2B35 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2B28 stack[0] = stack[-1] + 0x40 // @2B2A stack[1] = 0x2b36 // @2B30 stack[2] = stack[-1] + 0x00 // @2B31 stack[3] = stack[-3] // } // Block ends with call to 0x2747, returns to 0x2B36 label_2B36: // Incoming return from call to 0x2747 at 0x2B35 // Inputs[2] // { // @2B3C stack[-2] // @2B3E stack[-3] // } 2B36 5B JUMPDEST 2B37 61 PUSH2 0x2b43 2B3A 60 PUSH1 0x20 2B3C 83 DUP4 2B3D 01 ADD 2B3E 84 DUP5 2B3F 61 PUSH2 0x2747 2B42 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B37 stack[0] = 0x2b43 // @2B3D stack[1] = stack[-2] + 0x20 // @2B3E stack[2] = stack[-3] // } // Block ends with call to 0x2747, returns to 0x2B43 label_2B43: // Incoming return from call to 0x2747 at 0x2B42 // Inputs[3] // { // @2B44 stack[-1] // @2B44 stack[-5] // @2B45 stack[-4] // } 2B43 5B JUMPDEST 2B44 93 SWAP4 2B45 92 SWAP3 2B46 50 POP 2B47 50 POP 2B48 50 POP 2B49 56 *JUMP // Stack delta = -4 // Outputs[1] { @2B44 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2B4A: // Incoming jump from 0x19DE // Incoming jump from 0x1A61 // Incoming jump from 0x1B38 // Inputs[2] // { // @2B4F memory[0x40:0x60] // @2B52 stack[-1] // } 2B4A 5B JUMPDEST 2B4B 60 PUSH1 0x00 2B4D 60 PUSH1 0x40 2B4F 51 MLOAD 2B50 90 SWAP1 2B51 50 POP 2B52 81 DUP2 2B53 81 DUP2 2B54 01 ADD 2B55 81 DUP2 2B56 81 DUP2 2B57 10 LT 2B58 67 PUSH8 0xffffffffffffffff 2B61 82 DUP3 2B62 11 GT 2B63 17 OR 2B64 15 ISZERO 2B65 61 PUSH2 0x2b6d 2B68 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B50 stack[0] = memory[0x40:0x60] // @2B54 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x2b6d, if !((memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff) | (memory[0x40:0x60] + stack[-1] < memory[0x40:0x60])) label_2B69: // Incoming jump from 0x2B68, if not !((memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff) | (memory[0x40:0x60] + stack[-1] < memory[0x40:0x60])) // Inputs[1] { @2B6C memory[0x00:0x00] } 2B69 60 PUSH1 0x00 2B6B 80 DUP1 2B6C FD *REVERT // Stack delta = +0 // Outputs[1] { @2B6C revert(memory[0x00:0x00]); } // Block terminates label_2B6D: // Incoming jump from 0x2B68, if !((memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff) | (memory[0x40:0x60] + stack[-1] < memory[0x40:0x60])) // Inputs[4] // { // @2B6E stack[-1] // @2B73 stack[-2] // @2B73 stack[-4] // @2B74 stack[-3] // } 2B6D 5B JUMPDEST 2B6E 80 DUP1 2B6F 60 PUSH1 0x40 2B71 52 MSTORE 2B72 50 POP 2B73 91 SWAP2 2B74 90 SWAP1 2B75 50 POP 2B76 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2B71 memory[0x40:0x60] = stack[-1] // @2B73 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_2B77: // Incoming call from 0x19D9, returns to 0x19DA // Inputs[1] { @2B83 stack[-1] } 2B77 5B JUMPDEST 2B78 60 PUSH1 0x00 2B7A 67 PUSH8 0xffffffffffffffff 2B83 82 DUP3 2B84 11 GT 2B85 15 ISZERO 2B86 61 PUSH2 0x2b8e 2B89 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B78 stack[0] = 0x00 } // Block ends with conditional jump to 0x2b8e, if !(stack[-1] > 0xffffffffffffffff) label_2B8A: // Incoming jump from 0x2B89, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @2B8D memory[0x00:0x00] } 2B8A 60 PUSH1 0x00 2B8C 80 DUP1 2B8D FD *REVERT // Stack delta = +0 // Outputs[1] { @2B8D revert(memory[0x00:0x00]); } // Block terminates label_2B8E: // Incoming jump from 0x2B89, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @2B91 stack[-2] // @2B93 stack[-1] // @2B9B stack[-3] // } 2B8E 5B JUMPDEST 2B8F 60 PUSH1 0x20 2B91 82 DUP3 2B92 02 MUL 2B93 90 SWAP1 2B94 50 POP 2B95 60 PUSH1 0x20 2B97 81 DUP2 2B98 01 ADD 2B99 90 SWAP1 2B9A 50 POP 2B9B 91 SWAP2 2B9C 90 SWAP1 2B9D 50 POP 2B9E 56 *JUMP // Stack delta = -2 // Outputs[1] { @2B9B stack[-3] = stack[-2] * 0x20 + 0x20 } // Block ends with unconditional jump to stack[-3] label_2B9F: // Incoming call from 0x1A5C, returns to 0x1A5D // Inputs[1] { @2BAB stack[-1] } 2B9F 5B JUMPDEST 2BA0 60 PUSH1 0x00 2BA2 67 PUSH8 0xffffffffffffffff 2BAB 82 DUP3 2BAC 11 GT 2BAD 15 ISZERO 2BAE 61 PUSH2 0x2bb6 2BB1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BA0 stack[0] = 0x00 } // Block ends with conditional jump to 0x2bb6, if !(stack[-1] > 0xffffffffffffffff) label_2BB2: // Incoming jump from 0x2BB1, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @2BB5 memory[0x00:0x00] } 2BB2 60 PUSH1 0x00 2BB4 80 DUP1 2BB5 FD *REVERT // Stack delta = +0 // Outputs[1] { @2BB5 revert(memory[0x00:0x00]); } // Block terminates label_2BB6: // Incoming jump from 0x2BB1, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @2BB9 stack[-2] // @2BBB stack[-1] // @2BC3 stack[-3] // } 2BB6 5B JUMPDEST 2BB7 60 PUSH1 0x20 2BB9 82 DUP3 2BBA 02 MUL 2BBB 90 SWAP1 2BBC 50 POP 2BBD 60 PUSH1 0x20 2BBF 81 DUP2 2BC0 01 ADD 2BC1 90 SWAP1 2BC2 50 POP 2BC3 91 SWAP2 2BC4 90 SWAP1 2BC5 50 POP 2BC6 56 *JUMP // Stack delta = -2 // Outputs[1] { @2BC3 stack[-3] = stack[-2] * 0x20 + 0x20 } // Block ends with unconditional jump to stack[-3] label_2BC7: // Incoming call from 0x1B33, returns to 0x1B34 // Inputs[1] { @2BD3 stack[-1] } 2BC7 5B JUMPDEST 2BC8 60 PUSH1 0x00 2BCA 67 PUSH8 0xffffffffffffffff 2BD3 82 DUP3 2BD4 11 GT 2BD5 15 ISZERO 2BD6 61 PUSH2 0x2bde 2BD9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BC8 stack[0] = 0x00 } // Block ends with conditional jump to 0x2bde, if !(stack[-1] > 0xffffffffffffffff) label_2BDA: // Incoming jump from 0x2BD9, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @2BDD memory[0x00:0x00] } 2BDA 60 PUSH1 0x00 2BDC 80 DUP1 2BDD FD *REVERT // Stack delta = +0 // Outputs[1] { @2BDD revert(memory[0x00:0x00]); } // Block terminates label_2BDE: // Incoming jump from 0x2BD9, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @2BE4 stack[-2] // @2BE7 stack[-1] // @2BEF stack[-3] // } 2BDE 5B JUMPDEST 2BDF 60 PUSH1 0x1f 2BE1 19 NOT 2BE2 60 PUSH1 0x1f 2BE4 83 DUP4 2BE5 01 ADD 2BE6 16 AND 2BE7 90 SWAP1 2BE8 50 POP 2BE9 60 PUSH1 0x20 2BEB 81 DUP2 2BEC 01 ADD 2BED 90 SWAP1 2BEE 50 POP 2BEF 91 SWAP2 2BF0 90 SWAP1 2BF1 50 POP 2BF2 56 *JUMP // Stack delta = -2 // Outputs[1] { @2BEF stack[-3] = (stack[-2] + 0x1f & ~0x1f) + 0x20 } // Block ends with unconditional jump to stack[-3] label_2BF3: // Incoming call from 0x1F61, returns to 0x1F62 // Inputs[2] // { // @2BF6 stack[-1] // @2BFF stack[-2] // } 2BF3 5B JUMPDEST 2BF4 60 PUSH1 0x00 2BF6 81 DUP2 2BF7 90 SWAP1 2BF8 50 POP 2BF9 60 PUSH1 0x20 2BFB 82 DUP3 2BFC 01 ADD 2BFD 90 SWAP1 2BFE 50 POP 2BFF 91 SWAP2 2C00 90 SWAP1 2C01 50 POP 2C02 56 *JUMP // Stack delta = -1 // Outputs[1] { @2BFF stack[-2] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-2] label_2C03: // Incoming call from 0x208A, returns to 0x208B // Inputs[3] // { // @2C06 stack[-1] // @2C11 memory[0x00:0x20] // @2C14 stack[-2] // } 2C03 5B JUMPDEST 2C04 60 PUSH1 0x00 2C06 81 DUP2 2C07 90 SWAP1 2C08 50 POP 2C09 81 DUP2 2C0A 60 PUSH1 0x00 2C0C 52 MSTORE 2C0D 60 PUSH1 0x20 2C0F 60 PUSH1 0x00 2C11 20 SHA3 2C12 90 SWAP1 2C13 50 POP 2C14 91 SWAP2 2C15 90 SWAP1 2C16 50 POP 2C17 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2C0C memory[0x00:0x20] = stack[-1] // @2C14 stack[-2] = keccak256(memory[0x00:0x20]) // } // Block ends with unconditional jump to stack[-2] label_2C18: // Incoming call from 0x1F4C, returns to 0x1F4D // Inputs[3] // { // @2C1B stack[-1] // @2C1C memory[stack[-1]:stack[-1] + 0x20] // @2C1F stack[-2] // } 2C18 5B JUMPDEST 2C19 60 PUSH1 0x00 2C1B 81 DUP2 2C1C 51 MLOAD 2C1D 90 SWAP1 2C1E 50 POP 2C1F 91 SWAP2 2C20 90 SWAP1 2C21 50 POP 2C22 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C1F stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_2C23: // Incoming call from 0x1FC8, returns to 0x1FC9 // Inputs[3] // { // @2C26 stack[-1] // @2C27 memory[stack[-1]:stack[-1] + 0x20] // @2C2A stack[-2] // } 2C23 5B JUMPDEST 2C24 60 PUSH1 0x00 2C26 81 DUP2 2C27 51 MLOAD 2C28 90 SWAP1 2C29 50 POP 2C2A 91 SWAP2 2C2B 90 SWAP1 2C2C 50 POP 2C2D 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C2A stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_2C2E: // Incoming call from 0x2001, returns to 0x2002 // Inputs[3] // { // @2C31 stack[-1] // @2C32 memory[stack[-1]:stack[-1] + 0x20] // @2C35 stack[-2] // } 2C2E 5B JUMPDEST 2C2F 60 PUSH1 0x00 2C31 81 DUP2 2C32 51 MLOAD 2C33 90 SWAP1 2C34 50 POP 2C35 91 SWAP2 2C36 90 SWAP1 2C37 50 POP 2C38 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C35 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_2C39: // Incoming call from 0x1F84, returns to 0x1F85 // Inputs[2] // { // @2C3E stack[-1] // @2C42 stack[-2] // } 2C39 5B JUMPDEST 2C3A 60 PUSH1 0x00 2C3C 60 PUSH1 0x20 2C3E 82 DUP3 2C3F 01 ADD 2C40 90 SWAP1 2C41 50 POP 2C42 91 SWAP2 2C43 90 SWAP1 2C44 50 POP 2C45 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C42 stack[-2] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-2] label_2C46: // Incoming call from 0x1F56, returns to 0x1F57 // Inputs[3] // { // @2C49 stack[-2] // @2C4A stack[-1] // @2C52 stack[-3] // } 2C46 5B JUMPDEST 2C47 60 PUSH1 0x00 2C49 82 DUP3 2C4A 82 DUP3 2C4B 52 MSTORE 2C4C 60 PUSH1 0x20 2C4E 82 DUP3 2C4F 01 ADD 2C50 90 SWAP1 2C51 50 POP 2C52 92 SWAP3 2C53 91 SWAP2 2C54 50 POP 2C55 50 POP 2C56 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2C4B memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2C52 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_2C57: // Incoming call from 0x1FD2, returns to 0x1FD3 // Inputs[3] // { // @2C5A stack[-2] // @2C5B stack[-1] // @2C63 stack[-3] // } 2C57 5B JUMPDEST 2C58 60 PUSH1 0x00 2C5A 82 DUP3 2C5B 82 DUP3 2C5C 52 MSTORE 2C5D 60 PUSH1 0x20 2C5F 82 DUP3 2C60 01 ADD 2C61 90 SWAP1 2C62 50 POP 2C63 92 SWAP3 2C64 91 SWAP2 2C65 50 POP 2C66 50 POP 2C67 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2C5C memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2C63 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_2C68: // Incoming call from 0x22A2, returns to 0x22A3 // Incoming call from 0x21FC, returns to 0x21FD // Incoming call from 0x26DE, returns to 0x26DF // Incoming call from 0x23D4, returns to 0x23D5 // Incoming call from 0x247A, returns to 0x247B // Incoming call from 0x2196, returns to 0x2197 // Incoming call from 0x200B, returns to 0x200C // Incoming call from 0x20CA, returns to 0x20CB // Incoming call from 0x2546, returns to 0x2547 // Incoming call from 0x2678, returns to 0x2679 // Incoming call from 0x2130, returns to 0x2131 // Incoming call from 0x2308, returns to 0x2309 // Incoming call from 0x2612, returns to 0x2613 // Incoming call from 0x25AC, returns to 0x25AD // Incoming call from 0x24E0, returns to 0x24E1 // Incoming call from 0x236E, returns to 0x236F // Incoming call from 0x2262, returns to 0x2263 // Inputs[3] // { // @2C6B stack[-2] // @2C6C stack[-1] // @2C74 stack[-3] // } 2C68 5B JUMPDEST 2C69 60 PUSH1 0x00 2C6B 82 DUP3 2C6C 82 DUP3 2C6D 52 MSTORE 2C6E 60 PUSH1 0x20 2C70 82 DUP3 2C71 01 ADD 2C72 90 SWAP1 2C73 50 POP 2C74 92 SWAP3 2C75 91 SWAP2 2C76 50 POP 2C77 50 POP 2C78 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2C6D memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2C74 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_2C79: // Incoming call from 0x243A, returns to 0x243B // Incoming call from 0x205D, returns to 0x205E // Incoming call from 0x207F, returns to 0x2080 // Inputs[3] // { // @2C7C stack[-1] // @2C7F stack[-3] // @2C80 stack[-2] // } 2C79 5B JUMPDEST 2C7A 60 PUSH1 0x00 2C7C 81 DUP2 2C7D 90 SWAP1 2C7E 50 POP 2C7F 92 SWAP3 2C80 91 SWAP2 2C81 50 POP 2C82 50 POP 2C83 56 *JUMP // Stack delta = -2 // Outputs[1] { @2C7F stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2C84: // Incoming call from 0x2E20, returns to 0x2E21 // Incoming call from 0x1F3B, returns to 0x1F3C // Inputs[1] { @2C8A stack[-1] } 2C84 5B JUMPDEST 2C85 60 PUSH1 0x00 2C87 61 PUSH2 0x2c8f 2C8A 82 DUP3 2C8B 61 PUSH2 0x2cd8 2C8E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C85 stack[0] = 0x00 // @2C87 stack[1] = 0x2c8f // @2C8A stack[2] = stack[-1] // } // Block ends with call to 0x2cd8, returns to 0x2C8F label_2C8F: // Incoming return from call to 0x2CD8 at 0x2C8E // Inputs[4] // { // @2C90 stack[-2] // @2C90 stack[-1] // @2C92 stack[-4] // @2C93 stack[-3] // } 2C8F 5B JUMPDEST 2C90 90 SWAP1 2C91 50 POP 2C92 91 SWAP2 2C93 90 SWAP1 2C94 50 POP 2C95 56 *JUMP // Stack delta = -3 // Outputs[1] { @2C92 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2C96: // Incoming call from 0x1FA8, returns to 0x1FA9 // Incoming call from 0x2E37, returns to 0x2E38 // Inputs[2] // { // @2C99 stack[-1] // @2C9E stack[-2] // } 2C96 5B JUMPDEST 2C97 60 PUSH1 0x00 2C99 81 DUP2 2C9A 15 ISZERO 2C9B 15 ISZERO 2C9C 90 SWAP1 2C9D 50 POP 2C9E 91 SWAP2 2C9F 90 SWAP1 2CA0 50 POP 2CA1 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C9E stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_2CA2: // Incoming call from 0x2E4E, returns to 0x2E4F // Incoming call from 0x1FB7, returns to 0x1FB8 // Inputs[2] // { // @2CA5 stack[-1] // @2CA8 stack[-2] // } 2CA2 5B JUMPDEST 2CA3 60 PUSH1 0x00 2CA5 81 DUP2 2CA6 90 SWAP1 2CA7 50 POP 2CA8 91 SWAP2 2CA9 90 SWAP1 2CAA 50 POP 2CAB 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CA8 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2CAC: // Incoming call from 0x2E65, returns to 0x2E66 // Inputs[2] // { // @2CD0 stack[-1] // @2CD4 stack[-2] // } 2CAC 5B JUMPDEST 2CAD 60 PUSH1 0x00 2CAF 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 2CD0 82 DUP3 2CD1 16 AND 2CD2 90 SWAP1 2CD3 50 POP 2CD4 91 SWAP2 2CD5 90 SWAP1 2CD6 50 POP 2CD7 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CD4 stack[-2] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_2CD8: // Incoming call from 0x2C8E, returns to 0x2C8F // Inputs[2] // { // @2CF0 stack[-1] // @2CF4 stack[-2] // } 2CD8 5B JUMPDEST 2CD9 60 PUSH1 0x00 2CDB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CF0 82 DUP3 2CF1 16 AND 2CF2 90 SWAP1 2CF3 50 POP 2CF4 91 SWAP2 2CF5 90 SWAP1 2CF6 50 POP 2CF7 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CF4 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_2CF8: // Incoming call from 0x2E7C, returns to 0x2E7D // Incoming call from 0x2740, returns to 0x2741 // Incoming call from 0x274F, returns to 0x2750 // Inputs[2] // { // @2CFB stack[-1] // @2CFE stack[-2] // } 2CF8 5B JUMPDEST 2CF9 60 PUSH1 0x00 2CFB 81 DUP2 2CFC 90 SWAP1 2CFD 50 POP 2CFE 91 SWAP2 2CFF 90 SWAP1 2D00 50 POP 2D01 56 *JUMP // Stack delta = -1 // Outputs[1] { @2CFE stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2D02: // Incoming call from 0x1B5F, returns to 0x1B60 // Inputs[5] // { // @2D03 stack[-3] // @2D04 stack[-1] // @2D05 stack[-2] // @2D06 msg.data[stack[-1]:stack[-1] + stack[-3]] // @2D10 stack[-4] // } 2D02 5B JUMPDEST 2D03 82 DUP3 2D04 81 DUP2 2D05 83 DUP4 2D06 37 CALLDATACOPY 2D07 60 PUSH1 0x00 2D09 83 DUP4 2D0A 83 DUP4 2D0B 01 ADD 2D0C 52 MSTORE 2D0D 50 POP 2D0E 50 POP 2D0F 50 POP 2D10 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2D06 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @2D0C memory[stack[-2] + stack[-3]:stack[-2] + stack[-3] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_2D11: // Incoming call from 0x1FE2, returns to 0x1FE3 // Incoming call from 0x201B, returns to 0x201C // Inputs[1] { @2D15 stack[-3] } 2D11 5B JUMPDEST 2D12 60 PUSH1 0x00 2D14 5B JUMPDEST 2D15 83 DUP4 2D16 81 DUP2 2D17 10 LT 2D18 15 ISZERO 2D19 61 PUSH2 0x2d2f 2D1C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D12 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d2f, if !(0x00 < stack[-3]) label_2D1D: // Incoming jump from 0x2D1C, if not !(0x00 < stack[-3]) // Incoming jump from 0x2D1C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2D1D stack[-1] // @2D1E stack[-2] // @2D20 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2D22 stack[-3] // } 2D1D 80 DUP1 2D1E 82 DUP3 2D1F 01 ADD 2D20 51 MLOAD 2D21 81 DUP2 2D22 84 DUP5 2D23 01 ADD 2D24 52 MSTORE 2D25 60 PUSH1 0x20 2D27 81 DUP2 2D28 01 ADD 2D29 90 SWAP1 2D2A 50 POP 2D2B 61 PUSH2 0x2d14 2D2E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2D24 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2D29 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2d14 label_2D2F: // Incoming jump from 0x2D1C, if !(0x00 < stack[-3]) // Incoming jump from 0x2D1C, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2D30 stack[-4] // @2D31 stack[-1] // } 2D2F 5B JUMPDEST 2D30 83 DUP4 2D31 81 DUP2 2D32 11 GT 2D33 15 ISZERO 2D34 61 PUSH2 0x2d3e 2D37 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d3e, if !(stack[-1] > stack[-4]) label_2D38: // Incoming jump from 0x2D37, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2D3A stack[-4] // @2D3B stack[-3] // @2D43 stack[-5] // } 2D38 60 PUSH1 0x00 2D3A 84 DUP5 2D3B 84 DUP5 2D3C 01 ADD 2D3D 52 MSTORE 2D3E 5B JUMPDEST 2D3F 50 POP 2D40 50 POP 2D41 50 POP 2D42 50 POP 2D43 56 *JUMP // Stack delta = -5 // Outputs[1] { @2D3D memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2D44: // Incoming call from 0x2E02, returns to 0x2E03 // Incoming call from 0x2024, returns to 0x2025 // Incoming call from 0x1FEB, returns to 0x1FEC // Inputs[2] // { // @2D4C stack[-1] // @2D51 stack[-2] // } 2D44 5B JUMPDEST 2D45 60 PUSH1 0x00 2D47 60 PUSH1 0x1f 2D49 19 NOT 2D4A 60 PUSH1 0x1f 2D4C 83 DUP4 2D4D 01 ADD 2D4E 16 AND 2D4F 90 SWAP1 2D50 50 POP 2D51 91 SWAP2 2D52 90 SWAP1 2D53 50 POP 2D54 56 *JUMP // Stack delta = -1 // Outputs[1] { @2D51 stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_2D55: // Incoming call from 0x2D82, returns to 0x2D83 // Inputs[2] // { // @2D58 stack[-1] // @2D5E stack[-2] // } 2D55 5B JUMPDEST 2D56 60 PUSH1 0x00 2D58 81 DUP2 2D59 60 PUSH1 0xe0 2D5B 1C SHR 2D5C 90 SWAP1 2D5D 50 POP 2D5E 91 SWAP2 2D5F 90 SWAP1 2D60 50 POP 2D61 56 *JUMP // Stack delta = -1 // Outputs[1] { @2D5E stack[-2] = stack[-1] >> 0xe0 } // Block ends with unconditional jump to stack[-2] label_2D62: // Incoming call from 0x163E, returns to 0x163F // Incoming call from 0x187E, returns to 0x187F // Inputs[1] { @2D67 returndata.length } 2D62 5B JUMPDEST 2D63 60 PUSH1 0x00 2D65 60 PUSH1 0x44 2D67 3D RETURNDATASIZE 2D68 10 LT 2D69 15 ISZERO 2D6A 61 PUSH2 0x2d72 2D6D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D63 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d72, if !(returndata.length < 0x44) label_2D6E: // Incoming jump from 0x2D6D, if not !(returndata.length < 0x44) 2D6E 61 PUSH2 0x2e15 2D71 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2e15 label_2D72: // Incoming jump from 0x2D6D, if !(returndata.length < 0x44) // Inputs[2] // { // @2D78 returndata[0x00:0x04] // @2D7E memory[0x00:0x20] // } 2D72 5B JUMPDEST 2D73 60 PUSH1 0x04 2D75 60 PUSH1 0x00 2D77 80 DUP1 2D78 3E RETURNDATACOPY 2D79 61 PUSH2 0x2d83 2D7C 60 PUSH1 0x00 2D7E 51 MLOAD 2D7F 61 PUSH2 0x2d55 2D82 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2D78 memory[0x00:0x04] = returndata[0x00:0x04] // @2D79 stack[0] = 0x2d83 // @2D7E stack[1] = memory[0x00:0x20] // } // Block ends with call to 0x2d55, returns to 0x2D83 label_2D83: // Incoming return from call to 0x2D55 at 0x2D82 // Inputs[1] { @2D89 stack[-1] } 2D83 5B JUMPDEST 2D84 63 PUSH4 0x08c379a0 2D89 81 DUP2 2D8A 14 EQ 2D8B 61 PUSH2 0x2d94 2D8E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d94, if stack[-1] == 0x08c379a0 label_2D8F: // Incoming jump from 0x2D8E, if not stack[-1] == 0x08c379a0 2D8F 50 POP 2D90 61 PUSH2 0x2e15 2D93 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x2e15 label_2D94: // Incoming jump from 0x2D8E, if stack[-1] == 0x08c379a0 // Inputs[5] // { // @2D97 memory[0x40:0x60] // @2D9A returndata.length // @2D9F returndata[0x04:0x04 + returndata.length - 0x04] // @2DA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2DA2 returndata.length // } 2D94 5B JUMPDEST 2D95 60 PUSH1 0x40 2D97 51 MLOAD 2D98 60 PUSH1 0x04 2D9A 3D RETURNDATASIZE 2D9B 03 SUB 2D9C 60 PUSH1 0x04 2D9E 82 DUP3 2D9F 3E RETURNDATACOPY 2DA0 80 DUP1 2DA1 51 MLOAD 2DA2 3D RETURNDATASIZE 2DA3 60 PUSH1 0x24 2DA5 82 DUP3 2DA6 01 ADD 2DA7 11 GT 2DA8 67 PUSH8 0xffffffffffffffff 2DB1 82 DUP3 2DB2 11 GT 2DB3 17 OR 2DB4 15 ISZERO 2DB5 61 PUSH2 0x2dc0 2DB8 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2D97 stack[0] = memory[0x40:0x60] // @2D9F memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length - 0x04] = returndata[0x04:0x04 + returndata.length - 0x04] // @2DA1 stack[1] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } // Block ends with conditional jump to 0x2dc0, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_2DB9: // Incoming jump from 0x2DB8, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) 2DB9 50 POP 2DBA 50 POP 2DBB 50 POP 2DBC 61 PUSH2 0x2e15 2DBF 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to 0x2e15 label_2DC0: // Incoming jump from 0x2DB8, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[3] // { // @2DC1 stack[-1] // @2DC2 stack[-2] // @2DC5 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // } 2DC0 5B JUMPDEST 2DC1 80 DUP1 2DC2 82 DUP3 2DC3 01 ADD 2DC4 80 DUP1 2DC5 51 MLOAD 2DC6 67 PUSH8 0xffffffffffffffff 2DCF 81 DUP2 2DD0 11 GT 2DD1 15 ISZERO 2DD2 61 PUSH2 0x2ddf 2DD5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2DC3 stack[0] = stack[-2] + stack[-1] // @2DC5 stack[1] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x2ddf, if !(memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] > 0xffffffffffffffff) label_2DD6: // Incoming jump from 0x2DD5, if not !(memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] > 0xffffffffffffffff) 2DD6 50 POP 2DD7 50 POP 2DD8 50 POP 2DD9 50 POP 2DDA 50 POP 2DDB 61 PUSH2 0x2e15 2DDE 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x2e15 label_2DDF: // Incoming jump from 0x2DD5, if !(memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @2DE0 stack[-1] // @2DE3 stack[-2] // @2DE6 returndata.length // @2DE7 stack[-4] // } 2DDF 5B JUMPDEST 2DE0 80 DUP1 2DE1 60 PUSH1 0x20 2DE3 83 DUP4 2DE4 01 ADD 2DE5 01 ADD 2DE6 3D RETURNDATASIZE 2DE7 85 DUP6 2DE8 01 ADD 2DE9 81 DUP2 2DEA 11 GT 2DEB 15 ISZERO 2DEC 61 PUSH2 0x2dfa 2DEF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2DE5 stack[0] = stack[-2] + 0x20 + stack[-1] } // Block ends with conditional jump to 0x2dfa, if !(stack[-2] + 0x20 + stack[-1] > stack[-4] + returndata.length) label_2DF0: // Incoming jump from 0x2DEF, if not !(stack[-2] + 0x20 + stack[-1] > stack[-4] + returndata.length) 2DF0 50 POP 2DF1 50 POP 2DF2 50 POP 2DF3 50 POP 2DF4 50 POP 2DF5 50 POP 2DF6 61 PUSH2 0x2e15 2DF9 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to 0x2e15 label_2DFA: // Incoming jump from 0x2DEF, if !(stack[-2] + 0x20 + stack[-1] > stack[-4] + returndata.length) // Inputs[1] { @2DFE stack[-2] } 2DFA 5B JUMPDEST 2DFB 61 PUSH2 0x2e03 2DFE 82 DUP3 2DFF 61 PUSH2 0x2d44 2E02 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2DFB stack[0] = 0x2e03 // @2DFE stack[1] = stack[-2] // } // Block ends with call to 0x2d44, returns to 0x2E03 label_2E03: // Incoming return from call to 0x2D44 at 0x2E02 // Inputs[3] // { // @2E06 stack[-4] // @2E08 stack[-1] // @2E0D stack[-8] // } 2E03 5B JUMPDEST 2E04 60 PUSH1 0x20 2E06 84 DUP5 2E07 01 ADD 2E08 01 ADD 2E09 60 PUSH1 0x40 2E0B 52 MSTORE 2E0C 82 DUP3 2E0D 96 SWAP7 2E0E 50 POP 2E0F 50 POP 2E10 50 POP 2E11 50 POP 2E12 50 POP 2E13 50 POP 2E14 50 POP // Stack delta = -7 // Outputs[2] // { // @2E0B memory[0x40:0x60] = stack[-4] + 0x20 + stack[-1] // @2E0D stack[-8] = stack[-4] // } // Block continues label_2E15: // Incoming jump from 0x2DF9 // Incoming jump from 0x2D71 // Incoming jump from 0x2E14 // Incoming jump from 0x2DBF // Incoming jump from 0x2D93 // Incoming jump from 0x2DDE // Inputs[2] // { // @2E16 stack[-1] // @2E16 stack[-2] // } 2E15 5B JUMPDEST 2E16 90 SWAP1 2E17 56 *JUMP // Stack delta = -1 // Outputs[1] { @2E16 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2E18: // Incoming call from 0x19B4, returns to 0x19B5 // Inputs[1] { @2E1C stack[-1] } 2E18 5B JUMPDEST 2E19 61 PUSH2 0x2e21 2E1C 81 DUP2 2E1D 61 PUSH2 0x2c84 2E20 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2E19 stack[0] = 0x2e21 // @2E1C stack[1] = stack[-1] // } // Block ends with call to 0x2c84, returns to 0x2E21 label_2E21: // Incoming return from call to 0x2C84 at 0x2E20 // Inputs[2] // { // @2E22 stack[-2] // @2E23 stack[-1] // } 2E21 5B JUMPDEST 2E22 81 DUP2 2E23 14 EQ 2E24 61 PUSH2 0x2e2c 2E27 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e2c, if stack[-2] == stack[-1] label_2E28: // Incoming jump from 0x2E27, if not stack[-2] == stack[-1] // Inputs[1] { @2E2B memory[0x00:0x00] } 2E28 60 PUSH1 0x00 2E2A 80 DUP1 2E2B FD *REVERT // Stack delta = +0 // Outputs[1] { @2E2B revert(memory[0x00:0x00]); } // Block terminates label_2E2C: // Incoming jump from 0x2E27, if stack[-2] == stack[-1] // Inputs[1] { @2E2E stack[-2] } 2E2C 5B JUMPDEST 2E2D 50 POP 2E2E 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2E2F: // Incoming call from 0x1ACF, returns to 0x1AD0 // Inputs[1] { @2E33 stack[-1] } 2E2F 5B JUMPDEST 2E30 61 PUSH2 0x2e38 2E33 81 DUP2 2E34 61 PUSH2 0x2c96 2E37 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2E30 stack[0] = 0x2e38 // @2E33 stack[1] = stack[-1] // } // Block ends with call to 0x2c96, returns to 0x2E38 label_2E38: // Incoming return from call to 0x2C96 at 0x2E37 // Inputs[2] // { // @2E39 stack[-2] // @2E3A stack[-1] // } 2E38 5B JUMPDEST 2E39 81 DUP2 2E3A 14 EQ 2E3B 61 PUSH2 0x2e43 2E3E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e43, if stack[-2] == stack[-1] label_2E3F: // Incoming jump from 0x2E3E, if not stack[-2] == stack[-1] // Inputs[1] { @2E42 memory[0x00:0x00] } 2E3F 60 PUSH1 0x00 2E41 80 DUP1 2E42 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E42 revert(memory[0x00:0x00]); } // Block terminates label_2E43: // Incoming jump from 0x2E3E, if stack[-2] == stack[-1] // Inputs[1] { @2E45 stack[-2] } 2E43 5B JUMPDEST 2E44 50 POP 2E45 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2E46: // Incoming call from 0x1AE4, returns to 0x1AE5 // Inputs[1] { @2E4A stack[-1] } 2E46 5B JUMPDEST 2E47 61 PUSH2 0x2e4f 2E4A 81 DUP2 2E4B 61 PUSH2 0x2ca2 2E4E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2E47 stack[0] = 0x2e4f // @2E4A stack[1] = stack[-1] // } // Block ends with call to 0x2ca2, returns to 0x2E4F label_2E4F: // Incoming return from call to 0x2CA2 at 0x2E4E // Inputs[2] // { // @2E50 stack[-2] // @2E51 stack[-1] // } 2E4F 5B JUMPDEST 2E50 81 DUP2 2E51 14 EQ 2E52 61 PUSH2 0x2e5a 2E55 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e5a, if stack[-2] == stack[-1] label_2E56: // Incoming jump from 0x2E55, if not stack[-2] == stack[-1] // Inputs[1] { @2E59 memory[0x00:0x00] } 2E56 60 PUSH1 0x00 2E58 80 DUP1 2E59 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E59 revert(memory[0x00:0x00]); } // Block terminates label_2E5A: // Incoming jump from 0x2E55, if stack[-2] == stack[-1] // Inputs[1] { @2E5C stack[-2] } 2E5A 5B JUMPDEST 2E5B 50 POP 2E5C 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2E5D: // Incoming call from 0x1AF9, returns to 0x1AFA // Incoming call from 0x1B0E, returns to 0x1B0F // Inputs[1] { @2E61 stack[-1] } 2E5D 5B JUMPDEST 2E5E 61 PUSH2 0x2e66 2E61 81 DUP2 2E62 61 PUSH2 0x2cac 2E65 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2E5E stack[0] = 0x2e66 // @2E61 stack[1] = stack[-1] // } // Block ends with call to 0x2cac, returns to 0x2E66 label_2E66: // Incoming return from call to 0x2CAC at 0x2E65 // Inputs[2] // { // @2E67 stack[-2] // @2E68 stack[-1] // } 2E66 5B JUMPDEST 2E67 81 DUP2 2E68 14 EQ 2E69 61 PUSH2 0x2e71 2E6C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e71, if stack[-2] == stack[-1] label_2E6D: // Incoming jump from 0x2E6C, if not stack[-2] == stack[-1] // Inputs[1] { @2E70 memory[0x00:0x00] } 2E6D 60 PUSH1 0x00 2E6F 80 DUP1 2E70 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E70 revert(memory[0x00:0x00]); } // Block terminates label_2E71: // Incoming jump from 0x2E6C, if stack[-2] == stack[-1] // Inputs[1] { @2E73 stack[-2] } 2E71 5B JUMPDEST 2E72 50 POP 2E73 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2E74: // Incoming call from 0x1B77, returns to 0x1B78 // Inputs[1] { @2E78 stack[-1] } 2E74 5B JUMPDEST 2E75 61 PUSH2 0x2e7d 2E78 81 DUP2 2E79 61 PUSH2 0x2cf8 2E7C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2E75 stack[0] = 0x2e7d // @2E78 stack[1] = stack[-1] // } // Block ends with call to 0x2cf8, returns to 0x2E7D label_2E7D: // Incoming return from call to 0x2CF8 at 0x2E7C // Inputs[2] // { // @2E7E stack[-2] // @2E7F stack[-1] // } 2E7D 5B JUMPDEST 2E7E 81 DUP2 2E7F 14 EQ 2E80 61 PUSH2 0x2e88 2E83 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e88, if stack[-2] == stack[-1] label_2E84: // Incoming jump from 0x2E83, if not stack[-2] == stack[-1] // Inputs[1] { @2E87 memory[0x00:0x00] } 2E84 60 PUSH1 0x00 2E86 80 DUP1 2E87 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E87 revert(memory[0x00:0x00]); } // Block terminates label_2E88: // Incoming jump from 0x2E83, if stack[-2] == stack[-1] // Inputs[1] { @2E8A stack[-2] } 2E88 5B JUMPDEST 2E89 50 POP 2E8A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 2E8B FE *ASSERT 2E8C 45 GASLIMIT 2E8D 52 MSTORE 2E8E 43 NUMBER 2E8F 31 BALANCE 2E90 31 BALANCE 2E91 35 CALLDATALOAD 2E92 35 CALLDATALOAD 2E93 3A GASPRICE 2E94 20 SHA3 2E95 69 PUSH10 0x6e73756666696369656e 2EA0 74 PUSH21 0x2062616c616e636520666f72207472616e73666572 2EB6 A2 LOG2 2EB7 64 PUSH5 0x6970667358 2EBD 22 22 2EBE 12 SLT 2EBF 20 SHA3 2EC0 02 MUL 2EC1 44 DIFFICULTY 2EC2 ED ED 2EC3 7A PUSH27 0xd35b76642cde18eaae5783393d8fea05daba6d86ef2f209c093854 2EDF 87 DUP8 2EE0 64 PUSH5 0x736f6c6343 2EE6 00 *STOP 2EE7 06 MOD 2EE8 0B SIGNEXTEND 2EE9 00 *STOP 2EEA 33 CALLER
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]