Online Solidity Decompiler

« Decompile another contract

Address

0xa019c785322b921a84d086502da0d0dbdb993fba [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x22e8c8fc gamble(uint256,uint256)
0x6bd5450a winners(address)
0x7e467819 Unknown
0x92a0f6f9 Unknown
0x9d9ca28d isWinner(address)

Internal Methods

gamble(arg0, arg1)
winners(arg1) returns (r0)
func_04BC(arg0)
func_0522(arg0)
isWinner(arg0) 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 == 0x22e8c8fc) { // Dispatch table entry for gamble(uint256,uint256) var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00a7; var var2 = msg.data[0x04:0x24]; var var3 = msg.data[0x24:0x44]; gamble(var2, var3); stop(); } else if (var0 == 0x6bd5450a) { // Dispatch table entry for winners(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00ea; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = winners(var2); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = !!var2; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x7e467819) { // Dispatch table entry for 0x7e467819 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x012f; var2 = msg.data[0x04:0x24]; func_04BC(var2); stop(); } else if (var0 == 0x92a0f6f9) { // Dispatch table entry for 0x92a0f6f9 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0172; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; func_0522(var2); stop(); } else if (var0 == 0x9d9ca28d) { // Dispatch table entry for isWinner(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x01b5; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var1 = isWinner(var2); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = !!var1; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (temp2 + 0x20) - temp3]; } else { revert(memory[0x00:0x00]); } } function gamble(var arg0, var arg1) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; var var3 = var2; if (msg.gas >= storage[0x02]) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = msg.sender; var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + (temp0 + 0x20) - temp1], [0x13b5333f210c6f5716ba38a687328636d36778572f6e032a83950c9a238356b9]); var2 = msg.sender; var3 = arg1; var0 = 0x00; if (var0 >= 0x20) { label_030A: var0 = 0x00; if (var0 >= 0x20) { label_03B8: var var4 = 0x03; var var5 = 0x00; if (var5 >= 0x20) { assert(); } if (arg0 != storage[var5 + var4]) { return; } var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = msg.sender; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = arg1; var temp4 = memory[0x40:0x60]; log(memory[temp4:temp4 + (temp3 + 0x20) - temp4], [0xf524cff290ca88948da219ef106f97024214703e20ea88ab521bea6781ab5b41]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp5 = keccak256(memory[0x00:0x40]); storage[temp5] = (storage[temp5] & ~0xff) | 0x01; return; } else { label_0319: var1 = var0 + 0x01; if (var1 >= 0x20) { label_03AB: var0 = var0 + 0x01; if (var0 >= 0x20) { goto label_03B8; } else { goto label_0319; } } else { label_0329: var4 = 0x03; var5 = var1; if (var5 >= 0x20) { assert(); } var4 = storage[var5 + var4]; var5 = 0x03; var var6 = var0; if (var6 >= 0x20) { assert(); } if (storage[var6 + var5] >= var4) { label_039E: var1 = var1 + 0x01; if (var1 >= 0x20) { goto label_03AB; } else { goto label_0329; } } else { var4 = 0x03; var5 = var0; if (var5 >= 0x20) { assert(); } var3 = storage[var5 + var4]; var4 = 0x03; var5 = var1; if (var5 >= 0x20) { assert(); } var4 = storage[var5 + var4]; var5 = 0x03; var6 = var0; if (var6 >= 0x20) { assert(); } storage[var6 + var5] = var4; var4 = var3; var5 = 0x03; var6 = var1; if (var6 >= 0x20) { assert(); } storage[var6 + var5] = var4; goto label_039E; } } } } else { label_02CB: var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var3; var temp7 = memory[0x40:0x60]; var3 = keccak256(memory[temp7:temp7 + (temp6 + 0x20) - temp7]) ~ var2; var4 = var3; var5 = 0x03; var6 = var0; if (var6 >= 0x20) { assert(); } storage[var6 + var5] = var4; var0 = var0 + 0x01; if (var0 >= 0x20) { goto label_030A; } else { goto label_02CB; } } } function winners(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x00; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_04BC(var arg0) { if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } storage[0x02] = arg0; } function func_0522(var arg0) { if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; var temp0 = keccak256(memory[0x00:0x40]); storage[temp0] = (storage[temp0] & ~0xff) | 0x01; } function isWinner(var arg0) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; return storage[keccak256(memory[0x00:0x40])] & 0xff; } }

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 0x006d 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x006d, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 63 PUSH4 0x22e8c8fc 003C 14 EQ 003D 61 PUSH2 0x0072 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0072, if 0x22e8c8fc == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x22e8c8fc == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x6bd5450a 0047 14 EQ 0048 61 PUSH2 0x00a9 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a9, if 0x6bd5450a == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x6bd5450a == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x7e467819 0052 14 EQ 0053 61 PUSH2 0x0104 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0104, if 0x7e467819 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x7e467819 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x92a0f6f9 005D 14 EQ 005E 61 PUSH2 0x0131 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0131, if 0x92a0f6f9 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x92a0f6f9 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x9d9ca28d 0068 14 EQ 0069 61 PUSH2 0x0174 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0174, if 0x9d9ca28d == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x9d9ca28d == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0071 memory[0x00:0x00] } 006D 5B JUMPDEST 006E 60 PUSH1 0x00 0070 80 DUP1 0071 FD *REVERT // Stack delta = +0 // Outputs[1] { @0071 revert(memory[0x00:0x00]); } // Block terminates label_0072: // Incoming jump from 0x0040, if 0x22e8c8fc == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0073 msg.value } 0072 5B JUMPDEST 0073 34 CALLVALUE 0074 80 DUP1 0075 15 ISZERO 0076 61 PUSH2 0x007e 0079 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0073 stack[0] = msg.value } // Block ends with conditional jump to 0x007e, if !msg.value label_007A: // Incoming jump from 0x0079, if not !msg.value // Inputs[1] { @007D memory[0x00:0x00] } 007A 60 PUSH1 0x00 007C 80 DUP1 007D FD *REVERT // Stack delta = +0 // Outputs[1] { @007D revert(memory[0x00:0x00]); } // Block terminates label_007E: // Incoming jump from 0x0079, if !msg.value // Inputs[3] // { // @0086 msg.data.length // @008D msg.data[0x04:0x24] // @0097 msg.data[0x24:0x44] // } 007E 5B JUMPDEST 007F 50 POP 0080 61 PUSH2 0x00a7 0083 60 PUSH1 0x04 0085 80 DUP1 0086 36 CALLDATASIZE 0087 03 SUB 0088 81 DUP2 0089 01 ADD 008A 90 SWAP1 008B 80 DUP1 008C 80 DUP1 008D 35 CALLDATALOAD 008E 90 SWAP1 008F 60 PUSH1 0x20 0091 01 ADD 0092 90 SWAP1 0093 92 SWAP3 0094 91 SWAP2 0095 90 SWAP1 0096 80 DUP1 0097 35 CALLDATALOAD 0098 90 SWAP1 0099 60 PUSH1 0x20 009B 01 ADD 009C 90 SWAP1 009D 92 SWAP3 009E 91 SWAP2 009F 90 SWAP1 00A0 50 POP 00A1 50 POP 00A2 50 POP 00A3 61 PUSH2 0x01cf 00A6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0080 stack[-1] = 0x00a7 // @0093 stack[0] = msg.data[0x04:0x24] // @009D stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x01cf, returns to 0x00A7 label_00A7: // Incoming return from call to 0x01CF at 0x00A6 00A7 5B JUMPDEST 00A8 00 *STOP // Stack delta = +0 // Outputs[1] { @00A8 stop(); } // Block terminates label_00A9: // Incoming jump from 0x004B, if 0x6bd5450a == stack[-1] // Inputs[1] { @00AA msg.value } 00A9 5B JUMPDEST 00AA 34 CALLVALUE 00AB 80 DUP1 00AC 15 ISZERO 00AD 61 PUSH2 0x00b5 00B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00AA stack[0] = msg.value } // Block ends with conditional jump to 0x00b5, if !msg.value label_00B1: // Incoming jump from 0x00B0, if not !msg.value // Inputs[1] { @00B4 memory[0x00:0x00] } 00B1 60 PUSH1 0x00 00B3 80 DUP1 00B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B4 revert(memory[0x00:0x00]); } // Block terminates label_00B5: // Incoming jump from 0x00B0, if !msg.value // Inputs[2] // { // @00BD msg.data.length // @00C4 msg.data[0x04:0x24] // } 00B5 5B JUMPDEST 00B6 50 POP 00B7 61 PUSH2 0x00ea 00BA 60 PUSH1 0x04 00BC 80 DUP1 00BD 36 CALLDATASIZE 00BE 03 SUB 00BF 81 DUP2 00C0 01 ADD 00C1 90 SWAP1 00C2 80 DUP1 00C3 80 DUP1 00C4 35 CALLDATALOAD 00C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00DA 16 AND 00DB 90 SWAP1 00DC 60 PUSH1 0x20 00DE 01 ADD 00DF 90 SWAP1 00E0 92 SWAP3 00E1 91 SWAP2 00E2 90 SWAP1 00E3 50 POP 00E4 50 POP 00E5 50 POP 00E6 61 PUSH2 0x049c 00E9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @00B7 stack[-1] = 0x00ea // @00E0 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x049c, returns to 0x00EA label_00EA: // Incoming return from call to 0x049C at 0x00E9 // Inputs[4] // { // @00ED memory[0x40:0x60] // @00EF stack[-1] // @00FE memory[0x40:0x60] // @0103 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00EA 5B JUMPDEST 00EB 60 PUSH1 0x40 00ED 51 MLOAD 00EE 80 DUP1 00EF 82 DUP3 00F0 15 ISZERO 00F1 15 ISZERO 00F2 15 ISZERO 00F3 15 ISZERO 00F4 81 DUP2 00F5 52 MSTORE 00F6 60 PUSH1 0x20 00F8 01 ADD 00F9 91 SWAP2 00FA 50 POP 00FB 50 POP 00FC 60 PUSH1 0x40 00FE 51 MLOAD 00FF 80 DUP1 0100 91 SWAP2 0101 03 SUB 0102 90 SWAP1 0103 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0103 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0104: // Incoming jump from 0x0056, if 0x7e467819 == stack[-1] // Inputs[1] { @0105 msg.value } 0104 5B JUMPDEST 0105 34 CALLVALUE 0106 80 DUP1 0107 15 ISZERO 0108 61 PUSH2 0x0110 010B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0105 stack[0] = msg.value } // Block ends with conditional jump to 0x0110, if !msg.value label_010C: // Incoming jump from 0x010B, if not !msg.value // Inputs[1] { @010F memory[0x00:0x00] } 010C 60 PUSH1 0x00 010E 80 DUP1 010F FD *REVERT // Stack delta = +0 // Outputs[1] { @010F revert(memory[0x00:0x00]); } // Block terminates label_0110: // Incoming jump from 0x010B, if !msg.value // Inputs[2] // { // @0118 msg.data.length // @011F msg.data[0x04:0x24] // } 0110 5B JUMPDEST 0111 50 POP 0112 61 PUSH2 0x012f 0115 60 PUSH1 0x04 0117 80 DUP1 0118 36 CALLDATASIZE 0119 03 SUB 011A 81 DUP2 011B 01 ADD 011C 90 SWAP1 011D 80 DUP1 011E 80 DUP1 011F 35 CALLDATALOAD 0120 90 SWAP1 0121 60 PUSH1 0x20 0123 01 ADD 0124 90 SWAP1 0125 92 SWAP3 0126 91 SWAP2 0127 90 SWAP1 0128 50 POP 0129 50 POP 012A 50 POP 012B 61 PUSH2 0x04bc 012E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0112 stack[-1] = 0x012f // @0125 stack[0] = msg.data[0x04:0x24] // } // Block ends with call to 0x04bc, returns to 0x012F label_012F: // Incoming return from call to 0x04BC at 0x012E 012F 5B JUMPDEST 0130 00 *STOP // Stack delta = +0 // Outputs[1] { @0130 stop(); } // Block terminates label_0131: // Incoming jump from 0x0061, if 0x92a0f6f9 == stack[-1] // Inputs[1] { @0132 msg.value } 0131 5B JUMPDEST 0132 34 CALLVALUE 0133 80 DUP1 0134 15 ISZERO 0135 61 PUSH2 0x013d 0138 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0132 stack[0] = msg.value } // Block ends with conditional jump to 0x013d, if !msg.value label_0139: // Incoming jump from 0x0138, if not !msg.value // Inputs[1] { @013C memory[0x00:0x00] } 0139 60 PUSH1 0x00 013B 80 DUP1 013C FD *REVERT // Stack delta = +0 // Outputs[1] { @013C revert(memory[0x00:0x00]); } // Block terminates label_013D: // Incoming jump from 0x0138, if !msg.value // Inputs[2] // { // @0145 msg.data.length // @014C msg.data[0x04:0x24] // } 013D 5B JUMPDEST 013E 50 POP 013F 61 PUSH2 0x0172 0142 60 PUSH1 0x04 0144 80 DUP1 0145 36 CALLDATASIZE 0146 03 SUB 0147 81 DUP2 0148 01 ADD 0149 90 SWAP1 014A 80 DUP1 014B 80 DUP1 014C 35 CALLDATALOAD 014D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0162 16 AND 0163 90 SWAP1 0164 60 PUSH1 0x20 0166 01 ADD 0167 90 SWAP1 0168 92 SWAP3 0169 91 SWAP2 016A 90 SWAP1 016B 50 POP 016C 50 POP 016D 50 POP 016E 61 PUSH2 0x0522 0171 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @013F stack[-1] = 0x0172 // @0168 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0522, returns to 0x0172 label_0172: // Incoming return from call to 0x0522 at 0x0171 0172 5B JUMPDEST 0173 00 *STOP // Stack delta = +0 // Outputs[1] { @0173 stop(); } // Block terminates label_0174: // Incoming jump from 0x006C, if 0x9d9ca28d == stack[-1] // Inputs[1] { @0175 msg.value } 0174 5B JUMPDEST 0175 34 CALLVALUE 0176 80 DUP1 0177 15 ISZERO 0178 61 PUSH2 0x0180 017B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0175 stack[0] = msg.value } // Block ends with conditional jump to 0x0180, if !msg.value label_017C: // Incoming jump from 0x017B, if not !msg.value // Inputs[1] { @017F memory[0x00:0x00] } 017C 60 PUSH1 0x00 017E 80 DUP1 017F FD *REVERT // Stack delta = +0 // Outputs[1] { @017F revert(memory[0x00:0x00]); } // Block terminates label_0180: // Incoming jump from 0x017B, if !msg.value // Inputs[2] // { // @0188 msg.data.length // @018F msg.data[0x04:0x24] // } 0180 5B JUMPDEST 0181 50 POP 0182 61 PUSH2 0x01b5 0185 60 PUSH1 0x04 0187 80 DUP1 0188 36 CALLDATASIZE 0189 03 SUB 018A 81 DUP2 018B 01 ADD 018C 90 SWAP1 018D 80 DUP1 018E 80 DUP1 018F 35 CALLDATALOAD 0190 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01A5 16 AND 01A6 90 SWAP1 01A7 60 PUSH1 0x20 01A9 01 ADD 01AA 90 SWAP1 01AB 92 SWAP3 01AC 91 SWAP2 01AD 90 SWAP1 01AE 50 POP 01AF 50 POP 01B0 50 POP 01B1 61 PUSH2 0x05d8 01B4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0182 stack[-1] = 0x01b5 // @01AB stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x05d8, returns to 0x01B5 label_01B5: // Incoming return from call to 0x05D8 at 0x01B4 // Inputs[4] // { // @01B8 memory[0x40:0x60] // @01BA stack[-1] // @01C9 memory[0x40:0x60] // @01CE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01B5 5B JUMPDEST 01B6 60 PUSH1 0x40 01B8 51 MLOAD 01B9 80 DUP1 01BA 82 DUP3 01BB 15 ISZERO 01BC 15 ISZERO 01BD 15 ISZERO 01BE 15 ISZERO 01BF 81 DUP2 01C0 52 MSTORE 01C1 60 PUSH1 0x20 01C3 01 ADD 01C4 91 SWAP2 01C5 50 POP 01C6 50 POP 01C7 60 PUSH1 0x40 01C9 51 MLOAD 01CA 80 DUP1 01CB 91 SWAP2 01CC 03 SUB 01CD 90 SWAP1 01CE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @01CE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01CF: // Incoming call from 0x00A6, returns to 0x00A7 // Inputs[2] // { // @01D8 storage[0x02] // @01D9 msg.gas // } 01CF 5B JUMPDEST 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 60 PUSH1 0x00 01D5 80 DUP1 01D6 60 PUSH1 0x02 01D8 54 SLOAD 01D9 5A GAS 01DA 10 LT 01DB 15 ISZERO 01DC 15 ISZERO 01DD 61 PUSH2 0x01e5 01E0 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @01D0 stack[0] = 0x00 // @01D2 stack[1] = 0x00 // @01D3 stack[2] = 0x00 // @01D5 stack[3] = 0x00 // } // Block ends with conditional jump to 0x01e5, if !!(msg.gas < storage[0x02]) label_01E1: // Incoming jump from 0x01E0, if not !!(msg.gas < storage[0x02]) // Inputs[1] { @01E4 memory[0x00:0x00] } 01E1 60 PUSH1 0x00 01E3 80 DUP1 01E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E4 revert(memory[0x00:0x00]); } // Block terminates label_01E5: // Incoming jump from 0x01E0, if !!(msg.gas < storage[0x02]) // Inputs[3] // { // @01E9 msg.sender // @0223 memory[0x00:0x40] // @0227 storage[keccak256(memory[0x00:0x40])] // } 01E5 5B JUMPDEST 01E6 60 PUSH1 0x00 01E8 80 DUP1 01E9 33 CALLER 01EA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01FF 16 AND 0200 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0215 16 AND 0216 81 DUP2 0217 52 MSTORE 0218 60 PUSH1 0x20 021A 01 ADD 021B 90 SWAP1 021C 81 DUP2 021D 52 MSTORE 021E 60 PUSH1 0x20 0220 01 ADD 0221 60 PUSH1 0x00 0223 20 SHA3 0224 60 PUSH1 0x00 0226 90 SWAP1 0227 54 SLOAD 0228 90 SWAP1 0229 61 PUSH2 0x0100 022C 0A EXP 022D 90 SWAP1 022E 04 DIV 022F 60 PUSH1 0xff 0231 16 AND 0232 15 ISZERO 0233 15 ISZERO 0234 15 ISZERO 0235 61 PUSH2 0x023d 0238 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0217 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @021D memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x023d, if !!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) label_0239: // Incoming jump from 0x0238, if not !!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[1] { @023C memory[0x00:0x00] } 0239 60 PUSH1 0x00 023B 80 DUP1 023C FD *REVERT // Stack delta = +0 // Outputs[1] { @023C revert(memory[0x00:0x00]); } // Block terminates label_023D: // Incoming jump from 0x0238, if !!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) // Inputs[9] // { // @025F msg.sender // @0262 memory[0x40:0x60] // @029B memory[0x40:0x60] // @02A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @02A1 msg.sender // @02B8 stack[-2] // @02BA stack[-5] // @02BB stack[-1] // @02BF stack[-4] // } 023D 5B JUMPDEST 023E 7F PUSH32 0x13b5333f210c6f5716ba38a687328636d36778572f6e032a83950c9a238356b9 025F 33 CALLER 0260 60 PUSH1 0x40 0262 51 MLOAD 0263 80 DUP1 0264 82 DUP3 0265 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 027A 16 AND 027B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0290 16 AND 0291 81 DUP2 0292 52 MSTORE 0293 60 PUSH1 0x20 0295 01 ADD 0296 91 SWAP2 0297 50 POP 0298 50 POP 0299 60 PUSH1 0x40 029B 51 MLOAD 029C 80 DUP1 029D 91 SWAP2 029E 03 SUB 029F 90 SWAP1 02A0 A1 LOG1 02A1 33 CALLER 02A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02B7 16 AND 02B8 91 SWAP2 02B9 50 POP 02BA 84 DUP5 02BB 90 SWAP1 02BC 50 POP 02BD 60 PUSH1 0x00 02BF 93 SWAP4 02C0 50 POP 02C1 5B JUMPDEST 02C2 60 PUSH1 0x20 02C4 84 DUP5 02C5 10 LT 02C6 15 ISZERO 02C7 61 PUSH2 0x030a 02CA 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0292 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @02A0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x13b5333f210c6f5716ba38a687328636d36778572f6e032a83950c9a238356b9]); // @02B8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @02BB stack[-1] = stack[-5] // @02BF stack[-4] = 0x00 // } // Block ends with conditional jump to 0x030a, if !(0x00 < 0x20) label_02CB: // Incoming jump from 0x02CA, if not !(0x00 < 0x20) // Incoming jump from 0x02CA, if not !(stack[-4] < 0x20) // Inputs[6] // { // @02CB stack[-2] // @02CC stack[-1] // @02CF memory[0x40:0x60] // @02DC memory[0x40:0x60] // @02E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @02EC stack[-4] // } 02CB 81 DUP2 02CC 81 DUP2 02CD 60 PUSH1 0x40 02CF 51 MLOAD 02D0 80 DUP1 02D1 82 DUP3 02D2 81 DUP2 02D3 52 MSTORE 02D4 60 PUSH1 0x20 02D6 01 ADD 02D7 91 SWAP2 02D8 50 POP 02D9 50 POP 02DA 60 PUSH1 0x40 02DC 51 MLOAD 02DD 80 DUP1 02DE 91 SWAP2 02DF 03 SUB 02E0 90 SWAP1 02E1 20 SHA3 02E2 60 PUSH1 0x01 02E4 90 SWAP1 02E5 04 DIV 02E6 18 XOR 02E7 90 SWAP1 02E8 50 POP 02E9 80 DUP1 02EA 60 PUSH1 0x03 02EC 85 DUP6 02ED 60 PUSH1 0x20 02EF 81 DUP2 02F0 10 LT 02F1 15 ISZERO 02F2 15 ISZERO 02F3 61 PUSH2 0x02f8 02F6 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @02D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02E7 stack[-1] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) / 0x01 ~ stack[-2] // @02E9 stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) / 0x01 ~ stack[-2] // @02EA stack[1] = 0x03 // @02EC stack[2] = stack[-4] // } // Block ends with conditional jump to 0x02f8, if !!(stack[-4] < 0x20) label_02F7: // Incoming jump from 0x02F6, if not !!(stack[-4] < 0x20) 02F7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @02F7 assert(); } // Block terminates label_02F8: // Incoming jump from 0x02F6, if !!(stack[-4] < 0x20) // Inputs[4] // { // @02F9 stack[-2] // @02F9 stack[-1] // @02FA stack[-3] // @02FE stack[-7] // } 02F8 5B JUMPDEST 02F9 01 ADD 02FA 81 DUP2 02FB 90 SWAP1 02FC 55 SSTORE 02FD 50 POP 02FE 83 DUP4 02FF 80 DUP1 0300 60 PUSH1 0x01 0302 01 ADD 0303 94 SWAP5 0304 50 POP 0305 50 POP 0306 61 PUSH2 0x02c1 0309 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @02FC storage[stack[-1] + stack[-2]] = stack[-3] // @0303 stack[-7] = 0x01 + stack[-7] // } // Block ends with unconditional jump to 0x02c1 label_030A: // Incoming jump from 0x02CA, if !(0x00 < 0x20) // Incoming jump from 0x02CA, if !(stack[-4] < 0x20) // Inputs[1] { @030D stack[-4] } 030A 5B JUMPDEST 030B 60 PUSH1 0x00 030D 93 SWAP4 030E 50 POP 030F 5B JUMPDEST 0310 60 PUSH1 0x20 0312 84 DUP5 0313 10 LT 0314 15 ISZERO 0315 61 PUSH2 0x03b8 0318 57 *JUMPI // Stack delta = +0 // Outputs[1] { @030D stack[-4] = 0x00 } // Block ends with conditional jump to 0x03b8, if !(0x00 < 0x20) label_0319: // Incoming jump from 0x0318, if not !(stack[-4] < 0x20) // Incoming jump from 0x0318, if not !(0x00 < 0x20) // Inputs[2] // { // @031B stack[-4] // @031D stack[-3] // } 0319 60 PUSH1 0x01 031B 84 DUP5 031C 01 ADD 031D 92 SWAP3 031E 50 POP 031F 5B JUMPDEST 0320 60 PUSH1 0x20 0322 83 DUP4 0323 10 LT 0324 15 ISZERO 0325 61 PUSH2 0x03ab 0328 57 *JUMPI // Stack delta = +0 // Outputs[1] { @031D stack[-3] = stack[-4] + 0x01 } // Block ends with conditional jump to 0x03ab, if !(stack[-4] + 0x01 < 0x20) label_0329: // Incoming jump from 0x0328, if not !(stack[-3] < 0x20) // Incoming jump from 0x0328, if not !(stack[-4] + 0x01 < 0x20) // Inputs[1] { @032B stack[-3] } 0329 60 PUSH1 0x03 032B 83 DUP4 032C 60 PUSH1 0x20 032E 81 DUP2 032F 10 LT 0330 15 ISZERO 0331 15 ISZERO 0332 61 PUSH2 0x0337 0335 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0329 stack[0] = 0x03 // @032B stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0337, if !!(stack[-3] < 0x20) label_0336: // Incoming jump from 0x0335, if not !!(stack[-3] < 0x20) 0336 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0336 assert(); } // Block terminates label_0337: // Incoming jump from 0x0335, if !!(stack[-3] < 0x20) // Inputs[4] // { // @0338 stack[-1] // @0338 stack[-2] // @0339 storage[stack[-1] + stack[-2]] // @033C stack[-6] // } 0337 5B JUMPDEST 0338 01 ADD 0339 54 SLOAD 033A 60 PUSH1 0x03 033C 85 DUP6 033D 60 PUSH1 0x20 033F 81 DUP2 0340 10 LT 0341 15 ISZERO 0342 15 ISZERO 0343 61 PUSH2 0x0348 0346 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0339 stack[-2] = storage[stack[-1] + stack[-2]] // @033A stack[-1] = 0x03 // @033C stack[0] = stack[-6] // } // Block ends with conditional jump to 0x0348, if !!(stack[-6] < 0x20) label_0347: // Incoming jump from 0x0346, if not !!(stack[-6] < 0x20) 0347 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0347 assert(); } // Block terminates label_0348: // Incoming jump from 0x0346, if !!(stack[-6] < 0x20) // Inputs[4] // { // @0349 stack[-2] // @0349 stack[-1] // @034A storage[stack[-1] + stack[-2]] // @034B stack[-3] // } 0348 5B JUMPDEST 0349 01 ADD 034A 54 SLOAD 034B 10 LT 034C 15 ISZERO 034D 61 PUSH2 0x039e 0350 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x039e, if !(storage[stack[-1] + stack[-2]] < stack[-3]) label_0351: // Incoming jump from 0x0350, if not !(storage[stack[-1] + stack[-2]] < stack[-3]) // Inputs[1] { @0353 stack[-4] } 0351 60 PUSH1 0x03 0353 84 DUP5 0354 60 PUSH1 0x20 0356 81 DUP2 0357 10 LT 0358 15 ISZERO 0359 15 ISZERO 035A 61 PUSH2 0x035f 035D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0351 stack[0] = 0x03 // @0353 stack[1] = stack[-4] // } // Block ends with conditional jump to 0x035f, if !!(stack[-4] < 0x20) label_035E: // Incoming jump from 0x035D, if not !!(stack[-4] < 0x20) 035E FE *ASSERT // Stack delta = +0 // Outputs[1] { @035E assert(); } // Block terminates label_035F: // Incoming jump from 0x035D, if !!(stack[-4] < 0x20) // Inputs[5] // { // @0360 stack[-1] // @0360 stack[-2] // @0361 storage[stack[-1] + stack[-2]] // @0362 stack[-3] // @0366 stack[-5] // } 035F 5B JUMPDEST 0360 01 ADD 0361 54 SLOAD 0362 90 SWAP1 0363 50 POP 0364 60 PUSH1 0x03 0366 83 DUP4 0367 60 PUSH1 0x20 0369 81 DUP2 036A 10 LT 036B 15 ISZERO 036C 15 ISZERO 036D 61 PUSH2 0x0372 0370 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0362 stack[-3] = storage[stack[-1] + stack[-2]] // @0364 stack[-2] = 0x03 // @0366 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x0372, if !!(stack[-5] < 0x20) label_0371: // Incoming jump from 0x0370, if not !!(stack[-5] < 0x20) 0371 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0371 assert(); } // Block terminates label_0372: // Incoming jump from 0x0370, if !!(stack[-5] < 0x20) // Inputs[4] // { // @0373 stack[-2] // @0373 stack[-1] // @0374 storage[stack[-1] + stack[-2]] // @0377 stack[-6] // } 0372 5B JUMPDEST 0373 01 ADD 0374 54 SLOAD 0375 60 PUSH1 0x03 0377 85 DUP6 0378 60 PUSH1 0x20 037A 81 DUP2 037B 10 LT 037C 15 ISZERO 037D 15 ISZERO 037E 61 PUSH2 0x0383 0381 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0374 stack[-2] = storage[stack[-1] + stack[-2]] // @0375 stack[-1] = 0x03 // @0377 stack[0] = stack[-6] // } // Block ends with conditional jump to 0x0383, if !!(stack[-6] < 0x20) label_0382: // Incoming jump from 0x0381, if not !!(stack[-6] < 0x20) 0382 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0382 assert(); } // Block terminates label_0383: // Incoming jump from 0x0381, if !!(stack[-6] < 0x20) // Inputs[5] // { // @0384 stack[-2] // @0384 stack[-1] // @0385 stack[-3] // @0389 stack[-4] // @038C stack[-6] // } 0383 5B JUMPDEST 0384 01 ADD 0385 81 DUP2 0386 90 SWAP1 0387 55 SSTORE 0388 50 POP 0389 80 DUP1 038A 60 PUSH1 0x03 038C 84 DUP5 038D 60 PUSH1 0x20 038F 81 DUP2 0390 10 LT 0391 15 ISZERO 0392 15 ISZERO 0393 61 PUSH2 0x0398 0396 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0387 storage[stack[-1] + stack[-2]] = stack[-3] // @0389 stack[-3] = stack[-4] // @038A stack[-2] = 0x03 // @038C stack[-1] = stack[-6] // } // Block ends with conditional jump to 0x0398, if !!(stack[-6] < 0x20) label_0397: // Incoming jump from 0x0396, if not !!(stack[-6] < 0x20) 0397 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0397 assert(); } // Block terminates label_0398: // Incoming jump from 0x0396, if !!(stack[-6] < 0x20) // Inputs[3] // { // @0399 stack[-2] // @0399 stack[-1] // @039A stack[-3] // } 0398 5B JUMPDEST 0399 01 ADD 039A 81 DUP2 039B 90 SWAP1 039C 55 SSTORE 039D 50 POP // Stack delta = -3 // Outputs[1] { @039C storage[stack[-1] + stack[-2]] = stack[-3] } // Block continues label_039E: // Incoming jump from 0x039D // Incoming jump from 0x0350, if !(storage[stack[-1] + stack[-2]] < stack[-3]) // Inputs[1] { @039F stack[-3] } 039E 5B JUMPDEST 039F 82 DUP3 03A0 80 DUP1 03A1 60 PUSH1 0x01 03A3 01 ADD 03A4 93 SWAP4 03A5 50 POP 03A6 50 POP 03A7 61 PUSH2 0x031f 03AA 56 *JUMP // Stack delta = +0 // Outputs[1] { @03A4 stack[-3] = 0x01 + stack[-3] } // Block ends with unconditional jump to 0x031f label_03AB: // Incoming jump from 0x0328, if !(stack[-3] < 0x20) // Incoming jump from 0x0328, if !(stack[-4] + 0x01 < 0x20) // Inputs[1] { @03AC stack[-4] } 03AB 5B JUMPDEST 03AC 83 DUP4 03AD 80 DUP1 03AE 60 PUSH1 0x01 03B0 01 ADD 03B1 94 SWAP5 03B2 50 POP 03B3 50 POP 03B4 61 PUSH2 0x030f 03B7 56 *JUMP // Stack delta = +0 // Outputs[1] { @03B1 stack[-4] = 0x01 + stack[-4] } // Block ends with unconditional jump to 0x030f label_03B8: // Incoming jump from 0x0318, if !(stack[-4] < 0x20) // Incoming jump from 0x0318, if !(0x00 < 0x20) 03B8 5B JUMPDEST 03B9 60 PUSH1 0x03 03BB 60 PUSH1 0x00 03BD 60 PUSH1 0x20 03BF 81 DUP2 03C0 10 LT 03C1 15 ISZERO 03C2 15 ISZERO 03C3 61 PUSH2 0x03c8 03C6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @03B9 stack[0] = 0x03 // @03BB stack[1] = 0x00 // } // Block ends with conditional jump to 0x03c8, if !!(0x00 < 0x20) label_03C7: // Incoming jump from 0x03C6, if not !!(0x00 < 0x20) 03C7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @03C7 assert(); } // Block terminates label_03C8: // Incoming jump from 0x03C6, if !!(0x00 < 0x20) // Inputs[4] // { // @03C9 stack[-1] // @03C9 stack[-2] // @03CA storage[stack[-1] + stack[-2]] // @03CB stack[-8] // } 03C8 5B JUMPDEST 03C9 01 ADD 03CA 54 SLOAD 03CB 86 DUP7 03CC 14 EQ 03CD 15 ISZERO 03CE 61 PUSH2 0x0494 03D1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0494, if !(stack[-8] == storage[stack[-1] + stack[-2]]) label_03D2: // Incoming jump from 0x03D1, if not !(stack[-8] == storage[stack[-1] + stack[-2]]) // Inputs[9] // { // @03F3 msg.sender // @03F4 stack[-5] // @03F7 memory[0x40:0x60] // @0437 memory[0x40:0x60] // @043C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0442 msg.sender // @047C memory[0x00:0x40] // @0484 storage[keccak256(memory[0x00:0x40])] // @049B stack[-7] // } 03D2 7F PUSH32 0xf524cff290ca88948da219ef106f97024214703e20ea88ab521bea6781ab5b41 03F3 33 CALLER 03F4 86 DUP7 03F5 60 PUSH1 0x40 03F7 51 MLOAD 03F8 80 DUP1 03F9 83 DUP4 03FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 040F 16 AND 0410 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0425 16 AND 0426 81 DUP2 0427 52 MSTORE 0428 60 PUSH1 0x20 042A 01 ADD 042B 82 DUP3 042C 81 DUP2 042D 52 MSTORE 042E 60 PUSH1 0x20 0430 01 ADD 0431 92 SWAP3 0432 50 POP 0433 50 POP 0434 50 POP 0435 60 PUSH1 0x40 0437 51 MLOAD 0438 80 DUP1 0439 91 SWAP2 043A 03 SUB 043B 90 SWAP1 043C A1 LOG1 043D 60 PUSH1 0x01 043F 60 PUSH1 0x00 0441 80 DUP1 0442 33 CALLER 0443 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0458 16 AND 0459 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 046E 16 AND 046F 81 DUP2 0470 52 MSTORE 0471 60 PUSH1 0x20 0473 01 ADD 0474 90 SWAP1 0475 81 DUP2 0476 52 MSTORE 0477 60 PUSH1 0x20 0479 01 ADD 047A 60 PUSH1 0x00 047C 20 SHA3 047D 60 PUSH1 0x00 047F 61 PUSH2 0x0100 0482 0A EXP 0483 81 DUP2 0484 54 SLOAD 0485 81 DUP2 0486 60 PUSH1 0xff 0488 02 MUL 0489 19 NOT 048A 16 AND 048B 90 SWAP1 048C 83 DUP4 048D 15 ISZERO 048E 15 ISZERO 048F 02 MUL 0490 17 OR 0491 90 SWAP1 0492 55 SSTORE 0493 50 POP 0494 5B JUMPDEST 0495 50 POP 0496 50 POP 0497 50 POP 0498 50 POP 0499 50 POP 049A 50 POP 049B 56 *JUMP // Stack delta = -7 // Outputs[6] // { // @0427 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @042D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-5] // @043C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xf524cff290ca88948da219ef106f97024214703e20ea88ab521bea6781ab5b41]); // @0470 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0476 memory[0x20:0x40] = 0x00 // @0492 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-7] label_049C: // Incoming call from 0x00E9, returns to 0x00EA // Inputs[4] // { // @04A2 stack[-1] // @04AA memory[0x00:0x40] // @04AF storage[keccak256(memory[0x00:0x40])] // @04BA stack[-2] // } 049C 5B JUMPDEST 049D 60 PUSH1 0x00 049F 60 PUSH1 0x20 04A1 52 MSTORE 04A2 80 DUP1 04A3 60 PUSH1 0x00 04A5 52 MSTORE 04A6 60 PUSH1 0x40 04A8 60 PUSH1 0x00 04AA 20 SHA3 04AB 60 PUSH1 0x00 04AD 91 SWAP2 04AE 50 POP 04AF 54 SLOAD 04B0 90 SWAP1 04B1 61 PUSH2 0x0100 04B4 0A EXP 04B5 90 SWAP1 04B6 04 DIV 04B7 60 PUSH1 0xff 04B9 16 AND 04BA 81 DUP2 04BB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04A1 memory[0x20:0x40] = 0x00 // @04A5 memory[0x00:0x20] = stack[-1] // @04B9 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_04BC: // Incoming call from 0x012E, returns to 0x012F // Inputs[2] // { // @04C2 storage[0x01] // @04F6 msg.sender // } 04BC 5B JUMPDEST 04BD 60 PUSH1 0x01 04BF 60 PUSH1 0x00 04C1 90 SWAP1 04C2 54 SLOAD 04C3 90 SWAP1 04C4 61 PUSH2 0x0100 04C7 0A EXP 04C8 90 SWAP1 04C9 04 DIV 04CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04DF 16 AND 04E0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04F5 16 AND 04F6 33 CALLER 04F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 050C 16 AND 050D 14 EQ 050E 15 ISZERO 050F 15 ISZERO 0510 61 PUSH2 0x0518 0513 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0518, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) label_0514: // Incoming jump from 0x0513, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) // Inputs[1] { @0517 memory[0x00:0x00] } 0514 60 PUSH1 0x00 0516 80 DUP1 0517 FD *REVERT // Stack delta = +0 // Outputs[1] { @0517 revert(memory[0x00:0x00]); } // Block terminates label_0518: // Incoming jump from 0x0513, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) // Inputs[2] // { // @0519 stack[-1] // @0521 stack[-2] // } 0518 5B JUMPDEST 0519 80 DUP1 051A 60 PUSH1 0x02 051C 81 DUP2 051D 90 SWAP1 051E 55 SSTORE 051F 50 POP 0520 50 POP 0521 56 *JUMP // Stack delta = -2 // Outputs[1] { @051E storage[0x02] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0522: // Incoming call from 0x0171, returns to 0x0172 // Inputs[2] // { // @0528 storage[0x01] // @055C msg.sender // } 0522 5B JUMPDEST 0523 60 PUSH1 0x01 0525 60 PUSH1 0x00 0527 90 SWAP1 0528 54 SLOAD 0529 90 SWAP1 052A 61 PUSH2 0x0100 052D 0A EXP 052E 90 SWAP1 052F 04 DIV 0530 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0545 16 AND 0546 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 055B 16 AND 055C 33 CALLER 055D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0572 16 AND 0573 14 EQ 0574 15 ISZERO 0575 15 ISZERO 0576 61 PUSH2 0x057e 0579 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x057e, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) label_057A: // Incoming jump from 0x0579, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) // Inputs[1] { @057D memory[0x00:0x00] } 057A 60 PUSH1 0x00 057C 80 DUP1 057D FD *REVERT // Stack delta = +0 // Outputs[1] { @057D revert(memory[0x00:0x00]); } // Block terminates label_057E: // Incoming jump from 0x0579, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) // Inputs[4] // { // @0584 stack[-1] // @05BE memory[0x00:0x40] // @05C6 storage[keccak256(memory[0x00:0x40])] // @05D7 stack[-2] // } 057E 5B JUMPDEST 057F 60 PUSH1 0x01 0581 60 PUSH1 0x00 0583 80 DUP1 0584 83 DUP4 0585 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 059A 16 AND 059B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05B0 16 AND 05B1 81 DUP2 05B2 52 MSTORE 05B3 60 PUSH1 0x20 05B5 01 ADD 05B6 90 SWAP1 05B7 81 DUP2 05B8 52 MSTORE 05B9 60 PUSH1 0x20 05BB 01 ADD 05BC 60 PUSH1 0x00 05BE 20 SHA3 05BF 60 PUSH1 0x00 05C1 61 PUSH2 0x0100 05C4 0A EXP 05C5 81 DUP2 05C6 54 SLOAD 05C7 81 DUP2 05C8 60 PUSH1 0xff 05CA 02 MUL 05CB 19 NOT 05CC 16 AND 05CD 90 SWAP1 05CE 83 DUP4 05CF 15 ISZERO 05D0 15 ISZERO 05D1 02 MUL 05D2 17 OR 05D3 90 SWAP1 05D4 55 SSTORE 05D5 50 POP 05D6 50 POP 05D7 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @05B2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @05B8 memory[0x20:0x40] = 0x00 // @05D4 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_05D8: // Incoming call from 0x01B4, returns to 0x01B5 // Inputs[4] // { // @05DE stack[-1] // @0618 memory[0x00:0x40] // @061C storage[keccak256(memory[0x00:0x40])] // @0629 stack[-2] // } 05D8 5B JUMPDEST 05D9 60 PUSH1 0x00 05DB 80 DUP1 05DC 60 PUSH1 0x00 05DE 83 DUP4 05DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05F4 16 AND 05F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 060A 16 AND 060B 81 DUP2 060C 52 MSTORE 060D 60 PUSH1 0x20 060F 01 ADD 0610 90 SWAP1 0611 81 DUP2 0612 52 MSTORE 0613 60 PUSH1 0x20 0615 01 ADD 0616 60 PUSH1 0x00 0618 20 SHA3 0619 60 PUSH1 0x00 061B 90 SWAP1 061C 54 SLOAD 061D 90 SWAP1 061E 61 PUSH2 0x0100 0621 0A EXP 0622 90 SWAP1 0623 04 DIV 0624 60 PUSH1 0xff 0626 16 AND 0627 90 SWAP1 0628 50 POP 0629 91 SWAP2 062A 90 SWAP1 062B 50 POP 062C 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @060C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0612 memory[0x20:0x40] = 0x00 // @0629 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] 062D 00 *STOP 062E A1 LOG1 062F 65 PUSH6 0x627a7a723058 0636 20 SHA3 0637 D6 D6 0638 5E 5E 0639 CE CE 063A 70 PUSH17 0x469086b39caca53e2fea968407342232d8 064C F8 F8 064D A7 A7 064E 1E 1E 064F D7 D7 0650 30 ADDRESS 0651 F9 F9 0652 6D PUSH14 0x1785f53c0029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]