Online Solidity Decompiler

« Decompile another contract

Address

0x2f797ebd6bb007b0bb1df71cb3b827a3e35a7625 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x22e8c8fc gamble(uint256,uint256)
0x88896a0d deliverPrize(address,bytes)
0xfb4fd984 requestPrize(bytes32,uint8,bytes32,bytes32)

Internal Methods

gamble(arg0, arg1)
deliverPrize(arg0, arg1)
requestPrize(arg0, arg1, arg2, arg3) 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 = 0x0091; var var2 = msg.data[0x04:0x24]; var var3 = msg.data[0x24:0x44]; gamble(var2, var3); stop(); } else if (var0 == 0x88896a0d) { // Dispatch table entry for deliverPrize(address,bytes) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x011a; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var temp0 = msg.data[0x24:0x44] + 0x04; var temp1 = msg.data[temp0:temp0 + 0x20]; var temp2 = memory[0x40:0x60]; memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp2:temp2 + 0x20] = temp1; memory[temp2 + 0x20:temp2 + 0x20 + temp1] = msg.data[temp0 + 0x20:temp0 + 0x20 + temp1]; var3 = temp2; deliverPrize(var2, var3); stop(); } else if (var0 == 0xfb4fd984) { // Dispatch table entry for requestPrize(bytes32,uint8,bytes32,bytes32) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0174; var2 = msg.data[0x04:0x24]; var3 = msg.data[0x24:0x44] & 0xff; var var4 = msg.data[0x44:0x64]; var var5 = msg.data[0x64:0x84]; var1 = requestPrize(var2, var3, var4, var5); var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = !!var1; var temp4 = memory[0x40:0x60]; return memory[temp4:temp4 + (temp3 + 0x20) - temp4]; } else { revert(memory[0x00:0x00]); } } function gamble(var arg0, var arg1) { var var0 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0x22e8c8fc; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; memory[temp1:temp1 + 0x20] = arg0; var temp2 = temp1 + 0x20; memory[temp2:temp2 + 0x20] = arg1; var var2 = temp2 + 0x20; var var3 = 0x00; var var4 = memory[0x40:0x60]; var var5 = var2 - var4; var var6 = var4; var var7 = 0x00; var var8 = var0; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp3; temp3, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp3; if (!var3) { return; } var temp4 = returndata.length; memory[0x00:0x00 + temp4] = returndata[0x00:0x00 + temp4]; revert(memory[0x00:0x00 + returndata.length]); } function deliverPrize(var arg0, var arg1) { if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var var0 = 0x323412b3ed32efe977849903daead71dbc4774839b863e1973a02e587dc73f80; var var1 = arg0; var temp0 = arg1; var var2 = temp0; var temp1 = memory[0x40:0x60]; var var3 = temp1; memory[var3:var3 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var temp2 = var3 + 0x20; var var4 = temp2; var temp3 = var4 + 0x20; memory[var4:var4 + 0x20] = temp3 - var3; memory[temp3:temp3 + 0x20] = memory[var2:var2 + 0x20]; var var5 = temp3 + 0x20; var var6 = var2 + 0x20; var var7 = memory[var2:var2 + 0x20]; var var8 = var7; var var9 = var5; var var10 = var6; var var11 = 0x00; if (var11 >= var8) { label_0333: var temp4 = var7; var5 = temp4 + var5; var6 = temp4 & 0x1f; if (!var6) { var temp5 = memory[0x40:0x60]; log(memory[temp5:temp5 + var5 - temp5], [stack[-7]]); return; } else { var temp6 = var6; var temp7 = var5 - temp6; memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20]; var temp8 = memory[0x40:0x60]; log(memory[temp8:temp8 + (temp7 + 0x20) - temp8], [stack[-7]]); return; } } else { label_0321: var temp9 = var11; memory[var9 + temp9:var9 + temp9 + 0x20] = memory[var10 + temp9:var10 + temp9 + 0x20]; var11 = temp9 + 0x20; if (var11 >= var8) { goto label_0333; } else { goto label_0321; } } } function requestPrize(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x00; var var1 = msg.sender; var var2 = 0x01; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x00; memory[0x40:0x60] = temp0 + 0x20; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = arg0; var temp2 = temp1 + 0x20; memory[temp2:temp2 + 0x20] = arg1 & 0xff; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = arg2; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x20] = arg3; var var3 = temp4 + 0x20; var temp5 = memory[0x40:0x60]; var temp6; temp6, memory[temp5 - 0x20:temp5 - 0x20 + 0x20] = address(var2).call.gas(msg.gas)(memory[temp5:temp5 + var3 - temp5]); var var4 = !temp6; if (!var4) { var temp7 = memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff == var1; var1 = temp7; if (!var1) { label_0522: if (!var1) { return 0x00; } var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = arg0; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x20] = arg1 & 0xff; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = arg2; var temp11 = temp10 + 0x20; memory[temp11:temp11 + 0x20] = arg3; var temp12 = memory[0x40:0x60]; log(memory[temp12:temp12 + (temp11 + 0x20) - temp12], [0xb57a6638558b0f492ac22be013a619afc0486aaa433dad38d928098dabe86573]); return 0x01; } else { var1 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0x9d9ca28d; var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = (var2 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; var temp14 = temp13 + 0x04; memory[temp14:temp14 + 0x20] = msg.sender; var3 = temp14 + 0x20; var4 = 0x20; var var5 = memory[0x40:0x60]; var var6 = var3 - var5; var var7 = var5; var var8 = 0x00; var var9 = var1; var var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } var temp15; temp15, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]); var4 = !temp15; if (!var4) { var1 = memory[0x40:0x60]; var2 = returndata.length; if (var2 < 0x20) { revert(memory[0x00:0x00]); } var1 = memory[var1:var1 + 0x20]; goto label_0522; } else { var temp16 = returndata.length; memory[0x00:0x00 + temp16] = returndata[0x00:0x00 + temp16]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var temp17 = returndata.length; memory[0x00:0x00 + temp17] = returndata[0x00:0x00 + temp17]; revert(memory[0x00:0x00 + returndata.length]); } } }

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 0x0057 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0057, 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 0x005c 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x005c, 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 0x88896a0d 0047 14 EQ 0048 61 PUSH2 0x0093 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0093, if 0x88896a0d == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x88896a0d == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xfb4fd984 0052 14 EQ 0053 61 PUSH2 0x011c 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011c, if 0xfb4fd984 == stack[-1] label_0057: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0056, if not 0xfb4fd984 == stack[-1] // Inputs[1] { @005B memory[0x00:0x00] } 0057 5B JUMPDEST 0058 60 PUSH1 0x00 005A 80 DUP1 005B FD *REVERT // Stack delta = +0 // Outputs[1] { @005B revert(memory[0x00:0x00]); } // Block terminates label_005C: // Incoming jump from 0x0040, if 0x22e8c8fc == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @005D msg.value } 005C 5B JUMPDEST 005D 34 CALLVALUE 005E 80 DUP1 005F 15 ISZERO 0060 61 PUSH2 0x0068 0063 57 *JUMPI // Stack delta = +1 // Outputs[1] { @005D stack[0] = msg.value } // Block ends with conditional jump to 0x0068, if !msg.value label_0064: // Incoming jump from 0x0063, if not !msg.value // Inputs[1] { @0067 memory[0x00:0x00] } 0064 60 PUSH1 0x00 0066 80 DUP1 0067 FD *REVERT // Stack delta = +0 // Outputs[1] { @0067 revert(memory[0x00:0x00]); } // Block terminates label_0068: // Incoming jump from 0x0063, if !msg.value // Inputs[3] // { // @0070 msg.data.length // @0077 msg.data[0x04:0x24] // @0081 msg.data[0x24:0x44] // } 0068 5B JUMPDEST 0069 50 POP 006A 61 PUSH2 0x0091 006D 60 PUSH1 0x04 006F 80 DUP1 0070 36 CALLDATASIZE 0071 03 SUB 0072 81 DUP2 0073 01 ADD 0074 90 SWAP1 0075 80 DUP1 0076 80 DUP1 0077 35 CALLDATALOAD 0078 90 SWAP1 0079 60 PUSH1 0x20 007B 01 ADD 007C 90 SWAP1 007D 92 SWAP3 007E 91 SWAP2 007F 90 SWAP1 0080 80 DUP1 0081 35 CALLDATALOAD 0082 90 SWAP1 0083 60 PUSH1 0x20 0085 01 ADD 0086 90 SWAP1 0087 92 SWAP3 0088 91 SWAP2 0089 90 SWAP1 008A 50 POP 008B 50 POP 008C 50 POP 008D 61 PUSH2 0x018e 0090 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @006A stack[-1] = 0x0091 // @007D stack[0] = msg.data[0x04:0x24] // @0087 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x018e, returns to 0x0091 label_0091: // Incoming return from call to 0x018E at 0x0090 0091 5B JUMPDEST 0092 00 *STOP // Stack delta = +0 // Outputs[1] { @0092 stop(); } // Block terminates label_0093: // Incoming jump from 0x004B, if 0x88896a0d == stack[-1] // Inputs[1] { @0094 msg.value } 0093 5B JUMPDEST 0094 34 CALLVALUE 0095 80 DUP1 0096 15 ISZERO 0097 61 PUSH2 0x009f 009A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0094 stack[0] = msg.value } // Block ends with conditional jump to 0x009f, if !msg.value label_009B: // Incoming jump from 0x009A, if not !msg.value // Inputs[1] { @009E memory[0x00:0x00] } 009B 60 PUSH1 0x00 009D 80 DUP1 009E FD *REVERT // Stack delta = +0 // Outputs[1] { @009E revert(memory[0x00:0x00]); } // Block terminates label_009F: // Incoming jump from 0x009A, if !msg.value // Inputs[6] // { // @00A7 msg.data.length // @00AE msg.data[0x04:0x24] // @00CE msg.data[0x24:0x44] // @00D7 msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] // @00ED memory[0x40:0x60] // @0104 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]] // } 009F 5B JUMPDEST 00A0 50 POP 00A1 61 PUSH2 0x011a 00A4 60 PUSH1 0x04 00A6 80 DUP1 00A7 36 CALLDATASIZE 00A8 03 SUB 00A9 81 DUP2 00AA 01 ADD 00AB 90 SWAP1 00AC 80 DUP1 00AD 80 DUP1 00AE 35 CALLDATALOAD 00AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 00C4 16 AND 00C5 90 SWAP1 00C6 60 PUSH1 0x20 00C8 01 ADD 00C9 90 SWAP1 00CA 92 SWAP3 00CB 91 SWAP2 00CC 90 SWAP1 00CD 80 DUP1 00CE 35 CALLDATALOAD 00CF 90 SWAP1 00D0 60 PUSH1 0x20 00D2 01 ADD 00D3 90 SWAP1 00D4 82 DUP3 00D5 01 ADD 00D6 80 DUP1 00D7 35 CALLDATALOAD 00D8 90 SWAP1 00D9 60 PUSH1 0x20 00DB 01 ADD 00DC 90 SWAP1 00DD 80 DUP1 00DE 80 DUP1 00DF 60 PUSH1 0x1f 00E1 01 ADD 00E2 60 PUSH1 0x20 00E4 80 DUP1 00E5 91 SWAP2 00E6 04 DIV 00E7 02 MUL 00E8 60 PUSH1 0x20 00EA 01 ADD 00EB 60 PUSH1 0x40 00ED 51 MLOAD 00EE 90 SWAP1 00EF 81 DUP2 00F0 01 ADD 00F1 60 PUSH1 0x40 00F3 52 MSTORE 00F4 80 DUP1 00F5 93 SWAP4 00F6 92 SWAP3 00F7 91 SWAP2 00F8 90 SWAP1 00F9 81 DUP2 00FA 81 DUP2 00FB 52 MSTORE 00FC 60 PUSH1 0x20 00FE 01 ADD 00FF 83 DUP4 0100 83 DUP4 0101 80 DUP1 0102 82 DUP3 0103 84 DUP5 0104 37 CALLDATACOPY 0105 82 DUP3 0106 01 ADD 0107 91 SWAP2 0108 50 POP 0109 50 POP 010A 50 POP 010B 50 POP 010C 50 POP 010D 50 POP 010E 91 SWAP2 010F 92 SWAP3 0110 91 SWAP2 0111 92 SWAP3 0112 90 SWAP1 0113 50 POP 0114 50 POP 0115 50 POP 0116 61 PUSH2 0x0242 0119 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @00A1 stack[-1] = 0x011a // @00CA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @00F3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20]) / 0x20 * 0x20 // @00FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x24:0x44]:0x04 + msg.data[0x24:0x44] + 0x20] // @0104 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 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]] // @0111 stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x0242, returns to 0x011A label_011A: // Incoming return from call to 0x0242 at 0x0119 011A 5B JUMPDEST 011B 00 *STOP // Stack delta = +0 // Outputs[1] { @011B stop(); } // Block terminates label_011C: // Incoming jump from 0x0056, if 0xfb4fd984 == stack[-1] // Inputs[1] { @011D msg.value } 011C 5B JUMPDEST 011D 34 CALLVALUE 011E 80 DUP1 011F 15 ISZERO 0120 61 PUSH2 0x0128 0123 57 *JUMPI // Stack delta = +1 // Outputs[1] { @011D stack[0] = msg.value } // Block ends with conditional jump to 0x0128, if !msg.value label_0124: // Incoming jump from 0x0123, if not !msg.value // Inputs[1] { @0127 memory[0x00:0x00] } 0124 60 PUSH1 0x00 0126 80 DUP1 0127 FD *REVERT // Stack delta = +0 // Outputs[1] { @0127 revert(memory[0x00:0x00]); } // Block terminates label_0128: // Incoming jump from 0x0123, if !msg.value // Inputs[5] // { // @0130 msg.data.length // @0137 msg.data[0x04:0x24] // @0145 msg.data[0x24:0x44] // @0152 msg.data[0x44:0x64] // @0160 msg.data[0x64:0x84] // } 0128 5B JUMPDEST 0129 50 POP 012A 61 PUSH2 0x0174 012D 60 PUSH1 0x04 012F 80 DUP1 0130 36 CALLDATASIZE 0131 03 SUB 0132 81 DUP2 0133 01 ADD 0134 90 SWAP1 0135 80 DUP1 0136 80 DUP1 0137 35 CALLDATALOAD 0138 60 PUSH1 0x00 013A 19 NOT 013B 16 AND 013C 90 SWAP1 013D 60 PUSH1 0x20 013F 01 ADD 0140 90 SWAP1 0141 92 SWAP3 0142 91 SWAP2 0143 90 SWAP1 0144 80 DUP1 0145 35 CALLDATALOAD 0146 60 PUSH1 0xff 0148 16 AND 0149 90 SWAP1 014A 60 PUSH1 0x20 014C 01 ADD 014D 90 SWAP1 014E 92 SWAP3 014F 91 SWAP2 0150 90 SWAP1 0151 80 DUP1 0152 35 CALLDATALOAD 0153 60 PUSH1 0x00 0155 19 NOT 0156 16 AND 0157 90 SWAP1 0158 60 PUSH1 0x20 015A 01 ADD 015B 90 SWAP1 015C 92 SWAP3 015D 91 SWAP2 015E 90 SWAP1 015F 80 DUP1 0160 35 CALLDATALOAD 0161 60 PUSH1 0x00 0163 19 NOT 0164 16 AND 0165 90 SWAP1 0166 60 PUSH1 0x20 0168 01 ADD 0169 90 SWAP1 016A 92 SWAP3 016B 91 SWAP2 016C 90 SWAP1 016D 50 POP 016E 50 POP 016F 50 POP 0170 61 PUSH2 0x0372 0173 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @012A stack[-1] = 0x0174 // @0141 stack[0] = ~0x00 & msg.data[0x04:0x24] // @014E stack[1] = 0xff & msg.data[0x24:0x44] // @015C stack[2] = ~0x00 & msg.data[0x44:0x64] // @016A stack[3] = ~0x00 & msg.data[0x64:0x84] // } // Block ends with call to 0x0372, returns to 0x0174 label_0174: // Incoming return from call to 0x0372 at 0x0173 // Inputs[4] // { // @0177 memory[0x40:0x60] // @0179 stack[-1] // @0188 memory[0x40:0x60] // @018D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0174 5B JUMPDEST 0175 60 PUSH1 0x40 0177 51 MLOAD 0178 80 DUP1 0179 82 DUP3 017A 15 ISZERO 017B 15 ISZERO 017C 15 ISZERO 017D 15 ISZERO 017E 81 DUP2 017F 52 MSTORE 0180 60 PUSH1 0x20 0182 01 ADD 0183 91 SWAP2 0184 50 POP 0185 50 POP 0186 60 PUSH1 0x40 0188 51 MLOAD 0189 80 DUP1 018A 91 SWAP2 018B 03 SUB 018C 90 SWAP1 018D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @017F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @018D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_018E: // Incoming call from 0x0090, returns to 0x0091 // Inputs[6] // { // @0193 storage[0x00] // @01CC stack[-2] // @01CD stack[-1] // @01D0 memory[0x40:0x60] // @0211 memory[0x40:0x60] // @021A address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // } 018E 5B JUMPDEST 018F 60 PUSH1 0x00 0191 80 DUP1 0192 90 SWAP1 0193 54 SLOAD 0194 90 SWAP1 0195 61 PUSH2 0x0100 0198 0A EXP 0199 90 SWAP1 019A 04 DIV 019B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01B0 16 AND 01B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01C6 16 AND 01C7 63 PUSH4 0x22e8c8fc 01CC 83 DUP4 01CD 83 DUP4 01CE 60 PUSH1 0x40 01D0 51 MLOAD 01D1 83 DUP4 01D2 63 PUSH4 0xffffffff 01D7 16 AND 01D8 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 01F6 02 MUL 01F7 81 DUP2 01F8 52 MSTORE 01F9 60 PUSH1 0x04 01FB 01 ADD 01FC 80 DUP1 01FD 83 DUP4 01FE 81 DUP2 01FF 52 MSTORE 0200 60 PUSH1 0x20 0202 01 ADD 0203 82 DUP3 0204 81 DUP2 0205 52 MSTORE 0206 60 PUSH1 0x20 0208 01 ADD 0209 92 SWAP3 020A 50 POP 020B 50 POP 020C 50 POP 020D 60 PUSH1 0x00 020F 60 PUSH1 0x40 0211 51 MLOAD 0212 80 DUP1 0213 83 DUP4 0214 03 SUB 0215 81 DUP2 0216 60 PUSH1 0x00 0218 87 DUP8 0219 80 DUP1 021A 3B EXTCODESIZE 021B 15 ISZERO 021C 80 DUP1 021D 15 ISZERO 021E 61 PUSH2 0x0226 0221 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @01C6 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // @01C7 stack[1] = 0x22e8c8fc // @01F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x22e8c8fc) // @01FF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-2] // @0205 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @0209 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @020D stack[3] = 0x00 // @0211 stack[4] = memory[0x40:0x60] // @0214 stack[5] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0215 stack[6] = memory[0x40:0x60] // @0216 stack[7] = 0x00 // @0218 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // @021B stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x0226, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length label_0222: // Incoming jump from 0x0221, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // Inputs[1] { @0225 memory[0x00:0x00] } 0222 60 PUSH1 0x00 0224 80 DUP1 0225 FD *REVERT // Stack delta = +0 // Outputs[1] { @0225 revert(memory[0x00:0x00]); } // Block terminates label_0226: // Incoming jump from 0x0221, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @0228 msg.gas // @0229 stack[-3] // @0229 stack[-7] // @0229 stack[-6] // @0229 stack[-5] // @0229 stack[-4] // @0229 stack[-2] // @0229 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0229 memory[stack[-4]:stack[-4] + stack[-5]] // } 0226 5B JUMPDEST 0227 50 POP 0228 5A GAS 0229 F1 CALL 022A 15 ISZERO 022B 80 DUP1 022C 15 ISZERO 022D 61 PUSH2 0x023a 0230 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0229 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @022A stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x023a, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0231: // Incoming jump from 0x0230, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0231 returndata.length // @0235 returndata[0x00:0x00 + returndata.length] // @0236 returndata.length // @0239 memory[0x00:0x00 + returndata.length] // } 0231 3D RETURNDATASIZE 0232 60 PUSH1 0x00 0234 80 DUP1 0235 3E RETURNDATACOPY 0236 3D RETURNDATASIZE 0237 60 PUSH1 0x00 0239 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0235 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0239 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_023A: // Incoming jump from 0x0230, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0241 stack[-7] } 023A 5B JUMPDEST 023B 50 POP 023C 50 POP 023D 50 POP 023E 50 POP 023F 50 POP 0240 50 POP 0241 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0242: // Incoming call from 0x0119, returns to 0x011A // Inputs[2] // { // @0248 storage[0x01] // @027C msg.sender // } 0242 5B JUMPDEST 0243 60 PUSH1 0x01 0245 60 PUSH1 0x00 0247 90 SWAP1 0248 54 SLOAD 0249 90 SWAP1 024A 61 PUSH2 0x0100 024D 0A EXP 024E 90 SWAP1 024F 04 DIV 0250 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0265 16 AND 0266 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 027B 16 AND 027C 33 CALLER 027D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0292 16 AND 0293 14 EQ 0294 15 ISZERO 0295 15 ISZERO 0296 61 PUSH2 0x029e 0299 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029e, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) label_029A: // Incoming jump from 0x0299, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) // Inputs[1] { @029D memory[0x00:0x00] } 029A 60 PUSH1 0x00 029C 80 DUP1 029D FD *REVERT // Stack delta = +0 // Outputs[1] { @029D revert(memory[0x00:0x00]); } // Block terminates label_029E: // Incoming jump from 0x0299, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00) // Inputs[5] // { // @02C0 stack[-2] // @02C1 stack[-1] // @02C4 memory[0x40:0x60] // @0304 memory[stack[-1]:stack[-1] + 0x20] // @030D memory[stack[-1]:stack[-1] + 0x20] // } 029E 5B JUMPDEST 029F 7F PUSH32 0x323412b3ed32efe977849903daead71dbc4774839b863e1973a02e587dc73f80 02C0 82 DUP3 02C1 82 DUP3 02C2 60 PUSH1 0x40 02C4 51 MLOAD 02C5 80 DUP1 02C6 83 DUP4 02C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02DC 16 AND 02DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02F2 16 AND 02F3 81 DUP2 02F4 52 MSTORE 02F5 60 PUSH1 0x20 02F7 01 ADD 02F8 80 DUP1 02F9 60 PUSH1 0x20 02FB 01 ADD 02FC 82 DUP3 02FD 81 DUP2 02FE 03 SUB 02FF 82 DUP3 0300 52 MSTORE 0301 83 DUP4 0302 81 DUP2 0303 81 DUP2 0304 51 MLOAD 0305 81 DUP2 0306 52 MSTORE 0307 60 PUSH1 0x20 0309 01 ADD 030A 91 SWAP2 030B 50 POP 030C 80 DUP1 030D 51 MLOAD 030E 90 SWAP1 030F 60 PUSH1 0x20 0311 01 ADD 0312 90 SWAP1 0313 80 DUP1 0314 83 DUP4 0315 83 DUP4 0316 60 PUSH1 0x00 0318 5B JUMPDEST 0319 83 DUP4 031A 81 DUP2 031B 10 LT 031C 15 ISZERO 031D 61 PUSH2 0x0333 0320 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @029F stack[0] = 0x323412b3ed32efe977849903daead71dbc4774839b863e1973a02e587dc73f80 // @02C0 stack[1] = stack[-2] // @02C1 stack[2] = stack[-1] // @02C4 stack[3] = memory[0x40:0x60] // @02F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @02F7 stack[4] = 0x20 + memory[0x40:0x60] // @0300 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0306 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @030A stack[5] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0312 stack[6] = 0x20 + stack[-1] // @0312 stack[7] = memory[stack[-1]:stack[-1] + 0x20] // @0313 stack[8] = memory[stack[-1]:stack[-1] + 0x20] // @0314 stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0315 stack[10] = 0x20 + stack[-1] // @0316 stack[11] = 0x00 // } // Block ends with conditional jump to 0x0333, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0321: // Incoming jump from 0x0320, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0320, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0321 stack[-1] // @0322 stack[-2] // @0324 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0326 stack[-3] // } 0321 80 DUP1 0322 82 DUP3 0323 01 ADD 0324 51 MLOAD 0325 81 DUP2 0326 84 DUP5 0327 01 ADD 0328 52 MSTORE 0329 60 PUSH1 0x20 032B 81 DUP2 032C 01 ADD 032D 90 SWAP1 032E 50 POP 032F 61 PUSH2 0x0318 0332 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0328 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @032D stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0318 label_0333: // Incoming jump from 0x0320, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0320, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0338 stack[-6] // @0338 stack[-5] // @033A stack[-7] // } 0333 5B JUMPDEST 0334 50 POP 0335 50 POP 0336 50 POP 0337 50 POP 0338 90 SWAP1 0339 50 POP 033A 90 SWAP1 033B 81 DUP2 033C 01 ADD 033D 90 SWAP1 033E 60 PUSH1 0x1f 0340 16 AND 0341 80 DUP1 0342 15 ISZERO 0343 61 PUSH2 0x0360 0346 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @033D stack[-7] = stack[-5] + stack[-7] // @0340 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0360, if !(0x1f & stack[-5]) label_0347: // Incoming jump from 0x0346, if not !(0x1f & stack[-5]) // Inputs[8] // { // @0347 stack[-1] // @0348 stack[-2] // @034B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0362 stack[-6] // @0369 memory[0x40:0x60] // @036E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @036E stack[-7] // @0371 stack[-10] // } 0347 80 DUP1 0348 82 DUP3 0349 03 SUB 034A 80 DUP1 034B 51 MLOAD 034C 60 PUSH1 0x01 034E 83 DUP4 034F 60 PUSH1 0x20 0351 03 SUB 0352 61 PUSH2 0x0100 0355 0A EXP 0356 03 SUB 0357 19 NOT 0358 16 AND 0359 81 DUP2 035A 52 MSTORE 035B 60 PUSH1 0x20 035D 01 ADD 035E 91 SWAP2 035F 50 POP 0360 5B JUMPDEST 0361 50 POP 0362 93 SWAP4 0363 50 POP 0364 50 POP 0365 50 POP 0366 50 POP 0367 60 PUSH1 0x40 0369 51 MLOAD 036A 80 DUP1 036B 91 SWAP2 036C 03 SUB 036D 90 SWAP1 036E A1 LOG1 036F 50 POP 0370 50 POP 0371 56 *JUMP // Stack delta = -10 // Outputs[2] // { // @035A 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] // @036E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-7]]); // } // Block ends with unconditional jump to stack[-10] label_0372: // Incoming call from 0x0173, returns to 0x0174 // Inputs[11] // { // @0375 msg.sender // @038E stack[-4] // @038F stack[-3] // @0390 stack[-2] // @0391 stack[-1] // @0394 memory[0x40:0x60] // @03A1 memory[0x40:0x60] // @03E3 memory[0x40:0x60] // @03F0 msg.gas // @03F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @03F1 address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 0372 5B JUMPDEST 0373 60 PUSH1 0x00 0375 33 CALLER 0376 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 038B 16 AND 038C 60 PUSH1 0x01 038E 86 DUP7 038F 86 DUP7 0390 86 DUP7 0391 86 DUP7 0392 60 PUSH1 0x40 0394 51 MLOAD 0395 60 PUSH1 0x00 0397 81 DUP2 0398 52 MSTORE 0399 60 PUSH1 0x20 039B 01 ADD 039C 60 PUSH1 0x40 039E 52 MSTORE 039F 60 PUSH1 0x40 03A1 51 MLOAD 03A2 80 DUP1 03A3 85 DUP6 03A4 60 PUSH1 0x00 03A6 19 NOT 03A7 16 AND 03A8 60 PUSH1 0x00 03AA 19 NOT 03AB 16 AND 03AC 81 DUP2 03AD 52 MSTORE 03AE 60 PUSH1 0x20 03B0 01 ADD 03B1 84 DUP5 03B2 60 PUSH1 0xff 03B4 16 AND 03B5 60 PUSH1 0xff 03B7 16 AND 03B8 81 DUP2 03B9 52 MSTORE 03BA 60 PUSH1 0x20 03BC 01 ADD 03BD 83 DUP4 03BE 60 PUSH1 0x00 03C0 19 NOT 03C1 16 AND 03C2 60 PUSH1 0x00 03C4 19 NOT 03C5 16 AND 03C6 81 DUP2 03C7 52 MSTORE 03C8 60 PUSH1 0x20 03CA 01 ADD 03CB 82 DUP3 03CC 60 PUSH1 0x00 03CE 19 NOT 03CF 16 AND 03D0 60 PUSH1 0x00 03D2 19 NOT 03D3 16 AND 03D4 81 DUP2 03D5 52 MSTORE 03D6 60 PUSH1 0x20 03D8 01 ADD 03D9 94 SWAP5 03DA 50 POP 03DB 50 POP 03DC 50 POP 03DD 50 POP 03DE 50 POP 03DF 60 PUSH1 0x20 03E1 60 PUSH1 0x40 03E3 51 MLOAD 03E4 60 PUSH1 0x20 03E6 81 DUP2 03E7 03 SUB 03E8 90 SWAP1 03E9 80 DUP1 03EA 84 DUP5 03EB 03 SUB 03EC 90 SWAP1 03ED 60 PUSH1 0x00 03EF 86 DUP7 03F0 5A GAS 03F1 F1 CALL 03F2 15 ISZERO 03F3 80 DUP1 03F4 15 ISZERO 03F5 61 PUSH2 0x0402 03F8 57 *JUMPI // Stack delta = +5 // Outputs[12] // { // @0373 stack[0] = 0x00 // @038B stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @038C stack[2] = 0x01 // @0398 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @039E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @03AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-4] // @03B9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-3] // @03C7 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-2] // @03D5 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-1] // @03D9 stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @03F1 memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @03F2 stack[4] = !address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0402, if !!address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_03F9: // Incoming jump from 0x03F8, if not !!address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @03F9 returndata.length // @03FD returndata[0x00:0x00 + returndata.length] // @03FE returndata.length // @0401 memory[0x00:0x00 + returndata.length] // } 03F9 3D RETURNDATASIZE 03FA 60 PUSH1 0x00 03FC 80 DUP1 03FD 3E RETURNDATACOPY 03FE 3D RETURNDATASIZE 03FF 60 PUSH1 0x00 0401 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @03FD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0401 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0402: // Incoming jump from 0x03F8, if !!address(0x01).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @040A memory[0x40:0x60] // @040C memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] // @0423 stack[-4] // } 0402 5B JUMPDEST 0403 50 POP 0404 50 POP 0405 50 POP 0406 60 PUSH1 0x20 0408 60 PUSH1 0x40 040A 51 MLOAD 040B 03 SUB 040C 51 MLOAD 040D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0422 16 AND 0423 14 EQ 0424 80 DUP1 0425 15 ISZERO 0426 61 PUSH2 0x0522 0429 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0423 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4] } // Block ends with conditional jump to 0x0522, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4]) label_042A: // Incoming jump from 0x0429, if not !(0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4]) // Inputs[5] // { // @042F storage[0x00] // @0468 msg.sender // @046B memory[0x40:0x60] // @04D1 memory[0x40:0x60] // @04DA address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // } 042A 50 POP 042B 60 PUSH1 0x00 042D 80 DUP1 042E 90 SWAP1 042F 54 SLOAD 0430 90 SWAP1 0431 61 PUSH2 0x0100 0434 0A EXP 0435 90 SWAP1 0436 04 DIV 0437 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 044C 16 AND 044D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0462 16 AND 0463 63 PUSH4 0x9d9ca28d 0468 33 CALLER 0469 60 PUSH1 0x40 046B 51 MLOAD 046C 82 DUP3 046D 63 PUSH4 0xffffffff 0472 16 AND 0473 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0491 02 MUL 0492 81 DUP2 0493 52 MSTORE 0494 60 PUSH1 0x04 0496 01 ADD 0497 80 DUP1 0498 82 DUP3 0499 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04AE 16 AND 04AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C4 16 AND 04C5 81 DUP2 04C6 52 MSTORE 04C7 60 PUSH1 0x20 04C9 01 ADD 04CA 91 SWAP2 04CB 50 POP 04CC 50 POP 04CD 60 PUSH1 0x20 04CF 60 PUSH1 0x40 04D1 51 MLOAD 04D2 80 DUP1 04D3 83 DUP4 04D4 03 SUB 04D5 81 DUP2 04D6 60 PUSH1 0x00 04D8 87 DUP8 04D9 80 DUP1 04DA 3B EXTCODESIZE 04DB 15 ISZERO 04DC 80 DUP1 04DD 15 ISZERO 04DE 61 PUSH2 0x04e6 04E1 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @0462 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // @0463 stack[0] = 0x9d9ca28d // @0493 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x9d9ca28d) // @04C6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @04CA stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @04CD stack[2] = 0x20 // @04D1 stack[3] = memory[0x40:0x60] // @04D4 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @04D5 stack[5] = memory[0x40:0x60] // @04D6 stack[6] = 0x00 // @04D8 stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // @04DB stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x04e6, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length label_04E2: // Incoming jump from 0x04E1, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // Inputs[1] { @04E5 memory[0x00:0x00] } 04E2 60 PUSH1 0x00 04E4 80 DUP1 04E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E5 revert(memory[0x00:0x00]); } // Block terminates label_04E6: // Incoming jump from 0x04E1, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @04E8 msg.gas // @04E9 stack[-3] // @04E9 stack[-7] // @04E9 stack[-6] // @04E9 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @04E9 stack[-2] // @04E9 memory[stack[-4]:stack[-4] + stack[-5]] // @04E9 stack[-5] // @04E9 stack[-4] // } 04E6 5B JUMPDEST 04E7 50 POP 04E8 5A GAS 04E9 F1 CALL 04EA 15 ISZERO 04EB 80 DUP1 04EC 15 ISZERO 04ED 61 PUSH2 0x04fa 04F0 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @04E9 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @04EA stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x04fa, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_04F1: // Incoming jump from 0x04F0, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @04F1 returndata.length // @04F5 returndata[0x00:0x00 + returndata.length] // @04F6 returndata.length // @04F9 memory[0x00:0x00 + returndata.length] // } 04F1 3D RETURNDATASIZE 04F2 60 PUSH1 0x00 04F4 80 DUP1 04F5 3E RETURNDATACOPY 04F6 3D RETURNDATASIZE 04F7 60 PUSH1 0x00 04F9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @04F5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @04F9 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_04FA: // Incoming jump from 0x04F0, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0501 memory[0x40:0x60] // @0502 returndata.length // } 04FA 5B JUMPDEST 04FB 50 POP 04FC 50 POP 04FD 50 POP 04FE 50 POP 04FF 60 PUSH1 0x40 0501 51 MLOAD 0502 3D RETURNDATASIZE 0503 60 PUSH1 0x20 0505 81 DUP2 0506 10 LT 0507 15 ISZERO 0508 61 PUSH2 0x0510 050B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0501 stack[-4] = memory[0x40:0x60] // @0502 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0510, if !(returndata.length < 0x20) label_050C: // Incoming jump from 0x050B, if not !(returndata.length < 0x20) // Inputs[1] { @050F memory[0x00:0x00] } 050C 60 PUSH1 0x00 050E 80 DUP1 050F FD *REVERT // Stack delta = +0 // Outputs[1] { @050F revert(memory[0x00:0x00]); } // Block terminates label_0510: // Incoming jump from 0x050B, if !(returndata.length < 0x20) // Inputs[3] // { // @0511 stack[-2] // @0512 stack[-1] // @0516 memory[stack[-2]:stack[-2] + 0x20] // } 0510 5B JUMPDEST 0511 81 DUP2 0512 01 ADD 0513 90 SWAP1 0514 80 DUP1 0515 80 DUP1 0516 51 MLOAD 0517 90 SWAP1 0518 60 PUSH1 0x20 051A 01 ADD 051B 90 SWAP1 051C 92 SWAP3 051D 91 SWAP2 051E 90 SWAP1 051F 50 POP 0520 50 POP 0521 50 POP // Stack delta = -1 // Outputs[1] { @051C stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_0522: // Incoming jump from 0x0521 // Incoming jump from 0x0429, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] == stack[-4]) // Inputs[1] { @0523 stack[-1] } 0522 5B JUMPDEST 0523 15 ISZERO 0524 61 PUSH2 0x059d 0527 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x059d, if !stack[-1] label_0528: // Incoming jump from 0x0527, if not !stack[-1] // Inputs[8] // { // @0549 stack[-5] // @054A stack[-4] // @054B stack[-3] // @054C stack[-2] // @054F memory[0x40:0x60] // @058F memory[0x40:0x60] // @0594 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0597 stack[-1] // } 0528 7F PUSH32 0xb57a6638558b0f492ac22be013a619afc0486aaa433dad38d928098dabe86573 0549 85 DUP6 054A 85 DUP6 054B 85 DUP6 054C 85 DUP6 054D 60 PUSH1 0x40 054F 51 MLOAD 0550 80 DUP1 0551 85 DUP6 0552 60 PUSH1 0x00 0554 19 NOT 0555 16 AND 0556 60 PUSH1 0x00 0558 19 NOT 0559 16 AND 055A 81 DUP2 055B 52 MSTORE 055C 60 PUSH1 0x20 055E 01 ADD 055F 84 DUP5 0560 60 PUSH1 0xff 0562 16 AND 0563 60 PUSH1 0xff 0565 16 AND 0566 81 DUP2 0567 52 MSTORE 0568 60 PUSH1 0x20 056A 01 ADD 056B 83 DUP4 056C 60 PUSH1 0x00 056E 19 NOT 056F 16 AND 0570 60 PUSH1 0x00 0572 19 NOT 0573 16 AND 0574 81 DUP2 0575 52 MSTORE 0576 60 PUSH1 0x20 0578 01 ADD 0579 82 DUP3 057A 60 PUSH1 0x00 057C 19 NOT 057D 16 AND 057E 60 PUSH1 0x00 0580 19 NOT 0581 16 AND 0582 81 DUP2 0583 52 MSTORE 0584 60 PUSH1 0x20 0586 01 ADD 0587 94 SWAP5 0588 50 POP 0589 50 POP 058A 50 POP 058B 50 POP 058C 50 POP 058D 60 PUSH1 0x40 058F 51 MLOAD 0590 80 DUP1 0591 91 SWAP2 0592 03 SUB 0593 90 SWAP1 0594 A1 LOG1 0595 60 PUSH1 0x01 0597 90 SWAP1 0598 50 POP 0599 61 PUSH2 0x05a2 059C 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @055B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-5] // @0567 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-4] // @0575 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-3] // @0583 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = ~0x00 & ~0x00 & stack[-2] // @0594 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xb57a6638558b0f492ac22be013a619afc0486aaa433dad38d928098dabe86573]); // @0597 stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x05a2 label_059D: // Incoming jump from 0x0527, if !stack[-1] // Inputs[3] // { // @05A0 stack[-1] // @05A3 stack[-6] // @05A4 stack[-5] // } 059D 5B JUMPDEST 059E 60 PUSH1 0x00 05A0 90 SWAP1 05A1 50 POP 05A2 5B JUMPDEST 05A3 94 SWAP5 05A4 93 SWAP4 05A5 50 POP 05A6 50 POP 05A7 50 POP 05A8 50 POP 05A9 56 *JUMP // Stack delta = -5 // Outputs[1] { @05A3 stack[-6] = 0x00 } // Block ends with unconditional jump to stack[-6] 05AA 00 *STOP 05AB A1 LOG1 05AC 65 PUSH6 0x627a7a723058 05B3 20 SHA3 05B4 56 *JUMP 05B5 37 CALLDATACOPY 05B6 88 DUP9 05B7 B2 SWAP 05B8 B3 B3 05B9 C0 C0 05BA A0 LOG0 05BB 28 28 05BC 9F SWAP16 05BD 77 PUSH24 0x20eb886c7c25bc46e44529473e0adbc9c56b0c68c7920029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]