Online Solidity Decompiler

« Decompile another contract

Address

0xd630cb8c3bbfd38d1880b8256ee06d168ee3859c [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x2e1a7d4d withdraw(uint256)
0x66d16cc3 profit()
0x8c0320de payforflag(string,string)
0x8e2a219e Unknown
0x9189fec1 guess(uint256)
0xa9059cbb transfer(address,uint256)
0xd41b6db6 Unknown
0xe3d670d7 balance(address)

Internal Methods

withdraw(arg0)
profit()
payforflag(arg0, arg1)
func_045C(arg0)
guess(arg0)
transfer(arg0, arg1)
func_0555(arg1) returns (r0)
balance(arg1) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x2e1a7d4d) { // Dispatch table entry for withdraw(uint256) var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00aa; var var2 = msg.data[0x04:0x24]; withdraw(var2); stop(); } else if (var0 == 0x66d16cc3) { // Dispatch table entry for profit() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00aa; profit(); stop(); } else if (var0 == 0x8c0320de) { // Dispatch table entry for payforflag(string,string) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; var temp1 = msg.data[0x04:0x24]; var temp2 = msg.data[temp1 + 0x04:temp1 + 0x04 + 0x20]; memory[0x40:0x60] = temp0 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp0:temp0 + 0x20] = temp2; var1 = 0x00aa; memory[temp0 + 0x20:temp0 + 0x20 + temp2] = msg.data[temp1 + 0x24:temp1 + 0x24 + temp2]; var temp3 = memory[0x40:0x60]; var temp4 = msg.data[0x24:0x44] + 0x04; var temp5 = msg.data[temp4:temp4 + 0x20]; memory[0x40:0x60] = temp3 + (temp5 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp3:temp3 + 0x20] = temp5; var2 = temp0; memory[temp3 + 0x20:temp3 + 0x20 + temp5] = msg.data[temp4 + 0x20:temp4 + 0x20 + temp5]; var var3 = temp3; payforflag(var2, var3); stop(); } else if (var0 == 0x8e2a219e) { // Dispatch table entry for 0x8e2a219e (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00aa; var2 = msg.data[0x04:0x24]; func_045C(var2); stop(); } else if (var0 == 0x9189fec1) { // Dispatch table entry for guess(uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00aa; var2 = msg.data[0x04:0x24]; guess(var2); stop(); } else if (var0 == 0xa9059cbb) { // Dispatch table entry for transfer(address,uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00aa; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44]; transfer(var2, var3); stop(); } else if (var0 == 0xd41b6db6) { // Dispatch table entry for 0xd41b6db6 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x01e7; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = func_0555(var2); label_01E7: var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var2; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + temp6 - temp7 + 0x20]; } else if (var0 == 0xe3d670d7) { // Dispatch table entry for balance(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x01e7; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = balance(var2); goto label_01E7; } else { revert(memory[0x00:0x00]); } } function withdraw(var arg0) { if (arg0 != 0x02) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (arg0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; var temp1 = arg0; memory[temp0:temp0 + 0x00] = address(msg.sender).call.gas(msg.gas).value(temp1 * 0x5af3107a4000)(memory[temp0:temp0 + 0x00]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp2 = keccak256(memory[0x00:0x40]); storage[temp2] = storage[temp2] - temp1; } function profit() { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x01; if (storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } if (msg.sender & 0xffff != 0xb1b1) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp0 = keccak256(memory[0x00:0x40]); storage[temp0] = storage[temp0] + 0x01; memory[0x20:0x40] = 0x01; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = storage[temp1] + 0x01; } function payforflag(var arg0, var arg1) { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (0x02540be400 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = 0x00; var temp0 = memory[0x40:0x60]; var temp1 = address(address(this)).balance; var temp2; temp2, memory[temp0:temp0 + 0x00] = address(storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp1 * 0x08fc).value(temp1)(memory[temp0:temp0 + 0x00]); var var0 = !temp2; if (!var0) { var0 = 0x6335b7f9c4dff99c3a870eaf18b802774df3aba4e21b72549f3a03b6bc974c90; var temp3 = arg0; var var1 = temp3; var var2 = arg1; var temp4 = memory[0x40:0x60]; var var3 = temp4; var var4 = var3; var var5 = var4 + 0x20; var temp5 = var5 + 0x20; memory[var4:var4 + 0x20] = temp5 - var4; memory[temp5:temp5 + 0x20] = memory[var1:var1 + 0x20]; var var6 = temp5 + 0x20; var var7 = var1 + 0x20; var var8 = memory[var1:var1 + 0x20]; var var9 = var8; var var10 = var6; var var11 = var7; var var12 = 0x00; if (var12 >= var9) { label_03BC: var temp6 = var8; var6 = temp6 + var6; var7 = temp6 & 0x1f; if (!var7) { var temp7 = var6; memory[var5:var5 + 0x20] = temp7 - var3; var temp8 = var2; memory[temp7:temp7 + 0x20] = memory[temp8:temp8 + 0x20]; var6 = temp7 + 0x20; var8 = memory[temp8:temp8 + 0x20]; var7 = temp8 + 0x20; var9 = var8; var10 = var6; var11 = var7; var12 = 0x00; if (var12 >= var9) { label_041C: var temp9 = var8; var6 = temp9 + var6; var7 = temp9 & 0x1f; if (!var7) { var temp10 = memory[0x40:0x60]; log(memory[temp10:temp10 + var6 - temp10], [stack[-8]]); return; } else { var temp11 = var7; var temp12 = var6 - temp11; memory[temp12:temp12 + 0x20] = ~(0x0100 ** (0x20 - temp11) - 0x01) & memory[temp12:temp12 + 0x20]; var temp13 = memory[0x40:0x60]; log(memory[temp13:temp13 + (temp12 + 0x20) - temp13], [stack[-8]]); return; } } else { label_040D: var temp14 = var12; memory[temp14 + var10:temp14 + var10 + 0x20] = memory[temp14 + var11:temp14 + var11 + 0x20]; var12 = temp14 + 0x20; if (var12 >= var9) { goto label_041C; } else { goto label_040D; } } } else { var temp15 = var7; var temp16 = var6 - temp15; memory[temp16:temp16 + 0x20] = ~(0x0100 ** (0x20 - temp15) - 0x01) & memory[temp16:temp16 + 0x20]; var temp17 = temp16 + 0x20; memory[var5:var5 + 0x20] = temp17 - var3; var temp18 = var2; memory[temp17:temp17 + 0x20] = memory[temp18:temp18 + 0x20]; var6 = temp17 + 0x20; var7 = temp18 + 0x20; var8 = memory[temp18:temp18 + 0x20]; var9 = var8; var10 = var6; var11 = var7; var12 = 0x00; if (var12 >= var9) { goto label_041C; } else { goto label_040D; } } } else { label_03AD: var temp19 = var12; memory[temp19 + var10:temp19 + var10 + 0x20] = memory[temp19 + var11:temp19 + var11 + 0x20]; var12 = temp19 + 0x20; if (var12 >= var9) { goto label_03BC; } else { goto label_03AD; } } } else { var temp20 = returndata.length; memory[0x00:0x00 + temp20] = returndata[0x00:0x00 + temp20]; revert(memory[0x00:0x00 + returndata.length]); } } function func_045C(var arg0) { if (msg.sender != storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } storage[0x03] = arg0; } function guess(var arg0) { if (arg0 != storage[0x03]) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x01; if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp0 = keccak256(memory[0x00:0x40]); storage[temp0] = storage[temp0] + 0x01; memory[0x20:0x40] = 0x01; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = storage[temp1] + 0x01; } function transfer(var arg0, var arg1) { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } if (arg1 != 0x02) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x01; if (storage[keccak256(memory[0x00:0x40])] != 0x02) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = 0x00; memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; storage[keccak256(memory[0x00:0x40])] = arg1; } function func_0555(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x01; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } function balance(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x00; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x008d 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x008d, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @0032 msg.data[0x00:0x20] } 000D 63 PUSH4 0xffffffff 0012 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0030 60 PUSH1 0x00 0032 35 CALLDATALOAD 0033 04 DIV 0034 16 AND 0035 63 PUSH4 0x2e1a7d4d 003A 81 DUP2 003B 14 EQ 003C 61 PUSH2 0x0092 003F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0034 stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff } // Block ends with conditional jump to 0x0092, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x2e1a7d4d label_0040: // Incoming jump from 0x003F, if not msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x2e1a7d4d // Inputs[1] { @0040 stack[-1] } 0040 80 DUP1 0041 63 PUSH4 0x66d16cc3 0046 14 EQ 0047 61 PUSH2 0x00ac 004A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ac, if 0x66d16cc3 == stack[-1] label_004B: // Incoming jump from 0x004A, if not 0x66d16cc3 == stack[-1] // Inputs[1] { @004B stack[-1] } 004B 80 DUP1 004C 63 PUSH4 0x8c0320de 0051 14 EQ 0052 61 PUSH2 0x00c1 0055 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c1, if 0x8c0320de == stack[-1] label_0056: // Incoming jump from 0x0055, if not 0x8c0320de == stack[-1] // Inputs[1] { @0056 stack[-1] } 0056 80 DUP1 0057 63 PUSH4 0x8e2a219e 005C 14 EQ 005D 61 PUSH2 0x0158 0060 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0158, if 0x8e2a219e == stack[-1] label_0061: // Incoming jump from 0x0060, if not 0x8e2a219e == stack[-1] // Inputs[1] { @0061 stack[-1] } 0061 80 DUP1 0062 63 PUSH4 0x9189fec1 0067 14 EQ 0068 61 PUSH2 0x0170 006B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0170, if 0x9189fec1 == stack[-1] label_006C: // Incoming jump from 0x006B, if not 0x9189fec1 == stack[-1] // Inputs[1] { @006C stack[-1] } 006C 80 DUP1 006D 63 PUSH4 0xa9059cbb 0072 14 EQ 0073 61 PUSH2 0x0188 0076 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0188, if 0xa9059cbb == stack[-1] label_0077: // Incoming jump from 0x0076, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0077 stack[-1] } 0077 80 DUP1 0078 63 PUSH4 0xd41b6db6 007D 14 EQ 007E 61 PUSH2 0x01b9 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b9, if 0xd41b6db6 == stack[-1] label_0082: // Incoming jump from 0x0081, if not 0xd41b6db6 == stack[-1] // Inputs[1] { @0082 stack[-1] } 0082 80 DUP1 0083 63 PUSH4 0xe3d670d7 0088 14 EQ 0089 61 PUSH2 0x01f9 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f9, if 0xe3d670d7 == stack[-1] label_008D: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x008C, if not 0xe3d670d7 == stack[-1] // Inputs[1] { @0091 memory[0x00:0x00] } 008D 5B JUMPDEST 008E 60 PUSH1 0x00 0090 80 DUP1 0091 FD *REVERT // Stack delta = +0 // Outputs[1] { @0091 revert(memory[0x00:0x00]); } // Block terminates label_0092: // Incoming jump from 0x003F, if msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff == 0x2e1a7d4d // Inputs[1] { @0093 msg.value } 0092 5B JUMPDEST 0093 34 CALLVALUE 0094 80 DUP1 0095 15 ISZERO 0096 61 PUSH2 0x009e 0099 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0093 stack[0] = msg.value } // Block ends with conditional jump to 0x009e, if !msg.value label_009A: // Incoming jump from 0x0099, if not !msg.value // Inputs[1] { @009D memory[0x00:0x00] } 009A 60 PUSH1 0x00 009C 80 DUP1 009D FD *REVERT // Stack delta = +0 // Outputs[1] { @009D revert(memory[0x00:0x00]); } // Block terminates label_009E: // Incoming jump from 0x0099, if !msg.value // Inputs[1] { @00A5 msg.data[0x04:0x24] } 009E 5B JUMPDEST 009F 50 POP 00A0 61 PUSH2 0x00aa 00A3 60 PUSH1 0x04 00A5 35 CALLDATALOAD 00A6 61 PUSH2 0x0227 00A9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @00A0 stack[-1] = 0x00aa // @00A5 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0227, returns to 0x00AA label_00AA: // Incoming return from call to 0x045C at 0x016F // Incoming return from call to 0x0227 at 0x00A9 // Incoming return from call to 0x0286 at 0x00C0 // Incoming return from call to 0x04DB at 0x01B8 // Incoming return from call to 0x02DC at 0x0157 // Incoming return from call to 0x0485 at 0x0187 00AA 5B JUMPDEST 00AB 00 *STOP // Stack delta = +0 // Outputs[1] { @00AB stop(); } // Block terminates label_00AC: // Incoming jump from 0x004A, if 0x66d16cc3 == stack[-1] // Inputs[1] { @00AD msg.value } 00AC 5B JUMPDEST 00AD 34 CALLVALUE 00AE 80 DUP1 00AF 15 ISZERO 00B0 61 PUSH2 0x00b8 00B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00AD stack[0] = msg.value } // Block ends with conditional jump to 0x00b8, if !msg.value label_00B4: // Incoming jump from 0x00B3, if not !msg.value // Inputs[1] { @00B7 memory[0x00:0x00] } 00B4 60 PUSH1 0x00 00B6 80 DUP1 00B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B7 revert(memory[0x00:0x00]); } // Block terminates label_00B8: // Incoming jump from 0x00B3, if !msg.value 00B8 5B JUMPDEST 00B9 50 POP 00BA 61 PUSH2 0x00aa 00BD 61 PUSH2 0x0286 00C0 56 *JUMP // Stack delta = +0 // Outputs[1] { @00BA stack[-1] = 0x00aa } // Block ends with call to 0x0286, returns to 0x00AA label_00C1: // Incoming jump from 0x0055, if 0x8c0320de == stack[-1] // Inputs[1] { @00C2 msg.value } 00C1 5B JUMPDEST 00C2 34 CALLVALUE 00C3 80 DUP1 00C4 15 ISZERO 00C5 61 PUSH2 0x00cd 00C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00C2 stack[0] = msg.value } // Block ends with conditional jump to 0x00cd, if !msg.value label_00C9: // Incoming jump from 0x00C8, if not !msg.value // Inputs[1] { @00CC memory[0x00:0x00] } 00C9 60 PUSH1 0x00 00CB 80 DUP1 00CC FD *REVERT // Stack delta = +0 // Outputs[1] { @00CC revert(memory[0x00:0x00]); } // Block terminates label_00CD: // Incoming jump from 0x00C8, if !msg.value // Inputs[9] // { // @00D2 memory[0x40:0x60] // @00D8 msg.data[0x04:0x24] // @00DC msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @00F4 msg.data.length // @0109 msg.data[0x24 + msg.data[0x04:0x24]:0x24 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @010F memory[0x40:0x60] // @0115 msg.data[0x24:0x44] // @0119 msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] // @0147 msg.data[0x20 + 0x04 + msg.data[0x24:0x44]:0x20 + 0x04 + msg.data[0x24:0x44] + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]] // } 00CD 5B JUMPDEST 00CE 50 POP 00CF 60 PUSH1 0x40 00D1 80 DUP1 00D2 51 MLOAD 00D3 60 PUSH1 0x20 00D5 60 PUSH1 0x04 00D7 80 DUP1 00D8 35 CALLDATALOAD 00D9 80 DUP1 00DA 82 DUP3 00DB 01 ADD 00DC 35 CALLDATALOAD 00DD 60 PUSH1 0x1f 00DF 81 DUP2 00E0 01 ADD 00E1 84 DUP5 00E2 90 SWAP1 00E3 04 DIV 00E4 84 DUP5 00E5 02 MUL 00E6 85 DUP6 00E7 01 ADD 00E8 84 DUP5 00E9 01 ADD 00EA 90 SWAP1 00EB 95 SWAP6 00EC 52 MSTORE 00ED 84 DUP5 00EE 84 DUP5 00EF 52 MSTORE 00F0 61 PUSH2 0x00aa 00F3 94 SWAP5 00F4 36 CALLDATASIZE 00F5 94 SWAP5 00F6 92 SWAP3 00F7 93 SWAP4 00F8 60 PUSH1 0x24 00FA 93 SWAP4 00FB 92 SWAP3 00FC 84 DUP5 00FD 01 ADD 00FE 91 SWAP2 00FF 90 SWAP1 0100 81 DUP2 0101 90 SWAP1 0102 84 DUP5 0103 01 ADD 0104 83 DUP4 0105 82 DUP3 0106 80 DUP1 0107 82 DUP3 0108 84 DUP5 0109 37 CALLDATACOPY 010A 50 POP 010B 50 POP 010C 60 PUSH1 0x40 010E 80 DUP1 010F 51 MLOAD 0110 60 PUSH1 0x20 0112 60 PUSH1 0x1f 0114 89 DUP10 0115 35 CALLDATALOAD 0116 8B DUP12 0117 01 ADD 0118 80 DUP1 0119 35 CALLDATALOAD 011A 91 SWAP2 011B 82 DUP3 011C 01 ADD 011D 83 DUP4 011E 90 SWAP1 011F 04 DIV 0120 83 DUP4 0121 02 MUL 0122 84 DUP5 0123 01 ADD 0124 83 DUP4 0125 01 ADD 0126 90 SWAP1 0127 94 SWAP5 0128 52 MSTORE 0129 80 DUP1 012A 83 DUP4 012B 52 MSTORE 012C 97 SWAP8 012D 9A SWAP11 012E 99 SWAP10 012F 98 SWAP9 0130 81 DUP2 0131 01 ADD 0132 97 SWAP8 0133 91 SWAP2 0134 96 SWAP7 0135 50 POP 0136 91 SWAP2 0137 82 DUP3 0138 01 ADD 0139 94 SWAP5 013A 50 POP 013B 92 SWAP3 013C 50 POP 013D 82 DUP3 013E 91 SWAP2 013F 50 POP 0140 84 DUP5 0141 01 ADD 0142 83 DUP4 0143 82 DUP3 0144 80 DUP1 0145 82 DUP3 0146 84 DUP5 0147 37 CALLDATACOPY 0148 50 POP 0149 94 SWAP5 014A 97 SWAP8 014B 50 POP 014C 61 PUSH2 0x02dc 014F 96 SWAP7 0150 50 POP 0151 50 POP 0152 50 POP 0153 50 POP 0154 50 POP 0155 50 POP 0156 50 POP 0157 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @00EC memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] + 0x1f) / 0x20) // @00EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @00F3 stack[-1] = 0x00aa // @0109 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x24 + msg.data[0x04:0x24]:0x24 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @0128 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] + 0x1f) / 0x20) // @012B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] // @012D stack[0] = memory[0x40:0x60] // @0147 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x24:0x44]:0x20 + 0x04 + msg.data[0x24:0x44] + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]] // @014A stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x02dc, returns to 0x00AA label_0158: // Incoming jump from 0x0060, if 0x8e2a219e == stack[-1] // Inputs[1] { @0159 msg.value } 0158 5B JUMPDEST 0159 34 CALLVALUE 015A 80 DUP1 015B 15 ISZERO 015C 61 PUSH2 0x0164 015F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0159 stack[0] = msg.value } // Block ends with conditional jump to 0x0164, if !msg.value label_0160: // Incoming jump from 0x015F, if not !msg.value // Inputs[1] { @0163 memory[0x00:0x00] } 0160 60 PUSH1 0x00 0162 80 DUP1 0163 FD *REVERT // Stack delta = +0 // Outputs[1] { @0163 revert(memory[0x00:0x00]); } // Block terminates label_0164: // Incoming jump from 0x015F, if !msg.value // Inputs[1] { @016B msg.data[0x04:0x24] } 0164 5B JUMPDEST 0165 50 POP 0166 61 PUSH2 0x00aa 0169 60 PUSH1 0x04 016B 35 CALLDATALOAD 016C 61 PUSH2 0x045c 016F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0166 stack[-1] = 0x00aa // @016B stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x045c, returns to 0x00AA label_0170: // Incoming jump from 0x006B, if 0x9189fec1 == stack[-1] // Inputs[1] { @0171 msg.value } 0170 5B JUMPDEST 0171 34 CALLVALUE 0172 80 DUP1 0173 15 ISZERO 0174 61 PUSH2 0x017c 0177 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0171 stack[0] = msg.value } // Block ends with conditional jump to 0x017c, if !msg.value label_0178: // Incoming jump from 0x0177, if not !msg.value // Inputs[1] { @017B memory[0x00:0x00] } 0178 60 PUSH1 0x00 017A 80 DUP1 017B FD *REVERT // Stack delta = +0 // Outputs[1] { @017B revert(memory[0x00:0x00]); } // Block terminates label_017C: // Incoming jump from 0x0177, if !msg.value // Inputs[1] { @0183 msg.data[0x04:0x24] } 017C 5B JUMPDEST 017D 50 POP 017E 61 PUSH2 0x00aa 0181 60 PUSH1 0x04 0183 35 CALLDATALOAD 0184 61 PUSH2 0x0485 0187 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @017E stack[-1] = 0x00aa // @0183 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x0485, returns to 0x00AA label_0188: // Incoming jump from 0x0076, if 0xa9059cbb == stack[-1] // Inputs[1] { @0189 msg.value } 0188 5B JUMPDEST 0189 34 CALLVALUE 018A 80 DUP1 018B 15 ISZERO 018C 61 PUSH2 0x0194 018F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0189 stack[0] = msg.value } // Block ends with conditional jump to 0x0194, if !msg.value label_0190: // Incoming jump from 0x018F, if not !msg.value // Inputs[1] { @0193 memory[0x00:0x00] } 0190 60 PUSH1 0x00 0192 80 DUP1 0193 FD *REVERT // Stack delta = +0 // Outputs[1] { @0193 revert(memory[0x00:0x00]); } // Block terminates label_0194: // Incoming jump from 0x018F, if !msg.value // Inputs[2] // { // @01B0 msg.data[0x04:0x24] // @01B4 msg.data[0x24:0x44] // } 0194 5B JUMPDEST 0195 50 POP 0196 61 PUSH2 0x00aa 0199 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01AE 60 PUSH1 0x04 01B0 35 CALLDATALOAD 01B1 16 AND 01B2 60 PUSH1 0x24 01B4 35 CALLDATALOAD 01B5 61 PUSH2 0x04db 01B8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0196 stack[-1] = 0x00aa // @01B1 stack[0] = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff // @01B4 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x04db, returns to 0x00AA label_01B9: // Incoming jump from 0x0081, if 0xd41b6db6 == stack[-1] // Inputs[1] { @01BA msg.value } 01B9 5B JUMPDEST 01BA 34 CALLVALUE 01BB 80 DUP1 01BC 15 ISZERO 01BD 61 PUSH2 0x01c5 01C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01BA stack[0] = msg.value } // Block ends with conditional jump to 0x01c5, if !msg.value label_01C1: // Incoming jump from 0x01C0, if not !msg.value // Inputs[1] { @01C4 memory[0x00:0x00] } 01C1 60 PUSH1 0x00 01C3 80 DUP1 01C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C4 revert(memory[0x00:0x00]); } // Block terminates label_01C5: // Incoming jump from 0x01C0, if !msg.value // Inputs[1] { @01E1 msg.data[0x04:0x24] } 01C5 5B JUMPDEST 01C6 50 POP 01C7 61 PUSH2 0x01e7 01CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01DF 60 PUSH1 0x04 01E1 35 CALLDATALOAD 01E2 16 AND 01E3 61 PUSH2 0x0555 01E6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @01C7 stack[-1] = 0x01e7 // @01E2 stack[0] = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with call to 0x0555, returns to 0x01E7 label_01E7: // Incoming return from call to 0x0555 at 0x01E6 // Incoming return from call to 0x0567 at 0x0226 // Inputs[4] // { // @01EB memory[0x40:0x60] // @01EC stack[-1] // @01EF memory[0x40:0x60] // @01F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 01E7 5B JUMPDEST 01E8 60 PUSH1 0x40 01EA 80 DUP1 01EB 51 MLOAD 01EC 91 SWAP2 01ED 82 DUP3 01EE 52 MSTORE 01EF 51 MLOAD 01F0 90 SWAP1 01F1 81 DUP2 01F2 90 SWAP1 01F3 03 SUB 01F4 60 PUSH1 0x20 01F6 01 ADD 01F7 90 SWAP1 01F8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01F8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_01F9: // Incoming jump from 0x008C, if 0xe3d670d7 == stack[-1] // Inputs[1] { @01FA msg.value } 01F9 5B JUMPDEST 01FA 34 CALLVALUE 01FB 80 DUP1 01FC 15 ISZERO 01FD 61 PUSH2 0x0205 0200 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01FA stack[0] = msg.value } // Block ends with conditional jump to 0x0205, if !msg.value label_0201: // Incoming jump from 0x0200, if not !msg.value // Inputs[1] { @0204 memory[0x00:0x00] } 0201 60 PUSH1 0x00 0203 80 DUP1 0204 FD *REVERT // Stack delta = +0 // Outputs[1] { @0204 revert(memory[0x00:0x00]); } // Block terminates label_0205: // Incoming jump from 0x0200, if !msg.value // Inputs[1] { @0221 msg.data[0x04:0x24] } 0205 5B JUMPDEST 0206 50 POP 0207 61 PUSH2 0x01e7 020A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 021F 60 PUSH1 0x04 0221 35 CALLDATALOAD 0222 16 AND 0223 61 PUSH2 0x0567 0226 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0207 stack[-1] = 0x01e7 // @0222 stack[0] = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with call to 0x0567, returns to 0x01E7 label_0227: // Incoming call from 0x00A9, returns to 0x00AA // Inputs[1] { @022A stack[-1] } 0227 5B JUMPDEST 0228 60 PUSH1 0x02 022A 81 DUP2 022B 14 EQ 022C 61 PUSH2 0x0234 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0234, if stack[-1] == 0x02 label_0230: // Incoming jump from 0x022F, if not stack[-1] == 0x02 // Inputs[1] { @0233 memory[0x00:0x00] } 0230 60 PUSH1 0x00 0232 80 DUP1 0233 FD *REVERT // Stack delta = +0 // Outputs[1] { @0233 revert(memory[0x00:0x00]); } // Block terminates label_0234: // Incoming jump from 0x022F, if stack[-1] == 0x02 // Inputs[4] // { // @0235 msg.sender // @0243 memory[0x00:0x40] // @0244 storage[keccak256(memory[0x00:0x40])] // @0245 stack[-1] // } 0234 5B JUMPDEST 0235 33 CALLER 0236 60 PUSH1 0x00 0238 90 SWAP1 0239 81 DUP2 023A 52 MSTORE 023B 60 PUSH1 0x20 023D 81 DUP2 023E 90 SWAP1 023F 52 MSTORE 0240 60 PUSH1 0x40 0242 90 SWAP1 0243 20 SHA3 0244 54 SLOAD 0245 81 DUP2 0246 11 GT 0247 15 ISZERO 0248 61 PUSH2 0x0250 024B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @023A memory[0x00:0x20] = msg.sender // @023F memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x0250, if !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_024C: // Incoming jump from 0x024B, if not !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @024F memory[0x00:0x00] } 024C 60 PUSH1 0x00 024E 80 DUP1 024F FD *REVERT // Stack delta = +0 // Outputs[1] { @024F revert(memory[0x00:0x00]); } // Block terminates label_0250: // Incoming jump from 0x024B, if !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[10] // { // @0253 memory[0x40:0x60] // @0254 msg.sender // @025D stack[-1] // @0267 msg.gas // @0268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0268 address(msg.sender).call.gas(msg.gas).value(stack[-1] * 0x5af3107a4000)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @026B msg.sender // @0279 memory[0x00:0x40] // @027B storage[keccak256(memory[0x00:0x40])] // @0285 stack[-2] // } 0250 5B JUMPDEST 0251 60 PUSH1 0x40 0253 51 MLOAD 0254 33 CALLER 0255 90 SWAP1 0256 65 PUSH6 0x5af3107a4000 025D 83 DUP4 025E 02 MUL 025F 90 SWAP1 0260 60 PUSH1 0x00 0262 81 DUP2 0263 81 DUP2 0264 81 DUP2 0265 85 DUP6 0266 87 DUP8 0267 5A GAS 0268 F1 CALL 0269 50 POP 026A 50 POP 026B 33 CALLER 026C 60 PUSH1 0x00 026E 90 SWAP1 026F 81 DUP2 0270 52 MSTORE 0271 60 PUSH1 0x20 0273 81 DUP2 0274 90 SWAP1 0275 52 MSTORE 0276 60 PUSH1 0x40 0278 90 SWAP1 0279 20 SHA3 027A 80 DUP1 027B 54 SLOAD 027C 93 SWAP4 027D 90 SWAP1 027E 93 SWAP4 027F 03 SUB 0280 90 SWAP1 0281 92 SWAP3 0282 55 SSTORE 0283 50 POP 0284 50 POP 0285 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(msg.gas).value(stack[-1] * 0x5af3107a4000)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0270 memory[0x00:0x20] = msg.sender // @0275 memory[0x20:0x40] = 0x00 // @0282 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-1] // } // Block ends with unconditional jump to stack[-2] label_0286: // Incoming call from 0x00C0, returns to 0x00AA // Inputs[3] // { // @0287 msg.sender // @0295 memory[0x00:0x40] // @0296 storage[keccak256(memory[0x00:0x40])] // } 0286 5B JUMPDEST 0287 33 CALLER 0288 60 PUSH1 0x00 028A 90 SWAP1 028B 81 DUP2 028C 52 MSTORE 028D 60 PUSH1 0x01 028F 60 PUSH1 0x20 0291 52 MSTORE 0292 60 PUSH1 0x40 0294 90 SWAP1 0295 20 SHA3 0296 54 SLOAD 0297 15 ISZERO 0298 61 PUSH2 0x02a0 029B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @028C memory[0x00:0x20] = msg.sender // @0291 memory[0x20:0x40] = 0x01 // } // Block ends with conditional jump to 0x02a0, if !storage[keccak256(memory[0x00:0x40])] label_029C: // Incoming jump from 0x029B, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @029F memory[0x00:0x00] } 029C 60 PUSH1 0x00 029E 80 DUP1 029F FD *REVERT // Stack delta = +0 // Outputs[1] { @029F revert(memory[0x00:0x00]); } // Block terminates label_02A0: // Incoming jump from 0x029B, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @02A7 msg.sender } 02A0 5B JUMPDEST 02A1 61 PUSH2 0xb1b1 02A4 61 PUSH2 0xffff 02A7 33 CALLER 02A8 16 AND 02A9 14 EQ 02AA 61 PUSH2 0x02b2 02AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b2, if msg.sender & 0xffff == 0xb1b1 label_02AE: // Incoming jump from 0x02AD, if not msg.sender & 0xffff == 0xb1b1 // Inputs[1] { @02B1 memory[0x00:0x00] } 02AE 60 PUSH1 0x00 02B0 80 DUP1 02B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B1 revert(memory[0x00:0x00]); } // Block terminates label_02B2: // Incoming jump from 0x02AD, if msg.sender & 0xffff == 0xb1b1 // Inputs[6] // { // @02B3 msg.sender // @02C2 memory[0x00:0x40] // @02C4 storage[keccak256(memory[0x00:0x40])] // @02D3 memory[0x00:0x40] // @02D5 storage[keccak256(memory[0x00:0x40])] // @02DB stack[-1] // } 02B2 5B JUMPDEST 02B3 33 CALLER 02B4 60 PUSH1 0x00 02B6 90 SWAP1 02B7 81 DUP2 02B8 52 MSTORE 02B9 60 PUSH1 0x20 02BB 81 DUP2 02BC 81 DUP2 02BD 52 MSTORE 02BE 60 PUSH1 0x40 02C0 80 DUP1 02C1 83 DUP4 02C2 20 SHA3 02C3 80 DUP1 02C4 54 SLOAD 02C5 60 PUSH1 0x01 02C7 90 SWAP1 02C8 81 DUP2 02C9 01 ADD 02CA 90 SWAP1 02CB 91 SWAP2 02CC 55 SSTORE 02CD 91 SWAP2 02CE 82 DUP3 02CF 90 SWAP1 02D0 52 MSTORE 02D1 90 SWAP1 02D2 91 SWAP2 02D3 20 SHA3 02D4 80 DUP1 02D5 54 SLOAD 02D6 90 SWAP1 02D7 91 SWAP2 02D8 01 ADD 02D9 90 SWAP1 02DA 55 SSTORE 02DB 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @02B8 memory[0x00:0x20] = msg.sender // @02BD memory[0x20:0x40] = 0x00 // @02CC storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @02D0 memory[0x20:0x40] = 0x01 // @02DA storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-1] label_02DC: // Incoming call from 0x0157, returns to 0x00AA // Inputs[3] // { // @02DD msg.sender // @02EB memory[0x00:0x40] // @02EC storage[keccak256(memory[0x00:0x40])] // } 02DC 5B JUMPDEST 02DD 33 CALLER 02DE 60 PUSH1 0x00 02E0 90 SWAP1 02E1 81 DUP2 02E2 52 MSTORE 02E3 60 PUSH1 0x20 02E5 81 DUP2 02E6 90 SWAP1 02E7 52 MSTORE 02E8 60 PUSH1 0x40 02EA 90 SWAP1 02EB 20 SHA3 02EC 54 SLOAD 02ED 64 PUSH5 0x02540be400 02F3 11 GT 02F4 15 ISZERO 02F5 61 PUSH2 0x02fd 02F8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @02E2 memory[0x00:0x20] = msg.sender // @02E7 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x02fd, if !(0x02540be400 > storage[keccak256(memory[0x00:0x40])]) label_02F9: // Incoming jump from 0x02F8, if not !(0x02540be400 > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @02FC memory[0x00:0x00] } 02F9 60 PUSH1 0x00 02FB 80 DUP1 02FC FD *REVERT // Stack delta = +0 // Outputs[1] { @02FC revert(memory[0x00:0x00]); } // Block terminates label_02FD: // Incoming jump from 0x02F8, if !(0x02540be400 > storage[keccak256(memory[0x00:0x40])]) // Inputs[8] // { // @02FE msg.sender // @030D memory[0x00:0x40] // @0313 storage[0x02] // @0315 memory[0x40:0x60] // @0330 address(this) // @0331 address(address(this)).balance // @0341 address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x02]).call.gas(0x08fc * !address(address(this)).balance).value(address(address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0341 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 02FD 5B JUMPDEST 02FE 33 CALLER 02FF 60 PUSH1 0x00 0301 90 SWAP1 0302 81 DUP2 0303 52 MSTORE 0304 60 PUSH1 0x20 0306 81 DUP2 0307 90 SWAP1 0308 52 MSTORE 0309 60 PUSH1 0x40 030B 80 DUP1 030C 82 DUP3 030D 20 SHA3 030E 82 DUP3 030F 90 SWAP1 0310 55 SSTORE 0311 60 PUSH1 0x02 0313 54 SLOAD 0314 90 SWAP1 0315 51 MLOAD 0316 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 032B 91 SWAP2 032C 90 SWAP1 032D 91 SWAP2 032E 16 AND 032F 91 SWAP2 0330 30 ADDRESS 0331 31 BALANCE 0332 80 DUP1 0333 15 ISZERO 0334 61 PUSH2 0x08fc 0337 02 MUL 0338 92 SWAP3 0339 90 SWAP1 033A 91 SWAP2 033B 81 DUP2 033C 81 DUP2 033D 81 DUP2 033E 85 DUP6 033F 88 DUP9 0340 88 DUP9 0341 F1 CALL 0342 93 SWAP4 0343 50 POP 0344 50 POP 0345 50 POP 0346 50 POP 0347 15 ISZERO 0348 80 DUP1 0349 15 ISZERO 034A 61 PUSH2 0x0357 034D 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0303 memory[0x00:0x20] = msg.sender // @0308 memory[0x20:0x40] = 0x00 // @0310 storage[keccak256(memory[0x00:0x40])] = 0x00 // @0341 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x02]).call.gas(0x08fc * !address(address(this)).balance).value(address(address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0347 stack[0] = !address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x02]).call.gas(0x08fc * !address(address(this)).balance).value(address(address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0357, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x02]).call.gas(0x08fc * !address(address(this)).balance).value(address(address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_034E: // Incoming jump from 0x034D, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x02]).call.gas(0x08fc * !address(address(this)).balance).value(address(address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @034E returndata.length // @0352 returndata[0x00:0x00 + returndata.length] // @0353 returndata.length // @0356 memory[0x00:0x00 + returndata.length] // } 034E 3D RETURNDATASIZE 034F 60 PUSH1 0x00 0351 80 DUP1 0352 3E RETURNDATACOPY 0353 3D RETURNDATASIZE 0354 60 PUSH1 0x00 0356 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0352 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0356 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0357: // Incoming jump from 0x034D, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x02]).call.gas(0x08fc * !address(address(this)).balance).value(address(address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[5] // { // @037A stack[-3] // @037B stack[-2] // @037E memory[0x40:0x60] // @0390 memory[stack[-3]:stack[-3] + 0x20] // @0399 memory[stack[-3]:stack[-3] + 0x20] // } 0357 5B JUMPDEST 0358 50 POP 0359 7F PUSH32 0x6335b7f9c4dff99c3a870eaf18b802774df3aba4e21b72549f3a03b6bc974c90 037A 82 DUP3 037B 82 DUP3 037C 60 PUSH1 0x40 037E 51 MLOAD 037F 80 DUP1 0380 80 DUP1 0381 60 PUSH1 0x20 0383 01 ADD 0384 80 DUP1 0385 60 PUSH1 0x20 0387 01 ADD 0388 83 DUP4 0389 81 DUP2 038A 03 SUB 038B 83 DUP4 038C 52 MSTORE 038D 85 DUP6 038E 81 DUP2 038F 81 DUP2 0390 51 MLOAD 0391 81 DUP2 0392 52 MSTORE 0393 60 PUSH1 0x20 0395 01 ADD 0396 91 SWAP2 0397 50 POP 0398 80 DUP1 0399 51 MLOAD 039A 90 SWAP1 039B 60 PUSH1 0x20 039D 01 ADD 039E 90 SWAP1 039F 80 DUP1 03A0 83 DUP4 03A1 83 DUP4 03A2 60 PUSH1 0x00 03A4 5B JUMPDEST 03A5 83 DUP4 03A6 81 DUP2 03A7 10 LT 03A8 15 ISZERO 03A9 61 PUSH2 0x03bc 03AC 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @0359 stack[-1] = 0x6335b7f9c4dff99c3a870eaf18b802774df3aba4e21b72549f3a03b6bc974c90 // @037A stack[0] = stack[-3] // @037B stack[1] = stack[-2] // @037E stack[2] = memory[0x40:0x60] // @037F stack[3] = memory[0x40:0x60] // @0383 stack[4] = 0x20 + memory[0x40:0x60] // @038C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0392 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @0396 stack[5] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @039E stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @039E stack[6] = 0x20 + stack[-3] // @039F stack[8] = memory[stack[-3]:stack[-3] + 0x20] // @03A0 stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @03A1 stack[10] = 0x20 + stack[-3] // @03A2 stack[11] = 0x00 // } // Block ends with conditional jump to 0x03bc, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_03AD: // Incoming jump from 0x03AC, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x03AC, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @03AD stack[-2] // @03AE stack[-1] // @03B0 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @03B1 stack[-3] // } 03AD 81 DUP2 03AE 81 DUP2 03AF 01 ADD 03B0 51 MLOAD 03B1 83 DUP4 03B2 82 DUP3 03B3 01 ADD 03B4 52 MSTORE 03B5 60 PUSH1 0x20 03B7 01 ADD 03B8 61 PUSH2 0x03a4 03BB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03B4 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @03B7 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x03a4 label_03BC: // Incoming jump from 0x03AC, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x03AC, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @03C1 stack[-5] // @03C1 stack[-6] // @03C3 stack[-7] // } 03BC 5B JUMPDEST 03BD 50 POP 03BE 50 POP 03BF 50 POP 03C0 50 POP 03C1 90 SWAP1 03C2 50 POP 03C3 90 SWAP1 03C4 81 DUP2 03C5 01 ADD 03C6 90 SWAP1 03C7 60 PUSH1 0x1f 03C9 16 AND 03CA 80 DUP1 03CB 15 ISZERO 03CC 61 PUSH2 0x03e9 03CF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @03C6 stack[-7] = stack[-5] + stack[-7] // @03C9 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x03e9, if !(0x1f & stack[-5]) label_03D0: // Incoming jump from 0x03CF, if not !(0x1f & stack[-5]) // Inputs[8] // { // @03D0 stack[-1] // @03D1 stack[-2] // @03D4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03EB stack[-5] // @03EE stack[-3] // @03F0 stack[-6] // @03F1 memory[stack[-6]:stack[-6] + 0x20] // @03F5 memory[stack[-6]:stack[-6] + 0x20] // } 03D0 80 DUP1 03D1 82 DUP3 03D2 03 SUB 03D3 80 DUP1 03D4 51 MLOAD 03D5 60 PUSH1 0x01 03D7 83 DUP4 03D8 60 PUSH1 0x20 03DA 03 SUB 03DB 61 PUSH2 0x0100 03DE 0A EXP 03DF 03 SUB 03E0 19 NOT 03E1 16 AND 03E2 81 DUP2 03E3 52 MSTORE 03E4 60 PUSH1 0x20 03E6 01 ADD 03E7 91 SWAP2 03E8 50 POP 03E9 5B JUMPDEST 03EA 50 POP 03EB 83 DUP4 03EC 81 DUP2 03ED 03 SUB 03EE 82 DUP3 03EF 52 MSTORE 03F0 84 DUP5 03F1 51 MLOAD 03F2 81 DUP2 03F3 52 MSTORE 03F4 84 DUP5 03F5 51 MLOAD 03F6 60 PUSH1 0x20 03F8 91 SWAP2 03F9 82 DUP3 03FA 01 ADD 03FB 91 SWAP2 03FC 86 DUP7 03FD 01 ADD 03FE 90 SWAP1 03FF 80 DUP1 0400 83 DUP4 0401 83 DUP4 0402 60 PUSH1 0x00 0404 5B JUMPDEST 0405 83 DUP4 0406 81 DUP2 0407 10 LT 0408 15 ISZERO 0409 61 PUSH2 0x041c 040C 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @03E3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03EF memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @03F3 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @03FB stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @03FE stack[-1] = stack[-6] + 0x20 // @03FE stack[0] = memory[stack[-6]:stack[-6] + 0x20] // @03FF stack[1] = memory[stack[-6]:stack[-6] + 0x20] // @0400 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0401 stack[3] = stack[-6] + 0x20 // @0402 stack[4] = 0x00 // } // Block ends with conditional jump to 0x041c, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_040D: // Incoming jump from 0x040C, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x040C, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x040C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @040D stack[-2] // @040E stack[-1] // @0410 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0411 stack[-3] // } 040D 81 DUP2 040E 81 DUP2 040F 01 ADD 0410 51 MLOAD 0411 83 DUP4 0412 82 DUP3 0413 01 ADD 0414 52 MSTORE 0415 60 PUSH1 0x20 0417 01 ADD 0418 61 PUSH2 0x0404 041B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0414 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0417 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0404 label_041C: // Incoming jump from 0x040C, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x040C, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x040C, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0421 stack[-6] // @0421 stack[-5] // @0423 stack[-7] // } 041C 5B JUMPDEST 041D 50 POP 041E 50 POP 041F 50 POP 0420 50 POP 0421 90 SWAP1 0422 50 POP 0423 90 SWAP1 0424 81 DUP2 0425 01 ADD 0426 90 SWAP1 0427 60 PUSH1 0x1f 0429 16 AND 042A 80 DUP1 042B 15 ISZERO 042C 61 PUSH2 0x0449 042F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0426 stack[-7] = stack[-5] + stack[-7] // @0429 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0449, if !(0x1f & stack[-5]) label_0430: // Incoming jump from 0x042F, if not !(0x1f & stack[-5]) // Inputs[8] // { // @0430 stack[-1] // @0431 stack[-2] // @0434 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @044B stack[-7] // @0453 memory[0x40:0x60] // @0458 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @0458 stack[-8] // @045B stack[-11] // } 0430 80 DUP1 0431 82 DUP3 0432 03 SUB 0433 80 DUP1 0434 51 MLOAD 0435 60 PUSH1 0x01 0437 83 DUP4 0438 60 PUSH1 0x20 043A 03 SUB 043B 61 PUSH2 0x0100 043E 0A EXP 043F 03 SUB 0440 19 NOT 0441 16 AND 0442 81 DUP2 0443 52 MSTORE 0444 60 PUSH1 0x20 0446 01 ADD 0447 91 SWAP2 0448 50 POP 0449 5B JUMPDEST 044A 50 POP 044B 94 SWAP5 044C 50 POP 044D 50 POP 044E 50 POP 044F 50 POP 0450 50 POP 0451 60 PUSH1 0x40 0453 51 MLOAD 0454 80 DUP1 0455 91 SWAP2 0456 03 SUB 0457 90 SWAP1 0458 A1 LOG1 0459 50 POP 045A 50 POP 045B 56 *JUMP // Stack delta = -11 // Outputs[2] // { // @0443 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0458 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-8]]); // } // Block ends with unconditional jump to stack[-11] label_045C: // Incoming call from 0x016F, returns to 0x00AA // Inputs[2] // { // @045F storage[0x02] // @0476 msg.sender // } 045C 5B JUMPDEST 045D 60 PUSH1 0x02 045F 54 SLOAD 0460 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0475 16 AND 0476 33 CALLER 0477 14 EQ 0478 61 PUSH2 0x0480 047B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0480, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] label_047C: // Incoming jump from 0x047B, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] // Inputs[1] { @047F memory[0x00:0x00] } 047C 60 PUSH1 0x00 047E 80 DUP1 047F FD *REVERT // Stack delta = +0 // Outputs[1] { @047F revert(memory[0x00:0x00]); } // Block terminates label_0480: // Incoming jump from 0x047B, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] // Inputs[2] // { // @0483 stack[-1] // @0484 stack[-2] // } 0480 5B JUMPDEST 0481 60 PUSH1 0x03 0483 55 SSTORE 0484 56 *JUMP // Stack delta = -2 // Outputs[1] { @0483 storage[0x03] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0485: // Incoming call from 0x0187, returns to 0x00AA // Inputs[2] // { // @0488 storage[0x03] // @0489 stack[-1] // } 0485 5B JUMPDEST 0486 60 PUSH1 0x03 0488 54 SLOAD 0489 81 DUP2 048A 14 EQ 048B 61 PUSH2 0x0493 048E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0493, if stack[-1] == storage[0x03] label_048F: // Incoming jump from 0x048E, if not stack[-1] == storage[0x03] // Inputs[1] { @0492 memory[0x00:0x00] } 048F 60 PUSH1 0x00 0491 80 DUP1 0492 FD *REVERT // Stack delta = +0 // Outputs[1] { @0492 revert(memory[0x00:0x00]); } // Block terminates label_0493: // Incoming jump from 0x048E, if stack[-1] == storage[0x03] // Inputs[3] // { // @0494 msg.sender // @04A5 memory[0x00:0x40] // @04A6 storage[keccak256(memory[0x00:0x40])] // } 0493 5B JUMPDEST 0494 33 CALLER 0495 60 PUSH1 0x00 0497 90 SWAP1 0498 81 DUP2 0499 52 MSTORE 049A 60 PUSH1 0x01 049C 60 PUSH1 0x20 049E 81 DUP2 049F 90 SWAP1 04A0 52 MSTORE 04A1 60 PUSH1 0x40 04A3 90 SWAP1 04A4 91 SWAP2 04A5 20 SHA3 04A6 54 SLOAD 04A7 14 EQ 04A8 61 PUSH2 0x04b0 04AB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0499 memory[0x00:0x20] = msg.sender // @04A0 memory[0x20:0x40] = 0x01 // } // Block ends with conditional jump to 0x04b0, if storage[keccak256(memory[0x00:0x40])] == 0x01 label_04AC: // Incoming jump from 0x04AB, if not storage[keccak256(memory[0x00:0x40])] == 0x01 // Inputs[1] { @04AF memory[0x00:0x00] } 04AC 60 PUSH1 0x00 04AE 80 DUP1 04AF FD *REVERT // Stack delta = +0 // Outputs[1] { @04AF revert(memory[0x00:0x00]); } // Block terminates label_04B0: // Incoming jump from 0x04AB, if storage[keccak256(memory[0x00:0x40])] == 0x01 // Inputs[6] // { // @04B2 msg.sender // @04C1 memory[0x00:0x40] // @04C3 storage[keccak256(memory[0x00:0x40])] // @04D2 memory[0x00:0x40] // @04D4 storage[keccak256(memory[0x00:0x40])] // @04DA stack[-2] // } 04B0 5B JUMPDEST 04B1 50 POP 04B2 33 CALLER 04B3 60 PUSH1 0x00 04B5 90 SWAP1 04B6 81 DUP2 04B7 52 MSTORE 04B8 60 PUSH1 0x20 04BA 81 DUP2 04BB 81 DUP2 04BC 52 MSTORE 04BD 60 PUSH1 0x40 04BF 80 DUP1 04C0 83 DUP4 04C1 20 SHA3 04C2 80 DUP1 04C3 54 SLOAD 04C4 60 PUSH1 0x01 04C6 90 SWAP1 04C7 81 DUP2 04C8 01 ADD 04C9 90 SWAP1 04CA 91 SWAP2 04CB 55 SSTORE 04CC 91 SWAP2 04CD 82 DUP3 04CE 90 SWAP1 04CF 52 MSTORE 04D0 90 SWAP1 04D1 91 SWAP2 04D2 20 SHA3 04D3 80 DUP1 04D4 54 SLOAD 04D5 90 SWAP1 04D6 91 SWAP2 04D7 01 ADD 04D8 90 SWAP1 04D9 55 SSTORE 04DA 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @04B7 memory[0x00:0x20] = msg.sender // @04BC memory[0x20:0x40] = 0x00 // @04CB storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @04CF memory[0x20:0x40] = 0x01 // @04D9 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_04DB: // Incoming call from 0x01B8, returns to 0x00AA // Inputs[4] // { // @04DC msg.sender // @04EA memory[0x00:0x40] // @04EB storage[keccak256(memory[0x00:0x40])] // @04EC stack[-1] // } 04DB 5B JUMPDEST 04DC 33 CALLER 04DD 60 PUSH1 0x00 04DF 90 SWAP1 04E0 81 DUP2 04E1 52 MSTORE 04E2 60 PUSH1 0x20 04E4 81 DUP2 04E5 90 SWAP1 04E6 52 MSTORE 04E7 60 PUSH1 0x40 04E9 90 SWAP1 04EA 20 SHA3 04EB 54 SLOAD 04EC 81 DUP2 04ED 11 GT 04EE 15 ISZERO 04EF 61 PUSH2 0x04f7 04F2 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @04E1 memory[0x00:0x20] = msg.sender // @04E6 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x04f7, if !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_04F3: // Incoming jump from 0x04F2, if not !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @04F6 memory[0x00:0x00] } 04F3 60 PUSH1 0x00 04F5 80 DUP1 04F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F6 revert(memory[0x00:0x00]); } // Block terminates label_04F7: // Incoming jump from 0x04F2, if !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @04FA stack[-1] } 04F7 5B JUMPDEST 04F8 60 PUSH1 0x02 04FA 81 DUP2 04FB 14 EQ 04FC 61 PUSH2 0x0504 04FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0504, if stack[-1] == 0x02 label_0500: // Incoming jump from 0x04FF, if not stack[-1] == 0x02 // Inputs[1] { @0503 memory[0x00:0x00] } 0500 60 PUSH1 0x00 0502 80 DUP1 0503 FD *REVERT // Stack delta = +0 // Outputs[1] { @0503 revert(memory[0x00:0x00]); } // Block terminates label_0504: // Incoming jump from 0x04FF, if stack[-1] == 0x02 // Inputs[3] // { // @0505 msg.sender // @0513 memory[0x00:0x40] // @0514 storage[keccak256(memory[0x00:0x40])] // } 0504 5B JUMPDEST 0505 33 CALLER 0506 60 PUSH1 0x00 0508 90 SWAP1 0509 81 DUP2 050A 52 MSTORE 050B 60 PUSH1 0x01 050D 60 PUSH1 0x20 050F 52 MSTORE 0510 60 PUSH1 0x40 0512 90 SWAP1 0513 20 SHA3 0514 54 SLOAD 0515 60 PUSH1 0x02 0517 14 EQ 0518 61 PUSH2 0x0520 051B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @050A memory[0x00:0x20] = msg.sender // @050F memory[0x20:0x40] = 0x01 // } // Block ends with conditional jump to 0x0520, if 0x02 == storage[keccak256(memory[0x00:0x40])] label_051C: // Incoming jump from 0x051B, if not 0x02 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @051F memory[0x00:0x00] } 051C 60 PUSH1 0x00 051E 80 DUP1 051F FD *REVERT // Stack delta = +0 // Outputs[1] { @051F revert(memory[0x00:0x00]); } // Block terminates label_0520: // Incoming jump from 0x051B, if 0x02 == storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @0521 msg.sender // @0530 memory[0x00:0x40] // @0549 stack[-2] // @0550 stack[-1] // @0552 memory[0x00:0x40] // @0554 stack[-3] // } 0520 5B JUMPDEST 0521 33 CALLER 0522 60 PUSH1 0x00 0524 90 SWAP1 0525 81 DUP2 0526 52 MSTORE 0527 60 PUSH1 0x20 0529 81 DUP2 052A 90 SWAP1 052B 52 MSTORE 052C 60 PUSH1 0x40 052E 80 DUP1 052F 82 DUP3 0530 20 SHA3 0531 82 DUP3 0532 90 SWAP1 0533 55 SSTORE 0534 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0549 93 SWAP4 054A 90 SWAP1 054B 93 SWAP4 054C 16 AND 054D 81 DUP2 054E 52 MSTORE 054F 91 SWAP2 0550 90 SWAP1 0551 91 SWAP2 0552 20 SHA3 0553 55 SSTORE 0554 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0526 memory[0x00:0x20] = msg.sender // @052B memory[0x20:0x40] = 0x00 // @0533 storage[keccak256(memory[0x00:0x40])] = 0x00 // @054E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0553 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_0555: // Incoming call from 0x01E6, returns to 0x01E7 // Inputs[4] // { // @055D stack[-1] // @0563 memory[0x00:0x40] // @0564 storage[keccak256(memory[0x00:0x40])] // @0565 stack[-2] // } 0555 5B JUMPDEST 0556 60 PUSH1 0x01 0558 60 PUSH1 0x20 055A 52 MSTORE 055B 60 PUSH1 0x00 055D 90 SWAP1 055E 81 DUP2 055F 52 MSTORE 0560 60 PUSH1 0x40 0562 90 SWAP1 0563 20 SHA3 0564 54 SLOAD 0565 81 DUP2 0566 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @055A memory[0x20:0x40] = 0x01 // @055F memory[0x00:0x20] = stack[-1] // @0564 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0567: // Incoming call from 0x0226, returns to 0x01E7 // Inputs[4] // { // @056F stack[-1] // @0575 memory[0x00:0x40] // @0576 storage[keccak256(memory[0x00:0x40])] // @0577 stack[-2] // } 0567 5B JUMPDEST 0568 60 PUSH1 0x00 056A 60 PUSH1 0x20 056C 81 DUP2 056D 90 SWAP1 056E 52 MSTORE 056F 90 SWAP1 0570 81 DUP2 0571 52 MSTORE 0572 60 PUSH1 0x40 0574 90 SWAP1 0575 20 SHA3 0576 54 SLOAD 0577 81 DUP2 0578 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @056E memory[0x20:0x40] = 0x00 // @0571 memory[0x00:0x20] = stack[-1] // @0576 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] 0579 00 *STOP 057A A1 LOG1 057B 65 PUSH6 0x627a7a723058 0582 20 SHA3 0583 38 CODESIZE 0584 EB EB 0585 87 DUP8 0586 15 ISZERO 0587 79 PUSH26 0xa8df331e0ced52f636bf6e4224c28773c3811caa7dd5480d20d5 05A2 C5 C5 05A3 00 *STOP 05A4 29 29
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]