Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0088 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0088, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x70a08231 0026 11 GT 0027 61 PUSH2 0x005b 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x005b, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x70a08231 0031 14 EQ 0032 61 PUSH2 0x0127 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0127, if 0x70a08231 == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x70a08231 == stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x8da5cb5b 003C 14 EQ 003D 61 PUSH2 0x0157 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0157, if 0x8da5cb5b == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x95d89b41 0047 14 EQ 0048 61 PUSH2 0x0175 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x95d89b41 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x95d89b41 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xc87b56dd 0052 14 EQ 0053 61 PUSH2 0x0193 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0193, if 0xc87b56dd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xc87b56dd == stack[-1] 0057 61 PUSH2 0x0088 005A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0088 label_005B: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @005C stack[-1] } 005B 5B JUMPDEST 005C 80 DUP1 005D 63 PUSH4 0x01ffc9a7 0062 14 EQ 0063 61 PUSH2 0x008d 0066 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008d, if 0x01ffc9a7 == stack[-1] label_0067: // Incoming jump from 0x0066, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0067 stack[-1] } 0067 80 DUP1 0068 63 PUSH4 0x06fdde03 006D 14 EQ 006E 61 PUSH2 0x00bd 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bd, if 0x06fdde03 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x5a86c41a 0078 14 EQ 0079 61 PUSH2 0x00db 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00db, if 0x5a86c41a == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x5a86c41a == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x6352211e 0083 14 EQ 0084 61 PUSH2 0x00f7 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f7, if 0x6352211e == stack[-1] label_0088: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0087, if not 0x6352211e == stack[-1] // Incoming jump from 0x005A // Inputs[1] { @008C memory[0x00:0x00] } 0088 5B JUMPDEST 0089 60 PUSH1 0x00 008B 80 DUP1 008C FD *REVERT // Stack delta = +0 // Outputs[1] { @008C revert(memory[0x00:0x00]); } // Block terminates label_008D: // Incoming jump from 0x0066, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0094 msg.data.length } 008D 5B JUMPDEST 008E 61 PUSH2 0x00a7 0091 60 PUSH1 0x04 0093 80 DUP1 0094 36 CALLDATASIZE 0095 03 SUB 0096 81 DUP2 0097 01 ADD 0098 90 SWAP1 0099 61 PUSH2 0x00a2 009C 91 SWAP2 009D 90 SWAP1 009E 61 PUSH2 0x08d2 00A1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @008E stack[0] = 0x00a7 // @009C stack[1] = 0x00a2 // @009D stack[2] = 0x04 + (msg.data.length - 0x04) // @009D stack[3] = 0x04 // } // Block ends with call to 0x08d2, returns to 0x00A2 label_00A2: // Incoming return from call to 0x08D2 at 0x00A1 00A2 5B JUMPDEST 00A3 61 PUSH2 0x01c3 00A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01c3 label_00A7: // Incoming return from call to 0x00A2 at 0x00A1 // Inputs[2] // { // @00AA memory[0x40:0x60] // @00AE stack[-1] // } 00A7 5B JUMPDEST 00A8 60 PUSH1 0x40 00AA 51 MLOAD 00AB 61 PUSH2 0x00b4 00AE 91 SWAP2 00AF 90 SWAP1 00B0 61 PUSH2 0x09d0 00B3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00AE stack[-1] = 0x00b4 // @00AF stack[1] = memory[0x40:0x60] // @00AF stack[0] = stack[-1] // } // Block ends with call to 0x09d0, returns to 0x00B4 label_00B4: // Incoming return from call to 0x09D0 at 0x00B3 // Inputs[3] // { // @00B7 memory[0x40:0x60] // @00B9 stack[-1] // @00BC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00B4 5B JUMPDEST 00B5 60 PUSH1 0x40 00B7 51 MLOAD 00B8 80 DUP1 00B9 91 SWAP2 00BA 03 SUB 00BB 90 SWAP1 00BC F3 *RETURN // Stack delta = -1 // Outputs[1] { @00BC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00BD: // Incoming jump from 0x0071, if 0x06fdde03 == stack[-1] 00BD 5B JUMPDEST 00BE 61 PUSH2 0x00c5 00C1 61 PUSH2 0x02a5 00C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @00BE stack[0] = 0x00c5 } // Block ends with call to 0x02a5, returns to 0x00C5 label_00C5: // Incoming return from call to 0x02A5 at 0x00C4 // Inputs[2] // { // @00C8 memory[0x40:0x60] // @00CC stack[-1] // } 00C5 5B JUMPDEST 00C6 60 PUSH1 0x40 00C8 51 MLOAD 00C9 61 PUSH2 0x00d2 00CC 91 SWAP2 00CD 90 SWAP1 00CE 61 PUSH2 0x09eb 00D1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00CC stack[-1] = 0x00d2 // @00CD stack[1] = memory[0x40:0x60] // @00CD stack[0] = stack[-1] // } // Block ends with call to 0x09eb, returns to 0x00D2 label_00D2: // Incoming return from call to 0x09EB at 0x00D1 // Inputs[3] // { // @00D5 memory[0x40:0x60] // @00D7 stack[-1] // @00DA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00D2 5B JUMPDEST 00D3 60 PUSH1 0x40 00D5 51 MLOAD 00D6 80 DUP1 00D7 91 SWAP2 00D8 03 SUB 00D9 90 SWAP1 00DA F3 *RETURN // Stack delta = -1 // Outputs[1] { @00DA return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00DB: // Incoming jump from 0x007C, if 0x5a86c41a == stack[-1] // Inputs[1] { @00E2 msg.data.length } 00DB 5B JUMPDEST 00DC 61 PUSH2 0x00f5 00DF 60 PUSH1 0x04 00E1 80 DUP1 00E2 36 CALLDATASIZE 00E3 03 SUB 00E4 81 DUP2 00E5 01 ADD 00E6 90 SWAP1 00E7 61 PUSH2 0x00f0 00EA 91 SWAP2 00EB 90 SWAP1 00EC 61 PUSH2 0x085a 00EF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00DC stack[0] = 0x00f5 // @00EA stack[1] = 0x00f0 // @00EB stack[2] = 0x04 + (msg.data.length - 0x04) // @00EB stack[3] = 0x04 // } // Block ends with call to 0x085a, returns to 0x00F0 label_00F0: // Incoming return from call to 0x085A at 0x00EF 00F0 5B JUMPDEST 00F1 61 PUSH2 0x0337 00F4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0337 label_00F5: // Incoming return from call to 0x00F0 at 0x00EF 00F5 5B JUMPDEST 00F6 00 *STOP // Stack delta = +0 // Outputs[1] { @00F6 stop(); } // Block terminates label_00F7: // Incoming jump from 0x0087, if 0x6352211e == stack[-1] // Inputs[1] { @00FE msg.data.length } 00F7 5B JUMPDEST 00F8 61 PUSH2 0x0111 00FB 60 PUSH1 0x04 00FD 80 DUP1 00FE 36 CALLDATASIZE 00FF 03 SUB 0100 81 DUP2 0101 01 ADD 0102 90 SWAP1 0103 61 PUSH2 0x010c 0106 91 SWAP2 0107 90 SWAP1 0108 61 PUSH2 0x08ff 010B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00F8 stack[0] = 0x0111 // @0106 stack[1] = 0x010c // @0107 stack[2] = 0x04 + (msg.data.length - 0x04) // @0107 stack[3] = 0x04 // } // Block ends with call to 0x08ff, returns to 0x010C label_010C: // Incoming return from call to 0x08FF at 0x010B 010C 5B JUMPDEST 010D 61 PUSH2 0x040c 0110 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x040c label_0111: // Incoming return from call to 0x010C at 0x010B // Inputs[2] // { // @0114 memory[0x40:0x60] // @0118 stack[-1] // } 0111 5B JUMPDEST 0112 60 PUSH1 0x40 0114 51 MLOAD 0115 61 PUSH2 0x011e 0118 91 SWAP2 0119 90 SWAP1 011A 61 PUSH2 0x09b5 011D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0118 stack[-1] = 0x011e // @0119 stack[1] = memory[0x40:0x60] // @0119 stack[0] = stack[-1] // } // Block ends with call to 0x09b5, returns to 0x011E label_011E: // Incoming return from call to 0x09B5 at 0x011D // Inputs[3] // { // @0121 memory[0x40:0x60] // @0123 stack[-1] // @0126 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 011E 5B JUMPDEST 011F 60 PUSH1 0x40 0121 51 MLOAD 0122 80 DUP1 0123 91 SWAP2 0124 03 SUB 0125 90 SWAP1 0126 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0126 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0127: // Incoming jump from 0x0035, if 0x70a08231 == stack[-1] // Inputs[1] { @012E msg.data.length } 0127 5B JUMPDEST 0128 61 PUSH2 0x0141 012B 60 PUSH1 0x04 012D 80 DUP1 012E 36 CALLDATASIZE 012F 03 SUB 0130 81 DUP2 0131 01 ADD 0132 90 SWAP1 0133 61 PUSH2 0x013c 0136 91 SWAP2 0137 90 SWAP1 0138 61 PUSH2 0x0800 013B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0128 stack[0] = 0x0141 // @0136 stack[1] = 0x013c // @0137 stack[2] = 0x04 + (msg.data.length - 0x04) // @0137 stack[3] = 0x04 // } // Block ends with call to 0x0800, returns to 0x013C label_013C: // Incoming return from call to 0x0800 at 0x013B 013C 5B JUMPDEST 013D 61 PUSH2 0x04b2 0140 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04b2 label_0141: // Incoming return from call to 0x013C at 0x013B // Inputs[2] // { // @0144 memory[0x40:0x60] // @0148 stack[-1] // } 0141 5B JUMPDEST 0142 60 PUSH1 0x40 0144 51 MLOAD 0145 61 PUSH2 0x014e 0148 91 SWAP2 0149 90 SWAP1 014A 61 PUSH2 0x0a2d 014D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0148 stack[-1] = 0x014e // @0149 stack[1] = memory[0x40:0x60] // @0149 stack[0] = stack[-1] // } // Block ends with call to 0x0a2d, returns to 0x014E label_014E: // Incoming return from call to 0x0A2D at 0x014D // Inputs[3] // { // @0151 memory[0x40:0x60] // @0153 stack[-1] // @0156 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 014E 5B JUMPDEST 014F 60 PUSH1 0x40 0151 51 MLOAD 0152 80 DUP1 0153 91 SWAP2 0154 03 SUB 0155 90 SWAP1 0156 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0156 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0157: // Incoming jump from 0x0040, if 0x8da5cb5b == stack[-1] 0157 5B JUMPDEST 0158 61 PUSH2 0x015f 015B 61 PUSH2 0x052c 015E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0158 stack[0] = 0x015f } // Block ends with call to 0x052c, returns to 0x015F label_015F: // Incoming return from call to 0x052C at 0x015E // Inputs[2] // { // @0162 memory[0x40:0x60] // @0166 stack[-1] // } 015F 5B JUMPDEST 0160 60 PUSH1 0x40 0162 51 MLOAD 0163 61 PUSH2 0x016c 0166 91 SWAP2 0167 90 SWAP1 0168 61 PUSH2 0x09b5 016B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0166 stack[-1] = 0x016c // @0167 stack[1] = memory[0x40:0x60] // @0167 stack[0] = stack[-1] // } // Block ends with call to 0x09b5, returns to 0x016C label_016C: // Incoming return from call to 0x09B5 at 0x016B // Inputs[3] // { // @016F memory[0x40:0x60] // @0171 stack[-1] // @0174 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 016C 5B JUMPDEST 016D 60 PUSH1 0x40 016F 51 MLOAD 0170 80 DUP1 0171 91 SWAP2 0172 03 SUB 0173 90 SWAP1 0174 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0174 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0175: // Incoming jump from 0x004B, if 0x95d89b41 == stack[-1] 0175 5B JUMPDEST 0176 61 PUSH2 0x017d 0179 61 PUSH2 0x0552 017C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0176 stack[0] = 0x017d } // Block ends with call to 0x0552, returns to 0x017D label_017D: // Incoming return from call to 0x0552 at 0x017C // Inputs[2] // { // @0180 memory[0x40:0x60] // @0184 stack[-1] // } 017D 5B JUMPDEST 017E 60 PUSH1 0x40 0180 51 MLOAD 0181 61 PUSH2 0x018a 0184 91 SWAP2 0185 90 SWAP1 0186 61 PUSH2 0x09eb 0189 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0184 stack[-1] = 0x018a // @0185 stack[1] = memory[0x40:0x60] // @0185 stack[0] = stack[-1] // } // Block ends with call to 0x09eb, returns to 0x018A label_018A: // Incoming return from call to 0x09EB at 0x0189 // Inputs[3] // { // @018D memory[0x40:0x60] // @018F stack[-1] // @0192 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 018A 5B JUMPDEST 018B 60 PUSH1 0x40 018D 51 MLOAD 018E 80 DUP1 018F 91 SWAP2 0190 03 SUB 0191 90 SWAP1 0192 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0192 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0193: // Incoming jump from 0x0056, if 0xc87b56dd == stack[-1] // Inputs[1] { @019A msg.data.length } 0193 5B JUMPDEST 0194 61 PUSH2 0x01ad 0197 60 PUSH1 0x04 0199 80 DUP1 019A 36 CALLDATASIZE 019B 03 SUB 019C 81 DUP2 019D 01 ADD 019E 90 SWAP1 019F 61 PUSH2 0x01a8 01A2 91 SWAP2 01A3 90 SWAP1 01A4 61 PUSH2 0x08ff 01A7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0194 stack[0] = 0x01ad // @01A2 stack[1] = 0x01a8 // @01A3 stack[2] = 0x04 + (msg.data.length - 0x04) // @01A3 stack[3] = 0x04 // } // Block ends with call to 0x08ff, returns to 0x01A8 label_01A8: // Incoming return from call to 0x08FF at 0x01A7 01A8 5B JUMPDEST 01A9 61 PUSH2 0x05e4 01AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e4 label_01AD: // Incoming return from call to 0x01A8 at 0x01A7 // Inputs[2] // { // @01B0 memory[0x40:0x60] // @01B4 stack[-1] // } 01AD 5B JUMPDEST 01AE 60 PUSH1 0x40 01B0 51 MLOAD 01B1 61 PUSH2 0x01ba 01B4 91 SWAP2 01B5 90 SWAP1 01B6 61 PUSH2 0x09eb 01B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01B4 stack[-1] = 0x01ba // @01B5 stack[1] = memory[0x40:0x60] // @01B5 stack[0] = stack[-1] // } // Block ends with call to 0x09eb, returns to 0x01BA label_01BA: // Incoming return from call to 0x09EB at 0x01B9 // Inputs[3] // { // @01BD memory[0x40:0x60] // @01BF stack[-1] // @01C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01BA 5B JUMPDEST 01BB 60 PUSH1 0x40 01BD 51 MLOAD 01BE 80 DUP1 01BF 91 SWAP2 01C0 03 SUB 01C1 90 SWAP1 01C2 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01C2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01C3: // Incoming jump from 0x00A6 // Inputs[1] { @0206 stack[-1] } 01C3 5B JUMPDEST 01C4 60 PUSH1 0x00 01C6 7F PUSH32 0x13f2a32f00000000000000000000000000000000000000000000000000000000 01E7 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0204 19 NOT 0205 16 AND 0206 82 DUP3 0207 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0224 19 NOT 0225 16 AND 0226 14 EQ 0227 80 DUP1 0228 61 PUSH2 0x028e 022B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @01C4 stack[0] = 0x00 // @0226 stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x13f2a32f00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x028e, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x13f2a32f00000000000000000000000000000000000000000000000000000000 label_022C: // Incoming jump from 0x022B, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x13f2a32f00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @026D stack[-3] } 022C 50 POP 022D 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 024E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 026B 19 NOT 026C 16 AND 026D 82 DUP3 026E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 028B 19 NOT 028C 16 AND 028D 14 EQ 028E 5B JUMPDEST 028F 80 DUP1 0290 61 PUSH2 0x029e 0293 57 *JUMPI // Stack delta = +0 // Outputs[1] { @028D stack[-1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x029e, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 label_0294: // Incoming jump from 0x0293, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0293, if not stack[-1] // Inputs[1] { @0298 stack[-3] } 0294 50 POP 0295 61 PUSH2 0x029d 0298 82 DUP3 0299 61 PUSH2 0x0606 029C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0295 stack[-1] = 0x029d // @0298 stack[0] = stack[-3] // } // Block ends with call to 0x0606, returns to 0x029D label_029D: // Incoming return from call to 0x0606 at 0x029C 029D 5B JUMPDEST // Stack delta = +0 // Block continues label_029E: // Incoming jump from 0x0293, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0293, if stack[-1] // Incoming jump from 0x029D // Inputs[4] // { // @029F stack[-1] // @029F stack[-2] // @02A1 stack[-4] // @02A2 stack[-3] // } 029E 5B JUMPDEST 029F 90 SWAP1 02A0 50 POP 02A1 91 SWAP2 02A2 90 SWAP1 02A3 50 POP 02A4 56 *JUMP // Stack delta = -3 // Outputs[1] { @02A1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_02A5: // Incoming call from 0x00C4, returns to 0x00C5 // Inputs[1] { @02AB storage[0x01] } 02A5 5B JUMPDEST 02A6 60 PUSH1 0x60 02A8 60 PUSH1 0x01 02AA 80 DUP1 02AB 54 SLOAD 02AC 61 PUSH2 0x02b4 02AF 90 SWAP1 02B0 61 PUSH2 0x0b88 02B3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A6 stack[0] = 0x60 // @02A8 stack[1] = 0x01 // @02AF stack[2] = 0x02b4 // @02AF stack[3] = storage[0x01] // } // Block ends with call to 0x0b88, returns to 0x02B4 label_02B4: // Incoming return from call to 0x0B88 at 0x02B3 // Inputs[4] // { // @02B5 stack[-1] // @02C4 memory[0x40:0x60] // @02CC stack[-2] // @02D7 storage[stack[-2]] // } 02B4 5B JUMPDEST 02B5 80 DUP1 02B6 60 PUSH1 0x1f 02B8 01 ADD 02B9 60 PUSH1 0x20 02BB 80 DUP1 02BC 91 SWAP2 02BD 04 DIV 02BE 02 MUL 02BF 60 PUSH1 0x20 02C1 01 ADD 02C2 60 PUSH1 0x40 02C4 51 MLOAD 02C5 90 SWAP1 02C6 81 DUP2 02C7 01 ADD 02C8 60 PUSH1 0x40 02CA 52 MSTORE 02CB 80 DUP1 02CC 92 SWAP3 02CD 91 SWAP2 02CE 90 SWAP1 02CF 81 DUP2 02D0 81 DUP2 02D1 52 MSTORE 02D2 60 PUSH1 0x20 02D4 01 ADD 02D5 82 DUP3 02D6 80 DUP1 02D7 54 SLOAD 02D8 61 PUSH2 0x02e0 02DB 90 SWAP1 02DC 61 PUSH2 0x0b88 02DF 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @02CA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @02CC stack[-2] = memory[0x40:0x60] // @02CD stack[-1] = stack[-2] // @02CE stack[0] = stack[-1] // @02D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02D4 stack[1] = 0x20 + memory[0x40:0x60] // @02D5 stack[2] = stack[-2] // @02DB stack[4] = storage[stack[-2]] // @02DB stack[3] = 0x02e0 // } // Block ends with call to 0x0b88, returns to 0x02E0 label_02E0: // Incoming return from call to 0x0B88 at 0x02DF // Inputs[1] { @02E1 stack[-1] } 02E0 5B JUMPDEST 02E1 80 DUP1 02E2 15 ISZERO 02E3 61 PUSH2 0x032d 02E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032d, if !stack[-1] label_02E7: // Incoming jump from 0x02E6, if not !stack[-1] // Inputs[1] { @02E7 stack[-1] } 02E7 80 DUP1 02E8 60 PUSH1 0x1f 02EA 10 LT 02EB 61 PUSH2 0x0302 02EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0302, if 0x1f < stack[-1] label_02EF: // Incoming jump from 0x02EE, if not 0x1f < stack[-1] // Inputs[4] // { // @02F3 stack[-2] // @02F4 storage[stack[-2]] // @02F7 stack[-3] // @02F9 stack[-1] // } 02EF 61 PUSH2 0x0100 02F2 80 DUP1 02F3 83 DUP4 02F4 54 SLOAD 02F5 04 DIV 02F6 02 MUL 02F7 83 DUP4 02F8 52 MSTORE 02F9 91 SWAP2 02FA 60 PUSH1 0x20 02FC 01 ADD 02FD 91 SWAP2 02FE 61 PUSH2 0x032d 0301 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @02F8 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @02FD stack[-1] = stack[-1] // @02FD stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x032d label_0302: // Incoming jump from 0x02EE, if 0x1f < stack[-1] // Inputs[5] // { // @0303 stack[-3] // @0304 stack[-1] // @0306 stack[-2] // @030E memory[0x00:0x20] // @0312 storage[keccak256(memory[0x00:0x20])] // } 0302 5B JUMPDEST 0303 82 DUP3 0304 01 ADD 0305 91 SWAP2 0306 90 SWAP1 0307 60 PUSH1 0x00 0309 52 MSTORE 030A 60 PUSH1 0x20 030C 60 PUSH1 0x00 030E 20 SHA3 030F 90 SWAP1 0310 5B JUMPDEST 0311 81 DUP2 0312 54 SLOAD 0313 81 DUP2 0314 52 MSTORE 0315 90 SWAP1 0316 60 PUSH1 0x01 0318 01 ADD 0319 90 SWAP1 031A 60 PUSH1 0x20 031C 01 ADD 031D 80 DUP1 031E 83 DUP4 031F 11 GT 0320 61 PUSH2 0x0310 0323 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0305 stack[-3] = stack[-3] + stack[-1] // @0309 memory[0x00:0x20] = stack[-2] // @0314 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0319 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @031C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0310, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0324: // Incoming jump from 0x0323, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0323, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0324 stack[-3] // @0325 stack[-1] // } 0324 82 DUP3 0325 90 SWAP1 0326 03 SUB 0327 60 PUSH1 0x1f 0329 16 AND 032A 82 DUP3 032B 01 ADD 032C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @032C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @032C stack[-1] = stack[-3] // } // Block continues label_032D: // Incoming jump from 0x032C // Incoming jump from 0x02E6, if !stack[-1] // Incoming jump from 0x0301 // Inputs[3] // { // @0333 stack[-6] // @0333 stack[-7] // @0335 stack[-8] // } 032D 5B JUMPDEST 032E 50 POP 032F 50 POP 0330 50 POP 0331 50 POP 0332 50 POP 0333 90 SWAP1 0334 50 POP 0335 90 SWAP1 0336 56 *JUMP // Stack delta = -7 // Outputs[1] { @0335 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0337: // Incoming jump from 0x00F4 // Inputs[2] // { // @033B stack[-1] // @033C memory[stack[-1]:stack[-1] + 0x20] // } 0337 5B JUMPDEST 0338 60 PUSH1 0x00 033A 5B JUMPDEST 033B 81 DUP2 033C 51 MLOAD 033D 81 DUP2 033E 10 LT 033F 15 ISZERO 0340 61 PUSH2 0x0407 0343 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0338 stack[0] = 0x00 } // Block ends with conditional jump to 0x0407, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0344: // Incoming jump from 0x0343, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0343, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0344 stack[-3] // @0345 stack[-1] // @0347 memory[stack[-3]:stack[-3] + 0x20] // } 0344 82 DUP3 0345 81 DUP2 0346 81 DUP2 0347 51 MLOAD 0348 81 DUP2 0349 10 LT 034A 61 PUSH2 0x0356 034D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0344 stack[0] = stack[-3] // @0345 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0356, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_034E: // Incoming jump from 0x034D, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 034E 61 PUSH2 0x0355 0351 61 PUSH2 0x0c92 0354 56 *JUMP // Stack delta = +1 // Outputs[1] { @034E stack[0] = 0x0355 } // Block ends with unconditional jump to 0x0c92 0355 5B JUMPDEST label_0356: // Incoming jump from 0x034D, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @0359 stack[-1] // @035D stack[-2] // @035E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @035F stack[-4] // @0360 stack[-3] // @0362 memory[stack[-4]:stack[-4] + 0x20] // } 0356 5B JUMPDEST 0357 60 PUSH1 0x20 0359 02 MUL 035A 60 PUSH1 0x20 035C 01 ADD 035D 01 ADD 035E 51 MLOAD 035F 82 DUP3 0360 82 DUP3 0361 81 DUP2 0362 51 MLOAD 0363 81 DUP2 0364 10 LT 0365 61 PUSH2 0x0371 0368 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @035E stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @035F stack[-1] = stack[-4] // @0360 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0371, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_0369: // Incoming jump from 0x0368, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 0369 61 PUSH2 0x0370 036C 61 PUSH2 0x0c92 036F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0369 stack[0] = 0x0370 } // Block ends with unconditional jump to 0x0c92 0370 5B JUMPDEST label_0371: // Incoming jump from 0x0368, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[9] // { // @0374 stack[-1] // @0378 stack[-2] // @0379 memory[stack[-1] * 0x20 + 0x20 + stack[-2]:stack[-1] * 0x20 + 0x20 + stack[-2] + 0x20] // @0395 storage[0x04] // @03EC memory[0x40:0x60] // @03EF memory[0x40:0x60] // @03F4 stack[-3] // @03F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @03F5 stack[-4] // } 0371 5B JUMPDEST 0372 60 PUSH1 0x20 0374 02 MUL 0375 60 PUSH1 0x20 0377 01 ADD 0378 01 ADD 0379 51 MLOAD 037A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 038F 16 AND 0390 60 PUSH1 0x04 0392 60 PUSH1 0x00 0394 90 SWAP1 0395 54 SLOAD 0396 90 SWAP1 0397 61 PUSH2 0x0100 039A 0A EXP 039B 90 SWAP1 039C 04 DIV 039D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03B2 16 AND 03B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03C8 16 AND 03C9 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 03EA 60 PUSH1 0x40 03EC 51 MLOAD 03ED 60 PUSH1 0x40 03EF 51 MLOAD 03F0 80 DUP1 03F1 91 SWAP2 03F2 03 SUB 03F3 90 SWAP1 03F4 A4 LOG4 03F5 80 DUP1 03F6 80 DUP1 03F7 61 PUSH2 0x03ff 03FA 90 SWAP1 03FB 61 PUSH2 0x0beb 03FE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @03F4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, storage[0x04] & 0xffffffffffffffffffffffffffffffffffffffff, memory[stack[-1] * 0x20 + 0x20 + stack[-2]:stack[-1] * 0x20 + 0x20 + stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3]]); // @03F5 stack[-3] = stack[-4] // @03FA stack[-1] = stack[-4] // @03FA stack[-2] = 0x03ff // } // Block ends with call to 0x0beb, returns to 0x03FF label_03FF: // Incoming return from call to 0x0BEB at 0x03FE // Inputs[2] // { // @0400 stack[-1] // @0400 stack[-3] // } 03FF 5B JUMPDEST 0400 91 SWAP2 0401 50 POP 0402 50 POP 0403 61 PUSH2 0x033a 0406 56 *JUMP // Stack delta = -2 // Outputs[1] { @0400 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x033a label_0407: // Incoming jump from 0x0343, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0343, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @040B stack[-4] } 0407 5B JUMPDEST 0408 50 POP 0409 50 POP 040A 50 POP 040B 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_040C: // Incoming jump from 0x0110 // Inputs[2] // { // @043F stack[-1] // @0442 memory[0x40:0x60] // } 040C 5B JUMPDEST 040D 60 PUSH1 0x00 040F 73 PUSH20 0x845a007d9f283614f403a24e3eb3455f720559ca 0424 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0439 16 AND 043A 63 PUSH4 0x6352211e 043F 83 DUP4 0440 60 PUSH1 0x40 0442 51 MLOAD 0443 82 DUP3 0444 63 PUSH4 0xffffffff 0449 16 AND 044A 60 PUSH1 0xe0 044C 1B SHL 044D 81 DUP2 044E 52 MSTORE 044F 60 PUSH1 0x04 0451 01 ADD 0452 61 PUSH2 0x045b 0455 91 SWAP2 0456 90 SWAP1 0457 61 PUSH2 0x0a2d 045A 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @040D stack[0] = 0x00 // @0439 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0x845a007d9f283614f403a24e3eb3455f720559ca // @043A stack[2] = 0x6352211e // @044E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x6352211e) << 0xe0 // @0455 stack[3] = 0x045b // @0456 stack[4] = stack[-1] // @0456 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x0a2d, returns to 0x045B label_045B: // Incoming return from call to 0x0A2D at 0x045A // Inputs[4] // { // @0460 memory[0x40:0x60] // @0462 stack[-1] // @0465 stack[-3] // @0467 address(stack[-3]).code.length // } 045B 5B JUMPDEST 045C 60 PUSH1 0x20 045E 60 PUSH1 0x40 0460 51 MLOAD 0461 80 DUP1 0462 83 DUP4 0463 03 SUB 0464 81 DUP2 0465 86 DUP7 0466 80 DUP1 0467 3B EXTCODESIZE 0468 15 ISZERO 0469 80 DUP1 046A 15 ISZERO 046B 61 PUSH2 0x0473 046E 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @045C stack[0] = 0x20 // @0460 stack[1] = memory[0x40:0x60] // @0463 stack[2] = stack[-1] - memory[0x40:0x60] // @0464 stack[3] = memory[0x40:0x60] // @0465 stack[4] = stack[-3] // @0468 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0473, if !!address(stack[-3]).code.length label_046F: // Incoming jump from 0x046E, if not !!address(stack[-3]).code.length // Inputs[1] { @0472 memory[0x00:0x00] } 046F 60 PUSH1 0x00 0471 80 DUP1 0472 FD *REVERT // Stack delta = +0 // Outputs[1] { @0472 revert(memory[0x00:0x00]); } // Block terminates label_0473: // Incoming jump from 0x046E, if !!address(stack[-3]).code.length // Inputs[8] // { // @0475 msg.gas // @0476 stack[-6] // @0476 stack[-5] // @0476 stack[-2] // @0476 stack[-4] // @0476 stack[-3] // @0476 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0476 memory[stack[-3]:stack[-3] + stack[-4]] // } 0473 5B JUMPDEST 0474 50 POP 0475 5A GAS 0476 FA STATICCALL 0477 15 ISZERO 0478 80 DUP1 0479 15 ISZERO 047A 61 PUSH2 0x0487 047D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0476 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0477 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0487, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_047E: // Incoming jump from 0x047D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @047E returndata.length // @0482 returndata[0x00:0x00 + returndata.length] // @0483 returndata.length // @0486 memory[0x00:0x00 + returndata.length] // } 047E 3D RETURNDATASIZE 047F 60 PUSH1 0x00 0481 80 DUP1 0482 3E RETURNDATACOPY 0483 3D RETURNDATASIZE 0484 60 PUSH1 0x00 0486 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0482 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0486 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0487: // Incoming jump from 0x047D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @048E memory[0x40:0x60] // @048F returndata.length // } 0487 5B JUMPDEST 0488 50 POP 0489 50 POP 048A 50 POP 048B 50 POP 048C 60 PUSH1 0x40 048E 51 MLOAD 048F 3D RETURNDATASIZE 0490 60 PUSH1 0x1f 0492 19 NOT 0493 60 PUSH1 0x1f 0495 82 DUP3 0496 01 ADD 0497 16 AND 0498 82 DUP3 0499 01 ADD 049A 80 DUP1 049B 60 PUSH1 0x40 049D 52 MSTORE 049E 50 POP 049F 81 DUP2 04A0 01 ADD 04A1 90 SWAP1 04A2 61 PUSH2 0x04ab 04A5 91 SWAP2 04A6 90 SWAP1 04A7 61 PUSH2 0x082d 04AA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @049D memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @04A5 stack[-4] = 0x04ab // @04A6 stack[-2] = memory[0x40:0x60] // @04A6 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x082d, returns to 0x04AB label_04AB: // Incoming return from call to 0x082D at 0x04AA // Inputs[4] // { // @04AC stack[-1] // @04AC stack[-2] // @04AE stack[-4] // @04AF stack[-3] // } 04AB 5B JUMPDEST 04AC 90 SWAP1 04AD 50 POP 04AE 91 SWAP2 04AF 90 SWAP1 04B0 50 POP 04B1 56 *JUMP // Stack delta = -3 // Outputs[1] { @04AE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_04B2: // Incoming jump from 0x0140 // Inputs[1] { @04CC stack[-1] } 04B2 5B JUMPDEST 04B3 60 PUSH1 0x00 04B5 80 DUP1 04B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04CB 16 AND 04CC 82 DUP3 04CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04E2 16 AND 04E3 14 EQ 04E4 15 ISZERO 04E5 61 PUSH2 0x0523 04E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B3 stack[0] = 0x00 } // Block ends with conditional jump to 0x0523, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_04E9: // Incoming jump from 0x04E8, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @04EB memory[0x40:0x60] } 04E9 60 PUSH1 0x40 04EB 51 MLOAD 04EC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 050D 81 DUP2 050E 52 MSTORE 050F 60 PUSH1 0x04 0511 01 ADD 0512 61 PUSH2 0x051a 0515 90 SWAP1 0516 61 PUSH2 0x0a0d 0519 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @050E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0515 stack[0] = 0x051a // @0515 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x0a0d, returns to 0x051A label_051A: // Incoming return from call to 0x0A0D at 0x0519 // Inputs[3] // { // @051D memory[0x40:0x60] // @051F stack[-1] // @0522 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 051A 5B JUMPDEST 051B 60 PUSH1 0x40 051D 51 MLOAD 051E 80 DUP1 051F 91 SWAP2 0520 03 SUB 0521 90 SWAP1 0522 FD *REVERT // Stack delta = -1 // Outputs[1] { @0522 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0523: // Incoming jump from 0x04E8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0526 stack[-1] // @0528 stack[-3] // @0529 stack[-2] // } 0523 5B JUMPDEST 0524 60 PUSH1 0x01 0526 90 SWAP1 0527 50 POP 0528 91 SWAP2 0529 90 SWAP1 052A 50 POP 052B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0528 stack[-3] = 0x01 } // Block ends with unconditional jump to stack[-3] label_052C: // Incoming call from 0x015E, returns to 0x015F // Inputs[2] // { // @0532 storage[0x04] // @0550 stack[-1] // } 052C 5B JUMPDEST 052D 60 PUSH1 0x04 052F 60 PUSH1 0x00 0531 90 SWAP1 0532 54 SLOAD 0533 90 SWAP1 0534 61 PUSH2 0x0100 0537 0A EXP 0538 90 SWAP1 0539 04 DIV 053A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 054F 16 AND 0550 81 DUP2 0551 56 *JUMP // Stack delta = +1 // Outputs[1] { @054F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x04] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0552: // Incoming call from 0x017C, returns to 0x017D // Inputs[1] { @0558 storage[0x02] } 0552 5B JUMPDEST 0553 60 PUSH1 0x60 0555 60 PUSH1 0x02 0557 80 DUP1 0558 54 SLOAD 0559 61 PUSH2 0x0561 055C 90 SWAP1 055D 61 PUSH2 0x0b88 0560 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0553 stack[0] = 0x60 // @0555 stack[1] = 0x02 // @055C stack[2] = 0x0561 // @055C stack[3] = storage[0x02] // } // Block ends with call to 0x0b88, returns to 0x0561 label_0561: // Incoming return from call to 0x0B88 at 0x0560 // Inputs[4] // { // @0562 stack[-1] // @0571 memory[0x40:0x60] // @0579 stack[-2] // @0584 storage[stack[-2]] // } 0561 5B JUMPDEST 0562 80 DUP1 0563 60 PUSH1 0x1f 0565 01 ADD 0566 60 PUSH1 0x20 0568 80 DUP1 0569 91 SWAP2 056A 04 DIV 056B 02 MUL 056C 60 PUSH1 0x20 056E 01 ADD 056F 60 PUSH1 0x40 0571 51 MLOAD 0572 90 SWAP1 0573 81 DUP2 0574 01 ADD 0575 60 PUSH1 0x40 0577 52 MSTORE 0578 80 DUP1 0579 92 SWAP3 057A 91 SWAP2 057B 90 SWAP1 057C 81 DUP2 057D 81 DUP2 057E 52 MSTORE 057F 60 PUSH1 0x20 0581 01 ADD 0582 82 DUP3 0583 80 DUP1 0584 54 SLOAD 0585 61 PUSH2 0x058d 0588 90 SWAP1 0589 61 PUSH2 0x0b88 058C 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0577 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0579 stack[-2] = memory[0x40:0x60] // @057A stack[-1] = stack[-2] // @057B stack[0] = stack[-1] // @057E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0581 stack[1] = 0x20 + memory[0x40:0x60] // @0582 stack[2] = stack[-2] // @0588 stack[4] = storage[stack[-2]] // @0588 stack[3] = 0x058d // } // Block ends with call to 0x0b88, returns to 0x058D label_058D: // Incoming return from call to 0x0B88 at 0x058C // Inputs[1] { @058E stack[-1] } 058D 5B JUMPDEST 058E 80 DUP1 058F 15 ISZERO 0590 61 PUSH2 0x05da 0593 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05da, if !stack[-1] label_0594: // Incoming jump from 0x0593, if not !stack[-1] // Inputs[1] { @0594 stack[-1] } 0594 80 DUP1 0595 60 PUSH1 0x1f 0597 10 LT 0598 61 PUSH2 0x05af 059B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05af, if 0x1f < stack[-1] label_059C: // Incoming jump from 0x059B, if not 0x1f < stack[-1] // Inputs[4] // { // @05A0 stack[-2] // @05A1 storage[stack[-2]] // @05A4 stack[-3] // @05A6 stack[-1] // } 059C 61 PUSH2 0x0100 059F 80 DUP1 05A0 83 DUP4 05A1 54 SLOAD 05A2 04 DIV 05A3 02 MUL 05A4 83 DUP4 05A5 52 MSTORE 05A6 91 SWAP2 05A7 60 PUSH1 0x20 05A9 01 ADD 05AA 91 SWAP2 05AB 61 PUSH2 0x05da 05AE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @05A5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @05AA stack[-1] = stack[-1] // @05AA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x05da label_05AF: // Incoming jump from 0x059B, if 0x1f < stack[-1] // Inputs[5] // { // @05B0 stack[-3] // @05B1 stack[-1] // @05B3 stack[-2] // @05BB memory[0x00:0x20] // @05BF storage[keccak256(memory[0x00:0x20])] // } 05AF 5B JUMPDEST 05B0 82 DUP3 05B1 01 ADD 05B2 91 SWAP2 05B3 90 SWAP1 05B4 60 PUSH1 0x00 05B6 52 MSTORE 05B7 60 PUSH1 0x20 05B9 60 PUSH1 0x00 05BB 20 SHA3 05BC 90 SWAP1 05BD 5B JUMPDEST 05BE 81 DUP2 05BF 54 SLOAD 05C0 81 DUP2 05C1 52 MSTORE 05C2 90 SWAP1 05C3 60 PUSH1 0x01 05C5 01 ADD 05C6 90 SWAP1 05C7 60 PUSH1 0x20 05C9 01 ADD 05CA 80 DUP1 05CB 83 DUP4 05CC 11 GT 05CD 61 PUSH2 0x05bd 05D0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @05B2 stack[-3] = stack[-3] + stack[-1] // @05B6 memory[0x00:0x20] = stack[-2] // @05C1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @05C6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @05C9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x05bd, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_05D1: // Incoming jump from 0x05D0, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x05D0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @05D1 stack[-3] // @05D2 stack[-1] // } 05D1 82 DUP3 05D2 90 SWAP1 05D3 03 SUB 05D4 60 PUSH1 0x1f 05D6 16 AND 05D7 82 DUP3 05D8 01 ADD 05D9 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @05D9 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @05D9 stack[-1] = stack[-3] // } // Block continues label_05DA: // Incoming jump from 0x05AE // Incoming jump from 0x0593, if !stack[-1] // Incoming jump from 0x05D9 // Inputs[3] // { // @05E0 stack[-7] // @05E0 stack[-6] // @05E2 stack[-8] // } 05DA 5B JUMPDEST 05DB 50 POP 05DC 50 POP 05DD 50 POP 05DE 50 POP 05DF 50 POP 05E0 90 SWAP1 05E1 50 POP 05E2 90 SWAP1 05E3 56 *JUMP // Stack delta = -7 // Outputs[1] { @05E2 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_05E4: // Incoming jump from 0x01AC // Inputs[3] // { // @05E9 memory[0x40:0x60] // @0602 stack[-2] // @0603 stack[-1] // } 05E4 5B JUMPDEST 05E5 60 PUSH1 0x60 05E7 60 PUSH1 0x40 05E9 51 MLOAD 05EA 80 DUP1 05EB 60 PUSH1 0x80 05ED 01 ADD 05EE 60 PUSH1 0x40 05F0 52 MSTORE 05F1 80 DUP1 05F2 60 PUSH1 0x57 05F4 81 DUP2 05F5 52 MSTORE 05F6 60 PUSH1 0x20 05F8 01 ADD 05F9 61 PUSH2 0x0daa 05FC 60 PUSH1 0x57 05FE 91 SWAP2 05FF 39 CODECOPY 0600 90 SWAP1 0601 50 POP 0602 91 SWAP2 0603 90 SWAP1 0604 50 POP 0605 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @05F0 memory[0x40:0x60] = 0x80 + memory[0x40:0x60] // @05F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x57 // @05FF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x57] = code[0x0daa:0x0e01] // @0602 stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-2] label_0606: // Incoming call from 0x029C, returns to 0x029D // Inputs[2] // { // @0649 stack[-1] // @066C stack[-2] // } 0606 5B JUMPDEST 0607 60 PUSH1 0x00 0609 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 062A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0647 19 NOT 0648 16 AND 0649 82 DUP3 064A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0667 19 NOT 0668 16 AND 0669 14 EQ 066A 90 SWAP1 066B 50 POP 066C 91 SWAP2 066D 90 SWAP1 066E 50 POP 066F 56 *JUMP // Stack delta = -1 // Outputs[1] { @066C stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_0670: // Incoming call from 0x079E, returns to 0x079F // Inputs[1] { @0679 stack[-2] } 0670 5B JUMPDEST 0671 60 PUSH1 0x00 0673 61 PUSH2 0x0683 0676 61 PUSH2 0x067e 0679 84 DUP5 067A 61 PUSH2 0x0a6d 067D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0671 stack[0] = 0x00 // @0673 stack[1] = 0x0683 // @0676 stack[2] = 0x067e // @0679 stack[3] = stack[-2] // } // Block ends with call to 0x0a6d, returns to 0x067E label_067E: // Incoming return from call to 0x0A6D at 0x067D 067E 5B JUMPDEST 067F 61 PUSH2 0x0a48 0682 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a48 label_0683: // Incoming return from call to 0x067E at 0x067D // Inputs[5] // { // @0684 stack[-2] // @0684 stack[-1] // @0687 stack[-4] // @0690 stack[-3] // @0691 stack[-5] // } 0683 5B JUMPDEST 0684 90 SWAP1 0685 50 POP 0686 80 DUP1 0687 83 DUP4 0688 82 DUP3 0689 52 MSTORE 068A 60 PUSH1 0x20 068C 82 DUP3 068D 01 ADD 068E 90 SWAP1 068F 50 POP 0690 82 DUP3 0691 85 DUP6 0692 60 PUSH1 0x20 0694 86 DUP7 0695 02 MUL 0696 82 DUP3 0697 01 ADD 0698 11 GT 0699 15 ISZERO 069A 61 PUSH2 0x06a6 069D 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0684 stack[-2] = stack[-1] // @0689 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @068E stack[-1] = stack[-1] + 0x20 // @0690 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x06a6, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_069E: // Incoming jump from 0x069D, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) 069E 61 PUSH2 0x06a5 06A1 61 PUSH2 0x0cf5 06A4 56 *JUMP // Stack delta = +1 // Outputs[1] { @069E stack[0] = 0x06a5 } // Block ends with unconditional jump to 0x0cf5 06A5 5B JUMPDEST label_06A6: // Incoming jump from 0x069D, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @06AA stack[-5] } 06A6 5B JUMPDEST 06A7 60 PUSH1 0x00 06A9 5B JUMPDEST 06AA 85 DUP6 06AB 81 DUP2 06AC 10 LT 06AD 15 ISZERO 06AE 61 PUSH2 0x06d6 06B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A7 stack[0] = 0x00 } // Block ends with conditional jump to 0x06d6, if !(0x00 < stack[-5]) label_06B2: // Incoming jump from 0x06B1, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x06B1, if not !(0x00 < stack[-5]) // Inputs[2] // { // @06B2 stack[-2] // @06B6 stack[-7] // } 06B2 81 DUP2 06B3 61 PUSH2 0x06bc 06B6 88 DUP9 06B7 82 DUP3 06B8 61 PUSH2 0x0750 06BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06B2 stack[0] = stack[-2] // @06B3 stack[1] = 0x06bc // @06B6 stack[2] = stack[-7] // @06B7 stack[3] = stack[-2] // } // Block ends with call to 0x0750, returns to 0x06BC label_06BC: // Incoming return from call to 0x0750 at 0x06BB // Inputs[4] // { // @06BD stack[-5] // @06BE stack[-1] // @06C7 stack[-4] // @06CE stack[-3] // } 06BC 5B JUMPDEST 06BD 84 DUP5 06BE 52 MSTORE 06BF 60 PUSH1 0x20 06C1 84 DUP5 06C2 01 ADD 06C3 93 SWAP4 06C4 50 POP 06C5 60 PUSH1 0x20 06C7 83 DUP4 06C8 01 ADD 06C9 92 SWAP3 06CA 50 POP 06CB 50 POP 06CC 60 PUSH1 0x01 06CE 81 DUP2 06CF 01 ADD 06D0 90 SWAP1 06D1 50 POP 06D2 61 PUSH2 0x06a9 06D5 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @06BE memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @06C3 stack[-5] = stack[-5] + 0x20 // @06C9 stack[-4] = stack[-4] + 0x20 // @06D0 stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x06a9 label_06D6: // Incoming jump from 0x06B1, if !(stack[-1] < stack[-6]) // Incoming jump from 0x06B1, if !(0x00 < stack[-5]) // Inputs[3] // { // @06DA stack[-8] // @06DA stack[-4] // @06DB stack[-7] // } 06D6 5B JUMPDEST 06D7 50 POP 06D8 50 POP 06D9 50 POP 06DA 93 SWAP4 06DB 92 SWAP3 06DC 50 POP 06DD 50 POP 06DE 50 POP 06DF 56 *JUMP // Stack delta = -7 // Outputs[1] { @06DA stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_06E0: // Incoming call from 0x07CC, returns to 0x07CD // Inputs[1] { @06E9 stack[-2] } 06E0 5B JUMPDEST 06E1 60 PUSH1 0x00 06E3 61 PUSH2 0x06f3 06E6 61 PUSH2 0x06ee 06E9 84 DUP5 06EA 61 PUSH2 0x0a99 06ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06E1 stack[0] = 0x00 // @06E3 stack[1] = 0x06f3 // @06E6 stack[2] = 0x06ee // @06E9 stack[3] = stack[-2] // } // Block ends with call to 0x0a99, returns to 0x06EE label_06EE: // Incoming return from call to 0x0A99 at 0x06ED 06EE 5B JUMPDEST 06EF 61 PUSH2 0x0a48 06F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a48 label_06F3: // Incoming return from call to 0x06EE at 0x06ED // Inputs[5] // { // @06F4 stack[-2] // @06F4 stack[-1] // @06F7 stack[-4] // @0700 stack[-3] // @0701 stack[-5] // } 06F3 5B JUMPDEST 06F4 90 SWAP1 06F5 50 POP 06F6 80 DUP1 06F7 83 DUP4 06F8 82 DUP3 06F9 52 MSTORE 06FA 60 PUSH1 0x20 06FC 82 DUP3 06FD 01 ADD 06FE 90 SWAP1 06FF 50 POP 0700 82 DUP3 0701 85 DUP6 0702 60 PUSH1 0x20 0704 86 DUP7 0705 02 MUL 0706 82 DUP3 0707 01 ADD 0708 11 GT 0709 15 ISZERO 070A 61 PUSH2 0x0716 070D 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @06F4 stack[-2] = stack[-1] // @06F9 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @06FE stack[-1] = stack[-1] + 0x20 // @0700 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0716, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_070E: // Incoming jump from 0x070D, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) 070E 61 PUSH2 0x0715 0711 61 PUSH2 0x0cf5 0714 56 *JUMP // Stack delta = +1 // Outputs[1] { @070E stack[0] = 0x0715 } // Block ends with unconditional jump to 0x0cf5 0715 5B JUMPDEST label_0716: // Incoming jump from 0x070D, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @071A stack[-5] } 0716 5B JUMPDEST 0717 60 PUSH1 0x00 0719 5B JUMPDEST 071A 85 DUP6 071B 81 DUP2 071C 10 LT 071D 15 ISZERO 071E 61 PUSH2 0x0746 0721 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0717 stack[0] = 0x00 } // Block ends with conditional jump to 0x0746, if !(0x00 < stack[-5]) label_0722: // Incoming jump from 0x0721, if not !(0x00 < stack[-5]) // Incoming jump from 0x0721, if not !(stack[-1] < stack[-6]) // Inputs[2] // { // @0722 stack[-2] // @0726 stack[-7] // } 0722 81 DUP2 0723 61 PUSH2 0x072c 0726 88 DUP9 0727 82 DUP3 0728 61 PUSH2 0x07eb 072B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0722 stack[0] = stack[-2] // @0723 stack[1] = 0x072c // @0726 stack[2] = stack[-7] // @0727 stack[3] = stack[-2] // } // Block ends with call to 0x07eb, returns to 0x072C label_072C: // Incoming return from call to 0x07EB at 0x072B // Inputs[4] // { // @072D stack[-5] // @072E stack[-1] // @0737 stack[-4] // @073E stack[-3] // } 072C 5B JUMPDEST 072D 84 DUP5 072E 52 MSTORE 072F 60 PUSH1 0x20 0731 84 DUP5 0732 01 ADD 0733 93 SWAP4 0734 50 POP 0735 60 PUSH1 0x20 0737 83 DUP4 0738 01 ADD 0739 92 SWAP3 073A 50 POP 073B 50 POP 073C 60 PUSH1 0x01 073E 81 DUP2 073F 01 ADD 0740 90 SWAP1 0741 50 POP 0742 61 PUSH2 0x0719 0745 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @072E memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @0733 stack[-5] = stack[-5] + 0x20 // @0739 stack[-4] = stack[-4] + 0x20 // @0740 stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x0719 label_0746: // Incoming jump from 0x0721, if !(0x00 < stack[-5]) // Incoming jump from 0x0721, if !(stack[-1] < stack[-6]) // Inputs[3] // { // @074A stack[-8] // @074A stack[-4] // @074B stack[-7] // } 0746 5B JUMPDEST 0747 50 POP 0748 50 POP 0749 50 POP 074A 93 SWAP4 074B 92 SWAP3 074C 50 POP 074D 50 POP 074E 50 POP 074F 56 *JUMP // Stack delta = -7 // Outputs[1] { @074A stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_0750: // Incoming call from 0x0823, returns to 0x0824 // Incoming call from 0x06BB, returns to 0x06BC // Inputs[2] // { // @0753 stack[-1] // @0754 msg.data[stack[-1]:stack[-1] + 0x20] // } 0750 5B JUMPDEST 0751 60 PUSH1 0x00 0753 81 DUP2 0754 35 CALLDATALOAD 0755 90 SWAP1 0756 50 POP 0757 61 PUSH2 0x075f 075A 81 DUP2 075B 61 PUSH2 0x0d64 075E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0755 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0757 stack[1] = 0x075f // @075A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0d64, returns to 0x075F label_075F: // Incoming return from call to 0x0D64 at 0x075E // Inputs[3] // { // @0760 stack[-4] // @0760 stack[-1] // @0761 stack[-3] // } 075F 5B JUMPDEST 0760 92 SWAP3 0761 91 SWAP2 0762 50 POP 0763 50 POP 0764 56 *JUMP // Stack delta = -3 // Outputs[1] { @0760 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0765: // Incoming call from 0x0850, returns to 0x0851 // Inputs[2] // { // @0768 stack[-1] // @0769 memory[stack[-1]:stack[-1] + 0x20] // } 0765 5B JUMPDEST 0766 60 PUSH1 0x00 0768 81 DUP2 0769 51 MLOAD 076A 90 SWAP1 076B 50 POP 076C 61 PUSH2 0x0774 076F 81 DUP2 0770 61 PUSH2 0x0d64 0773 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @076A stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @076C stack[1] = 0x0774 // @076F stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0d64, returns to 0x0774 label_0774: // Incoming return from call to 0x0D64 at 0x0773 // Inputs[3] // { // @0775 stack[-1] // @0775 stack[-4] // @0776 stack[-3] // } 0774 5B JUMPDEST 0775 92 SWAP3 0776 91 SWAP2 0777 50 POP 0778 50 POP 0779 56 *JUMP // Stack delta = -3 // Outputs[1] { @0775 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_077A: // Incoming call from 0x08C7, returns to 0x08C8 // Inputs[2] // { // @077D stack[-2] // @0780 stack[-1] // } 077A 5B JUMPDEST 077B 60 PUSH1 0x00 077D 82 DUP3 077E 60 PUSH1 0x1f 0780 83 DUP4 0781 01 ADD 0782 12 SLT 0783 61 PUSH2 0x078f 0786 57 *JUMPI // Stack delta = +1 // Outputs[1] { @077B stack[0] = 0x00 } // Block ends with conditional jump to 0x078f, if stack[-1] + 0x1f i< stack[-2] label_0787: // Incoming jump from 0x0786, if not stack[-1] + 0x1f i< stack[-2] 0787 61 PUSH2 0x078e 078A 61 PUSH2 0x0cf0 078D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0787 stack[0] = 0x078e } // Block ends with unconditional jump to 0x0cf0 078E 5B JUMPDEST label_078F: // Incoming jump from 0x0786, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @0790 stack[-2] // @0791 msg.data[stack[-2]:stack[-2] + 0x20] // @0795 stack[-3] // } 078F 5B JUMPDEST 0790 81 DUP2 0791 35 CALLDATALOAD 0792 61 PUSH2 0x079f 0795 84 DUP5 0796 82 DUP3 0797 60 PUSH1 0x20 0799 86 DUP7 079A 01 ADD 079B 61 PUSH2 0x0670 079E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0791 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0792 stack[1] = 0x079f // @0795 stack[2] = stack[-3] // @0796 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @079A stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x0670, returns to 0x079F label_079F: // Incoming return from call to 0x0670 at 0x079E // Inputs[4] // { // @07A0 stack[-3] // @07A0 stack[-1] // @07A3 stack[-6] // @07A4 stack[-5] // } 079F 5B JUMPDEST 07A0 91 SWAP2 07A1 50 POP 07A2 50 POP 07A3 92 SWAP3 07A4 91 SWAP2 07A5 50 POP 07A6 50 POP 07A7 56 *JUMP // Stack delta = -5 // Outputs[1] { @07A3 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_07A8: // Incoming call from 0x089A, returns to 0x089B // Inputs[2] // { // @07AB stack[-2] // @07AE stack[-1] // } 07A8 5B JUMPDEST 07A9 60 PUSH1 0x00 07AB 82 DUP3 07AC 60 PUSH1 0x1f 07AE 83 DUP4 07AF 01 ADD 07B0 12 SLT 07B1 61 PUSH2 0x07bd 07B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07A9 stack[0] = 0x00 } // Block ends with conditional jump to 0x07bd, if stack[-1] + 0x1f i< stack[-2] label_07B5: // Incoming jump from 0x07B4, if not stack[-1] + 0x1f i< stack[-2] 07B5 61 PUSH2 0x07bc 07B8 61 PUSH2 0x0cf0 07BB 56 *JUMP // Stack delta = +1 // Outputs[1] { @07B5 stack[0] = 0x07bc } // Block ends with unconditional jump to 0x0cf0 07BC 5B JUMPDEST label_07BD: // Incoming jump from 0x07B4, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @07BE stack[-2] // @07BF msg.data[stack[-2]:stack[-2] + 0x20] // @07C3 stack[-3] // } 07BD 5B JUMPDEST 07BE 81 DUP2 07BF 35 CALLDATALOAD 07C0 61 PUSH2 0x07cd 07C3 84 DUP5 07C4 82 DUP3 07C5 60 PUSH1 0x20 07C7 86 DUP7 07C8 01 ADD 07C9 61 PUSH2 0x06e0 07CC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @07BF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @07C0 stack[1] = 0x07cd // @07C3 stack[2] = stack[-3] // @07C4 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @07C8 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x06e0, returns to 0x07CD label_07CD: // Incoming return from call to 0x06E0 at 0x07CC // Inputs[4] // { // @07CE stack[-3] // @07CE stack[-1] // @07D1 stack[-6] // @07D2 stack[-5] // } 07CD 5B JUMPDEST 07CE 91 SWAP2 07CF 50 POP 07D0 50 POP 07D1 92 SWAP3 07D2 91 SWAP2 07D3 50 POP 07D4 50 POP 07D5 56 *JUMP // Stack delta = -5 // Outputs[1] { @07D1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_07D6: // Incoming call from 0x08F5, returns to 0x08F6 // Inputs[2] // { // @07D9 stack[-1] // @07DA msg.data[stack[-1]:stack[-1] + 0x20] // } 07D6 5B JUMPDEST 07D7 60 PUSH1 0x00 07D9 81 DUP2 07DA 35 CALLDATALOAD 07DB 90 SWAP1 07DC 50 POP 07DD 61 PUSH2 0x07e5 07E0 81 DUP2 07E1 61 PUSH2 0x0d7b 07E4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07DB stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @07DD stack[1] = 0x07e5 // @07E0 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0d7b, returns to 0x07E5 label_07E5: // Incoming return from call to 0x0D7B at 0x07E4 // Inputs[3] // { // @07E6 stack[-1] // @07E6 stack[-4] // @07E7 stack[-3] // } 07E5 5B JUMPDEST 07E6 92 SWAP3 07E7 91 SWAP2 07E8 50 POP 07E9 50 POP 07EA 56 *JUMP // Stack delta = -3 // Outputs[1] { @07E6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_07EB: // Incoming call from 0x0922, returns to 0x0923 // Incoming call from 0x072B, returns to 0x072C // Inputs[2] // { // @07EE stack[-1] // @07EF msg.data[stack[-1]:stack[-1] + 0x20] // } 07EB 5B JUMPDEST 07EC 60 PUSH1 0x00 07EE 81 DUP2 07EF 35 CALLDATALOAD 07F0 90 SWAP1 07F1 50 POP 07F2 61 PUSH2 0x07fa 07F5 81 DUP2 07F6 61 PUSH2 0x0d92 07F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07F0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @07F2 stack[1] = 0x07fa // @07F5 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0d92, returns to 0x07FA label_07FA: // Incoming return from call to 0x0D92 at 0x07F9 // Inputs[3] // { // @07FB stack[-1] // @07FB stack[-4] // @07FC stack[-3] // } 07FA 5B JUMPDEST 07FB 92 SWAP3 07FC 91 SWAP2 07FD 50 POP 07FE 50 POP 07FF 56 *JUMP // Stack delta = -3 // Outputs[1] { @07FB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0800: // Incoming call from 0x013B, returns to 0x013C // Inputs[2] // { // @0805 stack[-1] // @0806 stack[-2] // } 0800 5B JUMPDEST 0801 60 PUSH1 0x00 0803 60 PUSH1 0x20 0805 82 DUP3 0806 84 DUP5 0807 03 SUB 0808 12 SLT 0809 15 ISZERO 080A 61 PUSH2 0x0816 080D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0801 stack[0] = 0x00 } // Block ends with conditional jump to 0x0816, if !(stack[-2] - stack[-1] i< 0x20) label_080E: // Incoming jump from 0x080D, if not !(stack[-2] - stack[-1] i< 0x20) 080E 61 PUSH2 0x0815 0811 61 PUSH2 0x0cff 0814 56 *JUMP // Stack delta = +1 // Outputs[1] { @080E stack[0] = 0x0815 } // Block ends with unconditional jump to 0x0cff 0815 5B JUMPDEST label_0816: // Incoming jump from 0x080D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @081C stack[-3] // @081E stack[-2] // } 0816 5B JUMPDEST 0817 60 PUSH1 0x00 0819 61 PUSH2 0x0824 081C 84 DUP5 081D 82 DUP3 081E 85 DUP6 081F 01 ADD 0820 61 PUSH2 0x0750 0823 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0817 stack[0] = 0x00 // @0819 stack[1] = 0x0824 // @081C stack[2] = stack[-3] // @081F stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0750, returns to 0x0824 label_0824: // Incoming return from call to 0x0750 at 0x0823 // Inputs[4] // { // @0825 stack[-3] // @0825 stack[-1] // @0828 stack[-6] // @0829 stack[-5] // } 0824 5B JUMPDEST 0825 91 SWAP2 0826 50 POP 0827 50 POP 0828 92 SWAP3 0829 91 SWAP2 082A 50 POP 082B 50 POP 082C 56 *JUMP // Stack delta = -5 // Outputs[1] { @0828 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_082D: // Incoming call from 0x04AA, returns to 0x04AB // Inputs[2] // { // @0832 stack[-1] // @0833 stack[-2] // } 082D 5B JUMPDEST 082E 60 PUSH1 0x00 0830 60 PUSH1 0x20 0832 82 DUP3 0833 84 DUP5 0834 03 SUB 0835 12 SLT 0836 15 ISZERO 0837 61 PUSH2 0x0843 083A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @082E stack[0] = 0x00 } // Block ends with conditional jump to 0x0843, if !(stack[-2] - stack[-1] i< 0x20) label_083B: // Incoming jump from 0x083A, if not !(stack[-2] - stack[-1] i< 0x20) 083B 61 PUSH2 0x0842 083E 61 PUSH2 0x0cff 0841 56 *JUMP // Stack delta = +1 // Outputs[1] { @083B stack[0] = 0x0842 } // Block ends with unconditional jump to 0x0cff 0842 5B JUMPDEST label_0843: // Incoming jump from 0x083A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0849 stack[-3] // @084B stack[-2] // } 0843 5B JUMPDEST 0844 60 PUSH1 0x00 0846 61 PUSH2 0x0851 0849 84 DUP5 084A 82 DUP3 084B 85 DUP6 084C 01 ADD 084D 61 PUSH2 0x0765 0850 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0844 stack[0] = 0x00 // @0846 stack[1] = 0x0851 // @0849 stack[2] = stack[-3] // @084C stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0765, returns to 0x0851 label_0851: // Incoming return from call to 0x0765 at 0x0850 // Inputs[4] // { // @0852 stack[-3] // @0852 stack[-1] // @0855 stack[-6] // @0856 stack[-5] // } 0851 5B JUMPDEST 0852 91 SWAP2 0853 50 POP 0854 50 POP 0855 92 SWAP3 0856 91 SWAP2 0857 50 POP 0858 50 POP 0859 56 *JUMP // Stack delta = -5 // Outputs[1] { @0855 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_085A: // Incoming call from 0x00EF, returns to 0x00F0 // Inputs[2] // { // @0860 stack[-1] // @0861 stack[-2] // } 085A 5B JUMPDEST 085B 60 PUSH1 0x00 085D 80 DUP1 085E 60 PUSH1 0x40 0860 83 DUP4 0861 85 DUP6 0862 03 SUB 0863 12 SLT 0864 15 ISZERO 0865 61 PUSH2 0x0871 0868 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @085B stack[0] = 0x00 // @085D stack[1] = 0x00 // } // Block ends with conditional jump to 0x0871, if !(stack[-2] - stack[-1] i< 0x40) label_0869: // Incoming jump from 0x0868, if not !(stack[-2] - stack[-1] i< 0x40) 0869 61 PUSH2 0x0870 086C 61 PUSH2 0x0cff 086F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0869 stack[0] = 0x0870 } // Block ends with unconditional jump to 0x0cff 0870 5B JUMPDEST label_0871: // Incoming jump from 0x0868, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @0874 stack[-3] // @0876 msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] // } 0871 5B JUMPDEST 0872 60 PUSH1 0x00 0874 83 DUP4 0875 01 ADD 0876 35 CALLDATALOAD 0877 67 PUSH8 0xffffffffffffffff 0880 81 DUP2 0881 11 GT 0882 15 ISZERO 0883 61 PUSH2 0x088f 0886 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0876 stack[0] = msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] } // Block ends with conditional jump to 0x088f, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) label_0887: // Incoming jump from 0x0886, if not !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) 0887 61 PUSH2 0x088e 088A 61 PUSH2 0x0cfa 088D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0887 stack[0] = 0x088e } // Block ends with unconditional jump to 0x0cfa 088E 5B JUMPDEST label_088F: // Incoming jump from 0x0886, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0893 stack[-5] // @0894 stack[-1] // @0895 stack[-4] // } 088F 5B JUMPDEST 0890 61 PUSH2 0x089b 0893 85 DUP6 0894 82 DUP3 0895 86 DUP7 0896 01 ADD 0897 61 PUSH2 0x07a8 089A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0890 stack[0] = 0x089b // @0893 stack[1] = stack[-5] // @0896 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x07a8, returns to 0x089B label_089B: // Incoming return from call to 0x07A8 at 0x089A // Inputs[4] // { // @089C stack[-1] // @089C stack[-4] // @08A1 stack[-5] // @08A3 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 089B 5B JUMPDEST 089C 92 SWAP3 089D 50 POP 089E 50 POP 089F 60 PUSH1 0x20 08A1 83 DUP4 08A2 01 ADD 08A3 35 CALLDATALOAD 08A4 67 PUSH8 0xffffffffffffffff 08AD 81 DUP2 08AE 11 GT 08AF 15 ISZERO 08B0 61 PUSH2 0x08bc 08B3 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @089C stack[-4] = stack[-1] // @08A3 stack[-2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x08bc, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_08B4: // Incoming jump from 0x08B3, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) 08B4 61 PUSH2 0x08bb 08B7 61 PUSH2 0x0cfa 08BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @08B4 stack[0] = 0x08bb } // Block ends with unconditional jump to 0x0cfa 08BB 5B JUMPDEST label_08BC: // Incoming jump from 0x08B3, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @08C0 stack[-5] // @08C1 stack[-1] // @08C2 stack[-4] // } 08BC 5B JUMPDEST 08BD 61 PUSH2 0x08c8 08C0 85 DUP6 08C1 82 DUP3 08C2 86 DUP7 08C3 01 ADD 08C4 61 PUSH2 0x077a 08C7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08BD stack[0] = 0x08c8 // @08C0 stack[1] = stack[-5] // @08C3 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x077a, returns to 0x08C8 label_08C8: // Incoming return from call to 0x077A at 0x08C7 // Inputs[6] // { // @08C9 stack[-1] // @08C9 stack[-3] // @08CC stack[-6] // @08CE stack[-7] // @08CE stack[-4] // @08CF stack[-5] // } 08C8 5B JUMPDEST 08C9 91 SWAP2 08CA 50 POP 08CB 50 POP 08CC 92 SWAP3 08CD 50 POP 08CE 92 SWAP3 08CF 90 SWAP1 08D0 50 POP 08D1 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @08CC stack[-6] = stack[-1] // @08CE stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_08D2: // Incoming call from 0x00A1, returns to 0x00A2 // Inputs[2] // { // @08D7 stack[-1] // @08D8 stack[-2] // } 08D2 5B JUMPDEST 08D3 60 PUSH1 0x00 08D5 60 PUSH1 0x20 08D7 82 DUP3 08D8 84 DUP5 08D9 03 SUB 08DA 12 SLT 08DB 15 ISZERO 08DC 61 PUSH2 0x08e8 08DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08D3 stack[0] = 0x00 } // Block ends with conditional jump to 0x08e8, if !(stack[-2] - stack[-1] i< 0x20) label_08E0: // Incoming jump from 0x08DF, if not !(stack[-2] - stack[-1] i< 0x20) 08E0 61 PUSH2 0x08e7 08E3 61 PUSH2 0x0cff 08E6 56 *JUMP // Stack delta = +1 // Outputs[1] { @08E0 stack[0] = 0x08e7 } // Block ends with unconditional jump to 0x0cff 08E7 5B JUMPDEST label_08E8: // Incoming jump from 0x08DF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @08EE stack[-3] // @08F0 stack[-2] // } 08E8 5B JUMPDEST 08E9 60 PUSH1 0x00 08EB 61 PUSH2 0x08f6 08EE 84 DUP5 08EF 82 DUP3 08F0 85 DUP6 08F1 01 ADD 08F2 61 PUSH2 0x07d6 08F5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08E9 stack[0] = 0x00 // @08EB stack[1] = 0x08f6 // @08EE stack[2] = stack[-3] // @08F1 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x07d6, returns to 0x08F6 label_08F6: // Incoming return from call to 0x07D6 at 0x08F5 // Inputs[4] // { // @08F7 stack[-3] // @08F7 stack[-1] // @08FA stack[-6] // @08FB stack[-5] // } 08F6 5B JUMPDEST 08F7 91 SWAP2 08F8 50 POP 08F9 50 POP 08FA 92 SWAP3 08FB 91 SWAP2 08FC 50 POP 08FD 50 POP 08FE 56 *JUMP // Stack delta = -5 // Outputs[1] { @08FA stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_08FF: // Incoming call from 0x010B, returns to 0x010C // Incoming call from 0x01A7, returns to 0x01A8 // Inputs[2] // { // @0904 stack[-1] // @0905 stack[-2] // } 08FF 5B JUMPDEST 0900 60 PUSH1 0x00 0902 60 PUSH1 0x20 0904 82 DUP3 0905 84 DUP5 0906 03 SUB 0907 12 SLT 0908 15 ISZERO 0909 61 PUSH2 0x0915 090C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0900 stack[0] = 0x00 } // Block ends with conditional jump to 0x0915, if !(stack[-2] - stack[-1] i< 0x20) label_090D: // Incoming jump from 0x090C, if not !(stack[-2] - stack[-1] i< 0x20) 090D 61 PUSH2 0x0914 0910 61 PUSH2 0x0cff 0913 56 *JUMP // Stack delta = +1 // Outputs[1] { @090D stack[0] = 0x0914 } // Block ends with unconditional jump to 0x0cff 0914 5B JUMPDEST label_0915: // Incoming jump from 0x090C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @091B stack[-3] // @091D stack[-2] // } 0915 5B JUMPDEST 0916 60 PUSH1 0x00 0918 61 PUSH2 0x0923 091B 84 DUP5 091C 82 DUP3 091D 85 DUP6 091E 01 ADD 091F 61 PUSH2 0x07eb 0922 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0916 stack[0] = 0x00 // @0918 stack[1] = 0x0923 // @091B stack[2] = stack[-3] // @091E stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x07eb, returns to 0x0923 label_0923: // Incoming return from call to 0x07EB at 0x0922 // Inputs[4] // { // @0924 stack[-1] // @0924 stack[-3] // @0927 stack[-6] // @0928 stack[-5] // } 0923 5B JUMPDEST 0924 91 SWAP2 0925 50 POP 0926 50 POP 0927 92 SWAP3 0928 91 SWAP2 0929 50 POP 092A 50 POP 092B 56 *JUMP // Stack delta = -5 // Outputs[1] { @0927 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_092C: // Incoming call from 0x09C9, returns to 0x09CA // Inputs[1] { @0930 stack[-1] } 092C 5B JUMPDEST 092D 61 PUSH2 0x0935 0930 81 DUP2 0931 61 PUSH2 0x0ae1 0934 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @092D stack[0] = 0x0935 // @0930 stack[1] = stack[-1] // } // Block ends with call to 0x0ae1, returns to 0x0935 label_0935: // Incoming return from call to 0x0AE1 at 0x0934 // Inputs[3] // { // @0936 stack[-3] // @0937 stack[-1] // @093A stack[-4] // } 0935 5B JUMPDEST 0936 82 DUP3 0937 52 MSTORE 0938 50 POP 0939 50 POP 093A 56 *JUMP // Stack delta = -4 // Outputs[1] { @0937 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_093B: // Incoming call from 0x09E4, returns to 0x09E5 // Inputs[1] { @093F stack[-1] } 093B 5B JUMPDEST 093C 61 PUSH2 0x0944 093F 81 DUP2 0940 61 PUSH2 0x0af3 0943 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @093C stack[0] = 0x0944 // @093F stack[1] = stack[-1] // } // Block ends with call to 0x0af3, returns to 0x0944 label_0944: // Incoming return from call to 0x0AF3 at 0x0943 // Inputs[3] // { // @0945 stack[-3] // @0946 stack[-1] // @0949 stack[-4] // } 0944 5B JUMPDEST 0945 82 DUP3 0946 52 MSTORE 0947 50 POP 0948 50 POP 0949 56 *JUMP // Stack delta = -4 // Outputs[1] { @0946 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_094A: // Incoming call from 0x0A04, returns to 0x0A05 // Inputs[1] { @0950 stack[-1] } 094A 5B JUMPDEST 094B 60 PUSH1 0x00 094D 61 PUSH2 0x0955 0950 82 DUP3 0951 61 PUSH2 0x0ac5 0954 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @094B stack[0] = 0x00 // @094D stack[1] = 0x0955 // @0950 stack[2] = stack[-1] // } // Block ends with call to 0x0ac5, returns to 0x0955 label_0955: // Incoming return from call to 0x0AC5 at 0x0954 // Inputs[2] // { // @0959 stack[-1] // @095A stack[-4] // } 0955 5B JUMPDEST 0956 61 PUSH2 0x095f 0959 81 DUP2 095A 85 DUP6 095B 61 PUSH2 0x0ad0 095E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0956 stack[0] = 0x095f // @0959 stack[1] = stack[-1] // @095A stack[2] = stack[-4] // } // Block ends with call to 0x0ad0, returns to 0x095F label_095F: // Incoming return from call to 0x0AD0 at 0x095E // Inputs[4] // { // @0960 stack[-5] // @0960 stack[-1] // @0965 stack[-2] // @0969 stack[-4] // } 095F 5B JUMPDEST 0960 93 SWAP4 0961 50 POP 0962 61 PUSH2 0x096f 0965 81 DUP2 0966 85 DUP6 0967 60 PUSH1 0x20 0969 86 DUP7 096A 01 ADD 096B 61 PUSH2 0x0b55 096E 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0960 stack[-5] = stack[-1] // @0962 stack[-1] = 0x096f // @0965 stack[0] = stack[-2] // @0966 stack[1] = stack[-1] // @096A stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x0b55, returns to 0x096F label_096F: // Incoming return from call to 0x0B55 at 0x096E // Inputs[1] { @0973 stack[-1] } 096F 5B JUMPDEST 0970 61 PUSH2 0x0978 0973 81 DUP2 0974 61 PUSH2 0x0d04 0977 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0970 stack[0] = 0x0978 // @0973 stack[1] = stack[-1] // } // Block ends with call to 0x0d04, returns to 0x0978 label_0978: // Incoming return from call to 0x0D04 at 0x0977 // Inputs[4] // { // @0979 stack[-5] // @097A stack[-1] // @097B stack[-3] // @097E stack[-6] // } 0978 5B JUMPDEST 0979 84 DUP5 097A 01 ADD 097B 91 SWAP2 097C 50 POP 097D 50 POP 097E 92 SWAP3 097F 91 SWAP2 0980 50 POP 0981 50 POP 0982 56 *JUMP // Stack delta = -5 // Outputs[1] { @097E stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_0983: // Incoming call from 0x0A25, returns to 0x0A26 // Inputs[1] { @098B stack[-1] } 0983 5B JUMPDEST 0984 60 PUSH1 0x00 0986 61 PUSH2 0x0990 0989 60 PUSH1 0x2a 098B 83 DUP4 098C 61 PUSH2 0x0ad0 098F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0984 stack[0] = 0x00 // @0986 stack[1] = 0x0990 // @0989 stack[2] = 0x2a // @098B stack[3] = stack[-1] // } // Block ends with call to 0x0ad0, returns to 0x0990 label_0990: // Incoming return from call to 0x0AD0 at 0x098F // Inputs[2] // { // @0991 stack[-3] // @0991 stack[-1] // } 0990 5B JUMPDEST 0991 91 SWAP2 0992 50 POP 0993 61 PUSH2 0x099b 0996 82 DUP3 0997 61 PUSH2 0x0d15 099A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0991 stack[-3] = stack[-1] // @0993 stack[-1] = 0x099b // @0996 stack[0] = stack[-1] // } // Block ends with call to 0x0d15, returns to 0x099B label_099B: // Incoming return from call to 0x0D15 at 0x099A // Inputs[3] // { // @099E stack[-2] // @09A0 stack[-1] // @09A2 stack[-3] // } 099B 5B JUMPDEST 099C 60 PUSH1 0x40 099E 82 DUP3 099F 01 ADD 09A0 90 SWAP1 09A1 50 POP 09A2 91 SWAP2 09A3 90 SWAP1 09A4 50 POP 09A5 56 *JUMP // Stack delta = -2 // Outputs[1] { @09A2 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_09A6: // Incoming call from 0x0A41, returns to 0x0A42 // Inputs[1] { @09AA stack[-1] } 09A6 5B JUMPDEST 09A7 61 PUSH2 0x09af 09AA 81 DUP2 09AB 61 PUSH2 0x0b4b 09AE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09A7 stack[0] = 0x09af // @09AA stack[1] = stack[-1] // } // Block ends with call to 0x0b4b, returns to 0x09AF label_09AF: // Incoming return from call to 0x0B4B at 0x09AE // Inputs[3] // { // @09B0 stack[-3] // @09B1 stack[-1] // @09B4 stack[-4] // } 09AF 5B JUMPDEST 09B0 82 DUP3 09B1 52 MSTORE 09B2 50 POP 09B3 50 POP 09B4 56 *JUMP // Stack delta = -4 // Outputs[1] { @09B1 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_09B5: // Incoming call from 0x011D, returns to 0x011E // Incoming call from 0x016B, returns to 0x016C // Inputs[2] // { // @09BA stack[-1] // @09C5 stack[-2] // } 09B5 5B JUMPDEST 09B6 60 PUSH1 0x00 09B8 60 PUSH1 0x20 09BA 82 DUP3 09BB 01 ADD 09BC 90 SWAP1 09BD 50 POP 09BE 61 PUSH2 0x09ca 09C1 60 PUSH1 0x00 09C3 83 DUP4 09C4 01 ADD 09C5 84 DUP5 09C6 61 PUSH2 0x092c 09C9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09BC stack[0] = stack[-1] + 0x20 // @09BE stack[1] = 0x09ca // @09C4 stack[2] = stack[-1] + 0x00 // @09C5 stack[3] = stack[-2] // } // Block ends with call to 0x092c, returns to 0x09CA label_09CA: // Incoming return from call to 0x092C at 0x09C9 // Inputs[3] // { // @09CB stack[-4] // @09CB stack[-1] // @09CC stack[-3] // } 09CA 5B JUMPDEST 09CB 92 SWAP3 09CC 91 SWAP2 09CD 50 POP 09CE 50 POP 09CF 56 *JUMP // Stack delta = -3 // Outputs[1] { @09CB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_09D0: // Incoming call from 0x00B3, returns to 0x00B4 // Inputs[2] // { // @09D5 stack[-1] // @09E0 stack[-2] // } 09D0 5B JUMPDEST 09D1 60 PUSH1 0x00 09D3 60 PUSH1 0x20 09D5 82 DUP3 09D6 01 ADD 09D7 90 SWAP1 09D8 50 POP 09D9 61 PUSH2 0x09e5 09DC 60 PUSH1 0x00 09DE 83 DUP4 09DF 01 ADD 09E0 84 DUP5 09E1 61 PUSH2 0x093b 09E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09D7 stack[0] = stack[-1] + 0x20 // @09D9 stack[1] = 0x09e5 // @09DF stack[2] = stack[-1] + 0x00 // @09E0 stack[3] = stack[-2] // } // Block ends with call to 0x093b, returns to 0x09E5 label_09E5: // Incoming return from call to 0x093B at 0x09E4 // Inputs[3] // { // @09E6 stack[-1] // @09E6 stack[-4] // @09E7 stack[-3] // } 09E5 5B JUMPDEST 09E6 92 SWAP3 09E7 91 SWAP2 09E8 50 POP 09E9 50 POP 09EA 56 *JUMP // Stack delta = -3 // Outputs[1] { @09E6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_09EB: // Incoming call from 0x01B9, returns to 0x01BA // Incoming call from 0x00D1, returns to 0x00D2 // Incoming call from 0x0189, returns to 0x018A // Inputs[2] // { // @09F0 stack[-1] // @0A00 stack[-2] // } 09EB 5B JUMPDEST 09EC 60 PUSH1 0x00 09EE 60 PUSH1 0x20 09F0 82 DUP3 09F1 01 ADD 09F2 90 SWAP1 09F3 50 POP 09F4 81 DUP2 09F5 81 DUP2 09F6 03 SUB 09F7 60 PUSH1 0x00 09F9 83 DUP4 09FA 01 ADD 09FB 52 MSTORE 09FC 61 PUSH2 0x0a05 09FF 81 DUP2 0A00 84 DUP5 0A01 61 PUSH2 0x094a 0A04 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @09F2 stack[0] = stack[-1] + 0x20 // @09FB memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @09FC stack[1] = 0x0a05 // @09FF stack[2] = stack[-1] + 0x20 // @0A00 stack[3] = stack[-2] // } // Block ends with call to 0x094a, returns to 0x0A05 label_0A05: // Incoming return from call to 0x094A at 0x0A04 // Inputs[4] // { // @0A06 stack[-2] // @0A06 stack[-1] // @0A08 stack[-5] // @0A09 stack[-4] // } 0A05 5B JUMPDEST 0A06 90 SWAP1 0A07 50 POP 0A08 92 SWAP3 0A09 91 SWAP2 0A0A 50 POP 0A0B 50 POP 0A0C 56 *JUMP // Stack delta = -4 // Outputs[1] { @0A08 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0A0D: // Incoming call from 0x0519, returns to 0x051A // Inputs[1] { @0A12 stack[-1] } 0A0D 5B JUMPDEST 0A0E 60 PUSH1 0x00 0A10 60 PUSH1 0x20 0A12 82 DUP3 0A13 01 ADD 0A14 90 SWAP1 0A15 50 POP 0A16 81 DUP2 0A17 81 DUP2 0A18 03 SUB 0A19 60 PUSH1 0x00 0A1B 83 DUP4 0A1C 01 ADD 0A1D 52 MSTORE 0A1E 61 PUSH2 0x0a26 0A21 81 DUP2 0A22 61 PUSH2 0x0983 0A25 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0A14 stack[0] = stack[-1] + 0x20 // @0A1D memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @0A1E stack[1] = 0x0a26 // @0A21 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x0983, returns to 0x0A26 label_0A26: // Incoming return from call to 0x0983 at 0x0A25 // Inputs[4] // { // @0A27 stack[-1] // @0A27 stack[-2] // @0A29 stack[-4] // @0A2A stack[-3] // } 0A26 5B JUMPDEST 0A27 90 SWAP1 0A28 50 POP 0A29 91 SWAP2 0A2A 90 SWAP1 0A2B 50 POP 0A2C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0A29 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0A2D: // Incoming call from 0x045A, returns to 0x045B // Incoming call from 0x014D, returns to 0x014E // Inputs[2] // { // @0A32 stack[-1] // @0A3D stack[-2] // } 0A2D 5B JUMPDEST 0A2E 60 PUSH1 0x00 0A30 60 PUSH1 0x20 0A32 82 DUP3 0A33 01 ADD 0A34 90 SWAP1 0A35 50 POP 0A36 61 PUSH2 0x0a42 0A39 60 PUSH1 0x00 0A3B 83 DUP4 0A3C 01 ADD 0A3D 84 DUP5 0A3E 61 PUSH2 0x09a6 0A41 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A34 stack[0] = stack[-1] + 0x20 // @0A36 stack[1] = 0x0a42 // @0A3C stack[2] = stack[-1] + 0x00 // @0A3D stack[3] = stack[-2] // } // Block ends with call to 0x09a6, returns to 0x0A42 label_0A42: // Incoming return from call to 0x09A6 at 0x0A41 // Inputs[3] // { // @0A43 stack[-1] // @0A43 stack[-4] // @0A44 stack[-3] // } 0A42 5B JUMPDEST 0A43 92 SWAP3 0A44 91 SWAP2 0A45 50 POP 0A46 50 POP 0A47 56 *JUMP // Stack delta = -3 // Outputs[1] { @0A43 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0A48: // Incoming jump from 0x0682 // Incoming jump from 0x06F2 0A48 5B JUMPDEST 0A49 60 PUSH1 0x00 0A4B 61 PUSH2 0x0a52 0A4E 61 PUSH2 0x0a63 0A51 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A49 stack[0] = 0x00 // @0A4B stack[1] = 0x0a52 // } // Block ends with call to 0x0a63, returns to 0x0A52 label_0A52: // Incoming return from call to 0x0A63 at 0x0A51 // Inputs[3] // { // @0A53 stack[-2] // @0A53 stack[-1] // @0A58 stack[-3] // } 0A52 5B JUMPDEST 0A53 90 SWAP1 0A54 50 POP 0A55 61 PUSH2 0x0a5e 0A58 82 DUP3 0A59 82 DUP3 0A5A 61 PUSH2 0x0bba 0A5D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0A53 stack[-2] = stack[-1] // @0A55 stack[-1] = 0x0a5e // @0A58 stack[0] = stack[-3] // @0A59 stack[1] = stack[-1] // } // Block ends with call to 0x0bba, returns to 0x0A5E label_0A5E: // Incoming return from call to 0x0BBA at 0x0A5D // Inputs[3] // { // @0A5F stack[-1] // @0A5F stack[-3] // @0A60 stack[-2] // } 0A5E 5B JUMPDEST 0A5F 91 SWAP2 0A60 90 SWAP1 0A61 50 POP 0A62 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A5F stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0A63: // Incoming call from 0x0A51, returns to 0x0A52 // Inputs[2] // { // @0A68 memory[0x40:0x60] // @0A6B stack[-1] // } 0A63 5B JUMPDEST 0A64 60 PUSH1 0x00 0A66 60 PUSH1 0x40 0A68 51 MLOAD 0A69 90 SWAP1 0A6A 50 POP 0A6B 90 SWAP1 0A6C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A6B stack[-1] = memory[0x40:0x60] } // Block ends with unconditional jump to stack[-1] label_0A6D: // Incoming call from 0x067D, returns to 0x067E // Inputs[1] { @0A79 stack[-1] } 0A6D 5B JUMPDEST 0A6E 60 PUSH1 0x00 0A70 67 PUSH8 0xffffffffffffffff 0A79 82 DUP3 0A7A 11 GT 0A7B 15 ISZERO 0A7C 61 PUSH2 0x0a88 0A7F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A6E stack[0] = 0x00 } // Block ends with conditional jump to 0x0a88, if !(stack[-1] > 0xffffffffffffffff) label_0A80: // Incoming jump from 0x0A7F, if not !(stack[-1] > 0xffffffffffffffff) 0A80 61 PUSH2 0x0a87 0A83 61 PUSH2 0x0cc1 0A86 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A80 stack[0] = 0x0a87 } // Block ends with unconditional jump to 0x0cc1 0A87 5B JUMPDEST label_0A88: // Incoming jump from 0x0A7F, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @0A8B stack[-2] // @0A8D stack[-1] // @0A95 stack[-3] // } 0A88 5B JUMPDEST 0A89 60 PUSH1 0x20 0A8B 82 DUP3 0A8C 02 MUL 0A8D 90 SWAP1 0A8E 50 POP 0A8F 60 PUSH1 0x20 0A91 81 DUP2 0A92 01 ADD 0A93 90 SWAP1 0A94 50 POP 0A95 91 SWAP2 0A96 90 SWAP1 0A97 50 POP 0A98 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A95 stack[-3] = stack[-2] * 0x20 + 0x20 } // Block ends with unconditional jump to stack[-3] label_0A99: // Incoming call from 0x06ED, returns to 0x06EE // Inputs[1] { @0AA5 stack[-1] } 0A99 5B JUMPDEST 0A9A 60 PUSH1 0x00 0A9C 67 PUSH8 0xffffffffffffffff 0AA5 82 DUP3 0AA6 11 GT 0AA7 15 ISZERO 0AA8 61 PUSH2 0x0ab4 0AAB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A9A stack[0] = 0x00 } // Block ends with conditional jump to 0x0ab4, if !(stack[-1] > 0xffffffffffffffff) label_0AAC: // Incoming jump from 0x0AAB, if not !(stack[-1] > 0xffffffffffffffff) 0AAC 61 PUSH2 0x0ab3 0AAF 61 PUSH2 0x0cc1 0AB2 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AAC stack[0] = 0x0ab3 } // Block ends with unconditional jump to 0x0cc1 0AB3 5B JUMPDEST label_0AB4: // Incoming jump from 0x0AAB, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @0AB7 stack[-2] // @0AB9 stack[-1] // @0AC1 stack[-3] // } 0AB4 5B JUMPDEST 0AB5 60 PUSH1 0x20 0AB7 82 DUP3 0AB8 02 MUL 0AB9 90 SWAP1 0ABA 50 POP 0ABB 60 PUSH1 0x20 0ABD 81 DUP2 0ABE 01 ADD 0ABF 90 SWAP1 0AC0 50 POP 0AC1 91 SWAP2 0AC2 90 SWAP1 0AC3 50 POP 0AC4 56 *JUMP // Stack delta = -2 // Outputs[1] { @0AC1 stack[-3] = stack[-2] * 0x20 + 0x20 } // Block ends with unconditional jump to stack[-3] label_0AC5: // Incoming call from 0x0954, returns to 0x0955 // Inputs[3] // { // @0AC8 stack[-1] // @0AC9 memory[stack[-1]:stack[-1] + 0x20] // @0ACC stack[-2] // } 0AC5 5B JUMPDEST 0AC6 60 PUSH1 0x00 0AC8 81 DUP2 0AC9 51 MLOAD 0ACA 90 SWAP1 0ACB 50 POP 0ACC 91 SWAP2 0ACD 90 SWAP1 0ACE 50 POP 0ACF 56 *JUMP // Stack delta = -1 // Outputs[1] { @0ACC stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_0AD0: // Incoming call from 0x098F, returns to 0x0990 // Incoming call from 0x095E, returns to 0x095F // Inputs[3] // { // @0AD3 stack[-2] // @0AD4 stack[-1] // @0ADC stack[-3] // } 0AD0 5B JUMPDEST 0AD1 60 PUSH1 0x00 0AD3 82 DUP3 0AD4 82 DUP3 0AD5 52 MSTORE 0AD6 60 PUSH1 0x20 0AD8 82 DUP3 0AD9 01 ADD 0ADA 90 SWAP1 0ADB 50 POP 0ADC 92 SWAP3 0ADD 91 SWAP2 0ADE 50 POP 0ADF 50 POP 0AE0 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0AD5 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @0ADC stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_0AE1: // Incoming call from 0x0D6C, returns to 0x0D6D // Incoming call from 0x0934, returns to 0x0935 // Inputs[1] { @0AE7 stack[-1] } 0AE1 5B JUMPDEST 0AE2 60 PUSH1 0x00 0AE4 61 PUSH2 0x0aec 0AE7 82 DUP3 0AE8 61 PUSH2 0x0b2b 0AEB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AE2 stack[0] = 0x00 // @0AE4 stack[1] = 0x0aec // @0AE7 stack[2] = stack[-1] // } // Block ends with call to 0x0b2b, returns to 0x0AEC label_0AEC: // Incoming return from call to 0x0B2B at 0x0AEB // Inputs[4] // { // @0AED stack[-2] // @0AED stack[-1] // @0AEF stack[-4] // @0AF0 stack[-3] // } 0AEC 5B JUMPDEST 0AED 90 SWAP1 0AEE 50 POP 0AEF 91 SWAP2 0AF0 90 SWAP1 0AF1 50 POP 0AF2 56 *JUMP // Stack delta = -3 // Outputs[1] { @0AEF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0AF3: // Incoming call from 0x0943, returns to 0x0944 // Inputs[2] // { // @0AF6 stack[-1] // @0AFB stack[-2] // } 0AF3 5B JUMPDEST 0AF4 60 PUSH1 0x00 0AF6 81 DUP2 0AF7 15 ISZERO 0AF8 15 ISZERO 0AF9 90 SWAP1 0AFA 50 POP 0AFB 91 SWAP2 0AFC 90 SWAP1 0AFD 50 POP 0AFE 56 *JUMP // Stack delta = -1 // Outputs[1] { @0AFB stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0AFF: // Incoming call from 0x0D83, returns to 0x0D84 // Inputs[2] // { // @0B23 stack[-1] // @0B27 stack[-2] // } 0AFF 5B JUMPDEST 0B00 60 PUSH1 0x00 0B02 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 0B23 82 DUP3 0B24 16 AND 0B25 90 SWAP1 0B26 50 POP 0B27 91 SWAP2 0B28 90 SWAP1 0B29 50 POP 0B2A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B27 stack[-2] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_0B2B: // Incoming call from 0x0AEB, returns to 0x0AEC // Inputs[2] // { // @0B43 stack[-1] // @0B47 stack[-2] // } 0B2B 5B JUMPDEST 0B2C 60 PUSH1 0x00 0B2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B43 82 DUP3 0B44 16 AND 0B45 90 SWAP1 0B46 50 POP 0B47 91 SWAP2 0B48 90 SWAP1 0B49 50 POP 0B4A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B47 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_0B4B: // Incoming call from 0x09AE, returns to 0x09AF // Incoming call from 0x0D9A, returns to 0x0D9B // Incoming call from 0x0BF5, returns to 0x0BF6 // Inputs[2] // { // @0B4E stack[-1] // @0B51 stack[-2] // } 0B4B 5B JUMPDEST 0B4C 60 PUSH1 0x00 0B4E 81 DUP2 0B4F 90 SWAP1 0B50 50 POP 0B51 91 SWAP2 0B52 90 SWAP1 0B53 50 POP 0B54 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B51 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0B55: // Incoming call from 0x096E, returns to 0x096F // Inputs[1] { @0B59 stack[-3] } 0B55 5B JUMPDEST 0B56 60 PUSH1 0x00 0B58 5B JUMPDEST 0B59 83 DUP4 0B5A 81 DUP2 0B5B 10 LT 0B5C 15 ISZERO 0B5D 61 PUSH2 0x0b73 0B60 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B56 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b73, if !(0x00 < stack[-3]) label_0B61: // Incoming jump from 0x0B60, if not !(0x00 < stack[-3]) // Incoming jump from 0x0B60, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0B61 stack[-1] // @0B62 stack[-2] // @0B64 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0B66 stack[-3] // } 0B61 80 DUP1 0B62 82 DUP3 0B63 01 ADD 0B64 51 MLOAD 0B65 81 DUP2 0B66 84 DUP5 0B67 01 ADD 0B68 52 MSTORE 0B69 60 PUSH1 0x20 0B6B 81 DUP2 0B6C 01 ADD 0B6D 90 SWAP1 0B6E 50 POP 0B6F 61 PUSH2 0x0b58 0B72 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B68 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0B6D stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0b58 label_0B73: // Incoming jump from 0x0B60, if !(0x00 < stack[-3]) // Incoming jump from 0x0B60, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @0B74 stack[-4] // @0B75 stack[-1] // } 0B73 5B JUMPDEST 0B74 83 DUP4 0B75 81 DUP2 0B76 11 GT 0B77 15 ISZERO 0B78 61 PUSH2 0x0b82 0B7B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b82, if !(stack[-1] > stack[-4]) label_0B7C: // Incoming jump from 0x0B7B, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @0B7E stack[-4] // @0B7F stack[-3] // @0B87 stack[-5] // } 0B7C 60 PUSH1 0x00 0B7E 84 DUP5 0B7F 84 DUP5 0B80 01 ADD 0B81 52 MSTORE 0B82 5B JUMPDEST 0B83 50 POP 0B84 50 POP 0B85 50 POP 0B86 50 POP 0B87 56 *JUMP // Stack delta = -5 // Outputs[1] { @0B81 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0B88: // Incoming call from 0x0560, returns to 0x0561 // Incoming call from 0x02DF, returns to 0x02E0 // Incoming call from 0x058C, returns to 0x058D // Incoming call from 0x02B3, returns to 0x02B4 // Inputs[1] { @0B8D stack[-1] } 0B88 5B JUMPDEST 0B89 60 PUSH1 0x00 0B8B 60 PUSH1 0x02 0B8D 82 DUP3 0B8E 04 DIV 0B8F 90 SWAP1 0B90 50 POP 0B91 60 PUSH1 0x01 0B93 82 DUP3 0B94 16 AND 0B95 80 DUP1 0B96 61 PUSH2 0x0ba0 0B99 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B8F stack[0] = stack[-1] / 0x02 // @0B94 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x0ba0, if stack[-1] & 0x01 label_0B9A: // Incoming jump from 0x0B99, if not stack[-1] & 0x01 // Inputs[2] // { // @0B9C stack[-2] // @0BA5 stack[-1] // } 0B9A 60 PUSH1 0x7f 0B9C 82 DUP3 0B9D 16 AND 0B9E 91 SWAP2 0B9F 50 POP 0BA0 5B JUMPDEST 0BA1 60 PUSH1 0x20 0BA3 82 DUP3 0BA4 10 LT 0BA5 81 DUP2 0BA6 14 EQ 0BA7 15 ISZERO 0BA8 61 PUSH2 0x0bb4 0BAB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0B9E stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x0bb4, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_0BAC: // Incoming jump from 0x0BAB, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x0BAB, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) 0BAC 61 PUSH2 0x0bb3 0BAF 61 PUSH2 0x0c63 0BB2 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BAC stack[0] = 0x0bb3 } // Block ends with unconditional jump to 0x0c63 0BB3 5B JUMPDEST label_0BB4: // Incoming jump from 0x0BAB, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x0BAB, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @0BB6 stack[-2] // @0BB6 stack[-4] // @0BB7 stack[-3] // } 0BB4 5B JUMPDEST 0BB5 50 POP 0BB6 91 SWAP2 0BB7 90 SWAP1 0BB8 50 POP 0BB9 56 *JUMP // Stack delta = -3 // Outputs[1] { @0BB6 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_0BBA: // Incoming call from 0x0A5D, returns to 0x0A5E // Inputs[1] { @0BBE stack[-2] } 0BBA 5B JUMPDEST 0BBB 61 PUSH2 0x0bc3 0BBE 82 DUP3 0BBF 61 PUSH2 0x0d04 0BC2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BBB stack[0] = 0x0bc3 // @0BBE stack[1] = stack[-2] // } // Block ends with call to 0x0d04, returns to 0x0BC3 label_0BC3: // Incoming return from call to 0x0D04 at 0x0BC2 // Inputs[2] // { // @0BC4 stack[-2] // @0BC5 stack[-1] // } 0BC3 5B JUMPDEST 0BC4 81 DUP2 0BC5 01 ADD 0BC6 81 DUP2 0BC7 81 DUP2 0BC8 10 LT 0BC9 67 PUSH8 0xffffffffffffffff 0BD2 82 DUP3 0BD3 11 GT 0BD4 17 OR 0BD5 15 ISZERO 0BD6 61 PUSH2 0x0be2 0BD9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0BC5 stack[-1] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0be2, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) label_0BDA: // Incoming jump from 0x0BD9, if not !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) 0BDA 61 PUSH2 0x0be1 0BDD 61 PUSH2 0x0cc1 0BE0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BDA stack[0] = 0x0be1 } // Block ends with unconditional jump to 0x0cc1 0BE1 5B JUMPDEST label_0BE2: // Incoming jump from 0x0BD9, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) // Inputs[2] // { // @0BE3 stack[-1] // @0BEA stack[-4] // } 0BE2 5B JUMPDEST 0BE3 80 DUP1 0BE4 60 PUSH1 0x40 0BE6 52 MSTORE 0BE7 50 POP 0BE8 50 POP 0BE9 50 POP 0BEA 56 *JUMP // Stack delta = -4 // Outputs[1] { @0BE6 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0BEB: // Incoming call from 0x03FE, returns to 0x03FF // Inputs[1] { @0BF1 stack[-1] } 0BEB 5B JUMPDEST 0BEC 60 PUSH1 0x00 0BEE 61 PUSH2 0x0bf6 0BF1 82 DUP3 0BF2 61 PUSH2 0x0b4b 0BF5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BEC stack[0] = 0x00 // @0BEE stack[1] = 0x0bf6 // @0BF1 stack[2] = stack[-1] // } // Block ends with call to 0x0b4b, returns to 0x0BF6 label_0BF6: // Incoming return from call to 0x0B4B at 0x0BF5 // Inputs[2] // { // @0BF7 stack[-1] // @0BF7 stack[-3] // } 0BF6 5B JUMPDEST 0BF7 91 SWAP2 0BF8 50 POP 0BF9 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0C1A 82 DUP3 0C1B 14 EQ 0C1C 15 ISZERO 0C1D 61 PUSH2 0x0c29 0C20 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0BF7 stack[-3] = stack[-1] } // Block ends with conditional jump to 0x0c29, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_0C21: // Incoming jump from 0x0C20, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) 0C21 61 PUSH2 0x0c28 0C24 61 PUSH2 0x0c34 0C27 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C21 stack[0] = 0x0c28 } // Block ends with unconditional jump to 0x0c34 0C28 5B JUMPDEST label_0C29: // Incoming jump from 0x0C20, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @0C2C stack[-2] // @0C2E stack[-1] // @0C30 stack[-3] // } 0C29 5B JUMPDEST 0C2A 60 PUSH1 0x01 0C2C 82 DUP3 0C2D 01 ADD 0C2E 90 SWAP1 0C2F 50 POP 0C30 91 SWAP2 0C31 90 SWAP1 0C32 50 POP 0C33 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C30 stack[-3] = stack[-2] + 0x01 } // Block ends with unconditional jump to stack[-3] label_0C34: // Incoming jump from 0x0C27 // Inputs[1] { @0C62 memory[0x00:0x24] } 0C34 5B JUMPDEST 0C35 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0C56 60 PUSH1 0x00 0C58 52 MSTORE 0C59 60 PUSH1 0x11 0C5B 60 PUSH1 0x04 0C5D 52 MSTORE 0C5E 60 PUSH1 0x24 0C60 60 PUSH1 0x00 0C62 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C58 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0C5D memory[0x04:0x24] = 0x11 // @0C62 revert(memory[0x00:0x24]); // } // Block terminates label_0C63: // Incoming jump from 0x0BB2 // Inputs[1] { @0C91 memory[0x00:0x24] } 0C63 5B JUMPDEST 0C64 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0C85 60 PUSH1 0x00 0C87 52 MSTORE 0C88 60 PUSH1 0x22 0C8A 60 PUSH1 0x04 0C8C 52 MSTORE 0C8D 60 PUSH1 0x24 0C8F 60 PUSH1 0x00 0C91 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C87 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0C8C memory[0x04:0x24] = 0x22 // @0C91 revert(memory[0x00:0x24]); // } // Block terminates label_0C92: // Incoming jump from 0x0354 // Incoming jump from 0x036F // Inputs[1] { @0CC0 memory[0x00:0x24] } 0C92 5B JUMPDEST 0C93 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0CB4 60 PUSH1 0x00 0CB6 52 MSTORE 0CB7 60 PUSH1 0x32 0CB9 60 PUSH1 0x04 0CBB 52 MSTORE 0CBC 60 PUSH1 0x24 0CBE 60 PUSH1 0x00 0CC0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0CB6 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0CBB memory[0x04:0x24] = 0x32 // @0CC0 revert(memory[0x00:0x24]); // } // Block terminates label_0CC1: // Incoming jump from 0x0AB2 // Incoming jump from 0x0A86 // Incoming jump from 0x0BE0 // Inputs[1] { @0CEF memory[0x00:0x24] } 0CC1 5B JUMPDEST 0CC2 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0CE3 60 PUSH1 0x00 0CE5 52 MSTORE 0CE6 60 PUSH1 0x41 0CE8 60 PUSH1 0x04 0CEA 52 MSTORE 0CEB 60 PUSH1 0x24 0CED 60 PUSH1 0x00 0CEF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0CE5 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0CEA memory[0x04:0x24] = 0x41 // @0CEF revert(memory[0x00:0x24]); // } // Block terminates label_0CF0: // Incoming jump from 0x078D // Incoming jump from 0x07BB // Inputs[1] { @0CF4 memory[0x00:0x00] } 0CF0 5B JUMPDEST 0CF1 60 PUSH1 0x00 0CF3 80 DUP1 0CF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CF4 revert(memory[0x00:0x00]); } // Block terminates label_0CF5: // Incoming jump from 0x06A4 // Incoming jump from 0x0714 // Inputs[1] { @0CF9 memory[0x00:0x00] } 0CF5 5B JUMPDEST 0CF6 60 PUSH1 0x00 0CF8 80 DUP1 0CF9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CF9 revert(memory[0x00:0x00]); } // Block terminates label_0CFA: // Incoming jump from 0x08BA // Incoming jump from 0x088D // Inputs[1] { @0CFE memory[0x00:0x00] } 0CFA 5B JUMPDEST 0CFB 60 PUSH1 0x00 0CFD 80 DUP1 0CFE FD *REVERT // Stack delta = +0 // Outputs[1] { @0CFE revert(memory[0x00:0x00]); } // Block terminates label_0CFF: // Incoming jump from 0x0814 // Incoming jump from 0x0841 // Incoming jump from 0x08E6 // Incoming jump from 0x0913 // Incoming jump from 0x086F // Inputs[1] { @0D03 memory[0x00:0x00] } 0CFF 5B JUMPDEST 0D00 60 PUSH1 0x00 0D02 80 DUP1 0D03 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D03 revert(memory[0x00:0x00]); } // Block terminates label_0D04: // Incoming call from 0x0977, returns to 0x0978 // Incoming call from 0x0BC2, returns to 0x0BC3 // Inputs[2] // { // @0D0C stack[-1] // @0D11 stack[-2] // } 0D04 5B JUMPDEST 0D05 60 PUSH1 0x00 0D07 60 PUSH1 0x1f 0D09 19 NOT 0D0A 60 PUSH1 0x1f 0D0C 83 DUP4 0D0D 01 ADD 0D0E 16 AND 0D0F 90 SWAP1 0D10 50 POP 0D11 91 SWAP2 0D12 90 SWAP1 0D13 50 POP 0D14 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D11 stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_0D15: // Incoming call from 0x099A, returns to 0x099B // Inputs[2] // { // @0D39 stack[-1] // @0D63 stack[-2] // } 0D15 5B JUMPDEST 0D16 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0D37 60 PUSH1 0x00 0D39 82 DUP3 0D3A 01 ADD 0D3B 52 MSTORE 0D3C 7F PUSH32 0x726f206164647265737300000000000000000000000000000000000000000000 0D5D 60 PUSH1 0x20 0D5F 82 DUP3 0D60 01 ADD 0D61 52 MSTORE 0D62 50 POP 0D63 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0D3B memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0D61 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x726f206164647265737300000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_0D64: // Incoming call from 0x0773, returns to 0x0774 // Incoming call from 0x075E, returns to 0x075F // Inputs[1] { @0D68 stack[-1] } 0D64 5B JUMPDEST 0D65 61 PUSH2 0x0d6d 0D68 81 DUP2 0D69 61 PUSH2 0x0ae1 0D6C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D65 stack[0] = 0x0d6d // @0D68 stack[1] = stack[-1] // } // Block ends with call to 0x0ae1, returns to 0x0D6D label_0D6D: // Incoming return from call to 0x0AE1 at 0x0D6C // Inputs[2] // { // @0D6E stack[-2] // @0D6F stack[-1] // } 0D6D 5B JUMPDEST 0D6E 81 DUP2 0D6F 14 EQ 0D70 61 PUSH2 0x0d78 0D73 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d78, if stack[-2] == stack[-1] label_0D74: // Incoming jump from 0x0D73, if not stack[-2] == stack[-1] // Inputs[1] { @0D77 memory[0x00:0x00] } 0D74 60 PUSH1 0x00 0D76 80 DUP1 0D77 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D77 revert(memory[0x00:0x00]); } // Block terminates label_0D78: // Incoming jump from 0x0D73, if stack[-2] == stack[-1] // Inputs[1] { @0D7A stack[-2] } 0D78 5B JUMPDEST 0D79 50 POP 0D7A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0D7B: // Incoming call from 0x07E4, returns to 0x07E5 // Inputs[1] { @0D7F stack[-1] } 0D7B 5B JUMPDEST 0D7C 61 PUSH2 0x0d84 0D7F 81 DUP2 0D80 61 PUSH2 0x0aff 0D83 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D7C stack[0] = 0x0d84 // @0D7F stack[1] = stack[-1] // } // Block ends with call to 0x0aff, returns to 0x0D84 label_0D84: // Incoming return from call to 0x0AFF at 0x0D83 // Inputs[2] // { // @0D85 stack[-2] // @0D86 stack[-1] // } 0D84 5B JUMPDEST 0D85 81 DUP2 0D86 14 EQ 0D87 61 PUSH2 0x0d8f 0D8A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d8f, if stack[-2] == stack[-1] label_0D8B: // Incoming jump from 0x0D8A, if not stack[-2] == stack[-1] // Inputs[1] { @0D8E memory[0x00:0x00] } 0D8B 60 PUSH1 0x00 0D8D 80 DUP1 0D8E FD *REVERT // Stack delta = +0 // Outputs[1] { @0D8E revert(memory[0x00:0x00]); } // Block terminates label_0D8F: // Incoming jump from 0x0D8A, if stack[-2] == stack[-1] // Inputs[1] { @0D91 stack[-2] } 0D8F 5B JUMPDEST 0D90 50 POP 0D91 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0D92: // Incoming call from 0x07F9, returns to 0x07FA // Inputs[1] { @0D96 stack[-1] } 0D92 5B JUMPDEST 0D93 61 PUSH2 0x0d9b 0D96 81 DUP2 0D97 61 PUSH2 0x0b4b 0D9A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D93 stack[0] = 0x0d9b // @0D96 stack[1] = stack[-1] // } // Block ends with call to 0x0b4b, returns to 0x0D9B label_0D9B: // Incoming return from call to 0x0B4B at 0x0D9A // Inputs[2] // { // @0D9C stack[-2] // @0D9D stack[-1] // } 0D9B 5B JUMPDEST 0D9C 81 DUP2 0D9D 14 EQ 0D9E 61 PUSH2 0x0da6 0DA1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0da6, if stack[-2] == stack[-1] label_0DA2: // Incoming jump from 0x0DA1, if not stack[-2] == stack[-1] // Inputs[1] { @0DA5 memory[0x00:0x00] } 0DA2 60 PUSH1 0x00 0DA4 80 DUP1 0DA5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DA5 revert(memory[0x00:0x00]); } // Block terminates label_0DA6: // Incoming jump from 0x0DA1, if stack[-2] == stack[-1] // Inputs[1] { @0DA8 stack[-2] } 0DA6 5B JUMPDEST 0DA7 50 POP 0DA8 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 0DA9 FE *ASSERT 0DAA 68 PUSH9 0x747470733a2f2f6761 0DB4 74 PUSH21 0x657761792e70696e6174612e636c6f75642f697066 0DCA 73 PUSH20 0x2f516d62784c747759714841447465785a4b4d62 0DDF 61 PUSH2 0x3546 0DE2 75 PUSH22 0x4d62765538386d745169584e48313163416e55567347 0DF9 65 PUSH6 0x2f312e6a736f 0E00 6E PUSH15 0xa264697066735822122001a8b019ef 0E10 86 DUP7 0E11 B3 B3 0E12 8D DUP14 0E13 D0 D0 0E14 F2 CALLCODE 0E15 06 MOD 0E16 F8 F8 0E17 7D PUSH30 0x84a151534c35132f7a2b38f1772ea2b7268e6464736f6c63430008070033