Online Solidity Decompiler

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 0x00d6 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x00d6, 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 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x9010d07c 0019 11 GT 001A 61 PUSH2 0x007f 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x007f, if 0x9010d07c > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x9010d07c > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc1075329 0024 11 GT 0025 61 PUSH2 0x0059 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0059, if 0xc1075329 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc1075329 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc1075329 002F 14 EQ 0030 61 PUSH2 0x02d9 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d9, if 0xc1075329 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc1075329 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc4d66de8 003A 14 EQ 003B 61 PUSH2 0x0312 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0312, if 0xc4d66de8 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc4d66de8 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xca15c873 0045 14 EQ 0046 61 PUSH2 0x0345 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0345, if 0xca15c873 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xca15c873 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xd547741f 0050 14 EQ 0051 61 PUSH2 0x036f 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036f, if 0xd547741f == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xd547741f == stack[-1] 0055 61 PUSH2 0x00dd 0058 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00dd label_0059: // Incoming jump from 0x0028, if 0xc1075329 > stack[-1] // Inputs[1] { @005A stack[-1] } 0059 5B JUMPDEST 005A 80 DUP1 005B 63 PUSH4 0x9010d07c 0060 14 EQ 0061 61 PUSH2 0x023f 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0x9010d07c == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x9010d07c == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0x91d14854 006B 14 EQ 006C 61 PUSH2 0x028b 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028b, if 0x91d14854 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x91d14854 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xa217fddf 0076 14 EQ 0077 61 PUSH2 0x02c4 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c4, if 0xa217fddf == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa217fddf == stack[-1] 007B 61 PUSH2 0x00dd 007E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00dd label_007F: // Incoming jump from 0x001D, if 0x9010d07c > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0x2f2ff15d 0086 11 GT 0087 61 PUSH2 0x00b0 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b0, if 0x2f2ff15d > stack[-1] label_008B: // Incoming jump from 0x008A, if not 0x2f2ff15d > stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0x2f2ff15d 0091 14 EQ 0092 61 PUSH2 0x019a 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019a, if 0x2f2ff15d == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x35bb3e16 009C 14 EQ 009D 61 PUSH2 0x01d3 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d3, if 0x35bb3e16 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x35bb3e16 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x36568abe 00A7 14 EQ 00A8 61 PUSH2 0x0206 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0206, if 0x36568abe == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x36568abe == stack[-1] 00AC 61 PUSH2 0x00dd 00AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00dd label_00B0: // Incoming jump from 0x008A, if 0x2f2ff15d > stack[-1] // Inputs[1] { @00B1 stack[-1] } 00B0 5B JUMPDEST 00B1 80 DUP1 00B2 63 PUSH4 0x248a9ca3 00B7 14 EQ 00B8 61 PUSH2 0x00e2 00BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e2, if 0x248a9ca3 == stack[-1] label_00BC: // Incoming jump from 0x00BB, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @00BC stack[-1] } 00BC 80 DUP1 00BD 63 PUSH4 0x24d7806c 00C2 14 EQ 00C3 61 PUSH2 0x011e 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011e, if 0x24d7806c == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0x24d7806c == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0x2d345670 00CD 14 EQ 00CE 61 PUSH2 0x0165 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0165, if 0x2d345670 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0x2d345670 == stack[-1] 00D2 61 PUSH2 0x00dd 00D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00dd label_00D6: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @00D7 msg.data.length } 00D6 5B JUMPDEST 00D7 36 CALLDATASIZE 00D8 61 PUSH2 0x00dd 00DB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dd, if msg.data.length label_00DC: // Incoming jump from 0x00DB, if not msg.data.length 00DC 00 *STOP // Stack delta = +0 // Outputs[1] { @00DC stop(); } // Block terminates label_00DD: // Incoming jump from 0x00DB, if msg.data.length // Incoming jump from 0x007E // Incoming jump from 0x0058 // Incoming jump from 0x00AF // Incoming jump from 0x00D5 // Inputs[1] { @00E1 memory[0x00:0x00] } 00DD 5B JUMPDEST 00DE 60 PUSH1 0x00 00E0 80 DUP1 00E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E1 revert(memory[0x00:0x00]); } // Block terminates label_00E2: // Incoming jump from 0x00BB, if 0x248a9ca3 == stack[-1] // Inputs[1] { @00E3 msg.value } 00E2 5B JUMPDEST 00E3 34 CALLVALUE 00E4 80 DUP1 00E5 15 ISZERO 00E6 61 PUSH2 0x00ee 00E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00E3 stack[0] = msg.value } // Block ends with conditional jump to 0x00ee, if !msg.value label_00EA: // Incoming jump from 0x00E9, if not !msg.value // Inputs[1] { @00ED memory[0x00:0x00] } 00EA 60 PUSH1 0x00 00EC 80 DUP1 00ED FD *REVERT // Stack delta = +0 // Outputs[1] { @00ED revert(memory[0x00:0x00]); } // Block terminates label_00EE: // Incoming jump from 0x00E9, if !msg.value // Inputs[1] { @00F6 msg.data.length } 00EE 5B JUMPDEST 00EF 50 POP 00F0 61 PUSH2 0x010c 00F3 60 PUSH1 0x04 00F5 80 DUP1 00F6 36 CALLDATASIZE 00F7 03 SUB 00F8 60 PUSH1 0x20 00FA 81 DUP2 00FB 10 LT 00FC 15 ISZERO 00FD 61 PUSH2 0x0105 0100 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @00F0 stack[-1] = 0x010c // @00F3 stack[0] = 0x04 // @00F7 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0105, returns to 0x010C, if !(msg.data.length - 0x04 < 0x20) label_0101: // Incoming jump from 0x0100, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0104 memory[0x00:0x00] } 0101 60 PUSH1 0x00 0103 80 DUP1 0104 FD *REVERT // Stack delta = +0 // Outputs[1] { @0104 revert(memory[0x00:0x00]); } // Block terminates label_0105: // Incoming call from 0x0100, returns to 0x010C, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0107 msg.data[stack[-2]:stack[-2] + 0x20] // @0107 stack[-2] // } 0105 5B JUMPDEST 0106 50 POP 0107 35 CALLDATALOAD 0108 61 PUSH2 0x03a8 010B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0107 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x03a8 label_010C: // Incoming return from call to 0x0105 at 0x0100 // Incoming return from call to 0x04EC at 0x02D8 // Inputs[4] // { // @0110 memory[0x40:0x60] // @0111 stack[-1] // @0114 memory[0x40:0x60] // @011D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 010C 5B JUMPDEST 010D 60 PUSH1 0x40 010F 80 DUP1 0110 51 MLOAD 0111 91 SWAP2 0112 82 DUP3 0113 52 MSTORE 0114 51 MLOAD 0115 90 SWAP1 0116 81 DUP2 0117 90 SWAP1 0118 03 SUB 0119 60 PUSH1 0x20 011B 01 ADD 011C 90 SWAP1 011D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0113 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @011D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_011E: // Incoming jump from 0x00C6, if 0x24d7806c == stack[-1] // Inputs[1] { @011F msg.value } 011E 5B JUMPDEST 011F 34 CALLVALUE 0120 80 DUP1 0121 15 ISZERO 0122 61 PUSH2 0x012a 0125 57 *JUMPI // Stack delta = +1 // Outputs[1] { @011F stack[0] = msg.value } // Block ends with conditional jump to 0x012a, if !msg.value label_0126: // Incoming jump from 0x0125, if not !msg.value // Inputs[1] { @0129 memory[0x00:0x00] } 0126 60 PUSH1 0x00 0128 80 DUP1 0129 FD *REVERT // Stack delta = +0 // Outputs[1] { @0129 revert(memory[0x00:0x00]); } // Block terminates label_012A: // Incoming jump from 0x0125, if !msg.value // Inputs[1] { @0132 msg.data.length } 012A 5B JUMPDEST 012B 50 POP 012C 61 PUSH2 0x0151 012F 60 PUSH1 0x04 0131 80 DUP1 0132 36 CALLDATASIZE 0133 03 SUB 0134 60 PUSH1 0x20 0136 81 DUP2 0137 10 LT 0138 15 ISZERO 0139 61 PUSH2 0x0141 013C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @012C stack[-1] = 0x0151 // @012F stack[0] = 0x04 // @0133 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0141, if !(msg.data.length - 0x04 < 0x20) label_013D: // Incoming jump from 0x013C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0140 memory[0x00:0x00] } 013D 60 PUSH1 0x00 013F 80 DUP1 0140 FD *REVERT // Stack delta = +0 // Outputs[1] { @0140 revert(memory[0x00:0x00]); } // Block terminates label_0141: // Incoming jump from 0x013C, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0143 stack[-2] // @0143 msg.data[stack[-2]:stack[-2] + 0x20] // } 0141 5B JUMPDEST 0142 50 POP 0143 35 CALLDATALOAD 0144 60 PUSH1 0x01 0146 60 PUSH1 0x01 0148 60 PUSH1 0xa0 014A 1B SHL 014B 03 SUB 014C 16 AND 014D 61 PUSH2 0x03bd 0150 56 *JUMP // Stack delta = -1 // Outputs[1] { @014C stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x03bd 0151 5B JUMPDEST 0152 60 PUSH1 0x40 0154 80 DUP1 0155 51 MLOAD 0156 91 SWAP2 0157 15 ISZERO 0158 15 ISZERO 0159 82 DUP3 015A 52 MSTORE 015B 51 MLOAD 015C 90 SWAP1 015D 81 DUP2 015E 90 SWAP1 015F 03 SUB 0160 60 PUSH1 0x20 0162 01 ADD 0163 90 SWAP1 0164 F3 *RETURN label_0165: // Incoming jump from 0x00D1, if 0x2d345670 == stack[-1] // Inputs[1] { @0166 msg.value } 0165 5B JUMPDEST 0166 34 CALLVALUE 0167 80 DUP1 0168 15 ISZERO 0169 61 PUSH2 0x0171 016C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0166 stack[0] = msg.value } // Block ends with conditional jump to 0x0171, if !msg.value label_016D: // Incoming jump from 0x016C, if not !msg.value // Inputs[1] { @0170 memory[0x00:0x00] } 016D 60 PUSH1 0x00 016F 80 DUP1 0170 FD *REVERT // Stack delta = +0 // Outputs[1] { @0170 revert(memory[0x00:0x00]); } // Block terminates label_0171: // Incoming jump from 0x016C, if !msg.value // Inputs[1] { @0179 msg.data.length } 0171 5B JUMPDEST 0172 50 POP 0173 61 PUSH2 0x0198 0176 60 PUSH1 0x04 0178 80 DUP1 0179 36 CALLDATASIZE 017A 03 SUB 017B 60 PUSH1 0x20 017D 81 DUP2 017E 10 LT 017F 15 ISZERO 0180 61 PUSH2 0x0188 0183 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0173 stack[-1] = 0x0198 // @0176 stack[0] = 0x04 // @017A stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0188, if !(msg.data.length - 0x04 < 0x20) label_0184: // Incoming jump from 0x0183, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0187 memory[0x00:0x00] } 0184 60 PUSH1 0x00 0186 80 DUP1 0187 FD *REVERT // Stack delta = +0 // Outputs[1] { @0187 revert(memory[0x00:0x00]); } // Block terminates label_0188: // Incoming jump from 0x0183, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @018A msg.data[stack[-2]:stack[-2] + 0x20] // @018A stack[-2] // } 0188 5B JUMPDEST 0189 50 POP 018A 35 CALLDATALOAD 018B 60 PUSH1 0x01 018D 60 PUSH1 0x01 018F 60 PUSH1 0xa0 0191 1B SHL 0192 03 SUB 0193 16 AND 0194 61 PUSH2 0x03cf 0197 56 *JUMP // Stack delta = -1 // Outputs[1] { @0193 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x03cf 0198 5B JUMPDEST 0199 00 *STOP label_019A: // Incoming jump from 0x0095, if 0x2f2ff15d == stack[-1] // Inputs[1] { @019B msg.value } 019A 5B JUMPDEST 019B 34 CALLVALUE 019C 80 DUP1 019D 15 ISZERO 019E 61 PUSH2 0x01a6 01A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @019B stack[0] = msg.value } // Block ends with conditional jump to 0x01a6, if !msg.value label_01A2: // Incoming jump from 0x01A1, if not !msg.value // Inputs[1] { @01A5 memory[0x00:0x00] } 01A2 60 PUSH1 0x00 01A4 80 DUP1 01A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A5 revert(memory[0x00:0x00]); } // Block terminates label_01A6: // Incoming jump from 0x01A1, if !msg.value // Inputs[1] { @01AE msg.data.length } 01A6 5B JUMPDEST 01A7 50 POP 01A8 61 PUSH2 0x0198 01AB 60 PUSH1 0x04 01AD 80 DUP1 01AE 36 CALLDATASIZE 01AF 03 SUB 01B0 60 PUSH1 0x40 01B2 81 DUP2 01B3 10 LT 01B4 15 ISZERO 01B5 61 PUSH2 0x01bd 01B8 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01A8 stack[-1] = 0x0198 // @01AB stack[0] = 0x04 // @01AF stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x01bd, if !(msg.data.length - 0x04 < 0x40) label_01B9: // Incoming jump from 0x01B8, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @01BC memory[0x00:0x00] } 01B9 60 PUSH1 0x00 01BB 80 DUP1 01BC FD *REVERT // Stack delta = +0 // Outputs[1] { @01BC revert(memory[0x00:0x00]); } // Block terminates label_01BD: // Incoming jump from 0x01B8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @01BF stack[-2] // @01C0 msg.data[stack[-2]:stack[-2] + 0x20] // @01C5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 01BD 5B JUMPDEST 01BE 50 POP 01BF 80 DUP1 01C0 35 CALLDATALOAD 01C1 90 SWAP1 01C2 60 PUSH1 0x20 01C4 01 ADD 01C5 35 CALLDATALOAD 01C6 60 PUSH1 0x01 01C8 60 PUSH1 0x01 01CA 60 PUSH1 0xa0 01CC 1B SHL 01CD 03 SUB 01CE 16 AND 01CF 61 PUSH2 0x03dd 01D2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01C1 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @01CE stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x03dd label_01D3: // Incoming jump from 0x00A0, if 0x35bb3e16 == stack[-1] // Inputs[1] { @01D4 msg.value } 01D3 5B JUMPDEST 01D4 34 CALLVALUE 01D5 80 DUP1 01D6 15 ISZERO 01D7 61 PUSH2 0x01df 01DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01D4 stack[0] = msg.value } // Block ends with conditional jump to 0x01df, if !msg.value label_01DB: // Incoming jump from 0x01DA, if not !msg.value // Inputs[1] { @01DE memory[0x00:0x00] } 01DB 60 PUSH1 0x00 01DD 80 DUP1 01DE FD *REVERT // Stack delta = +0 // Outputs[1] { @01DE revert(memory[0x00:0x00]); } // Block terminates label_01DF: // Incoming jump from 0x01DA, if !msg.value // Inputs[1] { @01E7 msg.data.length } 01DF 5B JUMPDEST 01E0 50 POP 01E1 61 PUSH2 0x0198 01E4 60 PUSH1 0x04 01E6 80 DUP1 01E7 36 CALLDATASIZE 01E8 03 SUB 01E9 60 PUSH1 0x20 01EB 81 DUP2 01EC 10 LT 01ED 15 ISZERO 01EE 61 PUSH2 0x01f6 01F1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01E1 stack[-1] = 0x0198 // @01E4 stack[0] = 0x04 // @01E8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x01f6, if !(msg.data.length - 0x04 < 0x20) label_01F2: // Incoming jump from 0x01F1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01F5 memory[0x00:0x00] } 01F2 60 PUSH1 0x00 01F4 80 DUP1 01F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F5 revert(memory[0x00:0x00]); } // Block terminates label_01F6: // Incoming jump from 0x01F1, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @01F8 msg.data[stack[-2]:stack[-2] + 0x20] // @01F8 stack[-2] // } 01F6 5B JUMPDEST 01F7 50 POP 01F8 35 CALLDATALOAD 01F9 60 PUSH1 0x01 01FB 60 PUSH1 0x01 01FD 60 PUSH1 0xa0 01FF 1B SHL 0200 03 SUB 0201 16 AND 0202 61 PUSH2 0x0449 0205 56 *JUMP // Stack delta = -1 // Outputs[1] { @0201 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0449 label_0206: // Incoming jump from 0x00AB, if 0x36568abe == stack[-1] // Inputs[1] { @0207 msg.value } 0206 5B JUMPDEST 0207 34 CALLVALUE 0208 80 DUP1 0209 15 ISZERO 020A 61 PUSH2 0x0212 020D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0207 stack[0] = msg.value } // Block ends with conditional jump to 0x0212, if !msg.value label_020E: // Incoming jump from 0x020D, if not !msg.value // Inputs[1] { @0211 memory[0x00:0x00] } 020E 60 PUSH1 0x00 0210 80 DUP1 0211 FD *REVERT // Stack delta = +0 // Outputs[1] { @0211 revert(memory[0x00:0x00]); } // Block terminates label_0212: // Incoming jump from 0x020D, if !msg.value // Inputs[1] { @021A msg.data.length } 0212 5B JUMPDEST 0213 50 POP 0214 61 PUSH2 0x0198 0217 60 PUSH1 0x04 0219 80 DUP1 021A 36 CALLDATASIZE 021B 03 SUB 021C 60 PUSH1 0x40 021E 81 DUP2 021F 10 LT 0220 15 ISZERO 0221 61 PUSH2 0x0229 0224 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0214 stack[-1] = 0x0198 // @0217 stack[0] = 0x04 // @021B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0229, if !(msg.data.length - 0x04 < 0x40) label_0225: // Incoming jump from 0x0224, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0228 memory[0x00:0x00] } 0225 60 PUSH1 0x00 0227 80 DUP1 0228 FD *REVERT // Stack delta = +0 // Outputs[1] { @0228 revert(memory[0x00:0x00]); } // Block terminates label_0229: // Incoming jump from 0x0224, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @022B stack[-2] // @022C msg.data[stack[-2]:stack[-2] + 0x20] // @0231 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0229 5B JUMPDEST 022A 50 POP 022B 80 DUP1 022C 35 CALLDATALOAD 022D 90 SWAP1 022E 60 PUSH1 0x20 0230 01 ADD 0231 35 CALLDATALOAD 0232 60 PUSH1 0x01 0234 60 PUSH1 0x01 0236 60 PUSH1 0xa0 0238 1B SHL 0239 03 SUB 023A 16 AND 023B 61 PUSH2 0x0454 023E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @022D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @023A stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0454 label_023F: // Incoming jump from 0x0064, if 0x9010d07c == stack[-1] // Inputs[1] { @0240 msg.value } 023F 5B JUMPDEST 0240 34 CALLVALUE 0241 80 DUP1 0242 15 ISZERO 0243 61 PUSH2 0x024b 0246 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0240 stack[0] = msg.value } // Block ends with conditional jump to 0x024b, if !msg.value label_0247: // Incoming jump from 0x0246, if not !msg.value // Inputs[1] { @024A memory[0x00:0x00] } 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0246, if !msg.value // Inputs[1] { @0253 msg.data.length } 024B 5B JUMPDEST 024C 50 POP 024D 61 PUSH2 0x026f 0250 60 PUSH1 0x04 0252 80 DUP1 0253 36 CALLDATASIZE 0254 03 SUB 0255 60 PUSH1 0x40 0257 81 DUP2 0258 10 LT 0259 15 ISZERO 025A 61 PUSH2 0x0262 025D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @024D stack[-1] = 0x026f // @0250 stack[0] = 0x04 // @0254 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0262, if !(msg.data.length - 0x04 < 0x40) label_025E: // Incoming jump from 0x025D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0261 memory[0x00:0x00] } 025E 60 PUSH1 0x00 0260 80 DUP1 0261 FD *REVERT // Stack delta = +0 // Outputs[1] { @0261 revert(memory[0x00:0x00]); } // Block terminates label_0262: // Incoming jump from 0x025D, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0264 stack[-2] // @0265 msg.data[stack[-2]:stack[-2] + 0x20] // @026A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0262 5B JUMPDEST 0263 50 POP 0264 80 DUP1 0265 35 CALLDATALOAD 0266 90 SWAP1 0267 60 PUSH1 0x20 0269 01 ADD 026A 35 CALLDATALOAD 026B 61 PUSH2 0x04b5 026E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0266 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @026A stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x04b5 026F 5B JUMPDEST 0270 60 PUSH1 0x40 0272 80 DUP1 0273 51 MLOAD 0274 60 PUSH1 0x01 0276 60 PUSH1 0x01 0278 60 PUSH1 0xa0 027A 1B SHL 027B 03 SUB 027C 90 SWAP1 027D 92 SWAP3 027E 16 AND 027F 82 DUP3 0280 52 MSTORE 0281 51 MLOAD 0282 90 SWAP1 0283 81 DUP2 0284 90 SWAP1 0285 03 SUB 0286 60 PUSH1 0x20 0288 01 ADD 0289 90 SWAP1 028A F3 *RETURN label_028B: // Incoming jump from 0x006F, if 0x91d14854 == stack[-1] // Inputs[1] { @028C msg.value } 028B 5B JUMPDEST 028C 34 CALLVALUE 028D 80 DUP1 028E 15 ISZERO 028F 61 PUSH2 0x0297 0292 57 *JUMPI // Stack delta = +1 // Outputs[1] { @028C stack[0] = msg.value } // Block ends with conditional jump to 0x0297, if !msg.value label_0293: // Incoming jump from 0x0292, if not !msg.value // Inputs[1] { @0296 memory[0x00:0x00] } 0293 60 PUSH1 0x00 0295 80 DUP1 0296 FD *REVERT // Stack delta = +0 // Outputs[1] { @0296 revert(memory[0x00:0x00]); } // Block terminates label_0297: // Incoming jump from 0x0292, if !msg.value // Inputs[1] { @029F msg.data.length } 0297 5B JUMPDEST 0298 50 POP 0299 61 PUSH2 0x0151 029C 60 PUSH1 0x04 029E 80 DUP1 029F 36 CALLDATASIZE 02A0 03 SUB 02A1 60 PUSH1 0x40 02A3 81 DUP2 02A4 10 LT 02A5 15 ISZERO 02A6 61 PUSH2 0x02ae 02A9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0299 stack[-1] = 0x0151 // @029C stack[0] = 0x04 // @02A0 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x02ae, if !(msg.data.length - 0x04 < 0x40) label_02AA: // Incoming jump from 0x02A9, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02AD memory[0x00:0x00] } 02AA 60 PUSH1 0x00 02AC 80 DUP1 02AD FD *REVERT // Stack delta = +0 // Outputs[1] { @02AD revert(memory[0x00:0x00]); } // Block terminates label_02AE: // Incoming jump from 0x02A9, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @02B0 stack[-2] // @02B1 msg.data[stack[-2]:stack[-2] + 0x20] // @02B6 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 02AE 5B JUMPDEST 02AF 50 POP 02B0 80 DUP1 02B1 35 CALLDATALOAD 02B2 90 SWAP1 02B3 60 PUSH1 0x20 02B5 01 ADD 02B6 35 CALLDATALOAD 02B7 60 PUSH1 0x01 02B9 60 PUSH1 0x01 02BB 60 PUSH1 0xa0 02BD 1B SHL 02BE 03 SUB 02BF 16 AND 02C0 61 PUSH2 0x04d4 02C3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02B2 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @02BF stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x04d4 label_02C4: // Incoming jump from 0x007A, if 0xa217fddf == stack[-1] // Inputs[1] { @02C5 msg.value } 02C4 5B JUMPDEST 02C5 34 CALLVALUE 02C6 80 DUP1 02C7 15 ISZERO 02C8 61 PUSH2 0x02d0 02CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C5 stack[0] = msg.value } // Block ends with conditional jump to 0x02d0, if !msg.value label_02CC: // Incoming jump from 0x02CB, if not !msg.value // Inputs[1] { @02CF memory[0x00:0x00] } 02CC 60 PUSH1 0x00 02CE 80 DUP1 02CF FD *REVERT // Stack delta = +0 // Outputs[1] { @02CF revert(memory[0x00:0x00]); } // Block terminates label_02D0: // Incoming jump from 0x02CB, if !msg.value 02D0 5B JUMPDEST 02D1 50 POP 02D2 61 PUSH2 0x010c 02D5 61 PUSH2 0x04ec 02D8 56 *JUMP // Stack delta = +0 // Outputs[1] { @02D2 stack[-1] = 0x010c } // Block ends with call to 0x04ec, returns to 0x010C label_02D9: // Incoming jump from 0x0033, if 0xc1075329 == stack[-1] // Inputs[1] { @02DA msg.value } 02D9 5B JUMPDEST 02DA 34 CALLVALUE 02DB 80 DUP1 02DC 15 ISZERO 02DD 61 PUSH2 0x02e5 02E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02DA stack[0] = msg.value } // Block ends with conditional jump to 0x02e5, if !msg.value label_02E1: // Incoming jump from 0x02E0, if not !msg.value // Inputs[1] { @02E4 memory[0x00:0x00] } 02E1 60 PUSH1 0x00 02E3 80 DUP1 02E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E4 revert(memory[0x00:0x00]); } // Block terminates label_02E5: // Incoming jump from 0x02E0, if !msg.value // Inputs[1] { @02ED msg.data.length } 02E5 5B JUMPDEST 02E6 50 POP 02E7 61 PUSH2 0x0198 02EA 60 PUSH1 0x04 02EC 80 DUP1 02ED 36 CALLDATASIZE 02EE 03 SUB 02EF 60 PUSH1 0x40 02F1 81 DUP2 02F2 10 LT 02F3 15 ISZERO 02F4 61 PUSH2 0x02fc 02F7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02E7 stack[-1] = 0x0198 // @02EA stack[0] = 0x04 // @02EE stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x02fc, if !(msg.data.length - 0x04 < 0x40) label_02F8: // Incoming jump from 0x02F7, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02FB memory[0x00:0x00] } 02F8 60 PUSH1 0x00 02FA 80 DUP1 02FB FD *REVERT // Stack delta = +0 // Outputs[1] { @02FB revert(memory[0x00:0x00]); } // Block terminates label_02FC: // Incoming jump from 0x02F7, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0306 stack[-2] // @0307 msg.data[stack[-2]:stack[-2] + 0x20] // @030D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 02FC 5B JUMPDEST 02FD 50 POP 02FE 60 PUSH1 0x01 0300 60 PUSH1 0x01 0302 60 PUSH1 0xa0 0304 1B SHL 0305 03 SUB 0306 81 DUP2 0307 35 CALLDATALOAD 0308 16 AND 0309 90 SWAP1 030A 60 PUSH1 0x20 030C 01 ADD 030D 35 CALLDATALOAD 030E 61 PUSH2 0x04f1 0311 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0309 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @030D stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x04f1 label_0312: // Incoming jump from 0x003E, if 0xc4d66de8 == stack[-1] // Inputs[1] { @0313 msg.value } 0312 5B JUMPDEST 0313 34 CALLVALUE 0314 80 DUP1 0315 15 ISZERO 0316 61 PUSH2 0x031e 0319 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0313 stack[0] = msg.value } // Block ends with conditional jump to 0x031e, if !msg.value label_031A: // Incoming jump from 0x0319, if not !msg.value // Inputs[1] { @031D memory[0x00:0x00] } 031A 60 PUSH1 0x00 031C 80 DUP1 031D FD *REVERT // Stack delta = +0 // Outputs[1] { @031D revert(memory[0x00:0x00]); } // Block terminates label_031E: // Incoming jump from 0x0319, if !msg.value // Inputs[1] { @0326 msg.data.length } 031E 5B JUMPDEST 031F 50 POP 0320 61 PUSH2 0x0198 0323 60 PUSH1 0x04 0325 80 DUP1 0326 36 CALLDATASIZE 0327 03 SUB 0328 60 PUSH1 0x20 032A 81 DUP2 032B 10 LT 032C 15 ISZERO 032D 61 PUSH2 0x0335 0330 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0320 stack[-1] = 0x0198 // @0323 stack[0] = 0x04 // @0327 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0335, if !(msg.data.length - 0x04 < 0x20) label_0331: // Incoming jump from 0x0330, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0334 memory[0x00:0x00] } 0331 60 PUSH1 0x00 0333 80 DUP1 0334 FD *REVERT // Stack delta = +0 // Outputs[1] { @0334 revert(memory[0x00:0x00]); } // Block terminates label_0335: // Incoming jump from 0x0330, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0337 msg.data[stack[-2]:stack[-2] + 0x20] // @0337 stack[-2] // } 0335 5B JUMPDEST 0336 50 POP 0337 35 CALLDATALOAD 0338 60 PUSH1 0x01 033A 60 PUSH1 0x01 033C 60 PUSH1 0xa0 033E 1B SHL 033F 03 SUB 0340 16 AND 0341 61 PUSH2 0x0595 0344 56 *JUMP // Stack delta = -1 // Outputs[1] { @0340 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0595 label_0345: // Incoming jump from 0x0049, if 0xca15c873 == stack[-1] // Inputs[1] { @0346 msg.value } 0345 5B JUMPDEST 0346 34 CALLVALUE 0347 80 DUP1 0348 15 ISZERO 0349 61 PUSH2 0x0351 034C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0346 stack[0] = msg.value } // Block ends with conditional jump to 0x0351, if !msg.value label_034D: // Incoming jump from 0x034C, if not !msg.value // Inputs[1] { @0350 memory[0x00:0x00] } 034D 60 PUSH1 0x00 034F 80 DUP1 0350 FD *REVERT // Stack delta = +0 // Outputs[1] { @0350 revert(memory[0x00:0x00]); } // Block terminates label_0351: // Incoming jump from 0x034C, if !msg.value // Inputs[1] { @0359 msg.data.length } 0351 5B JUMPDEST 0352 50 POP 0353 61 PUSH2 0x010c 0356 60 PUSH1 0x04 0358 80 DUP1 0359 36 CALLDATASIZE 035A 03 SUB 035B 60 PUSH1 0x20 035D 81 DUP2 035E 10 LT 035F 15 ISZERO 0360 61 PUSH2 0x0368 0363 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0353 stack[-1] = 0x010c // @0356 stack[0] = 0x04 // @035A stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0368, if !(msg.data.length - 0x04 < 0x20) label_0364: // Incoming jump from 0x0363, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0367 memory[0x00:0x00] } 0364 60 PUSH1 0x00 0366 80 DUP1 0367 FD *REVERT // Stack delta = +0 // Outputs[1] { @0367 revert(memory[0x00:0x00]); } // Block terminates label_0368: // Incoming jump from 0x0363, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @036A stack[-2] // @036A msg.data[stack[-2]:stack[-2] + 0x20] // } 0368 5B JUMPDEST 0369 50 POP 036A 35 CALLDATALOAD 036B 61 PUSH2 0x0640 036E 56 *JUMP // Stack delta = -1 // Outputs[1] { @036A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0640 label_036F: // Incoming jump from 0x0054, if 0xd547741f == stack[-1] // Inputs[1] { @0370 msg.value } 036F 5B JUMPDEST 0370 34 CALLVALUE 0371 80 DUP1 0372 15 ISZERO 0373 61 PUSH2 0x037b 0376 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0370 stack[0] = msg.value } // 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[1] { @0383 msg.data.length } 037B 5B JUMPDEST 037C 50 POP 037D 61 PUSH2 0x0198 0380 60 PUSH1 0x04 0382 80 DUP1 0383 36 CALLDATASIZE 0384 03 SUB 0385 60 PUSH1 0x40 0387 81 DUP2 0388 10 LT 0389 15 ISZERO 038A 61 PUSH2 0x0392 038D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @037D stack[-1] = 0x0198 // @0380 stack[0] = 0x04 // @0384 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0392, if !(msg.data.length - 0x04 < 0x40) label_038E: // Incoming jump from 0x038D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0391 memory[0x00:0x00] } 038E 60 PUSH1 0x00 0390 80 DUP1 0391 FD *REVERT // Stack delta = +0 // Outputs[1] { @0391 revert(memory[0x00:0x00]); } // Block terminates label_0392: // Incoming jump from 0x038D, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0394 stack[-2] // @0395 msg.data[stack[-2]:stack[-2] + 0x20] // @039A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0392 5B JUMPDEST 0393 50 POP 0394 80 DUP1 0395 35 CALLDATALOAD 0396 90 SWAP1 0397 60 PUSH1 0x20 0399 01 ADD 039A 35 CALLDATALOAD 039B 60 PUSH1 0x01 039D 60 PUSH1 0x01 039F 60 PUSH1 0xa0 03A1 1B SHL 03A2 03 SUB 03A3 16 AND 03A4 61 PUSH2 0x0657 03A7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0396 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03A3 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0657 label_03A8: // Incoming jump from 0x010B // Inputs[4] // { // @03AB stack[-1] // @03B6 memory[0x00:0x40] // @03BA storage[0x02 + keccak256(memory[0x00:0x40])] // @03BB stack[-2] // } 03A8 5B JUMPDEST 03A9 60 PUSH1 0x00 03AB 90 SWAP1 03AC 81 DUP2 03AD 52 MSTORE 03AE 60 PUSH1 0x33 03B0 60 PUSH1 0x20 03B2 52 MSTORE 03B3 60 PUSH1 0x40 03B5 90 SWAP1 03B6 20 SHA3 03B7 60 PUSH1 0x02 03B9 01 ADD 03BA 54 SLOAD 03BB 90 SWAP1 03BC 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @03AD memory[0x00:0x20] = stack[-1] // @03B2 memory[0x20:0x40] = 0x33 // @03BB stack[-2] = storage[0x02 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_03BD: // Incoming jump from 0x0150 // Inputs[1] { @03C4 stack[-1] } 03BD 5B JUMPDEST 03BE 60 PUSH1 0x00 03C0 61 PUSH2 0x03c9 03C3 81 DUP2 03C4 83 DUP4 03C5 61 PUSH2 0x04d4 03C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03BE stack[0] = 0x00 // @03C0 stack[1] = 0x03c9 // @03C3 stack[2] = 0x00 // @03C4 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x04d4 label_03C9: // Incoming return from call to 0x0937 at 0x0656 // Incoming return from call to 0x0A99 at 0x0941 // Incoming jump from 0x0BAC // Incoming jump from 0x0BA2 // Inputs[3] // { // @03CA stack[-1] // @03CA stack[-4] // @03CB stack[-3] // } 03C9 5B JUMPDEST 03CA 92 SWAP3 03CB 91 SWAP2 03CC 50 POP 03CD 50 POP 03CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @03CA stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_03CF: // Incoming jump from 0x0197 // Inputs[1] { @03D5 stack[-1] } 03CF 5B JUMPDEST 03D0 61 PUSH2 0x03da 03D3 60 PUSH1 0x00 03D5 82 DUP3 03D6 61 PUSH2 0x0657 03D9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @03D0 stack[0] = 0x03da // @03D3 stack[1] = 0x00 // @03D5 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0657 label_03DA: // Incoming jump from 0x0A8B, if !stack[-1] // Incoming jump from 0x0C3F, if !stack[-1] // Inputs[1] { @03DC stack[-2] } 03DA 5B JUMPDEST 03DB 50 POP 03DC 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_03DD: // Incoming jump from 0x0453 // Incoming jump from 0x01D2 // Inputs[3] // { // @03E0 stack[-2] // @03EB memory[0x00:0x40] // @03EF storage[0x02 + keccak256(memory[0x00:0x40])] // } 03DD 5B JUMPDEST 03DE 60 PUSH1 0x00 03E0 82 DUP3 03E1 81 DUP2 03E2 52 MSTORE 03E3 60 PUSH1 0x33 03E5 60 PUSH1 0x20 03E7 52 MSTORE 03E8 60 PUSH1 0x40 03EA 90 SWAP1 03EB 20 SHA3 03EC 60 PUSH1 0x02 03EE 01 ADD 03EF 54 SLOAD 03F0 61 PUSH2 0x0400 03F3 90 SWAP1 03F4 61 PUSH2 0x03fb 03F7 61 PUSH2 0x06b0 03FA 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @03E2 memory[0x00:0x20] = stack[-2] // @03E7 memory[0x20:0x40] = 0x33 // @03F3 stack[0] = 0x0400 // @03F3 stack[1] = storage[0x02 + keccak256(memory[0x00:0x40])] // @03F4 stack[2] = 0x03fb // } // Block ends with call to 0x06b0, returns to 0x03FB label_03FB: // Incoming return from call to 0x06B0 at 0x03FA // Incoming return from call to 0x06B0 at 0x0674 03FB 5B JUMPDEST 03FC 61 PUSH2 0x04d4 03FF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04d4 0400 5B JUMPDEST 0401 61 PUSH2 0x043b 0404 57 *JUMPI 0405 60 PUSH1 0x40 0407 51 MLOAD 0408 62 PUSH3 0x461bcd 040C 60 PUSH1 0xe5 040E 1B SHL 040F 81 DUP2 0410 52 MSTORE 0411 60 PUSH1 0x04 0413 01 ADD 0414 80 DUP1 0415 80 DUP1 0416 60 PUSH1 0x20 0418 01 ADD 0419 82 DUP3 041A 81 DUP2 041B 03 SUB 041C 82 DUP3 041D 52 MSTORE 041E 60 PUSH1 0x2f 0420 81 DUP2 0421 52 MSTORE 0422 60 PUSH1 0x20 0424 01 ADD 0425 80 DUP1 0426 61 PUSH2 0x0c70 0429 60 PUSH1 0x2f 042B 91 SWAP2 042C 39 CODECOPY 042D 60 PUSH1 0x40 042F 01 ADD 0430 91 SWAP2 0431 50 POP 0432 50 POP 0433 60 PUSH1 0x40 0435 51 MLOAD 0436 80 DUP1 0437 91 SWAP2 0438 03 SUB 0439 90 SWAP1 043A FD *REVERT 043B 5B JUMPDEST 043C 61 PUSH2 0x0445 043F 82 DUP3 0440 82 DUP3 0441 61 PUSH2 0x06b4 0444 56 *JUMP 0445 5B JUMPDEST 0446 50 POP 0447 50 POP 0448 56 *JUMP label_0449: // Incoming jump from 0x0205 // Inputs[1] { @044F stack[-1] } 0449 5B JUMPDEST 044A 61 PUSH2 0x03da 044D 60 PUSH1 0x00 044F 82 DUP3 0450 61 PUSH2 0x03dd 0453 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @044A stack[0] = 0x03da // @044D stack[1] = 0x00 // @044F stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x03dd label_0454: // Incoming jump from 0x023E 0454 5B JUMPDEST 0455 61 PUSH2 0x045c 0458 61 PUSH2 0x06b0 045B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0455 stack[0] = 0x045c } // Block ends with call to 0x06b0, returns to 0x045C label_045C: // Incoming return from call to 0x06B0 at 0x045B // Inputs[2] // { // @0465 stack[-1] // @0466 stack[-2] // } 045C 5B JUMPDEST 045D 60 PUSH1 0x01 045F 60 PUSH1 0x01 0461 60 PUSH1 0xa0 0463 1B SHL 0464 03 SUB 0465 16 AND 0466 81 DUP2 0467 60 PUSH1 0x01 0469 60 PUSH1 0x01 046B 60 PUSH1 0xa0 046D 1B SHL 046E 03 SUB 046F 16 AND 0470 14 EQ 0471 61 PUSH2 0x04ab 0474 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x04ab, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] label_0475: // Incoming jump from 0x0474, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @0477 memory[0x40:0x60] // @04A5 memory[0x40:0x60] // @04AA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0475 60 PUSH1 0x40 0477 51 MLOAD 0478 62 PUSH3 0x461bcd 047C 60 PUSH1 0xe5 047E 1B SHL 047F 81 DUP2 0480 52 MSTORE 0481 60 PUSH1 0x04 0483 01 ADD 0484 80 DUP1 0485 80 DUP1 0486 60 PUSH1 0x20 0488 01 ADD 0489 82 DUP3 048A 81 DUP2 048B 03 SUB 048C 82 DUP3 048D 52 MSTORE 048E 60 PUSH1 0x2f 0490 81 DUP2 0491 52 MSTORE 0492 60 PUSH1 0x20 0494 01 ADD 0495 80 DUP1 0496 61 PUSH2 0x0d65 0499 60 PUSH1 0x2f 049B 91 SWAP2 049C 39 CODECOPY 049D 60 PUSH1 0x40 049F 01 ADD 04A0 91 SWAP2 04A1 50 POP 04A2 50 POP 04A3 60 PUSH1 0x40 04A5 51 MLOAD 04A6 80 DUP1 04A7 91 SWAP2 04A8 03 SUB 04A9 90 SWAP1 04AA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0480 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @048D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0491 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2f // @049C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2f] = code[0x0d65:0x0d94] // @04AA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_04AB: // Incoming jump from 0x0474, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @04AF stack[-2] // @04B0 stack[-1] // } 04AB 5B JUMPDEST 04AC 61 PUSH2 0x0445 04AF 82 DUP3 04B0 82 DUP3 04B1 61 PUSH2 0x071d 04B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04AC stack[0] = 0x0445 // @04AF stack[1] = stack[-2] // @04B0 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x071d label_04B5: // Incoming jump from 0x026E // Inputs[3] // { // @04B8 stack[-2] // @04C3 memory[0x00:0x40] // @04C8 stack[-1] // } 04B5 5B JUMPDEST 04B6 60 PUSH1 0x00 04B8 82 DUP3 04B9 81 DUP2 04BA 52 MSTORE 04BB 60 PUSH1 0x33 04BD 60 PUSH1 0x20 04BF 52 MSTORE 04C0 60 PUSH1 0x40 04C2 81 DUP2 04C3 20 SHA3 04C4 61 PUSH2 0x04cd 04C7 90 SWAP1 04C8 83 DUP4 04C9 61 PUSH2 0x0786 04CC 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @04B6 stack[0] = 0x00 // @04BA memory[0x00:0x20] = stack[-2] // @04BF memory[0x20:0x40] = 0x33 // @04C7 stack[2] = keccak256(memory[0x00:0x40]) // @04C7 stack[1] = 0x04cd // @04C8 stack[3] = stack[-1] // } // Block ends with call to 0x0786, returns to 0x04CD label_04CD: // Incoming return from call to 0x09D0 at 0x07A6 // Incoming return from call to 0x0792 at 0x04EB // Incoming return from call to 0x0AE7 at 0x096B // Incoming return from call to 0x0786 at 0x04CC // Incoming return from call to 0x096C at 0x0791 // Inputs[3] // { // @04CE stack[-5] // @04CE stack[-1] // @04CF stack[-4] // } 04CD 5B JUMPDEST 04CE 93 SWAP4 04CF 92 SWAP3 04D0 50 POP 04D1 50 POP 04D2 50 POP 04D3 56 *JUMP // Stack delta = -4 // Outputs[1] { @04CE stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_04D4: // Incoming jump from 0x04FB // Incoming jump from 0x02C3 // Incoming jump from 0x03C8 // Incoming jump from 0x03FF // Inputs[3] // { // @04D7 stack[-2] // @04E2 memory[0x00:0x40] // @04E7 stack[-1] // } 04D4 5B JUMPDEST 04D5 60 PUSH1 0x00 04D7 82 DUP3 04D8 81 DUP2 04D9 52 MSTORE 04DA 60 PUSH1 0x33 04DC 60 PUSH1 0x20 04DE 52 MSTORE 04DF 60 PUSH1 0x40 04E1 81 DUP2 04E2 20 SHA3 04E3 61 PUSH2 0x04cd 04E6 90 SWAP1 04E7 83 DUP4 04E8 61 PUSH2 0x0792 04EB 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @04D5 stack[0] = 0x00 // @04D9 memory[0x00:0x20] = stack[-2] // @04DE memory[0x20:0x40] = 0x33 // @04E6 stack[2] = keccak256(memory[0x00:0x40]) // @04E6 stack[1] = 0x04cd // @04E7 stack[3] = stack[-1] // } // Block ends with call to 0x0792, returns to 0x04CD label_04EC: // Incoming call from 0x02D8, returns to 0x010C // Inputs[1] { @04EF stack[-1] } 04EC 5B JUMPDEST 04ED 60 PUSH1 0x00 04EF 81 DUP2 04F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @04ED stack[0] = 0x00 } // Block ends with unconditional jump to stack[-1] label_04F1: // Incoming jump from 0x0311 // Inputs[1] { @04F7 msg.sender } 04F1 5B JUMPDEST 04F2 61 PUSH2 0x04fc 04F5 60 PUSH1 0x00 04F7 33 CALLER 04F8 61 PUSH2 0x04d4 04FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04F2 stack[0] = 0x04fc // @04F5 stack[1] = 0x00 // @04F7 stack[2] = msg.sender // } // Block ends with unconditional jump to 0x04d4 04FC 5B JUMPDEST 04FD 61 PUSH2 0x0537 0500 57 *JUMPI 0501 60 PUSH1 0x40 0503 51 MLOAD 0504 62 PUSH3 0x461bcd 0508 60 PUSH1 0xe5 050A 1B SHL 050B 81 DUP2 050C 52 MSTORE 050D 60 PUSH1 0x04 050F 01 ADD 0510 80 DUP1 0511 80 DUP1 0512 60 PUSH1 0x20 0514 01 ADD 0515 82 DUP3 0516 81 DUP2 0517 03 SUB 0518 82 DUP3 0519 52 MSTORE 051A 60 PUSH1 0x2e 051C 81 DUP2 051D 52 MSTORE 051E 60 PUSH1 0x20 0520 01 ADD 0521 80 DUP1 0522 61 PUSH2 0x0d37 0525 60 PUSH1 0x2e 0527 91 SWAP2 0528 39 CODECOPY 0529 60 PUSH1 0x40 052B 01 ADD 052C 91 SWAP2 052D 50 POP 052E 50 POP 052F 60 PUSH1 0x40 0531 51 MLOAD 0532 80 DUP1 0533 91 SWAP2 0534 03 SUB 0535 90 SWAP1 0536 FD *REVERT 0537 5B JUMPDEST 0538 80 DUP1 0539 61 PUSH2 0x053f 053C 57 *JUMPI 053D 50 POP 053E 47 SELFBALANCE 053F 5B JUMPDEST 0540 61 PUSH2 0x0552 0543 60 PUSH1 0x01 0545 60 PUSH1 0x01 0547 60 PUSH1 0xa0 0549 1B SHL 054A 03 SUB 054B 83 DUP4 054C 16 AND 054D 82 DUP3 054E 61 PUSH2 0x07a7 0551 56 *JUMP 0552 5B JUMPDEST 0553 60 PUSH1 0x40 0555 80 DUP1 0556 51 MLOAD 0557 82 DUP3 0558 81 DUP2 0559 52 MSTORE 055A 90 SWAP1 055B 51 MLOAD 055C 60 PUSH1 0x01 055E 60 PUSH1 0x01 0560 60 PUSH1 0xa0 0562 1B SHL 0563 03 SUB 0564 84 DUP5 0565 16 AND 0566 91 SWAP2 0567 7F PUSH32 0xeaff4b37086828766ad3268786972c0cd24259d4c87a80f9d3963a3c3d999b0d 0588 91 SWAP2 0589 90 SWAP1 058A 81 DUP2 058B 90 SWAP1 058C 03 SUB 058D 60 PUSH1 0x20 058F 01 ADD 0590 90 SWAP1 0591 A2 LOG2 0592 50 POP 0593 50 POP 0594 56 *JUMP label_0595: // Incoming jump from 0x0344 // Inputs[1] { @0598 storage[0x00] } 0595 5B JUMPDEST 0596 60 PUSH1 0x00 0598 54 SLOAD 0599 61 PUSH2 0x0100 059C 90 SWAP1 059D 04 DIV 059E 60 PUSH1 0xff 05A0 16 AND 05A1 80 DUP1 05A2 61 PUSH2 0x05ae 05A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A0 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x05ae, if 0xff & storage[0x00] / 0x0100 label_05A6: // Incoming jump from 0x05A5, if not 0xff & storage[0x00] / 0x0100 05A6 50 POP 05A7 61 PUSH2 0x05ae 05AA 61 PUSH2 0x0891 05AD 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A7 stack[-1] = 0x05ae } // Block ends with call to 0x0891, returns to 0x05AE label_05AE: // Incoming jump from 0x05A5, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x0891 at 0x05AD // Inputs[1] { @05AF stack[-1] } 05AE 5B JUMPDEST 05AF 80 DUP1 05B0 61 PUSH2 0x05bc 05B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bc, if stack[-1] label_05B4: // Incoming jump from 0x05B3, if not stack[-1] // Inputs[1] { @05B7 storage[0x00] } 05B4 50 POP 05B5 60 PUSH1 0x00 05B7 54 SLOAD 05B8 60 PUSH1 0xff 05BA 16 AND 05BB 15 ISZERO 05BC 5B JUMPDEST 05BD 61 PUSH2 0x05f7 05C0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05f7, if !(0xff & storage[0x00]) label_05C1: // Incoming jump from 0x05C0, if not stack[-1] // Incoming jump from 0x05C0, if not !(0xff & storage[0x00]) // Inputs[3] // { // @05C3 memory[0x40:0x60] // @05F1 memory[0x40:0x60] // @05F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05C1 60 PUSH1 0x40 05C3 51 MLOAD 05C4 62 PUSH3 0x461bcd 05C8 60 PUSH1 0xe5 05CA 1B SHL 05CB 81 DUP2 05CC 52 MSTORE 05CD 60 PUSH1 0x04 05CF 01 ADD 05D0 80 DUP1 05D1 80 DUP1 05D2 60 PUSH1 0x20 05D4 01 ADD 05D5 82 DUP3 05D6 81 DUP2 05D7 03 SUB 05D8 82 DUP3 05D9 52 MSTORE 05DA 60 PUSH1 0x2e 05DC 81 DUP2 05DD 52 MSTORE 05DE 60 PUSH1 0x20 05E0 01 ADD 05E1 80 DUP1 05E2 61 PUSH2 0x0d09 05E5 60 PUSH1 0x2e 05E7 91 SWAP2 05E8 39 CODECOPY 05E9 60 PUSH1 0x40 05EB 01 ADD 05EC 91 SWAP2 05ED 50 POP 05EE 50 POP 05EF 60 PUSH1 0x40 05F1 51 MLOAD 05F2 80 DUP1 05F3 91 SWAP2 05F4 03 SUB 05F5 90 SWAP1 05F6 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @05CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05D9 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @05DD memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @05E8 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x0d09:0x0d37] // @05F6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_05F7: // Incoming jump from 0x05C0, if stack[-1] // Incoming jump from 0x05C0, if !(0xff & storage[0x00]) // Inputs[1] { @05FA storage[0x00] } 05F7 5B JUMPDEST 05F8 60 PUSH1 0x00 05FA 54 SLOAD 05FB 61 PUSH2 0x0100 05FE 90 SWAP1 05FF 04 DIV 0600 60 PUSH1 0xff 0602 16 AND 0603 15 ISZERO 0604 80 DUP1 0605 15 ISZERO 0606 61 PUSH2 0x0622 0609 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0603 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0622, if !!(0xff & storage[0x00] / 0x0100) label_060A: // Incoming jump from 0x0609, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[2] // { // @060D storage[0x00] // @0626 stack[-2] // } 060A 60 PUSH1 0x00 060C 80 DUP1 060D 54 SLOAD 060E 60 PUSH1 0xff 0610 19 NOT 0611 61 PUSH2 0xff00 0614 19 NOT 0615 90 SWAP1 0616 91 SWAP2 0617 16 AND 0618 61 PUSH2 0x0100 061B 17 OR 061C 16 AND 061D 60 PUSH1 0x01 061F 17 OR 0620 90 SWAP1 0621 55 SSTORE 0622 5B JUMPDEST 0623 61 PUSH2 0x062b 0626 82 DUP3 0627 61 PUSH2 0x0897 062A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0621 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0623 stack[0] = 0x062b // @0626 stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x0897 062B 5B JUMPDEST 062C 80 DUP1 062D 15 ISZERO 062E 61 PUSH2 0x0445 0631 57 *JUMPI 0632 60 PUSH1 0x00 0634 80 DUP1 0635 54 SLOAD 0636 61 PUSH2 0xff00 0639 19 NOT 063A 16 AND 063B 90 SWAP1 063C 55 SSTORE 063D 50 POP 063E 50 POP 063F 56 *JUMP label_0640: // Incoming jump from 0x036E // Inputs[2] // { // @0643 stack[-1] // @064E memory[0x00:0x40] // } 0640 5B JUMPDEST 0641 60 PUSH1 0x00 0643 81 DUP2 0644 81 DUP2 0645 52 MSTORE 0646 60 PUSH1 0x33 0648 60 PUSH1 0x20 064A 52 MSTORE 064B 60 PUSH1 0x40 064D 81 DUP2 064E 20 SHA3 064F 61 PUSH2 0x03c9 0652 90 SWAP1 0653 61 PUSH2 0x0937 0656 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0641 stack[0] = 0x00 // @0645 memory[0x00:0x20] = stack[-1] // @064A memory[0x20:0x40] = 0x33 // @0652 stack[1] = 0x03c9 // @0652 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x0937, returns to 0x03C9 label_0657: // Incoming jump from 0x03D9 // Incoming jump from 0x03A7 // Inputs[3] // { // @065A stack[-2] // @0665 memory[0x00:0x40] // @0669 storage[0x02 + keccak256(memory[0x00:0x40])] // } 0657 5B JUMPDEST 0658 60 PUSH1 0x00 065A 82 DUP3 065B 81 DUP2 065C 52 MSTORE 065D 60 PUSH1 0x33 065F 60 PUSH1 0x20 0661 52 MSTORE 0662 60 PUSH1 0x40 0664 90 SWAP1 0665 20 SHA3 0666 60 PUSH1 0x02 0668 01 ADD 0669 54 SLOAD 066A 61 PUSH2 0x0675 066D 90 SWAP1 066E 61 PUSH2 0x03fb 0671 61 PUSH2 0x06b0 0674 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @065C memory[0x00:0x20] = stack[-2] // @0661 memory[0x20:0x40] = 0x33 // @066D stack[0] = 0x0675 // @066D stack[1] = storage[0x02 + keccak256(memory[0x00:0x40])] // @066E stack[2] = 0x03fb // } // Block ends with call to 0x06b0, returns to 0x03FB 0675 5B JUMPDEST 0676 61 PUSH2 0x04ab 0679 57 *JUMPI 067A 60 PUSH1 0x40 067C 51 MLOAD 067D 62 PUSH3 0x461bcd 0681 60 PUSH1 0xe5 0683 1B SHL 0684 81 DUP2 0685 52 MSTORE 0686 60 PUSH1 0x04 0688 01 ADD 0689 80 DUP1 068A 80 DUP1 068B 60 PUSH1 0x20 068D 01 ADD 068E 82 DUP3 068F 81 DUP2 0690 03 SUB 0691 82 DUP3 0692 52 MSTORE 0693 60 PUSH1 0x30 0695 81 DUP2 0696 52 MSTORE 0697 60 PUSH1 0x20 0699 01 ADD 069A 80 DUP1 069B 61 PUSH2 0x0cd9 069E 60 PUSH1 0x30 06A0 91 SWAP2 06A1 39 CODECOPY 06A2 60 PUSH1 0x40 06A4 01 ADD 06A5 91 SWAP2 06A6 50 POP 06A7 50 POP 06A8 60 PUSH1 0x40 06AA 51 MLOAD 06AB 80 DUP1 06AC 91 SWAP2 06AD 03 SUB 06AE 90 SWAP1 06AF FD *REVERT label_06B0: // Incoming call from 0x0674, returns to 0x03FB // Incoming call from 0x03FA, returns to 0x03FB // Incoming call from 0x045B, returns to 0x045C // Inputs[2] // { // @06B1 msg.sender // @06B2 stack[-1] // } 06B0 5B JUMPDEST 06B1 33 CALLER 06B2 90 SWAP1 06B3 56 *JUMP // Stack delta = +0 // Outputs[1] { @06B2 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] 06B4 5B JUMPDEST 06B5 60 PUSH1 0x00 06B7 82 DUP3 06B8 81 DUP2 06B9 52 MSTORE 06BA 60 PUSH1 0x33 06BC 60 PUSH1 0x20 06BE 52 MSTORE 06BF 60 PUSH1 0x40 06C1 90 SWAP1 06C2 20 SHA3 06C3 61 PUSH2 0x06cc 06C6 90 SWAP1 06C7 82 DUP3 06C8 61 PUSH2 0x0942 06CB 56 *JUMP 06CC 5B JUMPDEST 06CD 15 ISZERO 06CE 61 PUSH2 0x0445 06D1 57 *JUMPI 06D2 61 PUSH2 0x06d9 06D5 61 PUSH2 0x06b0 06D8 56 *JUMP 06D9 5B JUMPDEST 06DA 60 PUSH1 0x01 06DC 60 PUSH1 0x01 06DE 60 PUSH1 0xa0 06E0 1B SHL 06E1 03 SUB 06E2 16 AND 06E3 81 DUP2 06E4 60 PUSH1 0x01 06E6 60 PUSH1 0x01 06E8 60 PUSH1 0xa0 06EA 1B SHL 06EB 03 SUB 06EC 16 AND 06ED 83 DUP4 06EE 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 070F 60 PUSH1 0x40 0711 51 MLOAD 0712 60 PUSH1 0x40 0714 51 MLOAD 0715 80 DUP1 0716 91 SWAP2 0717 03 SUB 0718 90 SWAP1 0719 A4 LOG4 071A 50 POP 071B 50 POP 071C 56 *JUMP label_071D: // Incoming jump from 0x04B4 // Inputs[3] // { // @0720 stack[-2] // @072B memory[0x00:0x40] // @0730 stack[-1] // } 071D 5B JUMPDEST 071E 60 PUSH1 0x00 0720 82 DUP3 0721 81 DUP2 0722 52 MSTORE 0723 60 PUSH1 0x33 0725 60 PUSH1 0x20 0727 52 MSTORE 0728 60 PUSH1 0x40 072A 90 SWAP1 072B 20 SHA3 072C 61 PUSH2 0x0735 072F 90 SWAP1 0730 82 DUP3 0731 61 PUSH2 0x0957 0734 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0722 memory[0x00:0x20] = stack[-2] // @0727 memory[0x20:0x40] = 0x33 // @072F stack[0] = 0x0735 // @072F stack[1] = keccak256(memory[0x00:0x40]) // @0730 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0957 0735 5B JUMPDEST 0736 15 ISZERO 0737 61 PUSH2 0x0445 073A 57 *JUMPI 073B 61 PUSH2 0x0742 073E 61 PUSH2 0x06b0 0741 56 *JUMP 0742 5B JUMPDEST 0743 60 PUSH1 0x01 0745 60 PUSH1 0x01 0747 60 PUSH1 0xa0 0749 1B SHL 074A 03 SUB 074B 16 AND 074C 81 DUP2 074D 60 PUSH1 0x01 074F 60 PUSH1 0x01 0751 60 PUSH1 0xa0 0753 1B SHL 0754 03 SUB 0755 16 AND 0756 83 DUP4 0757 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 0778 60 PUSH1 0x40 077A 51 MLOAD 077B 60 PUSH1 0x40 077D 51 MLOAD 077E 80 DUP1 077F 91 SWAP2 0780 03 SUB 0781 90 SWAP1 0782 A4 LOG4 0783 50 POP 0784 50 POP 0785 56 *JUMP label_0786: // Incoming call from 0x04CC, returns to 0x04CD // Inputs[2] // { // @078C stack[-2] // @078D stack[-1] // } 0786 5B JUMPDEST 0787 60 PUSH1 0x00 0789 61 PUSH2 0x04cd 078C 83 DUP4 078D 83 DUP4 078E 61 PUSH2 0x096c 0791 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0787 stack[0] = 0x00 // @0789 stack[1] = 0x04cd // @078C stack[2] = stack[-2] // @078D stack[3] = stack[-1] // } // Block ends with call to 0x096c, returns to 0x04CD label_0792: // Incoming call from 0x04EB, returns to 0x04CD // Inputs[2] // { // @0798 stack[-2] // @07A1 stack[-1] // } 0792 5B JUMPDEST 0793 60 PUSH1 0x00 0795 61 PUSH2 0x04cd 0798 83 DUP4 0799 60 PUSH1 0x01 079B 60 PUSH1 0x01 079D 60 PUSH1 0xa0 079F 1B SHL 07A0 03 SUB 07A1 84 DUP5 07A2 16 AND 07A3 61 PUSH2 0x09d0 07A6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0793 stack[0] = 0x00 // @0795 stack[1] = 0x04cd // @0798 stack[2] = stack[-2] // @07A2 stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x09d0, returns to 0x04CD 07A7 5B JUMPDEST 07A8 80 DUP1 07A9 47 SELFBALANCE 07AA 10 LT 07AB 15 ISZERO 07AC 61 PUSH2 0x07fc 07AF 57 *JUMPI 07B0 60 PUSH1 0x40 07B2 80 DUP1 07B3 51 MLOAD 07B4 62 PUSH3 0x461bcd 07B8 60 PUSH1 0xe5 07BA 1B SHL 07BB 81 DUP2 07BC 52 MSTORE 07BD 60 PUSH1 0x20 07BF 60 PUSH1 0x04 07C1 82 DUP3 07C2 01 ADD 07C3 52 MSTORE 07C4 60 PUSH1 0x1d 07C6 60 PUSH1 0x24 07C8 82 DUP3 07C9 01 ADD 07CA 52 MSTORE 07CB 7F PUSH32 0x416464726573733a20696e73756666696369656e742062616c616e6365000000 07EC 60 PUSH1 0x44 07EE 82 DUP3 07EF 01 ADD 07F0 52 MSTORE 07F1 90 SWAP1 07F2 51 MLOAD 07F3 90 SWAP1 07F4 81 DUP2 07F5 90 SWAP1 07F6 03 SUB 07F7 60 PUSH1 0x64 07F9 01 ADD 07FA 90 SWAP1 07FB FD *REVERT 07FC 5B JUMPDEST 07FD 60 PUSH1 0x40 07FF 51 MLOAD 0800 60 PUSH1 0x00 0802 90 SWAP1 0803 60 PUSH1 0x01 0805 60 PUSH1 0x01 0807 60 PUSH1 0xa0 0809 1B SHL 080A 03 SUB 080B 84 DUP5 080C 16 AND 080D 90 SWAP1 080E 83 DUP4 080F 90 SWAP1 0810 83 DUP4 0811 81 DUP2 0812 81 DUP2 0813 81 DUP2 0814 85 DUP6 0815 87 DUP8 0816 5A GAS 0817 F1 CALL 0818 92 SWAP3 0819 50 POP 081A 50 POP 081B 50 POP 081C 3D RETURNDATASIZE 081D 80 DUP1 081E 60 PUSH1 0x00 0820 81 DUP2 0821 14 EQ 0822 61 PUSH2 0x0847 0825 57 *JUMPI 0826 60 PUSH1 0x40 0828 51 MLOAD 0829 91 SWAP2 082A 50 POP 082B 60 PUSH1 0x1f 082D 19 NOT 082E 60 PUSH1 0x3f 0830 3D RETURNDATASIZE 0831 01 ADD 0832 16 AND 0833 82 DUP3 0834 01 ADD 0835 60 PUSH1 0x40 0837 52 MSTORE 0838 3D RETURNDATASIZE 0839 82 DUP3 083A 52 MSTORE 083B 3D RETURNDATASIZE 083C 60 PUSH1 0x00 083E 60 PUSH1 0x20 0840 84 DUP5 0841 01 ADD 0842 3E RETURNDATACOPY 0843 61 PUSH2 0x084c 0846 56 *JUMP 0847 5B JUMPDEST 0848 60 PUSH1 0x60 084A 91 SWAP2 084B 50 POP 084C 5B JUMPDEST 084D 50 POP 084E 50 POP 084F 90 SWAP1 0850 50 POP 0851 80 DUP1 0852 61 PUSH2 0x088c 0855 57 *JUMPI 0856 60 PUSH1 0x40 0858 51 MLOAD 0859 62 PUSH3 0x461bcd 085D 60 PUSH1 0xe5 085F 1B SHL 0860 81 DUP2 0861 52 MSTORE 0862 60 PUSH1 0x04 0864 01 ADD 0865 80 DUP1 0866 80 DUP1 0867 60 PUSH1 0x20 0869 01 ADD 086A 82 DUP3 086B 81 DUP2 086C 03 SUB 086D 82 DUP3 086E 52 MSTORE 086F 60 PUSH1 0x3a 0871 81 DUP2 0872 52 MSTORE 0873 60 PUSH1 0x20 0875 01 ADD 0876 80 DUP1 0877 61 PUSH2 0x0c9f 087A 60 PUSH1 0x3a 087C 91 SWAP2 087D 39 CODECOPY 087E 60 PUSH1 0x40 0880 01 ADD 0881 91 SWAP2 0882 50 POP 0883 50 POP 0884 60 PUSH1 0x40 0886 51 MLOAD 0887 80 DUP1 0888 91 SWAP2 0889 03 SUB 088A 90 SWAP1 088B FD *REVERT 088C 5B JUMPDEST 088D 50 POP 088E 50 POP 088F 50 POP 0890 56 *JUMP label_0891: // Incoming call from 0x05AD, returns to 0x05AE // Incoming call from 0x08AF, returns to 0x08B0 // Incoming call from 0x0BC5, returns to 0x0BC6 // Incoming call from 0x0A00, returns to 0x0A01 // Inputs[3] // { // @0892 address(this) // @0893 address(address(this)).code.length // @0895 stack[-1] // } 0891 5B JUMPDEST 0892 30 ADDRESS 0893 3B EXTCODESIZE 0894 15 ISZERO 0895 90 SWAP1 0896 56 *JUMP // Stack delta = +0 // Outputs[1] { @0895 stack[-1] = !address(address(this)).code.length } // Block ends with unconditional jump to stack[-1] label_0897: // Incoming jump from 0x062A // Incoming jump from 0x062A // Inputs[1] { @089A storage[0x00] } 0897 5B JUMPDEST 0898 60 PUSH1 0x00 089A 54 SLOAD 089B 61 PUSH2 0x0100 089E 90 SWAP1 089F 04 DIV 08A0 60 PUSH1 0xff 08A2 16 AND 08A3 80 DUP1 08A4 61 PUSH2 0x08b0 08A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08A2 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x08b0, if 0xff & storage[0x00] / 0x0100 label_08A8: // Incoming jump from 0x08A7, if not 0xff & storage[0x00] / 0x0100 08A8 50 POP 08A9 61 PUSH2 0x08b0 08AC 61 PUSH2 0x0891 08AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @08A9 stack[-1] = 0x08b0 } // Block ends with call to 0x0891, returns to 0x08B0 label_08B0: // Incoming jump from 0x08A7, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x0891 at 0x08AF // Inputs[1] { @08B1 stack[-1] } 08B0 5B JUMPDEST 08B1 80 DUP1 08B2 61 PUSH2 0x08be 08B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08be, if stack[-1] label_08B6: // Incoming jump from 0x08B5, if not stack[-1] // Inputs[1] { @08B9 storage[0x00] } 08B6 50 POP 08B7 60 PUSH1 0x00 08B9 54 SLOAD 08BA 60 PUSH1 0xff 08BC 16 AND 08BD 15 ISZERO 08BE 5B JUMPDEST 08BF 61 PUSH2 0x08f9 08C2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08f9, if !(0xff & storage[0x00]) label_08C3: // Incoming jump from 0x08C2, if not stack[-1] // Incoming jump from 0x08C2, if not !(0xff & storage[0x00]) // Inputs[3] // { // @08C5 memory[0x40:0x60] // @08F3 memory[0x40:0x60] // @08F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08C3 60 PUSH1 0x40 08C5 51 MLOAD 08C6 62 PUSH3 0x461bcd 08CA 60 PUSH1 0xe5 08CC 1B SHL 08CD 81 DUP2 08CE 52 MSTORE 08CF 60 PUSH1 0x04 08D1 01 ADD 08D2 80 DUP1 08D3 80 DUP1 08D4 60 PUSH1 0x20 08D6 01 ADD 08D7 82 DUP3 08D8 81 DUP2 08D9 03 SUB 08DA 82 DUP3 08DB 52 MSTORE 08DC 60 PUSH1 0x2e 08DE 81 DUP2 08DF 52 MSTORE 08E0 60 PUSH1 0x20 08E2 01 ADD 08E3 80 DUP1 08E4 61 PUSH2 0x0d09 08E7 60 PUSH1 0x2e 08E9 91 SWAP2 08EA 39 CODECOPY 08EB 60 PUSH1 0x40 08ED 01 ADD 08EE 91 SWAP2 08EF 50 POP 08F0 50 POP 08F1 60 PUSH1 0x40 08F3 51 MLOAD 08F4 80 DUP1 08F5 91 SWAP2 08F6 03 SUB 08F7 90 SWAP1 08F8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @08CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08DB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @08DF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @08EA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x0d09:0x0d37] // @08F8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08F9: // Incoming jump from 0x08C2, if stack[-1] // Incoming jump from 0x08C2, if !(0xff & storage[0x00]) // Inputs[1] { @08FC storage[0x00] } 08F9 5B JUMPDEST 08FA 60 PUSH1 0x00 08FC 54 SLOAD 08FD 61 PUSH2 0x0100 0900 90 SWAP1 0901 04 DIV 0902 60 PUSH1 0xff 0904 16 AND 0905 15 ISZERO 0906 80 DUP1 0907 15 ISZERO 0908 61 PUSH2 0x0924 090B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0905 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0924, if !!(0xff & storage[0x00] / 0x0100) label_090C: // Incoming jump from 0x090B, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @090F storage[0x00] } 090C 60 PUSH1 0x00 090E 80 DUP1 090F 54 SLOAD 0910 60 PUSH1 0xff 0912 19 NOT 0913 61 PUSH2 0xff00 0916 19 NOT 0917 90 SWAP1 0918 91 SWAP2 0919 16 AND 091A 61 PUSH2 0x0100 091D 17 OR 091E 16 AND 091F 60 PUSH1 0x01 0921 17 OR 0922 90 SWAP1 0923 55 SSTORE 0924 5B JUMPDEST 0925 61 PUSH2 0x092c 0928 61 PUSH2 0x09e8 092B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0923 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0925 stack[0] = 0x092c // } // Block ends with unconditional jump to 0x09e8 092C 5B JUMPDEST 092D 61 PUSH2 0x062b 0930 60 PUSH1 0x00 0932 83 DUP4 0933 61 PUSH2 0x043b 0936 56 *JUMP label_0937: // Incoming call from 0x0656, returns to 0x03C9 // Inputs[1] { @093D stack[-1] } 0937 5B JUMPDEST 0938 60 PUSH1 0x00 093A 61 PUSH2 0x03c9 093D 82 DUP3 093E 61 PUSH2 0x0a99 0941 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0938 stack[0] = 0x00 // @093A stack[1] = 0x03c9 // @093D stack[2] = stack[-1] // } // Block ends with call to 0x0a99, returns to 0x03C9 0942 5B JUMPDEST 0943 60 PUSH1 0x00 0945 61 PUSH2 0x04cd 0948 83 DUP4 0949 60 PUSH1 0x01 094B 60 PUSH1 0x01 094D 60 PUSH1 0xa0 094F 1B SHL 0950 03 SUB 0951 84 DUP5 0952 16 AND 0953 61 PUSH2 0x0a9d 0956 56 *JUMP label_0957: // Incoming jump from 0x0734 // Inputs[2] // { // @095D stack[-2] // @0966 stack[-1] // } 0957 5B JUMPDEST 0958 60 PUSH1 0x00 095A 61 PUSH2 0x04cd 095D 83 DUP4 095E 60 PUSH1 0x01 0960 60 PUSH1 0x01 0962 60 PUSH1 0xa0 0964 1B SHL 0965 03 SUB 0966 84 DUP5 0967 16 AND 0968 61 PUSH2 0x0ae7 096B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0958 stack[0] = 0x00 // @095A stack[1] = 0x04cd // @095D stack[2] = stack[-2] // @0967 stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x0ae7, returns to 0x04CD label_096C: // Incoming call from 0x0791, returns to 0x04CD // Inputs[3] // { // @096D stack[-2] // @096E storage[stack[-2]] // @0972 stack[-1] // } 096C 5B JUMPDEST 096D 81 DUP2 096E 54 SLOAD 096F 60 PUSH1 0x00 0971 90 SWAP1 0972 82 DUP3 0973 10 LT 0974 61 PUSH2 0x09ae 0977 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0971 stack[0] = 0x00 } // Block ends with conditional jump to 0x09ae, if stack[-1] < storage[stack[-2]] label_0978: // Incoming jump from 0x0977, if not stack[-1] < storage[stack[-2]] // Inputs[3] // { // @097A memory[0x40:0x60] // @09A8 memory[0x40:0x60] // @09AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0978 60 PUSH1 0x40 097A 51 MLOAD 097B 62 PUSH3 0x461bcd 097F 60 PUSH1 0xe5 0981 1B SHL 0982 81 DUP2 0983 52 MSTORE 0984 60 PUSH1 0x04 0986 01 ADD 0987 80 DUP1 0988 80 DUP1 0989 60 PUSH1 0x20 098B 01 ADD 098C 82 DUP3 098D 81 DUP2 098E 03 SUB 098F 82 DUP3 0990 52 MSTORE 0991 60 PUSH1 0x22 0993 81 DUP2 0994 52 MSTORE 0995 60 PUSH1 0x20 0997 01 ADD 0998 80 DUP1 0999 61 PUSH2 0x0c4e 099C 60 PUSH1 0x22 099E 91 SWAP2 099F 39 CODECOPY 09A0 60 PUSH1 0x40 09A2 01 ADD 09A3 91 SWAP2 09A4 50 POP 09A5 50 POP 09A6 60 PUSH1 0x40 09A8 51 MLOAD 09A9 80 DUP1 09AA 91 SWAP2 09AB 03 SUB 09AC 90 SWAP1 09AD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0983 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0990 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0994 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @099F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x0c4e:0x0c70] // @09AD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09AE: // Incoming jump from 0x0977, if stack[-1] < storage[stack[-2]] // Inputs[3] // { // @09AF stack[-3] // @09B3 stack[-2] // @09B5 storage[0x00 + stack[-3]] // } 09AE 5B JUMPDEST 09AF 82 DUP3 09B0 60 PUSH1 0x00 09B2 01 ADD 09B3 82 DUP3 09B4 81 DUP2 09B5 54 SLOAD 09B6 81 DUP2 09B7 10 LT 09B8 61 PUSH2 0x09bd 09BB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @09B2 stack[0] = 0x00 + stack[-3] // @09B3 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x09bd, if stack[-2] < storage[0x00 + stack[-3]] label_09BC: // Incoming jump from 0x09BB, if not stack[-2] < storage[0x00 + stack[-3]] 09BC FE *ASSERT // Stack delta = +0 // Outputs[1] { @09BC assert(); } // Block terminates label_09BD: // Incoming jump from 0x09BB, if stack[-2] < storage[0x00 + stack[-3]] // Inputs[7] // { // @09BE stack[-2] // @09BE stack[-1] // @09C6 memory[0x00:0x20] // @09C8 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @09C9 stack[-3] // @09CB stack[-6] // @09CC stack[-5] // } 09BD 5B JUMPDEST 09BE 90 SWAP1 09BF 60 PUSH1 0x00 09C1 52 MSTORE 09C2 60 PUSH1 0x20 09C4 60 PUSH1 0x00 09C6 20 SHA3 09C7 01 ADD 09C8 54 SLOAD 09C9 90 SWAP1 09CA 50 POP 09CB 92 SWAP3 09CC 91 SWAP2 09CD 50 POP 09CE 50 POP 09CF 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @09C1 memory[0x00:0x20] = stack[-2] // @09CB stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_09D0: // Incoming call from 0x07A6, returns to 0x04CD // Inputs[5] // { // @09D3 stack[-1] // @09D8 stack[-2] // @09E2 memory[0x00:0x40] // @09E3 storage[keccak256(memory[0x00:0x40])] // @09E6 stack[-3] // } 09D0 5B JUMPDEST 09D1 60 PUSH1 0x00 09D3 90 SWAP1 09D4 81 DUP2 09D5 52 MSTORE 09D6 60 PUSH1 0x01 09D8 91 SWAP2 09D9 90 SWAP1 09DA 91 SWAP2 09DB 01 ADD 09DC 60 PUSH1 0x20 09DE 52 MSTORE 09DF 60 PUSH1 0x40 09E1 90 SWAP1 09E2 20 SHA3 09E3 54 SLOAD 09E4 15 ISZERO 09E5 15 ISZERO 09E6 90 SWAP1 09E7 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @09D5 memory[0x00:0x20] = stack[-1] // @09DE memory[0x20:0x40] = 0x01 + stack[-2] // @09E6 stack[-3] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_09E8: // Incoming jump from 0x092B // Incoming jump from 0x092B // Inputs[1] { @09EB storage[0x00] } 09E8 5B JUMPDEST 09E9 60 PUSH1 0x00 09EB 54 SLOAD 09EC 61 PUSH2 0x0100 09EF 90 SWAP1 09F0 04 DIV 09F1 60 PUSH1 0xff 09F3 16 AND 09F4 80 DUP1 09F5 61 PUSH2 0x0a01 09F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09F3 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x0a01, if 0xff & storage[0x00] / 0x0100 label_09F9: // Incoming jump from 0x09F8, if not 0xff & storage[0x00] / 0x0100 09F9 50 POP 09FA 61 PUSH2 0x0a01 09FD 61 PUSH2 0x0891 0A00 56 *JUMP // Stack delta = +0 // Outputs[1] { @09FA stack[-1] = 0x0a01 } // Block ends with call to 0x0891, returns to 0x0A01 label_0A01: // Incoming return from call to 0x0891 at 0x0A00 // Incoming jump from 0x09F8, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @0A02 stack[-1] } 0A01 5B JUMPDEST 0A02 80 DUP1 0A03 61 PUSH2 0x0a0f 0A06 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0f, if stack[-1] label_0A07: // Incoming jump from 0x0A06, if not stack[-1] // Inputs[1] { @0A0A storage[0x00] } 0A07 50 POP 0A08 60 PUSH1 0x00 0A0A 54 SLOAD 0A0B 60 PUSH1 0xff 0A0D 16 AND 0A0E 15 ISZERO 0A0F 5B JUMPDEST 0A10 61 PUSH2 0x0a4a 0A13 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a4a, if !(0xff & storage[0x00]) label_0A14: // Incoming jump from 0x0A13, if not !(0xff & storage[0x00]) // Incoming jump from 0x0A13, if not stack[-1] // Inputs[3] // { // @0A16 memory[0x40:0x60] // @0A44 memory[0x40:0x60] // @0A49 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A14 60 PUSH1 0x40 0A16 51 MLOAD 0A17 62 PUSH3 0x461bcd 0A1B 60 PUSH1 0xe5 0A1D 1B SHL 0A1E 81 DUP2 0A1F 52 MSTORE 0A20 60 PUSH1 0x04 0A22 01 ADD 0A23 80 DUP1 0A24 80 DUP1 0A25 60 PUSH1 0x20 0A27 01 ADD 0A28 82 DUP3 0A29 81 DUP2 0A2A 03 SUB 0A2B 82 DUP3 0A2C 52 MSTORE 0A2D 60 PUSH1 0x2e 0A2F 81 DUP2 0A30 52 MSTORE 0A31 60 PUSH1 0x20 0A33 01 ADD 0A34 80 DUP1 0A35 61 PUSH2 0x0d09 0A38 60 PUSH1 0x2e 0A3A 91 SWAP2 0A3B 39 CODECOPY 0A3C 60 PUSH1 0x40 0A3E 01 ADD 0A3F 91 SWAP2 0A40 50 POP 0A41 50 POP 0A42 60 PUSH1 0x40 0A44 51 MLOAD 0A45 80 DUP1 0A46 91 SWAP2 0A47 03 SUB 0A48 90 SWAP1 0A49 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A1F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A2C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0A30 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @0A3B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x0d09:0x0d37] // @0A49 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A4A: // Incoming jump from 0x0A13, if !(0xff & storage[0x00]) // Incoming jump from 0x0A13, if stack[-1] // Inputs[1] { @0A4D storage[0x00] } 0A4A 5B JUMPDEST 0A4B 60 PUSH1 0x00 0A4D 54 SLOAD 0A4E 61 PUSH2 0x0100 0A51 90 SWAP1 0A52 04 DIV 0A53 60 PUSH1 0xff 0A55 16 AND 0A56 15 ISZERO 0A57 80 DUP1 0A58 15 ISZERO 0A59 61 PUSH2 0x0a75 0A5C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A56 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0a75, if !!(0xff & storage[0x00] / 0x0100) label_0A5D: // Incoming jump from 0x0A5C, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[1] { @0A60 storage[0x00] } 0A5D 60 PUSH1 0x00 0A5F 80 DUP1 0A60 54 SLOAD 0A61 60 PUSH1 0xff 0A63 19 NOT 0A64 61 PUSH2 0xff00 0A67 19 NOT 0A68 90 SWAP1 0A69 91 SWAP2 0A6A 16 AND 0A6B 61 PUSH2 0x0100 0A6E 17 OR 0A6F 16 AND 0A70 60 PUSH1 0x01 0A72 17 OR 0A73 90 SWAP1 0A74 55 SSTORE 0A75 5B JUMPDEST 0A76 61 PUSH2 0x0a7d 0A79 61 PUSH2 0x0bad 0A7C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0A74 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0A76 stack[0] = 0x0a7d // } // Block ends with call to 0x0bad, returns to 0x0A7D label_0A7D: // Incoming return from call to 0x0BAD at 0x0A7C // Incoming return from call to 0x0BAD at 0x0A7C 0A7D 5B JUMPDEST 0A7E 61 PUSH2 0x0a85 0A81 61 PUSH2 0x0bad 0A84 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A7E stack[0] = 0x0a85 } // Block ends with call to 0x0bad, returns to 0x0A85 label_0A85: // Incoming jump from 0x0C21, if !!(0xff & storage[0x00] / 0x0100) // Incoming return from call to 0x0BAD at 0x0A84 // Inputs[1] { @0A86 stack[-1] } 0A85 5B JUMPDEST 0A86 80 DUP1 0A87 15 ISZERO 0A88 61 PUSH2 0x03da 0A8B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03da, if !stack[-1] label_0A8C: // Incoming jump from 0x0A8B, if not !stack[-1] // Inputs[2] // { // @0A8F storage[0x00] // @0A98 stack[-2] // } 0A8C 60 PUSH1 0x00 0A8E 80 DUP1 0A8F 54 SLOAD 0A90 61 PUSH2 0xff00 0A93 19 NOT 0A94 16 AND 0A95 90 SWAP1 0A96 55 SSTORE 0A97 50 POP 0A98 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A96 storage[0x00] = ~0xff00 & storage[0x00] } // Block ends with unconditional jump to stack[-2] label_0A99: // Incoming call from 0x0941, returns to 0x03C9 // Inputs[3] // { // @0A9A stack[-1] // @0A9A storage[stack[-1]] // @0A9B stack[-2] // } 0A99 5B JUMPDEST 0A9A 54 SLOAD 0A9B 90 SWAP1 0A9C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A9B stack[-2] = storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] 0A9D 5B JUMPDEST 0A9E 60 PUSH1 0x00 0AA0 61 PUSH2 0x0aa9 0AA3 83 DUP4 0AA4 83 DUP4 0AA5 61 PUSH2 0x09d0 0AA8 56 *JUMP 0AA9 5B JUMPDEST 0AAA 61 PUSH2 0x0adf 0AAD 57 *JUMPI 0AAE 50 POP 0AAF 81 DUP2 0AB0 54 SLOAD 0AB1 60 PUSH1 0x01 0AB3 81 DUP2 0AB4 81 DUP2 0AB5 01 ADD 0AB6 84 DUP5 0AB7 55 SSTORE 0AB8 60 PUSH1 0x00 0ABA 84 DUP5 0ABB 81 DUP2 0ABC 52 MSTORE 0ABD 60 PUSH1 0x20 0ABF 80 DUP1 0AC0 82 DUP3 0AC1 20 SHA3 0AC2 90 SWAP1 0AC3 93 SWAP4 0AC4 01 ADD 0AC5 84 DUP5 0AC6 90 SWAP1 0AC7 55 SSTORE 0AC8 84 DUP5 0AC9 54 SLOAD 0ACA 84 DUP5 0ACB 82 DUP3 0ACC 52 MSTORE 0ACD 82 DUP3 0ACE 86 DUP7 0ACF 01 ADD 0AD0 90 SWAP1 0AD1 93 SWAP4 0AD2 52 MSTORE 0AD3 60 PUSH1 0x40 0AD5 90 SWAP1 0AD6 20 SHA3 0AD7 91 SWAP2 0AD8 90 SWAP1 0AD9 91 SWAP2 0ADA 55 SSTORE 0ADB 61 PUSH2 0x03c9 0ADE 56 *JUMP 0ADF 5B JUMPDEST 0AE0 50 POP 0AE1 60 PUSH1 0x00 0AE3 61 PUSH2 0x03c9 0AE6 56 *JUMP label_0AE7: // Incoming call from 0x096B, returns to 0x04CD // Inputs[4] // { // @0AEA stack[-1] // @0AEF stack[-2] // @0AF7 memory[0x00:0x40] // @0AF8 storage[keccak256(memory[0x00:0x40])] // } 0AE7 5B JUMPDEST 0AE8 60 PUSH1 0x00 0AEA 81 DUP2 0AEB 81 DUP2 0AEC 52 MSTORE 0AED 60 PUSH1 0x01 0AEF 83 DUP4 0AF0 01 ADD 0AF1 60 PUSH1 0x20 0AF3 52 MSTORE 0AF4 60 PUSH1 0x40 0AF6 81 DUP2 0AF7 20 SHA3 0AF8 54 SLOAD 0AF9 80 DUP1 0AFA 15 ISZERO 0AFB 61 PUSH2 0x0ba3 0AFE 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0AE8 stack[0] = 0x00 // @0AEC memory[0x00:0x20] = stack[-1] // @0AF3 memory[0x20:0x40] = stack[-2] + 0x01 // @0AF8 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0ba3, if !storage[keccak256(memory[0x00:0x40])] label_0AFF: // Incoming jump from 0x0AFE, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0AFF stack[-4] // @0B00 storage[stack[-4]] // @0B05 stack[-1] // } 0AFF 83 DUP4 0B00 54 SLOAD 0B01 60 PUSH1 0x00 0B03 19 NOT 0B04 80 DUP1 0B05 83 DUP4 0B06 01 ADD 0B07 91 SWAP2 0B08 90 SWAP1 0B09 81 DUP2 0B0A 01 ADD 0B0B 90 SWAP1 0B0C 60 PUSH1 0x00 0B0E 90 SWAP1 0B0F 87 DUP8 0B10 90 SWAP1 0B11 83 DUP4 0B12 90 SWAP1 0B13 81 DUP2 0B14 10 LT 0B15 61 PUSH2 0x0b1a 0B18 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0B07 stack[0] = stack[-1] + ~0x00 // @0B0B stack[1] = storage[stack[-4]] + ~0x00 // @0B0E stack[2] = 0x00 // @0B10 stack[3] = stack[-4] // @0B12 stack[4] = storage[stack[-4]] + ~0x00 // } // Block ends with conditional jump to 0x0b1a, if storage[stack[-4]] + ~0x00 < storage[stack[-4]] label_0B19: // Incoming jump from 0x0B18, if not storage[stack[-4]] + ~0x00 < storage[stack[-4]] 0B19 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B19 assert(); } // Block terminates label_0B1A: // Incoming jump from 0x0B18, if storage[stack[-4]] + ~0x00 < storage[stack[-4]] // Inputs[8] // { // @0B1B stack[-2] // @0B1B stack[-1] // @0B23 memory[0x00:0x20] // @0B25 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0B26 stack[-3] // @0B29 stack[-9] // @0B2D stack[-5] // @0B2F storage[0x00 + stack[-9]] // } 0B1A 5B JUMPDEST 0B1B 90 SWAP1 0B1C 60 PUSH1 0x00 0B1E 52 MSTORE 0B1F 60 PUSH1 0x20 0B21 60 PUSH1 0x00 0B23 20 SHA3 0B24 01 ADD 0B25 54 SLOAD 0B26 90 SWAP1 0B27 50 POP 0B28 80 DUP1 0B29 87 DUP8 0B2A 60 PUSH1 0x00 0B2C 01 ADD 0B2D 84 DUP5 0B2E 81 DUP2 0B2F 54 SLOAD 0B30 81 DUP2 0B31 10 LT 0B32 61 PUSH2 0x0b37 0B35 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0B1E memory[0x00:0x20] = stack[-2] // @0B26 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0B28 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0B2C stack[-1] = 0x00 + stack[-9] // @0B2D stack[0] = stack[-5] // } // Block ends with conditional jump to 0x0b37, if stack[-5] < storage[0x00 + stack[-9]] label_0B36: // Incoming jump from 0x0B35, if not stack[-5] < storage[0x00 + stack[-9]] 0B36 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B36 assert(); } // Block terminates label_0B37: // Incoming jump from 0x0B35, if stack[-5] < storage[0x00 + stack[-9]] // Inputs[9] // { // @0B3A stack[-2] // @0B41 memory[0x00:0x20] // @0B43 stack[-1] // @0B45 stack[-3] // @0B49 stack[-4] // @0B4E stack[-10] // @0B57 memory[0x00:0x40] // @0B59 stack[-6] // @0B5E storage[stack[-10]] // } 0B37 5B JUMPDEST 0B38 60 PUSH1 0x00 0B3A 91 SWAP2 0B3B 82 DUP3 0B3C 52 MSTORE 0B3D 60 PUSH1 0x20 0B3F 80 DUP1 0B40 83 DUP4 0B41 20 SHA3 0B42 90 SWAP1 0B43 91 SWAP2 0B44 01 ADD 0B45 92 SWAP3 0B46 90 SWAP1 0B47 92 SWAP3 0B48 55 SSTORE 0B49 82 DUP3 0B4A 81 DUP2 0B4B 52 MSTORE 0B4C 60 PUSH1 0x01 0B4E 89 DUP10 0B4F 81 DUP2 0B50 01 ADD 0B51 90 SWAP1 0B52 92 SWAP3 0B53 52 MSTORE 0B54 60 PUSH1 0x40 0B56 90 SWAP1 0B57 20 SHA3 0B58 90 SWAP1 0B59 84 DUP5 0B5A 01 ADD 0B5B 90 SWAP1 0B5C 55 SSTORE 0B5D 86 DUP7 0B5E 54 SLOAD 0B5F 87 DUP8 0B60 90 SWAP1 0B61 80 DUP1 0B62 61 PUSH2 0x0b67 0B65 57 *JUMPI // Stack delta = -1 // Outputs[7] // { // @0B3C memory[0x00:0x20] = stack[-2] // @0B48 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @0B4B memory[0x00:0x20] = stack[-4] // @0B53 memory[0x20:0x40] = 0x01 + stack[-10] // @0B5C storage[keccak256(memory[0x00:0x40])] = stack[-6] + 0x01 // @0B60 stack[-2] = storage[stack[-10]] // @0B60 stack[-3] = stack[-10] // } // Block ends with conditional jump to 0x0b67, if storage[stack[-10]] label_0B66: // Incoming jump from 0x0B65, if not storage[stack[-10]] 0B66 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B66 assert(); } // Block terminates label_0B67: // Incoming jump from 0x0B65, if storage[stack[-10]] // Inputs[7] // { // @0B6A stack[-1] // @0B6C stack[-2] // @0B76 memory[0x00:0x20] // @0B7E stack[-9] // @0B84 stack[-8] // @0B92 memory[0x00:0x40] // @0B99 stack[-7] // } 0B67 5B JUMPDEST 0B68 60 PUSH1 0x01 0B6A 90 SWAP1 0B6B 03 SUB 0B6C 81 DUP2 0B6D 81 DUP2 0B6E 90 SWAP1 0B6F 60 PUSH1 0x00 0B71 52 MSTORE 0B72 60 PUSH1 0x20 0B74 60 PUSH1 0x00 0B76 20 SHA3 0B77 01 ADD 0B78 60 PUSH1 0x00 0B7A 90 SWAP1 0B7B 55 SSTORE 0B7C 90 SWAP1 0B7D 55 SSTORE 0B7E 86 DUP7 0B7F 60 PUSH1 0x01 0B81 01 ADD 0B82 60 PUSH1 0x00 0B84 87 DUP8 0B85 81 DUP2 0B86 52 MSTORE 0B87 60 PUSH1 0x20 0B89 01 ADD 0B8A 90 SWAP1 0B8B 81 DUP2 0B8C 52 MSTORE 0B8D 60 PUSH1 0x20 0B8F 01 ADD 0B90 60 PUSH1 0x00 0B92 20 SHA3 0B93 60 PUSH1 0x00 0B95 90 SWAP1 0B96 55 SSTORE 0B97 60 PUSH1 0x01 0B99 94 SWAP5 0B9A 50 POP 0B9B 50 POP 0B9C 50 POP 0B9D 50 POP 0B9E 50 POP 0B9F 61 PUSH2 0x03c9 0BA2 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @0B71 memory[0x00:0x20] = stack[-2] // @0B7B storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @0B7D storage[stack[-2]] = stack[-1] - 0x01 // @0B86 memory[0x00:0x20] = stack[-8] // @0B8C memory[0x20:0x40] = 0x01 + stack[-9] // @0B96 storage[keccak256(memory[0x00:0x40])] = 0x00 // @0B99 stack[-7] = 0x01 // } // Block ends with unconditional jump to 0x03c9 label_0BA3: // Incoming jump from 0x0AFE, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0BA6 stack[-2] } 0BA3 5B JUMPDEST 0BA4 60 PUSH1 0x00 0BA6 91 SWAP2 0BA7 50 POP 0BA8 50 POP 0BA9 61 PUSH2 0x03c9 0BAC 56 *JUMP // Stack delta = -1 // Outputs[1] { @0BA6 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x03c9 label_0BAD: // Incoming call from 0x0A84, returns to 0x0A85 // Incoming call from 0x0A7C, returns to 0x0A7D // Incoming call from 0x0A7C, returns to 0x0A7D // Inputs[1] { @0BB0 storage[0x00] } 0BAD 5B JUMPDEST 0BAE 60 PUSH1 0x00 0BB0 54 SLOAD 0BB1 61 PUSH2 0x0100 0BB4 90 SWAP1 0BB5 04 DIV 0BB6 60 PUSH1 0xff 0BB8 16 AND 0BB9 80 DUP1 0BBA 61 PUSH2 0x0bc6 0BBD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BB8 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x0bc6, if 0xff & storage[0x00] / 0x0100 label_0BBE: // Incoming jump from 0x0BBD, if not 0xff & storage[0x00] / 0x0100 0BBE 50 POP 0BBF 61 PUSH2 0x0bc6 0BC2 61 PUSH2 0x0891 0BC5 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BBF stack[-1] = 0x0bc6 } // Block ends with call to 0x0891, returns to 0x0BC6 label_0BC6: // Incoming jump from 0x0BBD, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x0891 at 0x0BC5 // Inputs[1] { @0BC7 stack[-1] } 0BC6 5B JUMPDEST 0BC7 80 DUP1 0BC8 61 PUSH2 0x0bd4 0BCB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bd4, if stack[-1] label_0BCC: // Incoming jump from 0x0BCB, if not stack[-1] // Inputs[1] { @0BCF storage[0x00] } 0BCC 50 POP 0BCD 60 PUSH1 0x00 0BCF 54 SLOAD 0BD0 60 PUSH1 0xff 0BD2 16 AND 0BD3 15 ISZERO 0BD4 5B JUMPDEST 0BD5 61 PUSH2 0x0c0f 0BD8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c0f, if !(0xff & storage[0x00]) label_0BD9: // Incoming jump from 0x0BD8, if not !(0xff & storage[0x00]) // Incoming jump from 0x0BD8, if not stack[-1] // Inputs[3] // { // @0BDB memory[0x40:0x60] // @0C09 memory[0x40:0x60] // @0C0E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BD9 60 PUSH1 0x40 0BDB 51 MLOAD 0BDC 62 PUSH3 0x461bcd 0BE0 60 PUSH1 0xe5 0BE2 1B SHL 0BE3 81 DUP2 0BE4 52 MSTORE 0BE5 60 PUSH1 0x04 0BE7 01 ADD 0BE8 80 DUP1 0BE9 80 DUP1 0BEA 60 PUSH1 0x20 0BEC 01 ADD 0BED 82 DUP3 0BEE 81 DUP2 0BEF 03 SUB 0BF0 82 DUP3 0BF1 52 MSTORE 0BF2 60 PUSH1 0x2e 0BF4 81 DUP2 0BF5 52 MSTORE 0BF6 60 PUSH1 0x20 0BF8 01 ADD 0BF9 80 DUP1 0BFA 61 PUSH2 0x0d09 0BFD 60 PUSH1 0x2e 0BFF 91 SWAP2 0C00 39 CODECOPY 0C01 60 PUSH1 0x40 0C03 01 ADD 0C04 91 SWAP2 0C05 50 POP 0C06 50 POP 0C07 60 PUSH1 0x40 0C09 51 MLOAD 0C0A 80 DUP1 0C0B 91 SWAP2 0C0C 03 SUB 0C0D 90 SWAP1 0C0E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BF1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0BF5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @0C00 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x0d09:0x0d37] // @0C0E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C0F: // Incoming jump from 0x0BD8, if !(0xff & storage[0x00]) // Incoming jump from 0x0BD8, if stack[-1] // Inputs[1] { @0C12 storage[0x00] } 0C0F 5B JUMPDEST 0C10 60 PUSH1 0x00 0C12 54 SLOAD 0C13 61 PUSH2 0x0100 0C16 90 SWAP1 0C17 04 DIV 0C18 60 PUSH1 0xff 0C1A 16 AND 0C1B 15 ISZERO 0C1C 80 DUP1 0C1D 15 ISZERO 0C1E 61 PUSH2 0x0a85 0C21 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C1B stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0a85, if !!(0xff & storage[0x00] / 0x0100) label_0C22: // Incoming jump from 0x0C21, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[2] // { // @0C25 storage[0x00] // @0C3A stack[-1] // } 0C22 60 PUSH1 0x00 0C24 80 DUP1 0C25 54 SLOAD 0C26 60 PUSH1 0xff 0C28 19 NOT 0C29 61 PUSH2 0xff00 0C2C 19 NOT 0C2D 90 SWAP1 0C2E 91 SWAP2 0C2F 16 AND 0C30 61 PUSH2 0x0100 0C33 17 OR 0C34 16 AND 0C35 60 PUSH1 0x01 0C37 17 OR 0C38 90 SWAP1 0C39 55 SSTORE 0C3A 80 DUP1 0C3B 15 ISZERO 0C3C 61 PUSH2 0x03da 0C3F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0C39 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) } // Block ends with conditional jump to 0x03da, if !stack[-1] label_0C40: // Incoming jump from 0x0C3F, if not !stack[-1] // Inputs[2] // { // @0C43 storage[0x00] // @0C4C stack[-2] // } 0C40 60 PUSH1 0x00 0C42 80 DUP1 0C43 54 SLOAD 0C44 61 PUSH2 0xff00 0C47 19 NOT 0C48 16 AND 0C49 90 SWAP1 0C4A 55 SSTORE 0C4B 50 POP 0C4C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C4A storage[0x00] = ~0xff00 & storage[0x00] } // Block ends with unconditional jump to stack[-2] 0C4D FE *ASSERT 0C4E 45 GASLIMIT 0C4F 6E PUSH15 0x756d657261626c655365743a20696e 0C5F 64 PUSH5 0x6578206f75 0C65 74 PUSH21 0x206f6620626f756e6473416363657373436f6e7472 0C7B 6F PUSH16 0x6c3a2073656e646572206d7573742062 0C8C 65 PUSH6 0x20616e206164 0C93 6D PUSH14 0x696e20746f206772616e74416464 0CA2 72 PUSH19 0x6573733a20756e61626c6520746f2073656e64 0CB6 20 SHA3 0CB7 76 PUSH23 0x616c75652c20726563697069656e74206d617920686176 0CCF 65 PUSH6 0x207265766572 0CD6 74 PUSH21 0x6564416363657373436f6e74726f6c3a2073656e64 0CEC 65 PUSH6 0x72206d757374 0CF3 20 SHA3 0CF4 62 PUSH3 0x652061 0CF8 6E PUSH15 0x2061646d696e20746f207265766f6b 0D08 65 PUSH6 0x496e69746961 0D0F 6C PUSH13 0x697a61626c653a20636f6e7472 0D1D 61 PUSH2 0x6374 0D20 20 SHA3 0D21 69 PUSH10 0x7320616c726561647920 0D2C 69 PUSH10 0x6e697469616c697a6564 0D37 41 COINBASE 0D38 64 PUSH5 0x6d696e526f 0D3E 6C PUSH13 0x653a2063616c6c657220646f65 0D4C 73 PUSH20 0x206e6f742068617665207468652041646d696e20 0D61 72 PUSH19 0x6f6c65416363657373436f6e74726f6c3a2063 0D75 61 PUSH2 0x6e20 0D78 6F PUSH16 0x6e6c792072656e6f756e636520726f6c 0D89 65 PUSH6 0x7320666f7220 0D90 73 PUSH20 0x656c66a2646970667358221220ffc06316b126d3 0DA5 EB EB 0DA6 96 SWAP7 0DA7 29 29 0DA8 79 PUSH26 0x87595a6355edcb153ab86bec26c6c952af9b95f48364736f6c63 0DC3 43 NUMBER 0DC4 00 *STOP 0DC5 07 SMOD 0DC6 06 MOD 0DC7 00 *STOP 0DC8 33 CALLER