Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x00af 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x00af, 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 0x06fdde03 003C 14 EQ 003D 61 PUSH2 0x00b9 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x00b9, if 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x095ea7b3 0047 14 EQ 0048 61 PUSH2 0x0147 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0147, if 0x095ea7b3 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x18160ddd 0052 14 EQ 0053 61 PUSH2 0x01a1 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a1, if 0x18160ddd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x18160ddd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x23b872dd 005D 14 EQ 005E 61 PUSH2 0x01ca 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ca, if 0x23b872dd == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x23b872dd == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x2e1a7d4d 0068 14 EQ 0069 61 PUSH2 0x0243 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0243, if 0x2e1a7d4d == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x2e1a7d4d == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x313ce567 0073 14 EQ 0074 61 PUSH2 0x0266 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0266, if 0x313ce567 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x313ce567 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x70a08231 007E 14 EQ 007F 61 PUSH2 0x0295 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0295, if 0x70a08231 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x70a08231 == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0x95d89b41 0089 14 EQ 008A 61 PUSH2 0x02e2 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e2, if 0x95d89b41 == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0x95d89b41 == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0xa9059cbb 0094 14 EQ 0095 61 PUSH2 0x0370 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0370, if 0xa9059cbb == stack[-1] label_0099: // Incoming jump from 0x0098, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0099 stack[-1] } 0099 80 DUP1 009A 63 PUSH4 0xd0e30db0 009F 14 EQ 00A0 61 PUSH2 0x03ca 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ca, if 0xd0e30db0 == stack[-1] label_00A4: // Incoming jump from 0x00A3, if not 0xd0e30db0 == stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A4 80 DUP1 00A5 63 PUSH4 0xdd62ed3e 00AA 14 EQ 00AB 61 PUSH2 0x03d4 00AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d4, if 0xdd62ed3e == stack[-1] label_00AF: // Incoming jump from 0x00AE, if not 0xdd62ed3e == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 00AF 5B JUMPDEST 00B0 61 PUSH2 0x00b7 00B3 61 PUSH2 0x0440 00B6 56 *JUMP // Stack delta = +1 // Outputs[1] { @00B0 stack[0] = 0x00b7 } // Block ends with call to 0x0440, returns to 0x00B7 label_00B7: // Incoming return from call to 0x0440 at 0x00B6 00B7 5B JUMPDEST 00B8 00 *STOP // Stack delta = +0 // Outputs[1] { @00B8 stop(); } // Block terminates label_00B9: // Incoming jump from 0x0040, if 0x06fdde03 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @00BA msg.value } 00B9 5B JUMPDEST 00BA 34 CALLVALUE 00BB 15 ISZERO 00BC 61 PUSH2 0x00c4 00BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c4, if !msg.value label_00C0: // Incoming jump from 0x00BF, if not !msg.value // Inputs[1] { @00C3 memory[0x00:0x00] } 00C0 60 PUSH1 0x00 00C2 80 DUP1 00C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @00C3 revert(memory[0x00:0x00]); } // Block terminates label_00C4: // Incoming jump from 0x00BF, if !msg.value 00C4 5B JUMPDEST 00C5 61 PUSH2 0x00cc 00C8 61 PUSH2 0x04dd 00CB 56 *JUMP // Stack delta = +1 // Outputs[1] { @00C5 stack[0] = 0x00cc } // Block ends with call to 0x04dd, returns to 0x00CC label_00CC: // Incoming return from call to 0x04DD at 0x00CB // Inputs[4] // { // @00CF memory[0x40:0x60] // @00DA stack[-1] // @00DD memory[stack[-1]:stack[-1] + 0x20] // @00E6 memory[stack[-1]:stack[-1] + 0x20] // } 00CC 5B JUMPDEST 00CD 60 PUSH1 0x40 00CF 51 MLOAD 00D0 80 DUP1 00D1 80 DUP1 00D2 60 PUSH1 0x20 00D4 01 ADD 00D5 82 DUP3 00D6 81 DUP2 00D7 03 SUB 00D8 82 DUP3 00D9 52 MSTORE 00DA 83 DUP4 00DB 81 DUP2 00DC 81 DUP2 00DD 51 MLOAD 00DE 81 DUP2 00DF 52 MSTORE 00E0 60 PUSH1 0x20 00E2 01 ADD 00E3 91 SWAP2 00E4 50 POP 00E5 80 DUP1 00E6 51 MLOAD 00E7 90 SWAP1 00E8 60 PUSH1 0x20 00EA 01 ADD 00EB 90 SWAP1 00EC 80 DUP1 00ED 83 DUP4 00EE 83 DUP4 00EF 60 PUSH1 0x00 00F1 5B JUMPDEST 00F2 83 DUP4 00F3 81 DUP2 00F4 10 LT 00F5 15 ISZERO 00F6 61 PUSH2 0x010c 00F9 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @00CF stack[0] = memory[0x40:0x60] // @00D0 stack[1] = memory[0x40:0x60] // @00D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @00DF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @00E3 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @00EB stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @00EB stack[3] = 0x20 + stack[-1] // @00EC stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @00ED stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @00EE stack[7] = 0x20 + stack[-1] // @00EF stack[8] = 0x00 // } // Block ends with conditional jump to 0x010c, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_00FA: // Incoming jump from 0x00F9, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x00F9, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @00FA stack[-1] // @00FB stack[-2] // @00FD memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @00FF stack[-3] // } 00FA 80 DUP1 00FB 82 DUP3 00FC 01 ADD 00FD 51 MLOAD 00FE 81 DUP2 00FF 84 DUP5 0100 01 ADD 0101 52 MSTORE 0102 60 PUSH1 0x20 0104 81 DUP2 0105 01 ADD 0106 90 SWAP1 0107 50 POP 0108 61 PUSH2 0x00f1 010B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0101 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0106 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x00f1 label_010C: // Incoming jump from 0x00F9, if !(stack[-1] < stack[-4]) // Incoming jump from 0x00F9, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0111 stack[-6] // @0111 stack[-5] // @0113 stack[-7] // } 010C 5B JUMPDEST 010D 50 POP 010E 50 POP 010F 50 POP 0110 50 POP 0111 90 SWAP1 0112 50 POP 0113 90 SWAP1 0114 81 DUP2 0115 01 ADD 0116 90 SWAP1 0117 60 PUSH1 0x1f 0119 16 AND 011A 80 DUP1 011B 15 ISZERO 011C 61 PUSH2 0x0139 011F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0116 stack[-7] = stack[-5] + stack[-7] // @0119 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0139, if !(0x1f & stack[-5]) label_0120: // Incoming jump from 0x011F, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0120 stack[-1] // @0121 stack[-2] // @0124 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @013B stack[-5] // @0141 memory[0x40:0x60] // @0146 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0120 80 DUP1 0121 82 DUP3 0122 03 SUB 0123 80 DUP1 0124 51 MLOAD 0125 60 PUSH1 0x01 0127 83 DUP4 0128 60 PUSH1 0x20 012A 03 SUB 012B 61 PUSH2 0x0100 012E 0A EXP 012F 03 SUB 0130 19 NOT 0131 16 AND 0132 81 DUP2 0133 52 MSTORE 0134 60 PUSH1 0x20 0136 01 ADD 0137 91 SWAP2 0138 50 POP 0139 5B JUMPDEST 013A 50 POP 013B 92 SWAP3 013C 50 POP 013D 50 POP 013E 50 POP 013F 60 PUSH1 0x40 0141 51 MLOAD 0142 80 DUP1 0143 91 SWAP2 0144 03 SUB 0145 90 SWAP1 0146 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0133 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] // @0146 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0147: // Incoming jump from 0x004B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0148 msg.value } 0147 5B JUMPDEST 0148 34 CALLVALUE 0149 15 ISZERO 014A 61 PUSH2 0x0152 014D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0152, if !msg.value label_014E: // Incoming jump from 0x014D, if not !msg.value // Inputs[1] { @0151 memory[0x00:0x00] } 014E 60 PUSH1 0x00 0150 80 DUP1 0151 FD *REVERT // Stack delta = +0 // Outputs[1] { @0151 revert(memory[0x00:0x00]); } // Block terminates label_0152: // Incoming jump from 0x014D, if !msg.value // Inputs[2] // { // @015A msg.data[0x04:0x24] // @0179 msg.data[0x24:0x44] // } 0152 5B JUMPDEST 0153 61 PUSH2 0x0187 0156 60 PUSH1 0x04 0158 80 DUP1 0159 80 DUP1 015A 35 CALLDATALOAD 015B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0170 16 AND 0171 90 SWAP1 0172 60 PUSH1 0x20 0174 01 ADD 0175 90 SWAP1 0176 91 SWAP2 0177 90 SWAP1 0178 80 DUP1 0179 35 CALLDATALOAD 017A 90 SWAP1 017B 60 PUSH1 0x20 017D 01 ADD 017E 90 SWAP1 017F 91 SWAP2 0180 90 SWAP1 0181 50 POP 0182 50 POP 0183 61 PUSH2 0x057b 0186 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0153 stack[0] = 0x0187 // @0176 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @017F stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x057b, returns to 0x0187 label_0187: // Incoming return from call to 0x057B at 0x0186 // Inputs[4] // { // @018A memory[0x40:0x60] // @018C stack[-1] // @019B memory[0x40:0x60] // @01A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0187 5B JUMPDEST 0188 60 PUSH1 0x40 018A 51 MLOAD 018B 80 DUP1 018C 82 DUP3 018D 15 ISZERO 018E 15 ISZERO 018F 15 ISZERO 0190 15 ISZERO 0191 81 DUP2 0192 52 MSTORE 0193 60 PUSH1 0x20 0195 01 ADD 0196 91 SWAP2 0197 50 POP 0198 50 POP 0199 60 PUSH1 0x40 019B 51 MLOAD 019C 80 DUP1 019D 91 SWAP2 019E 03 SUB 019F 90 SWAP1 01A0 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0192 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @01A0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01A1: // Incoming jump from 0x0056, if 0x18160ddd == stack[-1] // Inputs[1] { @01A2 msg.value } 01A1 5B JUMPDEST 01A2 34 CALLVALUE 01A3 15 ISZERO 01A4 61 PUSH2 0x01ac 01A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ac, if !msg.value label_01A8: // Incoming jump from 0x01A7, if not !msg.value // Inputs[1] { @01AB memory[0x00:0x00] } 01A8 60 PUSH1 0x00 01AA 80 DUP1 01AB FD *REVERT // Stack delta = +0 // Outputs[1] { @01AB revert(memory[0x00:0x00]); } // Block terminates label_01AC: // Incoming jump from 0x01A7, if !msg.value 01AC 5B JUMPDEST 01AD 61 PUSH2 0x01b4 01B0 61 PUSH2 0x066d 01B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @01AD stack[0] = 0x01b4 } // Block ends with call to 0x066d, returns to 0x01B4 label_01B4: // Incoming return from call to 0x066D at 0x01B3 // Inputs[4] // { // @01B7 memory[0x40:0x60] // @01B9 stack[-1] // @01C4 memory[0x40:0x60] // @01C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01B4 5B JUMPDEST 01B5 60 PUSH1 0x40 01B7 51 MLOAD 01B8 80 DUP1 01B9 82 DUP3 01BA 81 DUP2 01BB 52 MSTORE 01BC 60 PUSH1 0x20 01BE 01 ADD 01BF 91 SWAP2 01C0 50 POP 01C1 50 POP 01C2 60 PUSH1 0x40 01C4 51 MLOAD 01C5 80 DUP1 01C6 91 SWAP2 01C7 03 SUB 01C8 90 SWAP1 01C9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01C9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01CA: // Incoming jump from 0x0061, if 0x23b872dd == stack[-1] // Inputs[1] { @01CB msg.value } 01CA 5B JUMPDEST 01CB 34 CALLVALUE 01CC 15 ISZERO 01CD 61 PUSH2 0x01d5 01D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d5, if !msg.value label_01D1: // Incoming jump from 0x01D0, if not !msg.value // Inputs[1] { @01D4 memory[0x00:0x00] } 01D1 60 PUSH1 0x00 01D3 80 DUP1 01D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D4 revert(memory[0x00:0x00]); } // Block terminates label_01D5: // Incoming jump from 0x01D0, if !msg.value // Inputs[3] // { // @01DD msg.data[0x04:0x24] // @01FC msg.data[0x24:0x44] // @021B msg.data[0x44:0x64] // } 01D5 5B JUMPDEST 01D6 61 PUSH2 0x0229 01D9 60 PUSH1 0x04 01DB 80 DUP1 01DC 80 DUP1 01DD 35 CALLDATALOAD 01DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01F3 16 AND 01F4 90 SWAP1 01F5 60 PUSH1 0x20 01F7 01 ADD 01F8 90 SWAP1 01F9 91 SWAP2 01FA 90 SWAP1 01FB 80 DUP1 01FC 35 CALLDATALOAD 01FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0212 16 AND 0213 90 SWAP1 0214 60 PUSH1 0x20 0216 01 ADD 0217 90 SWAP1 0218 91 SWAP2 0219 90 SWAP1 021A 80 DUP1 021B 35 CALLDATALOAD 021C 90 SWAP1 021D 60 PUSH1 0x20 021F 01 ADD 0220 90 SWAP1 0221 91 SWAP2 0222 90 SWAP1 0223 50 POP 0224 50 POP 0225 61 PUSH2 0x068c 0228 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D6 stack[0] = 0x0229 // @01F9 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0218 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @0221 stack[3] = msg.data[0x44:0x64] // } // Block ends with call to 0x068c, returns to 0x0229 label_0229: // Incoming return from call to 0x068C at 0x0228 // Inputs[4] // { // @022C memory[0x40:0x60] // @022E stack[-1] // @023D memory[0x40:0x60] // @0242 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0229 5B JUMPDEST 022A 60 PUSH1 0x40 022C 51 MLOAD 022D 80 DUP1 022E 82 DUP3 022F 15 ISZERO 0230 15 ISZERO 0231 15 ISZERO 0232 15 ISZERO 0233 81 DUP2 0234 52 MSTORE 0235 60 PUSH1 0x20 0237 01 ADD 0238 91 SWAP2 0239 50 POP 023A 50 POP 023B 60 PUSH1 0x40 023D 51 MLOAD 023E 80 DUP1 023F 91 SWAP2 0240 03 SUB 0241 90 SWAP1 0242 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0234 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0242 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0243: // Incoming jump from 0x006C, if 0x2e1a7d4d == stack[-1] // Inputs[1] { @0244 msg.value } 0243 5B JUMPDEST 0244 34 CALLVALUE 0245 15 ISZERO 0246 61 PUSH2 0x024e 0249 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024e, if !msg.value label_024A: // Incoming jump from 0x0249, if not !msg.value // Inputs[1] { @024D memory[0x00:0x00] } 024A 60 PUSH1 0x00 024C 80 DUP1 024D FD *REVERT // Stack delta = +0 // Outputs[1] { @024D revert(memory[0x00:0x00]); } // Block terminates label_024E: // Incoming jump from 0x0249, if !msg.value // Inputs[1] { @0256 msg.data[0x04:0x24] } 024E 5B JUMPDEST 024F 61 PUSH2 0x0264 0252 60 PUSH1 0x04 0254 80 DUP1 0255 80 DUP1 0256 35 CALLDATALOAD 0257 90 SWAP1 0258 60 PUSH1 0x20 025A 01 ADD 025B 90 SWAP1 025C 91 SWAP2 025D 90 SWAP1 025E 50 POP 025F 50 POP 0260 61 PUSH2 0x09d9 0263 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @024F stack[0] = 0x0264 // @025C stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x09d9, returns to 0x0264 label_0264: // Incoming return from call to 0x09D9 at 0x0263 0264 5B JUMPDEST 0265 00 *STOP // Stack delta = +0 // Outputs[1] { @0265 stop(); } // Block terminates label_0266: // Incoming jump from 0x0077, if 0x313ce567 == stack[-1] // Inputs[1] { @0267 msg.value } 0266 5B JUMPDEST 0267 34 CALLVALUE 0268 15 ISZERO 0269 61 PUSH2 0x0271 026C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0271, if !msg.value label_026D: // Incoming jump from 0x026C, if not !msg.value // Inputs[1] { @0270 memory[0x00:0x00] } 026D 60 PUSH1 0x00 026F 80 DUP1 0270 FD *REVERT // Stack delta = +0 // Outputs[1] { @0270 revert(memory[0x00:0x00]); } // Block terminates label_0271: // Incoming jump from 0x026C, if !msg.value 0271 5B JUMPDEST 0272 61 PUSH2 0x0279 0275 61 PUSH2 0x0b05 0278 56 *JUMP // Stack delta = +1 // Outputs[1] { @0272 stack[0] = 0x0279 } // Block ends with call to 0x0b05, returns to 0x0279 label_0279: // Incoming return from call to 0x0B05 at 0x0278 // Inputs[4] // { // @027C memory[0x40:0x60] // @027E stack[-1] // @028F memory[0x40:0x60] // @0294 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0279 5B JUMPDEST 027A 60 PUSH1 0x40 027C 51 MLOAD 027D 80 DUP1 027E 82 DUP3 027F 60 PUSH1 0xff 0281 16 AND 0282 60 PUSH1 0xff 0284 16 AND 0285 81 DUP2 0286 52 MSTORE 0287 60 PUSH1 0x20 0289 01 ADD 028A 91 SWAP2 028B 50 POP 028C 50 POP 028D 60 PUSH1 0x40 028F 51 MLOAD 0290 80 DUP1 0291 91 SWAP2 0292 03 SUB 0293 90 SWAP1 0294 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0286 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @0294 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0295: // Incoming jump from 0x0082, if 0x70a08231 == stack[-1] // Inputs[1] { @0296 msg.value } 0295 5B JUMPDEST 0296 34 CALLVALUE 0297 15 ISZERO 0298 61 PUSH2 0x02a0 029B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a0, if !msg.value label_029C: // Incoming jump from 0x029B, if not !msg.value // 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 !msg.value // Inputs[1] { @02A8 msg.data[0x04:0x24] } 02A0 5B JUMPDEST 02A1 61 PUSH2 0x02cc 02A4 60 PUSH1 0x04 02A6 80 DUP1 02A7 80 DUP1 02A8 35 CALLDATALOAD 02A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02BE 16 AND 02BF 90 SWAP1 02C0 60 PUSH1 0x20 02C2 01 ADD 02C3 90 SWAP1 02C4 91 SWAP2 02C5 90 SWAP1 02C6 50 POP 02C7 50 POP 02C8 61 PUSH2 0x0b18 02CB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02A1 stack[0] = 0x02cc // @02C4 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0b18, returns to 0x02CC label_02CC: // Incoming return from call to 0x0B18 at 0x02CB // Inputs[4] // { // @02CF memory[0x40:0x60] // @02D1 stack[-1] // @02DC memory[0x40:0x60] // @02E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02CC 5B JUMPDEST 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 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02E1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02E2: // Incoming jump from 0x008D, if 0x95d89b41 == stack[-1] // Inputs[1] { @02E3 msg.value } 02E2 5B JUMPDEST 02E3 34 CALLVALUE 02E4 15 ISZERO 02E5 61 PUSH2 0x02ed 02E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ed, if !msg.value label_02E9: // Incoming jump from 0x02E8, if not !msg.value // Inputs[1] { @02EC memory[0x00:0x00] } 02E9 60 PUSH1 0x00 02EB 80 DUP1 02EC FD *REVERT // Stack delta = +0 // Outputs[1] { @02EC revert(memory[0x00:0x00]); } // Block terminates label_02ED: // Incoming jump from 0x02E8, if !msg.value 02ED 5B JUMPDEST 02EE 61 PUSH2 0x02f5 02F1 61 PUSH2 0x0b30 02F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @02EE stack[0] = 0x02f5 } // Block ends with call to 0x0b30, returns to 0x02F5 label_02F5: // Incoming return from call to 0x0B30 at 0x02F4 // Inputs[4] // { // @02F8 memory[0x40:0x60] // @0303 stack[-1] // @0306 memory[stack[-1]:stack[-1] + 0x20] // @030F memory[stack[-1]:stack[-1] + 0x20] // } 02F5 5B JUMPDEST 02F6 60 PUSH1 0x40 02F8 51 MLOAD 02F9 80 DUP1 02FA 80 DUP1 02FB 60 PUSH1 0x20 02FD 01 ADD 02FE 82 DUP3 02FF 81 DUP2 0300 03 SUB 0301 82 DUP3 0302 52 MSTORE 0303 83 DUP4 0304 81 DUP2 0305 81 DUP2 0306 51 MLOAD 0307 81 DUP2 0308 52 MSTORE 0309 60 PUSH1 0x20 030B 01 ADD 030C 91 SWAP2 030D 50 POP 030E 80 DUP1 030F 51 MLOAD 0310 90 SWAP1 0311 60 PUSH1 0x20 0313 01 ADD 0314 90 SWAP1 0315 80 DUP1 0316 83 DUP4 0317 83 DUP4 0318 60 PUSH1 0x00 031A 5B JUMPDEST 031B 83 DUP4 031C 81 DUP2 031D 10 LT 031E 15 ISZERO 031F 61 PUSH2 0x0335 0322 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @02F8 stack[0] = memory[0x40:0x60] // @02F9 stack[1] = memory[0x40:0x60] // @0302 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0308 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @030C stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0314 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0314 stack[3] = 0x20 + stack[-1] // @0315 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0316 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0317 stack[7] = 0x20 + stack[-1] // @0318 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0335, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0323: // Incoming jump from 0x0322, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0322, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0323 stack[-1] // @0324 stack[-2] // @0326 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0328 stack[-3] // } 0323 80 DUP1 0324 82 DUP3 0325 01 ADD 0326 51 MLOAD 0327 81 DUP2 0328 84 DUP5 0329 01 ADD 032A 52 MSTORE 032B 60 PUSH1 0x20 032D 81 DUP2 032E 01 ADD 032F 90 SWAP1 0330 50 POP 0331 61 PUSH2 0x031a 0334 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @032A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @032F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x031a label_0335: // Incoming jump from 0x0322, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0322, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @033A stack[-6] // @033A stack[-5] // @033C stack[-7] // } 0335 5B JUMPDEST 0336 50 POP 0337 50 POP 0338 50 POP 0339 50 POP 033A 90 SWAP1 033B 50 POP 033C 90 SWAP1 033D 81 DUP2 033E 01 ADD 033F 90 SWAP1 0340 60 PUSH1 0x1f 0342 16 AND 0343 80 DUP1 0344 15 ISZERO 0345 61 PUSH2 0x0362 0348 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @033F stack[-7] = stack[-5] + stack[-7] // @0342 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0362, if !(0x1f & stack[-5]) label_0349: // Incoming jump from 0x0348, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0349 stack[-1] // @034A stack[-2] // @034D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0364 stack[-5] // @036A memory[0x40:0x60] // @036F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0349 80 DUP1 034A 82 DUP3 034B 03 SUB 034C 80 DUP1 034D 51 MLOAD 034E 60 PUSH1 0x01 0350 83 DUP4 0351 60 PUSH1 0x20 0353 03 SUB 0354 61 PUSH2 0x0100 0357 0A EXP 0358 03 SUB 0359 19 NOT 035A 16 AND 035B 81 DUP2 035C 52 MSTORE 035D 60 PUSH1 0x20 035F 01 ADD 0360 91 SWAP2 0361 50 POP 0362 5B JUMPDEST 0363 50 POP 0364 92 SWAP3 0365 50 POP 0366 50 POP 0367 50 POP 0368 60 PUSH1 0x40 036A 51 MLOAD 036B 80 DUP1 036C 91 SWAP2 036D 03 SUB 036E 90 SWAP1 036F F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @035C 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] // @036F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0370: // Incoming jump from 0x0098, if 0xa9059cbb == stack[-1] // Inputs[1] { @0371 msg.value } 0370 5B JUMPDEST 0371 34 CALLVALUE 0372 15 ISZERO 0373 61 PUSH2 0x037b 0376 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037b, if !msg.value label_0377: // Incoming jump from 0x0376, if not !msg.value // Inputs[1] { @037A memory[0x00:0x00] } 0377 60 PUSH1 0x00 0379 80 DUP1 037A FD *REVERT // Stack delta = +0 // Outputs[1] { @037A revert(memory[0x00:0x00]); } // Block terminates label_037B: // Incoming jump from 0x0376, if !msg.value // Inputs[2] // { // @0383 msg.data[0x04:0x24] // @03A2 msg.data[0x24:0x44] // } 037B 5B JUMPDEST 037C 61 PUSH2 0x03b0 037F 60 PUSH1 0x04 0381 80 DUP1 0382 80 DUP1 0383 35 CALLDATALOAD 0384 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0399 16 AND 039A 90 SWAP1 039B 60 PUSH1 0x20 039D 01 ADD 039E 90 SWAP1 039F 91 SWAP2 03A0 90 SWAP1 03A1 80 DUP1 03A2 35 CALLDATALOAD 03A3 90 SWAP1 03A4 60 PUSH1 0x20 03A6 01 ADD 03A7 90 SWAP1 03A8 91 SWAP2 03A9 90 SWAP1 03AA 50 POP 03AB 50 POP 03AC 61 PUSH2 0x0bce 03AF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @037C stack[0] = 0x03b0 // @039F stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @03A8 stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x0bce, returns to 0x03B0 label_03B0: // Incoming return from call to 0x0BCE at 0x03AF // Inputs[4] // { // @03B3 memory[0x40:0x60] // @03B5 stack[-1] // @03C4 memory[0x40:0x60] // @03C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03B0 5B JUMPDEST 03B1 60 PUSH1 0x40 03B3 51 MLOAD 03B4 80 DUP1 03B5 82 DUP3 03B6 15 ISZERO 03B7 15 ISZERO 03B8 15 ISZERO 03B9 15 ISZERO 03BA 81 DUP2 03BB 52 MSTORE 03BC 60 PUSH1 0x20 03BE 01 ADD 03BF 91 SWAP2 03C0 50 POP 03C1 50 POP 03C2 60 PUSH1 0x40 03C4 51 MLOAD 03C5 80 DUP1 03C6 91 SWAP2 03C7 03 SUB 03C8 90 SWAP1 03C9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @03C9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03CA: // Incoming jump from 0x00A3, if 0xd0e30db0 == stack[-1] 03CA 5B JUMPDEST 03CB 61 PUSH2 0x03d2 03CE 61 PUSH2 0x0440 03D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @03CB stack[0] = 0x03d2 } // Block ends with call to 0x0440, returns to 0x03D2 label_03D2: // Incoming return from call to 0x0440 at 0x03D1 03D2 5B JUMPDEST 03D3 00 *STOP // Stack delta = +0 // Outputs[1] { @03D3 stop(); } // Block terminates label_03D4: // Incoming jump from 0x00AE, if 0xdd62ed3e == stack[-1] // Inputs[1] { @03D5 msg.value } 03D4 5B JUMPDEST 03D5 34 CALLVALUE 03D6 15 ISZERO 03D7 61 PUSH2 0x03df 03DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03df, if !msg.value label_03DB: // Incoming jump from 0x03DA, if not !msg.value // Inputs[1] { @03DE memory[0x00:0x00] } 03DB 60 PUSH1 0x00 03DD 80 DUP1 03DE FD *REVERT // Stack delta = +0 // Outputs[1] { @03DE revert(memory[0x00:0x00]); } // Block terminates label_03DF: // Incoming jump from 0x03DA, if !msg.value // Inputs[2] // { // @03E7 msg.data[0x04:0x24] // @0406 msg.data[0x24:0x44] // } 03DF 5B JUMPDEST 03E0 61 PUSH2 0x042a 03E3 60 PUSH1 0x04 03E5 80 DUP1 03E6 80 DUP1 03E7 35 CALLDATALOAD 03E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03FD 16 AND 03FE 90 SWAP1 03FF 60 PUSH1 0x20 0401 01 ADD 0402 90 SWAP1 0403 91 SWAP2 0404 90 SWAP1 0405 80 DUP1 0406 35 CALLDATALOAD 0407 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 041C 16 AND 041D 90 SWAP1 041E 60 PUSH1 0x20 0420 01 ADD 0421 90 SWAP1 0422 91 SWAP2 0423 90 SWAP1 0424 50 POP 0425 50 POP 0426 61 PUSH2 0x0be3 0429 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @03E0 stack[0] = 0x042a // @0403 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0422 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x0be3, returns to 0x042A label_042A: // Incoming return from call to 0x0BE3 at 0x0429 // Inputs[4] // { // @042D memory[0x40:0x60] // @042F stack[-1] // @043A memory[0x40:0x60] // @043F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 042A 5B JUMPDEST 042B 60 PUSH1 0x40 042D 51 MLOAD 042E 80 DUP1 042F 82 DUP3 0430 81 DUP2 0431 52 MSTORE 0432 60 PUSH1 0x20 0434 01 ADD 0435 91 SWAP2 0436 50 POP 0437 50 POP 0438 60 PUSH1 0x40 043A 51 MLOAD 043B 80 DUP1 043C 91 SWAP2 043D 03 SUB 043E 90 SWAP1 043F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0431 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @043F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0440: // Incoming call from 0x03D1, returns to 0x03D2 // Incoming call from 0x00B6, returns to 0x00B7 // Inputs[10] // { // @0441 msg.value // @0446 msg.sender // @0480 memory[0x00:0x40] // @0485 storage[keccak256(memory[0x00:0x40])] // @048E msg.sender // @04C6 msg.value // @04C9 memory[0x40:0x60] // @04D6 memory[0x40:0x60] // @04DB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @04DC stack[-1] // } 0440 5B JUMPDEST 0441 34 CALLVALUE 0442 60 PUSH1 0x03 0444 60 PUSH1 0x00 0446 33 CALLER 0447 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 045C 16 AND 045D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0472 16 AND 0473 81 DUP2 0474 52 MSTORE 0475 60 PUSH1 0x20 0477 01 ADD 0478 90 SWAP1 0479 81 DUP2 047A 52 MSTORE 047B 60 PUSH1 0x20 047D 01 ADD 047E 60 PUSH1 0x00 0480 20 SHA3 0481 60 PUSH1 0x00 0483 82 DUP3 0484 82 DUP3 0485 54 SLOAD 0486 01 ADD 0487 92 SWAP3 0488 50 POP 0489 50 POP 048A 81 DUP2 048B 90 SWAP1 048C 55 SSTORE 048D 50 POP 048E 33 CALLER 048F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04A4 16 AND 04A5 7F PUSH32 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c 04C6 34 CALLVALUE 04C7 60 PUSH1 0x40 04C9 51 MLOAD 04CA 80 DUP1 04CB 82 DUP3 04CC 81 DUP2 04CD 52 MSTORE 04CE 60 PUSH1 0x20 04D0 01 ADD 04D1 91 SWAP2 04D2 50 POP 04D3 50 POP 04D4 60 PUSH1 0x40 04D6 51 MLOAD 04D7 80 DUP1 04D8 91 SWAP2 04D9 03 SUB 04DA 90 SWAP1 04DB A2 LOG2 04DC 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @0474 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @047A memory[0x20:0x40] = 0x03 // @048C storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + msg.value // @04CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.value // @04DB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c, msg.sender]); // } // Block ends with unconditional jump to stack[-1] label_04DD: // Incoming call from 0x00CB, returns to 0x00CC // Inputs[3] // { // @04E1 storage[0x00] // @0502 memory[0x40:0x60] // @0515 storage[0x00] // } 04DD 5B JUMPDEST 04DE 60 PUSH1 0x00 04E0 80 DUP1 04E1 54 SLOAD 04E2 60 PUSH1 0x01 04E4 81 DUP2 04E5 60 PUSH1 0x01 04E7 16 AND 04E8 15 ISZERO 04E9 61 PUSH2 0x0100 04EC 02 MUL 04ED 03 SUB 04EE 16 AND 04EF 60 PUSH1 0x02 04F1 90 SWAP1 04F2 04 DIV 04F3 80 DUP1 04F4 60 PUSH1 0x1f 04F6 01 ADD 04F7 60 PUSH1 0x20 04F9 80 DUP1 04FA 91 SWAP2 04FB 04 DIV 04FC 02 MUL 04FD 60 PUSH1 0x20 04FF 01 ADD 0500 60 PUSH1 0x40 0502 51 MLOAD 0503 90 SWAP1 0504 81 DUP2 0505 01 ADD 0506 60 PUSH1 0x40 0508 52 MSTORE 0509 80 DUP1 050A 92 SWAP3 050B 91 SWAP2 050C 90 SWAP1 050D 81 DUP2 050E 81 DUP2 050F 52 MSTORE 0510 60 PUSH1 0x20 0512 01 ADD 0513 82 DUP3 0514 80 DUP1 0515 54 SLOAD 0516 60 PUSH1 0x01 0518 81 DUP2 0519 60 PUSH1 0x01 051B 16 AND 051C 15 ISZERO 051D 61 PUSH2 0x0100 0520 02 MUL 0521 03 SUB 0522 16 AND 0523 60 PUSH1 0x02 0525 90 SWAP1 0526 04 DIV 0527 80 DUP1 0528 15 ISZERO 0529 61 PUSH2 0x0573 052C 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0508 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) / 0x20 * 0x20 // @050A stack[0] = memory[0x40:0x60] // @050B stack[1] = 0x00 // @050C stack[2] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @050F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // @0512 stack[3] = 0x20 + memory[0x40:0x60] // @0513 stack[4] = 0x00 // @0526 stack[5] = (0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02 // } // Block ends with conditional jump to 0x0573, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) label_052D: // Incoming jump from 0x052C, if not !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Inputs[1] { @052D stack[-1] } 052D 80 DUP1 052E 60 PUSH1 0x1f 0530 10 LT 0531 61 PUSH2 0x0548 0534 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0548, if 0x1f < stack[-1] label_0535: // Incoming jump from 0x0534, if not 0x1f < stack[-1] // Inputs[4] // { // @0539 stack[-2] // @053A storage[stack[-2]] // @053D stack[-3] // @053F stack[-1] // } 0535 61 PUSH2 0x0100 0538 80 DUP1 0539 83 DUP4 053A 54 SLOAD 053B 04 DIV 053C 02 MUL 053D 83 DUP4 053E 52 MSTORE 053F 91 SWAP2 0540 60 PUSH1 0x20 0542 01 ADD 0543 91 SWAP2 0544 61 PUSH2 0x0573 0547 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @053E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0543 stack[-1] = stack[-1] // @0543 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0573 label_0548: // Incoming jump from 0x0534, if 0x1f < stack[-1] // Inputs[5] // { // @0549 stack[-3] // @054A stack[-1] // @054C stack[-2] // @0554 memory[0x00:0x20] // @0558 storage[keccak256(memory[0x00:0x20])] // } 0548 5B JUMPDEST 0549 82 DUP3 054A 01 ADD 054B 91 SWAP2 054C 90 SWAP1 054D 60 PUSH1 0x00 054F 52 MSTORE 0550 60 PUSH1 0x20 0552 60 PUSH1 0x00 0554 20 SHA3 0555 90 SWAP1 0556 5B JUMPDEST 0557 81 DUP2 0558 54 SLOAD 0559 81 DUP2 055A 52 MSTORE 055B 90 SWAP1 055C 60 PUSH1 0x01 055E 01 ADD 055F 90 SWAP1 0560 60 PUSH1 0x20 0562 01 ADD 0563 80 DUP1 0564 83 DUP4 0565 11 GT 0566 61 PUSH2 0x0556 0569 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @054B stack[-3] = stack[-3] + stack[-1] // @054F memory[0x00:0x20] = stack[-2] // @055A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @055F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0562 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0556, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_056A: // Incoming jump from 0x0569, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0569, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @056A stack[-3] // @056B stack[-1] // } 056A 82 DUP3 056B 90 SWAP1 056C 03 SUB 056D 60 PUSH1 0x1f 056F 16 AND 0570 82 DUP3 0571 01 ADD 0572 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0572 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0572 stack[-1] = stack[-3] // } // Block continues label_0573: // Incoming jump from 0x052C, if !((0x0100 * !(0x01 & storage[0x00]) - 0x01 & storage[0x00]) / 0x02) // Incoming jump from 0x0547 // Incoming jump from 0x0572 // Inputs[1] { @0579 stack[-7] } 0573 5B JUMPDEST 0574 50 POP 0575 50 POP 0576 50 POP 0577 50 POP 0578 50 POP 0579 81 DUP2 057A 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_057B: // Incoming call from 0x0186, returns to 0x0187 // Inputs[10] // { // @057E stack[-1] // @0583 msg.sender // @05BD memory[0x00:0x40] // @05C0 stack[-2] // @05FA memory[0x00:0x40] // @0616 msg.sender // @0651 memory[0x40:0x60] // @065E memory[0x40:0x60] // @0663 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0668 stack[-3] // } 057B 5B JUMPDEST 057C 60 PUSH1 0x00 057E 81 DUP2 057F 60 PUSH1 0x04 0581 60 PUSH1 0x00 0583 33 CALLER 0584 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0599 16 AND 059A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05AF 16 AND 05B0 81 DUP2 05B1 52 MSTORE 05B2 60 PUSH1 0x20 05B4 01 ADD 05B5 90 SWAP1 05B6 81 DUP2 05B7 52 MSTORE 05B8 60 PUSH1 0x20 05BA 01 ADD 05BB 60 PUSH1 0x00 05BD 20 SHA3 05BE 60 PUSH1 0x00 05C0 85 DUP6 05C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05D6 16 AND 05D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05EC 16 AND 05ED 81 DUP2 05EE 52 MSTORE 05EF 60 PUSH1 0x20 05F1 01 ADD 05F2 90 SWAP1 05F3 81 DUP2 05F4 52 MSTORE 05F5 60 PUSH1 0x20 05F7 01 ADD 05F8 60 PUSH1 0x00 05FA 20 SHA3 05FB 81 DUP2 05FC 90 SWAP1 05FD 55 SSTORE 05FE 50 POP 05FF 82 DUP3 0600 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0615 16 AND 0616 33 CALLER 0617 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 062C 16 AND 062D 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 064E 84 DUP5 064F 60 PUSH1 0x40 0651 51 MLOAD 0652 80 DUP1 0653 82 DUP3 0654 81 DUP2 0655 52 MSTORE 0656 60 PUSH1 0x20 0658 01 ADD 0659 91 SWAP2 065A 50 POP 065B 50 POP 065C 60 PUSH1 0x40 065E 51 MLOAD 065F 80 DUP1 0660 91 SWAP2 0661 03 SUB 0662 90 SWAP1 0663 A3 LOG3 0664 60 PUSH1 0x01 0666 90 SWAP1 0667 50 POP 0668 92 SWAP3 0669 91 SWAP2 066A 50 POP 066B 50 POP 066C 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @05B1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @05B7 memory[0x20:0x40] = 0x04 // @05EE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @05F4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @05FD storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0655 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0663 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0668 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_066D: // Incoming call from 0x01B3, returns to 0x01B4 // Inputs[3] // { // @0670 address(this) // @0687 address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance // @068A stack[-1] // } 066D 5B JUMPDEST 066E 60 PUSH1 0x00 0670 30 ADDRESS 0671 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0686 16 AND 0687 31 BALANCE 0688 90 SWAP1 0689 50 POP 068A 90 SWAP1 068B 56 *JUMP // Stack delta = +0 // Outputs[1] { @068A stack[-1] = address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance } // Block ends with unconditional jump to stack[-1] label_068C: // Incoming call from 0x0228, returns to 0x0229 // Incoming call from 0x0BDA, returns to 0x0BDB // Inputs[4] // { // @068F stack[-1] // @0694 stack[-3] // @06CE memory[0x00:0x40] // @06CF storage[keccak256(memory[0x00:0x40])] // } 068C 5B JUMPDEST 068D 60 PUSH1 0x00 068F 81 DUP2 0690 60 PUSH1 0x03 0692 60 PUSH1 0x00 0694 86 DUP7 0695 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06AA 16 AND 06AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C0 16 AND 06C1 81 DUP2 06C2 52 MSTORE 06C3 60 PUSH1 0x20 06C5 01 ADD 06C6 90 SWAP1 06C7 81 DUP2 06C8 52 MSTORE 06C9 60 PUSH1 0x20 06CB 01 ADD 06CC 60 PUSH1 0x00 06CE 20 SHA3 06CF 54 SLOAD 06D0 10 LT 06D1 15 ISZERO 06D2 15 ISZERO 06D3 15 ISZERO 06D4 61 PUSH2 0x06dc 06D7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @068D stack[0] = 0x00 // @06C2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @06C8 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x06dc, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_06D8: // Incoming jump from 0x06D7, if not !!!(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[1] { @06DB memory[0x00:0x00] } 06D8 60 PUSH1 0x00 06DA 80 DUP1 06DB FD *REVERT // Stack delta = +0 // Outputs[1] { @06DB revert(memory[0x00:0x00]); } // Block terminates label_06DC: // Incoming jump from 0x06D7, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[2] // { // @06DD msg.sender // @06F4 stack[-4] // } 06DC 5B JUMPDEST 06DD 33 CALLER 06DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06F3 16 AND 06F4 84 DUP5 06F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 070A 16 AND 070B 14 EQ 070C 15 ISZERO 070D 80 DUP1 070E 15 ISZERO 070F 61 PUSH2 0x07b4 0712 57 *JUMPI // Stack delta = +1 // Outputs[1] { @070C stack[0] = !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) } // Block ends with conditional jump to 0x07b4, if !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) label_0713: // Incoming jump from 0x0712, if not !!(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[5] // { // @0739 stack[-5] // @0773 memory[0x00:0x40] // @0776 msg.sender // @07B0 memory[0x00:0x40] // @07B1 storage[keccak256(memory[0x00:0x40])] // } 0713 50 POP 0714 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0735 60 PUSH1 0x04 0737 60 PUSH1 0x00 0739 86 DUP7 073A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 074F 16 AND 0750 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0765 16 AND 0766 81 DUP2 0767 52 MSTORE 0768 60 PUSH1 0x20 076A 01 ADD 076B 90 SWAP1 076C 81 DUP2 076D 52 MSTORE 076E 60 PUSH1 0x20 0770 01 ADD 0771 60 PUSH1 0x00 0773 20 SHA3 0774 60 PUSH1 0x00 0776 33 CALLER 0777 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 078C 16 AND 078D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07A2 16 AND 07A3 81 DUP2 07A4 52 MSTORE 07A5 60 PUSH1 0x20 07A7 01 ADD 07A8 90 SWAP1 07A9 81 DUP2 07AA 52 MSTORE 07AB 60 PUSH1 0x20 07AD 01 ADD 07AE 60 PUSH1 0x00 07B0 20 SHA3 07B1 54 SLOAD 07B2 14 EQ 07B3 15 ISZERO 07B4 5B JUMPDEST 07B5 15 ISZERO 07B6 61 PUSH2 0x08cf 07B9 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @0767 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @076D memory[0x20:0x40] = 0x04 // @07A4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @07AA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x08cf, if !!(storage[keccak256(memory[0x00:0x40])] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_07BA: // Incoming jump from 0x07B9, if not !stack[-1] // Incoming jump from 0x07B9, if not !!(storage[keccak256(memory[0x00:0x40])] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[6] // { // @07BA stack[-2] // @07BF stack[-4] // @07F9 memory[0x00:0x40] // @07FC msg.sender // @0836 memory[0x00:0x40] // @0837 storage[keccak256(memory[0x00:0x40])] // } 07BA 81 DUP2 07BB 60 PUSH1 0x04 07BD 60 PUSH1 0x00 07BF 86 DUP7 07C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07D5 16 AND 07D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07EB 16 AND 07EC 81 DUP2 07ED 52 MSTORE 07EE 60 PUSH1 0x20 07F0 01 ADD 07F1 90 SWAP1 07F2 81 DUP2 07F3 52 MSTORE 07F4 60 PUSH1 0x20 07F6 01 ADD 07F7 60 PUSH1 0x00 07F9 20 SHA3 07FA 60 PUSH1 0x00 07FC 33 CALLER 07FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0812 16 AND 0813 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0828 16 AND 0829 81 DUP2 082A 52 MSTORE 082B 60 PUSH1 0x20 082D 01 ADD 082E 90 SWAP1 082F 81 DUP2 0830 52 MSTORE 0831 60 PUSH1 0x20 0833 01 ADD 0834 60 PUSH1 0x00 0836 20 SHA3 0837 54 SLOAD 0838 10 LT 0839 15 ISZERO 083A 15 ISZERO 083B 15 ISZERO 083C 61 PUSH2 0x0844 083F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @07ED memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @07F3 memory[0x20:0x40] = 0x04 // @082A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0830 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0844, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-2]) label_0840: // Incoming jump from 0x083F, if not !!!(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[1] { @0843 memory[0x00:0x00] } 0840 60 PUSH1 0x00 0842 80 DUP1 0843 FD *REVERT // Stack delta = +0 // Outputs[1] { @0843 revert(memory[0x00:0x00]); } // Block terminates label_0844: // Incoming jump from 0x083F, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[6] // { // @0845 stack[-2] // @084A stack[-4] // @0884 memory[0x00:0x40] // @0887 msg.sender // @08C1 memory[0x00:0x40] // @08C6 storage[keccak256(memory[0x00:0x40])] // } 0844 5B JUMPDEST 0845 81 DUP2 0846 60 PUSH1 0x04 0848 60 PUSH1 0x00 084A 86 DUP7 084B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0860 16 AND 0861 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0876 16 AND 0877 81 DUP2 0878 52 MSTORE 0879 60 PUSH1 0x20 087B 01 ADD 087C 90 SWAP1 087D 81 DUP2 087E 52 MSTORE 087F 60 PUSH1 0x20 0881 01 ADD 0882 60 PUSH1 0x00 0884 20 SHA3 0885 60 PUSH1 0x00 0887 33 CALLER 0888 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 089D 16 AND 089E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08B3 16 AND 08B4 81 DUP2 08B5 52 MSTORE 08B6 60 PUSH1 0x20 08B8 01 ADD 08B9 90 SWAP1 08BA 81 DUP2 08BB 52 MSTORE 08BC 60 PUSH1 0x20 08BE 01 ADD 08BF 60 PUSH1 0x00 08C1 20 SHA3 08C2 60 PUSH1 0x00 08C4 82 DUP3 08C5 82 DUP3 08C6 54 SLOAD 08C7 03 SUB 08C8 92 SWAP3 08C9 50 POP 08CA 50 POP 08CB 81 DUP2 08CC 90 SWAP1 08CD 55 SSTORE 08CE 50 POP // Stack delta = +0 // Outputs[5] // { // @0878 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @087E memory[0x20:0x40] = 0x04 // @08B5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @08BB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @08CD storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2] // } // Block continues label_08CF: // Incoming jump from 0x07B9, if !!(storage[keccak256(memory[0x00:0x40])] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Incoming jump from 0x07B9, if !stack[-1] // Incoming jump from 0x08CE // Inputs[12] // { // @08D0 stack[-2] // @08D5 stack[-4] // @090F memory[0x00:0x40] // @0914 storage[keccak256(memory[0x00:0x40])] // @0922 stack[-3] // @095C memory[0x00:0x40] // @0961 storage[keccak256(memory[0x00:0x40])] // @09BC memory[0x40:0x60] // @09C9 memory[0x40:0x60] // @09CE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @09D1 stack[-1] // @09D3 stack[-5] // } 08CF 5B JUMPDEST 08D0 81 DUP2 08D1 60 PUSH1 0x03 08D3 60 PUSH1 0x00 08D5 86 DUP7 08D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08EB 16 AND 08EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0901 16 AND 0902 81 DUP2 0903 52 MSTORE 0904 60 PUSH1 0x20 0906 01 ADD 0907 90 SWAP1 0908 81 DUP2 0909 52 MSTORE 090A 60 PUSH1 0x20 090C 01 ADD 090D 60 PUSH1 0x00 090F 20 SHA3 0910 60 PUSH1 0x00 0912 82 DUP3 0913 82 DUP3 0914 54 SLOAD 0915 03 SUB 0916 92 SWAP3 0917 50 POP 0918 50 POP 0919 81 DUP2 091A 90 SWAP1 091B 55 SSTORE 091C 50 POP 091D 81 DUP2 091E 60 PUSH1 0x03 0920 60 PUSH1 0x00 0922 85 DUP6 0923 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0938 16 AND 0939 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 094E 16 AND 094F 81 DUP2 0950 52 MSTORE 0951 60 PUSH1 0x20 0953 01 ADD 0954 90 SWAP1 0955 81 DUP2 0956 52 MSTORE 0957 60 PUSH1 0x20 0959 01 ADD 095A 60 PUSH1 0x00 095C 20 SHA3 095D 60 PUSH1 0x00 095F 82 DUP3 0960 82 DUP3 0961 54 SLOAD 0962 01 ADD 0963 92 SWAP3 0964 50 POP 0965 50 POP 0966 81 DUP2 0967 90 SWAP1 0968 55 SSTORE 0969 50 POP 096A 82 DUP3 096B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0980 16 AND 0981 84 DUP5 0982 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0997 16 AND 0998 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 09B9 84 DUP5 09BA 60 PUSH1 0x40 09BC 51 MLOAD 09BD 80 DUP1 09BE 82 DUP3 09BF 81 DUP2 09C0 52 MSTORE 09C1 60 PUSH1 0x20 09C3 01 ADD 09C4 91 SWAP2 09C5 50 POP 09C6 50 POP 09C7 60 PUSH1 0x40 09C9 51 MLOAD 09CA 80 DUP1 09CB 91 SWAP2 09CC 03 SUB 09CD 90 SWAP1 09CE A3 LOG3 09CF 60 PUSH1 0x01 09D1 90 SWAP1 09D2 50 POP 09D3 93 SWAP4 09D4 92 SWAP3 09D5 50 POP 09D6 50 POP 09D7 50 POP 09D8 56 *JUMP // Stack delta = -4 // Outputs[9] // { // @0903 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0909 memory[0x20:0x40] = 0x03 // @091B storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2] // @0950 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0956 memory[0x20:0x40] = 0x03 // @0968 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-2] // @09C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @09CE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // @09D3 stack[-5] = 0x01 // } // Block ends with unconditional jump to stack[-5] label_09D9: // Incoming call from 0x0263, returns to 0x0264 // Inputs[4] // { // @09DA stack[-1] // @09DF msg.sender // @0A19 memory[0x00:0x40] // @0A1A storage[keccak256(memory[0x00:0x40])] // } 09D9 5B JUMPDEST 09DA 80 DUP1 09DB 60 PUSH1 0x03 09DD 60 PUSH1 0x00 09DF 33 CALLER 09E0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09F5 16 AND 09F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A0B 16 AND 0A0C 81 DUP2 0A0D 52 MSTORE 0A0E 60 PUSH1 0x20 0A10 01 ADD 0A11 90 SWAP1 0A12 81 DUP2 0A13 52 MSTORE 0A14 60 PUSH1 0x20 0A16 01 ADD 0A17 60 PUSH1 0x00 0A19 20 SHA3 0A1A 54 SLOAD 0A1B 10 LT 0A1C 15 ISZERO 0A1D 15 ISZERO 0A1E 15 ISZERO 0A1F 61 PUSH2 0x0a27 0A22 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0A0D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0A13 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0a27, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_0A23: // Incoming jump from 0x0A22, if not !!!(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[1] { @0A26 memory[0x00:0x00] } 0A23 60 PUSH1 0x00 0A25 80 DUP1 0A26 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A26 revert(memory[0x00:0x00]); } // Block terminates label_0A27: // Incoming jump from 0x0A22, if !!!(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[9] // { // @0A28 stack[-1] // @0A2D msg.sender // @0A67 memory[0x00:0x40] // @0A6C storage[keccak256(memory[0x00:0x40])] // @0A75 msg.sender // @0A97 memory[0x40:0x60] // @0A9C memory[0x40:0x60] // @0AA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0AA4 address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 0A27 5B JUMPDEST 0A28 80 DUP1 0A29 60 PUSH1 0x03 0A2B 60 PUSH1 0x00 0A2D 33 CALLER 0A2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A43 16 AND 0A44 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A59 16 AND 0A5A 81 DUP2 0A5B 52 MSTORE 0A5C 60 PUSH1 0x20 0A5E 01 ADD 0A5F 90 SWAP1 0A60 81 DUP2 0A61 52 MSTORE 0A62 60 PUSH1 0x20 0A64 01 ADD 0A65 60 PUSH1 0x00 0A67 20 SHA3 0A68 60 PUSH1 0x00 0A6A 82 DUP3 0A6B 82 DUP3 0A6C 54 SLOAD 0A6D 03 SUB 0A6E 92 SWAP3 0A6F 50 POP 0A70 50 POP 0A71 81 DUP2 0A72 90 SWAP1 0A73 55 SSTORE 0A74 50 POP 0A75 33 CALLER 0A76 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A8B 16 AND 0A8C 61 PUSH2 0x08fc 0A8F 82 DUP3 0A90 90 SWAP1 0A91 81 DUP2 0A92 15 ISZERO 0A93 02 MUL 0A94 90 SWAP1 0A95 60 PUSH1 0x40 0A97 51 MLOAD 0A98 60 PUSH1 0x00 0A9A 60 PUSH1 0x40 0A9C 51 MLOAD 0A9D 80 DUP1 0A9E 83 DUP4 0A9F 03 SUB 0AA0 81 DUP2 0AA1 85 DUP6 0AA2 88 DUP9 0AA3 88 DUP9 0AA4 F1 CALL 0AA5 93 SWAP4 0AA6 50 POP 0AA7 50 POP 0AA8 50 POP 0AA9 50 POP 0AAA 15 ISZERO 0AAB 15 ISZERO 0AAC 61 PUSH2 0x0ab4 0AAF 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0A5B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0A61 memory[0x20:0x40] = 0x03 // @0A73 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-1] // @0AA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0ab4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_0AB0: // Incoming jump from 0x0AAF, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @0AB3 memory[0x00:0x00] } 0AB0 60 PUSH1 0x00 0AB2 80 DUP1 0AB3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB3 revert(memory[0x00:0x00]); } // Block terminates label_0AB4: // Incoming jump from 0x0AAF, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!stack[-1] * 0x08fc).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[6] // { // @0AB5 msg.sender // @0AED stack[-1] // @0AF0 memory[0x40:0x60] // @0AFD memory[0x40:0x60] // @0B02 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B04 stack[-2] // } 0AB4 5B JUMPDEST 0AB5 33 CALLER 0AB6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ACB 16 AND 0ACC 7F PUSH32 0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65 0AED 82 DUP3 0AEE 60 PUSH1 0x40 0AF0 51 MLOAD 0AF1 80 DUP1 0AF2 82 DUP3 0AF3 81 DUP2 0AF4 52 MSTORE 0AF5 60 PUSH1 0x20 0AF7 01 ADD 0AF8 91 SWAP2 0AF9 50 POP 0AFA 50 POP 0AFB 60 PUSH1 0x40 0AFD 51 MLOAD 0AFE 80 DUP1 0AFF 91 SWAP2 0B00 03 SUB 0B01 90 SWAP1 0B02 A2 LOG2 0B03 50 POP 0B04 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0AF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B02 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65, msg.sender]); // } // Block ends with unconditional jump to stack[-2] label_0B05: // Incoming call from 0x0278, returns to 0x0279 // Inputs[2] // { // @0B0B storage[0x02] // @0B16 stack[-1] // } 0B05 5B JUMPDEST 0B06 60 PUSH1 0x02 0B08 60 PUSH1 0x00 0B0A 90 SWAP1 0B0B 54 SLOAD 0B0C 90 SWAP1 0B0D 61 PUSH2 0x0100 0B10 0A EXP 0B11 90 SWAP1 0B12 04 DIV 0B13 60 PUSH1 0xff 0B15 16 AND 0B16 81 DUP2 0B17 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B15 stack[0] = 0xff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0B18: // Incoming call from 0x02CB, returns to 0x02CC // Inputs[4] // { // @0B1E stack[-1] // @0B26 memory[0x00:0x40] // @0B2D storage[keccak256(memory[0x00:0x40])] // @0B2E stack[-2] // } 0B18 5B JUMPDEST 0B19 60 PUSH1 0x03 0B1B 60 PUSH1 0x20 0B1D 52 MSTORE 0B1E 80 DUP1 0B1F 60 PUSH1 0x00 0B21 52 MSTORE 0B22 60 PUSH1 0x40 0B24 60 PUSH1 0x00 0B26 20 SHA3 0B27 60 PUSH1 0x00 0B29 91 SWAP2 0B2A 50 POP 0B2B 90 SWAP1 0B2C 50 POP 0B2D 54 SLOAD 0B2E 81 DUP2 0B2F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B1D memory[0x20:0x40] = 0x03 // @0B21 memory[0x00:0x20] = stack[-1] // @0B2D stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0B30: // Incoming call from 0x02F4, returns to 0x02F5 // Inputs[3] // { // @0B34 storage[0x01] // @0B55 memory[0x40:0x60] // @0B68 storage[0x01] // } 0B30 5B JUMPDEST 0B31 60 PUSH1 0x01 0B33 80 DUP1 0B34 54 SLOAD 0B35 60 PUSH1 0x01 0B37 81 DUP2 0B38 60 PUSH1 0x01 0B3A 16 AND 0B3B 15 ISZERO 0B3C 61 PUSH2 0x0100 0B3F 02 MUL 0B40 03 SUB 0B41 16 AND 0B42 60 PUSH1 0x02 0B44 90 SWAP1 0B45 04 DIV 0B46 80 DUP1 0B47 60 PUSH1 0x1f 0B49 01 ADD 0B4A 60 PUSH1 0x20 0B4C 80 DUP1 0B4D 91 SWAP2 0B4E 04 DIV 0B4F 02 MUL 0B50 60 PUSH1 0x20 0B52 01 ADD 0B53 60 PUSH1 0x40 0B55 51 MLOAD 0B56 90 SWAP1 0B57 81 DUP2 0B58 01 ADD 0B59 60 PUSH1 0x40 0B5B 52 MSTORE 0B5C 80 DUP1 0B5D 92 SWAP3 0B5E 91 SWAP2 0B5F 90 SWAP1 0B60 81 DUP2 0B61 81 DUP2 0B62 52 MSTORE 0B63 60 PUSH1 0x20 0B65 01 ADD 0B66 82 DUP3 0B67 80 DUP1 0B68 54 SLOAD 0B69 60 PUSH1 0x01 0B6B 81 DUP2 0B6C 60 PUSH1 0x01 0B6E 16 AND 0B6F 15 ISZERO 0B70 61 PUSH2 0x0100 0B73 02 MUL 0B74 03 SUB 0B75 16 AND 0B76 60 PUSH1 0x02 0B78 90 SWAP1 0B79 04 DIV 0B7A 80 DUP1 0B7B 15 ISZERO 0B7C 61 PUSH2 0x0bc6 0B7F 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0B5B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) / 0x20 * 0x20 // @0B5D stack[0] = memory[0x40:0x60] // @0B5E stack[1] = 0x01 // @0B5F stack[2] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @0B62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // @0B65 stack[3] = 0x20 + memory[0x40:0x60] // @0B66 stack[4] = 0x01 // @0B79 stack[5] = (0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02 // } // Block ends with conditional jump to 0x0bc6, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) label_0B80: // Incoming jump from 0x0B7F, if not !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Inputs[1] { @0B80 stack[-1] } 0B80 80 DUP1 0B81 60 PUSH1 0x1f 0B83 10 LT 0B84 61 PUSH2 0x0b9b 0B87 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b9b, if 0x1f < stack[-1] label_0B88: // Incoming jump from 0x0B87, if not 0x1f < stack[-1] // Inputs[4] // { // @0B8C stack[-2] // @0B8D storage[stack[-2]] // @0B90 stack[-3] // @0B92 stack[-1] // } 0B88 61 PUSH2 0x0100 0B8B 80 DUP1 0B8C 83 DUP4 0B8D 54 SLOAD 0B8E 04 DIV 0B8F 02 MUL 0B90 83 DUP4 0B91 52 MSTORE 0B92 91 SWAP2 0B93 60 PUSH1 0x20 0B95 01 ADD 0B96 91 SWAP2 0B97 61 PUSH2 0x0bc6 0B9A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B91 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B96 stack[-1] = stack[-1] // @0B96 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0bc6 label_0B9B: // Incoming jump from 0x0B87, if 0x1f < stack[-1] // Inputs[5] // { // @0B9C stack[-3] // @0B9D stack[-1] // @0B9F stack[-2] // @0BA7 memory[0x00:0x20] // @0BAB storage[keccak256(memory[0x00:0x20])] // } 0B9B 5B JUMPDEST 0B9C 82 DUP3 0B9D 01 ADD 0B9E 91 SWAP2 0B9F 90 SWAP1 0BA0 60 PUSH1 0x00 0BA2 52 MSTORE 0BA3 60 PUSH1 0x20 0BA5 60 PUSH1 0x00 0BA7 20 SHA3 0BA8 90 SWAP1 0BA9 5B JUMPDEST 0BAA 81 DUP2 0BAB 54 SLOAD 0BAC 81 DUP2 0BAD 52 MSTORE 0BAE 90 SWAP1 0BAF 60 PUSH1 0x01 0BB1 01 ADD 0BB2 90 SWAP1 0BB3 60 PUSH1 0x20 0BB5 01 ADD 0BB6 80 DUP1 0BB7 83 DUP4 0BB8 11 GT 0BB9 61 PUSH2 0x0ba9 0BBC 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B9E stack[-3] = stack[-3] + stack[-1] // @0BA2 memory[0x00:0x20] = stack[-2] // @0BAD memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0BB2 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0BB5 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0ba9, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0BBD: // Incoming jump from 0x0BBC, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0BBC, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0BBD stack[-3] // @0BBE stack[-1] // } 0BBD 82 DUP3 0BBE 90 SWAP1 0BBF 03 SUB 0BC0 60 PUSH1 0x1f 0BC2 16 AND 0BC3 82 DUP3 0BC4 01 ADD 0BC5 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0BC5 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0BC5 stack[-1] = stack[-3] // } // Block continues label_0BC6: // Incoming jump from 0x0B7F, if !((0x0100 * !(0x01 & storage[0x01]) - 0x01 & storage[0x01]) / 0x02) // Incoming jump from 0x0BC5 // Incoming jump from 0x0B9A // Inputs[1] { @0BCC stack[-7] } 0BC6 5B JUMPDEST 0BC7 50 POP 0BC8 50 POP 0BC9 50 POP 0BCA 50 POP 0BCB 50 POP 0BCC 81 DUP2 0BCD 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0BCE: // Incoming call from 0x03AF, returns to 0x03B0 // Inputs[3] // { // @0BD4 msg.sender // @0BD5 stack[-2] // @0BD6 stack[-1] // } 0BCE 5B JUMPDEST 0BCF 60 PUSH1 0x00 0BD1 61 PUSH2 0x0bdb 0BD4 33 CALLER 0BD5 84 DUP5 0BD6 84 DUP5 0BD7 61 PUSH2 0x068c 0BDA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0BCF stack[0] = 0x00 // @0BD1 stack[1] = 0x0bdb // @0BD4 stack[2] = msg.sender // @0BD5 stack[3] = stack[-2] // @0BD6 stack[4] = stack[-1] // } // Block ends with call to 0x068c, returns to 0x0BDB label_0BDB: // Incoming return from call to 0x068C at 0x0BDA // Inputs[4] // { // @0BDC stack[-2] // @0BDC stack[-1] // @0BDE stack[-5] // @0BDF stack[-4] // } 0BDB 5B JUMPDEST 0BDC 90 SWAP1 0BDD 50 POP 0BDE 92 SWAP3 0BDF 91 SWAP2 0BE0 50 POP 0BE1 50 POP 0BE2 56 *JUMP // Stack delta = -4 // Outputs[1] { @0BDE stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0BE3: // Incoming call from 0x0429, returns to 0x042A // Inputs[6] // { // @0BE9 stack[-2] // @0BF1 memory[0x00:0x40] // @0BF5 stack[-1] // @0BFD memory[0x00:0x40] // @0C05 storage[keccak256(memory[0x00:0x40])] // @0C06 stack[-3] // } 0BE3 5B JUMPDEST 0BE4 60 PUSH1 0x04 0BE6 60 PUSH1 0x20 0BE8 52 MSTORE 0BE9 81 DUP2 0BEA 60 PUSH1 0x00 0BEC 52 MSTORE 0BED 60 PUSH1 0x40 0BEF 60 PUSH1 0x00 0BF1 20 SHA3 0BF2 60 PUSH1 0x20 0BF4 52 MSTORE 0BF5 80 DUP1 0BF6 60 PUSH1 0x00 0BF8 52 MSTORE 0BF9 60 PUSH1 0x40 0BFB 60 PUSH1 0x00 0BFD 20 SHA3 0BFE 60 PUSH1 0x00 0C00 91 SWAP2 0C01 50 POP 0C02 91 SWAP2 0C03 50 POP 0C04 50 POP 0C05 54 SLOAD 0C06 81 DUP2 0C07 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @0BE8 memory[0x20:0x40] = 0x04 // @0BEC memory[0x00:0x20] = stack[-2] // @0BF4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0BF8 memory[0x00:0x20] = stack[-1] // @0C05 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 0C08 00 *STOP 0C09 A1 LOG1 0C0A 65 PUSH6 0x627a7a723058 0C11 20 SHA3 0C12 DE DE 0C13 B4 B4 0C14 C2 C2 0C15 CC CC 0C16 AB AB 0C17 3C EXTCODECOPY 0C18 2F 2F 0C19 DC DC 0C1A A3 LOG3 0C1B 2A 2A 0C1C B3 B3 0C1D F4 DELEGATECALL 0C1E 67 PUSH8 0x28389c2fe2c165d5 0C27 FA STATICCALL 0C28 FA STATICCALL 0C29 07 SMOD 0C2A 66 PUSH7 0x1e4e004f6c344a 0C32 00 *STOP 0C33 29 29