Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x01d8 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01d8, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x8da5cb5b 0019 11 GT 001A 61 PUSH2 0x0102 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0102, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc30f4a5a 0024 11 GT 0025 61 PUSH2 0x0095 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0xc30f4a5a > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc30f4a5a > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xf2fde38b 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xf2fde38b > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xf2fde38b > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xf2fde38b 003A 14 EQ 003B 61 PUSH2 0x1282 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1282, if 0xf2fde38b == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xf2fde38b == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf42906ab 0045 14 EQ 0046 61 PUSH2 0x12d3 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12d3, if 0xf42906ab == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf42906ab == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf9ea1e58 0050 14 EQ 0051 61 PUSH2 0x1432 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1432, if 0xf9ea1e58 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf9ea1e58 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xfd73d81c 005B 14 EQ 005C 61 PUSH2 0x1923 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1923, if 0xfd73d81c == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xfd73d81c == stack[-1] 0060 61 PUSH2 0x01d8 0063 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_0064: // Incoming jump from 0x0033, if 0xf2fde38b > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xc30f4a5a 006B 14 EQ 006C 61 PUSH2 0x1026 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1026, if 0xc30f4a5a == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xc30f4a5a == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xc87b56dd 0076 14 EQ 0077 61 PUSH2 0x10ee 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ee, if 0xc87b56dd == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xc87b56dd == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xe985e9c5 0081 14 EQ 0082 61 PUSH2 0x11a2 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11a2, if 0xe985e9c5 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xea13cc34 008C 14 EQ 008D 61 PUSH2 0x122b 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x122b, if 0xea13cc34 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xea13cc34 == stack[-1] 0091 61 PUSH2 0x01d8 0094 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_0095: // Incoming jump from 0x0028, if 0xc30f4a5a > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0xa22cb465 009C 11 GT 009D 61 PUSH2 0x00d1 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0xa22cb465 > stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xa22cb465 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xa22cb465 00A7 14 EQ 00A8 61 PUSH2 0x0de4 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0de4, if 0xa22cb465 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xa65ff74c 00B2 14 EQ 00B3 61 PUSH2 0x0e41 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e41, if 0xa65ff74c == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xa65ff74c == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0xb784c966 00BD 14 EQ 00BE 61 PUSH2 0x0ec3 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ec3, if 0xb784c966 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xb784c966 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xb88d4fde 00C8 14 EQ 00C9 61 PUSH2 0x0f14 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f14, if 0xb88d4fde == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xb88d4fde == stack[-1] 00CD 61 PUSH2 0x01d8 00D0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_00D1: // Incoming jump from 0x00A0, if 0xa22cb465 > stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D1 5B JUMPDEST 00D2 80 DUP1 00D3 63 PUSH4 0x8da5cb5b 00D8 14 EQ 00D9 61 PUSH2 0x0b42 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b42, if 0x8da5cb5b == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x8f32d59b 00E3 14 EQ 00E4 61 PUSH2 0x0b99 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b99, if 0x8f32d59b == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x8f32d59b == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x95d89b41 00EE 14 EQ 00EF 61 PUSH2 0x0bc8 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bc8, if 0x95d89b41 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x9bdb6f80 00F9 14 EQ 00FA 61 PUSH2 0x0c58 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c58, if 0x9bdb6f80 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x9bdb6f80 == stack[-1] 00FE 61 PUSH2 0x01d8 0101 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_0102: // Incoming jump from 0x001D, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0103 stack[-1] } 0102 5B JUMPDEST 0103 80 DUP1 0104 63 PUSH4 0x3ee98482 0109 11 GT 010A 61 PUSH2 0x017a 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017a, if 0x3ee98482 > stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x3ee98482 > stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x70a08231 0114 11 GT 0115 61 PUSH2 0x0149 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0149, if 0x70a08231 > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x70a08231 > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x70a08231 011F 14 EQ 0120 61 PUSH2 0x0a0b 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0b, if 0x70a08231 == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x70a08231 == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x715018a6 012A 14 EQ 012B 61 PUSH2 0x0a70 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a70, if 0x715018a6 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x715018a6 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x78954d18 0135 14 EQ 0136 61 PUSH2 0x0a87 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a87, if 0x78954d18 == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x78954d18 == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x85fadf94 0140 14 EQ 0141 61 PUSH2 0x0b17 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b17, if 0x85fadf94 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x85fadf94 == stack[-1] 0145 61 PUSH2 0x01d8 0148 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_0149: // Incoming jump from 0x0118, if 0x70a08231 > stack[-1] // Inputs[1] { @014A stack[-1] } 0149 5B JUMPDEST 014A 80 DUP1 014B 63 PUSH4 0x3ee98482 0150 14 EQ 0151 61 PUSH2 0x0517 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0517, if 0x3ee98482 == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x3ee98482 == stack[-1] // Inputs[1] { @0155 stack[-1] } 0155 80 DUP1 0156 63 PUSH4 0x42842e0e 015B 14 EQ 015C 61 PUSH2 0x0789 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0789, if 0x42842e0e == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x42842e0e == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x44a9f184 0166 14 EQ 0167 61 PUSH2 0x0804 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0804, if 0x44a9f184 == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x44a9f184 == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x6352211e 0171 14 EQ 0172 61 PUSH2 0x0990 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0990, if 0x6352211e == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x6352211e == stack[-1] 0176 61 PUSH2 0x01d8 0179 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_017A: // Incoming jump from 0x010D, if 0x3ee98482 > stack[-1] // Inputs[1] { @017B stack[-1] } 017A 5B JUMPDEST 017B 80 DUP1 017C 63 PUSH4 0x081812fc 0181 11 GT 0182 61 PUSH2 0x01b6 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b6, if 0x081812fc > stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x081812fc > stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x081812fc 018C 14 EQ 018D 61 PUSH2 0x0336 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0336, if 0x081812fc == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x081812fc == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x095ea7b3 0197 14 EQ 0198 61 PUSH2 0x03b1 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b1, if 0x095ea7b3 == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x1f9dbb2c 01A2 14 EQ 01A3 61 PUSH2 0x040c 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040c, if 0x1f9dbb2c == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x1f9dbb2c == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x23b872dd 01AD 14 EQ 01AE 61 PUSH2 0x049c 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049c, if 0x23b872dd == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x23b872dd == stack[-1] 01B2 61 PUSH2 0x01d8 01B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01d8 label_01B6: // Incoming jump from 0x0185, if 0x081812fc > stack[-1] // Inputs[1] { @01B7 stack[-1] } 01B6 5B JUMPDEST 01B7 80 DUP1 01B8 63 PUSH4 0x01ffc9a7 01BD 14 EQ 01BE 61 PUSH2 0x01dd 01C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01dd, if 0x01ffc9a7 == stack[-1] label_01C2: // Incoming jump from 0x01C1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C2 80 DUP1 01C3 63 PUSH4 0x0605d6ae 01C8 14 EQ 01C9 61 PUSH2 0x024f 01CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024f, if 0x0605d6ae == stack[-1] label_01CD: // Incoming jump from 0x01CC, if not 0x0605d6ae == stack[-1] // Inputs[1] { @01CD stack[-1] } 01CD 80 DUP1 01CE 63 PUSH4 0x06fdde03 01D3 14 EQ 01D4 61 PUSH2 0x02a6 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a6, if 0x06fdde03 == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x06fdde03 == stack[-1] // Incoming jump from 0x0148 // Incoming jump from 0x01B5 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0101 // Incoming jump from 0x0063 // Incoming jump from 0x0094 // Incoming jump from 0x00D0 // Incoming jump from 0x0179 // Inputs[1] { @01DC memory[0x00:0x00] } 01D8 5B JUMPDEST 01D9 60 PUSH1 0x00 01DB 80 DUP1 01DC FD *REVERT // Stack delta = +0 // Outputs[1] { @01DC revert(memory[0x00:0x00]); } // Block terminates label_01DD: // Incoming jump from 0x01C1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01DE msg.value } 01DD 5B JUMPDEST 01DE 34 CALLVALUE 01DF 80 DUP1 01E0 15 ISZERO 01E1 61 PUSH2 0x01e9 01E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01DE stack[0] = msg.value } // Block ends with conditional jump to 0x01e9, if !msg.value label_01E5: // Incoming jump from 0x01E4, if not !msg.value // Inputs[1] { @01E8 memory[0x00:0x00] } 01E5 60 PUSH1 0x00 01E7 80 DUP1 01E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E8 revert(memory[0x00:0x00]); } // Block terminates label_01E9: // Incoming jump from 0x01E4, if !msg.value // Inputs[1] { @01F1 msg.data.length } 01E9 5B JUMPDEST 01EA 50 POP 01EB 61 PUSH2 0x0235 01EE 60 PUSH1 0x04 01F0 80 DUP1 01F1 36 CALLDATASIZE 01F2 03 SUB 01F3 60 PUSH1 0x20 01F5 81 DUP2 01F6 10 LT 01F7 15 ISZERO 01F8 61 PUSH2 0x0200 01FB 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01EB stack[-1] = 0x0235 // @01EE stack[0] = 0x04 // @01F2 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0200, returns to 0x0235, if !(msg.data.length - 0x04 < 0x20) label_01FC: // Incoming jump from 0x01FB, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01FF memory[0x00:0x00] } 01FC 60 PUSH1 0x00 01FE 80 DUP1 01FF FD *REVERT // Stack delta = +0 // Outputs[1] { @01FF revert(memory[0x00:0x00]); } // Block terminates label_0200: // Incoming call from 0x01FB, returns to 0x0235, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0201 stack[-2] // @0202 stack[-1] // @0206 msg.data[stack[-2]:stack[-2] + 0x20] // } 0200 5B JUMPDEST 0201 81 DUP2 0202 01 ADD 0203 90 SWAP1 0204 80 DUP1 0205 80 DUP1 0206 35 CALLDATALOAD 0207 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0224 19 NOT 0225 16 AND 0226 90 SWAP1 0227 60 PUSH1 0x20 0229 01 ADD 022A 90 SWAP1 022B 92 SWAP3 022C 91 SWAP2 022D 90 SWAP1 022E 50 POP 022F 50 POP 0230 50 POP 0231 61 PUSH2 0x19b3 0234 56 *JUMP // Stack delta = -1 // Outputs[1] { @022B stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x19b3 label_0235: // Incoming return from call to 0x0200 at 0x01FB // Inputs[4] // { // @0238 memory[0x40:0x60] // @023A stack[-1] // @0249 memory[0x40:0x60] // @024E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0235 5B JUMPDEST 0236 60 PUSH1 0x40 0238 51 MLOAD 0239 80 DUP1 023A 82 DUP3 023B 15 ISZERO 023C 15 ISZERO 023D 15 ISZERO 023E 15 ISZERO 023F 81 DUP2 0240 52 MSTORE 0241 60 PUSH1 0x20 0243 01 ADD 0244 91 SWAP2 0245 50 POP 0246 50 POP 0247 60 PUSH1 0x40 0249 51 MLOAD 024A 80 DUP1 024B 91 SWAP2 024C 03 SUB 024D 90 SWAP1 024E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0240 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @024E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_024F: // Incoming jump from 0x01CC, if 0x0605d6ae == stack[-1] // Inputs[1] { @0250 msg.value } 024F 5B JUMPDEST 0250 34 CALLVALUE 0251 80 DUP1 0252 15 ISZERO 0253 61 PUSH2 0x025b 0256 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0250 stack[0] = msg.value } // Block ends with conditional jump to 0x025b, if !msg.value label_0257: // Incoming jump from 0x0256, if not !msg.value // Inputs[1] { @025A memory[0x00:0x00] } 0257 60 PUSH1 0x00 0259 80 DUP1 025A FD *REVERT // Stack delta = +0 // Outputs[1] { @025A revert(memory[0x00:0x00]); } // Block terminates label_025B: // Incoming jump from 0x0256, if !msg.value 025B 5B JUMPDEST 025C 50 POP 025D 61 PUSH2 0x0264 0260 61 PUSH2 0x1a1a 0263 56 *JUMP // Stack delta = +0 // Outputs[1] { @025D stack[-1] = 0x0264 } // Block ends with call to 0x1a1a, returns to 0x0264 label_0264: // Incoming return from call to 0x1A1A at 0x0263 // Inputs[4] // { // @0267 memory[0x40:0x60] // @0269 stack[-1] // @02A0 memory[0x40:0x60] // @02A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0264 5B JUMPDEST 0265 60 PUSH1 0x40 0267 51 MLOAD 0268 80 DUP1 0269 82 DUP3 026A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 027F 16 AND 0280 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0295 16 AND 0296 81 DUP2 0297 52 MSTORE 0298 60 PUSH1 0x20 029A 01 ADD 029B 91 SWAP2 029C 50 POP 029D 50 POP 029E 60 PUSH1 0x40 02A0 51 MLOAD 02A1 80 DUP1 02A2 91 SWAP2 02A3 03 SUB 02A4 90 SWAP1 02A5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0297 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @02A5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02A6: // Incoming jump from 0x01D7, if 0x06fdde03 == stack[-1] // Inputs[1] { @02A7 msg.value } 02A6 5B JUMPDEST 02A7 34 CALLVALUE 02A8 80 DUP1 02A9 15 ISZERO 02AA 61 PUSH2 0x02b2 02AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A7 stack[0] = msg.value } // Block ends with conditional jump to 0x02b2, if !msg.value label_02AE: // Incoming jump from 0x02AD, if not !msg.value // Inputs[1] { @02B1 memory[0x00:0x00] } 02AE 60 PUSH1 0x00 02B0 80 DUP1 02B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B1 revert(memory[0x00:0x00]); } // Block terminates label_02B2: // Incoming jump from 0x02AD, if !msg.value 02B2 5B JUMPDEST 02B3 50 POP 02B4 61 PUSH2 0x02bb 02B7 61 PUSH2 0x1a40 02BA 56 *JUMP // Stack delta = +0 // Outputs[1] { @02B4 stack[-1] = 0x02bb } // Block ends with call to 0x1a40, returns to 0x02BB label_02BB: // Incoming return from call to 0x1A40 at 0x02BA // Inputs[4] // { // @02BE memory[0x40:0x60] // @02C9 stack[-1] // @02CC memory[stack[-1]:stack[-1] + 0x20] // @02D5 memory[stack[-1]:stack[-1] + 0x20] // } 02BB 5B JUMPDEST 02BC 60 PUSH1 0x40 02BE 51 MLOAD 02BF 80 DUP1 02C0 80 DUP1 02C1 60 PUSH1 0x20 02C3 01 ADD 02C4 82 DUP3 02C5 81 DUP2 02C6 03 SUB 02C7 82 DUP3 02C8 52 MSTORE 02C9 83 DUP4 02CA 81 DUP2 02CB 81 DUP2 02CC 51 MLOAD 02CD 81 DUP2 02CE 52 MSTORE 02CF 60 PUSH1 0x20 02D1 01 ADD 02D2 91 SWAP2 02D3 50 POP 02D4 80 DUP1 02D5 51 MLOAD 02D6 90 SWAP1 02D7 60 PUSH1 0x20 02D9 01 ADD 02DA 90 SWAP1 02DB 80 DUP1 02DC 83 DUP4 02DD 83 DUP4 02DE 60 PUSH1 0x00 02E0 5B JUMPDEST 02E1 83 DUP4 02E2 81 DUP2 02E3 10 LT 02E4 15 ISZERO 02E5 61 PUSH2 0x02fb 02E8 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @02BE stack[0] = memory[0x40:0x60] // @02BF stack[1] = memory[0x40:0x60] // @02C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @02CE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02D2 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @02DA stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02DA stack[3] = 0x20 + stack[-1] // @02DB stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @02DC stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @02DD stack[7] = 0x20 + stack[-1] // @02DE stack[8] = 0x00 // } // Block ends with conditional jump to 0x02fb, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_02E9: // Incoming jump from 0x02E8, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x02E8, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @02E9 stack[-1] // @02EA stack[-2] // @02EC memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02EE stack[-3] // } 02E9 80 DUP1 02EA 82 DUP3 02EB 01 ADD 02EC 51 MLOAD 02ED 81 DUP2 02EE 84 DUP5 02EF 01 ADD 02F0 52 MSTORE 02F1 60 PUSH1 0x20 02F3 81 DUP2 02F4 01 ADD 02F5 90 SWAP1 02F6 50 POP 02F7 61 PUSH2 0x02e0 02FA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02F0 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @02F5 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x02e0 label_02FB: // Incoming jump from 0x02E8, if !(stack[-1] < stack[-4]) // Incoming jump from 0x02E8, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0300 stack[-5] // @0300 stack[-6] // @0302 stack[-7] // } 02FB 5B JUMPDEST 02FC 50 POP 02FD 50 POP 02FE 50 POP 02FF 50 POP 0300 90 SWAP1 0301 50 POP 0302 90 SWAP1 0303 81 DUP2 0304 01 ADD 0305 90 SWAP1 0306 60 PUSH1 0x1f 0308 16 AND 0309 80 DUP1 030A 15 ISZERO 030B 61 PUSH2 0x0328 030E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0305 stack[-7] = stack[-5] + stack[-7] // @0308 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0328, if !(0x1f & stack[-5]) label_030F: // Incoming jump from 0x030E, if not !(0x1f & stack[-5]) // Inputs[6] // { // @030F stack[-1] // @0310 stack[-2] // @0313 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @032A stack[-5] // @0330 memory[0x40:0x60] // @0335 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 030F 80 DUP1 0310 82 DUP3 0311 03 SUB 0312 80 DUP1 0313 51 MLOAD 0314 60 PUSH1 0x01 0316 83 DUP4 0317 60 PUSH1 0x20 0319 03 SUB 031A 61 PUSH2 0x0100 031D 0A EXP 031E 03 SUB 031F 19 NOT 0320 16 AND 0321 81 DUP2 0322 52 MSTORE 0323 60 PUSH1 0x20 0325 01 ADD 0326 91 SWAP2 0327 50 POP 0328 5B JUMPDEST 0329 50 POP 032A 92 SWAP3 032B 50 POP 032C 50 POP 032D 50 POP 032E 60 PUSH1 0x40 0330 51 MLOAD 0331 80 DUP1 0332 91 SWAP2 0333 03 SUB 0334 90 SWAP1 0335 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0322 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0335 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0336: // Incoming jump from 0x0190, if 0x081812fc == stack[-1] // Inputs[1] { @0337 msg.value } 0336 5B JUMPDEST 0337 34 CALLVALUE 0338 80 DUP1 0339 15 ISZERO 033A 61 PUSH2 0x0342 033D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0337 stack[0] = msg.value } // Block ends with conditional jump to 0x0342, if !msg.value label_033E: // Incoming jump from 0x033D, if not !msg.value // Inputs[1] { @0341 memory[0x00:0x00] } 033E 60 PUSH1 0x00 0340 80 DUP1 0341 FD *REVERT // Stack delta = +0 // Outputs[1] { @0341 revert(memory[0x00:0x00]); } // Block terminates label_0342: // Incoming jump from 0x033D, if !msg.value // Inputs[1] { @034A msg.data.length } 0342 5B JUMPDEST 0343 50 POP 0344 61 PUSH2 0x036f 0347 60 PUSH1 0x04 0349 80 DUP1 034A 36 CALLDATASIZE 034B 03 SUB 034C 60 PUSH1 0x20 034E 81 DUP2 034F 10 LT 0350 15 ISZERO 0351 61 PUSH2 0x0359 0354 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0344 stack[-1] = 0x036f // @0347 stack[0] = 0x04 // @034B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0359, returns to 0x036F, if !(msg.data.length - 0x04 < 0x20) label_0355: // Incoming jump from 0x0354, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0358 memory[0x00:0x00] } 0355 60 PUSH1 0x00 0357 80 DUP1 0358 FD *REVERT // Stack delta = +0 // Outputs[1] { @0358 revert(memory[0x00:0x00]); } // Block terminates label_0359: // Incoming call from 0x0354, returns to 0x036F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @035A stack[-2] // @035B stack[-1] // @035F msg.data[stack[-2]:stack[-2] + 0x20] // } 0359 5B JUMPDEST 035A 81 DUP2 035B 01 ADD 035C 90 SWAP1 035D 80 DUP1 035E 80 DUP1 035F 35 CALLDATALOAD 0360 90 SWAP1 0361 60 PUSH1 0x20 0363 01 ADD 0364 90 SWAP1 0365 92 SWAP3 0366 91 SWAP2 0367 90 SWAP1 0368 50 POP 0369 50 POP 036A 50 POP 036B 61 PUSH2 0x1ae2 036E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0365 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1ae2 label_036F: // Incoming return from call to 0x0359 at 0x0354 // Inputs[4] // { // @0372 memory[0x40:0x60] // @0374 stack[-1] // @03AB memory[0x40:0x60] // @03B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 036F 5B JUMPDEST 0370 60 PUSH1 0x40 0372 51 MLOAD 0373 80 DUP1 0374 82 DUP3 0375 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 038A 16 AND 038B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03A0 16 AND 03A1 81 DUP2 03A2 52 MSTORE 03A3 60 PUSH1 0x20 03A5 01 ADD 03A6 91 SWAP2 03A7 50 POP 03A8 50 POP 03A9 60 PUSH1 0x40 03AB 51 MLOAD 03AC 80 DUP1 03AD 91 SWAP2 03AE 03 SUB 03AF 90 SWAP1 03B0 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @03B0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03B1: // Incoming jump from 0x019B, if 0x095ea7b3 == stack[-1] // Inputs[1] { @03B2 msg.value } 03B1 5B JUMPDEST 03B2 34 CALLVALUE 03B3 80 DUP1 03B4 15 ISZERO 03B5 61 PUSH2 0x03bd 03B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B2 stack[0] = msg.value } // Block ends with conditional jump to 0x03bd, if !msg.value label_03B9: // Incoming jump from 0x03B8, if not !msg.value // Inputs[1] { @03BC memory[0x00:0x00] } 03B9 60 PUSH1 0x00 03BB 80 DUP1 03BC FD *REVERT // Stack delta = +0 // Outputs[1] { @03BC revert(memory[0x00:0x00]); } // Block terminates label_03BD: // Incoming jump from 0x03B8, if !msg.value // Inputs[1] { @03C5 msg.data.length } 03BD 5B JUMPDEST 03BE 50 POP 03BF 61 PUSH2 0x040a 03C2 60 PUSH1 0x04 03C4 80 DUP1 03C5 36 CALLDATASIZE 03C6 03 SUB 03C7 60 PUSH1 0x40 03C9 81 DUP2 03CA 10 LT 03CB 15 ISZERO 03CC 61 PUSH2 0x03d4 03CF 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03BF stack[-1] = 0x040a // @03C2 stack[0] = 0x04 // @03C6 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03d4, returns to 0x040A, if !(msg.data.length - 0x04 < 0x40) label_03D0: // Incoming jump from 0x03CF, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03D3 memory[0x00:0x00] } 03D0 60 PUSH1 0x00 03D2 80 DUP1 03D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D3 revert(memory[0x00:0x00]); } // Block terminates label_03D4: // Incoming call from 0x03CF, returns to 0x040A, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03D5 stack[-2] // @03D6 stack[-1] // @03DA msg.data[stack[-2]:stack[-2] + 0x20] // @03FA msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03D4 5B JUMPDEST 03D5 81 DUP2 03D6 01 ADD 03D7 90 SWAP1 03D8 80 DUP1 03D9 80 DUP1 03DA 35 CALLDATALOAD 03DB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03F0 16 AND 03F1 90 SWAP1 03F2 60 PUSH1 0x20 03F4 01 ADD 03F5 90 SWAP1 03F6 92 SWAP3 03F7 91 SWAP2 03F8 90 SWAP1 03F9 80 DUP1 03FA 35 CALLDATALOAD 03FB 90 SWAP1 03FC 60 PUSH1 0x20 03FE 01 ADD 03FF 90 SWAP1 0400 92 SWAP3 0401 91 SWAP2 0402 90 SWAP1 0403 50 POP 0404 50 POP 0405 50 POP 0406 61 PUSH2 0x1b7d 0409 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03F6 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0400 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1b7d label_040A: // Incoming return from call to 0x03D4 at 0x03CF 040A 5B JUMPDEST 040B 00 *STOP // Stack delta = +0 // Outputs[1] { @040B stop(); } // Block terminates label_040C: // Incoming jump from 0x01A6, if 0x1f9dbb2c == stack[-1] // Inputs[1] { @040D msg.value } 040C 5B JUMPDEST 040D 34 CALLVALUE 040E 80 DUP1 040F 15 ISZERO 0410 61 PUSH2 0x0418 0413 57 *JUMPI // Stack delta = +1 // Outputs[1] { @040D stack[0] = msg.value } // Block ends with conditional jump to 0x0418, if !msg.value label_0414: // Incoming jump from 0x0413, if not !msg.value // Inputs[1] { @0417 memory[0x00:0x00] } 0414 60 PUSH1 0x00 0416 80 DUP1 0417 FD *REVERT // Stack delta = +0 // Outputs[1] { @0417 revert(memory[0x00:0x00]); } // Block terminates label_0418: // Incoming jump from 0x0413, if !msg.value 0418 5B JUMPDEST 0419 50 POP 041A 61 PUSH2 0x0421 041D 61 PUSH2 0x1d64 0420 56 *JUMP // Stack delta = +0 // Outputs[1] { @041A stack[-1] = 0x0421 } // Block ends with call to 0x1d64, returns to 0x0421 label_0421: // Incoming return from call to 0x1D64 at 0x0420 // Inputs[4] // { // @0424 memory[0x40:0x60] // @042F stack[-1] // @0432 memory[stack[-1]:stack[-1] + 0x20] // @043B memory[stack[-1]:stack[-1] + 0x20] // } 0421 5B JUMPDEST 0422 60 PUSH1 0x40 0424 51 MLOAD 0425 80 DUP1 0426 80 DUP1 0427 60 PUSH1 0x20 0429 01 ADD 042A 82 DUP3 042B 81 DUP2 042C 03 SUB 042D 82 DUP3 042E 52 MSTORE 042F 83 DUP4 0430 81 DUP2 0431 81 DUP2 0432 51 MLOAD 0433 81 DUP2 0434 52 MSTORE 0435 60 PUSH1 0x20 0437 01 ADD 0438 91 SWAP2 0439 50 POP 043A 80 DUP1 043B 51 MLOAD 043C 90 SWAP1 043D 60 PUSH1 0x20 043F 01 ADD 0440 90 SWAP1 0441 80 DUP1 0442 83 DUP4 0443 83 DUP4 0444 60 PUSH1 0x00 0446 5B JUMPDEST 0447 83 DUP4 0448 81 DUP2 0449 10 LT 044A 15 ISZERO 044B 61 PUSH2 0x0461 044E 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0424 stack[0] = memory[0x40:0x60] // @0425 stack[1] = memory[0x40:0x60] // @042E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0434 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0438 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0440 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0440 stack[3] = 0x20 + stack[-1] // @0441 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0442 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0443 stack[7] = 0x20 + stack[-1] // @0444 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0461, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_044F: // Incoming jump from 0x044E, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x044E, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @044F stack[-1] // @0450 stack[-2] // @0452 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0454 stack[-3] // } 044F 80 DUP1 0450 82 DUP3 0451 01 ADD 0452 51 MLOAD 0453 81 DUP2 0454 84 DUP5 0455 01 ADD 0456 52 MSTORE 0457 60 PUSH1 0x20 0459 81 DUP2 045A 01 ADD 045B 90 SWAP1 045C 50 POP 045D 61 PUSH2 0x0446 0460 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0456 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @045B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0446 label_0461: // Incoming jump from 0x044E, if !(stack[-1] < stack[-4]) // Incoming jump from 0x044E, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0466 stack[-5] // @0466 stack[-6] // @0468 stack[-7] // } 0461 5B JUMPDEST 0462 50 POP 0463 50 POP 0464 50 POP 0465 50 POP 0466 90 SWAP1 0467 50 POP 0468 90 SWAP1 0469 81 DUP2 046A 01 ADD 046B 90 SWAP1 046C 60 PUSH1 0x1f 046E 16 AND 046F 80 DUP1 0470 15 ISZERO 0471 61 PUSH2 0x048e 0474 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @046B stack[-7] = stack[-5] + stack[-7] // @046E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x048e, if !(0x1f & stack[-5]) label_0475: // Incoming jump from 0x0474, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0475 stack[-1] // @0476 stack[-2] // @0479 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0490 stack[-5] // @0496 memory[0x40:0x60] // @049B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0475 80 DUP1 0476 82 DUP3 0477 03 SUB 0478 80 DUP1 0479 51 MLOAD 047A 60 PUSH1 0x01 047C 83 DUP4 047D 60 PUSH1 0x20 047F 03 SUB 0480 61 PUSH2 0x0100 0483 0A EXP 0484 03 SUB 0485 19 NOT 0486 16 AND 0487 81 DUP2 0488 52 MSTORE 0489 60 PUSH1 0x20 048B 01 ADD 048C 91 SWAP2 048D 50 POP 048E 5B JUMPDEST 048F 50 POP 0490 92 SWAP3 0491 50 POP 0492 50 POP 0493 50 POP 0494 60 PUSH1 0x40 0496 51 MLOAD 0497 80 DUP1 0498 91 SWAP2 0499 03 SUB 049A 90 SWAP1 049B F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0488 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @049B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_049C: // Incoming jump from 0x01B1, if 0x23b872dd == stack[-1] // Inputs[1] { @049D msg.value } 049C 5B JUMPDEST 049D 34 CALLVALUE 049E 80 DUP1 049F 15 ISZERO 04A0 61 PUSH2 0x04a8 04A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049D stack[0] = msg.value } // Block ends with conditional jump to 0x04a8, if !msg.value label_04A4: // Incoming jump from 0x04A3, if not !msg.value // Inputs[1] { @04A7 memory[0x00:0x00] } 04A4 60 PUSH1 0x00 04A6 80 DUP1 04A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A7 revert(memory[0x00:0x00]); } // Block terminates label_04A8: // Incoming jump from 0x04A3, if !msg.value // Inputs[1] { @04B0 msg.data.length } 04A8 5B JUMPDEST 04A9 50 POP 04AA 61 PUSH2 0x0515 04AD 60 PUSH1 0x04 04AF 80 DUP1 04B0 36 CALLDATASIZE 04B1 03 SUB 04B2 60 PUSH1 0x60 04B4 81 DUP2 04B5 10 LT 04B6 15 ISZERO 04B7 61 PUSH2 0x04bf 04BA 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04AA stack[-1] = 0x0515 // @04AD stack[0] = 0x04 // @04B1 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04bf, returns to 0x0515, if !(msg.data.length - 0x04 < 0x60) label_04BB: // Incoming jump from 0x04BA, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @04BE memory[0x00:0x00] } 04BB 60 PUSH1 0x00 04BD 80 DUP1 04BE FD *REVERT // Stack delta = +0 // Outputs[1] { @04BE revert(memory[0x00:0x00]); } // Block terminates label_04BF: // Incoming call from 0x04BA, returns to 0x0515, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @04C0 stack[-2] // @04C1 stack[-1] // @04C5 msg.data[stack[-2]:stack[-2] + 0x20] // @04E5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0505 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 04BF 5B JUMPDEST 04C0 81 DUP2 04C1 01 ADD 04C2 90 SWAP1 04C3 80 DUP1 04C4 80 DUP1 04C5 35 CALLDATALOAD 04C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04DB 16 AND 04DC 90 SWAP1 04DD 60 PUSH1 0x20 04DF 01 ADD 04E0 90 SWAP1 04E1 92 SWAP3 04E2 91 SWAP2 04E3 90 SWAP1 04E4 80 DUP1 04E5 35 CALLDATALOAD 04E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04FB 16 AND 04FC 90 SWAP1 04FD 60 PUSH1 0x20 04FF 01 ADD 0500 90 SWAP1 0501 92 SWAP3 0502 91 SWAP2 0503 90 SWAP1 0504 80 DUP1 0505 35 CALLDATALOAD 0506 90 SWAP1 0507 60 PUSH1 0x20 0509 01 ADD 050A 90 SWAP1 050B 92 SWAP3 050C 91 SWAP2 050D 90 SWAP1 050E 50 POP 050F 50 POP 0510 50 POP 0511 61 PUSH2 0x1e02 0514 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @04E1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0501 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @050B stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1e02 label_0515: // Incoming return from call to 0x04BF at 0x04BA 0515 5B JUMPDEST 0516 00 *STOP // Stack delta = +0 // Outputs[1] { @0516 stop(); } // Block terminates label_0517: // Incoming jump from 0x0154, if 0x3ee98482 == stack[-1] // Inputs[1] { @0518 msg.value } 0517 5B JUMPDEST 0518 34 CALLVALUE 0519 80 DUP1 051A 15 ISZERO 051B 61 PUSH2 0x0523 051E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0518 stack[0] = msg.value } // Block ends with conditional jump to 0x0523, if !msg.value label_051F: // Incoming jump from 0x051E, if not !msg.value // Inputs[1] { @0522 memory[0x00:0x00] } 051F 60 PUSH1 0x00 0521 80 DUP1 0522 FD *REVERT // Stack delta = +0 // Outputs[1] { @0522 revert(memory[0x00:0x00]); } // Block terminates label_0523: // Incoming jump from 0x051E, if !msg.value // Inputs[1] { @052B msg.data.length } 0523 5B JUMPDEST 0524 50 POP 0525 61 PUSH2 0x0550 0528 60 PUSH1 0x04 052A 80 DUP1 052B 36 CALLDATASIZE 052C 03 SUB 052D 60 PUSH1 0x20 052F 81 DUP2 0530 10 LT 0531 15 ISZERO 0532 61 PUSH2 0x053a 0535 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0525 stack[-1] = 0x0550 // @0528 stack[0] = 0x04 // @052C stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x053a, returns to 0x0550, if !(msg.data.length - 0x04 < 0x20) label_0536: // Incoming jump from 0x0535, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0539 memory[0x00:0x00] } 0536 60 PUSH1 0x00 0538 80 DUP1 0539 FD *REVERT // Stack delta = +0 // Outputs[1] { @0539 revert(memory[0x00:0x00]); } // Block terminates label_053A: // Incoming call from 0x0535, returns to 0x0550, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @053B stack[-2] // @053C stack[-1] // @0540 msg.data[stack[-2]:stack[-2] + 0x20] // } 053A 5B JUMPDEST 053B 81 DUP2 053C 01 ADD 053D 90 SWAP1 053E 80 DUP1 053F 80 DUP1 0540 35 CALLDATALOAD 0541 90 SWAP1 0542 60 PUSH1 0x20 0544 01 ADD 0545 90 SWAP1 0546 92 SWAP3 0547 91 SWAP2 0548 90 SWAP1 0549 50 POP 054A 50 POP 054B 50 POP 054C 61 PUSH2 0x1e78 054F 56 *JUMP // Stack delta = -1 // Outputs[1] { @0546 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1e78 label_0550: // Incoming return from call to 0x053A at 0x0535 // Inputs[6] // { // @0553 memory[0x40:0x60] // @0569 stack[-2] // @056F stack[-1] // @057A stack[-7] // @057D memory[stack[-7]:stack[-7] + 0x20] // @0586 memory[stack[-7]:stack[-7] + 0x20] // } 0550 5B JUMPDEST 0551 60 PUSH1 0x40 0553 51 MLOAD 0554 80 DUP1 0555 80 DUP1 0556 60 PUSH1 0x20 0558 01 ADD 0559 80 DUP1 055A 60 PUSH1 0x20 055C 01 ADD 055D 80 DUP1 055E 60 PUSH1 0x20 0560 01 ADD 0561 80 DUP1 0562 60 PUSH1 0x20 0564 01 ADD 0565 80 DUP1 0566 60 PUSH1 0x20 0568 01 ADD 0569 88 DUP9 056A 81 DUP2 056B 52 MSTORE 056C 60 PUSH1 0x20 056E 01 ADD 056F 87 DUP8 0570 81 DUP2 0571 52 MSTORE 0572 60 PUSH1 0x20 0574 01 ADD 0575 86 DUP7 0576 81 DUP2 0577 03 SUB 0578 86 DUP7 0579 52 MSTORE 057A 8D DUP14 057B 81 DUP2 057C 81 DUP2 057D 51 MLOAD 057E 81 DUP2 057F 52 MSTORE 0580 60 PUSH1 0x20 0582 01 ADD 0583 91 SWAP2 0584 50 POP 0585 80 DUP1 0586 51 MLOAD 0587 90 SWAP1 0588 60 PUSH1 0x20 058A 01 ADD 058B 90 SWAP1 058C 80 DUP1 058D 83 DUP4 058E 83 DUP4 058F 60 PUSH1 0x00 0591 5B JUMPDEST 0592 83 DUP4 0593 81 DUP2 0594 10 LT 0595 15 ISZERO 0596 61 PUSH2 0x05ac 0599 57 *JUMPI // Stack delta = +13 // Outputs[17] // { // @0553 stack[0] = memory[0x40:0x60] // @0554 stack[1] = memory[0x40:0x60] // @0558 stack[2] = 0x20 + memory[0x40:0x60] // @055C stack[3] = 0x20 + 0x20 + memory[0x40:0x60] // @0560 stack[4] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0564 stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @056B memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-2] // @0571 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @0579 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @057F memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-7]:stack[-7] + 0x20] // @0583 stack[6] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @058B stack[8] = memory[stack[-7]:stack[-7] + 0x20] // @058B stack[7] = 0x20 + stack[-7] // @058C stack[9] = memory[stack[-7]:stack[-7] + 0x20] // @058D stack[10] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @058E stack[11] = 0x20 + stack[-7] // @058F stack[12] = 0x00 // } // Block ends with conditional jump to 0x05ac, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) label_059A: // Incoming jump from 0x0599, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0599, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[4] // { // @059A stack[-1] // @059B stack[-2] // @059D memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @059F stack[-3] // } 059A 80 DUP1 059B 82 DUP3 059C 01 ADD 059D 51 MLOAD 059E 81 DUP2 059F 84 DUP5 05A0 01 ADD 05A1 52 MSTORE 05A2 60 PUSH1 0x20 05A4 81 DUP2 05A5 01 ADD 05A6 90 SWAP1 05A7 50 POP 05A8 61 PUSH2 0x0591 05AB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @05A1 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @05A6 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0591 label_05AC: // Incoming jump from 0x0599, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0599, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[3] // { // @05B1 stack[-5] // @05B1 stack[-6] // @05B3 stack[-7] // } 05AC 5B JUMPDEST 05AD 50 POP 05AE 50 POP 05AF 50 POP 05B0 50 POP 05B1 90 SWAP1 05B2 50 POP 05B3 90 SWAP1 05B4 81 DUP2 05B5 01 ADD 05B6 90 SWAP1 05B7 60 PUSH1 0x1f 05B9 16 AND 05BA 80 DUP1 05BB 15 ISZERO 05BC 61 PUSH2 0x05d9 05BF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @05B6 stack[-7] = stack[-5] + stack[-7] // @05B9 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x05d9, if !(0x1f & stack[-5]) label_05C0: // Incoming jump from 0x05BF, if not !(0x1f & stack[-5]) // Inputs[8] // { // @05C0 stack[-1] // @05C1 stack[-2] // @05C4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @05DB stack[-8] // @05DE stack[-6] // @05E0 stack[-14] // @05E3 memory[stack[-14]:stack[-14] + 0x20] // @05EC memory[stack[-14]:stack[-14] + 0x20] // } 05C0 80 DUP1 05C1 82 DUP3 05C2 03 SUB 05C3 80 DUP1 05C4 51 MLOAD 05C5 60 PUSH1 0x01 05C7 83 DUP4 05C8 60 PUSH1 0x20 05CA 03 SUB 05CB 61 PUSH2 0x0100 05CE 0A EXP 05CF 03 SUB 05D0 19 NOT 05D1 16 AND 05D2 81 DUP2 05D3 52 MSTORE 05D4 60 PUSH1 0x20 05D6 01 ADD 05D7 91 SWAP2 05D8 50 POP 05D9 5B JUMPDEST 05DA 50 POP 05DB 86 DUP7 05DC 81 DUP2 05DD 03 SUB 05DE 85 DUP6 05DF 52 MSTORE 05E0 8C DUP13 05E1 81 DUP2 05E2 81 DUP2 05E3 51 MLOAD 05E4 81 DUP2 05E5 52 MSTORE 05E6 60 PUSH1 0x20 05E8 01 ADD 05E9 91 SWAP2 05EA 50 POP 05EB 80 DUP1 05EC 51 MLOAD 05ED 90 SWAP1 05EE 60 PUSH1 0x20 05F0 01 ADD 05F1 90 SWAP1 05F2 80 DUP1 05F3 83 DUP4 05F4 83 DUP4 05F5 60 PUSH1 0x00 05F7 5B JUMPDEST 05F8 83 DUP4 05F9 81 DUP2 05FA 10 LT 05FB 15 ISZERO 05FC 61 PUSH2 0x0612 05FF 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @05D3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @05DF memory[stack[-6]:stack[-6] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-8] // @05E5 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-14]:stack[-14] + 0x20] // @05E9 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @05F1 stack[-1] = 0x20 + stack[-14] // @05F1 stack[0] = memory[stack[-14]:stack[-14] + 0x20] // @05F2 stack[1] = memory[stack[-14]:stack[-14] + 0x20] // @05F3 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @05F4 stack[3] = 0x20 + stack[-14] // @05F5 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0612, if !(0x00 < memory[stack[-14]:stack[-14] + 0x20]) label_0600: // Incoming jump from 0x05FF, if not !(0x00 < memory[stack[-14]:stack[-14] + 0x20]) // Incoming jump from 0x05FF, if not !(0x00 < memory[stack[-14]:stack[-14] + 0x20]) // Incoming jump from 0x05FF, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0600 stack[-1] // @0601 stack[-2] // @0603 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0605 stack[-3] // } 0600 80 DUP1 0601 82 DUP3 0602 01 ADD 0603 51 MLOAD 0604 81 DUP2 0605 84 DUP5 0606 01 ADD 0607 52 MSTORE 0608 60 PUSH1 0x20 060A 81 DUP2 060B 01 ADD 060C 90 SWAP1 060D 50 POP 060E 61 PUSH2 0x05f7 0611 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0607 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @060C stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x05f7 label_0612: // Incoming jump from 0x05FF, if !(0x00 < memory[stack[-14]:stack[-14] + 0x20]) // Incoming jump from 0x05FF, if !(0x00 < memory[stack[-14]:stack[-14] + 0x20]) // Incoming jump from 0x05FF, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0617 stack[-5] // @0617 stack[-6] // @0619 stack[-7] // } 0612 5B JUMPDEST 0613 50 POP 0614 50 POP 0615 50 POP 0616 50 POP 0617 90 SWAP1 0618 50 POP 0619 90 SWAP1 061A 81 DUP2 061B 01 ADD 061C 90 SWAP1 061D 60 PUSH1 0x1f 061F 16 AND 0620 80 DUP1 0621 15 ISZERO 0622 61 PUSH2 0x063f 0625 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @061C stack[-7] = stack[-5] + stack[-7] // @061F stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x063f, if !(0x1f & stack[-5]) label_0626: // Incoming jump from 0x0625, if not !(0x1f & stack[-5]) // Inputs[8] // { // @0626 stack[-1] // @0627 stack[-2] // @062A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0641 stack[-8] // @0644 stack[-5] // @0646 stack[-13] // @0649 memory[stack[-13]:stack[-13] + 0x20] // @0652 memory[stack[-13]:stack[-13] + 0x20] // } 0626 80 DUP1 0627 82 DUP3 0628 03 SUB 0629 80 DUP1 062A 51 MLOAD 062B 60 PUSH1 0x01 062D 83 DUP4 062E 60 PUSH1 0x20 0630 03 SUB 0631 61 PUSH2 0x0100 0634 0A EXP 0635 03 SUB 0636 19 NOT 0637 16 AND 0638 81 DUP2 0639 52 MSTORE 063A 60 PUSH1 0x20 063C 01 ADD 063D 91 SWAP2 063E 50 POP 063F 5B JUMPDEST 0640 50 POP 0641 86 DUP7 0642 81 DUP2 0643 03 SUB 0644 84 DUP5 0645 52 MSTORE 0646 8B DUP12 0647 81 DUP2 0648 81 DUP2 0649 51 MLOAD 064A 81 DUP2 064B 52 MSTORE 064C 60 PUSH1 0x20 064E 01 ADD 064F 91 SWAP2 0650 50 POP 0651 80 DUP1 0652 51 MLOAD 0653 90 SWAP1 0654 60 PUSH1 0x20 0656 01 ADD 0657 90 SWAP1 0658 80 DUP1 0659 83 DUP4 065A 83 DUP4 065B 60 PUSH1 0x00 065D 5B JUMPDEST 065E 83 DUP4 065F 81 DUP2 0660 10 LT 0661 15 ISZERO 0662 61 PUSH2 0x0678 0665 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0639 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0645 memory[stack[-5]:stack[-5] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-8] // @064B memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-13]:stack[-13] + 0x20] // @064F stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0657 stack[-1] = 0x20 + stack[-13] // @0657 stack[0] = memory[stack[-13]:stack[-13] + 0x20] // @0658 stack[1] = memory[stack[-13]:stack[-13] + 0x20] // @0659 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @065A stack[3] = 0x20 + stack[-13] // @065B stack[4] = 0x00 // } // Block ends with conditional jump to 0x0678, if !(0x00 < memory[stack[-13]:stack[-13] + 0x20]) label_0666: // Incoming jump from 0x0665, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0665, if not !(0x00 < memory[stack[-13]:stack[-13] + 0x20]) // Incoming jump from 0x0665, if not !(0x00 < memory[stack[-13]:stack[-13] + 0x20]) // Inputs[4] // { // @0666 stack[-1] // @0667 stack[-2] // @0669 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @066B stack[-3] // } 0666 80 DUP1 0667 82 DUP3 0668 01 ADD 0669 51 MLOAD 066A 81 DUP2 066B 84 DUP5 066C 01 ADD 066D 52 MSTORE 066E 60 PUSH1 0x20 0670 81 DUP2 0671 01 ADD 0672 90 SWAP1 0673 50 POP 0674 61 PUSH2 0x065d 0677 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @066D memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0672 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x065d label_0678: // Incoming jump from 0x0665, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0665, if !(0x00 < memory[stack[-13]:stack[-13] + 0x20]) // Incoming jump from 0x0665, if !(0x00 < memory[stack[-13]:stack[-13] + 0x20]) // Inputs[3] // { // @067D stack[-5] // @067D stack[-6] // @067F stack[-7] // } 0678 5B JUMPDEST 0679 50 POP 067A 50 POP 067B 50 POP 067C 50 POP 067D 90 SWAP1 067E 50 POP 067F 90 SWAP1 0680 81 DUP2 0681 01 ADD 0682 90 SWAP1 0683 60 PUSH1 0x1f 0685 16 AND 0686 80 DUP1 0687 15 ISZERO 0688 61 PUSH2 0x06a5 068B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0682 stack[-7] = stack[-5] + stack[-7] // @0685 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x06a5, if !(0x1f & stack[-5]) label_068C: // Incoming jump from 0x068B, if not !(0x1f & stack[-5]) // Inputs[8] // { // @068C stack[-1] // @068D stack[-2] // @0690 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @06A7 stack[-8] // @06AA stack[-4] // @06AC stack[-12] // @06AF memory[stack[-12]:stack[-12] + 0x20] // @06B8 memory[stack[-12]:stack[-12] + 0x20] // } 068C 80 DUP1 068D 82 DUP3 068E 03 SUB 068F 80 DUP1 0690 51 MLOAD 0691 60 PUSH1 0x01 0693 83 DUP4 0694 60 PUSH1 0x20 0696 03 SUB 0697 61 PUSH2 0x0100 069A 0A EXP 069B 03 SUB 069C 19 NOT 069D 16 AND 069E 81 DUP2 069F 52 MSTORE 06A0 60 PUSH1 0x20 06A2 01 ADD 06A3 91 SWAP2 06A4 50 POP 06A5 5B JUMPDEST 06A6 50 POP 06A7 86 DUP7 06A8 81 DUP2 06A9 03 SUB 06AA 83 DUP4 06AB 52 MSTORE 06AC 8A DUP11 06AD 81 DUP2 06AE 81 DUP2 06AF 51 MLOAD 06B0 81 DUP2 06B1 52 MSTORE 06B2 60 PUSH1 0x20 06B4 01 ADD 06B5 91 SWAP2 06B6 50 POP 06B7 80 DUP1 06B8 51 MLOAD 06B9 90 SWAP1 06BA 60 PUSH1 0x20 06BC 01 ADD 06BD 90 SWAP1 06BE 80 DUP1 06BF 83 DUP4 06C0 83 DUP4 06C1 60 PUSH1 0x00 06C3 5B JUMPDEST 06C4 83 DUP4 06C5 81 DUP2 06C6 10 LT 06C7 15 ISZERO 06C8 61 PUSH2 0x06de 06CB 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @069F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @06AB memory[stack[-4]:stack[-4] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-8] // @06B1 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-12]:stack[-12] + 0x20] // @06B5 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @06BD stack[-1] = 0x20 + stack[-12] // @06BD stack[0] = memory[stack[-12]:stack[-12] + 0x20] // @06BE stack[1] = memory[stack[-12]:stack[-12] + 0x20] // @06BF stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @06C0 stack[3] = 0x20 + stack[-12] // @06C1 stack[4] = 0x00 // } // Block ends with conditional jump to 0x06de, if !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) label_06CC: // Incoming jump from 0x06CB, if not !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) // Incoming jump from 0x06CB, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x06CB, if not !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) // Inputs[4] // { // @06CC stack[-1] // @06CD stack[-2] // @06CF memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @06D1 stack[-3] // } 06CC 80 DUP1 06CD 82 DUP3 06CE 01 ADD 06CF 51 MLOAD 06D0 81 DUP2 06D1 84 DUP5 06D2 01 ADD 06D3 52 MSTORE 06D4 60 PUSH1 0x20 06D6 81 DUP2 06D7 01 ADD 06D8 90 SWAP1 06D9 50 POP 06DA 61 PUSH2 0x06c3 06DD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06D3 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @06D8 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x06c3 label_06DE: // Incoming jump from 0x06CB, if !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) // Incoming jump from 0x06CB, if !(stack[-1] < stack[-4]) // Incoming jump from 0x06CB, if !(0x00 < memory[stack[-12]:stack[-12] + 0x20]) // Inputs[3] // { // @06E3 stack[-5] // @06E3 stack[-6] // @06E5 stack[-7] // } 06DE 5B JUMPDEST 06DF 50 POP 06E0 50 POP 06E1 50 POP 06E2 50 POP 06E3 90 SWAP1 06E4 50 POP 06E5 90 SWAP1 06E6 81 DUP2 06E7 01 ADD 06E8 90 SWAP1 06E9 60 PUSH1 0x1f 06EB 16 AND 06EC 80 DUP1 06ED 15 ISZERO 06EE 61 PUSH2 0x070b 06F1 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @06E8 stack[-7] = stack[-5] + stack[-7] // @06EB stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x070b, if !(0x1f & stack[-5]) label_06F2: // Incoming jump from 0x06F1, if not !(0x1f & stack[-5]) // Inputs[8] // { // @06F2 stack[-1] // @06F3 stack[-2] // @06F6 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @070D stack[-8] // @0710 stack[-3] // @0712 stack[-11] // @0715 memory[stack[-11]:stack[-11] + 0x20] // @071E memory[stack[-11]:stack[-11] + 0x20] // } 06F2 80 DUP1 06F3 82 DUP3 06F4 03 SUB 06F5 80 DUP1 06F6 51 MLOAD 06F7 60 PUSH1 0x01 06F9 83 DUP4 06FA 60 PUSH1 0x20 06FC 03 SUB 06FD 61 PUSH2 0x0100 0700 0A EXP 0701 03 SUB 0702 19 NOT 0703 16 AND 0704 81 DUP2 0705 52 MSTORE 0706 60 PUSH1 0x20 0708 01 ADD 0709 91 SWAP2 070A 50 POP 070B 5B JUMPDEST 070C 50 POP 070D 86 DUP7 070E 81 DUP2 070F 03 SUB 0710 82 DUP3 0711 52 MSTORE 0712 89 DUP10 0713 81 DUP2 0714 81 DUP2 0715 51 MLOAD 0716 81 DUP2 0717 52 MSTORE 0718 60 PUSH1 0x20 071A 01 ADD 071B 91 SWAP2 071C 50 POP 071D 80 DUP1 071E 51 MLOAD 071F 90 SWAP1 0720 60 PUSH1 0x20 0722 01 ADD 0723 90 SWAP1 0724 80 DUP1 0725 83 DUP4 0726 83 DUP4 0727 60 PUSH1 0x00 0729 5B JUMPDEST 072A 83 DUP4 072B 81 DUP2 072C 10 LT 072D 15 ISZERO 072E 61 PUSH2 0x0744 0731 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0705 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0711 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-8] // @0717 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-11]:stack[-11] + 0x20] // @071B stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0723 stack[-1] = 0x20 + stack[-11] // @0723 stack[0] = memory[stack[-11]:stack[-11] + 0x20] // @0724 stack[1] = memory[stack[-11]:stack[-11] + 0x20] // @0725 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0726 stack[3] = 0x20 + stack[-11] // @0727 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0744, if !(0x00 < memory[stack[-11]:stack[-11] + 0x20]) label_0732: // Incoming jump from 0x0731, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0731, if not !(0x00 < memory[stack[-11]:stack[-11] + 0x20]) // Incoming jump from 0x0731, if not !(0x00 < memory[stack[-11]:stack[-11] + 0x20]) // Inputs[4] // { // @0732 stack[-1] // @0733 stack[-2] // @0735 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0737 stack[-3] // } 0732 80 DUP1 0733 82 DUP3 0734 01 ADD 0735 51 MLOAD 0736 81 DUP2 0737 84 DUP5 0738 01 ADD 0739 52 MSTORE 073A 60 PUSH1 0x20 073C 81 DUP2 073D 01 ADD 073E 90 SWAP1 073F 50 POP 0740 61 PUSH2 0x0729 0743 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0739 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @073E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0729 label_0744: // Incoming jump from 0x0731, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0731, if !(0x00 < memory[stack[-11]:stack[-11] + 0x20]) // Incoming jump from 0x0731, if !(0x00 < memory[stack[-11]:stack[-11] + 0x20]) // Inputs[3] // { // @0749 stack[-6] // @0749 stack[-5] // @074B stack[-7] // } 0744 5B JUMPDEST 0745 50 POP 0746 50 POP 0747 50 POP 0748 50 POP 0749 90 SWAP1 074A 50 POP 074B 90 SWAP1 074C 81 DUP2 074D 01 ADD 074E 90 SWAP1 074F 60 PUSH1 0x1f 0751 16 AND 0752 80 DUP1 0753 15 ISZERO 0754 61 PUSH2 0x0771 0757 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @074E stack[-7] = stack[-5] + stack[-7] // @0751 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0771, if !(0x1f & stack[-5]) label_0758: // Incoming jump from 0x0757, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0758 stack[-1] // @0759 stack[-2] // @075C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0773 stack[-15] // @0783 memory[0x40:0x60] // @0788 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0758 80 DUP1 0759 82 DUP3 075A 03 SUB 075B 80 DUP1 075C 51 MLOAD 075D 60 PUSH1 0x01 075F 83 DUP4 0760 60 PUSH1 0x20 0762 03 SUB 0763 61 PUSH2 0x0100 0766 0A EXP 0767 03 SUB 0768 19 NOT 0769 16 AND 076A 81 DUP2 076B 52 MSTORE 076C 60 PUSH1 0x20 076E 01 ADD 076F 91 SWAP2 0770 50 POP 0771 5B JUMPDEST 0772 50 POP 0773 9C SWAP13 0774 50 POP 0775 50 POP 0776 50 POP 0777 50 POP 0778 50 POP 0779 50 POP 077A 50 POP 077B 50 POP 077C 50 POP 077D 50 POP 077E 50 POP 077F 50 POP 0780 50 POP 0781 60 PUSH1 0x40 0783 51 MLOAD 0784 80 DUP1 0785 91 SWAP2 0786 03 SUB 0787 90 SWAP1 0788 F3 *RETURN // Stack delta = -15 // Outputs[2] // { // @076B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0788 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0789: // Incoming jump from 0x015F, if 0x42842e0e == stack[-1] // Inputs[1] { @078A msg.value } 0789 5B JUMPDEST 078A 34 CALLVALUE 078B 80 DUP1 078C 15 ISZERO 078D 61 PUSH2 0x0795 0790 57 *JUMPI // Stack delta = +1 // Outputs[1] { @078A stack[0] = msg.value } // Block ends with conditional jump to 0x0795, if !msg.value label_0791: // Incoming jump from 0x0790, if not !msg.value // Inputs[1] { @0794 memory[0x00:0x00] } 0791 60 PUSH1 0x00 0793 80 DUP1 0794 FD *REVERT // Stack delta = +0 // Outputs[1] { @0794 revert(memory[0x00:0x00]); } // Block terminates label_0795: // Incoming jump from 0x0790, if !msg.value // Inputs[1] { @079D msg.data.length } 0795 5B JUMPDEST 0796 50 POP 0797 61 PUSH2 0x0802 079A 60 PUSH1 0x04 079C 80 DUP1 079D 36 CALLDATASIZE 079E 03 SUB 079F 60 PUSH1 0x60 07A1 81 DUP2 07A2 10 LT 07A3 15 ISZERO 07A4 61 PUSH2 0x07ac 07A7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0797 stack[-1] = 0x0802 // @079A stack[0] = 0x04 // @079E stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x07ac, returns to 0x0802, if !(msg.data.length - 0x04 < 0x60) label_07A8: // Incoming jump from 0x07A7, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @07AB memory[0x00:0x00] } 07A8 60 PUSH1 0x00 07AA 80 DUP1 07AB FD *REVERT // Stack delta = +0 // Outputs[1] { @07AB revert(memory[0x00:0x00]); } // Block terminates label_07AC: // Incoming call from 0x07A7, returns to 0x0802, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @07AD stack[-2] // @07AE stack[-1] // @07B2 msg.data[stack[-2]:stack[-2] + 0x20] // @07D2 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @07F2 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 07AC 5B JUMPDEST 07AD 81 DUP2 07AE 01 ADD 07AF 90 SWAP1 07B0 80 DUP1 07B1 80 DUP1 07B2 35 CALLDATALOAD 07B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C8 16 AND 07C9 90 SWAP1 07CA 60 PUSH1 0x20 07CC 01 ADD 07CD 90 SWAP1 07CE 92 SWAP3 07CF 91 SWAP2 07D0 90 SWAP1 07D1 80 DUP1 07D2 35 CALLDATALOAD 07D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07E8 16 AND 07E9 90 SWAP1 07EA 60 PUSH1 0x20 07EC 01 ADD 07ED 90 SWAP1 07EE 92 SWAP3 07EF 91 SWAP2 07F0 90 SWAP1 07F1 80 DUP1 07F2 35 CALLDATALOAD 07F3 90 SWAP1 07F4 60 PUSH1 0x20 07F6 01 ADD 07F7 90 SWAP1 07F8 92 SWAP3 07F9 91 SWAP2 07FA 90 SWAP1 07FB 50 POP 07FC 50 POP 07FD 50 POP 07FE 61 PUSH2 0x2220 0801 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @07CE stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @07EE stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @07F8 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2220 label_0802: // Incoming return from call to 0x07AC at 0x07A7 0802 5B JUMPDEST 0803 00 *STOP // Stack delta = +0 // Outputs[1] { @0803 stop(); } // Block terminates label_0804: // Incoming jump from 0x016A, if 0x44a9f184 == stack[-1] // Inputs[1] { @0805 msg.value } 0804 5B JUMPDEST 0805 34 CALLVALUE 0806 80 DUP1 0807 15 ISZERO 0808 61 PUSH2 0x0810 080B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0805 stack[0] = msg.value } // Block ends with conditional jump to 0x0810, if !msg.value label_080C: // Incoming jump from 0x080B, if not !msg.value // Inputs[1] { @080F memory[0x00:0x00] } 080C 60 PUSH1 0x00 080E 80 DUP1 080F FD *REVERT // Stack delta = +0 // Outputs[1] { @080F revert(memory[0x00:0x00]); } // Block terminates label_0810: // Incoming jump from 0x080B, if !msg.value // Inputs[1] { @0818 msg.data.length } 0810 5B JUMPDEST 0811 50 POP 0812 61 PUSH2 0x083d 0815 60 PUSH1 0x04 0817 80 DUP1 0818 36 CALLDATASIZE 0819 03 SUB 081A 60 PUSH1 0x20 081C 81 DUP2 081D 10 LT 081E 15 ISZERO 081F 61 PUSH2 0x0827 0822 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0812 stack[-1] = 0x083d // @0815 stack[0] = 0x04 // @0819 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0827, returns to 0x083D, if !(msg.data.length - 0x04 < 0x20) label_0823: // Incoming jump from 0x0822, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0826 memory[0x00:0x00] } 0823 60 PUSH1 0x00 0825 80 DUP1 0826 FD *REVERT // Stack delta = +0 // Outputs[1] { @0826 revert(memory[0x00:0x00]); } // Block terminates label_0827: // Incoming call from 0x0822, returns to 0x083D, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0828 stack[-2] // @0829 stack[-1] // @082D msg.data[stack[-2]:stack[-2] + 0x20] // } 0827 5B JUMPDEST 0828 81 DUP2 0829 01 ADD 082A 90 SWAP1 082B 80 DUP1 082C 80 DUP1 082D 35 CALLDATALOAD 082E 90 SWAP1 082F 60 PUSH1 0x20 0831 01 ADD 0832 90 SWAP1 0833 92 SWAP3 0834 91 SWAP2 0835 90 SWAP1 0836 50 POP 0837 50 POP 0838 50 POP 0839 61 PUSH2 0x2240 083C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0833 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2240 label_083D: // Incoming return from call to 0x0827 at 0x0822 // Inputs[4] // { // @0840 memory[0x40:0x60] // @0853 stack[-3] // @0856 memory[stack[-3]:stack[-3] + 0x20] // @085F memory[stack[-3]:stack[-3] + 0x20] // } 083D 5B JUMPDEST 083E 60 PUSH1 0x40 0840 51 MLOAD 0841 80 DUP1 0842 80 DUP1 0843 60 PUSH1 0x20 0845 01 ADD 0846 80 DUP1 0847 60 PUSH1 0x20 0849 01 ADD 084A 80 DUP1 084B 60 PUSH1 0x20 084D 01 ADD 084E 84 DUP5 084F 81 DUP2 0850 03 SUB 0851 84 DUP5 0852 52 MSTORE 0853 87 DUP8 0854 81 DUP2 0855 81 DUP2 0856 51 MLOAD 0857 81 DUP2 0858 52 MSTORE 0859 60 PUSH1 0x20 085B 01 ADD 085C 91 SWAP2 085D 50 POP 085E 80 DUP1 085F 51 MLOAD 0860 90 SWAP1 0861 60 PUSH1 0x20 0863 01 ADD 0864 90 SWAP1 0865 80 DUP1 0866 83 DUP4 0867 83 DUP4 0868 60 PUSH1 0x00 086A 5B JUMPDEST 086B 83 DUP4 086C 81 DUP2 086D 10 LT 086E 15 ISZERO 086F 61 PUSH2 0x0885 0872 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @0840 stack[0] = memory[0x40:0x60] // @0841 stack[1] = memory[0x40:0x60] // @0845 stack[2] = 0x20 + memory[0x40:0x60] // @0849 stack[3] = 0x20 + 0x20 + memory[0x40:0x60] // @0852 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0858 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @085C stack[4] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0864 stack[5] = 0x20 + stack[-3] // @0864 stack[6] = memory[stack[-3]:stack[-3] + 0x20] // @0865 stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @0866 stack[8] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0867 stack[9] = 0x20 + stack[-3] // @0868 stack[10] = 0x00 // } // Block ends with conditional jump to 0x0885, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_0873: // Incoming jump from 0x0872, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0872, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0873 stack[-1] // @0874 stack[-2] // @0876 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0878 stack[-3] // } 0873 80 DUP1 0874 82 DUP3 0875 01 ADD 0876 51 MLOAD 0877 81 DUP2 0878 84 DUP5 0879 01 ADD 087A 52 MSTORE 087B 60 PUSH1 0x20 087D 81 DUP2 087E 01 ADD 087F 90 SWAP1 0880 50 POP 0881 61 PUSH2 0x086a 0884 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @087A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @087F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x086a label_0885: // Incoming jump from 0x0872, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0872, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @088A stack[-6] // @088A stack[-5] // @088C stack[-7] // } 0885 5B JUMPDEST 0886 50 POP 0887 50 POP 0888 50 POP 0889 50 POP 088A 90 SWAP1 088B 50 POP 088C 90 SWAP1 088D 81 DUP2 088E 01 ADD 088F 90 SWAP1 0890 60 PUSH1 0x1f 0892 16 AND 0893 80 DUP1 0894 15 ISZERO 0895 61 PUSH2 0x08b2 0898 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @088F stack[-7] = stack[-5] + stack[-7] // @0892 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x08b2, if !(0x1f & stack[-5]) label_0899: // Incoming jump from 0x0898, if not !(0x1f & stack[-5]) // Inputs[8] // { // @0899 stack[-1] // @089A stack[-2] // @089D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @08B4 stack[-6] // @08B7 stack[-4] // @08B9 stack[-8] // @08BC memory[stack[-8]:stack[-8] + 0x20] // @08C5 memory[stack[-8]:stack[-8] + 0x20] // } 0899 80 DUP1 089A 82 DUP3 089B 03 SUB 089C 80 DUP1 089D 51 MLOAD 089E 60 PUSH1 0x01 08A0 83 DUP4 08A1 60 PUSH1 0x20 08A3 03 SUB 08A4 61 PUSH2 0x0100 08A7 0A EXP 08A8 03 SUB 08A9 19 NOT 08AA 16 AND 08AB 81 DUP2 08AC 52 MSTORE 08AD 60 PUSH1 0x20 08AF 01 ADD 08B0 91 SWAP2 08B1 50 POP 08B2 5B JUMPDEST 08B3 50 POP 08B4 84 DUP5 08B5 81 DUP2 08B6 03 SUB 08B7 83 DUP4 08B8 52 MSTORE 08B9 86 DUP7 08BA 81 DUP2 08BB 81 DUP2 08BC 51 MLOAD 08BD 81 DUP2 08BE 52 MSTORE 08BF 60 PUSH1 0x20 08C1 01 ADD 08C2 91 SWAP2 08C3 50 POP 08C4 80 DUP1 08C5 51 MLOAD 08C6 90 SWAP1 08C7 60 PUSH1 0x20 08C9 01 ADD 08CA 90 SWAP1 08CB 80 DUP1 08CC 83 DUP4 08CD 83 DUP4 08CE 60 PUSH1 0x00 08D0 5B JUMPDEST 08D1 83 DUP4 08D2 81 DUP2 08D3 10 LT 08D4 15 ISZERO 08D5 61 PUSH2 0x08eb 08D8 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @08AC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @08B8 memory[stack[-4]:stack[-4] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-6] // @08BE memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-8]:stack[-8] + 0x20] // @08C2 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @08CA stack[-1] = 0x20 + stack[-8] // @08CA stack[0] = memory[stack[-8]:stack[-8] + 0x20] // @08CB stack[1] = memory[stack[-8]:stack[-8] + 0x20] // @08CC stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @08CD stack[3] = 0x20 + stack[-8] // @08CE stack[4] = 0x00 // } // Block ends with conditional jump to 0x08eb, if !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) label_08D9: // Incoming jump from 0x08D8, if not !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Incoming jump from 0x08D8, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x08D8, if not !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[4] // { // @08D9 stack[-1] // @08DA stack[-2] // @08DC memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @08DE stack[-3] // } 08D9 80 DUP1 08DA 82 DUP3 08DB 01 ADD 08DC 51 MLOAD 08DD 81 DUP2 08DE 84 DUP5 08DF 01 ADD 08E0 52 MSTORE 08E1 60 PUSH1 0x20 08E3 81 DUP2 08E4 01 ADD 08E5 90 SWAP1 08E6 50 POP 08E7 61 PUSH2 0x08d0 08EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08E0 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @08E5 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x08d0 label_08EB: // Incoming jump from 0x08D8, if !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Incoming jump from 0x08D8, if !(stack[-1] < stack[-4]) // Incoming jump from 0x08D8, if !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[3] // { // @08F0 stack[-6] // @08F0 stack[-5] // @08F2 stack[-7] // } 08EB 5B JUMPDEST 08EC 50 POP 08ED 50 POP 08EE 50 POP 08EF 50 POP 08F0 90 SWAP1 08F1 50 POP 08F2 90 SWAP1 08F3 81 DUP2 08F4 01 ADD 08F5 90 SWAP1 08F6 60 PUSH1 0x1f 08F8 16 AND 08F9 80 DUP1 08FA 15 ISZERO 08FB 61 PUSH2 0x0918 08FE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @08F5 stack[-7] = stack[-5] + stack[-7] // @08F8 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0918, if !(0x1f & stack[-5]) label_08FF: // Incoming jump from 0x08FE, if not !(0x1f & stack[-5]) // Inputs[8] // { // @08FF stack[-1] // @0900 stack[-2] // @0903 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @091A stack[-6] // @091D stack[-3] // @091F stack[-7] // @0922 memory[stack[-7]:stack[-7] + 0x20] // @092B memory[stack[-7]:stack[-7] + 0x20] // } 08FF 80 DUP1 0900 82 DUP3 0901 03 SUB 0902 80 DUP1 0903 51 MLOAD 0904 60 PUSH1 0x01 0906 83 DUP4 0907 60 PUSH1 0x20 0909 03 SUB 090A 61 PUSH2 0x0100 090D 0A EXP 090E 03 SUB 090F 19 NOT 0910 16 AND 0911 81 DUP2 0912 52 MSTORE 0913 60 PUSH1 0x20 0915 01 ADD 0916 91 SWAP2 0917 50 POP 0918 5B JUMPDEST 0919 50 POP 091A 84 DUP5 091B 81 DUP2 091C 03 SUB 091D 82 DUP3 091E 52 MSTORE 091F 85 DUP6 0920 81 DUP2 0921 81 DUP2 0922 51 MLOAD 0923 81 DUP2 0924 52 MSTORE 0925 60 PUSH1 0x20 0927 01 ADD 0928 91 SWAP2 0929 50 POP 092A 80 DUP1 092B 51 MLOAD 092C 90 SWAP1 092D 60 PUSH1 0x20 092F 01 ADD 0930 90 SWAP1 0931 80 DUP1 0932 83 DUP4 0933 83 DUP4 0934 60 PUSH1 0x00 0936 5B JUMPDEST 0937 83 DUP4 0938 81 DUP2 0939 10 LT 093A 15 ISZERO 093B 61 PUSH2 0x0951 093E 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0912 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @091E memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-6] // @0924 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-7]:stack[-7] + 0x20] // @0928 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0930 stack[-1] = 0x20 + stack[-7] // @0930 stack[0] = memory[stack[-7]:stack[-7] + 0x20] // @0931 stack[1] = memory[stack[-7]:stack[-7] + 0x20] // @0932 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0933 stack[3] = 0x20 + stack[-7] // @0934 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0951, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) label_093F: // Incoming jump from 0x093E, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x093E, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x093E, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[4] // { // @093F stack[-1] // @0940 stack[-2] // @0942 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0944 stack[-3] // } 093F 80 DUP1 0940 82 DUP3 0941 01 ADD 0942 51 MLOAD 0943 81 DUP2 0944 84 DUP5 0945 01 ADD 0946 52 MSTORE 0947 60 PUSH1 0x20 0949 81 DUP2 094A 01 ADD 094B 90 SWAP1 094C 50 POP 094D 61 PUSH2 0x0936 0950 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0946 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @094B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0936 label_0951: // Incoming jump from 0x093E, if !(stack[-1] < stack[-4]) // Incoming jump from 0x093E, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x093E, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[3] // { // @0956 stack[-6] // @0956 stack[-5] // @0958 stack[-7] // } 0951 5B JUMPDEST 0952 50 POP 0953 50 POP 0954 50 POP 0955 50 POP 0956 90 SWAP1 0957 50 POP 0958 90 SWAP1 0959 81 DUP2 095A 01 ADD 095B 90 SWAP1 095C 60 PUSH1 0x1f 095E 16 AND 095F 80 DUP1 0960 15 ISZERO 0961 61 PUSH2 0x097e 0964 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @095B stack[-7] = stack[-5] + stack[-7] // @095E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x097e, if !(0x1f & stack[-5]) label_0965: // Incoming jump from 0x0964, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0965 stack[-1] // @0966 stack[-2] // @0969 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0980 stack[-9] // @098A memory[0x40:0x60] // @098F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0965 80 DUP1 0966 82 DUP3 0967 03 SUB 0968 80 DUP1 0969 51 MLOAD 096A 60 PUSH1 0x01 096C 83 DUP4 096D 60 PUSH1 0x20 096F 03 SUB 0970 61 PUSH2 0x0100 0973 0A EXP 0974 03 SUB 0975 19 NOT 0976 16 AND 0977 81 DUP2 0978 52 MSTORE 0979 60 PUSH1 0x20 097B 01 ADD 097C 91 SWAP2 097D 50 POP 097E 5B JUMPDEST 097F 50 POP 0980 96 SWAP7 0981 50 POP 0982 50 POP 0983 50 POP 0984 50 POP 0985 50 POP 0986 50 POP 0987 50 POP 0988 60 PUSH1 0x40 098A 51 MLOAD 098B 80 DUP1 098C 91 SWAP2 098D 03 SUB 098E 90 SWAP1 098F F3 *RETURN // Stack delta = -9 // Outputs[2] // { // @0978 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @098F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0990: // Incoming jump from 0x0175, if 0x6352211e == stack[-1] // Inputs[1] { @0991 msg.value } 0990 5B JUMPDEST 0991 34 CALLVALUE 0992 80 DUP1 0993 15 ISZERO 0994 61 PUSH2 0x099c 0997 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0991 stack[0] = msg.value } // Block ends with conditional jump to 0x099c, if !msg.value label_0998: // Incoming jump from 0x0997, if not !msg.value // Inputs[1] { @099B memory[0x00:0x00] } 0998 60 PUSH1 0x00 099A 80 DUP1 099B FD *REVERT // Stack delta = +0 // Outputs[1] { @099B revert(memory[0x00:0x00]); } // Block terminates label_099C: // Incoming jump from 0x0997, if !msg.value // Inputs[1] { @09A4 msg.data.length } 099C 5B JUMPDEST 099D 50 POP 099E 61 PUSH2 0x09c9 09A1 60 PUSH1 0x04 09A3 80 DUP1 09A4 36 CALLDATASIZE 09A5 03 SUB 09A6 60 PUSH1 0x20 09A8 81 DUP2 09A9 10 LT 09AA 15 ISZERO 09AB 61 PUSH2 0x09b3 09AE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @099E stack[-1] = 0x09c9 // @09A1 stack[0] = 0x04 // @09A5 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09b3, returns to 0x09C9, if !(msg.data.length - 0x04 < 0x20) label_09AF: // Incoming jump from 0x09AE, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @09B2 memory[0x00:0x00] } 09AF 60 PUSH1 0x00 09B1 80 DUP1 09B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @09B2 revert(memory[0x00:0x00]); } // Block terminates label_09B3: // Incoming call from 0x09AE, returns to 0x09C9, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @09B4 stack[-2] // @09B5 stack[-1] // @09B9 msg.data[stack[-2]:stack[-2] + 0x20] // } 09B3 5B JUMPDEST 09B4 81 DUP2 09B5 01 ADD 09B6 90 SWAP1 09B7 80 DUP1 09B8 80 DUP1 09B9 35 CALLDATALOAD 09BA 90 SWAP1 09BB 60 PUSH1 0x20 09BD 01 ADD 09BE 90 SWAP1 09BF 92 SWAP3 09C0 91 SWAP2 09C1 90 SWAP1 09C2 50 POP 09C3 50 POP 09C4 50 POP 09C5 61 PUSH2 0x2456 09C8 56 *JUMP // Stack delta = -1 // Outputs[1] { @09BF stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2456 label_09C9: // Incoming return from call to 0x09B3 at 0x09AE // Inputs[4] // { // @09CC memory[0x40:0x60] // @09CE stack[-1] // @0A05 memory[0x40:0x60] // @0A0A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09C9 5B JUMPDEST 09CA 60 PUSH1 0x40 09CC 51 MLOAD 09CD 80 DUP1 09CE 82 DUP3 09CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09E4 16 AND 09E5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09FA 16 AND 09FB 81 DUP2 09FC 52 MSTORE 09FD 60 PUSH1 0x20 09FF 01 ADD 0A00 91 SWAP2 0A01 50 POP 0A02 50 POP 0A03 60 PUSH1 0x40 0A05 51 MLOAD 0A06 80 DUP1 0A07 91 SWAP2 0A08 03 SUB 0A09 90 SWAP1 0A0A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @09FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A0A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A0B: // Incoming jump from 0x0123, if 0x70a08231 == stack[-1] // Inputs[1] { @0A0C msg.value } 0A0B 5B JUMPDEST 0A0C 34 CALLVALUE 0A0D 80 DUP1 0A0E 15 ISZERO 0A0F 61 PUSH2 0x0a17 0A12 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A0C stack[0] = msg.value } // Block ends with conditional jump to 0x0a17, if !msg.value label_0A13: // Incoming jump from 0x0A12, if not !msg.value // Inputs[1] { @0A16 memory[0x00:0x00] } 0A13 60 PUSH1 0x00 0A15 80 DUP1 0A16 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A16 revert(memory[0x00:0x00]); } // Block terminates label_0A17: // Incoming jump from 0x0A12, if !msg.value // Inputs[1] { @0A1F msg.data.length } 0A17 5B JUMPDEST 0A18 50 POP 0A19 61 PUSH2 0x0a5a 0A1C 60 PUSH1 0x04 0A1E 80 DUP1 0A1F 36 CALLDATASIZE 0A20 03 SUB 0A21 60 PUSH1 0x20 0A23 81 DUP2 0A24 10 LT 0A25 15 ISZERO 0A26 61 PUSH2 0x0a2e 0A29 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0A19 stack[-1] = 0x0a5a // @0A1C stack[0] = 0x04 // @0A20 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a2e, returns to 0x0A5A, if !(msg.data.length - 0x04 < 0x20) label_0A2A: // Incoming jump from 0x0A29, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A2D memory[0x00:0x00] } 0A2A 60 PUSH1 0x00 0A2C 80 DUP1 0A2D FD *REVERT // Stack delta = +0 // Outputs[1] { @0A2D revert(memory[0x00:0x00]); } // Block terminates label_0A2E: // Incoming call from 0x0A29, returns to 0x0A5A, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0A2F stack[-2] // @0A30 stack[-1] // @0A34 msg.data[stack[-2]:stack[-2] + 0x20] // } 0A2E 5B JUMPDEST 0A2F 81 DUP2 0A30 01 ADD 0A31 90 SWAP1 0A32 80 DUP1 0A33 80 DUP1 0A34 35 CALLDATALOAD 0A35 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A4A 16 AND 0A4B 90 SWAP1 0A4C 60 PUSH1 0x20 0A4E 01 ADD 0A4F 90 SWAP1 0A50 92 SWAP3 0A51 91 SWAP2 0A52 90 SWAP1 0A53 50 POP 0A54 50 POP 0A55 50 POP 0A56 61 PUSH2 0x251e 0A59 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A50 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x251e label_0A5A: // Incoming return from call to 0x0A2E at 0x0A29 // Inputs[4] // { // @0A5D memory[0x40:0x60] // @0A5F stack[-1] // @0A6A memory[0x40:0x60] // @0A6F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A5A 5B JUMPDEST 0A5B 60 PUSH1 0x40 0A5D 51 MLOAD 0A5E 80 DUP1 0A5F 82 DUP3 0A60 81 DUP2 0A61 52 MSTORE 0A62 60 PUSH1 0x20 0A64 01 ADD 0A65 91 SWAP2 0A66 50 POP 0A67 50 POP 0A68 60 PUSH1 0x40 0A6A 51 MLOAD 0A6B 80 DUP1 0A6C 91 SWAP2 0A6D 03 SUB 0A6E 90 SWAP1 0A6F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0A6F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A70: // Incoming jump from 0x012E, if 0x715018a6 == stack[-1] // Inputs[1] { @0A71 msg.value } 0A70 5B JUMPDEST 0A71 34 CALLVALUE 0A72 80 DUP1 0A73 15 ISZERO 0A74 61 PUSH2 0x0a7c 0A77 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A71 stack[0] = msg.value } // Block ends with conditional jump to 0x0a7c, if !msg.value label_0A78: // Incoming jump from 0x0A77, if not !msg.value // Inputs[1] { @0A7B memory[0x00:0x00] } 0A78 60 PUSH1 0x00 0A7A 80 DUP1 0A7B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A7B revert(memory[0x00:0x00]); } // Block terminates label_0A7C: // Incoming jump from 0x0A77, if !msg.value 0A7C 5B JUMPDEST 0A7D 50 POP 0A7E 61 PUSH2 0x0a85 0A81 61 PUSH2 0x25f3 0A84 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A7E stack[-1] = 0x0a85 } // Block ends with call to 0x25f3, returns to 0x0A85 label_0A85: // Incoming return from call to 0x25F3 at 0x0A84 0A85 5B JUMPDEST 0A86 00 *STOP // Stack delta = +0 // Outputs[1] { @0A86 stop(); } // Block terminates label_0A87: // Incoming jump from 0x0139, if 0x78954d18 == stack[-1] // Inputs[1] { @0A88 msg.value } 0A87 5B JUMPDEST 0A88 34 CALLVALUE 0A89 80 DUP1 0A8A 15 ISZERO 0A8B 61 PUSH2 0x0a93 0A8E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A88 stack[0] = msg.value } // Block ends with conditional jump to 0x0a93, if !msg.value label_0A8F: // Incoming jump from 0x0A8E, if not !msg.value // Inputs[1] { @0A92 memory[0x00:0x00] } 0A8F 60 PUSH1 0x00 0A91 80 DUP1 0A92 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A92 revert(memory[0x00:0x00]); } // Block terminates label_0A93: // Incoming jump from 0x0A8E, if !msg.value 0A93 5B JUMPDEST 0A94 50 POP 0A95 61 PUSH2 0x0a9c 0A98 61 PUSH2 0x272e 0A9B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A95 stack[-1] = 0x0a9c } // Block ends with call to 0x272e, returns to 0x0A9C label_0A9C: // Incoming return from call to 0x272E at 0x0A9B // Inputs[4] // { // @0A9F memory[0x40:0x60] // @0AAA stack[-1] // @0AAD memory[stack[-1]:stack[-1] + 0x20] // @0AB6 memory[stack[-1]:stack[-1] + 0x20] // } 0A9C 5B JUMPDEST 0A9D 60 PUSH1 0x40 0A9F 51 MLOAD 0AA0 80 DUP1 0AA1 80 DUP1 0AA2 60 PUSH1 0x20 0AA4 01 ADD 0AA5 82 DUP3 0AA6 81 DUP2 0AA7 03 SUB 0AA8 82 DUP3 0AA9 52 MSTORE 0AAA 83 DUP4 0AAB 81 DUP2 0AAC 81 DUP2 0AAD 51 MLOAD 0AAE 81 DUP2 0AAF 52 MSTORE 0AB0 60 PUSH1 0x20 0AB2 01 ADD 0AB3 91 SWAP2 0AB4 50 POP 0AB5 80 DUP1 0AB6 51 MLOAD 0AB7 90 SWAP1 0AB8 60 PUSH1 0x20 0ABA 01 ADD 0ABB 90 SWAP1 0ABC 80 DUP1 0ABD 83 DUP4 0ABE 83 DUP4 0ABF 60 PUSH1 0x00 0AC1 5B JUMPDEST 0AC2 83 DUP4 0AC3 81 DUP2 0AC4 10 LT 0AC5 15 ISZERO 0AC6 61 PUSH2 0x0adc 0AC9 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0A9F stack[0] = memory[0x40:0x60] // @0AA0 stack[1] = memory[0x40:0x60] // @0AA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0AAF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0AB3 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0ABB stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0ABB stack[3] = 0x20 + stack[-1] // @0ABC stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0ABD stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0ABE stack[7] = 0x20 + stack[-1] // @0ABF stack[8] = 0x00 // } // Block ends with conditional jump to 0x0adc, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0ACA: // Incoming jump from 0x0AC9, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0AC9, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0ACA stack[-1] // @0ACB stack[-2] // @0ACD memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0ACF stack[-3] // } 0ACA 80 DUP1 0ACB 82 DUP3 0ACC 01 ADD 0ACD 51 MLOAD 0ACE 81 DUP2 0ACF 84 DUP5 0AD0 01 ADD 0AD1 52 MSTORE 0AD2 60 PUSH1 0x20 0AD4 81 DUP2 0AD5 01 ADD 0AD6 90 SWAP1 0AD7 50 POP 0AD8 61 PUSH2 0x0ac1 0ADB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0AD1 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0AD6 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0ac1 label_0ADC: // Incoming jump from 0x0AC9, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0AC9, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0AE1 stack[-6] // @0AE1 stack[-5] // @0AE3 stack[-7] // } 0ADC 5B JUMPDEST 0ADD 50 POP 0ADE 50 POP 0ADF 50 POP 0AE0 50 POP 0AE1 90 SWAP1 0AE2 50 POP 0AE3 90 SWAP1 0AE4 81 DUP2 0AE5 01 ADD 0AE6 90 SWAP1 0AE7 60 PUSH1 0x1f 0AE9 16 AND 0AEA 80 DUP1 0AEB 15 ISZERO 0AEC 61 PUSH2 0x0b09 0AEF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0AE6 stack[-7] = stack[-5] + stack[-7] // @0AE9 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0b09, if !(0x1f & stack[-5]) label_0AF0: // Incoming jump from 0x0AEF, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0AF0 stack[-1] // @0AF1 stack[-2] // @0AF4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0B0B stack[-5] // @0B11 memory[0x40:0x60] // @0B16 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0AF0 80 DUP1 0AF1 82 DUP3 0AF2 03 SUB 0AF3 80 DUP1 0AF4 51 MLOAD 0AF5 60 PUSH1 0x01 0AF7 83 DUP4 0AF8 60 PUSH1 0x20 0AFA 03 SUB 0AFB 61 PUSH2 0x0100 0AFE 0A EXP 0AFF 03 SUB 0B00 19 NOT 0B01 16 AND 0B02 81 DUP2 0B03 52 MSTORE 0B04 60 PUSH1 0x20 0B06 01 ADD 0B07 91 SWAP2 0B08 50 POP 0B09 5B JUMPDEST 0B0A 50 POP 0B0B 92 SWAP3 0B0C 50 POP 0B0D 50 POP 0B0E 50 POP 0B0F 60 PUSH1 0x40 0B11 51 MLOAD 0B12 80 DUP1 0B13 91 SWAP2 0B14 03 SUB 0B15 90 SWAP1 0B16 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0B03 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0B16 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0B17: // Incoming jump from 0x0144, if 0x85fadf94 == stack[-1] // Inputs[1] { @0B18 msg.value } 0B17 5B JUMPDEST 0B18 34 CALLVALUE 0B19 80 DUP1 0B1A 15 ISZERO 0B1B 61 PUSH2 0x0b23 0B1E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B18 stack[0] = msg.value } // Block ends with conditional jump to 0x0b23, if !msg.value label_0B1F: // Incoming jump from 0x0B1E, if not !msg.value // Inputs[1] { @0B22 memory[0x00:0x00] } 0B1F 60 PUSH1 0x00 0B21 80 DUP1 0B22 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B22 revert(memory[0x00:0x00]); } // Block terminates label_0B23: // Incoming jump from 0x0B1E, if !msg.value 0B23 5B JUMPDEST 0B24 50 POP 0B25 61 PUSH2 0x0b2c 0B28 61 PUSH2 0x27cc 0B2B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0B25 stack[-1] = 0x0b2c } // Block ends with call to 0x27cc, returns to 0x0B2C label_0B2C: // Incoming return from call to 0x27CC at 0x0B2B // Inputs[4] // { // @0B2F memory[0x40:0x60] // @0B31 stack[-1] // @0B3C memory[0x40:0x60] // @0B41 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B2C 5B JUMPDEST 0B2D 60 PUSH1 0x40 0B2F 51 MLOAD 0B30 80 DUP1 0B31 82 DUP3 0B32 81 DUP2 0B33 52 MSTORE 0B34 60 PUSH1 0x20 0B36 01 ADD 0B37 91 SWAP2 0B38 50 POP 0B39 50 POP 0B3A 60 PUSH1 0x40 0B3C 51 MLOAD 0B3D 80 DUP1 0B3E 91 SWAP2 0B3F 03 SUB 0B40 90 SWAP1 0B41 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0B33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B41 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0B42: // Incoming jump from 0x00DC, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0B43 msg.value } 0B42 5B JUMPDEST 0B43 34 CALLVALUE 0B44 80 DUP1 0B45 15 ISZERO 0B46 61 PUSH2 0x0b4e 0B49 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B43 stack[0] = msg.value } // Block ends with conditional jump to 0x0b4e, if !msg.value label_0B4A: // Incoming jump from 0x0B49, if not !msg.value // Inputs[1] { @0B4D memory[0x00:0x00] } 0B4A 60 PUSH1 0x00 0B4C 80 DUP1 0B4D FD *REVERT // Stack delta = +0 // Outputs[1] { @0B4D revert(memory[0x00:0x00]); } // Block terminates label_0B4E: // Incoming jump from 0x0B49, if !msg.value 0B4E 5B JUMPDEST 0B4F 50 POP 0B50 61 PUSH2 0x0b57 0B53 61 PUSH2 0x27d2 0B56 56 *JUMP // Stack delta = +0 // Outputs[1] { @0B50 stack[-1] = 0x0b57 } // Block ends with call to 0x27d2, returns to 0x0B57 label_0B57: // Incoming return from call to 0x27D2 at 0x0B56 // Inputs[4] // { // @0B5A memory[0x40:0x60] // @0B5C stack[-1] // @0B93 memory[0x40:0x60] // @0B98 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B57 5B JUMPDEST 0B58 60 PUSH1 0x40 0B5A 51 MLOAD 0B5B 80 DUP1 0B5C 82 DUP3 0B5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B72 16 AND 0B73 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B88 16 AND 0B89 81 DUP2 0B8A 52 MSTORE 0B8B 60 PUSH1 0x20 0B8D 01 ADD 0B8E 91 SWAP2 0B8F 50 POP 0B90 50 POP 0B91 60 PUSH1 0x40 0B93 51 MLOAD 0B94 80 DUP1 0B95 91 SWAP2 0B96 03 SUB 0B97 90 SWAP1 0B98 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0B8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B98 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0B99: // Incoming jump from 0x00E7, if 0x8f32d59b == stack[-1] // Inputs[1] { @0B9A msg.value } 0B99 5B JUMPDEST 0B9A 34 CALLVALUE 0B9B 80 DUP1 0B9C 15 ISZERO 0B9D 61 PUSH2 0x0ba5 0BA0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B9A stack[0] = msg.value } // Block ends with conditional jump to 0x0ba5, if !msg.value label_0BA1: // Incoming jump from 0x0BA0, if not !msg.value // Inputs[1] { @0BA4 memory[0x00:0x00] } 0BA1 60 PUSH1 0x00 0BA3 80 DUP1 0BA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BA4 revert(memory[0x00:0x00]); } // Block terminates label_0BA5: // Incoming jump from 0x0BA0, if !msg.value 0BA5 5B JUMPDEST 0BA6 50 POP 0BA7 61 PUSH2 0x0bae 0BAA 61 PUSH2 0x27fc 0BAD 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BA7 stack[-1] = 0x0bae } // Block ends with call to 0x27fc, returns to 0x0BAE label_0BAE: // Incoming return from call to 0x27FC at 0x0BAD // Inputs[4] // { // @0BB1 memory[0x40:0x60] // @0BB3 stack[-1] // @0BC2 memory[0x40:0x60] // @0BC7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BAE 5B JUMPDEST 0BAF 60 PUSH1 0x40 0BB1 51 MLOAD 0BB2 80 DUP1 0BB3 82 DUP3 0BB4 15 ISZERO 0BB5 15 ISZERO 0BB6 15 ISZERO 0BB7 15 ISZERO 0BB8 81 DUP2 0BB9 52 MSTORE 0BBA 60 PUSH1 0x20 0BBC 01 ADD 0BBD 91 SWAP2 0BBE 50 POP 0BBF 50 POP 0BC0 60 PUSH1 0x40 0BC2 51 MLOAD 0BC3 80 DUP1 0BC4 91 SWAP2 0BC5 03 SUB 0BC6 90 SWAP1 0BC7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0BB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0BC7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0BC8: // Incoming jump from 0x00F2, if 0x95d89b41 == stack[-1] // Inputs[1] { @0BC9 msg.value } 0BC8 5B JUMPDEST 0BC9 34 CALLVALUE 0BCA 80 DUP1 0BCB 15 ISZERO 0BCC 61 PUSH2 0x0bd4 0BCF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BC9 stack[0] = msg.value } // Block ends with conditional jump to 0x0bd4, if !msg.value label_0BD0: // Incoming jump from 0x0BCF, if not !msg.value // Inputs[1] { @0BD3 memory[0x00:0x00] } 0BD0 60 PUSH1 0x00 0BD2 80 DUP1 0BD3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BD3 revert(memory[0x00:0x00]); } // Block terminates label_0BD4: // Incoming jump from 0x0BCF, if !msg.value 0BD4 5B JUMPDEST 0BD5 50 POP 0BD6 61 PUSH2 0x0bdd 0BD9 61 PUSH2 0x285b 0BDC 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BD6 stack[-1] = 0x0bdd } // Block ends with call to 0x285b, returns to 0x0BDD label_0BDD: // Incoming return from call to 0x285B at 0x0BDC // Inputs[4] // { // @0BE0 memory[0x40:0x60] // @0BEB stack[-1] // @0BEE memory[stack[-1]:stack[-1] + 0x20] // @0BF7 memory[stack[-1]:stack[-1] + 0x20] // } 0BDD 5B JUMPDEST 0BDE 60 PUSH1 0x40 0BE0 51 MLOAD 0BE1 80 DUP1 0BE2 80 DUP1 0BE3 60 PUSH1 0x20 0BE5 01 ADD 0BE6 82 DUP3 0BE7 81 DUP2 0BE8 03 SUB 0BE9 82 DUP3 0BEA 52 MSTORE 0BEB 83 DUP4 0BEC 81 DUP2 0BED 81 DUP2 0BEE 51 MLOAD 0BEF 81 DUP2 0BF0 52 MSTORE 0BF1 60 PUSH1 0x20 0BF3 01 ADD 0BF4 91 SWAP2 0BF5 50 POP 0BF6 80 DUP1 0BF7 51 MLOAD 0BF8 90 SWAP1 0BF9 60 PUSH1 0x20 0BFB 01 ADD 0BFC 90 SWAP1 0BFD 80 DUP1 0BFE 83 DUP4 0BFF 83 DUP4 0C00 60 PUSH1 0x00 0C02 5B JUMPDEST 0C03 83 DUP4 0C04 81 DUP2 0C05 10 LT 0C06 15 ISZERO 0C07 61 PUSH2 0x0c1d 0C0A 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0BE0 stack[0] = memory[0x40:0x60] // @0BE1 stack[1] = memory[0x40:0x60] // @0BEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0BF0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0BF4 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0BFC stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0BFC stack[3] = 0x20 + stack[-1] // @0BFD stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0BFE stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0BFF stack[7] = 0x20 + stack[-1] // @0C00 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0c1d, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0C0B: // Incoming jump from 0x0C0A, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0C0A, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0C0B stack[-1] // @0C0C stack[-2] // @0C0E memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0C10 stack[-3] // } 0C0B 80 DUP1 0C0C 82 DUP3 0C0D 01 ADD 0C0E 51 MLOAD 0C0F 81 DUP2 0C10 84 DUP5 0C11 01 ADD 0C12 52 MSTORE 0C13 60 PUSH1 0x20 0C15 81 DUP2 0C16 01 ADD 0C17 90 SWAP1 0C18 50 POP 0C19 61 PUSH2 0x0c02 0C1C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C12 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0C17 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0c02 label_0C1D: // Incoming jump from 0x0C0A, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0C0A, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0C22 stack[-6] // @0C22 stack[-5] // @0C24 stack[-7] // } 0C1D 5B JUMPDEST 0C1E 50 POP 0C1F 50 POP 0C20 50 POP 0C21 50 POP 0C22 90 SWAP1 0C23 50 POP 0C24 90 SWAP1 0C25 81 DUP2 0C26 01 ADD 0C27 90 SWAP1 0C28 60 PUSH1 0x1f 0C2A 16 AND 0C2B 80 DUP1 0C2C 15 ISZERO 0C2D 61 PUSH2 0x0c4a 0C30 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0C27 stack[-7] = stack[-5] + stack[-7] // @0C2A stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0c4a, if !(0x1f & stack[-5]) label_0C31: // Incoming jump from 0x0C30, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0C31 stack[-1] // @0C32 stack[-2] // @0C35 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0C4C stack[-5] // @0C52 memory[0x40:0x60] // @0C57 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0C31 80 DUP1 0C32 82 DUP3 0C33 03 SUB 0C34 80 DUP1 0C35 51 MLOAD 0C36 60 PUSH1 0x01 0C38 83 DUP4 0C39 60 PUSH1 0x20 0C3B 03 SUB 0C3C 61 PUSH2 0x0100 0C3F 0A EXP 0C40 03 SUB 0C41 19 NOT 0C42 16 AND 0C43 81 DUP2 0C44 52 MSTORE 0C45 60 PUSH1 0x20 0C47 01 ADD 0C48 91 SWAP2 0C49 50 POP 0C4A 5B JUMPDEST 0C4B 50 POP 0C4C 92 SWAP3 0C4D 50 POP 0C4E 50 POP 0C4F 50 POP 0C50 60 PUSH1 0x40 0C52 51 MLOAD 0C53 80 DUP1 0C54 91 SWAP2 0C55 03 SUB 0C56 90 SWAP1 0C57 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0C44 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0C57 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0C58: // Incoming jump from 0x00FD, if 0x9bdb6f80 == stack[-1] // Inputs[1] { @0C59 msg.value } 0C58 5B JUMPDEST 0C59 34 CALLVALUE 0C5A 80 DUP1 0C5B 15 ISZERO 0C5C 61 PUSH2 0x0c64 0C5F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C59 stack[0] = msg.value } // Block ends with conditional jump to 0x0c64, if !msg.value label_0C60: // Incoming jump from 0x0C5F, if not !msg.value // Inputs[1] { @0C63 memory[0x00:0x00] } 0C60 60 PUSH1 0x00 0C62 80 DUP1 0C63 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C63 revert(memory[0x00:0x00]); } // Block terminates label_0C64: // Incoming jump from 0x0C5F, if !msg.value // Inputs[1] { @0C6C msg.data.length } 0C64 5B JUMPDEST 0C65 50 POP 0C66 61 PUSH2 0x0c91 0C69 60 PUSH1 0x04 0C6B 80 DUP1 0C6C 36 CALLDATASIZE 0C6D 03 SUB 0C6E 60 PUSH1 0x20 0C70 81 DUP2 0C71 10 LT 0C72 15 ISZERO 0C73 61 PUSH2 0x0c7b 0C76 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0C66 stack[-1] = 0x0c91 // @0C69 stack[0] = 0x04 // @0C6D stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0c7b, returns to 0x0C91, if !(msg.data.length - 0x04 < 0x20) label_0C77: // Incoming jump from 0x0C76, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0C7A memory[0x00:0x00] } 0C77 60 PUSH1 0x00 0C79 80 DUP1 0C7A FD *REVERT // Stack delta = +0 // Outputs[1] { @0C7A revert(memory[0x00:0x00]); } // Block terminates label_0C7B: // Incoming call from 0x0C76, returns to 0x0C91, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0C7C stack[-2] // @0C7D stack[-1] // @0C81 msg.data[stack[-2]:stack[-2] + 0x20] // } 0C7B 5B JUMPDEST 0C7C 81 DUP2 0C7D 01 ADD 0C7E 90 SWAP1 0C7F 80 DUP1 0C80 80 DUP1 0C81 35 CALLDATALOAD 0C82 90 SWAP1 0C83 60 PUSH1 0x20 0C85 01 ADD 0C86 90 SWAP1 0C87 92 SWAP3 0C88 91 SWAP2 0C89 90 SWAP1 0C8A 50 POP 0C8B 50 POP 0C8C 50 POP 0C8D 61 PUSH2 0x28fd 0C90 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C87 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x28fd label_0C91: // Incoming return from call to 0x0C7B at 0x0C76 // Inputs[4] // { // @0C94 memory[0x40:0x60] // @0CA7 stack[-3] // @0CAA memory[stack[-3]:stack[-3] + 0x20] // @0CB3 memory[stack[-3]:stack[-3] + 0x20] // } 0C91 5B JUMPDEST 0C92 60 PUSH1 0x40 0C94 51 MLOAD 0C95 80 DUP1 0C96 80 DUP1 0C97 60 PUSH1 0x20 0C99 01 ADD 0C9A 80 DUP1 0C9B 60 PUSH1 0x20 0C9D 01 ADD 0C9E 80 DUP1 0C9F 60 PUSH1 0x20 0CA1 01 ADD 0CA2 84 DUP5 0CA3 81 DUP2 0CA4 03 SUB 0CA5 84 DUP5 0CA6 52 MSTORE 0CA7 87 DUP8 0CA8 81 DUP2 0CA9 81 DUP2 0CAA 51 MLOAD 0CAB 81 DUP2 0CAC 52 MSTORE 0CAD 60 PUSH1 0x20 0CAF 01 ADD 0CB0 91 SWAP2 0CB1 50 POP 0CB2 80 DUP1 0CB3 51 MLOAD 0CB4 90 SWAP1 0CB5 60 PUSH1 0x20 0CB7 01 ADD 0CB8 90 SWAP1 0CB9 80 DUP1 0CBA 83 DUP4 0CBB 83 DUP4 0CBC 60 PUSH1 0x00 0CBE 5B JUMPDEST 0CBF 83 DUP4 0CC0 81 DUP2 0CC1 10 LT 0CC2 15 ISZERO 0CC3 61 PUSH2 0x0cd9 0CC6 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @0C94 stack[0] = memory[0x40:0x60] // @0C95 stack[1] = memory[0x40:0x60] // @0C99 stack[2] = 0x20 + memory[0x40:0x60] // @0C9D stack[3] = 0x20 + 0x20 + memory[0x40:0x60] // @0CA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0CAC memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @0CB0 stack[4] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0CB8 stack[5] = 0x20 + stack[-3] // @0CB8 stack[6] = memory[stack[-3]:stack[-3] + 0x20] // @0CB9 stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @0CBA stack[8] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0CBB stack[9] = 0x20 + stack[-3] // @0CBC stack[10] = 0x00 // } // Block ends with conditional jump to 0x0cd9, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_0CC7: // Incoming jump from 0x0CC6, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0CC6, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0CC7 stack[-1] // @0CC8 stack[-2] // @0CCA memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0CCC stack[-3] // } 0CC7 80 DUP1 0CC8 82 DUP3 0CC9 01 ADD 0CCA 51 MLOAD 0CCB 81 DUP2 0CCC 84 DUP5 0CCD 01 ADD 0CCE 52 MSTORE 0CCF 60 PUSH1 0x20 0CD1 81 DUP2 0CD2 01 ADD 0CD3 90 SWAP1 0CD4 50 POP 0CD5 61 PUSH2 0x0cbe 0CD8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0CCE memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0CD3 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0cbe label_0CD9: // Incoming jump from 0x0CC6, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0CC6, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0CDE stack[-5] // @0CDE stack[-6] // @0CE0 stack[-7] // } 0CD9 5B JUMPDEST 0CDA 50 POP 0CDB 50 POP 0CDC 50 POP 0CDD 50 POP 0CDE 90 SWAP1 0CDF 50 POP 0CE0 90 SWAP1 0CE1 81 DUP2 0CE2 01 ADD 0CE3 90 SWAP1 0CE4 60 PUSH1 0x1f 0CE6 16 AND 0CE7 80 DUP1 0CE8 15 ISZERO 0CE9 61 PUSH2 0x0d06 0CEC 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0CE3 stack[-7] = stack[-5] + stack[-7] // @0CE6 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0d06, if !(0x1f & stack[-5]) label_0CED: // Incoming jump from 0x0CEC, if not !(0x1f & stack[-5]) // Inputs[8] // { // @0CED stack[-1] // @0CEE stack[-2] // @0CF1 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0D08 stack[-6] // @0D0B stack[-4] // @0D0D stack[-8] // @0D10 memory[stack[-8]:stack[-8] + 0x20] // @0D19 memory[stack[-8]:stack[-8] + 0x20] // } 0CED 80 DUP1 0CEE 82 DUP3 0CEF 03 SUB 0CF0 80 DUP1 0CF1 51 MLOAD 0CF2 60 PUSH1 0x01 0CF4 83 DUP4 0CF5 60 PUSH1 0x20 0CF7 03 SUB 0CF8 61 PUSH2 0x0100 0CFB 0A EXP 0CFC 03 SUB 0CFD 19 NOT 0CFE 16 AND 0CFF 81 DUP2 0D00 52 MSTORE 0D01 60 PUSH1 0x20 0D03 01 ADD 0D04 91 SWAP2 0D05 50 POP 0D06 5B JUMPDEST 0D07 50 POP 0D08 84 DUP5 0D09 81 DUP2 0D0A 03 SUB 0D0B 83 DUP4 0D0C 52 MSTORE 0D0D 86 DUP7 0D0E 81 DUP2 0D0F 81 DUP2 0D10 51 MLOAD 0D11 81 DUP2 0D12 52 MSTORE 0D13 60 PUSH1 0x20 0D15 01 ADD 0D16 91 SWAP2 0D17 50 POP 0D18 80 DUP1 0D19 51 MLOAD 0D1A 90 SWAP1 0D1B 60 PUSH1 0x20 0D1D 01 ADD 0D1E 90 SWAP1 0D1F 80 DUP1 0D20 83 DUP4 0D21 83 DUP4 0D22 60 PUSH1 0x00 0D24 5B JUMPDEST 0D25 83 DUP4 0D26 81 DUP2 0D27 10 LT 0D28 15 ISZERO 0D29 61 PUSH2 0x0d3f 0D2C 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0D00 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0D0C memory[stack[-4]:stack[-4] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-6] // @0D12 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-8]:stack[-8] + 0x20] // @0D16 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0D1E stack[-1] = 0x20 + stack[-8] // @0D1E stack[0] = memory[stack[-8]:stack[-8] + 0x20] // @0D1F stack[1] = memory[stack[-8]:stack[-8] + 0x20] // @0D20 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0D21 stack[3] = 0x20 + stack[-8] // @0D22 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0d3f, if !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) label_0D2D: // Incoming jump from 0x0D2C, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0D2C, if not !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Incoming jump from 0x0D2C, if not !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[4] // { // @0D2D stack[-1] // @0D2E stack[-2] // @0D30 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0D32 stack[-3] // } 0D2D 80 DUP1 0D2E 82 DUP3 0D2F 01 ADD 0D30 51 MLOAD 0D31 81 DUP2 0D32 84 DUP5 0D33 01 ADD 0D34 52 MSTORE 0D35 60 PUSH1 0x20 0D37 81 DUP2 0D38 01 ADD 0D39 90 SWAP1 0D3A 50 POP 0D3B 61 PUSH2 0x0d24 0D3E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0D34 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0D39 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0d24 label_0D3F: // Incoming jump from 0x0D2C, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0D2C, if !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Incoming jump from 0x0D2C, if !(0x00 < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[3] // { // @0D44 stack[-6] // @0D44 stack[-5] // @0D46 stack[-7] // } 0D3F 5B JUMPDEST 0D40 50 POP 0D41 50 POP 0D42 50 POP 0D43 50 POP 0D44 90 SWAP1 0D45 50 POP 0D46 90 SWAP1 0D47 81 DUP2 0D48 01 ADD 0D49 90 SWAP1 0D4A 60 PUSH1 0x1f 0D4C 16 AND 0D4D 80 DUP1 0D4E 15 ISZERO 0D4F 61 PUSH2 0x0d6c 0D52 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D49 stack[-7] = stack[-5] + stack[-7] // @0D4C stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0d6c, if !(0x1f & stack[-5]) label_0D53: // Incoming jump from 0x0D52, if not !(0x1f & stack[-5]) // Inputs[8] // { // @0D53 stack[-1] // @0D54 stack[-2] // @0D57 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0D6E stack[-6] // @0D71 stack[-3] // @0D73 stack[-7] // @0D76 memory[stack[-7]:stack[-7] + 0x20] // @0D7F memory[stack[-7]:stack[-7] + 0x20] // } 0D53 80 DUP1 0D54 82 DUP3 0D55 03 SUB 0D56 80 DUP1 0D57 51 MLOAD 0D58 60 PUSH1 0x01 0D5A 83 DUP4 0D5B 60 PUSH1 0x20 0D5D 03 SUB 0D5E 61 PUSH2 0x0100 0D61 0A EXP 0D62 03 SUB 0D63 19 NOT 0D64 16 AND 0D65 81 DUP2 0D66 52 MSTORE 0D67 60 PUSH1 0x20 0D69 01 ADD 0D6A 91 SWAP2 0D6B 50 POP 0D6C 5B JUMPDEST 0D6D 50 POP 0D6E 84 DUP5 0D6F 81 DUP2 0D70 03 SUB 0D71 82 DUP3 0D72 52 MSTORE 0D73 85 DUP6 0D74 81 DUP2 0D75 81 DUP2 0D76 51 MLOAD 0D77 81 DUP2 0D78 52 MSTORE 0D79 60 PUSH1 0x20 0D7B 01 ADD 0D7C 91 SWAP2 0D7D 50 POP 0D7E 80 DUP1 0D7F 51 MLOAD 0D80 90 SWAP1 0D81 60 PUSH1 0x20 0D83 01 ADD 0D84 90 SWAP1 0D85 80 DUP1 0D86 83 DUP4 0D87 83 DUP4 0D88 60 PUSH1 0x00 0D8A 5B JUMPDEST 0D8B 83 DUP4 0D8C 81 DUP2 0D8D 10 LT 0D8E 15 ISZERO 0D8F 61 PUSH2 0x0da5 0D92 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0D66 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0D72 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-6] // @0D78 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-7]:stack[-7] + 0x20] // @0D7C stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0D84 stack[-1] = 0x20 + stack[-7] // @0D84 stack[0] = memory[stack[-7]:stack[-7] + 0x20] // @0D85 stack[1] = memory[stack[-7]:stack[-7] + 0x20] // @0D86 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @0D87 stack[3] = 0x20 + stack[-7] // @0D88 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0da5, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) label_0D93: // Incoming jump from 0x0D92, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x0D92, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0D92, if not !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[4] // { // @0D93 stack[-1] // @0D94 stack[-2] // @0D96 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0D98 stack[-3] // } 0D93 80 DUP1 0D94 82 DUP3 0D95 01 ADD 0D96 51 MLOAD 0D97 81 DUP2 0D98 84 DUP5 0D99 01 ADD 0D9A 52 MSTORE 0D9B 60 PUSH1 0x20 0D9D 81 DUP2 0D9E 01 ADD 0D9F 90 SWAP1 0DA0 50 POP 0DA1 61 PUSH2 0x0d8a 0DA4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0D9A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0D9F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0d8a label_0DA5: // Incoming jump from 0x0D92, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Incoming jump from 0x0D92, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0D92, if !(0x00 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[3] // { // @0DAA stack[-6] // @0DAA stack[-5] // @0DAC stack[-7] // } 0DA5 5B JUMPDEST 0DA6 50 POP 0DA7 50 POP 0DA8 50 POP 0DA9 50 POP 0DAA 90 SWAP1 0DAB 50 POP 0DAC 90 SWAP1 0DAD 81 DUP2 0DAE 01 ADD 0DAF 90 SWAP1 0DB0 60 PUSH1 0x1f 0DB2 16 AND 0DB3 80 DUP1 0DB4 15 ISZERO 0DB5 61 PUSH2 0x0dd2 0DB8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0DAF stack[-7] = stack[-5] + stack[-7] // @0DB2 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0dd2, if !(0x1f & stack[-5]) label_0DB9: // Incoming jump from 0x0DB8, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0DB9 stack[-1] // @0DBA stack[-2] // @0DBD memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0DD4 stack[-9] // @0DDE memory[0x40:0x60] // @0DE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0DB9 80 DUP1 0DBA 82 DUP3 0DBB 03 SUB 0DBC 80 DUP1 0DBD 51 MLOAD 0DBE 60 PUSH1 0x01 0DC0 83 DUP4 0DC1 60 PUSH1 0x20 0DC3 03 SUB 0DC4 61 PUSH2 0x0100 0DC7 0A EXP 0DC8 03 SUB 0DC9 19 NOT 0DCA 16 AND 0DCB 81 DUP2 0DCC 52 MSTORE 0DCD 60 PUSH1 0x20 0DCF 01 ADD 0DD0 91 SWAP2 0DD1 50 POP 0DD2 5B JUMPDEST 0DD3 50 POP 0DD4 96 SWAP7 0DD5 50 POP 0DD6 50 POP 0DD7 50 POP 0DD8 50 POP 0DD9 50 POP 0DDA 50 POP 0DDB 50 POP 0DDC 60 PUSH1 0x40 0DDE 51 MLOAD 0DDF 80 DUP1 0DE0 91 SWAP2 0DE1 03 SUB 0DE2 90 SWAP1 0DE3 F3 *RETURN // Stack delta = -9 // Outputs[2] // { // @0DCC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0DE3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0DE4: // Incoming jump from 0x00AB, if 0xa22cb465 == stack[-1] // Inputs[1] { @0DE5 msg.value } 0DE4 5B JUMPDEST 0DE5 34 CALLVALUE 0DE6 80 DUP1 0DE7 15 ISZERO 0DE8 61 PUSH2 0x0df0 0DEB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DE5 stack[0] = msg.value } // Block ends with conditional jump to 0x0df0, if !msg.value label_0DEC: // Incoming jump from 0x0DEB, if not !msg.value // Inputs[1] { @0DEF memory[0x00:0x00] } 0DEC 60 PUSH1 0x00 0DEE 80 DUP1 0DEF FD *REVERT // Stack delta = +0 // Outputs[1] { @0DEF revert(memory[0x00:0x00]); } // Block terminates label_0DF0: // Incoming jump from 0x0DEB, if !msg.value // Inputs[1] { @0DF8 msg.data.length } 0DF0 5B JUMPDEST 0DF1 50 POP 0DF2 61 PUSH2 0x0e3f 0DF5 60 PUSH1 0x04 0DF7 80 DUP1 0DF8 36 CALLDATASIZE 0DF9 03 SUB 0DFA 60 PUSH1 0x40 0DFC 81 DUP2 0DFD 10 LT 0DFE 15 ISZERO 0DFF 61 PUSH2 0x0e07 0E02 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0DF2 stack[-1] = 0x0e3f // @0DF5 stack[0] = 0x04 // @0DF9 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e07, returns to 0x0E3F, if !(msg.data.length - 0x04 < 0x40) label_0E03: // Incoming jump from 0x0E02, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0E06 memory[0x00:0x00] } 0E03 60 PUSH1 0x00 0E05 80 DUP1 0E06 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E06 revert(memory[0x00:0x00]); } // Block terminates label_0E07: // Incoming call from 0x0E02, returns to 0x0E3F, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0E08 stack[-2] // @0E09 stack[-1] // @0E0D msg.data[stack[-2]:stack[-2] + 0x20] // @0E2D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0E07 5B JUMPDEST 0E08 81 DUP2 0E09 01 ADD 0E0A 90 SWAP1 0E0B 80 DUP1 0E0C 80 DUP1 0E0D 35 CALLDATALOAD 0E0E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E23 16 AND 0E24 90 SWAP1 0E25 60 PUSH1 0x20 0E27 01 ADD 0E28 90 SWAP1 0E29 92 SWAP3 0E2A 91 SWAP2 0E2B 90 SWAP1 0E2C 80 DUP1 0E2D 35 CALLDATALOAD 0E2E 15 ISZERO 0E2F 15 ISZERO 0E30 90 SWAP1 0E31 60 PUSH1 0x20 0E33 01 ADD 0E34 90 SWAP1 0E35 92 SWAP3 0E36 91 SWAP2 0E37 90 SWAP1 0E38 50 POP 0E39 50 POP 0E3A 50 POP 0E3B 61 PUSH2 0x2bb2 0E3E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E29 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0E35 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2bb2 label_0E3F: // Incoming return from call to 0x0E07 at 0x0E02 0E3F 5B JUMPDEST 0E40 00 *STOP // Stack delta = +0 // Outputs[1] { @0E40 stop(); } // Block terminates label_0E41: // Incoming jump from 0x00B6, if 0xa65ff74c == stack[-1] // Inputs[1] { @0E42 msg.value } 0E41 5B JUMPDEST 0E42 34 CALLVALUE 0E43 80 DUP1 0E44 15 ISZERO 0E45 61 PUSH2 0x0e4d 0E48 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E42 stack[0] = msg.value } // Block ends with conditional jump to 0x0e4d, if !msg.value label_0E49: // Incoming jump from 0x0E48, if not !msg.value // Inputs[1] { @0E4C memory[0x00:0x00] } 0E49 60 PUSH1 0x00 0E4B 80 DUP1 0E4C FD *REVERT // Stack delta = +0 // Outputs[1] { @0E4C revert(memory[0x00:0x00]); } // Block terminates label_0E4D: // Incoming jump from 0x0E48, if !msg.value // Inputs[1] { @0E55 msg.data.length } 0E4D 5B JUMPDEST 0E4E 50 POP 0E4F 61 PUSH2 0x0e7a 0E52 60 PUSH1 0x04 0E54 80 DUP1 0E55 36 CALLDATASIZE 0E56 03 SUB 0E57 60 PUSH1 0x20 0E59 81 DUP2 0E5A 10 LT 0E5B 15 ISZERO 0E5C 61 PUSH2 0x0e64 0E5F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0E4F stack[-1] = 0x0e7a // @0E52 stack[0] = 0x04 // @0E56 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e64, returns to 0x0E7A, if !(msg.data.length - 0x04 < 0x20) label_0E60: // Incoming jump from 0x0E5F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0E63 memory[0x00:0x00] } 0E60 60 PUSH1 0x00 0E62 80 DUP1 0E63 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E63 revert(memory[0x00:0x00]); } // Block terminates label_0E64: // Incoming call from 0x0E5F, returns to 0x0E7A, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0E65 stack[-2] // @0E66 stack[-1] // @0E6A msg.data[stack[-2]:stack[-2] + 0x20] // } 0E64 5B JUMPDEST 0E65 81 DUP2 0E66 01 ADD 0E67 90 SWAP1 0E68 80 DUP1 0E69 80 DUP1 0E6A 35 CALLDATALOAD 0E6B 90 SWAP1 0E6C 60 PUSH1 0x20 0E6E 01 ADD 0E6F 90 SWAP1 0E70 92 SWAP3 0E71 91 SWAP2 0E72 90 SWAP1 0E73 50 POP 0E74 50 POP 0E75 50 POP 0E76 61 PUSH2 0x2d6a 0E79 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E70 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2d6a label_0E7A: // Incoming return from call to 0x0E64 at 0x0E5F // Inputs[5] // { // @0E7D memory[0x40:0x60] // @0E7F stack[-2] // @0EB1 stack[-1] // @0EBD memory[0x40:0x60] // @0EC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E7A 5B JUMPDEST 0E7B 60 PUSH1 0x40 0E7D 51 MLOAD 0E7E 80 DUP1 0E7F 83 DUP4 0E80 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E95 16 AND 0E96 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EAB 16 AND 0EAC 81 DUP2 0EAD 52 MSTORE 0EAE 60 PUSH1 0x20 0EB0 01 ADD 0EB1 82 DUP3 0EB2 81 DUP2 0EB3 52 MSTORE 0EB4 60 PUSH1 0x20 0EB6 01 ADD 0EB7 92 SWAP3 0EB8 50 POP 0EB9 50 POP 0EBA 50 POP 0EBB 60 PUSH1 0x40 0EBD 51 MLOAD 0EBE 80 DUP1 0EBF 91 SWAP2 0EC0 03 SUB 0EC1 90 SWAP1 0EC2 F3 *RETURN // Stack delta = -2 // Outputs[3] // { // @0EAD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0EB3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-1] // @0EC2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0EC3: // Incoming jump from 0x00C1, if 0xb784c966 == stack[-1] // Inputs[1] { @0EC4 msg.value } 0EC3 5B JUMPDEST 0EC4 34 CALLVALUE 0EC5 80 DUP1 0EC6 15 ISZERO 0EC7 61 PUSH2 0x0ecf 0ECA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EC4 stack[0] = msg.value } // Block ends with conditional jump to 0x0ecf, if !msg.value label_0ECB: // Incoming jump from 0x0ECA, if not !msg.value // Inputs[1] { @0ECE memory[0x00:0x00] } 0ECB 60 PUSH1 0x00 0ECD 80 DUP1 0ECE FD *REVERT // Stack delta = +0 // Outputs[1] { @0ECE revert(memory[0x00:0x00]); } // Block terminates label_0ECF: // Incoming jump from 0x0ECA, if !msg.value // Inputs[1] { @0ED7 msg.data.length } 0ECF 5B JUMPDEST 0ED0 50 POP 0ED1 61 PUSH2 0x0f12 0ED4 60 PUSH1 0x04 0ED6 80 DUP1 0ED7 36 CALLDATASIZE 0ED8 03 SUB 0ED9 60 PUSH1 0x20 0EDB 81 DUP2 0EDC 10 LT 0EDD 15 ISZERO 0EDE 61 PUSH2 0x0ee6 0EE1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0ED1 stack[-1] = 0x0f12 // @0ED4 stack[0] = 0x04 // @0ED8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0ee6, returns to 0x0F12, if !(msg.data.length - 0x04 < 0x20) label_0EE2: // Incoming jump from 0x0EE1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0EE5 memory[0x00:0x00] } 0EE2 60 PUSH1 0x00 0EE4 80 DUP1 0EE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EE5 revert(memory[0x00:0x00]); } // Block terminates label_0EE6: // Incoming call from 0x0EE1, returns to 0x0F12, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0EE7 stack[-2] // @0EE8 stack[-1] // @0EEC msg.data[stack[-2]:stack[-2] + 0x20] // } 0EE6 5B JUMPDEST 0EE7 81 DUP2 0EE8 01 ADD 0EE9 90 SWAP1 0EEA 80 DUP1 0EEB 80 DUP1 0EEC 35 CALLDATALOAD 0EED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F02 16 AND 0F03 90 SWAP1 0F04 60 PUSH1 0x20 0F06 01 ADD 0F07 90 SWAP1 0F08 92 SWAP3 0F09 91 SWAP2 0F0A 90 SWAP1 0F0B 50 POP 0F0C 50 POP 0F0D 50 POP 0F0E 61 PUSH2 0x2dad 0F11 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F08 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2dad label_0F12: // Incoming return from call to 0x0EE6 at 0x0EE1 0F12 5B JUMPDEST 0F13 00 *STOP // Stack delta = +0 // Outputs[1] { @0F13 stop(); } // Block terminates label_0F14: // Incoming jump from 0x00CC, if 0xb88d4fde == stack[-1] // Inputs[1] { @0F15 msg.value } 0F14 5B JUMPDEST 0F15 34 CALLVALUE 0F16 80 DUP1 0F17 15 ISZERO 0F18 61 PUSH2 0x0f20 0F1B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F15 stack[0] = msg.value } // Block ends with conditional jump to 0x0f20, if !msg.value label_0F1C: // Incoming jump from 0x0F1B, if not !msg.value // Inputs[1] { @0F1F memory[0x00:0x00] } 0F1C 60 PUSH1 0x00 0F1E 80 DUP1 0F1F FD *REVERT // Stack delta = +0 // Outputs[1] { @0F1F revert(memory[0x00:0x00]); } // Block terminates label_0F20: // Incoming jump from 0x0F1B, if !msg.value // Inputs[1] { @0F28 msg.data.length } 0F20 5B JUMPDEST 0F21 50 POP 0F22 61 PUSH2 0x1024 0F25 60 PUSH1 0x04 0F27 80 DUP1 0F28 36 CALLDATASIZE 0F29 03 SUB 0F2A 60 PUSH1 0x80 0F2C 81 DUP2 0F2D 10 LT 0F2E 15 ISZERO 0F2F 61 PUSH2 0x0f37 0F32 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0F22 stack[-1] = 0x1024 // @0F25 stack[0] = 0x04 // @0F29 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0f37, returns to 0x1024, if !(msg.data.length - 0x04 < 0x80) label_0F33: // Incoming jump from 0x0F32, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0F36 memory[0x00:0x00] } 0F33 60 PUSH1 0x00 0F35 80 DUP1 0F36 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F36 revert(memory[0x00:0x00]); } // Block terminates label_0F37: // Incoming call from 0x0F32, returns to 0x1024, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0F38 stack[-2] // @0F39 stack[-1] // @0F3D msg.data[stack[-2]:stack[-2] + 0x20] // @0F5D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0F7D msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0F87 msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 0F37 5B JUMPDEST 0F38 81 DUP2 0F39 01 ADD 0F3A 90 SWAP1 0F3B 80 DUP1 0F3C 80 DUP1 0F3D 35 CALLDATALOAD 0F3E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F53 16 AND 0F54 90 SWAP1 0F55 60 PUSH1 0x20 0F57 01 ADD 0F58 90 SWAP1 0F59 92 SWAP3 0F5A 91 SWAP2 0F5B 90 SWAP1 0F5C 80 DUP1 0F5D 35 CALLDATALOAD 0F5E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F73 16 AND 0F74 90 SWAP1 0F75 60 PUSH1 0x20 0F77 01 ADD 0F78 90 SWAP1 0F79 92 SWAP3 0F7A 91 SWAP2 0F7B 90 SWAP1 0F7C 80 DUP1 0F7D 35 CALLDATALOAD 0F7E 90 SWAP1 0F7F 60 PUSH1 0x20 0F81 01 ADD 0F82 90 SWAP1 0F83 92 SWAP3 0F84 91 SWAP2 0F85 90 SWAP1 0F86 80 DUP1 0F87 35 CALLDATALOAD 0F88 90 SWAP1 0F89 60 PUSH1 0x20 0F8B 01 ADD 0F8C 90 SWAP1 0F8D 64 PUSH5 0x0100000000 0F93 81 DUP2 0F94 11 GT 0F95 15 ISZERO 0F96 61 PUSH2 0x0f9e 0F99 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0F59 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0F79 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0F83 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0F84 stack[1] = stack[-2] + stack[-1] // @0F85 stack[2] = stack[-2] // @0F8C stack[4] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @0F8C stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0f9e, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_0F9A: // Incoming jump from 0x0F99, if not !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0F9D memory[0x00:0x00] } 0F9A 60 PUSH1 0x00 0F9C 80 DUP1 0F9D FD *REVERT // Stack delta = +0 // Outputs[1] { @0F9D revert(memory[0x00:0x00]); } // Block terminates label_0F9E: // Incoming jump from 0x0F99, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0F9F stack[-3] // @0FA0 stack[-1] // @0FA1 stack[-4] // } 0F9E 5B JUMPDEST 0F9F 82 DUP3 0FA0 01 ADD 0FA1 83 DUP4 0FA2 60 PUSH1 0x20 0FA4 82 DUP3 0FA5 01 ADD 0FA6 11 GT 0FA7 15 ISZERO 0FA8 61 PUSH2 0x0fb0 0FAB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0FA0 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0fb0, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0FAC: // Incoming jump from 0x0FAB, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0FAF memory[0x00:0x00] } 0FAC 60 PUSH1 0x00 0FAE 80 DUP1 0FAF FD *REVERT // Stack delta = +0 // Outputs[1] { @0FAF revert(memory[0x00:0x00]); } // Block terminates label_0FB0: // Incoming jump from 0x0FAB, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0FB1 stack[-1] // @0FB2 msg.data[stack[-1]:stack[-1] + 0x20] // @0FB7 stack[-2] // @0FB8 stack[-4] // } 0FB0 5B JUMPDEST 0FB1 80 DUP1 0FB2 35 CALLDATALOAD 0FB3 90 SWAP1 0FB4 60 PUSH1 0x20 0FB6 01 ADD 0FB7 91 SWAP2 0FB8 84 DUP5 0FB9 60 PUSH1 0x01 0FBB 83 DUP4 0FBC 02 MUL 0FBD 84 DUP5 0FBE 01 ADD 0FBF 11 GT 0FC0 64 PUSH5 0x0100000000 0FC6 83 DUP4 0FC7 11 GT 0FC8 17 OR 0FC9 15 ISZERO 0FCA 61 PUSH2 0x0fd2 0FCD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0FB3 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0FB7 stack[0] = stack[-2] // @0FB7 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0fd2, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0FCE: // Incoming jump from 0x0FCD, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0FD1 memory[0x00:0x00] } 0FCE 60 PUSH1 0x00 0FD0 80 DUP1 0FD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FD1 revert(memory[0x00:0x00]); } // Block terminates label_0FD2: // Incoming jump from 0x0FCD, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0FD3 stack[-3] // @0FD3 stack[-1] // @0FD4 stack[-2] // @0FE5 memory[0x40:0x60] // @0FFC msg.data[stack[-3]:stack[-3] + stack[-2]] // @1018 stack[-4] // @1019 stack[-5] // } 0FD2 5B JUMPDEST 0FD3 91 SWAP2 0FD4 90 SWAP1 0FD5 80 DUP1 0FD6 80 DUP1 0FD7 60 PUSH1 0x1f 0FD9 01 ADD 0FDA 60 PUSH1 0x20 0FDC 80 DUP1 0FDD 91 SWAP2 0FDE 04 DIV 0FDF 02 MUL 0FE0 60 PUSH1 0x20 0FE2 01 ADD 0FE3 60 PUSH1 0x40 0FE5 51 MLOAD 0FE6 90 SWAP1 0FE7 81 DUP2 0FE8 01 ADD 0FE9 60 PUSH1 0x40 0FEB 52 MSTORE 0FEC 80 DUP1 0FED 93 SWAP4 0FEE 92 SWAP3 0FEF 91 SWAP2 0FF0 90 SWAP1 0FF1 81 DUP2 0FF2 81 DUP2 0FF3 52 MSTORE 0FF4 60 PUSH1 0x20 0FF6 01 ADD 0FF7 83 DUP4 0FF8 83 DUP4 0FF9 80 DUP1 0FFA 82 DUP3 0FFB 84 DUP5 0FFC 37 CALLDATACOPY 0FFD 60 PUSH1 0x00 0FFF 81 DUP2 1000 84 DUP5 1001 01 ADD 1002 52 MSTORE 1003 60 PUSH1 0x1f 1005 19 NOT 1006 60 PUSH1 0x1f 1008 82 DUP3 1009 01 ADD 100A 16 AND 100B 90 SWAP1 100C 50 POP 100D 80 DUP1 100E 83 DUP4 100F 01 ADD 1010 92 SWAP3 1011 50 POP 1012 50 POP 1013 50 POP 1014 50 POP 1015 50 POP 1016 50 POP 1017 50 POP 1018 91 SWAP2 1019 92 SWAP3 101A 91 SWAP2 101B 92 SWAP3 101C 90 SWAP1 101D 50 POP 101E 50 POP 101F 50 POP 1020 61 PUSH2 0x2e6b 1023 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0FEB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0FF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0FFC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1002 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @101B stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2e6b label_1024: // Incoming return from call to 0x0F37 at 0x0F32 1024 5B JUMPDEST 1025 00 *STOP // Stack delta = +0 // Outputs[1] { @1025 stop(); } // Block terminates label_1026: // Incoming jump from 0x006F, if 0xc30f4a5a == stack[-1] // Inputs[1] { @1027 msg.value } 1026 5B JUMPDEST 1027 34 CALLVALUE 1028 80 DUP1 1029 15 ISZERO 102A 61 PUSH2 0x1032 102D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1027 stack[0] = msg.value } // Block ends with conditional jump to 0x1032, if !msg.value label_102E: // Incoming jump from 0x102D, if not !msg.value // Inputs[1] { @1031 memory[0x00:0x00] } 102E 60 PUSH1 0x00 1030 80 DUP1 1031 FD *REVERT // Stack delta = +0 // Outputs[1] { @1031 revert(memory[0x00:0x00]); } // Block terminates label_1032: // Incoming jump from 0x102D, if !msg.value // Inputs[1] { @103A msg.data.length } 1032 5B JUMPDEST 1033 50 POP 1034 61 PUSH2 0x10ec 1037 60 PUSH1 0x04 1039 80 DUP1 103A 36 CALLDATASIZE 103B 03 SUB 103C 60 PUSH1 0x20 103E 81 DUP2 103F 10 LT 1040 15 ISZERO 1041 61 PUSH2 0x1049 1044 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1034 stack[-1] = 0x10ec // @1037 stack[0] = 0x04 // @103B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x1049, returns to 0x10EC, if !(msg.data.length - 0x04 < 0x20) label_1045: // Incoming jump from 0x1044, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @1048 memory[0x00:0x00] } 1045 60 PUSH1 0x00 1047 80 DUP1 1048 FD *REVERT // Stack delta = +0 // Outputs[1] { @1048 revert(memory[0x00:0x00]); } // Block terminates label_1049: // Incoming call from 0x1044, returns to 0x10EC, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @104A stack[-2] // @104B stack[-1] // @104F msg.data[stack[-2]:stack[-2] + 0x20] // } 1049 5B JUMPDEST 104A 81 DUP2 104B 01 ADD 104C 90 SWAP1 104D 80 DUP1 104E 80 DUP1 104F 35 CALLDATALOAD 1050 90 SWAP1 1051 60 PUSH1 0x20 1053 01 ADD 1054 90 SWAP1 1055 64 PUSH5 0x0100000000 105B 81 DUP2 105C 11 GT 105D 15 ISZERO 105E 61 PUSH2 0x1066 1061 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @104C stack[-1] = stack[-2] // @104C stack[-2] = stack[-2] + stack[-1] // @1054 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @1054 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x1066, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_1062: // Incoming jump from 0x1061, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @1065 memory[0x00:0x00] } 1062 60 PUSH1 0x00 1064 80 DUP1 1065 FD *REVERT // Stack delta = +0 // Outputs[1] { @1065 revert(memory[0x00:0x00]); } // Block terminates label_1066: // Incoming jump from 0x1061, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @1067 stack[-3] // @1068 stack[-1] // @1069 stack[-4] // } 1066 5B JUMPDEST 1067 82 DUP3 1068 01 ADD 1069 83 DUP4 106A 60 PUSH1 0x20 106C 82 DUP3 106D 01 ADD 106E 11 GT 106F 15 ISZERO 1070 61 PUSH2 0x1078 1073 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1068 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1078, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1074: // Incoming jump from 0x1073, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @1077 memory[0x00:0x00] } 1074 60 PUSH1 0x00 1076 80 DUP1 1077 FD *REVERT // Stack delta = +0 // Outputs[1] { @1077 revert(memory[0x00:0x00]); } // Block terminates label_1078: // Incoming jump from 0x1073, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1079 stack[-1] // @107A msg.data[stack[-1]:stack[-1] + 0x20] // @107F stack[-2] // @1080 stack[-4] // } 1078 5B JUMPDEST 1079 80 DUP1 107A 35 CALLDATALOAD 107B 90 SWAP1 107C 60 PUSH1 0x20 107E 01 ADD 107F 91 SWAP2 1080 84 DUP5 1081 60 PUSH1 0x01 1083 83 DUP4 1084 02 MUL 1085 84 DUP5 1086 01 ADD 1087 11 GT 1088 64 PUSH5 0x0100000000 108E 83 DUP4 108F 11 GT 1090 17 OR 1091 15 ISZERO 1092 61 PUSH2 0x109a 1095 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @107B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @107F stack[0] = stack[-2] // @107F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x109a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1096: // Incoming jump from 0x1095, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @1099 memory[0x00:0x00] } 1096 60 PUSH1 0x00 1098 80 DUP1 1099 FD *REVERT // Stack delta = +0 // Outputs[1] { @1099 revert(memory[0x00:0x00]); } // Block terminates label_109A: // Incoming jump from 0x1095, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @109B stack[-1] // @109B stack[-3] // @109C stack[-2] // @10AD memory[0x40:0x60] // @10C4 msg.data[stack[-3]:stack[-3] + stack[-2]] // @10E0 stack[-4] // @10E1 stack[-5] // } 109A 5B JUMPDEST 109B 91 SWAP2 109C 90 SWAP1 109D 80 DUP1 109E 80 DUP1 109F 60 PUSH1 0x1f 10A1 01 ADD 10A2 60 PUSH1 0x20 10A4 80 DUP1 10A5 91 SWAP2 10A6 04 DIV 10A7 02 MUL 10A8 60 PUSH1 0x20 10AA 01 ADD 10AB 60 PUSH1 0x40 10AD 51 MLOAD 10AE 90 SWAP1 10AF 81 DUP2 10B0 01 ADD 10B1 60 PUSH1 0x40 10B3 52 MSTORE 10B4 80 DUP1 10B5 93 SWAP4 10B6 92 SWAP3 10B7 91 SWAP2 10B8 90 SWAP1 10B9 81 DUP2 10BA 81 DUP2 10BB 52 MSTORE 10BC 60 PUSH1 0x20 10BE 01 ADD 10BF 83 DUP4 10C0 83 DUP4 10C1 80 DUP1 10C2 82 DUP3 10C3 84 DUP5 10C4 37 CALLDATACOPY 10C5 60 PUSH1 0x00 10C7 81 DUP2 10C8 84 DUP5 10C9 01 ADD 10CA 52 MSTORE 10CB 60 PUSH1 0x1f 10CD 19 NOT 10CE 60 PUSH1 0x1f 10D0 82 DUP3 10D1 01 ADD 10D2 16 AND 10D3 90 SWAP1 10D4 50 POP 10D5 80 DUP1 10D6 83 DUP4 10D7 01 ADD 10D8 92 SWAP3 10D9 50 POP 10DA 50 POP 10DB 50 POP 10DC 50 POP 10DD 50 POP 10DE 50 POP 10DF 50 POP 10E0 91 SWAP2 10E1 92 SWAP3 10E2 91 SWAP2 10E3 92 SWAP3 10E4 90 SWAP1 10E5 50 POP 10E6 50 POP 10E7 50 POP 10E8 61 PUSH2 0x2ee3 10EB 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @10B3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @10BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @10C4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @10CA memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @10E3 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2ee3 label_10EC: // Incoming return from call to 0x1049 at 0x1044 10EC 5B JUMPDEST 10ED 00 *STOP // Stack delta = +0 // Outputs[1] { @10ED stop(); } // Block terminates label_10EE: // Incoming jump from 0x007A, if 0xc87b56dd == stack[-1] // Inputs[1] { @10EF msg.value } 10EE 5B JUMPDEST 10EF 34 CALLVALUE 10F0 80 DUP1 10F1 15 ISZERO 10F2 61 PUSH2 0x10fa 10F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10EF stack[0] = msg.value } // Block ends with conditional jump to 0x10fa, if !msg.value label_10F6: // Incoming jump from 0x10F5, if not !msg.value // Inputs[1] { @10F9 memory[0x00:0x00] } 10F6 60 PUSH1 0x00 10F8 80 DUP1 10F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @10F9 revert(memory[0x00:0x00]); } // Block terminates label_10FA: // Incoming jump from 0x10F5, if !msg.value // Inputs[1] { @1102 msg.data.length } 10FA 5B JUMPDEST 10FB 50 POP 10FC 61 PUSH2 0x1127 10FF 60 PUSH1 0x04 1101 80 DUP1 1102 36 CALLDATASIZE 1103 03 SUB 1104 60 PUSH1 0x20 1106 81 DUP2 1107 10 LT 1108 15 ISZERO 1109 61 PUSH2 0x1111 110C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @10FC stack[-1] = 0x1127 // @10FF stack[0] = 0x04 // @1103 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x1111, returns to 0x1127, if !(msg.data.length - 0x04 < 0x20) label_110D: // Incoming jump from 0x110C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @1110 memory[0x00:0x00] } 110D 60 PUSH1 0x00 110F 80 DUP1 1110 FD *REVERT // Stack delta = +0 // Outputs[1] { @1110 revert(memory[0x00:0x00]); } // Block terminates label_1111: // Incoming call from 0x110C, returns to 0x1127, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @1112 stack[-2] // @1113 stack[-1] // @1117 msg.data[stack[-2]:stack[-2] + 0x20] // } 1111 5B JUMPDEST 1112 81 DUP2 1113 01 ADD 1114 90 SWAP1 1115 80 DUP1 1116 80 DUP1 1117 35 CALLDATALOAD 1118 90 SWAP1 1119 60 PUSH1 0x20 111B 01 ADD 111C 90 SWAP1 111D 92 SWAP3 111E 91 SWAP2 111F 90 SWAP1 1120 50 POP 1121 50 POP 1122 50 POP 1123 61 PUSH2 0x2f77 1126 56 *JUMP // Stack delta = -1 // Outputs[1] { @111D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2f77 label_1127: // Incoming return from call to 0x1111 at 0x110C // Inputs[4] // { // @112A memory[0x40:0x60] // @1135 stack[-1] // @1138 memory[stack[-1]:stack[-1] + 0x20] // @1141 memory[stack[-1]:stack[-1] + 0x20] // } 1127 5B JUMPDEST 1128 60 PUSH1 0x40 112A 51 MLOAD 112B 80 DUP1 112C 80 DUP1 112D 60 PUSH1 0x20 112F 01 ADD 1130 82 DUP3 1131 81 DUP2 1132 03 SUB 1133 82 DUP3 1134 52 MSTORE 1135 83 DUP4 1136 81 DUP2 1137 81 DUP2 1138 51 MLOAD 1139 81 DUP2 113A 52 MSTORE 113B 60 PUSH1 0x20 113D 01 ADD 113E 91 SWAP2 113F 50 POP 1140 80 DUP1 1141 51 MLOAD 1142 90 SWAP1 1143 60 PUSH1 0x20 1145 01 ADD 1146 90 SWAP1 1147 80 DUP1 1148 83 DUP4 1149 83 DUP4 114A 60 PUSH1 0x00 114C 5B JUMPDEST 114D 83 DUP4 114E 81 DUP2 114F 10 LT 1150 15 ISZERO 1151 61 PUSH2 0x1167 1154 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @112A stack[0] = memory[0x40:0x60] // @112B stack[1] = memory[0x40:0x60] // @1134 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @113A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @113E stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @1146 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @1146 stack[3] = 0x20 + stack[-1] // @1147 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @1148 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @1149 stack[7] = 0x20 + stack[-1] // @114A stack[8] = 0x00 // } // Block ends with conditional jump to 0x1167, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1155: // Incoming jump from 0x1154, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1154, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1155 stack[-1] // @1156 stack[-2] // @1158 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @115A stack[-3] // } 1155 80 DUP1 1156 82 DUP3 1157 01 ADD 1158 51 MLOAD 1159 81 DUP2 115A 84 DUP5 115B 01 ADD 115C 52 MSTORE 115D 60 PUSH1 0x20 115F 81 DUP2 1160 01 ADD 1161 90 SWAP1 1162 50 POP 1163 61 PUSH2 0x114c 1166 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @115C memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1161 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x114c label_1167: // Incoming jump from 0x1154, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1154, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @116C stack[-6] // @116C stack[-5] // @116E stack[-7] // } 1167 5B JUMPDEST 1168 50 POP 1169 50 POP 116A 50 POP 116B 50 POP 116C 90 SWAP1 116D 50 POP 116E 90 SWAP1 116F 81 DUP2 1170 01 ADD 1171 90 SWAP1 1172 60 PUSH1 0x1f 1174 16 AND 1175 80 DUP1 1176 15 ISZERO 1177 61 PUSH2 0x1194 117A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1171 stack[-7] = stack[-5] + stack[-7] // @1174 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1194, if !(0x1f & stack[-5]) label_117B: // Incoming jump from 0x117A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @117B stack[-1] // @117C stack[-2] // @117F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1196 stack[-5] // @119C memory[0x40:0x60] // @11A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 117B 80 DUP1 117C 82 DUP3 117D 03 SUB 117E 80 DUP1 117F 51 MLOAD 1180 60 PUSH1 0x01 1182 83 DUP4 1183 60 PUSH1 0x20 1185 03 SUB 1186 61 PUSH2 0x0100 1189 0A EXP 118A 03 SUB 118B 19 NOT 118C 16 AND 118D 81 DUP2 118E 52 MSTORE 118F 60 PUSH1 0x20 1191 01 ADD 1192 91 SWAP2 1193 50 POP 1194 5B JUMPDEST 1195 50 POP 1196 92 SWAP3 1197 50 POP 1198 50 POP 1199 50 POP 119A 60 PUSH1 0x40 119C 51 MLOAD 119D 80 DUP1 119E 91 SWAP2 119F 03 SUB 11A0 90 SWAP1 11A1 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @118E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @11A1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_11A2: // Incoming jump from 0x0085, if 0xe985e9c5 == stack[-1] // Inputs[1] { @11A3 msg.value } 11A2 5B JUMPDEST 11A3 34 CALLVALUE 11A4 80 DUP1 11A5 15 ISZERO 11A6 61 PUSH2 0x11ae 11A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11A3 stack[0] = msg.value } // Block ends with conditional jump to 0x11ae, if !msg.value label_11AA: // Incoming jump from 0x11A9, if not !msg.value // Inputs[1] { @11AD memory[0x00:0x00] } 11AA 60 PUSH1 0x00 11AC 80 DUP1 11AD FD *REVERT // Stack delta = +0 // Outputs[1] { @11AD revert(memory[0x00:0x00]); } // Block terminates label_11AE: // Incoming jump from 0x11A9, if !msg.value // Inputs[1] { @11B6 msg.data.length } 11AE 5B JUMPDEST 11AF 50 POP 11B0 61 PUSH2 0x1211 11B3 60 PUSH1 0x04 11B5 80 DUP1 11B6 36 CALLDATASIZE 11B7 03 SUB 11B8 60 PUSH1 0x40 11BA 81 DUP2 11BB 10 LT 11BC 15 ISZERO 11BD 61 PUSH2 0x11c5 11C0 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @11B0 stack[-1] = 0x1211 // @11B3 stack[0] = 0x04 // @11B7 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x11c5, returns to 0x1211, if !(msg.data.length - 0x04 < 0x40) label_11C1: // Incoming jump from 0x11C0, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @11C4 memory[0x00:0x00] } 11C1 60 PUSH1 0x00 11C3 80 DUP1 11C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @11C4 revert(memory[0x00:0x00]); } // Block terminates label_11C5: // Incoming call from 0x11C0, returns to 0x1211, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @11C6 stack[-2] // @11C7 stack[-1] // @11CB msg.data[stack[-2]:stack[-2] + 0x20] // @11EB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 11C5 5B JUMPDEST 11C6 81 DUP2 11C7 01 ADD 11C8 90 SWAP1 11C9 80 DUP1 11CA 80 DUP1 11CB 35 CALLDATALOAD 11CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E1 16 AND 11E2 90 SWAP1 11E3 60 PUSH1 0x20 11E5 01 ADD 11E6 90 SWAP1 11E7 92 SWAP3 11E8 91 SWAP2 11E9 90 SWAP1 11EA 80 DUP1 11EB 35 CALLDATALOAD 11EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1201 16 AND 1202 90 SWAP1 1203 60 PUSH1 0x20 1205 01 ADD 1206 90 SWAP1 1207 92 SWAP3 1208 91 SWAP2 1209 90 SWAP1 120A 50 POP 120B 50 POP 120C 50 POP 120D 61 PUSH2 0x30d9 1210 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @11E7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @1207 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x30d9 label_1211: // Incoming return from call to 0x11C5 at 0x11C0 // Inputs[4] // { // @1214 memory[0x40:0x60] // @1216 stack[-1] // @1225 memory[0x40:0x60] // @122A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1211 5B JUMPDEST 1212 60 PUSH1 0x40 1214 51 MLOAD 1215 80 DUP1 1216 82 DUP3 1217 15 ISZERO 1218 15 ISZERO 1219 15 ISZERO 121A 15 ISZERO 121B 81 DUP2 121C 52 MSTORE 121D 60 PUSH1 0x20 121F 01 ADD 1220 91 SWAP2 1221 50 POP 1222 50 POP 1223 60 PUSH1 0x40 1225 51 MLOAD 1226 80 DUP1 1227 91 SWAP2 1228 03 SUB 1229 90 SWAP1 122A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @121C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @122A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_122B: // Incoming jump from 0x0090, if 0xea13cc34 == stack[-1] // Inputs[1] { @122C msg.value } 122B 5B JUMPDEST 122C 34 CALLVALUE 122D 80 DUP1 122E 15 ISZERO 122F 61 PUSH2 0x1237 1232 57 *JUMPI // Stack delta = +1 // Outputs[1] { @122C stack[0] = msg.value } // Block ends with conditional jump to 0x1237, if !msg.value label_1233: // Incoming jump from 0x1232, if not !msg.value // Inputs[1] { @1236 memory[0x00:0x00] } 1233 60 PUSH1 0x00 1235 80 DUP1 1236 FD *REVERT // Stack delta = +0 // Outputs[1] { @1236 revert(memory[0x00:0x00]); } // Block terminates label_1237: // Incoming jump from 0x1232, if !msg.value 1237 5B JUMPDEST 1238 50 POP 1239 61 PUSH2 0x1240 123C 61 PUSH2 0x316d 123F 56 *JUMP // Stack delta = +0 // Outputs[1] { @1239 stack[-1] = 0x1240 } // Block ends with call to 0x316d, returns to 0x1240 label_1240: // Incoming return from call to 0x316D at 0x123F // Inputs[4] // { // @1243 memory[0x40:0x60] // @1245 stack[-1] // @127C memory[0x40:0x60] // @1281 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1240 5B JUMPDEST 1241 60 PUSH1 0x40 1243 51 MLOAD 1244 80 DUP1 1245 82 DUP3 1246 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 125B 16 AND 125C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1271 16 AND 1272 81 DUP2 1273 52 MSTORE 1274 60 PUSH1 0x20 1276 01 ADD 1277 91 SWAP2 1278 50 POP 1279 50 POP 127A 60 PUSH1 0x40 127C 51 MLOAD 127D 80 DUP1 127E 91 SWAP2 127F 03 SUB 1280 90 SWAP1 1281 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @1273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1281 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_1282: // Incoming jump from 0x003E, if 0xf2fde38b == stack[-1] // Inputs[1] { @1283 msg.value } 1282 5B JUMPDEST 1283 34 CALLVALUE 1284 80 DUP1 1285 15 ISZERO 1286 61 PUSH2 0x128e 1289 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1283 stack[0] = msg.value } // Block ends with conditional jump to 0x128e, if !msg.value label_128A: // Incoming jump from 0x1289, if not !msg.value // Inputs[1] { @128D memory[0x00:0x00] } 128A 60 PUSH1 0x00 128C 80 DUP1 128D FD *REVERT // Stack delta = +0 // Outputs[1] { @128D revert(memory[0x00:0x00]); } // Block terminates label_128E: // Incoming jump from 0x1289, if !msg.value // Inputs[1] { @1296 msg.data.length } 128E 5B JUMPDEST 128F 50 POP 1290 61 PUSH2 0x12d1 1293 60 PUSH1 0x04 1295 80 DUP1 1296 36 CALLDATASIZE 1297 03 SUB 1298 60 PUSH1 0x20 129A 81 DUP2 129B 10 LT 129C 15 ISZERO 129D 61 PUSH2 0x12a5 12A0 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1290 stack[-1] = 0x12d1 // @1293 stack[0] = 0x04 // @1297 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x12a5, returns to 0x12D1, if !(msg.data.length - 0x04 < 0x20) label_12A1: // Incoming jump from 0x12A0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @12A4 memory[0x00:0x00] } 12A1 60 PUSH1 0x00 12A3 80 DUP1 12A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @12A4 revert(memory[0x00:0x00]); } // Block terminates label_12A5: // Incoming call from 0x12A0, returns to 0x12D1, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @12A6 stack[-2] // @12A7 stack[-1] // @12AB msg.data[stack[-2]:stack[-2] + 0x20] // } 12A5 5B JUMPDEST 12A6 81 DUP2 12A7 01 ADD 12A8 90 SWAP1 12A9 80 DUP1 12AA 80 DUP1 12AB 35 CALLDATALOAD 12AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12C1 16 AND 12C2 90 SWAP1 12C3 60 PUSH1 0x20 12C5 01 ADD 12C6 90 SWAP1 12C7 92 SWAP3 12C8 91 SWAP2 12C9 90 SWAP1 12CA 50 POP 12CB 50 POP 12CC 50 POP 12CD 61 PUSH2 0x3193 12D0 56 *JUMP // Stack delta = -1 // Outputs[1] { @12C7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x3193 label_12D1: // Incoming return from call to 0x12A5 at 0x12A0 12D1 5B JUMPDEST 12D2 00 *STOP // Stack delta = +0 // Outputs[1] { @12D2 stop(); } // Block terminates label_12D3: // Incoming jump from 0x0049, if 0xf42906ab == stack[-1] // Inputs[1] { @12D4 msg.value } 12D3 5B JUMPDEST 12D4 34 CALLVALUE 12D5 80 DUP1 12D6 15 ISZERO 12D7 61 PUSH2 0x12df 12DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12D4 stack[0] = msg.value } // Block ends with conditional jump to 0x12df, if !msg.value label_12DB: // Incoming jump from 0x12DA, if not !msg.value // Inputs[1] { @12DE memory[0x00:0x00] } 12DB 60 PUSH1 0x00 12DD 80 DUP1 12DE FD *REVERT // Stack delta = +0 // Outputs[1] { @12DE revert(memory[0x00:0x00]); } // Block terminates label_12DF: // Incoming jump from 0x12DA, if !msg.value // Inputs[1] { @12E7 msg.data.length } 12DF 5B JUMPDEST 12E0 50 POP 12E1 61 PUSH2 0x1430 12E4 60 PUSH1 0x04 12E6 80 DUP1 12E7 36 CALLDATASIZE 12E8 03 SUB 12E9 60 PUSH1 0x40 12EB 81 DUP2 12EC 10 LT 12ED 15 ISZERO 12EE 61 PUSH2 0x12f6 12F1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @12E1 stack[-1] = 0x1430 // @12E4 stack[0] = 0x04 // @12E8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x12f6, returns to 0x1430, if !(msg.data.length - 0x04 < 0x40) label_12F2: // Incoming jump from 0x12F1, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @12F5 memory[0x00:0x00] } 12F2 60 PUSH1 0x00 12F4 80 DUP1 12F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @12F5 revert(memory[0x00:0x00]); } // Block terminates label_12F6: // Incoming call from 0x12F1, returns to 0x1430, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @12F7 stack[-2] // @12F8 stack[-1] // @12FC msg.data[stack[-2]:stack[-2] + 0x20] // } 12F6 5B JUMPDEST 12F7 81 DUP2 12F8 01 ADD 12F9 90 SWAP1 12FA 80 DUP1 12FB 80 DUP1 12FC 35 CALLDATALOAD 12FD 90 SWAP1 12FE 60 PUSH1 0x20 1300 01 ADD 1301 90 SWAP1 1302 64 PUSH5 0x0100000000 1308 81 DUP2 1309 11 GT 130A 15 ISZERO 130B 61 PUSH2 0x1313 130E 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @12F9 stack[-1] = stack[-2] // @12F9 stack[-2] = stack[-2] + stack[-1] // @1301 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @1301 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x1313, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_130F: // Incoming jump from 0x130E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @1312 memory[0x00:0x00] } 130F 60 PUSH1 0x00 1311 80 DUP1 1312 FD *REVERT // Stack delta = +0 // Outputs[1] { @1312 revert(memory[0x00:0x00]); } // Block terminates label_1313: // Incoming jump from 0x130E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @1314 stack[-3] // @1315 stack[-1] // @1316 stack[-4] // } 1313 5B JUMPDEST 1314 82 DUP3 1315 01 ADD 1316 83 DUP4 1317 60 PUSH1 0x20 1319 82 DUP3 131A 01 ADD 131B 11 GT 131C 15 ISZERO 131D 61 PUSH2 0x1325 1320 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1315 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1325, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1321: // Incoming jump from 0x1320, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @1324 memory[0x00:0x00] } 1321 60 PUSH1 0x00 1323 80 DUP1 1324 FD *REVERT // Stack delta = +0 // Outputs[1] { @1324 revert(memory[0x00:0x00]); } // Block terminates label_1325: // Incoming jump from 0x1320, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1326 stack[-1] // @1327 msg.data[stack[-1]:stack[-1] + 0x20] // @132C stack[-2] // @132D stack[-4] // } 1325 5B JUMPDEST 1326 80 DUP1 1327 35 CALLDATALOAD 1328 90 SWAP1 1329 60 PUSH1 0x20 132B 01 ADD 132C 91 SWAP2 132D 84 DUP5 132E 60 PUSH1 0x01 1330 83 DUP4 1331 02 MUL 1332 84 DUP5 1333 01 ADD 1334 11 GT 1335 64 PUSH5 0x0100000000 133B 83 DUP4 133C 11 GT 133D 17 OR 133E 15 ISZERO 133F 61 PUSH2 0x1347 1342 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1328 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @132C stack[0] = stack[-2] // @132C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x1347, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1343: // Incoming jump from 0x1342, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @1346 memory[0x00:0x00] } 1343 60 PUSH1 0x00 1345 80 DUP1 1346 FD *REVERT // Stack delta = +0 // Outputs[1] { @1346 revert(memory[0x00:0x00]); } // Block terminates label_1347: // Incoming jump from 0x1342, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @1348 stack[-1] // @1348 stack[-3] // @1349 stack[-2] // @135A memory[0x40:0x60] // @1371 msg.data[stack[-3]:stack[-3] + stack[-2]] // @138D stack[-4] // @138E stack[-5] // @1393 msg.data[stack[-1]:stack[-1] + 0x20] // } 1347 5B JUMPDEST 1348 91 SWAP2 1349 90 SWAP1 134A 80 DUP1 134B 80 DUP1 134C 60 PUSH1 0x1f 134E 01 ADD 134F 60 PUSH1 0x20 1351 80 DUP1 1352 91 SWAP2 1353 04 DIV 1354 02 MUL 1355 60 PUSH1 0x20 1357 01 ADD 1358 60 PUSH1 0x40 135A 51 MLOAD 135B 90 SWAP1 135C 81 DUP2 135D 01 ADD 135E 60 PUSH1 0x40 1360 52 MSTORE 1361 80 DUP1 1362 93 SWAP4 1363 92 SWAP3 1364 91 SWAP2 1365 90 SWAP1 1366 81 DUP2 1367 81 DUP2 1368 52 MSTORE 1369 60 PUSH1 0x20 136B 01 ADD 136C 83 DUP4 136D 83 DUP4 136E 80 DUP1 136F 82 DUP3 1370 84 DUP5 1371 37 CALLDATACOPY 1372 60 PUSH1 0x00 1374 81 DUP2 1375 84 DUP5 1376 01 ADD 1377 52 MSTORE 1378 60 PUSH1 0x1f 137A 19 NOT 137B 60 PUSH1 0x1f 137D 82 DUP3 137E 01 ADD 137F 16 AND 1380 90 SWAP1 1381 50 POP 1382 80 DUP1 1383 83 DUP4 1384 01 ADD 1385 92 SWAP3 1386 50 POP 1387 50 POP 1388 50 POP 1389 50 POP 138A 50 POP 138B 50 POP 138C 50 POP 138D 91 SWAP2 138E 92 SWAP3 138F 91 SWAP2 1390 92 SWAP3 1391 90 SWAP1 1392 80 DUP1 1393 35 CALLDATALOAD 1394 90 SWAP1 1395 60 PUSH1 0x20 1397 01 ADD 1398 90 SWAP1 1399 64 PUSH5 0x0100000000 139F 81 DUP2 13A0 11 GT 13A1 15 ISZERO 13A2 61 PUSH2 0x13aa 13A5 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1360 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1368 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1371 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1377 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @138F stack[-4] = stack[-5] // @1390 stack[-5] = memory[0x40:0x60] // @1391 stack[-3] = stack[-4] // @1398 stack[-2] = 0x20 + stack[-1] // @1398 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x13aa, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_13A6: // Incoming jump from 0x13A5, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @13A9 memory[0x00:0x00] } 13A6 60 PUSH1 0x00 13A8 80 DUP1 13A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @13A9 revert(memory[0x00:0x00]); } // Block terminates label_13AA: // Incoming jump from 0x13A5, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @13AB stack[-3] // @13AC stack[-1] // @13AD stack[-4] // } 13AA 5B JUMPDEST 13AB 82 DUP3 13AC 01 ADD 13AD 83 DUP4 13AE 60 PUSH1 0x20 13B0 82 DUP3 13B1 01 ADD 13B2 11 GT 13B3 15 ISZERO 13B4 61 PUSH2 0x13bc 13B7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @13AC stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x13bc, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_13B8: // Incoming jump from 0x13B7, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @13BB memory[0x00:0x00] } 13B8 60 PUSH1 0x00 13BA 80 DUP1 13BB FD *REVERT // Stack delta = +0 // Outputs[1] { @13BB revert(memory[0x00:0x00]); } // Block terminates label_13BC: // Incoming jump from 0x13B7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @13BD stack[-1] // @13BE msg.data[stack[-1]:stack[-1] + 0x20] // @13C3 stack[-2] // @13C4 stack[-4] // } 13BC 5B JUMPDEST 13BD 80 DUP1 13BE 35 CALLDATALOAD 13BF 90 SWAP1 13C0 60 PUSH1 0x20 13C2 01 ADD 13C3 91 SWAP2 13C4 84 DUP5 13C5 60 PUSH1 0x01 13C7 83 DUP4 13C8 02 MUL 13C9 84 DUP5 13CA 01 ADD 13CB 11 GT 13CC 64 PUSH5 0x0100000000 13D2 83 DUP4 13D3 11 GT 13D4 17 OR 13D5 15 ISZERO 13D6 61 PUSH2 0x13de 13D9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @13BF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @13C3 stack[0] = stack[-2] // @13C3 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x13de, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_13DA: // Incoming jump from 0x13D9, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @13DD memory[0x00:0x00] } 13DA 60 PUSH1 0x00 13DC 80 DUP1 13DD FD *REVERT // Stack delta = +0 // Outputs[1] { @13DD revert(memory[0x00:0x00]); } // Block terminates label_13DE: // Incoming jump from 0x13D9, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @13DF stack[-3] // @13DF stack[-1] // @13E0 stack[-2] // @13F1 memory[0x40:0x60] // @1408 msg.data[stack[-3]:stack[-3] + stack[-2]] // @1424 stack[-4] // @1425 stack[-5] // } 13DE 5B JUMPDEST 13DF 91 SWAP2 13E0 90 SWAP1 13E1 80 DUP1 13E2 80 DUP1 13E3 60 PUSH1 0x1f 13E5 01 ADD 13E6 60 PUSH1 0x20 13E8 80 DUP1 13E9 91 SWAP2 13EA 04 DIV 13EB 02 MUL 13EC 60 PUSH1 0x20 13EE 01 ADD 13EF 60 PUSH1 0x40 13F1 51 MLOAD 13F2 90 SWAP1 13F3 81 DUP2 13F4 01 ADD 13F5 60 PUSH1 0x40 13F7 52 MSTORE 13F8 80 DUP1 13F9 93 SWAP4 13FA 92 SWAP3 13FB 91 SWAP2 13FC 90 SWAP1 13FD 81 DUP2 13FE 81 DUP2 13FF 52 MSTORE 1400 60 PUSH1 0x20 1402 01 ADD 1403 83 DUP4 1404 83 DUP4 1405 80 DUP1 1406 82 DUP3 1407 84 DUP5 1408 37 CALLDATACOPY 1409 60 PUSH1 0x00 140B 81 DUP2 140C 84 DUP5 140D 01 ADD 140E 52 MSTORE 140F 60 PUSH1 0x1f 1411 19 NOT 1412 60 PUSH1 0x1f 1414 82 DUP3 1415 01 ADD 1416 16 AND 1417 90 SWAP1 1418 50 POP 1419 80 DUP1 141A 83 DUP4 141B 01 ADD 141C 92 SWAP3 141D 50 POP 141E 50 POP 141F 50 POP 1420 50 POP 1421 50 POP 1422 50 POP 1423 50 POP 1424 91 SWAP2 1425 92 SWAP3 1426 91 SWAP2 1427 92 SWAP3 1428 90 SWAP1 1429 50 POP 142A 50 POP 142B 50 POP 142C 61 PUSH2 0x3219 142F 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @13F7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @13FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1408 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @140E memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @1427 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x3219 label_1430: // Incoming return from call to 0x12F6 at 0x12F1 1430 5B JUMPDEST 1431 00 *STOP // Stack delta = +0 // Outputs[1] { @1431 stop(); } // Block terminates label_1432: // Incoming jump from 0x0054, if 0xf9ea1e58 == stack[-1] // Inputs[1] { @1439 msg.data.length } 1432 5B JUMPDEST 1433 61 PUSH2 0x1921 1436 60 PUSH1 0x04 1438 80 DUP1 1439 36 CALLDATASIZE 143A 03 SUB 143B 61 PUSH2 0x0140 143E 81 DUP2 143F 10 LT 1440 15 ISZERO 1441 61 PUSH2 0x1449 1444 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1433 stack[0] = 0x1921 // @1436 stack[1] = 0x04 // @143A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x1449, returns to 0x1921, if !(msg.data.length - 0x04 < 0x0140) label_1445: // Incoming jump from 0x1444, if not !(msg.data.length - 0x04 < 0x0140) // Inputs[1] { @1448 memory[0x00:0x00] } 1445 60 PUSH1 0x00 1447 80 DUP1 1448 FD *REVERT // Stack delta = +0 // Outputs[1] { @1448 revert(memory[0x00:0x00]); } // Block terminates label_1449: // Incoming call from 0x1444, returns to 0x1921, if !(msg.data.length - 0x04 < 0x0140) // Inputs[3] // { // @144A stack[-2] // @144B stack[-1] // @144F msg.data[stack[-2]:stack[-2] + 0x20] // } 1449 5B JUMPDEST 144A 81 DUP2 144B 01 ADD 144C 90 SWAP1 144D 80 DUP1 144E 80 DUP1 144F 35 CALLDATALOAD 1450 90 SWAP1 1451 60 PUSH1 0x20 1453 01 ADD 1454 90 SWAP1 1455 64 PUSH5 0x0100000000 145B 81 DUP2 145C 11 GT 145D 15 ISZERO 145E 61 PUSH2 0x1466 1461 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @144C stack[-1] = stack[-2] // @144C stack[-2] = stack[-2] + stack[-1] // @1454 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @1454 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x1466, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_1462: // Incoming jump from 0x1461, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @1465 memory[0x00:0x00] } 1462 60 PUSH1 0x00 1464 80 DUP1 1465 FD *REVERT // Stack delta = +0 // Outputs[1] { @1465 revert(memory[0x00:0x00]); } // Block terminates label_1466: // Incoming jump from 0x1461, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @1467 stack[-3] // @1468 stack[-1] // @1469 stack[-4] // } 1466 5B JUMPDEST 1467 82 DUP3 1468 01 ADD 1469 83 DUP4 146A 60 PUSH1 0x20 146C 82 DUP3 146D 01 ADD 146E 11 GT 146F 15 ISZERO 1470 61 PUSH2 0x1478 1473 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1468 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1478, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1474: // Incoming jump from 0x1473, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @1477 memory[0x00:0x00] } 1474 60 PUSH1 0x00 1476 80 DUP1 1477 FD *REVERT // Stack delta = +0 // Outputs[1] { @1477 revert(memory[0x00:0x00]); } // Block terminates label_1478: // Incoming jump from 0x1473, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1479 stack[-1] // @147A msg.data[stack[-1]:stack[-1] + 0x20] // @147F stack[-2] // @1480 stack[-4] // } 1478 5B JUMPDEST 1479 80 DUP1 147A 35 CALLDATALOAD 147B 90 SWAP1 147C 60 PUSH1 0x20 147E 01 ADD 147F 91 SWAP2 1480 84 DUP5 1481 60 PUSH1 0x01 1483 83 DUP4 1484 02 MUL 1485 84 DUP5 1486 01 ADD 1487 11 GT 1488 64 PUSH5 0x0100000000 148E 83 DUP4 148F 11 GT 1490 17 OR 1491 15 ISZERO 1492 61 PUSH2 0x149a 1495 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @147B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @147F stack[0] = stack[-2] // @147F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x149a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1496: // Incoming jump from 0x1495, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @1499 memory[0x00:0x00] } 1496 60 PUSH1 0x00 1498 80 DUP1 1499 FD *REVERT // Stack delta = +0 // Outputs[1] { @1499 revert(memory[0x00:0x00]); } // Block terminates label_149A: // Incoming jump from 0x1495, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @149B stack[-1] // @149B stack[-3] // @149C stack[-2] // @14AD memory[0x40:0x60] // @14C4 msg.data[stack[-3]:stack[-3] + stack[-2]] // @14E0 stack[-4] // @14E1 stack[-5] // @14E6 msg.data[stack[-1]:stack[-1] + 0x20] // } 149A 5B JUMPDEST 149B 91 SWAP2 149C 90 SWAP1 149D 80 DUP1 149E 80 DUP1 149F 60 PUSH1 0x1f 14A1 01 ADD 14A2 60 PUSH1 0x20 14A4 80 DUP1 14A5 91 SWAP2 14A6 04 DIV 14A7 02 MUL 14A8 60 PUSH1 0x20 14AA 01 ADD 14AB 60 PUSH1 0x40 14AD 51 MLOAD 14AE 90 SWAP1 14AF 81 DUP2 14B0 01 ADD 14B1 60 PUSH1 0x40 14B3 52 MSTORE 14B4 80 DUP1 14B5 93 SWAP4 14B6 92 SWAP3 14B7 91 SWAP2 14B8 90 SWAP1 14B9 81 DUP2 14BA 81 DUP2 14BB 52 MSTORE 14BC 60 PUSH1 0x20 14BE 01 ADD 14BF 83 DUP4 14C0 83 DUP4 14C1 80 DUP1 14C2 82 DUP3 14C3 84 DUP5 14C4 37 CALLDATACOPY 14C5 60 PUSH1 0x00 14C7 81 DUP2 14C8 84 DUP5 14C9 01 ADD 14CA 52 MSTORE 14CB 60 PUSH1 0x1f 14CD 19 NOT 14CE 60 PUSH1 0x1f 14D0 82 DUP3 14D1 01 ADD 14D2 16 AND 14D3 90 SWAP1 14D4 50 POP 14D5 80 DUP1 14D6 83 DUP4 14D7 01 ADD 14D8 92 SWAP3 14D9 50 POP 14DA 50 POP 14DB 50 POP 14DC 50 POP 14DD 50 POP 14DE 50 POP 14DF 50 POP 14E0 91 SWAP2 14E1 92 SWAP3 14E2 91 SWAP2 14E3 92 SWAP3 14E4 90 SWAP1 14E5 80 DUP1 14E6 35 CALLDATALOAD 14E7 90 SWAP1 14E8 60 PUSH1 0x20 14EA 01 ADD 14EB 90 SWAP1 14EC 64 PUSH5 0x0100000000 14F2 81 DUP2 14F3 11 GT 14F4 15 ISZERO 14F5 61 PUSH2 0x14fd 14F8 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @14B3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @14BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @14C4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @14CA memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @14E2 stack[-4] = stack[-5] // @14E3 stack[-5] = memory[0x40:0x60] // @14E4 stack[-3] = stack[-4] // @14EB stack[-2] = 0x20 + stack[-1] // @14EB stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x14fd, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_14F9: // Incoming jump from 0x14F8, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @14FC memory[0x00:0x00] } 14F9 60 PUSH1 0x00 14FB 80 DUP1 14FC FD *REVERT // Stack delta = +0 // Outputs[1] { @14FC revert(memory[0x00:0x00]); } // Block terminates label_14FD: // Incoming jump from 0x14F8, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @14FE stack[-3] // @14FF stack[-1] // @1500 stack[-4] // } 14FD 5B JUMPDEST 14FE 82 DUP3 14FF 01 ADD 1500 83 DUP4 1501 60 PUSH1 0x20 1503 82 DUP3 1504 01 ADD 1505 11 GT 1506 15 ISZERO 1507 61 PUSH2 0x150f 150A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @14FF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x150f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_150B: // Incoming jump from 0x150A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @150E memory[0x00:0x00] } 150B 60 PUSH1 0x00 150D 80 DUP1 150E FD *REVERT // Stack delta = +0 // Outputs[1] { @150E revert(memory[0x00:0x00]); } // Block terminates label_150F: // Incoming jump from 0x150A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1510 stack[-1] // @1511 msg.data[stack[-1]:stack[-1] + 0x20] // @1516 stack[-2] // @1517 stack[-4] // } 150F 5B JUMPDEST 1510 80 DUP1 1511 35 CALLDATALOAD 1512 90 SWAP1 1513 60 PUSH1 0x20 1515 01 ADD 1516 91 SWAP2 1517 84 DUP5 1518 60 PUSH1 0x01 151A 83 DUP4 151B 02 MUL 151C 84 DUP5 151D 01 ADD 151E 11 GT 151F 64 PUSH5 0x0100000000 1525 83 DUP4 1526 11 GT 1527 17 OR 1528 15 ISZERO 1529 61 PUSH2 0x1531 152C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1512 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @1516 stack[0] = stack[-2] // @1516 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x1531, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_152D: // Incoming jump from 0x152C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @1530 memory[0x00:0x00] } 152D 60 PUSH1 0x00 152F 80 DUP1 1530 FD *REVERT // Stack delta = +0 // Outputs[1] { @1530 revert(memory[0x00:0x00]); } // Block terminates label_1531: // Incoming jump from 0x152C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @1532 stack[-3] // @1532 stack[-1] // @1533 stack[-2] // @1544 memory[0x40:0x60] // @155B msg.data[stack[-3]:stack[-3] + stack[-2]] // @1577 stack[-4] // @1578 stack[-5] // @157D msg.data[stack[-1]:stack[-1] + 0x20] // } 1531 5B JUMPDEST 1532 91 SWAP2 1533 90 SWAP1 1534 80 DUP1 1535 80 DUP1 1536 60 PUSH1 0x1f 1538 01 ADD 1539 60 PUSH1 0x20 153B 80 DUP1 153C 91 SWAP2 153D 04 DIV 153E 02 MUL 153F 60 PUSH1 0x20 1541 01 ADD 1542 60 PUSH1 0x40 1544 51 MLOAD 1545 90 SWAP1 1546 81 DUP2 1547 01 ADD 1548 60 PUSH1 0x40 154A 52 MSTORE 154B 80 DUP1 154C 93 SWAP4 154D 92 SWAP3 154E 91 SWAP2 154F 90 SWAP1 1550 81 DUP2 1551 81 DUP2 1552 52 MSTORE 1553 60 PUSH1 0x20 1555 01 ADD 1556 83 DUP4 1557 83 DUP4 1558 80 DUP1 1559 82 DUP3 155A 84 DUP5 155B 37 CALLDATACOPY 155C 60 PUSH1 0x00 155E 81 DUP2 155F 84 DUP5 1560 01 ADD 1561 52 MSTORE 1562 60 PUSH1 0x1f 1564 19 NOT 1565 60 PUSH1 0x1f 1567 82 DUP3 1568 01 ADD 1569 16 AND 156A 90 SWAP1 156B 50 POP 156C 80 DUP1 156D 83 DUP4 156E 01 ADD 156F 92 SWAP3 1570 50 POP 1571 50 POP 1572 50 POP 1573 50 POP 1574 50 POP 1575 50 POP 1576 50 POP 1577 91 SWAP2 1578 92 SWAP3 1579 91 SWAP2 157A 92 SWAP3 157B 90 SWAP1 157C 80 DUP1 157D 35 CALLDATALOAD 157E 90 SWAP1 157F 60 PUSH1 0x20 1581 01 ADD 1582 90 SWAP1 1583 64 PUSH5 0x0100000000 1589 81 DUP2 158A 11 GT 158B 15 ISZERO 158C 61 PUSH2 0x1594 158F 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @154A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1552 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @155B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1561 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @1579 stack[-4] = stack[-5] // @157A stack[-5] = memory[0x40:0x60] // @157B stack[-3] = stack[-4] // @1582 stack[-2] = 0x20 + stack[-1] // @1582 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x1594, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_1590: // Incoming jump from 0x158F, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @1593 memory[0x00:0x00] } 1590 60 PUSH1 0x00 1592 80 DUP1 1593 FD *REVERT // Stack delta = +0 // Outputs[1] { @1593 revert(memory[0x00:0x00]); } // Block terminates label_1594: // Incoming jump from 0x158F, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @1595 stack[-3] // @1596 stack[-1] // @1597 stack[-4] // } 1594 5B JUMPDEST 1595 82 DUP3 1596 01 ADD 1597 83 DUP4 1598 60 PUSH1 0x20 159A 82 DUP3 159B 01 ADD 159C 11 GT 159D 15 ISZERO 159E 61 PUSH2 0x15a6 15A1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1596 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x15a6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_15A2: // Incoming jump from 0x15A1, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @15A5 memory[0x00:0x00] } 15A2 60 PUSH1 0x00 15A4 80 DUP1 15A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @15A5 revert(memory[0x00:0x00]); } // Block terminates label_15A6: // Incoming jump from 0x15A1, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @15A7 stack[-1] // @15A8 msg.data[stack[-1]:stack[-1] + 0x20] // @15AD stack[-2] // @15AE stack[-4] // } 15A6 5B JUMPDEST 15A7 80 DUP1 15A8 35 CALLDATALOAD 15A9 90 SWAP1 15AA 60 PUSH1 0x20 15AC 01 ADD 15AD 91 SWAP2 15AE 84 DUP5 15AF 60 PUSH1 0x01 15B1 83 DUP4 15B2 02 MUL 15B3 84 DUP5 15B4 01 ADD 15B5 11 GT 15B6 64 PUSH5 0x0100000000 15BC 83 DUP4 15BD 11 GT 15BE 17 OR 15BF 15 ISZERO 15C0 61 PUSH2 0x15c8 15C3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @15A9 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @15AD stack[0] = stack[-2] // @15AD stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x15c8, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_15C4: // Incoming jump from 0x15C3, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @15C7 memory[0x00:0x00] } 15C4 60 PUSH1 0x00 15C6 80 DUP1 15C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @15C7 revert(memory[0x00:0x00]); } // Block terminates label_15C8: // Incoming jump from 0x15C3, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @15C9 stack[-3] // @15C9 stack[-1] // @15CA stack[-2] // @15DB memory[0x40:0x60] // @15F2 msg.data[stack[-3]:stack[-3] + stack[-2]] // @160E stack[-4] // @160F stack[-5] // @1614 msg.data[stack[-1]:stack[-1] + 0x20] // } 15C8 5B JUMPDEST 15C9 91 SWAP2 15CA 90 SWAP1 15CB 80 DUP1 15CC 80 DUP1 15CD 60 PUSH1 0x1f 15CF 01 ADD 15D0 60 PUSH1 0x20 15D2 80 DUP1 15D3 91 SWAP2 15D4 04 DIV 15D5 02 MUL 15D6 60 PUSH1 0x20 15D8 01 ADD 15D9 60 PUSH1 0x40 15DB 51 MLOAD 15DC 90 SWAP1 15DD 81 DUP2 15DE 01 ADD 15DF 60 PUSH1 0x40 15E1 52 MSTORE 15E2 80 DUP1 15E3 93 SWAP4 15E4 92 SWAP3 15E5 91 SWAP2 15E6 90 SWAP1 15E7 81 DUP2 15E8 81 DUP2 15E9 52 MSTORE 15EA 60 PUSH1 0x20 15EC 01 ADD 15ED 83 DUP4 15EE 83 DUP4 15EF 80 DUP1 15F0 82 DUP3 15F1 84 DUP5 15F2 37 CALLDATACOPY 15F3 60 PUSH1 0x00 15F5 81 DUP2 15F6 84 DUP5 15F7 01 ADD 15F8 52 MSTORE 15F9 60 PUSH1 0x1f 15FB 19 NOT 15FC 60 PUSH1 0x1f 15FE 82 DUP3 15FF 01 ADD 1600 16 AND 1601 90 SWAP1 1602 50 POP 1603 80 DUP1 1604 83 DUP4 1605 01 ADD 1606 92 SWAP3 1607 50 POP 1608 50 POP 1609 50 POP 160A 50 POP 160B 50 POP 160C 50 POP 160D 50 POP 160E 91 SWAP2 160F 92 SWAP3 1610 91 SWAP2 1611 92 SWAP3 1612 90 SWAP1 1613 80 DUP1 1614 35 CALLDATALOAD 1615 90 SWAP1 1616 60 PUSH1 0x20 1618 01 ADD 1619 90 SWAP1 161A 64 PUSH5 0x0100000000 1620 81 DUP2 1621 11 GT 1622 15 ISZERO 1623 61 PUSH2 0x162b 1626 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @15E1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @15E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @15F2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @15F8 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @1610 stack[-4] = stack[-5] // @1611 stack[-5] = memory[0x40:0x60] // @1612 stack[-3] = stack[-4] // @1619 stack[-2] = 0x20 + stack[-1] // @1619 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x162b, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_1627: // Incoming jump from 0x1626, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @162A memory[0x00:0x00] } 1627 60 PUSH1 0x00 1629 80 DUP1 162A FD *REVERT // Stack delta = +0 // Outputs[1] { @162A revert(memory[0x00:0x00]); } // Block terminates label_162B: // Incoming jump from 0x1626, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @162C stack[-3] // @162D stack[-1] // @162E stack[-4] // } 162B 5B JUMPDEST 162C 82 DUP3 162D 01 ADD 162E 83 DUP4 162F 60 PUSH1 0x20 1631 82 DUP3 1632 01 ADD 1633 11 GT 1634 15 ISZERO 1635 61 PUSH2 0x163d 1638 57 *JUMPI // Stack delta = +0 // Outputs[1] { @162D stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x163d, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1639: // Incoming jump from 0x1638, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @163C memory[0x00:0x00] } 1639 60 PUSH1 0x00 163B 80 DUP1 163C FD *REVERT // Stack delta = +0 // Outputs[1] { @163C revert(memory[0x00:0x00]); } // Block terminates label_163D: // Incoming jump from 0x1638, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @163E stack[-1] // @163F msg.data[stack[-1]:stack[-1] + 0x20] // @1644 stack[-2] // @1645 stack[-4] // } 163D 5B JUMPDEST 163E 80 DUP1 163F 35 CALLDATALOAD 1640 90 SWAP1 1641 60 PUSH1 0x20 1643 01 ADD 1644 91 SWAP2 1645 84 DUP5 1646 60 PUSH1 0x01 1648 83 DUP4 1649 02 MUL 164A 84 DUP5 164B 01 ADD 164C 11 GT 164D 64 PUSH5 0x0100000000 1653 83 DUP4 1654 11 GT 1655 17 OR 1656 15 ISZERO 1657 61 PUSH2 0x165f 165A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1640 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @1644 stack[0] = stack[-2] // @1644 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x165f, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_165B: // Incoming jump from 0x165A, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @165E memory[0x00:0x00] } 165B 60 PUSH1 0x00 165D 80 DUP1 165E FD *REVERT // Stack delta = +0 // Outputs[1] { @165E revert(memory[0x00:0x00]); } // Block terminates label_165F: // Incoming jump from 0x165A, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @1660 stack[-3] // @1660 stack[-1] // @1661 stack[-2] // @1672 memory[0x40:0x60] // @1689 msg.data[stack[-3]:stack[-3] + stack[-2]] // @16A5 stack[-4] // @16A6 stack[-5] // @16AB msg.data[stack[-1]:stack[-1] + 0x20] // } 165F 5B JUMPDEST 1660 91 SWAP2 1661 90 SWAP1 1662 80 DUP1 1663 80 DUP1 1664 60 PUSH1 0x1f 1666 01 ADD 1667 60 PUSH1 0x20 1669 80 DUP1 166A 91 SWAP2 166B 04 DIV 166C 02 MUL 166D 60 PUSH1 0x20 166F 01 ADD 1670 60 PUSH1 0x40 1672 51 MLOAD 1673 90 SWAP1 1674 81 DUP2 1675 01 ADD 1676 60 PUSH1 0x40 1678 52 MSTORE 1679 80 DUP1 167A 93 SWAP4 167B 92 SWAP3 167C 91 SWAP2 167D 90 SWAP1 167E 81 DUP2 167F 81 DUP2 1680 52 MSTORE 1681 60 PUSH1 0x20 1683 01 ADD 1684 83 DUP4 1685 83 DUP4 1686 80 DUP1 1687 82 DUP3 1688 84 DUP5 1689 37 CALLDATACOPY 168A 60 PUSH1 0x00 168C 81 DUP2 168D 84 DUP5 168E 01 ADD 168F 52 MSTORE 1690 60 PUSH1 0x1f 1692 19 NOT 1693 60 PUSH1 0x1f 1695 82 DUP3 1696 01 ADD 1697 16 AND 1698 90 SWAP1 1699 50 POP 169A 80 DUP1 169B 83 DUP4 169C 01 ADD 169D 92 SWAP3 169E 50 POP 169F 50 POP 16A0 50 POP 16A1 50 POP 16A2 50 POP 16A3 50 POP 16A4 50 POP 16A5 91 SWAP2 16A6 92 SWAP3 16A7 91 SWAP2 16A8 92 SWAP3 16A9 90 SWAP1 16AA 80 DUP1 16AB 35 CALLDATALOAD 16AC 90 SWAP1 16AD 60 PUSH1 0x20 16AF 01 ADD 16B0 90 SWAP1 16B1 64 PUSH5 0x0100000000 16B7 81 DUP2 16B8 11 GT 16B9 15 ISZERO 16BA 61 PUSH2 0x16c2 16BD 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1678 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1680 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1689 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @168F memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @16A7 stack[-4] = stack[-5] // @16A8 stack[-5] = memory[0x40:0x60] // @16A9 stack[-3] = stack[-4] // @16B0 stack[-2] = 0x20 + stack[-1] // @16B0 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x16c2, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_16BE: // Incoming jump from 0x16BD, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @16C1 memory[0x00:0x00] } 16BE 60 PUSH1 0x00 16C0 80 DUP1 16C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @16C1 revert(memory[0x00:0x00]); } // Block terminates label_16C2: // Incoming jump from 0x16BD, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @16C3 stack[-3] // @16C4 stack[-1] // @16C5 stack[-4] // } 16C2 5B JUMPDEST 16C3 82 DUP3 16C4 01 ADD 16C5 83 DUP4 16C6 60 PUSH1 0x20 16C8 82 DUP3 16C9 01 ADD 16CA 11 GT 16CB 15 ISZERO 16CC 61 PUSH2 0x16d4 16CF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @16C4 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x16d4, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_16D0: // Incoming jump from 0x16CF, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @16D3 memory[0x00:0x00] } 16D0 60 PUSH1 0x00 16D2 80 DUP1 16D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @16D3 revert(memory[0x00:0x00]); } // Block terminates label_16D4: // Incoming jump from 0x16CF, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @16D5 stack[-1] // @16D6 msg.data[stack[-1]:stack[-1] + 0x20] // @16DB stack[-2] // @16DC stack[-4] // } 16D4 5B JUMPDEST 16D5 80 DUP1 16D6 35 CALLDATALOAD 16D7 90 SWAP1 16D8 60 PUSH1 0x20 16DA 01 ADD 16DB 91 SWAP2 16DC 84 DUP5 16DD 60 PUSH1 0x01 16DF 83 DUP4 16E0 02 MUL 16E1 84 DUP5 16E2 01 ADD 16E3 11 GT 16E4 64 PUSH5 0x0100000000 16EA 83 DUP4 16EB 11 GT 16EC 17 OR 16ED 15 ISZERO 16EE 61 PUSH2 0x16f6 16F1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @16D7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @16DB stack[0] = stack[-2] // @16DB stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x16f6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_16F2: // Incoming jump from 0x16F1, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @16F5 memory[0x00:0x00] } 16F2 60 PUSH1 0x00 16F4 80 DUP1 16F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @16F5 revert(memory[0x00:0x00]); } // Block terminates label_16F6: // Incoming jump from 0x16F1, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @16F7 stack[-3] // @16F7 stack[-1] // @16F8 stack[-2] // @1709 memory[0x40:0x60] // @1720 msg.data[stack[-3]:stack[-3] + stack[-2]] // @173C stack[-4] // @173D stack[-5] // @1742 msg.data[stack[-1]:stack[-1] + 0x20] // } 16F6 5B JUMPDEST 16F7 91 SWAP2 16F8 90 SWAP1 16F9 80 DUP1 16FA 80 DUP1 16FB 60 PUSH1 0x1f 16FD 01 ADD 16FE 60 PUSH1 0x20 1700 80 DUP1 1701 91 SWAP2 1702 04 DIV 1703 02 MUL 1704 60 PUSH1 0x20 1706 01 ADD 1707 60 PUSH1 0x40 1709 51 MLOAD 170A 90 SWAP1 170B 81 DUP2 170C 01 ADD 170D 60 PUSH1 0x40 170F 52 MSTORE 1710 80 DUP1 1711 93 SWAP4 1712 92 SWAP3 1713 91 SWAP2 1714 90 SWAP1 1715 81 DUP2 1716 81 DUP2 1717 52 MSTORE 1718 60 PUSH1 0x20 171A 01 ADD 171B 83 DUP4 171C 83 DUP4 171D 80 DUP1 171E 82 DUP3 171F 84 DUP5 1720 37 CALLDATACOPY 1721 60 PUSH1 0x00 1723 81 DUP2 1724 84 DUP5 1725 01 ADD 1726 52 MSTORE 1727 60 PUSH1 0x1f 1729 19 NOT 172A 60 PUSH1 0x1f 172C 82 DUP3 172D 01 ADD 172E 16 AND 172F 90 SWAP1 1730 50 POP 1731 80 DUP1 1732 83 DUP4 1733 01 ADD 1734 92 SWAP3 1735 50 POP 1736 50 POP 1737 50 POP 1738 50 POP 1739 50 POP 173A 50 POP 173B 50 POP 173C 91 SWAP2 173D 92 SWAP3 173E 91 SWAP2 173F 92 SWAP3 1740 90 SWAP1 1741 80 DUP1 1742 35 CALLDATALOAD 1743 90 SWAP1 1744 60 PUSH1 0x20 1746 01 ADD 1747 90 SWAP1 1748 64 PUSH5 0x0100000000 174E 81 DUP2 174F 11 GT 1750 15 ISZERO 1751 61 PUSH2 0x1759 1754 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @170F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1717 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1720 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1726 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @173E stack[-4] = stack[-5] // @173F stack[-5] = memory[0x40:0x60] // @1740 stack[-3] = stack[-4] // @1747 stack[-2] = 0x20 + stack[-1] // @1747 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x1759, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_1755: // Incoming jump from 0x1754, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @1758 memory[0x00:0x00] } 1755 60 PUSH1 0x00 1757 80 DUP1 1758 FD *REVERT // Stack delta = +0 // Outputs[1] { @1758 revert(memory[0x00:0x00]); } // Block terminates label_1759: // Incoming jump from 0x1754, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @175A stack[-3] // @175B stack[-1] // @175C stack[-4] // } 1759 5B JUMPDEST 175A 82 DUP3 175B 01 ADD 175C 83 DUP4 175D 60 PUSH1 0x20 175F 82 DUP3 1760 01 ADD 1761 11 GT 1762 15 ISZERO 1763 61 PUSH2 0x176b 1766 57 *JUMPI // Stack delta = +0 // Outputs[1] { @175B stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x176b, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_1767: // Incoming jump from 0x1766, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @176A memory[0x00:0x00] } 1767 60 PUSH1 0x00 1769 80 DUP1 176A FD *REVERT // Stack delta = +0 // Outputs[1] { @176A revert(memory[0x00:0x00]); } // Block terminates label_176B: // Incoming jump from 0x1766, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @176C stack[-1] // @176D msg.data[stack[-1]:stack[-1] + 0x20] // @1772 stack[-2] // @1773 stack[-4] // } 176B 5B JUMPDEST 176C 80 DUP1 176D 35 CALLDATALOAD 176E 90 SWAP1 176F 60 PUSH1 0x20 1771 01 ADD 1772 91 SWAP2 1773 84 DUP5 1774 60 PUSH1 0x01 1776 83 DUP4 1777 02 MUL 1778 84 DUP5 1779 01 ADD 177A 11 GT 177B 64 PUSH5 0x0100000000 1781 83 DUP4 1782 11 GT 1783 17 OR 1784 15 ISZERO 1785 61 PUSH2 0x178d 1788 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @176E stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @1772 stack[0] = stack[-2] // @1772 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x178d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1789: // Incoming jump from 0x1788, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @178C memory[0x00:0x00] } 1789 60 PUSH1 0x00 178B 80 DUP1 178C FD *REVERT // Stack delta = +0 // Outputs[1] { @178C revert(memory[0x00:0x00]); } // Block terminates label_178D: // Incoming jump from 0x1788, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @178E stack[-1] // @178E stack[-3] // @178F stack[-2] // @17A0 memory[0x40:0x60] // @17B7 msg.data[stack[-3]:stack[-3] + stack[-2]] // @17D3 stack[-4] // @17D4 stack[-5] // @17D9 msg.data[stack[-1]:stack[-1] + 0x20] // } 178D 5B JUMPDEST 178E 91 SWAP2 178F 90 SWAP1 1790 80 DUP1 1791 80 DUP1 1792 60 PUSH1 0x1f 1794 01 ADD 1795 60 PUSH1 0x20 1797 80 DUP1 1798 91 SWAP2 1799 04 DIV 179A 02 MUL 179B 60 PUSH1 0x20 179D 01 ADD 179E 60 PUSH1 0x40 17A0 51 MLOAD 17A1 90 SWAP1 17A2 81 DUP2 17A3 01 ADD 17A4 60 PUSH1 0x40 17A6 52 MSTORE 17A7 80 DUP1 17A8 93 SWAP4 17A9 92 SWAP3 17AA 91 SWAP2 17AB 90 SWAP1 17AC 81 DUP2 17AD 81 DUP2 17AE 52 MSTORE 17AF 60 PUSH1 0x20 17B1 01 ADD 17B2 83 DUP4 17B3 83 DUP4 17B4 80 DUP1 17B5 82 DUP3 17B6 84 DUP5 17B7 37 CALLDATACOPY 17B8 60 PUSH1 0x00 17BA 81 DUP2 17BB 84 DUP5 17BC 01 ADD 17BD 52 MSTORE 17BE 60 PUSH1 0x1f 17C0 19 NOT 17C1 60 PUSH1 0x1f 17C3 82 DUP3 17C4 01 ADD 17C5 16 AND 17C6 90 SWAP1 17C7 50 POP 17C8 80 DUP1 17C9 83 DUP4 17CA 01 ADD 17CB 92 SWAP3 17CC 50 POP 17CD 50 POP 17CE 50 POP 17CF 50 POP 17D0 50 POP 17D1 50 POP 17D2 50 POP 17D3 91 SWAP2 17D4 92 SWAP3 17D5 91 SWAP2 17D6 92 SWAP3 17D7 90 SWAP1 17D8 80 DUP1 17D9 35 CALLDATALOAD 17DA 90 SWAP1 17DB 60 PUSH1 0x20 17DD 01 ADD 17DE 90 SWAP1 17DF 64 PUSH5 0x0100000000 17E5 81 DUP2 17E6 11 GT 17E7 15 ISZERO 17E8 61 PUSH2 0x17f0 17EB 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @17A6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @17AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @17B7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @17BD memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @17D5 stack[-4] = stack[-5] // @17D6 stack[-5] = memory[0x40:0x60] // @17D7 stack[-3] = stack[-4] // @17DE stack[-2] = 0x20 + stack[-1] // @17DE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x17f0, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_17EC: // Incoming jump from 0x17EB, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @17EF memory[0x00:0x00] } 17EC 60 PUSH1 0x00 17EE 80 DUP1 17EF FD *REVERT // Stack delta = +0 // Outputs[1] { @17EF revert(memory[0x00:0x00]); } // Block terminates label_17F0: // Incoming jump from 0x17EB, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @17F1 stack[-3] // @17F2 stack[-1] // @17F3 stack[-4] // } 17F0 5B JUMPDEST 17F1 82 DUP3 17F2 01 ADD 17F3 83 DUP4 17F4 60 PUSH1 0x20 17F6 82 DUP3 17F7 01 ADD 17F8 11 GT 17F9 15 ISZERO 17FA 61 PUSH2 0x1802 17FD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @17F2 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1802, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_17FE: // Incoming jump from 0x17FD, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @1801 memory[0x00:0x00] } 17FE 60 PUSH1 0x00 1800 80 DUP1 1801 FD *REVERT // Stack delta = +0 // Outputs[1] { @1801 revert(memory[0x00:0x00]); } // Block terminates label_1802: // Incoming jump from 0x17FD, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @1803 stack[-1] // @1804 msg.data[stack[-1]:stack[-1] + 0x20] // @1809 stack[-2] // @180A stack[-4] // } 1802 5B JUMPDEST 1803 80 DUP1 1804 35 CALLDATALOAD 1805 90 SWAP1 1806 60 PUSH1 0x20 1808 01 ADD 1809 91 SWAP2 180A 84 DUP5 180B 60 PUSH1 0x01 180D 83 DUP4 180E 02 MUL 180F 84 DUP5 1810 01 ADD 1811 11 GT 1812 64 PUSH5 0x0100000000 1818 83 DUP4 1819 11 GT 181A 17 OR 181B 15 ISZERO 181C 61 PUSH2 0x1824 181F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1805 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @1809 stack[0] = stack[-2] // @1809 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x1824, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_1820: // Incoming jump from 0x181F, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @1823 memory[0x00:0x00] } 1820 60 PUSH1 0x00 1822 80 DUP1 1823 FD *REVERT // Stack delta = +0 // Outputs[1] { @1823 revert(memory[0x00:0x00]); } // Block terminates label_1824: // Incoming jump from 0x181F, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[10] // { // @1825 stack[-3] // @1825 stack[-1] // @1826 stack[-2] // @1837 memory[0x40:0x60] // @184E msg.data[stack[-3]:stack[-3] + stack[-2]] // @186A stack[-4] // @186B stack[-5] // @1870 msg.data[stack[-1]:stack[-1] + 0x20] // @187A msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1884 msg.data[0x20 + 0x20 + stack[-1]:0x20 + 0x20 + stack[-1] + 0x20] // } 1824 5B JUMPDEST 1825 91 SWAP2 1826 90 SWAP1 1827 80 DUP1 1828 80 DUP1 1829 60 PUSH1 0x1f 182B 01 ADD 182C 60 PUSH1 0x20 182E 80 DUP1 182F 91 SWAP2 1830 04 DIV 1831 02 MUL 1832 60 PUSH1 0x20 1834 01 ADD 1835 60 PUSH1 0x40 1837 51 MLOAD 1838 90 SWAP1 1839 81 DUP2 183A 01 ADD 183B 60 PUSH1 0x40 183D 52 MSTORE 183E 80 DUP1 183F 93 SWAP4 1840 92 SWAP3 1841 91 SWAP2 1842 90 SWAP1 1843 81 DUP2 1844 81 DUP2 1845 52 MSTORE 1846 60 PUSH1 0x20 1848 01 ADD 1849 83 DUP4 184A 83 DUP4 184B 80 DUP1 184C 82 DUP3 184D 84 DUP5 184E 37 CALLDATACOPY 184F 60 PUSH1 0x00 1851 81 DUP2 1852 84 DUP5 1853 01 ADD 1854 52 MSTORE 1855 60 PUSH1 0x1f 1857 19 NOT 1858 60 PUSH1 0x1f 185A 82 DUP3 185B 01 ADD 185C 16 AND 185D 90 SWAP1 185E 50 POP 185F 80 DUP1 1860 83 DUP4 1861 01 ADD 1862 92 SWAP3 1863 50 POP 1864 50 POP 1865 50 POP 1866 50 POP 1867 50 POP 1868 50 POP 1869 50 POP 186A 91 SWAP2 186B 92 SWAP3 186C 91 SWAP2 186D 92 SWAP3 186E 90 SWAP1 186F 80 DUP1 1870 35 CALLDATALOAD 1871 90 SWAP1 1872 60 PUSH1 0x20 1874 01 ADD 1875 90 SWAP1 1876 92 SWAP3 1877 91 SWAP2 1878 90 SWAP1 1879 80 DUP1 187A 35 CALLDATALOAD 187B 90 SWAP1 187C 60 PUSH1 0x20 187E 01 ADD 187F 90 SWAP1 1880 92 SWAP3 1881 91 SWAP2 1882 90 SWAP1 1883 80 DUP1 1884 35 CALLDATALOAD 1885 90 SWAP1 1886 60 PUSH1 0x20 1888 01 ADD 1889 90 SWAP1 188A 64 PUSH5 0x0100000000 1890 81 DUP2 1891 11 GT 1892 15 ISZERO 1893 61 PUSH2 0x189b 1896 57 *JUMPI // Stack delta = +2 // Outputs[11] // { // @183D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1845 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @184E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1854 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @186D stack[-5] = memory[0x40:0x60] // @1876 stack[-4] = msg.data[stack[-1]:stack[-1] + 0x20] // @1880 stack[-3] = msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @1881 stack[-2] = stack[-5] // @1882 stack[-1] = stack[-4] // @1889 stack[0] = 0x20 + 0x20 + 0x20 + stack[-1] // @1889 stack[1] = msg.data[0x20 + 0x20 + stack[-1]:0x20 + 0x20 + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x189b, if !(msg.data[0x20 + 0x20 + stack[-1]:0x20 + 0x20 + stack[-1] + 0x20] > 0x0100000000) label_1897: // Incoming jump from 0x1896, if not !(msg.data[0x20 + 0x20 + stack[-1]:0x20 + 0x20 + stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @189A memory[0x00:0x00] } 1897 60 PUSH1 0x00 1899 80 DUP1 189A FD *REVERT // Stack delta = +0 // Outputs[1] { @189A revert(memory[0x00:0x00]); } // Block terminates label_189B: // Incoming jump from 0x1896, if !(msg.data[0x20 + 0x20 + stack[-1]:0x20 + 0x20 + stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @189C stack[-3] // @189D stack[-1] // @189E stack[-4] // } 189B 5B JUMPDEST 189C 82 DUP3 189D 01 ADD 189E 83 DUP4 189F 60 PUSH1 0x20 18A1 82 DUP3 18A2 01 ADD 18A3 11 GT 18A4 15 ISZERO 18A5 61 PUSH2 0x18ad 18A8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @189D stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x18ad, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_18A9: // Incoming jump from 0x18A8, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @18AC memory[0x00:0x00] } 18A9 60 PUSH1 0x00 18AB 80 DUP1 18AC FD *REVERT // Stack delta = +0 // Outputs[1] { @18AC revert(memory[0x00:0x00]); } // Block terminates label_18AD: // Incoming jump from 0x18A8, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @18AE stack[-1] // @18AF msg.data[stack[-1]:stack[-1] + 0x20] // @18B4 stack[-2] // @18B5 stack[-4] // } 18AD 5B JUMPDEST 18AE 80 DUP1 18AF 35 CALLDATALOAD 18B0 90 SWAP1 18B1 60 PUSH1 0x20 18B3 01 ADD 18B4 91 SWAP2 18B5 84 DUP5 18B6 60 PUSH1 0x01 18B8 83 DUP4 18B9 02 MUL 18BA 84 DUP5 18BB 01 ADD 18BC 11 GT 18BD 64 PUSH5 0x0100000000 18C3 83 DUP4 18C4 11 GT 18C5 17 OR 18C6 15 ISZERO 18C7 61 PUSH2 0x18cf 18CA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @18B0 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @18B4 stack[0] = stack[-2] // @18B4 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x18cf, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_18CB: // Incoming jump from 0x18CA, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @18CE memory[0x00:0x00] } 18CB 60 PUSH1 0x00 18CD 80 DUP1 18CE FD *REVERT // Stack delta = +0 // Outputs[1] { @18CE revert(memory[0x00:0x00]); } // Block terminates label_18CF: // Incoming jump from 0x18CA, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @18D0 stack[-3] // @18D0 stack[-1] // @18D1 stack[-2] // @18E2 memory[0x40:0x60] // @18F9 msg.data[stack[-3]:stack[-3] + stack[-2]] // @1915 stack[-4] // @1916 stack[-5] // } 18CF 5B JUMPDEST 18D0 91 SWAP2 18D1 90 SWAP1 18D2 80 DUP1 18D3 80 DUP1 18D4 60 PUSH1 0x1f 18D6 01 ADD 18D7 60 PUSH1 0x20 18D9 80 DUP1 18DA 91 SWAP2 18DB 04 DIV 18DC 02 MUL 18DD 60 PUSH1 0x20 18DF 01 ADD 18E0 60 PUSH1 0x40 18E2 51 MLOAD 18E3 90 SWAP1 18E4 81 DUP2 18E5 01 ADD 18E6 60 PUSH1 0x40 18E8 52 MSTORE 18E9 80 DUP1 18EA 93 SWAP4 18EB 92 SWAP3 18EC 91 SWAP2 18ED 90 SWAP1 18EE 81 DUP2 18EF 81 DUP2 18F0 52 MSTORE 18F1 60 PUSH1 0x20 18F3 01 ADD 18F4 83 DUP4 18F5 83 DUP4 18F6 80 DUP1 18F7 82 DUP3 18F8 84 DUP5 18F9 37 CALLDATACOPY 18FA 60 PUSH1 0x00 18FC 81 DUP2 18FD 84 DUP5 18FE 01 ADD 18FF 52 MSTORE 1900 60 PUSH1 0x1f 1902 19 NOT 1903 60 PUSH1 0x1f 1905 82 DUP3 1906 01 ADD 1907 16 AND 1908 90 SWAP1 1909 50 POP 190A 80 DUP1 190B 83 DUP4 190C 01 ADD 190D 92 SWAP3 190E 50 POP 190F 50 POP 1910 50 POP 1911 50 POP 1912 50 POP 1913 50 POP 1914 50 POP 1915 91 SWAP2 1916 92 SWAP3 1917 91 SWAP2 1918 92 SWAP3 1919 90 SWAP1 191A 50 POP 191B 50 POP 191C 50 POP 191D 61 PUSH2 0x32c5 1920 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @18E8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @18F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @18F9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @18FF memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @1918 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x32c5 label_1921: // Incoming return from call to 0x1449 at 0x1444 1921 5B JUMPDEST 1922 00 *STOP // Stack delta = +0 // Outputs[1] { @1922 stop(); } // Block terminates label_1923: // Incoming jump from 0x005F, if 0xfd73d81c == stack[-1] // Inputs[1] { @1924 msg.value } 1923 5B JUMPDEST 1924 34 CALLVALUE 1925 80 DUP1 1926 15 ISZERO 1927 61 PUSH2 0x192f 192A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1924 stack[0] = msg.value } // Block ends with conditional jump to 0x192f, if !msg.value label_192B: // Incoming jump from 0x192A, if not !msg.value // Inputs[1] { @192E memory[0x00:0x00] } 192B 60 PUSH1 0x00 192D 80 DUP1 192E FD *REVERT // Stack delta = +0 // Outputs[1] { @192E revert(memory[0x00:0x00]); } // Block terminates label_192F: // Incoming jump from 0x192A, if !msg.value 192F 5B JUMPDEST 1930 50 POP 1931 61 PUSH2 0x1938 1934 61 PUSH2 0x3aaa 1937 56 *JUMP // Stack delta = +0 // Outputs[1] { @1931 stack[-1] = 0x1938 } // Block ends with call to 0x3aaa, returns to 0x1938 label_1938: // Incoming return from call to 0x3AAA at 0x1937 // Inputs[4] // { // @193B memory[0x40:0x60] // @1946 stack[-1] // @1949 memory[stack[-1]:stack[-1] + 0x20] // @1952 memory[stack[-1]:stack[-1] + 0x20] // } 1938 5B JUMPDEST 1939 60 PUSH1 0x40 193B 51 MLOAD 193C 80 DUP1 193D 80 DUP1 193E 60 PUSH1 0x20 1940 01 ADD 1941 82 DUP3 1942 81 DUP2 1943 03 SUB 1944 82 DUP3 1945 52 MSTORE 1946 83 DUP4 1947 81 DUP2 1948 81 DUP2 1949 51 MLOAD 194A 81 DUP2 194B 52 MSTORE 194C 60 PUSH1 0x20 194E 01 ADD 194F 91 SWAP2 1950 50 POP 1951 80 DUP1 1952 51 MLOAD 1953 90 SWAP1 1954 60 PUSH1 0x20 1956 01 ADD 1957 90 SWAP1 1958 80 DUP1 1959 83 DUP4 195A 83 DUP4 195B 60 PUSH1 0x00 195D 5B JUMPDEST 195E 83 DUP4 195F 81 DUP2 1960 10 LT 1961 15 ISZERO 1962 61 PUSH2 0x1978 1965 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @193B stack[0] = memory[0x40:0x60] // @193C stack[1] = memory[0x40:0x60] // @1945 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @194B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @194F stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @1957 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @1957 stack[3] = 0x20 + stack[-1] // @1958 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @1959 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @195A stack[7] = 0x20 + stack[-1] // @195B stack[8] = 0x00 // } // Block ends with conditional jump to 0x1978, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1966: // Incoming jump from 0x1965, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1965, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1966 stack[-1] // @1967 stack[-2] // @1969 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @196B stack[-3] // } 1966 80 DUP1 1967 82 DUP3 1968 01 ADD 1969 51 MLOAD 196A 81 DUP2 196B 84 DUP5 196C 01 ADD 196D 52 MSTORE 196E 60 PUSH1 0x20 1970 81 DUP2 1971 01 ADD 1972 90 SWAP1 1973 50 POP 1974 61 PUSH2 0x195d 1977 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @196D memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1972 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x195d label_1978: // Incoming jump from 0x1965, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1965, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @197D stack[-5] // @197D stack[-6] // @197F stack[-7] // } 1978 5B JUMPDEST 1979 50 POP 197A 50 POP 197B 50 POP 197C 50 POP 197D 90 SWAP1 197E 50 POP 197F 90 SWAP1 1980 81 DUP2 1981 01 ADD 1982 90 SWAP1 1983 60 PUSH1 0x1f 1985 16 AND 1986 80 DUP1 1987 15 ISZERO 1988 61 PUSH2 0x19a5 198B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1982 stack[-7] = stack[-5] + stack[-7] // @1985 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x19a5, if !(0x1f & stack[-5]) label_198C: // Incoming jump from 0x198B, if not !(0x1f & stack[-5]) // Inputs[6] // { // @198C stack[-1] // @198D stack[-2] // @1990 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @19A7 stack[-5] // @19AD memory[0x40:0x60] // @19B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 198C 80 DUP1 198D 82 DUP3 198E 03 SUB 198F 80 DUP1 1990 51 MLOAD 1991 60 PUSH1 0x01 1993 83 DUP4 1994 60 PUSH1 0x20 1996 03 SUB 1997 61 PUSH2 0x0100 199A 0A EXP 199B 03 SUB 199C 19 NOT 199D 16 AND 199E 81 DUP2 199F 52 MSTORE 19A0 60 PUSH1 0x20 19A2 01 ADD 19A3 91 SWAP2 19A4 50 POP 19A5 5B JUMPDEST 19A6 50 POP 19A7 92 SWAP3 19A8 50 POP 19A9 50 POP 19AA 50 POP 19AB 60 PUSH1 0x40 19AD 51 MLOAD 19AE 80 DUP1 19AF 91 SWAP2 19B0 03 SUB 19B1 90 SWAP1 19B2 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @199F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @19B2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_19B3: // Incoming jump from 0x0234 // Inputs[4] // { // @19B9 stack[-1] // @1A05 memory[0x00:0x40] // @1A09 storage[keccak256(memory[0x00:0x40])] // @1A16 stack[-2] // } 19B3 5B JUMPDEST 19B4 60 PUSH1 0x00 19B6 80 DUP1 19B7 60 PUSH1 0x00 19B9 83 DUP4 19BA 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 19D7 19 NOT 19D8 16 AND 19D9 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 19F6 19 NOT 19F7 16 AND 19F8 81 DUP2 19F9 52 MSTORE 19FA 60 PUSH1 0x20 19FC 01 ADD 19FD 90 SWAP1 19FE 81 DUP2 19FF 52 MSTORE 1A00 60 PUSH1 0x20 1A02 01 ADD 1A03 60 PUSH1 0x00 1A05 20 SHA3 1A06 60 PUSH1 0x00 1A08 90 SWAP1 1A09 54 SLOAD 1A0A 90 SWAP1 1A0B 61 PUSH2 0x0100 1A0E 0A EXP 1A0F 90 SWAP1 1A10 04 DIV 1A11 60 PUSH1 0xff 1A13 16 AND 1A14 90 SWAP1 1A15 50 POP 1A16 91 SWAP2 1A17 90 SWAP1 1A18 50 POP 1A19 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @19F9 memory[0x00:0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // @19FF memory[0x20:0x40] = 0x00 // @1A16 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_1A1A: // Incoming call from 0x0263, returns to 0x0264 // Inputs[2] // { // @1A20 storage[0x0e] // @1A3E stack[-1] // } 1A1A 5B JUMPDEST 1A1B 60 PUSH1 0x0e 1A1D 60 PUSH1 0x00 1A1F 90 SWAP1 1A20 54 SLOAD 1A21 90 SWAP1 1A22 61 PUSH2 0x0100 1A25 0A EXP 1A26 90 SWAP1 1A27 04 DIV 1A28 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A3D 16 AND 1A3E 81 DUP2 1A3F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A3D stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1A40: // Incoming call from 0x02BA, returns to 0x02BB // Inputs[3] // { // @1A46 storage[0x05] // @1A67 memory[0x40:0x60] // @1A7A storage[0x05] // } 1A40 5B JUMPDEST 1A41 60 PUSH1 0x60 1A43 60 PUSH1 0x05 1A45 80 DUP1 1A46 54 SLOAD 1A47 60 PUSH1 0x01 1A49 81 DUP2 1A4A 60 PUSH1 0x01 1A4C 16 AND 1A4D 15 ISZERO 1A4E 61 PUSH2 0x0100 1A51 02 MUL 1A52 03 SUB 1A53 16 AND 1A54 60 PUSH1 0x02 1A56 90 SWAP1 1A57 04 DIV 1A58 80 DUP1 1A59 60 PUSH1 0x1f 1A5B 01 ADD 1A5C 60 PUSH1 0x20 1A5E 80 DUP1 1A5F 91 SWAP2 1A60 04 DIV 1A61 02 MUL 1A62 60 PUSH1 0x20 1A64 01 ADD 1A65 60 PUSH1 0x40 1A67 51 MLOAD 1A68 90 SWAP1 1A69 81 DUP2 1A6A 01 ADD 1A6B 60 PUSH1 0x40 1A6D 52 MSTORE 1A6E 80 DUP1 1A6F 92 SWAP3 1A70 91 SWAP2 1A71 90 SWAP1 1A72 81 DUP2 1A73 81 DUP2 1A74 52 MSTORE 1A75 60 PUSH1 0x20 1A77 01 ADD 1A78 82 DUP3 1A79 80 DUP1 1A7A 54 SLOAD 1A7B 60 PUSH1 0x01 1A7D 81 DUP2 1A7E 60 PUSH1 0x01 1A80 16 AND 1A81 15 ISZERO 1A82 61 PUSH2 0x0100 1A85 02 MUL 1A86 03 SUB 1A87 16 AND 1A88 60 PUSH1 0x02 1A8A 90 SWAP1 1A8B 04 DIV 1A8C 80 DUP1 1A8D 15 ISZERO 1A8E 61 PUSH2 0x1ad8 1A91 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1A41 stack[0] = 0x60 // @1A6D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) / 0x20 * 0x20 // @1A6F stack[1] = memory[0x40:0x60] // @1A70 stack[2] = 0x05 // @1A71 stack[3] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // @1A74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // @1A77 stack[4] = 0x20 + memory[0x40:0x60] // @1A78 stack[5] = 0x05 // @1A8B stack[6] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // } // Block ends with conditional jump to 0x1ad8, if !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) label_1A92: // Incoming jump from 0x1A91, if not !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) // Inputs[1] { @1A92 stack[-1] } 1A92 80 DUP1 1A93 60 PUSH1 0x1f 1A95 10 LT 1A96 61 PUSH2 0x1aad 1A99 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1aad, if 0x1f < stack[-1] label_1A9A: // Incoming jump from 0x1A99, if not 0x1f < stack[-1] // Inputs[4] // { // @1A9E stack[-2] // @1A9F storage[stack[-2]] // @1AA2 stack[-3] // @1AA4 stack[-1] // } 1A9A 61 PUSH2 0x0100 1A9D 80 DUP1 1A9E 83 DUP4 1A9F 54 SLOAD 1AA0 04 DIV 1AA1 02 MUL 1AA2 83 DUP4 1AA3 52 MSTORE 1AA4 91 SWAP2 1AA5 60 PUSH1 0x20 1AA7 01 ADD 1AA8 91 SWAP2 1AA9 61 PUSH2 0x1ad8 1AAC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1AA3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1AA8 stack[-1] = stack[-1] // @1AA8 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1ad8 label_1AAD: // Incoming jump from 0x1A99, if 0x1f < stack[-1] // Inputs[5] // { // @1AAE stack[-3] // @1AAF stack[-1] // @1AB1 stack[-2] // @1AB9 memory[0x00:0x20] // @1ABD storage[keccak256(memory[0x00:0x20])] // } 1AAD 5B JUMPDEST 1AAE 82 DUP3 1AAF 01 ADD 1AB0 91 SWAP2 1AB1 90 SWAP1 1AB2 60 PUSH1 0x00 1AB4 52 MSTORE 1AB5 60 PUSH1 0x20 1AB7 60 PUSH1 0x00 1AB9 20 SHA3 1ABA 90 SWAP1 1ABB 5B JUMPDEST 1ABC 81 DUP2 1ABD 54 SLOAD 1ABE 81 DUP2 1ABF 52 MSTORE 1AC0 90 SWAP1 1AC1 60 PUSH1 0x01 1AC3 01 ADD 1AC4 90 SWAP1 1AC5 60 PUSH1 0x20 1AC7 01 ADD 1AC8 80 DUP1 1AC9 83 DUP4 1ACA 11 GT 1ACB 61 PUSH2 0x1abb 1ACE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1AB0 stack[-3] = stack[-3] + stack[-1] // @1AB4 memory[0x00:0x20] = stack[-2] // @1ABF memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1AC4 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1AC7 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1abb, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1ACF: // Incoming jump from 0x1ACE, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1ACE, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1ACF stack[-3] // @1AD0 stack[-1] // } 1ACF 82 DUP3 1AD0 90 SWAP1 1AD1 03 SUB 1AD2 60 PUSH1 0x1f 1AD4 16 AND 1AD5 82 DUP3 1AD6 01 ADD 1AD7 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1AD7 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1AD7 stack[-1] = stack[-3] // } // Block continues label_1AD8: // Incoming jump from 0x1AD7 // Incoming jump from 0x1AAC // Incoming jump from 0x1A91, if !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) // Inputs[3] // { // @1ADE stack[-7] // @1ADE stack[-6] // @1AE0 stack[-8] // } 1AD8 5B JUMPDEST 1AD9 50 POP 1ADA 50 POP 1ADB 50 POP 1ADC 50 POP 1ADD 50 POP 1ADE 90 SWAP1 1ADF 50 POP 1AE0 90 SWAP1 1AE1 56 *JUMP // Stack delta = -7 // Outputs[1] { @1AE0 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1AE2: // Incoming call from 0x3C83, returns to 0x3C84 // Incoming jump from 0x036E // Inputs[1] { @1AE8 stack[-1] } 1AE2 5B JUMPDEST 1AE3 60 PUSH1 0x00 1AE5 61 PUSH2 0x1aed 1AE8 82 DUP3 1AE9 61 PUSH2 0x3b48 1AEC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AE3 stack[0] = 0x00 // @1AE5 stack[1] = 0x1aed // @1AE8 stack[2] = stack[-1] // } // Block ends with call to 0x3b48, returns to 0x1AED label_1AED: // Incoming return from call to 0x3B48 at 0x1AEC // Inputs[1] { @1AF1 stack[-1] } 1AED 5B JUMPDEST 1AEE 61 PUSH2 0x1b42 1AF1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b42, if stack[-1] label_1AF2: // Incoming jump from 0x1AF1, if not stack[-1] // Inputs[3] // { // @1AF4 memory[0x40:0x60] // @1B3C memory[0x40:0x60] // @1B41 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AF2 60 PUSH1 0x40 1AF4 51 MLOAD 1AF5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B16 81 DUP2 1B17 52 MSTORE 1B18 60 PUSH1 0x04 1B1A 01 ADD 1B1B 80 DUP1 1B1C 80 DUP1 1B1D 60 PUSH1 0x20 1B1F 01 ADD 1B20 82 DUP3 1B21 81 DUP2 1B22 03 SUB 1B23 82 DUP3 1B24 52 MSTORE 1B25 60 PUSH1 0x2c 1B27 81 DUP2 1B28 52 MSTORE 1B29 60 PUSH1 0x20 1B2B 01 ADD 1B2C 80 DUP1 1B2D 61 PUSH2 0x4cba 1B30 60 PUSH1 0x2c 1B32 91 SWAP2 1B33 39 CODECOPY 1B34 60 PUSH1 0x40 1B36 01 ADD 1B37 91 SWAP2 1B38 50 POP 1B39 50 POP 1B3A 60 PUSH1 0x40 1B3C 51 MLOAD 1B3D 80 DUP1 1B3E 91 SWAP2 1B3F 03 SUB 1B40 90 SWAP1 1B41 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1B24 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B28 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @1B33 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x4cba:0x4ce6] // @1B41 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B42: // Incoming jump from 0x1AF1, if stack[-1] // Inputs[5] // { // @1B47 stack[-2] // @1B55 memory[0x00:0x40] // @1B59 storage[keccak256(memory[0x00:0x40])] // @1B77 stack[-1] // @1B79 stack[-3] // } 1B42 5B JUMPDEST 1B43 60 PUSH1 0x02 1B45 60 PUSH1 0x00 1B47 83 DUP4 1B48 81 DUP2 1B49 52 MSTORE 1B4A 60 PUSH1 0x20 1B4C 01 ADD 1B4D 90 SWAP1 1B4E 81 DUP2 1B4F 52 MSTORE 1B50 60 PUSH1 0x20 1B52 01 ADD 1B53 60 PUSH1 0x00 1B55 20 SHA3 1B56 60 PUSH1 0x00 1B58 90 SWAP1 1B59 54 SLOAD 1B5A 90 SWAP1 1B5B 61 PUSH2 0x0100 1B5E 0A EXP 1B5F 90 SWAP1 1B60 04 DIV 1B61 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B76 16 AND 1B77 90 SWAP1 1B78 50 POP 1B79 91 SWAP2 1B7A 90 SWAP1 1B7B 50 POP 1B7C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1B49 memory[0x00:0x20] = stack[-2] // @1B4F memory[0x20:0x40] = 0x02 // @1B79 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_1B7D: // Incoming jump from 0x0409 // Inputs[1] { @1B83 stack[-1] } 1B7D 5B JUMPDEST 1B7E 60 PUSH1 0x00 1B80 61 PUSH2 0x1b88 1B83 82 DUP3 1B84 61 PUSH2 0x2456 1B87 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B7E stack[0] = 0x00 // @1B80 stack[1] = 0x1b88 // @1B83 stack[2] = stack[-1] // } // Block ends with call to 0x2456, returns to 0x1B88 label_1B88: // Incoming return from call to 0x2456 at 0x1B87 // Inputs[3] // { // @1B89 stack[-1] // @1B89 stack[-2] // @1BA2 stack[-4] // } 1B88 5B JUMPDEST 1B89 90 SWAP1 1B8A 50 POP 1B8B 80 DUP1 1B8C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BA1 16 AND 1BA2 83 DUP4 1BA3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BB8 16 AND 1BB9 14 EQ 1BBA 15 ISZERO 1BBB 61 PUSH2 0x1c0f 1BBE 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1B89 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1c0f, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_1BBF: // Incoming jump from 0x1BBE, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @1BC1 memory[0x40:0x60] // @1C09 memory[0x40:0x60] // @1C0E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1BBF 60 PUSH1 0x40 1BC1 51 MLOAD 1BC2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BE3 81 DUP2 1BE4 52 MSTORE 1BE5 60 PUSH1 0x04 1BE7 01 ADD 1BE8 80 DUP1 1BE9 80 DUP1 1BEA 60 PUSH1 0x20 1BEC 01 ADD 1BED 82 DUP3 1BEE 81 DUP2 1BEF 03 SUB 1BF0 82 DUP3 1BF1 52 MSTORE 1BF2 60 PUSH1 0x21 1BF4 81 DUP2 1BF5 52 MSTORE 1BF6 60 PUSH1 0x20 1BF8 01 ADD 1BF9 80 DUP1 1BFA 61 PUSH2 0x4d0f 1BFD 60 PUSH1 0x21 1BFF 91 SWAP2 1C00 39 CODECOPY 1C01 60 PUSH1 0x40 1C03 01 ADD 1C04 91 SWAP2 1C05 50 POP 1C06 50 POP 1C07 60 PUSH1 0x40 1C09 51 MLOAD 1C0A 80 DUP1 1C0B 91 SWAP2 1C0C 03 SUB 1C0D 90 SWAP1 1C0E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1BE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1BF1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1BF5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @1C00 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x4d0f:0x4d30] // @1C0E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C0F: // Incoming jump from 0x1BBE, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @1C10 stack[-1] } 1C0F 5B JUMPDEST 1C10 80 DUP1 1C11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C26 16 AND 1C27 61 PUSH2 0x1c2e 1C2A 61 PUSH2 0x3bba 1C2D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C26 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1C27 stack[1] = 0x1c2e // } // Block ends with call to 0x3bba, returns to 0x1C2E label_1C2E: // Incoming return from call to 0x3BBA at 0x1C2D // Inputs[2] // { // @1C44 stack[-1] // @1C45 stack[-2] // } 1C2E 5B JUMPDEST 1C2F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C44 16 AND 1C45 14 EQ 1C46 80 DUP1 1C47 61 PUSH2 0x1c5d 1C4A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1C45 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x1c5d, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1C4B: // Incoming jump from 0x1C4A, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1C4F stack[-2] } 1C4B 50 POP 1C4C 61 PUSH2 0x1c5c 1C4F 81 DUP2 1C50 61 PUSH2 0x1c57 1C53 61 PUSH2 0x3bba 1C56 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C4C stack[-1] = 0x1c5c // @1C4F stack[0] = stack[-2] // @1C50 stack[1] = 0x1c57 // } // Block ends with call to 0x3bba, returns to 0x1C57 label_1C57: // Incoming return from call to 0x3BBA at 0x1C56 1C57 5B JUMPDEST 1C58 61 PUSH2 0x30d9 1C5B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x30d9 label_1C5C: // Incoming return from call to 0x1C57 at 0x1C56 1C5C 5B JUMPDEST // Stack delta = +0 // Block continues label_1C5D: // Incoming jump from 0x1C4A, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Incoming jump from 0x1C5C // Inputs[1] { @1C61 stack[-1] } 1C5D 5B JUMPDEST 1C5E 61 PUSH2 0x1cb2 1C61 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1cb2, if stack[-1] label_1C62: // Incoming jump from 0x1C61, if not stack[-1] // Inputs[3] // { // @1C64 memory[0x40:0x60] // @1CAC memory[0x40:0x60] // @1CB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1C62 60 PUSH1 0x40 1C64 51 MLOAD 1C65 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C86 81 DUP2 1C87 52 MSTORE 1C88 60 PUSH1 0x04 1C8A 01 ADD 1C8B 80 DUP1 1C8C 80 DUP1 1C8D 60 PUSH1 0x20 1C8F 01 ADD 1C90 82 DUP3 1C91 81 DUP2 1C92 03 SUB 1C93 82 DUP3 1C94 52 MSTORE 1C95 60 PUSH1 0x38 1C97 81 DUP2 1C98 52 MSTORE 1C99 60 PUSH1 0x20 1C9B 01 ADD 1C9C 80 DUP1 1C9D 61 PUSH2 0x4c2f 1CA0 60 PUSH1 0x38 1CA2 91 SWAP2 1CA3 39 CODECOPY 1CA4 60 PUSH1 0x40 1CA6 01 ADD 1CA7 91 SWAP2 1CA8 50 POP 1CA9 50 POP 1CAA 60 PUSH1 0x40 1CAC 51 MLOAD 1CAD 80 DUP1 1CAE 91 SWAP2 1CAF 03 SUB 1CB0 90 SWAP1 1CB1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1C87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C94 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1C98 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x38 // @1CA3 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x38] = code[0x4c2f:0x4c67] // @1CB1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1CB2: // Incoming jump from 0x1C61, if stack[-1] // Inputs[9] // { // @1CB3 stack[-3] // @1CB8 stack[-2] // @1CC6 memory[0x00:0x40] // @1CCE storage[keccak256(memory[0x00:0x40])] // @1D1D stack[-1] // @1D57 memory[0x40:0x60] // @1D5A memory[0x40:0x60] // @1D5F memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1D63 stack[-4] // } 1CB2 5B JUMPDEST 1CB3 82 DUP3 1CB4 60 PUSH1 0x02 1CB6 60 PUSH1 0x00 1CB8 84 DUP5 1CB9 81 DUP2 1CBA 52 MSTORE 1CBB 60 PUSH1 0x20 1CBD 01 ADD 1CBE 90 SWAP1 1CBF 81 DUP2 1CC0 52 MSTORE 1CC1 60 PUSH1 0x20 1CC3 01 ADD 1CC4 60 PUSH1 0x00 1CC6 20 SHA3 1CC7 60 PUSH1 0x00 1CC9 61 PUSH2 0x0100 1CCC 0A EXP 1CCD 81 DUP2 1CCE 54 SLOAD 1CCF 81 DUP2 1CD0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CE5 02 MUL 1CE6 19 NOT 1CE7 16 AND 1CE8 90 SWAP1 1CE9 83 DUP4 1CEA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CFF 16 AND 1D00 02 MUL 1D01 17 OR 1D02 90 SWAP1 1D03 55 SSTORE 1D04 50 POP 1D05 81 DUP2 1D06 83 DUP4 1D07 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D1C 16 AND 1D1D 82 DUP3 1D1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D33 16 AND 1D34 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1D55 60 PUSH1 0x40 1D57 51 MLOAD 1D58 60 PUSH1 0x40 1D5A 51 MLOAD 1D5B 80 DUP1 1D5C 91 SWAP2 1D5D 03 SUB 1D5E 90 SWAP1 1D5F A4 LOG4 1D60 50 POP 1D61 50 POP 1D62 50 POP 1D63 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1CBA memory[0x00:0x20] = stack[-2] // @1CC0 memory[0x20:0x40] = 0x02 // @1D03 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1D5F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_1D64: // Incoming call from 0x0420, returns to 0x0421 // Inputs[3] // { // @1D68 storage[0x0b] // @1D89 memory[0x40:0x60] // @1D9C storage[0x0b] // } 1D64 5B JUMPDEST 1D65 60 PUSH1 0x0b 1D67 80 DUP1 1D68 54 SLOAD 1D69 60 PUSH1 0x01 1D6B 81 DUP2 1D6C 60 PUSH1 0x01 1D6E 16 AND 1D6F 15 ISZERO 1D70 61 PUSH2 0x0100 1D73 02 MUL 1D74 03 SUB 1D75 16 AND 1D76 60 PUSH1 0x02 1D78 90 SWAP1 1D79 04 DIV 1D7A 80 DUP1 1D7B 60 PUSH1 0x1f 1D7D 01 ADD 1D7E 60 PUSH1 0x20 1D80 80 DUP1 1D81 91 SWAP2 1D82 04 DIV 1D83 02 MUL 1D84 60 PUSH1 0x20 1D86 01 ADD 1D87 60 PUSH1 0x40 1D89 51 MLOAD 1D8A 90 SWAP1 1D8B 81 DUP2 1D8C 01 ADD 1D8D 60 PUSH1 0x40 1D8F 52 MSTORE 1D90 80 DUP1 1D91 92 SWAP3 1D92 91 SWAP2 1D93 90 SWAP1 1D94 81 DUP2 1D95 81 DUP2 1D96 52 MSTORE 1D97 60 PUSH1 0x20 1D99 01 ADD 1D9A 82 DUP3 1D9B 80 DUP1 1D9C 54 SLOAD 1D9D 60 PUSH1 0x01 1D9F 81 DUP2 1DA0 60 PUSH1 0x01 1DA2 16 AND 1DA3 15 ISZERO 1DA4 61 PUSH2 0x0100 1DA7 02 MUL 1DA8 03 SUB 1DA9 16 AND 1DAA 60 PUSH1 0x02 1DAC 90 SWAP1 1DAD 04 DIV 1DAE 80 DUP1 1DAF 15 ISZERO 1DB0 61 PUSH2 0x1dfa 1DB3 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1D8F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) / 0x20 * 0x20 // @1D91 stack[0] = memory[0x40:0x60] // @1D92 stack[1] = 0x0b // @1D93 stack[2] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // @1D96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // @1D99 stack[3] = 0x20 + memory[0x40:0x60] // @1D9A stack[4] = 0x0b // @1DAD stack[5] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // } // Block ends with conditional jump to 0x1dfa, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) label_1DB4: // Incoming jump from 0x1DB3, if not !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[1] { @1DB4 stack[-1] } 1DB4 80 DUP1 1DB5 60 PUSH1 0x1f 1DB7 10 LT 1DB8 61 PUSH2 0x1dcf 1DBB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1dcf, if 0x1f < stack[-1] label_1DBC: // Incoming jump from 0x1DBB, if not 0x1f < stack[-1] // Inputs[4] // { // @1DC0 stack[-2] // @1DC1 storage[stack[-2]] // @1DC4 stack[-3] // @1DC6 stack[-1] // } 1DBC 61 PUSH2 0x0100 1DBF 80 DUP1 1DC0 83 DUP4 1DC1 54 SLOAD 1DC2 04 DIV 1DC3 02 MUL 1DC4 83 DUP4 1DC5 52 MSTORE 1DC6 91 SWAP2 1DC7 60 PUSH1 0x20 1DC9 01 ADD 1DCA 91 SWAP2 1DCB 61 PUSH2 0x1dfa 1DCE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1DC5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1DCA stack[-1] = stack[-1] // @1DCA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1dfa label_1DCF: // Incoming jump from 0x1DBB, if 0x1f < stack[-1] // Inputs[5] // { // @1DD0 stack[-3] // @1DD1 stack[-1] // @1DD3 stack[-2] // @1DDB memory[0x00:0x20] // @1DDF storage[keccak256(memory[0x00:0x20])] // } 1DCF 5B JUMPDEST 1DD0 82 DUP3 1DD1 01 ADD 1DD2 91 SWAP2 1DD3 90 SWAP1 1DD4 60 PUSH1 0x00 1DD6 52 MSTORE 1DD7 60 PUSH1 0x20 1DD9 60 PUSH1 0x00 1DDB 20 SHA3 1DDC 90 SWAP1 1DDD 5B JUMPDEST 1DDE 81 DUP2 1DDF 54 SLOAD 1DE0 81 DUP2 1DE1 52 MSTORE 1DE2 90 SWAP1 1DE3 60 PUSH1 0x01 1DE5 01 ADD 1DE6 90 SWAP1 1DE7 60 PUSH1 0x20 1DE9 01 ADD 1DEA 80 DUP1 1DEB 83 DUP4 1DEC 11 GT 1DED 61 PUSH2 0x1ddd 1DF0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1DD2 stack[-3] = stack[-3] + stack[-1] // @1DD6 memory[0x00:0x20] = stack[-2] // @1DE1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1DE6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1DE9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1ddd, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1DF1: // Incoming jump from 0x1DF0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1DF0, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1DF1 stack[-3] // @1DF2 stack[-1] // } 1DF1 82 DUP3 1DF2 90 SWAP1 1DF3 03 SUB 1DF4 60 PUSH1 0x1f 1DF6 16 AND 1DF7 82 DUP3 1DF8 01 ADD 1DF9 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1DF9 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1DF9 stack[-1] = stack[-3] // } // Block continues label_1DFA: // Incoming jump from 0x1DF9 // Incoming jump from 0x1DCE // Incoming jump from 0x1DB3, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[1] { @1E00 stack[-7] } 1DFA 5B JUMPDEST 1DFB 50 POP 1DFC 50 POP 1DFD 50 POP 1DFE 50 POP 1DFF 50 POP 1E00 81 DUP2 1E01 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1E02: // Incoming jump from 0x0514 1E02 5B JUMPDEST 1E03 61 PUSH2 0x1e13 1E06 61 PUSH2 0x1e0d 1E09 61 PUSH2 0x3bba 1E0C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E03 stack[0] = 0x1e13 // @1E06 stack[1] = 0x1e0d // } // Block ends with call to 0x3bba, returns to 0x1E0D label_1E0D: // Incoming return from call to 0x3BBA at 0x1E0C // Inputs[1] { @1E0E stack[-3] } 1E0D 5B JUMPDEST 1E0E 82 DUP3 1E0F 61 PUSH2 0x3bc2 1E12 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E0E stack[0] = stack[-3] } // Block ends with unconditional jump to 0x3bc2 label_1E13: // Incoming return from call to 0x1E0D at 0x1E0C // Inputs[1] { @1E17 stack[-1] } 1E13 5B JUMPDEST 1E14 61 PUSH2 0x1e68 1E17 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e68, if stack[-1] label_1E18: // Incoming jump from 0x1E17, if not stack[-1] // Inputs[3] // { // @1E1A memory[0x40:0x60] // @1E62 memory[0x40:0x60] // @1E67 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1E18 60 PUSH1 0x40 1E1A 51 MLOAD 1E1B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1E3C 81 DUP2 1E3D 52 MSTORE 1E3E 60 PUSH1 0x04 1E40 01 ADD 1E41 80 DUP1 1E42 80 DUP1 1E43 60 PUSH1 0x20 1E45 01 ADD 1E46 82 DUP3 1E47 81 DUP2 1E48 03 SUB 1E49 82 DUP3 1E4A 52 MSTORE 1E4B 60 PUSH1 0x31 1E4D 81 DUP2 1E4E 52 MSTORE 1E4F 60 PUSH1 0x20 1E51 01 ADD 1E52 80 DUP1 1E53 61 PUSH2 0x4d30 1E56 60 PUSH1 0x31 1E58 91 SWAP2 1E59 39 CODECOPY 1E5A 60 PUSH1 0x40 1E5C 01 ADD 1E5D 91 SWAP2 1E5E 50 POP 1E5F 50 POP 1E60 60 PUSH1 0x40 1E62 51 MLOAD 1E63 80 DUP1 1E64 91 SWAP2 1E65 03 SUB 1E66 90 SWAP1 1E67 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1E3D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1E4A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1E4E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @1E59 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x4d30:0x4d61] // @1E67 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E68: // Incoming jump from 0x1E17, if stack[-1] // Inputs[3] // { // @1E6C stack[-3] // @1E6D stack[-2] // @1E6E stack[-1] // } 1E68 5B JUMPDEST 1E69 61 PUSH2 0x1e73 1E6C 83 DUP4 1E6D 83 DUP4 1E6E 83 DUP4 1E6F 61 PUSH2 0x3cb6 1E72 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E69 stack[0] = 0x1e73 // @1E6C stack[1] = stack[-3] // @1E6D stack[2] = stack[-2] // @1E6E stack[3] = stack[-1] // } // Block ends with call to 0x3cb6, returns to 0x1E73 label_1E73: // Incoming return from call to 0x3CB6 at 0x1E72 // Inputs[1] { @1E77 stack[-4] } 1E73 5B JUMPDEST 1E74 50 POP 1E75 50 POP 1E76 50 POP 1E77 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1E78: // Incoming jump from 0x054F // Inputs[5] // { // @1E88 stack[-1] // @1E96 memory[0x00:0x40] // @1E98 storage[keccak256(memory[0x00:0x40])] // @1EB9 memory[0x40:0x60] // @1ECC storage[keccak256(memory[0x00:0x40])] // } 1E78 5B JUMPDEST 1E79 60 PUSH1 0x60 1E7B 80 DUP1 1E7C 60 PUSH1 0x60 1E7E 80 DUP1 1E7F 60 PUSH1 0x60 1E81 60 PUSH1 0x00 1E83 80 DUP1 1E84 60 PUSH1 0x0f 1E86 60 PUSH1 0x00 1E88 89 DUP10 1E89 81 DUP2 1E8A 52 MSTORE 1E8B 60 PUSH1 0x20 1E8D 01 ADD 1E8E 90 SWAP1 1E8F 81 DUP2 1E90 52 MSTORE 1E91 60 PUSH1 0x20 1E93 01 ADD 1E94 60 PUSH1 0x00 1E96 20 SHA3 1E97 80 DUP1 1E98 54 SLOAD 1E99 60 PUSH1 0x01 1E9B 81 DUP2 1E9C 60 PUSH1 0x01 1E9E 16 AND 1E9F 15 ISZERO 1EA0 61 PUSH2 0x0100 1EA3 02 MUL 1EA4 03 SUB 1EA5 16 AND 1EA6 60 PUSH1 0x02 1EA8 90 SWAP1 1EA9 04 DIV 1EAA 80 DUP1 1EAB 60 PUSH1 0x1f 1EAD 01 ADD 1EAE 60 PUSH1 0x20 1EB0 80 DUP1 1EB1 91 SWAP2 1EB2 04 DIV 1EB3 02 MUL 1EB4 60 PUSH1 0x20 1EB6 01 ADD 1EB7 60 PUSH1 0x40 1EB9 51 MLOAD 1EBA 90 SWAP1 1EBB 81 DUP2 1EBC 01 ADD 1EBD 60 PUSH1 0x40 1EBF 52 MSTORE 1EC0 80 DUP1 1EC1 92 SWAP3 1EC2 91 SWAP2 1EC3 90 SWAP1 1EC4 81 DUP2 1EC5 81 DUP2 1EC6 52 MSTORE 1EC7 60 PUSH1 0x20 1EC9 01 ADD 1ECA 82 DUP3 1ECB 80 DUP1 1ECC 54 SLOAD 1ECD 60 PUSH1 0x01 1ECF 81 DUP2 1ED0 60 PUSH1 0x01 1ED2 16 AND 1ED3 15 ISZERO 1ED4 61 PUSH2 0x0100 1ED7 02 MUL 1ED8 03 SUB 1ED9 16 AND 1EDA 60 PUSH1 0x02 1EDC 90 SWAP1 1EDD 04 DIV 1EDE 80 DUP1 1EDF 15 ISZERO 1EE0 61 PUSH2 0x1f2a 1EE3 57 *JUMPI // Stack delta = +13 // Outputs[17] // { // @1E79 stack[0] = 0x60 // @1E7B stack[1] = 0x60 // @1E7C stack[2] = 0x60 // @1E7E stack[3] = 0x60 // @1E7F stack[4] = 0x60 // @1E81 stack[5] = 0x00 // @1E83 stack[6] = 0x00 // @1E8A memory[0x00:0x20] = stack[-1] // @1E90 memory[0x20:0x40] = 0x0f // @1EBF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @1EC1 stack[7] = memory[0x40:0x60] // @1EC2 stack[8] = keccak256(memory[0x00:0x40]) // @1EC3 stack[9] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @1EC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @1EC9 stack[10] = 0x20 + memory[0x40:0x60] // @1ECA stack[11] = keccak256(memory[0x00:0x40]) // @1EDD stack[12] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x1f2a, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_1EE4: // Incoming jump from 0x1EE3, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @1EE4 stack[-1] } 1EE4 80 DUP1 1EE5 60 PUSH1 0x1f 1EE7 10 LT 1EE8 61 PUSH2 0x1eff 1EEB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1eff, if 0x1f < stack[-1] label_1EEC: // Incoming jump from 0x1EEB, if not 0x1f < stack[-1] // Inputs[4] // { // @1EF0 stack[-2] // @1EF1 storage[stack[-2]] // @1EF4 stack[-3] // @1EF6 stack[-1] // } 1EEC 61 PUSH2 0x0100 1EEF 80 DUP1 1EF0 83 DUP4 1EF1 54 SLOAD 1EF2 04 DIV 1EF3 02 MUL 1EF4 83 DUP4 1EF5 52 MSTORE 1EF6 91 SWAP2 1EF7 60 PUSH1 0x20 1EF9 01 ADD 1EFA 91 SWAP2 1EFB 61 PUSH2 0x1f2a 1EFE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1EF5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1EFA stack[-1] = stack[-1] // @1EFA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1f2a label_1EFF: // Incoming jump from 0x1EEB, if 0x1f < stack[-1] // Inputs[5] // { // @1F00 stack[-3] // @1F01 stack[-1] // @1F03 stack[-2] // @1F0B memory[0x00:0x20] // @1F0F storage[keccak256(memory[0x00:0x20])] // } 1EFF 5B JUMPDEST 1F00 82 DUP3 1F01 01 ADD 1F02 91 SWAP2 1F03 90 SWAP1 1F04 60 PUSH1 0x00 1F06 52 MSTORE 1F07 60 PUSH1 0x20 1F09 60 PUSH1 0x00 1F0B 20 SHA3 1F0C 90 SWAP1 1F0D 5B JUMPDEST 1F0E 81 DUP2 1F0F 54 SLOAD 1F10 81 DUP2 1F11 52 MSTORE 1F12 90 SWAP1 1F13 60 PUSH1 0x01 1F15 01 ADD 1F16 90 SWAP1 1F17 60 PUSH1 0x20 1F19 01 ADD 1F1A 80 DUP1 1F1B 83 DUP4 1F1C 11 GT 1F1D 61 PUSH2 0x1f0d 1F20 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1F02 stack[-3] = stack[-3] + stack[-1] // @1F06 memory[0x00:0x20] = stack[-2] // @1F11 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1F16 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1F19 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1f0d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1F21: // Incoming jump from 0x1F20, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1F20, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1F21 stack[-3] // @1F22 stack[-1] // } 1F21 82 DUP3 1F22 90 SWAP1 1F23 03 SUB 1F24 60 PUSH1 0x1f 1F26 16 AND 1F27 82 DUP3 1F28 01 ADD 1F29 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1F29 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1F29 stack[-1] = stack[-3] // } // Block continues label_1F2A: // Incoming jump from 0x1EFE // Incoming jump from 0x1F29 // Incoming jump from 0x1EE3, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[7] // { // @1F30 stack[-6] // @1F30 stack[-13] // @1F36 stack[-14] // @1F44 memory[0x00:0x40] // @1F46 storage[keccak256(memory[0x00:0x40])] // @1F67 memory[0x40:0x60] // @1F7A storage[keccak256(memory[0x00:0x40])] // } 1F2A 5B JUMPDEST 1F2B 50 POP 1F2C 50 POP 1F2D 50 POP 1F2E 50 POP 1F2F 50 POP 1F30 96 SWAP7 1F31 50 POP 1F32 60 PUSH1 0x10 1F34 60 PUSH1 0x00 1F36 89 DUP10 1F37 81 DUP2 1F38 52 MSTORE 1F39 60 PUSH1 0x20 1F3B 01 ADD 1F3C 90 SWAP1 1F3D 81 DUP2 1F3E 52 MSTORE 1F3F 60 PUSH1 0x20 1F41 01 ADD 1F42 60 PUSH1 0x00 1F44 20 SHA3 1F45 80 DUP1 1F46 54 SLOAD 1F47 60 PUSH1 0x01 1F49 81 DUP2 1F4A 60 PUSH1 0x01 1F4C 16 AND 1F4D 15 ISZERO 1F4E 61 PUSH2 0x0100 1F51 02 MUL 1F52 03 SUB 1F53 16 AND 1F54 60 PUSH1 0x02 1F56 90 SWAP1 1F57 04 DIV 1F58 80 DUP1 1F59 60 PUSH1 0x1f 1F5B 01 ADD 1F5C 60 PUSH1 0x20 1F5E 80 DUP1 1F5F 91 SWAP2 1F60 04 DIV 1F61 02 MUL 1F62 60 PUSH1 0x20 1F64 01 ADD 1F65 60 PUSH1 0x40 1F67 51 MLOAD 1F68 90 SWAP1 1F69 81 DUP2 1F6A 01 ADD 1F6B 60 PUSH1 0x40 1F6D 52 MSTORE 1F6E 80 DUP1 1F6F 92 SWAP3 1F70 91 SWAP2 1F71 90 SWAP1 1F72 81 DUP2 1F73 81 DUP2 1F74 52 MSTORE 1F75 60 PUSH1 0x20 1F77 01 ADD 1F78 82 DUP3 1F79 80 DUP1 1F7A 54 SLOAD 1F7B 60 PUSH1 0x01 1F7D 81 DUP2 1F7E 60 PUSH1 0x01 1F80 16 AND 1F81 15 ISZERO 1F82 61 PUSH2 0x0100 1F85 02 MUL 1F86 03 SUB 1F87 16 AND 1F88 60 PUSH1 0x02 1F8A 90 SWAP1 1F8B 04 DIV 1F8C 80 DUP1 1F8D 15 ISZERO 1F8E 61 PUSH2 0x1fd8 1F91 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @1F30 stack[-13] = stack[-6] // @1F38 memory[0x00:0x20] = stack[-14] // @1F3E memory[0x20:0x40] = 0x10 // @1F6D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @1F6F stack[-6] = memory[0x40:0x60] // @1F70 stack[-5] = keccak256(memory[0x00:0x40]) // @1F71 stack[-4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @1F74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @1F77 stack[-3] = 0x20 + memory[0x40:0x60] // @1F78 stack[-2] = keccak256(memory[0x00:0x40]) // @1F8B stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x1fd8, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_1F92: // Incoming jump from 0x1F91, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @1F92 stack[-1] } 1F92 80 DUP1 1F93 60 PUSH1 0x1f 1F95 10 LT 1F96 61 PUSH2 0x1fad 1F99 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1fad, if 0x1f < stack[-1] label_1F9A: // Incoming jump from 0x1F99, if not 0x1f < stack[-1] // Inputs[4] // { // @1F9E stack[-2] // @1F9F storage[stack[-2]] // @1FA2 stack[-3] // @1FA4 stack[-1] // } 1F9A 61 PUSH2 0x0100 1F9D 80 DUP1 1F9E 83 DUP4 1F9F 54 SLOAD 1FA0 04 DIV 1FA1 02 MUL 1FA2 83 DUP4 1FA3 52 MSTORE 1FA4 91 SWAP2 1FA5 60 PUSH1 0x20 1FA7 01 ADD 1FA8 91 SWAP2 1FA9 61 PUSH2 0x1fd8 1FAC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1FA3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1FA8 stack[-1] = stack[-1] // @1FA8 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1fd8 label_1FAD: // Incoming jump from 0x1F99, if 0x1f < stack[-1] // Inputs[5] // { // @1FAE stack[-3] // @1FAF stack[-1] // @1FB1 stack[-2] // @1FB9 memory[0x00:0x20] // @1FBD storage[keccak256(memory[0x00:0x20])] // } 1FAD 5B JUMPDEST 1FAE 82 DUP3 1FAF 01 ADD 1FB0 91 SWAP2 1FB1 90 SWAP1 1FB2 60 PUSH1 0x00 1FB4 52 MSTORE 1FB5 60 PUSH1 0x20 1FB7 60 PUSH1 0x00 1FB9 20 SHA3 1FBA 90 SWAP1 1FBB 5B JUMPDEST 1FBC 81 DUP2 1FBD 54 SLOAD 1FBE 81 DUP2 1FBF 52 MSTORE 1FC0 90 SWAP1 1FC1 60 PUSH1 0x01 1FC3 01 ADD 1FC4 90 SWAP1 1FC5 60 PUSH1 0x20 1FC7 01 ADD 1FC8 80 DUP1 1FC9 83 DUP4 1FCA 11 GT 1FCB 61 PUSH2 0x1fbb 1FCE 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1FB0 stack[-3] = stack[-3] + stack[-1] // @1FB4 memory[0x00:0x20] = stack[-2] // @1FBF memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1FC4 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1FC7 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1fbb, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1FCF: // Incoming jump from 0x1FCE, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1FCE, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1FCF stack[-3] // @1FD0 stack[-1] // } 1FCF 82 DUP3 1FD0 90 SWAP1 1FD1 03 SUB 1FD2 60 PUSH1 0x1f 1FD4 16 AND 1FD5 82 DUP3 1FD6 01 ADD 1FD7 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1FD7 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1FD7 stack[-1] = stack[-3] // } // Block continues label_1FD8: // Incoming jump from 0x1FD7 // Incoming jump from 0x1F91, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x1FAC // Inputs[7] // { // @1FDE stack[-12] // @1FDE stack[-6] // @1FE4 stack[-14] // @1FF2 memory[0x00:0x40] // @1FF4 storage[keccak256(memory[0x00:0x40])] // @2015 memory[0x40:0x60] // @2028 storage[keccak256(memory[0x00:0x40])] // } 1FD8 5B JUMPDEST 1FD9 50 POP 1FDA 50 POP 1FDB 50 POP 1FDC 50 POP 1FDD 50 POP 1FDE 95 SWAP6 1FDF 50 POP 1FE0 60 PUSH1 0x13 1FE2 60 PUSH1 0x00 1FE4 89 DUP10 1FE5 81 DUP2 1FE6 52 MSTORE 1FE7 60 PUSH1 0x20 1FE9 01 ADD 1FEA 90 SWAP1 1FEB 81 DUP2 1FEC 52 MSTORE 1FED 60 PUSH1 0x20 1FEF 01 ADD 1FF0 60 PUSH1 0x00 1FF2 20 SHA3 1FF3 80 DUP1 1FF4 54 SLOAD 1FF5 60 PUSH1 0x01 1FF7 81 DUP2 1FF8 60 PUSH1 0x01 1FFA 16 AND 1FFB 15 ISZERO 1FFC 61 PUSH2 0x0100 1FFF 02 MUL 2000 03 SUB 2001 16 AND 2002 60 PUSH1 0x02 2004 90 SWAP1 2005 04 DIV 2006 80 DUP1 2007 60 PUSH1 0x1f 2009 01 ADD 200A 60 PUSH1 0x20 200C 80 DUP1 200D 91 SWAP2 200E 04 DIV 200F 02 MUL 2010 60 PUSH1 0x20 2012 01 ADD 2013 60 PUSH1 0x40 2015 51 MLOAD 2016 90 SWAP1 2017 81 DUP2 2018 01 ADD 2019 60 PUSH1 0x40 201B 52 MSTORE 201C 80 DUP1 201D 92 SWAP3 201E 91 SWAP2 201F 90 SWAP1 2020 81 DUP2 2021 81 DUP2 2022 52 MSTORE 2023 60 PUSH1 0x20 2025 01 ADD 2026 82 DUP3 2027 80 DUP1 2028 54 SLOAD 2029 60 PUSH1 0x01 202B 81 DUP2 202C 60 PUSH1 0x01 202E 16 AND 202F 15 ISZERO 2030 61 PUSH2 0x0100 2033 02 MUL 2034 03 SUB 2035 16 AND 2036 60 PUSH1 0x02 2038 90 SWAP1 2039 04 DIV 203A 80 DUP1 203B 15 ISZERO 203C 61 PUSH2 0x2086 203F 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @1FDE stack[-12] = stack[-6] // @1FE6 memory[0x00:0x20] = stack[-14] // @1FEC memory[0x20:0x40] = 0x13 // @201B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @201D stack[-6] = memory[0x40:0x60] // @201E stack[-5] = keccak256(memory[0x00:0x40]) // @201F stack[-4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2022 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2025 stack[-3] = 0x20 + memory[0x40:0x60] // @2026 stack[-2] = keccak256(memory[0x00:0x40]) // @2039 stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x2086, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_2040: // Incoming jump from 0x203F, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @2040 stack[-1] } 2040 80 DUP1 2041 60 PUSH1 0x1f 2043 10 LT 2044 61 PUSH2 0x205b 2047 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x205b, if 0x1f < stack[-1] label_2048: // Incoming jump from 0x2047, if not 0x1f < stack[-1] // Inputs[4] // { // @204C stack[-2] // @204D storage[stack[-2]] // @2050 stack[-3] // @2052 stack[-1] // } 2048 61 PUSH2 0x0100 204B 80 DUP1 204C 83 DUP4 204D 54 SLOAD 204E 04 DIV 204F 02 MUL 2050 83 DUP4 2051 52 MSTORE 2052 91 SWAP2 2053 60 PUSH1 0x20 2055 01 ADD 2056 91 SWAP2 2057 61 PUSH2 0x2086 205A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2051 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2056 stack[-1] = stack[-1] // @2056 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2086 label_205B: // Incoming jump from 0x2047, if 0x1f < stack[-1] // Inputs[5] // { // @205C stack[-3] // @205D stack[-1] // @205F stack[-2] // @2067 memory[0x00:0x20] // @206B storage[keccak256(memory[0x00:0x20])] // } 205B 5B JUMPDEST 205C 82 DUP3 205D 01 ADD 205E 91 SWAP2 205F 90 SWAP1 2060 60 PUSH1 0x00 2062 52 MSTORE 2063 60 PUSH1 0x20 2065 60 PUSH1 0x00 2067 20 SHA3 2068 90 SWAP1 2069 5B JUMPDEST 206A 81 DUP2 206B 54 SLOAD 206C 81 DUP2 206D 52 MSTORE 206E 90 SWAP1 206F 60 PUSH1 0x01 2071 01 ADD 2072 90 SWAP1 2073 60 PUSH1 0x20 2075 01 ADD 2076 80 DUP1 2077 83 DUP4 2078 11 GT 2079 61 PUSH2 0x2069 207C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @205E stack[-3] = stack[-3] + stack[-1] // @2062 memory[0x00:0x20] = stack[-2] // @206D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2072 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2075 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2069, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_207D: // Incoming jump from 0x207C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x207C, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @207D stack[-3] // @207E stack[-1] // } 207D 82 DUP3 207E 90 SWAP1 207F 03 SUB 2080 60 PUSH1 0x1f 2082 16 AND 2083 82 DUP3 2084 01 ADD 2085 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2085 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2085 stack[-1] = stack[-3] // } // Block continues label_2086: // Incoming jump from 0x205A // Incoming jump from 0x203F, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x2085 // Inputs[7] // { // @208C stack[-6] // @208C stack[-11] // @2092 stack[-14] // @20A0 memory[0x00:0x40] // @20A2 storage[keccak256(memory[0x00:0x40])] // @20C3 memory[0x40:0x60] // @20D6 storage[keccak256(memory[0x00:0x40])] // } 2086 5B JUMPDEST 2087 50 POP 2088 50 POP 2089 50 POP 208A 50 POP 208B 50 POP 208C 94 SWAP5 208D 50 POP 208E 60 PUSH1 0x12 2090 60 PUSH1 0x00 2092 89 DUP10 2093 81 DUP2 2094 52 MSTORE 2095 60 PUSH1 0x20 2097 01 ADD 2098 90 SWAP1 2099 81 DUP2 209A 52 MSTORE 209B 60 PUSH1 0x20 209D 01 ADD 209E 60 PUSH1 0x00 20A0 20 SHA3 20A1 80 DUP1 20A2 54 SLOAD 20A3 60 PUSH1 0x01 20A5 81 DUP2 20A6 60 PUSH1 0x01 20A8 16 AND 20A9 15 ISZERO 20AA 61 PUSH2 0x0100 20AD 02 MUL 20AE 03 SUB 20AF 16 AND 20B0 60 PUSH1 0x02 20B2 90 SWAP1 20B3 04 DIV 20B4 80 DUP1 20B5 60 PUSH1 0x1f 20B7 01 ADD 20B8 60 PUSH1 0x20 20BA 80 DUP1 20BB 91 SWAP2 20BC 04 DIV 20BD 02 MUL 20BE 60 PUSH1 0x20 20C0 01 ADD 20C1 60 PUSH1 0x40 20C3 51 MLOAD 20C4 90 SWAP1 20C5 81 DUP2 20C6 01 ADD 20C7 60 PUSH1 0x40 20C9 52 MSTORE 20CA 80 DUP1 20CB 92 SWAP3 20CC 91 SWAP2 20CD 90 SWAP1 20CE 81 DUP2 20CF 81 DUP2 20D0 52 MSTORE 20D1 60 PUSH1 0x20 20D3 01 ADD 20D4 82 DUP3 20D5 80 DUP1 20D6 54 SLOAD 20D7 60 PUSH1 0x01 20D9 81 DUP2 20DA 60 PUSH1 0x01 20DC 16 AND 20DD 15 ISZERO 20DE 61 PUSH2 0x0100 20E1 02 MUL 20E2 03 SUB 20E3 16 AND 20E4 60 PUSH1 0x02 20E6 90 SWAP1 20E7 04 DIV 20E8 80 DUP1 20E9 15 ISZERO 20EA 61 PUSH2 0x2134 20ED 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @208C stack[-11] = stack[-6] // @2094 memory[0x00:0x20] = stack[-14] // @209A memory[0x20:0x40] = 0x12 // @20C9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @20CB stack[-6] = memory[0x40:0x60] // @20CC stack[-5] = keccak256(memory[0x00:0x40]) // @20CD stack[-4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @20D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @20D3 stack[-3] = 0x20 + memory[0x40:0x60] // @20D4 stack[-2] = keccak256(memory[0x00:0x40]) // @20E7 stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x2134, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_20EE: // Incoming jump from 0x20ED, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @20EE stack[-1] } 20EE 80 DUP1 20EF 60 PUSH1 0x1f 20F1 10 LT 20F2 61 PUSH2 0x2109 20F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2109, if 0x1f < stack[-1] label_20F6: // Incoming jump from 0x20F5, if not 0x1f < stack[-1] // Inputs[4] // { // @20FA stack[-2] // @20FB storage[stack[-2]] // @20FE stack[-3] // @2100 stack[-1] // } 20F6 61 PUSH2 0x0100 20F9 80 DUP1 20FA 83 DUP4 20FB 54 SLOAD 20FC 04 DIV 20FD 02 MUL 20FE 83 DUP4 20FF 52 MSTORE 2100 91 SWAP2 2101 60 PUSH1 0x20 2103 01 ADD 2104 91 SWAP2 2105 61 PUSH2 0x2134 2108 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @20FF memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2104 stack[-1] = stack[-1] // @2104 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2134 label_2109: // Incoming jump from 0x20F5, if 0x1f < stack[-1] // Inputs[5] // { // @210A stack[-3] // @210B stack[-1] // @210D stack[-2] // @2115 memory[0x00:0x20] // @2119 storage[keccak256(memory[0x00:0x20])] // } 2109 5B JUMPDEST 210A 82 DUP3 210B 01 ADD 210C 91 SWAP2 210D 90 SWAP1 210E 60 PUSH1 0x00 2110 52 MSTORE 2111 60 PUSH1 0x20 2113 60 PUSH1 0x00 2115 20 SHA3 2116 90 SWAP1 2117 5B JUMPDEST 2118 81 DUP2 2119 54 SLOAD 211A 81 DUP2 211B 52 MSTORE 211C 90 SWAP1 211D 60 PUSH1 0x01 211F 01 ADD 2120 90 SWAP1 2121 60 PUSH1 0x20 2123 01 ADD 2124 80 DUP1 2125 83 DUP4 2126 11 GT 2127 61 PUSH2 0x2117 212A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @210C stack[-3] = stack[-3] + stack[-1] // @2110 memory[0x00:0x20] = stack[-2] // @211B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2120 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2123 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2117, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_212B: // Incoming jump from 0x212A, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x212A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @212B stack[-3] // @212C stack[-1] // } 212B 82 DUP3 212C 90 SWAP1 212D 03 SUB 212E 60 PUSH1 0x1f 2130 16 AND 2131 82 DUP3 2132 01 ADD 2133 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2133 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2133 stack[-1] = stack[-3] // } // Block continues label_2134: // Incoming jump from 0x20ED, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x2108 // Incoming jump from 0x2133 // Inputs[7] // { // @213A stack[-10] // @213A stack[-6] // @2140 stack[-14] // @214E memory[0x00:0x40] // @2150 storage[keccak256(memory[0x00:0x40])] // @2171 memory[0x40:0x60] // @2184 storage[keccak256(memory[0x00:0x40])] // } 2134 5B JUMPDEST 2135 50 POP 2136 50 POP 2137 50 POP 2138 50 POP 2139 50 POP 213A 93 SWAP4 213B 50 POP 213C 60 PUSH1 0x14 213E 60 PUSH1 0x00 2140 89 DUP10 2141 81 DUP2 2142 52 MSTORE 2143 60 PUSH1 0x20 2145 01 ADD 2146 90 SWAP1 2147 81 DUP2 2148 52 MSTORE 2149 60 PUSH1 0x20 214B 01 ADD 214C 60 PUSH1 0x00 214E 20 SHA3 214F 80 DUP1 2150 54 SLOAD 2151 60 PUSH1 0x01 2153 81 DUP2 2154 60 PUSH1 0x01 2156 16 AND 2157 15 ISZERO 2158 61 PUSH2 0x0100 215B 02 MUL 215C 03 SUB 215D 16 AND 215E 60 PUSH1 0x02 2160 90 SWAP1 2161 04 DIV 2162 80 DUP1 2163 60 PUSH1 0x1f 2165 01 ADD 2166 60 PUSH1 0x20 2168 80 DUP1 2169 91 SWAP2 216A 04 DIV 216B 02 MUL 216C 60 PUSH1 0x20 216E 01 ADD 216F 60 PUSH1 0x40 2171 51 MLOAD 2172 90 SWAP1 2173 81 DUP2 2174 01 ADD 2175 60 PUSH1 0x40 2177 52 MSTORE 2178 80 DUP1 2179 92 SWAP3 217A 91 SWAP2 217B 90 SWAP1 217C 81 DUP2 217D 81 DUP2 217E 52 MSTORE 217F 60 PUSH1 0x20 2181 01 ADD 2182 82 DUP3 2183 80 DUP1 2184 54 SLOAD 2185 60 PUSH1 0x01 2187 81 DUP2 2188 60 PUSH1 0x01 218A 16 AND 218B 15 ISZERO 218C 61 PUSH2 0x0100 218F 02 MUL 2190 03 SUB 2191 16 AND 2192 60 PUSH1 0x02 2194 90 SWAP1 2195 04 DIV 2196 80 DUP1 2197 15 ISZERO 2198 61 PUSH2 0x21e2 219B 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @213A stack[-10] = stack[-6] // @2142 memory[0x00:0x20] = stack[-14] // @2148 memory[0x20:0x40] = 0x14 // @2177 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @2179 stack[-6] = memory[0x40:0x60] // @217A stack[-5] = keccak256(memory[0x00:0x40]) // @217B stack[-4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @217E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2181 stack[-3] = 0x20 + memory[0x40:0x60] // @2182 stack[-2] = keccak256(memory[0x00:0x40]) // @2195 stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x21e2, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_219C: // Incoming jump from 0x219B, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @219C stack[-1] } 219C 80 DUP1 219D 60 PUSH1 0x1f 219F 10 LT 21A0 61 PUSH2 0x21b7 21A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21b7, if 0x1f < stack[-1] label_21A4: // Incoming jump from 0x21A3, if not 0x1f < stack[-1] // Inputs[4] // { // @21A8 stack[-2] // @21A9 storage[stack[-2]] // @21AC stack[-3] // @21AE stack[-1] // } 21A4 61 PUSH2 0x0100 21A7 80 DUP1 21A8 83 DUP4 21A9 54 SLOAD 21AA 04 DIV 21AB 02 MUL 21AC 83 DUP4 21AD 52 MSTORE 21AE 91 SWAP2 21AF 60 PUSH1 0x20 21B1 01 ADD 21B2 91 SWAP2 21B3 61 PUSH2 0x21e2 21B6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @21AD memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @21B2 stack[-1] = stack[-1] // @21B2 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x21e2 label_21B7: // Incoming jump from 0x21A3, if 0x1f < stack[-1] // Inputs[5] // { // @21B8 stack[-3] // @21B9 stack[-1] // @21BB stack[-2] // @21C3 memory[0x00:0x20] // @21C7 storage[keccak256(memory[0x00:0x20])] // } 21B7 5B JUMPDEST 21B8 82 DUP3 21B9 01 ADD 21BA 91 SWAP2 21BB 90 SWAP1 21BC 60 PUSH1 0x00 21BE 52 MSTORE 21BF 60 PUSH1 0x20 21C1 60 PUSH1 0x00 21C3 20 SHA3 21C4 90 SWAP1 21C5 5B JUMPDEST 21C6 81 DUP2 21C7 54 SLOAD 21C8 81 DUP2 21C9 52 MSTORE 21CA 90 SWAP1 21CB 60 PUSH1 0x01 21CD 01 ADD 21CE 90 SWAP1 21CF 60 PUSH1 0x20 21D1 01 ADD 21D2 80 DUP1 21D3 83 DUP4 21D4 11 GT 21D5 61 PUSH2 0x21c5 21D8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @21BA stack[-3] = stack[-3] + stack[-1] // @21BE memory[0x00:0x20] = stack[-2] // @21C9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @21CE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @21D1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x21c5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_21D9: // Incoming jump from 0x21D8, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x21D8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @21D9 stack[-3] // @21DA stack[-1] // } 21D9 82 DUP3 21DA 90 SWAP1 21DB 03 SUB 21DC 60 PUSH1 0x1f 21DE 16 AND 21DF 82 DUP3 21E0 01 ADD 21E1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @21E1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @21E1 stack[-1] = stack[-3] // } // Block continues label_21E2: // Incoming jump from 0x21B6 // Incoming jump from 0x21E1 // Incoming jump from 0x219B, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[14] // { // @21E8 stack[-6] // @21E8 stack[-9] // @21EE stack[-14] // @21FC memory[0x00:0x40] // @21FD storage[keccak256(memory[0x00:0x40])] // @21FE stack[-8] // @2212 memory[0x00:0x40] // @2213 storage[keccak256(memory[0x00:0x40])] // @2214 stack[-7] // @2217 stack[-11] // @2218 stack[-13] // @2219 stack[-15] // @221B stack[-10] // @221C stack[-12] // } 21E2 5B JUMPDEST 21E3 50 POP 21E4 50 POP 21E5 50 POP 21E6 50 POP 21E7 50 POP 21E8 92 SWAP3 21E9 50 POP 21EA 60 PUSH1 0x16 21EC 60 PUSH1 0x00 21EE 89 DUP10 21EF 81 DUP2 21F0 52 MSTORE 21F1 60 PUSH1 0x20 21F3 01 ADD 21F4 90 SWAP1 21F5 81 DUP2 21F6 52 MSTORE 21F7 60 PUSH1 0x20 21F9 01 ADD 21FA 60 PUSH1 0x00 21FC 20 SHA3 21FD 54 SLOAD 21FE 91 SWAP2 21FF 50 POP 2200 60 PUSH1 0x17 2202 60 PUSH1 0x00 2204 89 DUP10 2205 81 DUP2 2206 52 MSTORE 2207 60 PUSH1 0x20 2209 01 ADD 220A 90 SWAP1 220B 81 DUP2 220C 52 MSTORE 220D 60 PUSH1 0x20 220F 01 ADD 2210 60 PUSH1 0x00 2212 20 SHA3 2213 54 SLOAD 2214 90 SWAP1 2215 50 POP 2216 91 SWAP2 2217 93 SWAP4 2218 95 SWAP6 2219 97 SWAP8 221A 90 SWAP1 221B 92 SWAP3 221C 94 SWAP5 221D 96 SWAP7 221E 50 POP 221F 56 *JUMP // Stack delta = -8 // Outputs[11] // { // @21F0 memory[0x00:0x20] = stack[-14] // @21F6 memory[0x20:0x40] = 0x16 // @2206 memory[0x00:0x20] = stack[-14] // @220C memory[0x20:0x40] = 0x17 // @2216 stack[-9] = storage[keccak256(memory[0x00:0x40])] // @2217 stack[-11] = stack[-6] // @2218 stack[-13] = stack[-11] // @2219 stack[-15] = stack[-13] // @221B stack[-10] = storage[keccak256(memory[0x00:0x40])] // @221C stack[-12] = stack[-10] // @221D stack[-14] = stack[-12] // } // Block ends with unconditional jump to stack[-15] label_2220: // Incoming jump from 0x0801 // Inputs[4] // { // @2224 stack[-3] // @2225 stack[-2] // @2226 stack[-1] // @2229 memory[0x40:0x60] // } 2220 5B JUMPDEST 2221 61 PUSH2 0x223b 2224 83 DUP4 2225 83 DUP4 2226 83 DUP4 2227 60 PUSH1 0x40 2229 51 MLOAD 222A 80 DUP1 222B 60 PUSH1 0x20 222D 01 ADD 222E 60 PUSH1 0x40 2230 52 MSTORE 2231 80 DUP1 2232 60 PUSH1 0x00 2234 81 DUP2 2235 52 MSTORE 2236 50 POP 2237 61 PUSH2 0x2e6b 223A 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2221 stack[0] = 0x223b // @2224 stack[1] = stack[-3] // @2225 stack[2] = stack[-2] // @2226 stack[3] = stack[-1] // @2229 stack[4] = memory[0x40:0x60] // @2230 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @2235 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x2e6b, returns to 0x223B label_223B: // Incoming return from call to 0x2E6B at 0x223A // Inputs[1] { @223F stack[-4] } 223B 5B JUMPDEST 223C 50 POP 223D 50 POP 223E 50 POP 223F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2240: // Incoming jump from 0x083C // Inputs[5] // { // @224A stack[-1] // @2258 memory[0x00:0x40] // @225A storage[keccak256(memory[0x00:0x40])] // @227B memory[0x40:0x60] // @228E storage[keccak256(memory[0x00:0x40])] // } 2240 5B JUMPDEST 2241 60 PUSH1 0x60 2243 80 DUP1 2244 60 PUSH1 0x60 2246 60 PUSH1 0x19 2248 60 PUSH1 0x00 224A 85 DUP6 224B 81 DUP2 224C 52 MSTORE 224D 60 PUSH1 0x20 224F 01 ADD 2250 90 SWAP1 2251 81 DUP2 2252 52 MSTORE 2253 60 PUSH1 0x20 2255 01 ADD 2256 60 PUSH1 0x00 2258 20 SHA3 2259 80 DUP1 225A 54 SLOAD 225B 60 PUSH1 0x01 225D 81 DUP2 225E 60 PUSH1 0x01 2260 16 AND 2261 15 ISZERO 2262 61 PUSH2 0x0100 2265 02 MUL 2266 03 SUB 2267 16 AND 2268 60 PUSH1 0x02 226A 90 SWAP1 226B 04 DIV 226C 80 DUP1 226D 60 PUSH1 0x1f 226F 01 ADD 2270 60 PUSH1 0x20 2272 80 DUP1 2273 91 SWAP2 2274 04 DIV 2275 02 MUL 2276 60 PUSH1 0x20 2278 01 ADD 2279 60 PUSH1 0x40 227B 51 MLOAD 227C 90 SWAP1 227D 81 DUP2 227E 01 ADD 227F 60 PUSH1 0x40 2281 52 MSTORE 2282 80 DUP1 2283 92 SWAP3 2284 91 SWAP2 2285 90 SWAP1 2286 81 DUP2 2287 81 DUP2 2288 52 MSTORE 2289 60 PUSH1 0x20 228B 01 ADD 228C 82 DUP3 228D 80 DUP1 228E 54 SLOAD 228F 60 PUSH1 0x01 2291 81 DUP2 2292 60 PUSH1 0x01 2294 16 AND 2295 15 ISZERO 2296 61 PUSH2 0x0100 2299 02 MUL 229A 03 SUB 229B 16 AND 229C 60 PUSH1 0x02 229E 90 SWAP1 229F 04 DIV 22A0 80 DUP1 22A1 15 ISZERO 22A2 61 PUSH2 0x22ec 22A5 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @2241 stack[0] = 0x60 // @2243 stack[1] = 0x60 // @2244 stack[2] = 0x60 // @224C memory[0x00:0x20] = stack[-1] // @2252 memory[0x20:0x40] = 0x19 // @2281 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @2283 stack[3] = memory[0x40:0x60] // @2284 stack[4] = keccak256(memory[0x00:0x40]) // @2285 stack[5] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2288 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @228B stack[6] = 0x20 + memory[0x40:0x60] // @228C stack[7] = keccak256(memory[0x00:0x40]) // @229F stack[8] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x22ec, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_22A6: // Incoming jump from 0x22A5, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @22A6 stack[-1] } 22A6 80 DUP1 22A7 60 PUSH1 0x1f 22A9 10 LT 22AA 61 PUSH2 0x22c1 22AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x22c1, if 0x1f < stack[-1] label_22AE: // Incoming jump from 0x22AD, if not 0x1f < stack[-1] // Inputs[4] // { // @22B2 stack[-2] // @22B3 storage[stack[-2]] // @22B6 stack[-3] // @22B8 stack[-1] // } 22AE 61 PUSH2 0x0100 22B1 80 DUP1 22B2 83 DUP4 22B3 54 SLOAD 22B4 04 DIV 22B5 02 MUL 22B6 83 DUP4 22B7 52 MSTORE 22B8 91 SWAP2 22B9 60 PUSH1 0x20 22BB 01 ADD 22BC 91 SWAP2 22BD 61 PUSH2 0x22ec 22C0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @22B7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @22BC stack[-1] = stack[-1] // @22BC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x22ec label_22C1: // Incoming jump from 0x22AD, if 0x1f < stack[-1] // Inputs[5] // { // @22C2 stack[-3] // @22C3 stack[-1] // @22C5 stack[-2] // @22CD memory[0x00:0x20] // @22D1 storage[keccak256(memory[0x00:0x20])] // } 22C1 5B JUMPDEST 22C2 82 DUP3 22C3 01 ADD 22C4 91 SWAP2 22C5 90 SWAP1 22C6 60 PUSH1 0x00 22C8 52 MSTORE 22C9 60 PUSH1 0x20 22CB 60 PUSH1 0x00 22CD 20 SHA3 22CE 90 SWAP1 22CF 5B JUMPDEST 22D0 81 DUP2 22D1 54 SLOAD 22D2 81 DUP2 22D3 52 MSTORE 22D4 90 SWAP1 22D5 60 PUSH1 0x01 22D7 01 ADD 22D8 90 SWAP1 22D9 60 PUSH1 0x20 22DB 01 ADD 22DC 80 DUP1 22DD 83 DUP4 22DE 11 GT 22DF 61 PUSH2 0x22cf 22E2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @22C4 stack[-3] = stack[-3] + stack[-1] // @22C8 memory[0x00:0x20] = stack[-2] // @22D3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @22D8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @22DB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x22cf, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_22E3: // Incoming jump from 0x22E2, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x22E2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @22E3 stack[-3] // @22E4 stack[-1] // } 22E3 82 DUP3 22E4 90 SWAP1 22E5 03 SUB 22E6 60 PUSH1 0x1f 22E8 16 AND 22E9 82 DUP3 22EA 01 ADD 22EB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @22EB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @22EB stack[-1] = stack[-3] // } // Block continues label_22EC: // Incoming jump from 0x22EB // Incoming jump from 0x22A5, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x22C0 // Inputs[7] // { // @22F2 stack[-6] // @22F2 stack[-9] // @22F8 stack[-10] // @2306 memory[0x00:0x40] // @2308 storage[keccak256(memory[0x00:0x40])] // @2329 memory[0x40:0x60] // @233C storage[keccak256(memory[0x00:0x40])] // } 22EC 5B JUMPDEST 22ED 50 POP 22EE 50 POP 22EF 50 POP 22F0 50 POP 22F1 50 POP 22F2 92 SWAP3 22F3 50 POP 22F4 60 PUSH1 0x18 22F6 60 PUSH1 0x00 22F8 85 DUP6 22F9 81 DUP2 22FA 52 MSTORE 22FB 60 PUSH1 0x20 22FD 01 ADD 22FE 90 SWAP1 22FF 81 DUP2 2300 52 MSTORE 2301 60 PUSH1 0x20 2303 01 ADD 2304 60 PUSH1 0x00 2306 20 SHA3 2307 80 DUP1 2308 54 SLOAD 2309 60 PUSH1 0x01 230B 81 DUP2 230C 60 PUSH1 0x01 230E 16 AND 230F 15 ISZERO 2310 61 PUSH2 0x0100 2313 02 MUL 2314 03 SUB 2315 16 AND 2316 60 PUSH1 0x02 2318 90 SWAP1 2319 04 DIV 231A 80 DUP1 231B 60 PUSH1 0x1f 231D 01 ADD 231E 60 PUSH1 0x20 2320 80 DUP1 2321 91 SWAP2 2322 04 DIV 2323 02 MUL 2324 60 PUSH1 0x20 2326 01 ADD 2327 60 PUSH1 0x40 2329 51 MLOAD 232A 90 SWAP1 232B 81 DUP2 232C 01 ADD 232D 60 PUSH1 0x40 232F 52 MSTORE 2330 80 DUP1 2331 92 SWAP3 2332 91 SWAP2 2333 90 SWAP1 2334 81 DUP2 2335 81 DUP2 2336 52 MSTORE 2337 60 PUSH1 0x20 2339 01 ADD 233A 82 DUP3 233B 80 DUP1 233C 54 SLOAD 233D 60 PUSH1 0x01 233F 81 DUP2 2340 60 PUSH1 0x01 2342 16 AND 2343 15 ISZERO 2344 61 PUSH2 0x0100 2347 02 MUL 2348 03 SUB 2349 16 AND 234A 60 PUSH1 0x02 234C 90 SWAP1 234D 04 DIV 234E 80 DUP1 234F 15 ISZERO 2350 61 PUSH2 0x239a 2353 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @22F2 stack[-9] = stack[-6] // @22FA memory[0x00:0x20] = stack[-10] // @2300 memory[0x20:0x40] = 0x18 // @232F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @2331 stack[-6] = memory[0x40:0x60] // @2332 stack[-5] = keccak256(memory[0x00:0x40]) // @2333 stack[-4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2336 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2339 stack[-3] = 0x20 + memory[0x40:0x60] // @233A stack[-2] = keccak256(memory[0x00:0x40]) // @234D stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x239a, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_2354: // Incoming jump from 0x2353, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @2354 stack[-1] } 2354 80 DUP1 2355 60 PUSH1 0x1f 2357 10 LT 2358 61 PUSH2 0x236f 235B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x236f, if 0x1f < stack[-1] label_235C: // Incoming jump from 0x235B, if not 0x1f < stack[-1] // Inputs[4] // { // @2360 stack[-2] // @2361 storage[stack[-2]] // @2364 stack[-3] // @2366 stack[-1] // } 235C 61 PUSH2 0x0100 235F 80 DUP1 2360 83 DUP4 2361 54 SLOAD 2362 04 DIV 2363 02 MUL 2364 83 DUP4 2365 52 MSTORE 2366 91 SWAP2 2367 60 PUSH1 0x20 2369 01 ADD 236A 91 SWAP2 236B 61 PUSH2 0x239a 236E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2365 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @236A stack[-1] = stack[-1] // @236A stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x239a label_236F: // Incoming jump from 0x235B, if 0x1f < stack[-1] // Inputs[5] // { // @2370 stack[-3] // @2371 stack[-1] // @2373 stack[-2] // @237B memory[0x00:0x20] // @237F storage[keccak256(memory[0x00:0x20])] // } 236F 5B JUMPDEST 2370 82 DUP3 2371 01 ADD 2372 91 SWAP2 2373 90 SWAP1 2374 60 PUSH1 0x00 2376 52 MSTORE 2377 60 PUSH1 0x20 2379 60 PUSH1 0x00 237B 20 SHA3 237C 90 SWAP1 237D 5B JUMPDEST 237E 81 DUP2 237F 54 SLOAD 2380 81 DUP2 2381 52 MSTORE 2382 90 SWAP1 2383 60 PUSH1 0x01 2385 01 ADD 2386 90 SWAP1 2387 60 PUSH1 0x20 2389 01 ADD 238A 80 DUP1 238B 83 DUP4 238C 11 GT 238D 61 PUSH2 0x237d 2390 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2372 stack[-3] = stack[-3] + stack[-1] // @2376 memory[0x00:0x20] = stack[-2] // @2381 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2386 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2389 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x237d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2391: // Incoming jump from 0x2390, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2390, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @2391 stack[-3] // @2392 stack[-1] // } 2391 82 DUP3 2392 90 SWAP1 2393 03 SUB 2394 60 PUSH1 0x1f 2396 16 AND 2397 82 DUP3 2398 01 ADD 2399 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2399 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2399 stack[-1] = stack[-3] // } // Block continues label_239A: // Incoming jump from 0x2399 // Incoming jump from 0x236E // Incoming jump from 0x2353, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[7] // { // @23A0 stack[-8] // @23A0 stack[-6] // @23A6 stack[-10] // @23B4 memory[0x00:0x40] // @23B6 storage[keccak256(memory[0x00:0x40])] // @23D7 memory[0x40:0x60] // @23EA storage[keccak256(memory[0x00:0x40])] // } 239A 5B JUMPDEST 239B 50 POP 239C 50 POP 239D 50 POP 239E 50 POP 239F 50 POP 23A0 91 SWAP2 23A1 50 POP 23A2 60 PUSH1 0x11 23A4 60 PUSH1 0x00 23A6 85 DUP6 23A7 81 DUP2 23A8 52 MSTORE 23A9 60 PUSH1 0x20 23AB 01 ADD 23AC 90 SWAP1 23AD 81 DUP2 23AE 52 MSTORE 23AF 60 PUSH1 0x20 23B1 01 ADD 23B2 60 PUSH1 0x00 23B4 20 SHA3 23B5 80 DUP1 23B6 54 SLOAD 23B7 60 PUSH1 0x01 23B9 81 DUP2 23BA 60 PUSH1 0x01 23BC 16 AND 23BD 15 ISZERO 23BE 61 PUSH2 0x0100 23C1 02 MUL 23C2 03 SUB 23C3 16 AND 23C4 60 PUSH1 0x02 23C6 90 SWAP1 23C7 04 DIV 23C8 80 DUP1 23C9 60 PUSH1 0x1f 23CB 01 ADD 23CC 60 PUSH1 0x20 23CE 80 DUP1 23CF 91 SWAP2 23D0 04 DIV 23D1 02 MUL 23D2 60 PUSH1 0x20 23D4 01 ADD 23D5 60 PUSH1 0x40 23D7 51 MLOAD 23D8 90 SWAP1 23D9 81 DUP2 23DA 01 ADD 23DB 60 PUSH1 0x40 23DD 52 MSTORE 23DE 80 DUP1 23DF 92 SWAP3 23E0 91 SWAP2 23E1 90 SWAP1 23E2 81 DUP2 23E3 81 DUP2 23E4 52 MSTORE 23E5 60 PUSH1 0x20 23E7 01 ADD 23E8 82 DUP3 23E9 80 DUP1 23EA 54 SLOAD 23EB 60 PUSH1 0x01 23ED 81 DUP2 23EE 60 PUSH1 0x01 23F0 16 AND 23F1 15 ISZERO 23F2 61 PUSH2 0x0100 23F5 02 MUL 23F6 03 SUB 23F7 16 AND 23F8 60 PUSH1 0x02 23FA 90 SWAP1 23FB 04 DIV 23FC 80 DUP1 23FD 15 ISZERO 23FE 61 PUSH2 0x2448 2401 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @23A0 stack[-8] = stack[-6] // @23A8 memory[0x00:0x20] = stack[-10] // @23AE memory[0x20:0x40] = 0x11 // @23DD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @23DF stack[-6] = memory[0x40:0x60] // @23E0 stack[-5] = keccak256(memory[0x00:0x40]) // @23E1 stack[-4] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @23E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @23E7 stack[-3] = 0x20 + memory[0x40:0x60] // @23E8 stack[-2] = keccak256(memory[0x00:0x40]) // @23FB stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x2448, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_2402: // Incoming jump from 0x2401, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @2402 stack[-1] } 2402 80 DUP1 2403 60 PUSH1 0x1f 2405 10 LT 2406 61 PUSH2 0x241d 2409 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x241d, if 0x1f < stack[-1] label_240A: // Incoming jump from 0x2409, if not 0x1f < stack[-1] // Inputs[4] // { // @240E stack[-2] // @240F storage[stack[-2]] // @2412 stack[-3] // @2414 stack[-1] // } 240A 61 PUSH2 0x0100 240D 80 DUP1 240E 83 DUP4 240F 54 SLOAD 2410 04 DIV 2411 02 MUL 2412 83 DUP4 2413 52 MSTORE 2414 91 SWAP2 2415 60 PUSH1 0x20 2417 01 ADD 2418 91 SWAP2 2419 61 PUSH2 0x2448 241C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2413 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2418 stack[-1] = stack[-1] // @2418 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2448 label_241D: // Incoming jump from 0x2409, if 0x1f < stack[-1] // Inputs[5] // { // @241E stack[-3] // @241F stack[-1] // @2421 stack[-2] // @2429 memory[0x00:0x20] // @242D storage[keccak256(memory[0x00:0x20])] // } 241D 5B JUMPDEST 241E 82 DUP3 241F 01 ADD 2420 91 SWAP2 2421 90 SWAP1 2422 60 PUSH1 0x00 2424 52 MSTORE 2425 60 PUSH1 0x20 2427 60 PUSH1 0x00 2429 20 SHA3 242A 90 SWAP1 242B 5B JUMPDEST 242C 81 DUP2 242D 54 SLOAD 242E 81 DUP2 242F 52 MSTORE 2430 90 SWAP1 2431 60 PUSH1 0x01 2433 01 ADD 2434 90 SWAP1 2435 60 PUSH1 0x20 2437 01 ADD 2438 80 DUP1 2439 83 DUP4 243A 11 GT 243B 61 PUSH2 0x242b 243E 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2420 stack[-3] = stack[-3] + stack[-1] // @2424 memory[0x00:0x20] = stack[-2] // @242F memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2434 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2437 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x242b, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_243F: // Incoming jump from 0x243E, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x243E, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @243F stack[-3] // @2440 stack[-1] // } 243F 82 DUP3 2440 90 SWAP1 2441 03 SUB 2442 60 PUSH1 0x1f 2444 16 AND 2445 82 DUP3 2446 01 ADD 2447 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2447 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2447 stack[-1] = stack[-3] // } // Block continues label_2448: // Incoming jump from 0x2401, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x241C // Incoming jump from 0x2447 // Inputs[6] // { // @244E stack[-6] // @244E stack[-7] // @2450 stack[-9] // @2451 stack[-11] // @2452 stack[-8] // @2453 stack[-10] // } 2448 5B JUMPDEST 2449 50 POP 244A 50 POP 244B 50 POP 244C 50 POP 244D 50 POP 244E 90 SWAP1 244F 50 POP 2450 91 SWAP2 2451 93 SWAP4 2452 90 SWAP1 2453 92 SWAP3 2454 50 POP 2455 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @2450 stack[-9] = stack[-6] // @2451 stack[-11] = stack[-9] // @2453 stack[-10] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_2456: // Incoming jump from 0x09C8 // Incoming call from 0x1B87, returns to 0x1B88 // Incoming call from 0x3CD5, returns to 0x3CD6 // Incoming call from 0x3C2C, returns to 0x3C2D // Inputs[3] // { // @245E stack[-1] // @246C memory[0x00:0x40] // @2470 storage[keccak256(memory[0x00:0x40])] // } 2456 5B JUMPDEST 2457 60 PUSH1 0x00 2459 80 DUP1 245A 60 PUSH1 0x01 245C 60 PUSH1 0x00 245E 84 DUP5 245F 81 DUP2 2460 52 MSTORE 2461 60 PUSH1 0x20 2463 01 ADD 2464 90 SWAP1 2465 81 DUP2 2466 52 MSTORE 2467 60 PUSH1 0x20 2469 01 ADD 246A 60 PUSH1 0x00 246C 20 SHA3 246D 60 PUSH1 0x00 246F 90 SWAP1 2470 54 SLOAD 2471 90 SWAP1 2472 61 PUSH2 0x0100 2475 0A EXP 2476 90 SWAP1 2477 04 DIV 2478 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 248D 16 AND 248E 90 SWAP1 248F 50 POP 2490 60 PUSH1 0x00 2492 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24A7 16 AND 24A8 81 DUP2 24A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24BE 16 AND 24BF 14 EQ 24C0 15 ISZERO 24C1 61 PUSH2 0x2515 24C4 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2457 stack[0] = 0x00 // @2460 memory[0x00:0x20] = stack[-1] // @2466 memory[0x20:0x40] = 0x01 // @248E stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with conditional jump to 0x2515, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_24C5: // Incoming jump from 0x24C4, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @24C7 memory[0x40:0x60] // @250F memory[0x40:0x60] // @2514 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 24C5 60 PUSH1 0x40 24C7 51 MLOAD 24C8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 24E9 81 DUP2 24EA 52 MSTORE 24EB 60 PUSH1 0x04 24ED 01 ADD 24EE 80 DUP1 24EF 80 DUP1 24F0 60 PUSH1 0x20 24F2 01 ADD 24F3 82 DUP3 24F4 81 DUP2 24F5 03 SUB 24F6 82 DUP3 24F7 52 MSTORE 24F8 60 PUSH1 0x29 24FA 81 DUP2 24FB 52 MSTORE 24FC 60 PUSH1 0x20 24FE 01 ADD 24FF 80 DUP1 2500 61 PUSH2 0x4c91 2503 60 PUSH1 0x29 2505 91 SWAP2 2506 39 CODECOPY 2507 60 PUSH1 0x40 2509 01 ADD 250A 91 SWAP2 250B 50 POP 250C 50 POP 250D 60 PUSH1 0x40 250F 51 MLOAD 2510 80 DUP1 2511 91 SWAP2 2512 03 SUB 2513 90 SWAP1 2514 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @24EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @24F7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @24FB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @2506 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x4c91:0x4cba] // @2514 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2515: // Incoming jump from 0x24C4, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @2516 stack[-1] // @2517 stack[-2] // @251A stack[-4] // @251B stack[-3] // } 2515 5B JUMPDEST 2516 80 DUP1 2517 91 SWAP2 2518 50 POP 2519 50 POP 251A 91 SWAP2 251B 90 SWAP1 251C 50 POP 251D 56 *JUMP // Stack delta = -3 // Outputs[1] { @251A stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_251E: // Incoming jump from 0x0A59 // Inputs[1] { @2538 stack[-1] } 251E 5B JUMPDEST 251F 60 PUSH1 0x00 2521 80 DUP1 2522 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2537 16 AND 2538 82 DUP3 2539 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 254E 16 AND 254F 14 EQ 2550 15 ISZERO 2551 61 PUSH2 0x25a5 2554 57 *JUMPI // Stack delta = +1 // Outputs[1] { @251F stack[0] = 0x00 } // Block ends with conditional jump to 0x25a5, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2555: // Incoming jump from 0x2554, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2557 memory[0x40:0x60] // @259F memory[0x40:0x60] // @25A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2555 60 PUSH1 0x40 2557 51 MLOAD 2558 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2579 81 DUP2 257A 52 MSTORE 257B 60 PUSH1 0x04 257D 01 ADD 257E 80 DUP1 257F 80 DUP1 2580 60 PUSH1 0x20 2582 01 ADD 2583 82 DUP3 2584 81 DUP2 2585 03 SUB 2586 82 DUP3 2587 52 MSTORE 2588 60 PUSH1 0x2a 258A 81 DUP2 258B 52 MSTORE 258C 60 PUSH1 0x20 258E 01 ADD 258F 80 DUP1 2590 61 PUSH2 0x4c67 2593 60 PUSH1 0x2a 2595 91 SWAP2 2596 39 CODECOPY 2597 60 PUSH1 0x40 2599 01 ADD 259A 91 SWAP2 259B 50 POP 259C 50 POP 259D 60 PUSH1 0x40 259F 51 MLOAD 25A0 80 DUP1 25A1 91 SWAP2 25A2 03 SUB 25A3 90 SWAP1 25A4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @257A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2587 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @258B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @2596 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x4c67:0x4c91] // @25A4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_25A5: // Incoming jump from 0x2554, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @25AD stack[-2] // @25E7 memory[0x00:0x40] // } 25A5 5B JUMPDEST 25A6 61 PUSH2 0x25ec 25A9 60 PUSH1 0x03 25AB 60 PUSH1 0x00 25AD 84 DUP5 25AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25C3 16 AND 25C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25D9 16 AND 25DA 81 DUP2 25DB 52 MSTORE 25DC 60 PUSH1 0x20 25DE 01 ADD 25DF 90 SWAP1 25E0 81 DUP2 25E1 52 MSTORE 25E2 60 PUSH1 0x20 25E4 01 ADD 25E5 60 PUSH1 0x00 25E7 20 SHA3 25E8 61 PUSH2 0x3f11 25EB 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @25A6 stack[0] = 0x25ec // @25DB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @25E1 memory[0x20:0x40] = 0x03 // @25E7 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x3f11, returns to 0x25EC label_25EC: // Incoming return from call to 0x3F11 at 0x25EB // Inputs[4] // { // @25ED stack[-1] // @25ED stack[-2] // @25EF stack[-4] // @25F0 stack[-3] // } 25EC 5B JUMPDEST 25ED 90 SWAP1 25EE 50 POP 25EF 91 SWAP2 25F0 90 SWAP1 25F1 50 POP 25F2 56 *JUMP // Stack delta = -3 // Outputs[1] { @25EF stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_25F3: // Incoming call from 0x0A84, returns to 0x0A85 25F3 5B JUMPDEST 25F4 61 PUSH2 0x25fb 25F7 61 PUSH2 0x27fc 25FA 56 *JUMP // Stack delta = +1 // Outputs[1] { @25F4 stack[0] = 0x25fb } // Block ends with call to 0x27fc, returns to 0x25FB label_25FB: // Incoming return from call to 0x27FC at 0x25FA // Inputs[1] { @25FF stack[-1] } 25FB 5B JUMPDEST 25FC 61 PUSH2 0x266d 25FF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x266d, if stack[-1] label_2600: // Incoming jump from 0x25FF, if not stack[-1] // Inputs[3] // { // @2602 memory[0x40:0x60] // @2667 memory[0x40:0x60] // @266C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2600 60 PUSH1 0x40 2602 51 MLOAD 2603 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2624 81 DUP2 2625 52 MSTORE 2626 60 PUSH1 0x04 2628 01 ADD 2629 80 DUP1 262A 80 DUP1 262B 60 PUSH1 0x20 262D 01 ADD 262E 82 DUP3 262F 81 DUP2 2630 03 SUB 2631 82 DUP3 2632 52 MSTORE 2633 60 PUSH1 0x20 2635 81 DUP2 2636 52 MSTORE 2637 60 PUSH1 0x20 2639 01 ADD 263A 80 DUP1 263B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 265C 81 DUP2 265D 52 MSTORE 265E 50 POP 265F 60 PUSH1 0x20 2661 01 ADD 2662 91 SWAP2 2663 50 POP 2664 50 POP 2665 60 PUSH1 0x40 2667 51 MLOAD 2668 80 DUP1 2669 91 SWAP2 266A 03 SUB 266B 90 SWAP1 266C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2625 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2632 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2636 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @265D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @266C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_266D: // Incoming jump from 0x25FF, if stack[-1] // Inputs[6] // { // @268B storage[0x08] // @26E2 memory[0x40:0x60] // @26E5 memory[0x40:0x60] // @26EA memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @26F6 storage[0x08] // @272D stack[-1] // } 266D 5B JUMPDEST 266E 60 PUSH1 0x00 2670 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2685 16 AND 2686 60 PUSH1 0x08 2688 60 PUSH1 0x00 268A 90 SWAP1 268B 54 SLOAD 268C 90 SWAP1 268D 61 PUSH2 0x0100 2690 0A EXP 2691 90 SWAP1 2692 04 DIV 2693 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26A8 16 AND 26A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26BE 16 AND 26BF 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 26E0 60 PUSH1 0x40 26E2 51 MLOAD 26E3 60 PUSH1 0x40 26E5 51 MLOAD 26E6 80 DUP1 26E7 91 SWAP2 26E8 03 SUB 26E9 90 SWAP1 26EA A3 LOG3 26EB 60 PUSH1 0x00 26ED 60 PUSH1 0x08 26EF 60 PUSH1 0x00 26F1 61 PUSH2 0x0100 26F4 0A EXP 26F5 81 DUP2 26F6 54 SLOAD 26F7 81 DUP2 26F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 270D 02 MUL 270E 19 NOT 270F 16 AND 2710 90 SWAP1 2711 83 DUP4 2712 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2727 16 AND 2728 02 MUL 2729 17 OR 272A 90 SWAP1 272B 55 SSTORE 272C 50 POP 272D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @26EA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @272B storage[0x08] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x08]) // } // Block ends with unconditional jump to stack[-1] label_272E: // Incoming call from 0x0A9B, returns to 0x0A9C // Inputs[3] // { // @2732 storage[0x0c] // @2753 memory[0x40:0x60] // @2766 storage[0x0c] // } 272E 5B JUMPDEST 272F 60 PUSH1 0x0c 2731 80 DUP1 2732 54 SLOAD 2733 60 PUSH1 0x01 2735 81 DUP2 2736 60 PUSH1 0x01 2738 16 AND 2739 15 ISZERO 273A 61 PUSH2 0x0100 273D 02 MUL 273E 03 SUB 273F 16 AND 2740 60 PUSH1 0x02 2742 90 SWAP1 2743 04 DIV 2744 80 DUP1 2745 60 PUSH1 0x1f 2747 01 ADD 2748 60 PUSH1 0x20 274A 80 DUP1 274B 91 SWAP2 274C 04 DIV 274D 02 MUL 274E 60 PUSH1 0x20 2750 01 ADD 2751 60 PUSH1 0x40 2753 51 MLOAD 2754 90 SWAP1 2755 81 DUP2 2756 01 ADD 2757 60 PUSH1 0x40 2759 52 MSTORE 275A 80 DUP1 275B 92 SWAP3 275C 91 SWAP2 275D 90 SWAP1 275E 81 DUP2 275F 81 DUP2 2760 52 MSTORE 2761 60 PUSH1 0x20 2763 01 ADD 2764 82 DUP3 2765 80 DUP1 2766 54 SLOAD 2767 60 PUSH1 0x01 2769 81 DUP2 276A 60 PUSH1 0x01 276C 16 AND 276D 15 ISZERO 276E 61 PUSH2 0x0100 2771 02 MUL 2772 03 SUB 2773 16 AND 2774 60 PUSH1 0x02 2776 90 SWAP1 2777 04 DIV 2778 80 DUP1 2779 15 ISZERO 277A 61 PUSH2 0x27c4 277D 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @2759 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02) / 0x20 * 0x20 // @275B stack[0] = memory[0x40:0x60] // @275C stack[1] = 0x0c // @275D stack[2] = (0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02 // @2760 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02 // @2763 stack[3] = 0x20 + memory[0x40:0x60] // @2764 stack[4] = 0x0c // @2777 stack[5] = (0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02 // } // Block ends with conditional jump to 0x27c4, if !((0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02) label_277E: // Incoming jump from 0x277D, if not !((0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02) // Inputs[1] { @277E stack[-1] } 277E 80 DUP1 277F 60 PUSH1 0x1f 2781 10 LT 2782 61 PUSH2 0x2799 2785 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2799, if 0x1f < stack[-1] label_2786: // Incoming jump from 0x2785, if not 0x1f < stack[-1] // Inputs[4] // { // @278A stack[-2] // @278B storage[stack[-2]] // @278E stack[-3] // @2790 stack[-1] // } 2786 61 PUSH2 0x0100 2789 80 DUP1 278A 83 DUP4 278B 54 SLOAD 278C 04 DIV 278D 02 MUL 278E 83 DUP4 278F 52 MSTORE 2790 91 SWAP2 2791 60 PUSH1 0x20 2793 01 ADD 2794 91 SWAP2 2795 61 PUSH2 0x27c4 2798 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @278F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2794 stack[-1] = stack[-1] // @2794 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x27c4 label_2799: // Incoming jump from 0x2785, if 0x1f < stack[-1] // Inputs[5] // { // @279A stack[-3] // @279B stack[-1] // @279D stack[-2] // @27A5 memory[0x00:0x20] // @27A9 storage[keccak256(memory[0x00:0x20])] // } 2799 5B JUMPDEST 279A 82 DUP3 279B 01 ADD 279C 91 SWAP2 279D 90 SWAP1 279E 60 PUSH1 0x00 27A0 52 MSTORE 27A1 60 PUSH1 0x20 27A3 60 PUSH1 0x00 27A5 20 SHA3 27A6 90 SWAP1 27A7 5B JUMPDEST 27A8 81 DUP2 27A9 54 SLOAD 27AA 81 DUP2 27AB 52 MSTORE 27AC 90 SWAP1 27AD 60 PUSH1 0x01 27AF 01 ADD 27B0 90 SWAP1 27B1 60 PUSH1 0x20 27B3 01 ADD 27B4 80 DUP1 27B5 83 DUP4 27B6 11 GT 27B7 61 PUSH2 0x27a7 27BA 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @279C stack[-3] = stack[-3] + stack[-1] // @27A0 memory[0x00:0x20] = stack[-2] // @27AB memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @27B0 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @27B3 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x27a7, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_27BB: // Incoming jump from 0x27BA, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x27BA, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @27BB stack[-3] // @27BC stack[-1] // } 27BB 82 DUP3 27BC 90 SWAP1 27BD 03 SUB 27BE 60 PUSH1 0x1f 27C0 16 AND 27C1 82 DUP3 27C2 01 ADD 27C3 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @27C3 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @27C3 stack[-1] = stack[-3] // } // Block continues label_27C4: // Incoming jump from 0x277D, if !((0x0100 * !(0x01 & storage[0x0c]) - 0x01 & storage[0x0c]) / 0x02) // Incoming jump from 0x27C3 // Incoming jump from 0x2798 // Inputs[1] { @27CA stack[-7] } 27C4 5B JUMPDEST 27C5 50 POP 27C6 50 POP 27C7 50 POP 27C8 50 POP 27C9 50 POP 27CA 81 DUP2 27CB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_27CC: // Incoming call from 0x0B2B, returns to 0x0B2C // Inputs[2] // { // @27CF storage[0x09] // @27D0 stack[-1] // } 27CC 5B JUMPDEST 27CD 60 PUSH1 0x09 27CF 54 SLOAD 27D0 81 DUP2 27D1 56 *JUMP // Stack delta = +1 // Outputs[1] { @27CF stack[0] = storage[0x09] } // Block ends with unconditional jump to stack[-1] label_27D2: // Incoming call from 0x0B56, returns to 0x0B57 // Inputs[2] // { // @27DA storage[0x08] // @27FA stack[-1] // } 27D2 5B JUMPDEST 27D3 60 PUSH1 0x00 27D5 60 PUSH1 0x08 27D7 60 PUSH1 0x00 27D9 90 SWAP1 27DA 54 SLOAD 27DB 90 SWAP1 27DC 61 PUSH2 0x0100 27DF 0A EXP 27E0 90 SWAP1 27E1 04 DIV 27E2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27F7 16 AND 27F8 90 SWAP1 27F9 50 POP 27FA 90 SWAP1 27FB 56 *JUMP // Stack delta = +0 // Outputs[1] { @27FA stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x08] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_27FC: // Incoming call from 0x32CC, returns to 0x32CD // Incoming call from 0x319A, returns to 0x319B // Incoming call from 0x3220, returns to 0x3221 // Incoming call from 0x0BAD, returns to 0x0BAE // Incoming call from 0x25FA, returns to 0x25FB // Incoming call from 0x2DB4, returns to 0x2DB5 // Incoming call from 0x2EEA, returns to 0x2EEB // Inputs[1] { @2804 storage[0x08] } 27FC 5B JUMPDEST 27FD 60 PUSH1 0x00 27FF 60 PUSH1 0x08 2801 60 PUSH1 0x00 2803 90 SWAP1 2804 54 SLOAD 2805 90 SWAP1 2806 61 PUSH2 0x0100 2809 0A EXP 280A 90 SWAP1 280B 04 DIV 280C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2821 16 AND 2822 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2837 16 AND 2838 61 PUSH2 0x283f 283B 61 PUSH2 0x3bba 283E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27FD stack[0] = 0x00 // @2837 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x08] / 0x0100 ** 0x00 // @2838 stack[2] = 0x283f // } // Block ends with call to 0x3bba, returns to 0x283F label_283F: // Incoming return from call to 0x3BBA at 0x283E // Inputs[4] // { // @2855 stack[-1] // @2856 stack[-2] // @2857 stack[-3] // @2859 stack[-4] // } 283F 5B JUMPDEST 2840 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2855 16 AND 2856 14 EQ 2857 90 SWAP1 2858 50 POP 2859 90 SWAP1 285A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2859 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-4] label_285B: // Incoming call from 0x0BDC, returns to 0x0BDD // Inputs[3] // { // @2861 storage[0x06] // @2882 memory[0x40:0x60] // @2895 storage[0x06] // } 285B 5B JUMPDEST 285C 60 PUSH1 0x60 285E 60 PUSH1 0x06 2860 80 DUP1 2861 54 SLOAD 2862 60 PUSH1 0x01 2864 81 DUP2 2865 60 PUSH1 0x01 2867 16 AND 2868 15 ISZERO 2869 61 PUSH2 0x0100 286C 02 MUL 286D 03 SUB 286E 16 AND 286F 60 PUSH1 0x02 2871 90 SWAP1 2872 04 DIV 2873 80 DUP1 2874 60 PUSH1 0x1f 2876 01 ADD 2877 60 PUSH1 0x20 2879 80 DUP1 287A 91 SWAP2 287B 04 DIV 287C 02 MUL 287D 60 PUSH1 0x20 287F 01 ADD 2880 60 PUSH1 0x40 2882 51 MLOAD 2883 90 SWAP1 2884 81 DUP2 2885 01 ADD 2886 60 PUSH1 0x40 2888 52 MSTORE 2889 80 DUP1 288A 92 SWAP3 288B 91 SWAP2 288C 90 SWAP1 288D 81 DUP2 288E 81 DUP2 288F 52 MSTORE 2890 60 PUSH1 0x20 2892 01 ADD 2893 82 DUP3 2894 80 DUP1 2895 54 SLOAD 2896 60 PUSH1 0x01 2898 81 DUP2 2899 60 PUSH1 0x01 289B 16 AND 289C 15 ISZERO 289D 61 PUSH2 0x0100 28A0 02 MUL 28A1 03 SUB 28A2 16 AND 28A3 60 PUSH1 0x02 28A5 90 SWAP1 28A6 04 DIV 28A7 80 DUP1 28A8 15 ISZERO 28A9 61 PUSH2 0x28f3 28AC 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @285C stack[0] = 0x60 // @2888 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) / 0x20 * 0x20 // @288A stack[1] = memory[0x40:0x60] // @288B stack[2] = 0x06 // @288C stack[3] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @288F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @2892 stack[4] = 0x20 + memory[0x40:0x60] // @2893 stack[5] = 0x06 // @28A6 stack[6] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // } // Block ends with conditional jump to 0x28f3, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) label_28AD: // Incoming jump from 0x28AC, if not !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Inputs[1] { @28AD stack[-1] } 28AD 80 DUP1 28AE 60 PUSH1 0x1f 28B0 10 LT 28B1 61 PUSH2 0x28c8 28B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x28c8, if 0x1f < stack[-1] label_28B5: // Incoming jump from 0x28B4, if not 0x1f < stack[-1] // Inputs[4] // { // @28B9 stack[-2] // @28BA storage[stack[-2]] // @28BD stack[-3] // @28BF stack[-1] // } 28B5 61 PUSH2 0x0100 28B8 80 DUP1 28B9 83 DUP4 28BA 54 SLOAD 28BB 04 DIV 28BC 02 MUL 28BD 83 DUP4 28BE 52 MSTORE 28BF 91 SWAP2 28C0 60 PUSH1 0x20 28C2 01 ADD 28C3 91 SWAP2 28C4 61 PUSH2 0x28f3 28C7 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @28BE memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @28C3 stack[-1] = stack[-1] // @28C3 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x28f3 label_28C8: // Incoming jump from 0x28B4, if 0x1f < stack[-1] // Inputs[5] // { // @28C9 stack[-3] // @28CA stack[-1] // @28CC stack[-2] // @28D4 memory[0x00:0x20] // @28D8 storage[keccak256(memory[0x00:0x20])] // } 28C8 5B JUMPDEST 28C9 82 DUP3 28CA 01 ADD 28CB 91 SWAP2 28CC 90 SWAP1 28CD 60 PUSH1 0x00 28CF 52 MSTORE 28D0 60 PUSH1 0x20 28D2 60 PUSH1 0x00 28D4 20 SHA3 28D5 90 SWAP1 28D6 5B JUMPDEST 28D7 81 DUP2 28D8 54 SLOAD 28D9 81 DUP2 28DA 52 MSTORE 28DB 90 SWAP1 28DC 60 PUSH1 0x01 28DE 01 ADD 28DF 90 SWAP1 28E0 60 PUSH1 0x20 28E2 01 ADD 28E3 80 DUP1 28E4 83 DUP4 28E5 11 GT 28E6 61 PUSH2 0x28d6 28E9 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @28CB stack[-3] = stack[-3] + stack[-1] // @28CF memory[0x00:0x20] = stack[-2] // @28DA memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @28DF stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @28E2 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x28d6, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_28EA: // Incoming jump from 0x28E9, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x28E9, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @28EA stack[-3] // @28EB stack[-1] // } 28EA 82 DUP3 28EB 90 SWAP1 28EC 03 SUB 28ED 60 PUSH1 0x1f 28EF 16 AND 28F0 82 DUP3 28F1 01 ADD 28F2 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @28F2 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @28F2 stack[-1] = stack[-3] // } // Block continues label_28F3: // Incoming jump from 0x28C7 // Incoming jump from 0x28AC, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Incoming jump from 0x28F2 // Inputs[3] // { // @28F9 stack[-6] // @28F9 stack[-7] // @28FB stack[-8] // } 28F3 5B JUMPDEST 28F4 50 POP 28F5 50 POP 28F6 50 POP 28F7 50 POP 28F8 50 POP 28F9 90 SWAP1 28FA 50 POP 28FB 90 SWAP1 28FC 56 *JUMP // Stack delta = -7 // Outputs[1] { @28FB stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_28FD: // Incoming jump from 0x0C90 // Inputs[4] // { // @2909 stack[-1] // @2917 memory[0x00:0x40] // @291A memory[0x40:0x60] // @2921 storage[0x0a] // } 28FD 5B JUMPDEST 28FE 60 PUSH1 0x60 2900 80 DUP1 2901 60 PUSH1 0x60 2903 60 PUSH1 0x0a 2905 60 PUSH1 0x0f 2907 60 PUSH1 0x00 2909 86 DUP7 290A 81 DUP2 290B 52 MSTORE 290C 60 PUSH1 0x20 290E 01 ADD 290F 90 SWAP1 2910 81 DUP2 2911 52 MSTORE 2912 60 PUSH1 0x20 2914 01 ADD 2915 60 PUSH1 0x00 2917 20 SHA3 2918 60 PUSH1 0x40 291A 51 MLOAD 291B 60 PUSH1 0x20 291D 01 ADD 291E 80 DUP1 291F 83 DUP4 2920 80 DUP1 2921 54 SLOAD 2922 60 PUSH1 0x01 2924 81 DUP2 2925 60 PUSH1 0x01 2927 16 AND 2928 15 ISZERO 2929 61 PUSH2 0x0100 292C 02 MUL 292D 03 SUB 292E 16 AND 292F 60 PUSH1 0x02 2931 90 SWAP1 2932 04 DIV 2933 80 DUP1 2934 15 ISZERO 2935 61 PUSH2 0x2975 2938 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @28FE stack[0] = 0x60 // @2900 stack[1] = 0x60 // @2901 stack[2] = 0x60 // @2903 stack[3] = 0x0a // @290B memory[0x00:0x20] = stack[-1] // @2911 memory[0x20:0x40] = 0x0f // @2917 stack[4] = keccak256(memory[0x00:0x40]) // @291D stack[5] = 0x20 + memory[0x40:0x60] // @291E stack[6] = 0x20 + memory[0x40:0x60] // @291F stack[7] = 0x0a // @2932 stack[8] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // } // Block ends with conditional jump to 0x2975, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) label_2939: // Incoming jump from 0x2938, if not !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Inputs[1] { @2939 stack[-1] } 2939 80 DUP1 293A 60 PUSH1 0x1f 293C 10 LT 293D 61 PUSH2 0x2953 2940 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2953, if 0x1f < stack[-1] label_2941: // Incoming jump from 0x2940, if not 0x1f < stack[-1] // Inputs[4] // { // @2945 stack[-2] // @2946 storage[stack[-2]] // @2949 stack[-3] // @294B stack[-1] // } 2941 61 PUSH2 0x0100 2944 80 DUP1 2945 83 DUP4 2946 54 SLOAD 2947 04 DIV 2948 02 MUL 2949 83 DUP4 294A 52 MSTORE 294B 91 SWAP2 294C 82 DUP3 294D 01 ADD 294E 91 SWAP2 294F 61 PUSH2 0x2975 2952 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @294A memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @294E stack[-1] = stack[-1] // @294E stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2975 label_2953: // Incoming jump from 0x2940, if 0x1f < stack[-1] // Inputs[5] // { // @2954 stack[-3] // @2955 stack[-1] // @2957 stack[-2] // @295F memory[0x00:0x20] // @2963 storage[keccak256(memory[0x00:0x20])] // } 2953 5B JUMPDEST 2954 82 DUP3 2955 01 ADD 2956 91 SWAP2 2957 90 SWAP1 2958 60 PUSH1 0x00 295A 52 MSTORE 295B 60 PUSH1 0x20 295D 60 PUSH1 0x00 295F 20 SHA3 2960 90 SWAP1 2961 5B JUMPDEST 2962 81 DUP2 2963 54 SLOAD 2964 81 DUP2 2965 52 MSTORE 2966 90 SWAP1 2967 60 PUSH1 0x01 2969 01 ADD 296A 90 SWAP1 296B 60 PUSH1 0x20 296D 01 ADD 296E 80 DUP1 296F 83 DUP4 2970 11 GT 2971 61 PUSH2 0x2961 2974 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2956 stack[-3] = stack[-3] + stack[-1] // @295A memory[0x00:0x20] = stack[-2] // @2965 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @296A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @296D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2961, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2975: // Incoming jump from 0x2974, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2974, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2938, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Incoming jump from 0x2952 // Inputs[2] // { // @2978 stack[-5] // @297A storage[stack[-5]] // } 2975 5B JUMPDEST 2976 50 POP 2977 50 POP 2978 82 DUP3 2979 80 DUP1 297A 54 SLOAD 297B 60 PUSH1 0x01 297D 81 DUP2 297E 60 PUSH1 0x01 2980 16 AND 2981 15 ISZERO 2982 61 PUSH2 0x0100 2985 02 MUL 2986 03 SUB 2987 16 AND 2988 60 PUSH1 0x02 298A 90 SWAP1 298B 04 DIV 298C 80 DUP1 298D 15 ISZERO 298E 61 PUSH2 0x29ce 2991 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2978 stack[-2] = stack[-5] // @298B stack[-1] = (0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02 // } // Block ends with conditional jump to 0x29ce, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) label_2992: // Incoming jump from 0x2991, if not !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Inputs[1] { @2992 stack[-1] } 2992 80 DUP1 2993 60 PUSH1 0x1f 2995 10 LT 2996 61 PUSH2 0x29ac 2999 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x29ac, if 0x1f < stack[-1] label_299A: // Incoming jump from 0x2999, if not 0x1f < stack[-1] // Inputs[4] // { // @299E stack[-2] // @299F storage[stack[-2]] // @29A2 stack[-3] // @29A4 stack[-1] // } 299A 61 PUSH2 0x0100 299D 80 DUP1 299E 83 DUP4 299F 54 SLOAD 29A0 04 DIV 29A1 02 MUL 29A2 83 DUP4 29A3 52 MSTORE 29A4 91 SWAP2 29A5 82 DUP3 29A6 01 ADD 29A7 91 SWAP2 29A8 61 PUSH2 0x29ce 29AB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @29A3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @29A7 stack[-1] = stack[-1] // @29A7 stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x29ce label_29AC: // Incoming jump from 0x2999, if 0x1f < stack[-1] // Inputs[5] // { // @29AD stack[-3] // @29AE stack[-1] // @29B0 stack[-2] // @29B8 memory[0x00:0x20] // @29BC storage[keccak256(memory[0x00:0x20])] // } 29AC 5B JUMPDEST 29AD 82 DUP3 29AE 01 ADD 29AF 91 SWAP2 29B0 90 SWAP1 29B1 60 PUSH1 0x00 29B3 52 MSTORE 29B4 60 PUSH1 0x20 29B6 60 PUSH1 0x00 29B8 20 SHA3 29B9 90 SWAP1 29BA 5B JUMPDEST 29BB 81 DUP2 29BC 54 SLOAD 29BD 81 DUP2 29BE 52 MSTORE 29BF 90 SWAP1 29C0 60 PUSH1 0x01 29C2 01 ADD 29C3 90 SWAP1 29C4 60 PUSH1 0x20 29C6 01 ADD 29C7 80 DUP1 29C8 83 DUP4 29C9 11 GT 29CA 61 PUSH2 0x29ba 29CD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @29AF stack[-3] = stack[-3] + stack[-1] // @29B3 memory[0x00:0x20] = stack[-2] // @29BE memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @29C3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @29C6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x29ba, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_29CE: // Incoming jump from 0x29AB // Incoming jump from 0x29CD, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2991, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Incoming jump from 0x29CD, if not stack[-3] > 0x20 + stack[-1] // Inputs[8] // { // @29D1 stack[-6] // @29D1 stack[-3] // @29D7 memory[0x40:0x60] // @29E4 stack[-9] // @29EC stack[-10] // @29FA memory[0x00:0x40] // @29FD memory[0x40:0x60] // @2A04 storage[0x0b] // } 29CE 5B JUMPDEST 29CF 50 POP 29D0 50 POP 29D1 92 SWAP3 29D2 50 POP 29D3 50 POP 29D4 50 POP 29D5 60 PUSH1 0x40 29D7 51 MLOAD 29D8 60 PUSH1 0x20 29DA 81 DUP2 29DB 83 DUP4 29DC 03 SUB 29DD 03 SUB 29DE 81 DUP2 29DF 52 MSTORE 29E0 90 SWAP1 29E1 60 PUSH1 0x40 29E3 52 MSTORE 29E4 92 SWAP3 29E5 50 POP 29E6 60 PUSH1 0x0b 29E8 60 PUSH1 0x10 29EA 60 PUSH1 0x00 29EC 86 DUP7 29ED 81 DUP2 29EE 52 MSTORE 29EF 60 PUSH1 0x20 29F1 01 ADD 29F2 90 SWAP1 29F3 81 DUP2 29F4 52 MSTORE 29F5 60 PUSH1 0x20 29F7 01 ADD 29F8 60 PUSH1 0x00 29FA 20 SHA3 29FB 60 PUSH1 0x40 29FD 51 MLOAD 29FE 60 PUSH1 0x20 2A00 01 ADD 2A01 80 DUP1 2A02 83 DUP4 2A03 80 DUP1 2A04 54 SLOAD 2A05 60 PUSH1 0x01 2A07 81 DUP2 2A08 60 PUSH1 0x01 2A0A 16 AND 2A0B 15 ISZERO 2A0C 61 PUSH2 0x0100 2A0F 02 MUL 2A10 03 SUB 2A11 16 AND 2A12 60 PUSH1 0x02 2A14 90 SWAP1 2A15 04 DIV 2A16 80 DUP1 2A17 15 ISZERO 2A18 61 PUSH2 0x2a58 2A1B 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @29DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] - memory[0x40:0x60] - 0x20 // @29E3 memory[0x40:0x60] = stack[-3] // @29E4 stack[-9] = memory[0x40:0x60] // @29E6 stack[-6] = 0x0b // @29EE memory[0x00:0x20] = stack[-10] // @29F4 memory[0x20:0x40] = 0x10 // @29FA stack[-5] = keccak256(memory[0x00:0x40]) // @2A00 stack[-4] = 0x20 + memory[0x40:0x60] // @2A01 stack[-3] = 0x20 + memory[0x40:0x60] // @2A02 stack[-2] = 0x0b // @2A15 stack[-1] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // } // Block ends with conditional jump to 0x2a58, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) label_2A1C: // Incoming jump from 0x2A1B, if not !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[1] { @2A1C stack[-1] } 2A1C 80 DUP1 2A1D 60 PUSH1 0x1f 2A1F 10 LT 2A20 61 PUSH2 0x2a36 2A23 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a36, if 0x1f < stack[-1] label_2A24: // Incoming jump from 0x2A23, if not 0x1f < stack[-1] // Inputs[4] // { // @2A28 stack[-2] // @2A29 storage[stack[-2]] // @2A2C stack[-3] // @2A2E stack[-1] // } 2A24 61 PUSH2 0x0100 2A27 80 DUP1 2A28 83 DUP4 2A29 54 SLOAD 2A2A 04 DIV 2A2B 02 MUL 2A2C 83 DUP4 2A2D 52 MSTORE 2A2E 91 SWAP2 2A2F 82 DUP3 2A30 01 ADD 2A31 91 SWAP2 2A32 61 PUSH2 0x2a58 2A35 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2A2D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2A31 stack[-1] = stack[-1] // @2A31 stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2a58 label_2A36: // Incoming jump from 0x2A23, if 0x1f < stack[-1] // Inputs[5] // { // @2A37 stack[-3] // @2A38 stack[-1] // @2A3A stack[-2] // @2A42 memory[0x00:0x20] // @2A46 storage[keccak256(memory[0x00:0x20])] // } 2A36 5B JUMPDEST 2A37 82 DUP3 2A38 01 ADD 2A39 91 SWAP2 2A3A 90 SWAP1 2A3B 60 PUSH1 0x00 2A3D 52 MSTORE 2A3E 60 PUSH1 0x20 2A40 60 PUSH1 0x00 2A42 20 SHA3 2A43 90 SWAP1 2A44 5B JUMPDEST 2A45 81 DUP2 2A46 54 SLOAD 2A47 81 DUP2 2A48 52 MSTORE 2A49 90 SWAP1 2A4A 60 PUSH1 0x01 2A4C 01 ADD 2A4D 90 SWAP1 2A4E 60 PUSH1 0x20 2A50 01 ADD 2A51 80 DUP1 2A52 83 DUP4 2A53 11 GT 2A54 61 PUSH2 0x2a44 2A57 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2A39 stack[-3] = stack[-3] + stack[-1] // @2A3D memory[0x00:0x20] = stack[-2] // @2A48 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2A4D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2A50 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2a44, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2A58: // Incoming jump from 0x2A57, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2A35 // Incoming jump from 0x2A57, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2A1B, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[2] // { // @2A5B stack[-5] // @2A5D storage[stack[-5]] // } 2A58 5B JUMPDEST 2A59 50 POP 2A5A 50 POP 2A5B 82 DUP3 2A5C 80 DUP1 2A5D 54 SLOAD 2A5E 60 PUSH1 0x01 2A60 81 DUP2 2A61 60 PUSH1 0x01 2A63 16 AND 2A64 15 ISZERO 2A65 61 PUSH2 0x0100 2A68 02 MUL 2A69 03 SUB 2A6A 16 AND 2A6B 60 PUSH1 0x02 2A6D 90 SWAP1 2A6E 04 DIV 2A6F 80 DUP1 2A70 15 ISZERO 2A71 61 PUSH2 0x2ab1 2A74 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2A5B stack[-2] = stack[-5] // @2A6E stack[-1] = (0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02 // } // Block ends with conditional jump to 0x2ab1, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) label_2A75: // Incoming jump from 0x2A74, if not !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Inputs[1] { @2A75 stack[-1] } 2A75 80 DUP1 2A76 60 PUSH1 0x1f 2A78 10 LT 2A79 61 PUSH2 0x2a8f 2A7C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a8f, if 0x1f < stack[-1] label_2A7D: // Incoming jump from 0x2A7C, if not 0x1f < stack[-1] // Inputs[4] // { // @2A81 stack[-2] // @2A82 storage[stack[-2]] // @2A85 stack[-3] // @2A87 stack[-1] // } 2A7D 61 PUSH2 0x0100 2A80 80 DUP1 2A81 83 DUP4 2A82 54 SLOAD 2A83 04 DIV 2A84 02 MUL 2A85 83 DUP4 2A86 52 MSTORE 2A87 91 SWAP2 2A88 82 DUP3 2A89 01 ADD 2A8A 91 SWAP2 2A8B 61 PUSH2 0x2ab1 2A8E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2A86 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2A8A stack[-1] = stack[-1] // @2A8A stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2ab1 label_2A8F: // Incoming jump from 0x2A7C, if 0x1f < stack[-1] // Inputs[5] // { // @2A90 stack[-3] // @2A91 stack[-1] // @2A93 stack[-2] // @2A9B memory[0x00:0x20] // @2A9F storage[keccak256(memory[0x00:0x20])] // } 2A8F 5B JUMPDEST 2A90 82 DUP3 2A91 01 ADD 2A92 91 SWAP2 2A93 90 SWAP1 2A94 60 PUSH1 0x00 2A96 52 MSTORE 2A97 60 PUSH1 0x20 2A99 60 PUSH1 0x00 2A9B 20 SHA3 2A9C 90 SWAP1 2A9D 5B JUMPDEST 2A9E 81 DUP2 2A9F 54 SLOAD 2AA0 81 DUP2 2AA1 52 MSTORE 2AA2 90 SWAP1 2AA3 60 PUSH1 0x01 2AA5 01 ADD 2AA6 90 SWAP1 2AA7 60 PUSH1 0x20 2AA9 01 ADD 2AAA 80 DUP1 2AAB 83 DUP4 2AAC 11 GT 2AAD 61 PUSH2 0x2a9d 2AB0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2A92 stack[-3] = stack[-3] + stack[-1] // @2A96 memory[0x00:0x20] = stack[-2] // @2AA1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2AA6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2AA9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2a9d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2AB1: // Incoming jump from 0x2AB0, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2A74, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Incoming jump from 0x2AB0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2A8E // Inputs[8] // { // @2AB4 stack[-3] // @2AB4 stack[-6] // @2ABA memory[0x40:0x60] // @2AC7 stack[-8] // @2ACF stack[-10] // @2ADD memory[0x00:0x40] // @2AE0 memory[0x40:0x60] // @2AE7 storage[0x0b] // } 2AB1 5B JUMPDEST 2AB2 50 POP 2AB3 50 POP 2AB4 92 SWAP3 2AB5 50 POP 2AB6 50 POP 2AB7 50 POP 2AB8 60 PUSH1 0x40 2ABA 51 MLOAD 2ABB 60 PUSH1 0x20 2ABD 81 DUP2 2ABE 83 DUP4 2ABF 03 SUB 2AC0 03 SUB 2AC1 81 DUP2 2AC2 52 MSTORE 2AC3 90 SWAP1 2AC4 60 PUSH1 0x40 2AC6 52 MSTORE 2AC7 91 SWAP2 2AC8 50 POP 2AC9 60 PUSH1 0x0b 2ACB 60 PUSH1 0x11 2ACD 60 PUSH1 0x00 2ACF 86 DUP7 2AD0 81 DUP2 2AD1 52 MSTORE 2AD2 60 PUSH1 0x20 2AD4 01 ADD 2AD5 90 SWAP1 2AD6 81 DUP2 2AD7 52 MSTORE 2AD8 60 PUSH1 0x20 2ADA 01 ADD 2ADB 60 PUSH1 0x00 2ADD 20 SHA3 2ADE 60 PUSH1 0x40 2AE0 51 MLOAD 2AE1 60 PUSH1 0x20 2AE3 01 ADD 2AE4 80 DUP1 2AE5 83 DUP4 2AE6 80 DUP1 2AE7 54 SLOAD 2AE8 60 PUSH1 0x01 2AEA 81 DUP2 2AEB 60 PUSH1 0x01 2AED 16 AND 2AEE 15 ISZERO 2AEF 61 PUSH2 0x0100 2AF2 02 MUL 2AF3 03 SUB 2AF4 16 AND 2AF5 60 PUSH1 0x02 2AF7 90 SWAP1 2AF8 04 DIV 2AF9 80 DUP1 2AFA 15 ISZERO 2AFB 61 PUSH2 0x2b3b 2AFE 57 *JUMPI // Stack delta = +0 // Outputs[11] // { // @2AC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] - memory[0x40:0x60] - 0x20 // @2AC6 memory[0x40:0x60] = stack[-3] // @2AC7 stack[-8] = memory[0x40:0x60] // @2AC9 stack[-6] = 0x0b // @2AD1 memory[0x00:0x20] = stack[-10] // @2AD7 memory[0x20:0x40] = 0x11 // @2ADD stack[-5] = keccak256(memory[0x00:0x40]) // @2AE3 stack[-4] = 0x20 + memory[0x40:0x60] // @2AE4 stack[-3] = 0x20 + memory[0x40:0x60] // @2AE5 stack[-2] = 0x0b // @2AF8 stack[-1] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // } // Block ends with conditional jump to 0x2b3b, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) label_2AFF: // Incoming jump from 0x2AFE, if not !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[1] { @2AFF stack[-1] } 2AFF 80 DUP1 2B00 60 PUSH1 0x1f 2B02 10 LT 2B03 61 PUSH2 0x2b19 2B06 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2b19, if 0x1f < stack[-1] label_2B07: // Incoming jump from 0x2B06, if not 0x1f < stack[-1] // Inputs[4] // { // @2B0B stack[-2] // @2B0C storage[stack[-2]] // @2B0F stack[-3] // @2B11 stack[-1] // } 2B07 61 PUSH2 0x0100 2B0A 80 DUP1 2B0B 83 DUP4 2B0C 54 SLOAD 2B0D 04 DIV 2B0E 02 MUL 2B0F 83 DUP4 2B10 52 MSTORE 2B11 91 SWAP2 2B12 82 DUP3 2B13 01 ADD 2B14 91 SWAP2 2B15 61 PUSH2 0x2b3b 2B18 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2B10 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2B14 stack[-1] = stack[-1] // @2B14 stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2b3b label_2B19: // Incoming jump from 0x2B06, if 0x1f < stack[-1] // Inputs[5] // { // @2B1A stack[-3] // @2B1B stack[-1] // @2B1D stack[-2] // @2B25 memory[0x00:0x20] // @2B29 storage[keccak256(memory[0x00:0x20])] // } 2B19 5B JUMPDEST 2B1A 82 DUP3 2B1B 01 ADD 2B1C 91 SWAP2 2B1D 90 SWAP1 2B1E 60 PUSH1 0x00 2B20 52 MSTORE 2B21 60 PUSH1 0x20 2B23 60 PUSH1 0x00 2B25 20 SHA3 2B26 90 SWAP1 2B27 5B JUMPDEST 2B28 81 DUP2 2B29 54 SLOAD 2B2A 81 DUP2 2B2B 52 MSTORE 2B2C 90 SWAP1 2B2D 60 PUSH1 0x01 2B2F 01 ADD 2B30 90 SWAP1 2B31 60 PUSH1 0x20 2B33 01 ADD 2B34 80 DUP1 2B35 83 DUP4 2B36 11 GT 2B37 61 PUSH2 0x2b27 2B3A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2B1C stack[-3] = stack[-3] + stack[-1] // @2B20 memory[0x00:0x20] = stack[-2] // @2B2B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2B30 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2B33 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2b27, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2B3B: // Incoming jump from 0x2B3A, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2B3A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2B18 // Incoming jump from 0x2AFE, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[2] // { // @2B3E stack[-5] // @2B40 storage[stack[-5]] // } 2B3B 5B JUMPDEST 2B3C 50 POP 2B3D 50 POP 2B3E 82 DUP3 2B3F 80 DUP1 2B40 54 SLOAD 2B41 60 PUSH1 0x01 2B43 81 DUP2 2B44 60 PUSH1 0x01 2B46 16 AND 2B47 15 ISZERO 2B48 61 PUSH2 0x0100 2B4B 02 MUL 2B4C 03 SUB 2B4D 16 AND 2B4E 60 PUSH1 0x02 2B50 90 SWAP1 2B51 04 DIV 2B52 80 DUP1 2B53 15 ISZERO 2B54 61 PUSH2 0x2b94 2B57 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2B3E stack[-2] = stack[-5] // @2B51 stack[-1] = (0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02 // } // Block ends with conditional jump to 0x2b94, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) label_2B58: // Incoming jump from 0x2B57, if not !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Inputs[1] { @2B58 stack[-1] } 2B58 80 DUP1 2B59 60 PUSH1 0x1f 2B5B 10 LT 2B5C 61 PUSH2 0x2b72 2B5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2b72, if 0x1f < stack[-1] label_2B60: // Incoming jump from 0x2B5F, if not 0x1f < stack[-1] // Inputs[4] // { // @2B64 stack[-2] // @2B65 storage[stack[-2]] // @2B68 stack[-3] // @2B6A stack[-1] // } 2B60 61 PUSH2 0x0100 2B63 80 DUP1 2B64 83 DUP4 2B65 54 SLOAD 2B66 04 DIV 2B67 02 MUL 2B68 83 DUP4 2B69 52 MSTORE 2B6A 91 SWAP2 2B6B 82 DUP3 2B6C 01 ADD 2B6D 91 SWAP2 2B6E 61 PUSH2 0x2b94 2B71 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2B69 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2B6D stack[-1] = stack[-1] // @2B6D stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2b94 label_2B72: // Incoming jump from 0x2B5F, if 0x1f < stack[-1] // Inputs[5] // { // @2B73 stack[-3] // @2B74 stack[-1] // @2B76 stack[-2] // @2B7E memory[0x00:0x20] // @2B82 storage[keccak256(memory[0x00:0x20])] // } 2B72 5B JUMPDEST 2B73 82 DUP3 2B74 01 ADD 2B75 91 SWAP2 2B76 90 SWAP1 2B77 60 PUSH1 0x00 2B79 52 MSTORE 2B7A 60 PUSH1 0x20 2B7C 60 PUSH1 0x00 2B7E 20 SHA3 2B7F 90 SWAP1 2B80 5B JUMPDEST 2B81 81 DUP2 2B82 54 SLOAD 2B83 81 DUP2 2B84 52 MSTORE 2B85 90 SWAP1 2B86 60 PUSH1 0x01 2B88 01 ADD 2B89 90 SWAP1 2B8A 60 PUSH1 0x20 2B8C 01 ADD 2B8D 80 DUP1 2B8E 83 DUP4 2B8F 11 GT 2B90 61 PUSH2 0x2b80 2B93 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2B75 stack[-3] = stack[-3] + stack[-1] // @2B79 memory[0x00:0x20] = stack[-2] // @2B84 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2B89 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2B8C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2b80, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2B94: // Incoming jump from 0x2B71 // Incoming jump from 0x2B93, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2B57, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Incoming jump from 0x2B93, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[8] // { // @2B97 stack[-6] // @2B97 stack[-3] // @2B9D memory[0x40:0x60] // @2BAA stack[-7] // @2BAC stack[-9] // @2BAD stack[-11] // @2BAE stack[-8] // @2BAF stack[-10] // } 2B94 5B JUMPDEST 2B95 50 POP 2B96 50 POP 2B97 92 SWAP3 2B98 50 POP 2B99 50 POP 2B9A 50 POP 2B9B 60 PUSH1 0x40 2B9D 51 MLOAD 2B9E 60 PUSH1 0x20 2BA0 81 DUP2 2BA1 83 DUP4 2BA2 03 SUB 2BA3 03 SUB 2BA4 81 DUP2 2BA5 52 MSTORE 2BA6 90 SWAP1 2BA7 60 PUSH1 0x40 2BA9 52 MSTORE 2BAA 90 SWAP1 2BAB 50 POP 2BAC 91 SWAP2 2BAD 93 SWAP4 2BAE 90 SWAP1 2BAF 92 SWAP3 2BB0 50 POP 2BB1 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @2BA5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] - memory[0x40:0x60] - 0x20 // @2BA9 memory[0x40:0x60] = stack[-3] // @2BAC stack[-9] = memory[0x40:0x60] // @2BAD stack[-11] = stack[-9] // @2BAF stack[-10] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_2BB2: // Incoming jump from 0x0E3E 2BB2 5B JUMPDEST 2BB3 61 PUSH2 0x2bba 2BB6 61 PUSH2 0x3bba 2BB9 56 *JUMP // Stack delta = +1 // Outputs[1] { @2BB3 stack[0] = 0x2bba } // Block ends with call to 0x3bba, returns to 0x2BBA label_2BBA: // Incoming return from call to 0x3BBA at 0x2BB9 // Inputs[2] // { // @2BD0 stack[-1] // @2BD1 stack[-3] // } 2BBA 5B JUMPDEST 2BBB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BD0 16 AND 2BD1 82 DUP3 2BD2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BE7 16 AND 2BE8 14 EQ 2BE9 15 ISZERO 2BEA 61 PUSH2 0x2c5b 2BED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2c5b, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_2BEE: // Incoming jump from 0x2BED, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @2BF0 memory[0x40:0x60] // @2C55 memory[0x40:0x60] // @2C5A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2BEE 60 PUSH1 0x40 2BF0 51 MLOAD 2BF1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2C12 81 DUP2 2C13 52 MSTORE 2C14 60 PUSH1 0x04 2C16 01 ADD 2C17 80 DUP1 2C18 80 DUP1 2C19 60 PUSH1 0x20 2C1B 01 ADD 2C1C 82 DUP3 2C1D 81 DUP2 2C1E 03 SUB 2C1F 82 DUP3 2C20 52 MSTORE 2C21 60 PUSH1 0x19 2C23 81 DUP2 2C24 52 MSTORE 2C25 60 PUSH1 0x20 2C27 01 ADD 2C28 80 DUP1 2C29 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 2C4A 81 DUP2 2C4B 52 MSTORE 2C4C 50 POP 2C4D 60 PUSH1 0x20 2C4F 01 ADD 2C50 91 SWAP2 2C51 50 POP 2C52 50 POP 2C53 60 PUSH1 0x40 2C55 51 MLOAD 2C56 80 DUP1 2C57 91 SWAP2 2C58 03 SUB 2C59 90 SWAP1 2C5A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2C13 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2C20 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2C24 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x19 // @2C4B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @2C5A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2C5B: // Incoming jump from 0x2BED, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @2C5C stack[-1] } 2C5B 5B JUMPDEST 2C5C 80 DUP1 2C5D 60 PUSH1 0x04 2C5F 60 PUSH1 0x00 2C61 61 PUSH2 0x2c68 2C64 61 PUSH2 0x3bba 2C67 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2C5C stack[0] = stack[-1] // @2C5D stack[1] = 0x04 // @2C5F stack[2] = 0x00 // @2C61 stack[3] = 0x2c68 // } // Block ends with call to 0x3bba, returns to 0x2C68 label_2C68: // Incoming return from call to 0x3BBA at 0x2C67 // Inputs[8] // { // @2C7E stack[-1] // @2C95 stack[-2] // @2C9A stack[-3] // @2CA2 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @2CA5 stack[-6] // @2CDF memory[0x00:0x40] // @2CE7 storage[keccak256(memory[0x00:0x40])] // @2CEF stack[-4] // } 2C68 5B JUMPDEST 2C69 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C7E 16 AND 2C7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C94 16 AND 2C95 81 DUP2 2C96 52 MSTORE 2C97 60 PUSH1 0x20 2C99 01 ADD 2C9A 90 SWAP1 2C9B 81 DUP2 2C9C 52 MSTORE 2C9D 60 PUSH1 0x20 2C9F 01 ADD 2CA0 60 PUSH1 0x00 2CA2 20 SHA3 2CA3 60 PUSH1 0x00 2CA5 84 DUP5 2CA6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CBB 16 AND 2CBC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CD1 16 AND 2CD2 81 DUP2 2CD3 52 MSTORE 2CD4 60 PUSH1 0x20 2CD6 01 ADD 2CD7 90 SWAP1 2CD8 81 DUP2 2CD9 52 MSTORE 2CDA 60 PUSH1 0x20 2CDC 01 ADD 2CDD 60 PUSH1 0x00 2CDF 20 SHA3 2CE0 60 PUSH1 0x00 2CE2 61 PUSH2 0x0100 2CE5 0A EXP 2CE6 81 DUP2 2CE7 54 SLOAD 2CE8 81 DUP2 2CE9 60 PUSH1 0xff 2CEB 02 MUL 2CEC 19 NOT 2CED 16 AND 2CEE 90 SWAP1 2CEF 83 DUP4 2CF0 15 ISZERO 2CF1 15 ISZERO 2CF2 02 MUL 2CF3 17 OR 2CF4 90 SWAP1 2CF5 55 SSTORE 2CF6 50 POP 2CF7 81 DUP2 2CF8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D0D 16 AND 2D0E 61 PUSH2 0x2d15 2D11 61 PUSH2 0x3bba 2D14 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @2C96 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2C9C memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @2CD3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2CD9 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @2CF5 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2D0D stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2D0E stack[-3] = 0x2d15 // } // Block ends with call to 0x3bba, returns to 0x2D15 label_2D15: // Incoming return from call to 0x3BBA at 0x2D14 // Inputs[7] // { // @2D2B stack[-1] // @2D4D stack[-3] // @2D50 memory[0x40:0x60] // @2D61 memory[0x40:0x60] // @2D66 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2D66 stack[-2] // @2D69 stack[-5] // } 2D15 5B JUMPDEST 2D16 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D2B 16 AND 2D2C 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 2D4D 83 DUP4 2D4E 60 PUSH1 0x40 2D50 51 MLOAD 2D51 80 DUP1 2D52 82 DUP3 2D53 15 ISZERO 2D54 15 ISZERO 2D55 15 ISZERO 2D56 15 ISZERO 2D57 81 DUP2 2D58 52 MSTORE 2D59 60 PUSH1 0x20 2D5B 01 ADD 2D5C 91 SWAP2 2D5D 50 POP 2D5E 50 POP 2D5F 60 PUSH1 0x40 2D61 51 MLOAD 2D62 80 DUP1 2D63 91 SWAP2 2D64 03 SUB 2D65 90 SWAP1 2D66 A3 LOG3 2D67 50 POP 2D68 50 POP 2D69 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2D58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-3] // @2D66 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-5] label_2D6A: // Incoming jump from 0x0E79 // Inputs[5] // { // @2D73 storage[0x0d] // @2D97 stack[-1] // @2DA5 memory[0x00:0x40] // @2DA6 storage[keccak256(memory[0x00:0x40])] // @2DAB stack[-2] // } 2D6A 5B JUMPDEST 2D6B 60 PUSH1 0x00 2D6D 80 DUP1 2D6E 60 PUSH1 0x0d 2D70 60 PUSH1 0x00 2D72 90 SWAP1 2D73 54 SLOAD 2D74 90 SWAP1 2D75 61 PUSH2 0x0100 2D78 0A EXP 2D79 90 SWAP1 2D7A 04 DIV 2D7B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D90 16 AND 2D91 91 SWAP2 2D92 50 POP 2D93 60 PUSH1 0x15 2D95 60 PUSH1 0x00 2D97 84 DUP5 2D98 81 DUP2 2D99 52 MSTORE 2D9A 60 PUSH1 0x20 2D9C 01 ADD 2D9D 90 SWAP1 2D9E 81 DUP2 2D9F 52 MSTORE 2DA0 60 PUSH1 0x20 2DA2 01 ADD 2DA3 60 PUSH1 0x00 2DA5 20 SHA3 2DA6 54 SLOAD 2DA7 90 SWAP1 2DA8 50 POP 2DA9 91 SWAP2 2DAA 50 POP 2DAB 91 SWAP2 2DAC 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2D99 memory[0x00:0x20] = stack[-1] // @2D9F memory[0x20:0x40] = 0x15 // @2DA9 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2DAB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_2DAD: // Incoming jump from 0x0F11 2DAD 5B JUMPDEST 2DAE 61 PUSH2 0x2db5 2DB1 61 PUSH2 0x27fc 2DB4 56 *JUMP // Stack delta = +1 // Outputs[1] { @2DAE stack[0] = 0x2db5 } // Block ends with call to 0x27fc, returns to 0x2DB5 label_2DB5: // Incoming return from call to 0x27FC at 0x2DB4 // Inputs[1] { @2DB9 stack[-1] } 2DB5 5B JUMPDEST 2DB6 61 PUSH2 0x2e27 2DB9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2e27, if stack[-1] label_2DBA: // Incoming jump from 0x2DB9, if not stack[-1] // Inputs[3] // { // @2DBC memory[0x40:0x60] // @2E21 memory[0x40:0x60] // @2E26 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2DBA 60 PUSH1 0x40 2DBC 51 MLOAD 2DBD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2DDE 81 DUP2 2DDF 52 MSTORE 2DE0 60 PUSH1 0x04 2DE2 01 ADD 2DE3 80 DUP1 2DE4 80 DUP1 2DE5 60 PUSH1 0x20 2DE7 01 ADD 2DE8 82 DUP3 2DE9 81 DUP2 2DEA 03 SUB 2DEB 82 DUP3 2DEC 52 MSTORE 2DED 60 PUSH1 0x20 2DEF 81 DUP2 2DF0 52 MSTORE 2DF1 60 PUSH1 0x20 2DF3 01 ADD 2DF4 80 DUP1 2DF5 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2E16 81 DUP2 2E17 52 MSTORE 2E18 50 POP 2E19 60 PUSH1 0x20 2E1B 01 ADD 2E1C 91 SWAP2 2E1D 50 POP 2E1E 50 POP 2E1F 60 PUSH1 0x40 2E21 51 MLOAD 2E22 80 DUP1 2E23 91 SWAP2 2E24 03 SUB 2E25 90 SWAP1 2E26 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DDF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2DEC memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2DF0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @2E17 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2E26 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2E27: // Incoming jump from 0x2DB9, if stack[-1] // Inputs[3] // { // @2E28 stack[-1] // @2E32 storage[0x0d] // @2E6A stack[-2] // } 2E27 5B JUMPDEST 2E28 80 DUP1 2E29 60 PUSH1 0x0d 2E2B 60 PUSH1 0x00 2E2D 61 PUSH2 0x0100 2E30 0A EXP 2E31 81 DUP2 2E32 54 SLOAD 2E33 81 DUP2 2E34 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E49 02 MUL 2E4A 19 NOT 2E4B 16 AND 2E4C 90 SWAP1 2E4D 83 DUP4 2E4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E63 16 AND 2E64 02 MUL 2E65 17 OR 2E66 90 SWAP1 2E67 55 SSTORE 2E68 50 POP 2E69 50 POP 2E6A 56 *JUMP // Stack delta = -2 // Outputs[1] { @2E67 storage[0x0d] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0d]) } // Block ends with unconditional jump to stack[-2] label_2E6B: // Incoming call from 0x223A, returns to 0x223B // Incoming jump from 0x1023 2E6B 5B JUMPDEST 2E6C 61 PUSH2 0x2e7c 2E6F 61 PUSH2 0x2e76 2E72 61 PUSH2 0x3bba 2E75 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2E6C stack[0] = 0x2e7c // @2E6F stack[1] = 0x2e76 // } // Block ends with call to 0x3bba, returns to 0x2E76 label_2E76: // Incoming return from call to 0x3BBA at 0x2E75 // Inputs[1] { @2E77 stack[-4] } 2E76 5B JUMPDEST 2E77 83 DUP4 2E78 61 PUSH2 0x3bc2 2E7B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2E77 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x3bc2 label_2E7C: // Incoming return from call to 0x2E76 at 0x2E75 // Inputs[1] { @2E80 stack[-1] } 2E7C 5B JUMPDEST 2E7D 61 PUSH2 0x2ed1 2E80 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ed1, if stack[-1] label_2E81: // Incoming jump from 0x2E80, if not stack[-1] // Inputs[3] // { // @2E83 memory[0x40:0x60] // @2ECB memory[0x40:0x60] // @2ED0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2E81 60 PUSH1 0x40 2E83 51 MLOAD 2E84 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2EA5 81 DUP2 2EA6 52 MSTORE 2EA7 60 PUSH1 0x04 2EA9 01 ADD 2EAA 80 DUP1 2EAB 80 DUP1 2EAC 60 PUSH1 0x20 2EAE 01 ADD 2EAF 82 DUP3 2EB0 81 DUP2 2EB1 03 SUB 2EB2 82 DUP3 2EB3 52 MSTORE 2EB4 60 PUSH1 0x31 2EB6 81 DUP2 2EB7 52 MSTORE 2EB8 60 PUSH1 0x20 2EBA 01 ADD 2EBB 80 DUP1 2EBC 61 PUSH2 0x4d30 2EBF 60 PUSH1 0x31 2EC1 91 SWAP2 2EC2 39 CODECOPY 2EC3 60 PUSH1 0x40 2EC5 01 ADD 2EC6 91 SWAP2 2EC7 50 POP 2EC8 50 POP 2EC9 60 PUSH1 0x40 2ECB 51 MLOAD 2ECC 80 DUP1 2ECD 91 SWAP2 2ECE 03 SUB 2ECF 90 SWAP1 2ED0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2EA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2EB3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2EB7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @2EC2 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x4d30:0x4d61] // @2ED0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2ED1: // Incoming jump from 0x2E80, if stack[-1] // Inputs[4] // { // @2ED5 stack[-4] // @2ED6 stack[-3] // @2ED7 stack[-2] // @2ED8 stack[-1] // } 2ED1 5B JUMPDEST 2ED2 61 PUSH2 0x2edd 2ED5 84 DUP5 2ED6 84 DUP5 2ED7 84 DUP5 2ED8 84 DUP5 2ED9 61 PUSH2 0x3f1f 2EDC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2ED2 stack[0] = 0x2edd // @2ED5 stack[1] = stack[-4] // @2ED6 stack[2] = stack[-3] // @2ED7 stack[3] = stack[-2] // @2ED8 stack[4] = stack[-1] // } // Block ends with call to 0x3f1f, returns to 0x2EDD label_2EDD: // Incoming return from call to 0x3F1F at 0x2EDC // Inputs[1] { @2EE2 stack[-5] } 2EDD 5B JUMPDEST 2EDE 50 POP 2EDF 50 POP 2EE0 50 POP 2EE1 50 POP 2EE2 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_2EE3: // Incoming jump from 0x10EB 2EE3 5B JUMPDEST 2EE4 61 PUSH2 0x2eeb 2EE7 61 PUSH2 0x27fc 2EEA 56 *JUMP // Stack delta = +1 // Outputs[1] { @2EE4 stack[0] = 0x2eeb } // Block ends with call to 0x27fc, returns to 0x2EEB label_2EEB: // Incoming return from call to 0x27FC at 0x2EEA // Inputs[1] { @2EEF stack[-1] } 2EEB 5B JUMPDEST 2EEC 61 PUSH2 0x2f5d 2EEF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2f5d, if stack[-1] label_2EF0: // Incoming jump from 0x2EEF, if not stack[-1] // Inputs[3] // { // @2EF2 memory[0x40:0x60] // @2F57 memory[0x40:0x60] // @2F5C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2EF0 60 PUSH1 0x40 2EF2 51 MLOAD 2EF3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2F14 81 DUP2 2F15 52 MSTORE 2F16 60 PUSH1 0x04 2F18 01 ADD 2F19 80 DUP1 2F1A 80 DUP1 2F1B 60 PUSH1 0x20 2F1D 01 ADD 2F1E 82 DUP3 2F1F 81 DUP2 2F20 03 SUB 2F21 82 DUP3 2F22 52 MSTORE 2F23 60 PUSH1 0x20 2F25 81 DUP2 2F26 52 MSTORE 2F27 60 PUSH1 0x20 2F29 01 ADD 2F2A 80 DUP1 2F2B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2F4C 81 DUP2 2F4D 52 MSTORE 2F4E 50 POP 2F4F 60 PUSH1 0x20 2F51 01 ADD 2F52 91 SWAP2 2F53 50 POP 2F54 50 POP 2F55 60 PUSH1 0x40 2F57 51 MLOAD 2F58 80 DUP1 2F59 91 SWAP2 2F5A 03 SUB 2F5B 90 SWAP1 2F5C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2F15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2F22 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2F26 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @2F4D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2F5C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2F5D: // Incoming jump from 0x2EEF, if stack[-1] // Inputs[2] // { // @2F5E stack[-1] // @2F63 memory[stack[-1]:stack[-1] + 0x20] // } 2F5D 5B JUMPDEST 2F5E 80 DUP1 2F5F 60 PUSH1 0x0c 2F61 90 SWAP1 2F62 80 DUP1 2F63 51 MLOAD 2F64 90 SWAP1 2F65 60 PUSH1 0x20 2F67 01 ADD 2F68 90 SWAP1 2F69 61 PUSH2 0x2f73 2F6C 92 SWAP3 2F6D 91 SWAP2 2F6E 90 SWAP1 2F6F 61 PUSH2 0x4ae1 2F72 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2F6C stack[0] = 0x2f73 // @2F6D stack[1] = 0x0c // @2F6E stack[2] = 0x20 + stack[-1] // @2F6E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x4ae1, returns to 0x2F73 label_2F73: // Incoming return from call to 0x4AE1 at 0x2F72 // Inputs[1] { @2F76 stack[-3] } 2F73 5B JUMPDEST 2F74 50 POP 2F75 50 POP 2F76 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2F77: // Incoming jump from 0x1126 2F77 5B JUMPDEST 2F78 60 PUSH1 0x60 2F7A 60 PUSH1 0x0c 2F7C 61 PUSH2 0x2f8b 2F7F 61 PUSH2 0x2f86 2F82 61 PUSH2 0x3f91 2F85 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2F78 stack[0] = 0x60 // @2F7A stack[1] = 0x0c // @2F7C stack[2] = 0x2f8b // @2F7F stack[3] = 0x2f86 // } // Block ends with call to 0x3f91, returns to 0x2F86 label_2F86: // Incoming return from call to 0x3F91 at 0x2F85 2F86 5B JUMPDEST 2F87 61 PUSH2 0x3f99 2F8A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x3f99 label_2F8B: // Incoming return from call to 0x2F86 at 0x2F85 // Inputs[1] { @2F8F stack[-4] } 2F8B 5B JUMPDEST 2F8C 61 PUSH2 0x2f94 2F8F 84 DUP5 2F90 61 PUSH2 0x421a 2F93 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2F8C stack[0] = 0x2f94 // @2F8F stack[1] = stack[-4] // } // Block ends with call to 0x421a, returns to 0x2F94 label_2F94: // Incoming return from call to 0x421A at 0x2F93 // Inputs[3] // { // @2F97 memory[0x40:0x60] // @2F9C stack[-3] // @2F9E storage[stack[-3]] // } 2F94 5B JUMPDEST 2F95 60 PUSH1 0x40 2F97 51 MLOAD 2F98 60 PUSH1 0x20 2F9A 01 ADD 2F9B 80 DUP1 2F9C 84 DUP5 2F9D 80 DUP1 2F9E 54 SLOAD 2F9F 60 PUSH1 0x01 2FA1 81 DUP2 2FA2 60 PUSH1 0x01 2FA4 16 AND 2FA5 15 ISZERO 2FA6 61 PUSH2 0x0100 2FA9 02 MUL 2FAA 03 SUB 2FAB 16 AND 2FAC 60 PUSH1 0x02 2FAE 90 SWAP1 2FAF 04 DIV 2FB0 80 DUP1 2FB1 15 ISZERO 2FB2 61 PUSH2 0x2ff2 2FB5 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2F9A stack[0] = 0x20 + memory[0x40:0x60] // @2F9B stack[1] = 0x20 + memory[0x40:0x60] // @2F9C stack[2] = stack[-3] // @2FAF stack[3] = (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02 // } // Block ends with conditional jump to 0x2ff2, if !((0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) label_2FB6: // Incoming jump from 0x2FB5, if not !((0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) // Inputs[1] { @2FB6 stack[-1] } 2FB6 80 DUP1 2FB7 60 PUSH1 0x1f 2FB9 10 LT 2FBA 61 PUSH2 0x2fd0 2FBD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2fd0, if 0x1f < stack[-1] label_2FBE: // Incoming jump from 0x2FBD, if not 0x1f < stack[-1] // Inputs[4] // { // @2FC2 stack[-2] // @2FC3 storage[stack[-2]] // @2FC6 stack[-3] // @2FC8 stack[-1] // } 2FBE 61 PUSH2 0x0100 2FC1 80 DUP1 2FC2 83 DUP4 2FC3 54 SLOAD 2FC4 04 DIV 2FC5 02 MUL 2FC6 83 DUP4 2FC7 52 MSTORE 2FC8 91 SWAP2 2FC9 82 DUP3 2FCA 01 ADD 2FCB 91 SWAP2 2FCC 61 PUSH2 0x2ff2 2FCF 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2FC7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2FCB stack[-1] = stack[-1] // @2FCB stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2ff2 label_2FD0: // Incoming jump from 0x2FBD, if 0x1f < stack[-1] // Inputs[5] // { // @2FD1 stack[-3] // @2FD2 stack[-1] // @2FD4 stack[-2] // @2FDC memory[0x00:0x20] // @2FE0 storage[keccak256(memory[0x00:0x20])] // } 2FD0 5B JUMPDEST 2FD1 82 DUP3 2FD2 01 ADD 2FD3 91 SWAP2 2FD4 90 SWAP1 2FD5 60 PUSH1 0x00 2FD7 52 MSTORE 2FD8 60 PUSH1 0x20 2FDA 60 PUSH1 0x00 2FDC 20 SHA3 2FDD 90 SWAP1 2FDE 5B JUMPDEST 2FDF 81 DUP2 2FE0 54 SLOAD 2FE1 81 DUP2 2FE2 52 MSTORE 2FE3 90 SWAP1 2FE4 60 PUSH1 0x01 2FE6 01 ADD 2FE7 90 SWAP1 2FE8 60 PUSH1 0x20 2FEA 01 ADD 2FEB 80 DUP1 2FEC 83 DUP4 2FED 11 GT 2FEE 61 PUSH2 0x2fde 2FF1 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2FD3 stack[-3] = stack[-3] + stack[-1] // @2FD7 memory[0x00:0x20] = stack[-2] // @2FE2 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @2FE7 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2FEA stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2fde, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2FF2: // Incoming jump from 0x2FF1, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x2FB5, if !((0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) // Incoming jump from 0x2FCF // Incoming jump from 0x2FF1, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[3] // { // @2FF5 stack[-6] // @2FF7 memory[stack[-6]:stack[-6] + 0x20] // @2FFE stack[-3] // } 2FF2 5B JUMPDEST 2FF3 50 POP 2FF4 50 POP 2FF5 83 DUP4 2FF6 80 DUP1 2FF7 51 MLOAD 2FF8 90 SWAP1 2FF9 60 PUSH1 0x20 2FFB 01 ADD 2FFC 90 SWAP1 2FFD 80 DUP1 2FFE 83 DUP4 2FFF 83 DUP4 3000 5B JUMPDEST 3001 60 PUSH1 0x20 3003 83 DUP4 3004 10 LT 3005 61 PUSH2 0x3023 3008 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2FFC stack[-2] = 0x20 + stack[-6] // @2FFC stack[-1] = memory[stack[-6]:stack[-6] + 0x20] // @2FFD stack[0] = memory[stack[-6]:stack[-6] + 0x20] // @2FFE stack[1] = stack[-3] // @2FFF stack[2] = 0x20 + stack[-6] // } // Block ends with conditional jump to 0x3023, if memory[stack[-6]:stack[-6] + 0x20] < 0x20 label_3009: // Incoming jump from 0x3008, if not memory[stack[-6]:stack[-6] + 0x20] < 0x20 // Incoming jump from 0x3008, if not stack[-3] < 0x20 // Inputs[4] // { // @3009 stack[-1] // @300A memory[stack[-1]:stack[-1] + 0x20] // @300B stack[-2] // @301B stack[-3] // } 3009 80 DUP1 300A 51 MLOAD 300B 82 DUP3 300C 52 MSTORE 300D 60 PUSH1 0x20 300F 82 DUP3 3010 01 ADD 3011 91 SWAP2 3012 50 POP 3013 60 PUSH1 0x20 3015 81 DUP2 3016 01 ADD 3017 90 SWAP1 3018 50 POP 3019 60 PUSH1 0x20 301B 83 DUP4 301C 03 SUB 301D 92 SWAP3 301E 50 POP 301F 61 PUSH2 0x3000 3022 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @300C memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @3011 stack[-2] = stack[-2] + 0x20 // @3017 stack[-1] = stack[-1] + 0x20 // @301D stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x3000 label_3023: // Incoming jump from 0x3008, if memory[stack[-6]:stack[-6] + 0x20] < 0x20 // Incoming jump from 0x3008, if stack[-3] < 0x20 // Inputs[10] // { // @3026 stack[-3] // @3031 stack[-1] // @3032 memory[stack[-1]:stack[-1] + 0x20] // @3035 stack[-2] // @3036 memory[stack[-2]:stack[-2] + 0x20] // @3043 stack[-5] // @3043 stack[-4] // @3045 stack[-6] // @306E stack[-8] // @3070 memory[stack[-8]:stack[-8] + 0x20] // } 3023 5B JUMPDEST 3024 60 PUSH1 0x01 3026 83 DUP4 3027 60 PUSH1 0x20 3029 03 SUB 302A 61 PUSH2 0x0100 302D 0A EXP 302E 03 SUB 302F 80 DUP1 3030 19 NOT 3031 82 DUP3 3032 51 MLOAD 3033 16 AND 3034 81 DUP2 3035 84 DUP5 3036 51 MLOAD 3037 16 AND 3038 80 DUP1 3039 82 DUP3 303A 17 OR 303B 85 DUP6 303C 52 MSTORE 303D 50 POP 303E 50 POP 303F 50 POP 3040 50 POP 3041 50 POP 3042 50 POP 3043 90 SWAP1 3044 50 POP 3045 01 ADD 3046 80 DUP1 3047 7F PUSH32 0x2669643d00000000000000000000000000000000000000000000000000000000 3068 81 DUP2 3069 52 MSTORE 306A 50 POP 306B 60 PUSH1 0x04 306D 01 ADD 306E 82 DUP3 306F 80 DUP1 3070 51 MLOAD 3071 90 SWAP1 3072 60 PUSH1 0x20 3074 01 ADD 3075 90 SWAP1 3076 80 DUP1 3077 83 DUP4 3078 83 DUP4 3079 5B JUMPDEST 307A 60 PUSH1 0x20 307C 83 DUP4 307D 10 LT 307E 61 PUSH2 0x309c 3081 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @303C memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @3069 memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = 0x2669643d00000000000000000000000000000000000000000000000000000000 // @306D stack[-6] = 0x04 + stack[-4] + stack[-6] // @3075 stack[-5] = 0x20 + stack[-8] // @3075 stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @3076 stack[-3] = memory[stack[-8]:stack[-8] + 0x20] // @3077 stack[-2] = 0x04 + stack[-4] + stack[-6] // @3078 stack[-1] = 0x20 + stack[-8] // } // Block ends with conditional jump to 0x309c, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 label_3082: // Incoming jump from 0x3081, if not memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Incoming jump from 0x3081, if not stack[-3] < 0x20 // Inputs[4] // { // @3082 stack[-1] // @3083 memory[stack[-1]:stack[-1] + 0x20] // @3084 stack[-2] // @3094 stack[-3] // } 3082 80 DUP1 3083 51 MLOAD 3084 82 DUP3 3085 52 MSTORE 3086 60 PUSH1 0x20 3088 82 DUP3 3089 01 ADD 308A 91 SWAP2 308B 50 POP 308C 60 PUSH1 0x20 308E 81 DUP2 308F 01 ADD 3090 90 SWAP1 3091 50 POP 3092 60 PUSH1 0x20 3094 83 DUP4 3095 03 SUB 3096 92 SWAP3 3097 50 POP 3098 61 PUSH2 0x3079 309B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3085 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @308A stack[-2] = stack[-2] + 0x20 // @3090 stack[-1] = stack[-1] + 0x20 // @3096 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x3079 label_309C: // Incoming jump from 0x3081, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Incoming jump from 0x3081, if stack[-3] < 0x20 // Inputs[13] // { // @309F stack[-3] // @30AA stack[-1] // @30AB memory[stack[-1]:stack[-1] + 0x20] // @30AE stack[-2] // @30AF memory[stack[-2]:stack[-2] + 0x20] // @30BC stack[-4] // @30BC stack[-5] // @30BE stack[-6] // @30BF stack[-10] // @30C6 memory[0x40:0x60] // @30D3 stack[-11] // @30D5 stack[-13] // @30D6 stack[-12] // } 309C 5B JUMPDEST 309D 60 PUSH1 0x01 309F 83 DUP4 30A0 60 PUSH1 0x20 30A2 03 SUB 30A3 61 PUSH2 0x0100 30A6 0A EXP 30A7 03 SUB 30A8 80 DUP1 30A9 19 NOT 30AA 82 DUP3 30AB 51 MLOAD 30AC 16 AND 30AD 81 DUP2 30AE 84 DUP5 30AF 51 MLOAD 30B0 16 AND 30B1 80 DUP1 30B2 82 DUP3 30B3 17 OR 30B4 85 DUP6 30B5 52 MSTORE 30B6 50 POP 30B7 50 POP 30B8 50 POP 30B9 50 POP 30BA 50 POP 30BB 50 POP 30BC 90 SWAP1 30BD 50 POP 30BE 01 ADD 30BF 93 SWAP4 30C0 50 POP 30C1 50 POP 30C2 50 POP 30C3 50 POP 30C4 60 PUSH1 0x40 30C6 51 MLOAD 30C7 60 PUSH1 0x20 30C9 81 DUP2 30CA 83 DUP4 30CB 03 SUB 30CC 03 SUB 30CD 81 DUP2 30CE 52 MSTORE 30CF 90 SWAP1 30D0 60 PUSH1 0x40 30D2 52 MSTORE 30D3 90 SWAP1 30D4 50 POP 30D5 91 SWAP2 30D6 90 SWAP1 30D7 50 POP 30D8 56 *JUMP // Stack delta = -12 // Outputs[4] // { // @30B5 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @30CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @30D2 memory[0x40:0x60] = stack[-4] + stack[-6] // @30D5 stack[-13] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-13] label_30D9: // Incoming jump from 0x1C5B // Incoming call from 0x3CAB, returns to 0x3CAC // Incoming jump from 0x1210 // Inputs[6] // { // @30E0 stack[-2] // @311A memory[0x00:0x40] // @311D stack[-1] // @3157 memory[0x00:0x40] // @315B storage[keccak256(memory[0x00:0x40])] // @3168 stack[-3] // } 30D9 5B JUMPDEST 30DA 60 PUSH1 0x00 30DC 60 PUSH1 0x04 30DE 60 PUSH1 0x00 30E0 84 DUP5 30E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30F6 16 AND 30F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 310C 16 AND 310D 81 DUP2 310E 52 MSTORE 310F 60 PUSH1 0x20 3111 01 ADD 3112 90 SWAP1 3113 81 DUP2 3114 52 MSTORE 3115 60 PUSH1 0x20 3117 01 ADD 3118 60 PUSH1 0x00 311A 20 SHA3 311B 60 PUSH1 0x00 311D 83 DUP4 311E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3133 16 AND 3134 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3149 16 AND 314A 81 DUP2 314B 52 MSTORE 314C 60 PUSH1 0x20 314E 01 ADD 314F 90 SWAP1 3150 81 DUP2 3151 52 MSTORE 3152 60 PUSH1 0x20 3154 01 ADD 3155 60 PUSH1 0x00 3157 20 SHA3 3158 60 PUSH1 0x00 315A 90 SWAP1 315B 54 SLOAD 315C 90 SWAP1 315D 61 PUSH2 0x0100 3160 0A EXP 3161 90 SWAP1 3162 04 DIV 3163 60 PUSH1 0xff 3165 16 AND 3166 90 SWAP1 3167 50 POP 3168 92 SWAP3 3169 91 SWAP2 316A 50 POP 316B 50 POP 316C 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @310E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @3114 memory[0x20:0x40] = 0x04 // @314B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @3151 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @3168 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_316D: // Incoming call from 0x123F, returns to 0x1240 // Inputs[2] // { // @3173 storage[0x0d] // @3191 stack[-1] // } 316D 5B JUMPDEST 316E 60 PUSH1 0x0d 3170 60 PUSH1 0x00 3172 90 SWAP1 3173 54 SLOAD 3174 90 SWAP1 3175 61 PUSH2 0x0100 3178 0A EXP 3179 90 SWAP1 317A 04 DIV 317B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3190 16 AND 3191 81 DUP2 3192 56 *JUMP // Stack delta = +1 // Outputs[1] { @3190 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_3193: // Incoming jump from 0x12D0 3193 5B JUMPDEST 3194 61 PUSH2 0x319b 3197 61 PUSH2 0x27fc 319A 56 *JUMP // Stack delta = +1 // Outputs[1] { @3194 stack[0] = 0x319b } // Block ends with call to 0x27fc, returns to 0x319B label_319B: // Incoming return from call to 0x27FC at 0x319A // Inputs[1] { @319F stack[-1] } 319B 5B JUMPDEST 319C 61 PUSH2 0x320d 319F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x320d, if stack[-1] label_31A0: // Incoming jump from 0x319F, if not stack[-1] // Inputs[3] // { // @31A2 memory[0x40:0x60] // @3207 memory[0x40:0x60] // @320C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 31A0 60 PUSH1 0x40 31A2 51 MLOAD 31A3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 31C4 81 DUP2 31C5 52 MSTORE 31C6 60 PUSH1 0x04 31C8 01 ADD 31C9 80 DUP1 31CA 80 DUP1 31CB 60 PUSH1 0x20 31CD 01 ADD 31CE 82 DUP3 31CF 81 DUP2 31D0 03 SUB 31D1 82 DUP3 31D2 52 MSTORE 31D3 60 PUSH1 0x20 31D5 81 DUP2 31D6 52 MSTORE 31D7 60 PUSH1 0x20 31D9 01 ADD 31DA 80 DUP1 31DB 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 31FC 81 DUP2 31FD 52 MSTORE 31FE 50 POP 31FF 60 PUSH1 0x20 3201 01 ADD 3202 91 SWAP2 3203 50 POP 3204 50 POP 3205 60 PUSH1 0x40 3207 51 MLOAD 3208 80 DUP1 3209 91 SWAP2 320A 03 SUB 320B 90 SWAP1 320C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @31C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @31D2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @31D6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @31FD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @320C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_320D: // Incoming jump from 0x319F, if stack[-1] // Inputs[1] { @3211 stack[-1] } 320D 5B JUMPDEST 320E 61 PUSH2 0x3216 3211 81 DUP2 3212 61 PUSH2 0x4347 3215 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @320E stack[0] = 0x3216 // @3211 stack[1] = stack[-1] // } // Block ends with call to 0x4347, returns to 0x3216 label_3216: // Incoming return from call to 0x4347 at 0x3215 // Inputs[1] { @3218 stack[-2] } 3216 5B JUMPDEST 3217 50 POP 3218 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_3219: // Incoming jump from 0x142F 3219 5B JUMPDEST 321A 61 PUSH2 0x3221 321D 61 PUSH2 0x27fc 3220 56 *JUMP // Stack delta = +1 // Outputs[1] { @321A stack[0] = 0x3221 } // Block ends with call to 0x27fc, returns to 0x3221 label_3221: // Incoming return from call to 0x27FC at 0x3220 // Inputs[1] { @3225 stack[-1] } 3221 5B JUMPDEST 3222 61 PUSH2 0x3293 3225 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3293, if stack[-1] label_3226: // Incoming jump from 0x3225, if not stack[-1] // Inputs[3] // { // @3228 memory[0x40:0x60] // @328D memory[0x40:0x60] // @3292 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3226 60 PUSH1 0x40 3228 51 MLOAD 3229 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 324A 81 DUP2 324B 52 MSTORE 324C 60 PUSH1 0x04 324E 01 ADD 324F 80 DUP1 3250 80 DUP1 3251 60 PUSH1 0x20 3253 01 ADD 3254 82 DUP3 3255 81 DUP2 3256 03 SUB 3257 82 DUP3 3258 52 MSTORE 3259 60 PUSH1 0x20 325B 81 DUP2 325C 52 MSTORE 325D 60 PUSH1 0x20 325F 01 ADD 3260 80 DUP1 3261 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 3282 81 DUP2 3283 52 MSTORE 3284 50 POP 3285 60 PUSH1 0x20 3287 01 ADD 3288 91 SWAP2 3289 50 POP 328A 50 POP 328B 60 PUSH1 0x40 328D 51 MLOAD 328E 80 DUP1 328F 91 SWAP2 3290 03 SUB 3291 90 SWAP1 3292 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @324B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3258 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @325C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @3283 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @3292 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3293: // Incoming jump from 0x3225, if stack[-1] // Inputs[2] // { // @3294 stack[-2] // @3299 memory[stack[-2]:stack[-2] + 0x20] // } 3293 5B JUMPDEST 3294 81 DUP2 3295 60 PUSH1 0x0a 3297 90 SWAP1 3298 80 DUP1 3299 51 MLOAD 329A 90 SWAP1 329B 60 PUSH1 0x20 329D 01 ADD 329E 90 SWAP1 329F 61 PUSH2 0x32a9 32A2 92 SWAP3 32A3 91 SWAP2 32A4 90 SWAP1 32A5 61 PUSH2 0x4ae1 32A8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @32A2 stack[0] = 0x32a9 // @32A3 stack[1] = 0x0a // @32A4 stack[2] = 0x20 + stack[-2] // @32A4 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x4ae1, returns to 0x32A9 label_32A9: // Incoming return from call to 0x4AE1 at 0x32A8 // Inputs[2] // { // @32AB stack[-2] // @32B0 memory[stack[-2]:stack[-2] + 0x20] // } 32A9 5B JUMPDEST 32AA 50 POP 32AB 80 DUP1 32AC 60 PUSH1 0x0b 32AE 90 SWAP1 32AF 80 DUP1 32B0 51 MLOAD 32B1 90 SWAP1 32B2 60 PUSH1 0x20 32B4 01 ADD 32B5 90 SWAP1 32B6 61 PUSH2 0x32c0 32B9 92 SWAP3 32BA 91 SWAP2 32BB 90 SWAP1 32BC 61 PUSH2 0x4ae1 32BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @32B9 stack[-1] = 0x32c0 // @32BA stack[0] = 0x0b // @32BB stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @32BB stack[1] = 0x20 + stack[-2] // } // Block ends with call to 0x4ae1, returns to 0x32C0 label_32C0: // Incoming return from call to 0x4AE1 at 0x32BF // Inputs[1] { @32C4 stack[-4] } 32C0 5B JUMPDEST 32C1 50 POP 32C2 50 POP 32C3 50 POP 32C4 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_32C5: // Incoming jump from 0x1920 32C5 5B JUMPDEST 32C6 61 PUSH2 0x32cd 32C9 61 PUSH2 0x27fc 32CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @32C6 stack[0] = 0x32cd } // Block ends with call to 0x27fc, returns to 0x32CD label_32CD: // Incoming return from call to 0x27FC at 0x32CC // Inputs[1] { @32D1 stack[-1] } 32CD 5B JUMPDEST 32CE 61 PUSH2 0x333f 32D1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x333f, if stack[-1] label_32D2: // Incoming jump from 0x32D1, if not stack[-1] // Inputs[3] // { // @32D4 memory[0x40:0x60] // @3339 memory[0x40:0x60] // @333E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 32D2 60 PUSH1 0x40 32D4 51 MLOAD 32D5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 32F6 81 DUP2 32F7 52 MSTORE 32F8 60 PUSH1 0x04 32FA 01 ADD 32FB 80 DUP1 32FC 80 DUP1 32FD 60 PUSH1 0x20 32FF 01 ADD 3300 82 DUP3 3301 81 DUP2 3302 03 SUB 3303 82 DUP3 3304 52 MSTORE 3305 60 PUSH1 0x20 3307 81 DUP2 3308 52 MSTORE 3309 60 PUSH1 0x20 330B 01 ADD 330C 80 DUP1 330D 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 332E 81 DUP2 332F 52 MSTORE 3330 50 POP 3331 60 PUSH1 0x20 3333 01 ADD 3334 91 SWAP2 3335 50 POP 3336 50 POP 3337 60 PUSH1 0x40 3339 51 MLOAD 333A 80 DUP1 333B 91 SWAP2 333C 03 SUB 333D 90 SWAP1 333E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @32F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3304 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3308 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @332F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @333E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_333F: // Incoming jump from 0x32D1, if stack[-1] // Inputs[4] // { // @3347 storage[0x0e] // @3382 memory[0x40:0x60] // @3396 memory[0x40:0x60] // @339D address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // } 333F 5B JUMPDEST 3340 60 PUSH1 0x00 3342 60 PUSH1 0x0e 3344 60 PUSH1 0x00 3346 90 SWAP1 3347 54 SLOAD 3348 90 SWAP1 3349 61 PUSH2 0x0100 334C 0A EXP 334D 90 SWAP1 334E 04 DIV 334F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3364 16 AND 3365 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 337A 16 AND 337B 63 PUSH4 0xe66fcda8 3380 60 PUSH1 0x40 3382 51 MLOAD 3383 81 DUP2 3384 63 PUSH4 0xffffffff 3389 16 AND 338A 60 PUSH1 0xe0 338C 1B SHL 338D 81 DUP2 338E 52 MSTORE 338F 60 PUSH1 0x04 3391 01 ADD 3392 60 PUSH1 0x20 3394 60 PUSH1 0x40 3396 51 MLOAD 3397 80 DUP1 3398 83 DUP4 3399 03 SUB 339A 81 DUP2 339B 86 DUP7 339C 80 DUP1 339D 3B EXTCODESIZE 339E 15 ISZERO 339F 80 DUP1 33A0 15 ISZERO 33A1 61 PUSH2 0x33a9 33A4 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @3340 stack[0] = 0x00 // @337A stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // @337B stack[2] = 0xe66fcda8 // @338E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xe66fcda8) << 0xe0 // @3391 stack[3] = 0x04 + memory[0x40:0x60] // @3392 stack[4] = 0x20 // @3396 stack[5] = memory[0x40:0x60] // @3399 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @339A stack[7] = memory[0x40:0x60] // @339B stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 // @339E stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x33a9, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length label_33A5: // Incoming jump from 0x33A4, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // Inputs[1] { @33A8 memory[0x00:0x00] } 33A5 60 PUSH1 0x00 33A7 80 DUP1 33A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @33A8 revert(memory[0x00:0x00]); } // Block terminates label_33A9: // Incoming jump from 0x33A4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @33AB msg.gas // @33AC stack[-2] // @33AC stack[-5] // @33AC stack[-6] // @33AC memory[stack[-3]:stack[-3] + stack[-4]] // @33AC stack[-3] // @33AC stack[-4] // @33AC address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 33A9 5B JUMPDEST 33AA 50 POP 33AB 5A GAS 33AC FA STATICCALL 33AD 15 ISZERO 33AE 80 DUP1 33AF 15 ISZERO 33B0 61 PUSH2 0x33bd 33B3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @33AC memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @33AD stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x33bd, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_33B4: // Incoming jump from 0x33B3, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @33B4 returndata.length // @33B8 returndata[0x00:0x00 + returndata.length] // @33B9 returndata.length // @33BC memory[0x00:0x00 + returndata.length] // } 33B4 3D RETURNDATASIZE 33B5 60 PUSH1 0x00 33B7 80 DUP1 33B8 3E RETURNDATACOPY 33B9 3D RETURNDATASIZE 33BA 60 PUSH1 0x00 33BC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @33B8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @33BC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_33BD: // Incoming jump from 0x33B3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @33C4 memory[0x40:0x60] // @33C5 returndata.length // } 33BD 5B JUMPDEST 33BE 50 POP 33BF 50 POP 33C0 50 POP 33C1 50 POP 33C2 60 PUSH1 0x40 33C4 51 MLOAD 33C5 3D RETURNDATASIZE 33C6 60 PUSH1 0x20 33C8 81 DUP2 33C9 10 LT 33CA 15 ISZERO 33CB 61 PUSH2 0x33d3 33CE 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @33C4 stack[-4] = memory[0x40:0x60] // @33C5 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x33d3, if !(returndata.length < 0x20) label_33CF: // Incoming jump from 0x33CE, if not !(returndata.length < 0x20) // Inputs[1] { @33D2 memory[0x00:0x00] } 33CF 60 PUSH1 0x00 33D1 80 DUP1 33D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @33D2 revert(memory[0x00:0x00]); } // Block terminates label_33D3: // Incoming jump from 0x33CE, if !(returndata.length < 0x20) // Inputs[5] // { // @33D4 stack[-2] // @33D5 stack[-1] // @33D9 memory[stack[-2]:stack[-2] + 0x20] // @33E5 stack[-3] // @33E8 msg.value // } 33D3 5B JUMPDEST 33D4 81 DUP2 33D5 01 ADD 33D6 90 SWAP1 33D7 80 DUP1 33D8 80 DUP1 33D9 51 MLOAD 33DA 90 SWAP1 33DB 60 PUSH1 0x20 33DD 01 ADD 33DE 90 SWAP1 33DF 92 SWAP3 33E0 91 SWAP2 33E1 90 SWAP1 33E2 50 POP 33E3 50 POP 33E4 50 POP 33E5 90 SWAP1 33E6 50 POP 33E7 80 DUP1 33E8 34 CALLVALUE 33E9 14 EQ 33EA 61 PUSH2 0x33f2 33ED 57 *JUMPI // Stack delta = -2 // Outputs[1] { @33E5 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x33f2, if msg.value == memory[stack[-2]:stack[-2] + 0x20] label_33EE: // Incoming jump from 0x33ED, if not msg.value == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @33F1 memory[0x00:0x00] } 33EE 60 PUSH1 0x00 33F0 80 DUP1 33F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @33F1 revert(memory[0x00:0x00]); } // Block terminates label_33F2: // Incoming jump from 0x33ED, if msg.value == memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @3421 msg.value // @3429 memory[0x40:0x60] // @342E memory[0x40:0x60] // @3436 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @3436 address(0xffffffffffffffffffffffffffffffffffffffff & 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 33F2 5B JUMPDEST 33F3 73 PUSH20 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073 3408 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 341D 16 AND 341E 61 PUSH2 0x08fc 3421 34 CALLVALUE 3422 90 SWAP1 3423 81 DUP2 3424 15 ISZERO 3425 02 MUL 3426 90 SWAP1 3427 60 PUSH1 0x40 3429 51 MLOAD 342A 60 PUSH1 0x00 342C 60 PUSH1 0x40 342E 51 MLOAD 342F 80 DUP1 3430 83 DUP4 3431 03 SUB 3432 81 DUP2 3433 85 DUP6 3434 88 DUP9 3435 88 DUP9 3436 F1 CALL 3437 93 SWAP4 3438 50 POP 3439 50 POP 343A 50 POP 343B 50 POP 343C 15 ISZERO 343D 80 DUP1 343E 15 ISZERO 343F 61 PUSH2 0x344c 3442 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @3436 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @343C stack[0] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x344c, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_3443: // Incoming jump from 0x3442, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[4] // { // @3443 returndata.length // @3447 returndata[0x00:0x00 + returndata.length] // @3448 returndata.length // @344B memory[0x00:0x00 + returndata.length] // } 3443 3D RETURNDATASIZE 3444 60 PUSH1 0x00 3446 80 DUP1 3447 3E RETURNDATACOPY 3448 3D RETURNDATASIZE 3449 60 PUSH1 0x00 344B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3447 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @344B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_344C: // Incoming jump from 0x3442, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x4c7bedfa26c744e6bd61cbdf86f3fc4a76dca073).call.gas(!msg.value * 0x08fc).value(msg.value)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @3455 stack[-4] } 344C 5B JUMPDEST 344D 50 POP 344E 60 PUSH1 0x00 3450 60 PUSH1 0x01 3452 90 SWAP1 3453 50 POP 3454 5B JUMPDEST 3455 83 DUP4 3456 81 DUP2 3457 60 PUSH1 0xff 3459 16 AND 345A 11 GT 345B 61 PUSH2 0x3a9c 345E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3452 stack[-1] = 0x01 } // Block ends with conditional jump to 0x3a9c, if 0xff & 0x01 > stack[-4] label_345F: // Incoming jump from 0x345E, if not 0xff & stack[-1] > stack[-4] // Incoming jump from 0x345E, if not 0xff & 0x01 > stack[-4] // Inputs[5] // { // @3463 storage[0x09] // @346B stack[-12] // @3472 storage[0x09] // @3480 memory[0x00:0x40] // @3483 memory[stack[-12]:stack[-12] + 0x20] // } 345F 60 PUSH1 0x01 3461 60 PUSH1 0x09 3463 54 SLOAD 3464 01 ADD 3465 60 PUSH1 0x09 3467 81 DUP2 3468 90 SWAP1 3469 55 SSTORE 346A 50 POP 346B 8B DUP12 346C 60 PUSH1 0x0f 346E 60 PUSH1 0x00 3470 60 PUSH1 0x09 3472 54 SLOAD 3473 81 DUP2 3474 52 MSTORE 3475 60 PUSH1 0x20 3477 01 ADD 3478 90 SWAP1 3479 81 DUP2 347A 52 MSTORE 347B 60 PUSH1 0x20 347D 01 ADD 347E 60 PUSH1 0x00 3480 20 SHA3 3481 90 SWAP1 3482 80 DUP1 3483 51 MLOAD 3484 90 SWAP1 3485 60 PUSH1 0x20 3487 01 ADD 3488 90 SWAP1 3489 61 PUSH2 0x3493 348C 92 SWAP3 348D 91 SWAP2 348E 90 SWAP1 348F 61 PUSH2 0x4ae1 3492 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @3469 storage[0x09] = storage[0x09] + 0x01 // @3474 memory[0x00:0x20] = storage[0x09] // @347A memory[0x20:0x40] = 0x0f // @348C stack[0] = 0x3493 // @348D stack[1] = keccak256(memory[0x00:0x40]) // @348E stack[2] = 0x20 + stack[-12] // @348E stack[3] = memory[stack[-12]:stack[-12] + 0x20] // } // Block ends with call to 0x4ae1, returns to 0x3493 label_3493: // Incoming return from call to 0x4AE1 at 0x3492 // Inputs[4] // { // @3495 stack[-12] // @349C storage[0x09] // @34AA memory[0x00:0x40] // @34AD memory[stack[-12]:stack[-12] + 0x20] // } 3493 5B JUMPDEST 3494 50 POP 3495 8A DUP11 3496 60 PUSH1 0x10 3498 60 PUSH1 0x00 349A 60 PUSH1 0x09 349C 54 SLOAD 349D 81 DUP2 349E 52 MSTORE 349F 60 PUSH1 0x20 34A1 01 ADD 34A2 90 SWAP1 34A3 81 DUP2 34A4 52 MSTORE 34A5 60 PUSH1 0x20 34A7 01 ADD 34A8 60 PUSH1 0x00 34AA 20 SHA3 34AB 90 SWAP1 34AC 80 DUP1 34AD 51 MLOAD 34AE 90 SWAP1 34AF 60 PUSH1 0x20 34B1 01 ADD 34B2 90 SWAP1 34B3 61 PUSH2 0x34bd 34B6 92 SWAP3 34B7 91 SWAP2 34B8 90 SWAP1 34B9 61 PUSH2 0x4ae1 34BC 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @349E memory[0x00:0x20] = storage[0x09] // @34A4 memory[0x20:0x40] = 0x10 // @34B6 stack[-1] = 0x34bd // @34B7 stack[0] = keccak256(memory[0x00:0x40]) // @34B8 stack[2] = memory[stack[-12]:stack[-12] + 0x20] // @34B8 stack[1] = 0x20 + stack[-12] // } // Block ends with call to 0x4ae1, returns to 0x34BD label_34BD: // Incoming return from call to 0x4AE1 at 0x34BC // Inputs[4] // { // @34BF stack[-11] // @34C6 storage[0x09] // @34D4 memory[0x00:0x40] // @34D7 memory[stack[-11]:stack[-11] + 0x20] // } 34BD 5B JUMPDEST 34BE 50 POP 34BF 89 DUP10 34C0 60 PUSH1 0x11 34C2 60 PUSH1 0x00 34C4 60 PUSH1 0x09 34C6 54 SLOAD 34C7 81 DUP2 34C8 52 MSTORE 34C9 60 PUSH1 0x20 34CB 01 ADD 34CC 90 SWAP1 34CD 81 DUP2 34CE 52 MSTORE 34CF 60 PUSH1 0x20 34D1 01 ADD 34D2 60 PUSH1 0x00 34D4 20 SHA3 34D5 90 SWAP1 34D6 80 DUP1 34D7 51 MLOAD 34D8 90 SWAP1 34D9 60 PUSH1 0x20 34DB 01 ADD 34DC 90 SWAP1 34DD 61 PUSH2 0x34e7 34E0 92 SWAP3 34E1 91 SWAP2 34E2 90 SWAP1 34E3 61 PUSH2 0x4ae1 34E6 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @34C8 memory[0x00:0x20] = storage[0x09] // @34CE memory[0x20:0x40] = 0x11 // @34E0 stack[-1] = 0x34e7 // @34E1 stack[0] = keccak256(memory[0x00:0x40]) // @34E2 stack[2] = memory[stack[-11]:stack[-11] + 0x20] // @34E2 stack[1] = 0x20 + stack[-11] // } // Block ends with call to 0x4ae1, returns to 0x34E7 label_34E7: // Incoming return from call to 0x4AE1 at 0x34E6 // Inputs[4] // { // @34E9 stack[-10] // @34F0 storage[0x09] // @34FE memory[0x00:0x40] // @3501 memory[stack[-10]:stack[-10] + 0x20] // } 34E7 5B JUMPDEST 34E8 50 POP 34E9 88 DUP9 34EA 60 PUSH1 0x13 34EC 60 PUSH1 0x00 34EE 60 PUSH1 0x09 34F0 54 SLOAD 34F1 81 DUP2 34F2 52 MSTORE 34F3 60 PUSH1 0x20 34F5 01 ADD 34F6 90 SWAP1 34F7 81 DUP2 34F8 52 MSTORE 34F9 60 PUSH1 0x20 34FB 01 ADD 34FC 60 PUSH1 0x00 34FE 20 SHA3 34FF 90 SWAP1 3500 80 DUP1 3501 51 MLOAD 3502 90 SWAP1 3503 60 PUSH1 0x20 3505 01 ADD 3506 90 SWAP1 3507 61 PUSH2 0x3511 350A 92 SWAP3 350B 91 SWAP2 350C 90 SWAP1 350D 61 PUSH2 0x4ae1 3510 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @34F2 memory[0x00:0x20] = storage[0x09] // @34F8 memory[0x20:0x40] = 0x13 // @350A stack[-1] = 0x3511 // @350B stack[0] = keccak256(memory[0x00:0x40]) // @350C stack[2] = memory[stack[-10]:stack[-10] + 0x20] // @350C stack[1] = 0x20 + stack[-10] // } // Block ends with call to 0x4ae1, returns to 0x3511 label_3511: // Incoming return from call to 0x4AE1 at 0x3510 // Inputs[4] // { // @3513 stack[-9] // @351A storage[0x09] // @3528 memory[0x00:0x40] // @352B memory[stack[-9]:stack[-9] + 0x20] // } 3511 5B JUMPDEST 3512 50 POP 3513 87 DUP8 3514 60 PUSH1 0x12 3516 60 PUSH1 0x00 3518 60 PUSH1 0x09 351A 54 SLOAD 351B 81 DUP2 351C 52 MSTORE 351D 60 PUSH1 0x20 351F 01 ADD 3520 90 SWAP1 3521 81 DUP2 3522 52 MSTORE 3523 60 PUSH1 0x20 3525 01 ADD 3526 60 PUSH1 0x00 3528 20 SHA3 3529 90 SWAP1 352A 80 DUP1 352B 51 MLOAD 352C 90 SWAP1 352D 60 PUSH1 0x20 352F 01 ADD 3530 90 SWAP1 3531 61 PUSH2 0x353b 3534 92 SWAP3 3535 91 SWAP2 3536 90 SWAP1 3537 61 PUSH2 0x4ae1 353A 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @351C memory[0x00:0x20] = storage[0x09] // @3522 memory[0x20:0x40] = 0x12 // @3534 stack[-1] = 0x353b // @3535 stack[0] = keccak256(memory[0x00:0x40]) // @3536 stack[2] = memory[stack[-9]:stack[-9] + 0x20] // @3536 stack[1] = 0x20 + stack[-9] // } // Block ends with call to 0x4ae1, returns to 0x353B label_353B: // Incoming return from call to 0x4AE1 at 0x353A // Inputs[4] // { // @353D stack[-8] // @3544 storage[0x09] // @3552 memory[0x00:0x40] // @3555 memory[stack[-8]:stack[-8] + 0x20] // } 353B 5B JUMPDEST 353C 50 POP 353D 86 DUP7 353E 60 PUSH1 0x14 3540 60 PUSH1 0x00 3542 60 PUSH1 0x09 3544 54 SLOAD 3545 81 DUP2 3546 52 MSTORE 3547 60 PUSH1 0x20 3549 01 ADD 354A 90 SWAP1 354B 81 DUP2 354C 52 MSTORE 354D 60 PUSH1 0x20 354F 01 ADD 3550 60 PUSH1 0x00 3552 20 SHA3 3553 90 SWAP1 3554 80 DUP1 3555 51 MLOAD 3556 90 SWAP1 3557 60 PUSH1 0x20 3559 01 ADD 355A 90 SWAP1 355B 61 PUSH2 0x3565 355E 92 SWAP3 355F 91 SWAP2 3560 90 SWAP1 3561 61 PUSH2 0x4ae1 3564 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @3546 memory[0x00:0x20] = storage[0x09] // @354C memory[0x20:0x40] = 0x14 // @355E stack[-1] = 0x3565 // @355F stack[0] = keccak256(memory[0x00:0x40]) // @3560 stack[2] = memory[stack[-8]:stack[-8] + 0x20] // @3560 stack[1] = 0x20 + stack[-8] // } // Block ends with call to 0x4ae1, returns to 0x3565 label_3565: // Incoming return from call to 0x4AE1 at 0x3564 // Inputs[4] // { // @3567 stack[-7] // @356E storage[0x09] // @357C memory[0x00:0x40] // @357F memory[stack[-7]:stack[-7] + 0x20] // } 3565 5B JUMPDEST 3566 50 POP 3567 85 DUP6 3568 60 PUSH1 0x19 356A 60 PUSH1 0x00 356C 60 PUSH1 0x09 356E 54 SLOAD 356F 81 DUP2 3570 52 MSTORE 3571 60 PUSH1 0x20 3573 01 ADD 3574 90 SWAP1 3575 81 DUP2 3576 52 MSTORE 3577 60 PUSH1 0x20 3579 01 ADD 357A 60 PUSH1 0x00 357C 20 SHA3 357D 90 SWAP1 357E 80 DUP1 357F 51 MLOAD 3580 90 SWAP1 3581 60 PUSH1 0x20 3583 01 ADD 3584 90 SWAP1 3585 61 PUSH2 0x358f 3588 92 SWAP3 3589 91 SWAP2 358A 90 SWAP1 358B 61 PUSH2 0x4ae1 358E 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @3570 memory[0x00:0x20] = storage[0x09] // @3576 memory[0x20:0x40] = 0x19 // @3588 stack[-1] = 0x358f // @3589 stack[0] = keccak256(memory[0x00:0x40]) // @358A stack[2] = memory[stack[-7]:stack[-7] + 0x20] // @358A stack[1] = 0x20 + stack[-7] // } // Block ends with call to 0x4ae1, returns to 0x358F label_358F: // Incoming return from call to 0x4AE1 at 0x358E // Inputs[13] // { // @3591 stack[-6] // @3598 storage[0x09] // @35A6 memory[0x00:0x40] // @35AB stack[-2] // @35B5 storage[0x09] // @35C3 memory[0x00:0x40] // @35C8 stack[-5] // @35CF storage[0x09] // @35DD memory[0x00:0x40] // @35E2 stack[-4] // @35E9 storage[0x09] // @35F7 memory[0x00:0x40] // @35FA memory[stack[-4]:stack[-4] + 0x20] // } 358F 5B JUMPDEST 3590 50 POP 3591 84 DUP5 3592 60 PUSH1 0x15 3594 60 PUSH1 0x00 3596 60 PUSH1 0x09 3598 54 SLOAD 3599 81 DUP2 359A 52 MSTORE 359B 60 PUSH1 0x20 359D 01 ADD 359E 90 SWAP1 359F 81 DUP2 35A0 52 MSTORE 35A1 60 PUSH1 0x20 35A3 01 ADD 35A4 60 PUSH1 0x00 35A6 20 SHA3 35A7 81 DUP2 35A8 90 SWAP1 35A9 55 SSTORE 35AA 50 POP 35AB 80 DUP1 35AC 60 PUSH1 0xff 35AE 16 AND 35AF 60 PUSH1 0x16 35B1 60 PUSH1 0x00 35B3 60 PUSH1 0x09 35B5 54 SLOAD 35B6 81 DUP2 35B7 52 MSTORE 35B8 60 PUSH1 0x20 35BA 01 ADD 35BB 90 SWAP1 35BC 81 DUP2 35BD 52 MSTORE 35BE 60 PUSH1 0x20 35C0 01 ADD 35C1 60 PUSH1 0x00 35C3 20 SHA3 35C4 81 DUP2 35C5 90 SWAP1 35C6 55 SSTORE 35C7 50 POP 35C8 83 DUP4 35C9 60 PUSH1 0x17 35CB 60 PUSH1 0x00 35CD 60 PUSH1 0x09 35CF 54 SLOAD 35D0 81 DUP2 35D1 52 MSTORE 35D2 60 PUSH1 0x20 35D4 01 ADD 35D5 90 SWAP1 35D6 81 DUP2 35D7 52 MSTORE 35D8 60 PUSH1 0x20 35DA 01 ADD 35DB 60 PUSH1 0x00 35DD 20 SHA3 35DE 81 DUP2 35DF 90 SWAP1 35E0 55 SSTORE 35E1 50 POP 35E2 82 DUP3 35E3 60 PUSH1 0x18 35E5 60 PUSH1 0x00 35E7 60 PUSH1 0x09 35E9 54 SLOAD 35EA 81 DUP2 35EB 52 MSTORE 35EC 60 PUSH1 0x20 35EE 01 ADD 35EF 90 SWAP1 35F0 81 DUP2 35F1 52 MSTORE 35F2 60 PUSH1 0x20 35F4 01 ADD 35F5 60 PUSH1 0x00 35F7 20 SHA3 35F8 90 SWAP1 35F9 80 DUP1 35FA 51 MLOAD 35FB 90 SWAP1 35FC 60 PUSH1 0x20 35FE 01 ADD 35FF 90 SWAP1 3600 61 PUSH2 0x360a 3603 92 SWAP3 3604 91 SWAP2 3605 90 SWAP1 3606 61 PUSH2 0x4ae1 3609 56 *JUMP // Stack delta = +3 // Outputs[15] // { // @359A memory[0x00:0x20] = storage[0x09] // @35A0 memory[0x20:0x40] = 0x15 // @35A9 storage[keccak256(memory[0x00:0x40])] = stack[-6] // @35B7 memory[0x00:0x20] = storage[0x09] // @35BD memory[0x20:0x40] = 0x16 // @35C6 storage[keccak256(memory[0x00:0x40])] = 0xff & stack[-2] // @35D1 memory[0x00:0x20] = storage[0x09] // @35D7 memory[0x20:0x40] = 0x17 // @35E0 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @35EB memory[0x00:0x20] = storage[0x09] // @35F1 memory[0x20:0x40] = 0x18 // @3603 stack[-1] = 0x360a // @3604 stack[0] = keccak256(memory[0x00:0x40]) // @3605 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @3605 stack[1] = 0x20 + stack[-4] // } // Block ends with call to 0x4ae1, returns to 0x360A label_360A: // Incoming return from call to 0x4AE1 at 0x3609 // Inputs[2] // { // @3610 storage[0x09] // @361B storage[0x0d] // } 360A 5B JUMPDEST 360B 50 POP 360C 60 PUSH1 0x00 360E 60 PUSH1 0x09 3610 54 SLOAD 3611 90 SWAP1 3612 50 POP 3613 61 PUSH2 0x363e 3616 60 PUSH1 0x0d 3618 60 PUSH1 0x00 361A 90 SWAP1 361B 54 SLOAD 361C 90 SWAP1 361D 61 PUSH2 0x0100 3620 0A EXP 3621 90 SWAP1 3622 04 DIV 3623 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3638 16 AND 3639 82 DUP3 363A 61 PUSH2 0x448d 363D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @3611 stack[-1] = storage[0x09] // @3613 stack[0] = 0x363e // @3638 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // @3639 stack[2] = storage[0x09] // } // Block ends with call to 0x448d, returns to 0x363E label_363E: // Incoming return from call to 0x448D at 0x363D // Inputs[9] // { // @3662 storage[0x09] // @3663 stack[-10] // @3664 stack[-9] // @3665 stack[-8] // @3666 stack[-2] // @3667 stack[-5] // @366A memory[0x40:0x60] // @3695 memory[stack[-10]:stack[-10] + 0x20] // @369E memory[stack[-10]:stack[-10] + 0x20] // } 363E 5B JUMPDEST 363F 7F PUSH32 0xb595052542148b2bf1b1e55e14a41579ae9163be75cff6d179f3e96c2bbf4c7f 3660 60 PUSH1 0x09 3662 54 SLOAD 3663 8B DUP12 3664 8B DUP12 3665 8B DUP12 3666 86 DUP7 3667 8A DUP11 3668 60 PUSH1 0x40 366A 51 MLOAD 366B 80 DUP1 366C 87 DUP8 366D 81 DUP2 366E 52 MSTORE 366F 60 PUSH1 0x20 3671 01 ADD 3672 80 DUP1 3673 60 PUSH1 0x20 3675 01 ADD 3676 80 DUP1 3677 60 PUSH1 0x20 3679 01 ADD 367A 80 DUP1 367B 60 PUSH1 0x20 367D 01 ADD 367E 86 DUP7 367F 60 PUSH1 0xff 3681 16 AND 3682 81 DUP2 3683 52 MSTORE 3684 60 PUSH1 0x20 3686 01 ADD 3687 85 DUP6 3688 81 DUP2 3689 52 MSTORE 368A 60 PUSH1 0x20 368C 01 ADD 368D 84 DUP5 368E 81 DUP2 368F 03 SUB 3690 84 DUP5 3691 52 MSTORE 3692 89 DUP10 3693 81 DUP2 3694 81 DUP2 3695 51 MLOAD 3696 81 DUP2 3697 52 MSTORE 3698 60 PUSH1 0x20 369A 01 ADD 369B 91 SWAP2 369C 50 POP 369D 80 DUP1 369E 51 MLOAD 369F 90 SWAP1 36A0 60 PUSH1 0x20 36A2 01 ADD 36A3 90 SWAP1 36A4 80 DUP1 36A5 83 DUP4 36A6 83 DUP4 36A7 60 PUSH1 0x00 36A9 5B JUMPDEST 36AA 83 DUP4 36AB 81 DUP2 36AC 10 LT 36AD 15 ISZERO 36AE 61 PUSH2 0x36c4 36B1 57 *JUMPI // Stack delta = +18 // Outputs[23] // { // @363F stack[0] = 0xb595052542148b2bf1b1e55e14a41579ae9163be75cff6d179f3e96c2bbf4c7f // @3662 stack[1] = storage[0x09] // @3663 stack[2] = stack[-10] // @3664 stack[3] = stack[-9] // @3665 stack[4] = stack[-8] // @3666 stack[5] = stack[-2] // @3667 stack[6] = stack[-5] // @366A stack[7] = memory[0x40:0x60] // @366E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] // @3671 stack[8] = 0x20 + memory[0x40:0x60] // @3675 stack[9] = 0x20 + 0x20 + memory[0x40:0x60] // @3679 stack[10] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3683 memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0xff & stack[-2] // @3689 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-5] // @3691 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @3697 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-10]:stack[-10] + 0x20] // @369B stack[11] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @36A3 stack[12] = 0x20 + stack[-10] // @36A3 stack[13] = memory[stack[-10]:stack[-10] + 0x20] // @36A4 stack[14] = memory[stack[-10]:stack[-10] + 0x20] // @36A5 stack[15] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @36A6 stack[16] = 0x20 + stack[-10] // @36A7 stack[17] = 0x00 // } // Block ends with conditional jump to 0x36c4, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) label_36B2: // Incoming jump from 0x36B1, if not !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Incoming jump from 0x36B1, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @36B2 stack[-1] // @36B3 stack[-2] // @36B5 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @36B7 stack[-3] // } 36B2 80 DUP1 36B3 82 DUP3 36B4 01 ADD 36B5 51 MLOAD 36B6 81 DUP2 36B7 84 DUP5 36B8 01 ADD 36B9 52 MSTORE 36BA 60 PUSH1 0x20 36BC 81 DUP2 36BD 01 ADD 36BE 90 SWAP1 36BF 50 POP 36C0 61 PUSH2 0x36a9 36C3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @36B9 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @36BE stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x36a9 label_36C4: // Incoming jump from 0x36B1, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Incoming jump from 0x36B1, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @36C9 stack[-6] // @36C9 stack[-5] // @36CB stack[-7] // } 36C4 5B JUMPDEST 36C5 50 POP 36C6 50 POP 36C7 50 POP 36C8 50 POP 36C9 90 SWAP1 36CA 50 POP 36CB 90 SWAP1 36CC 81 DUP2 36CD 01 ADD 36CE 90 SWAP1 36CF 60 PUSH1 0x1f 36D1 16 AND 36D2 80 DUP1 36D3 15 ISZERO 36D4 61 PUSH2 0x36f1 36D7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @36CE stack[-7] = stack[-5] + stack[-7] // @36D1 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x36f1, if !(0x1f & stack[-5]) label_36D8: // Incoming jump from 0x36D7, if not !(0x1f & stack[-5]) // Inputs[8] // { // @36D8 stack[-1] // @36D9 stack[-2] // @36DC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @36F3 stack[-6] // @36F6 stack[-4] // @36F8 stack[-10] // @36FB memory[stack[-10]:stack[-10] + 0x20] // @3704 memory[stack[-10]:stack[-10] + 0x20] // } 36D8 80 DUP1 36D9 82 DUP3 36DA 03 SUB 36DB 80 DUP1 36DC 51 MLOAD 36DD 60 PUSH1 0x01 36DF 83 DUP4 36E0 60 PUSH1 0x20 36E2 03 SUB 36E3 61 PUSH2 0x0100 36E6 0A EXP 36E7 03 SUB 36E8 19 NOT 36E9 16 AND 36EA 81 DUP2 36EB 52 MSTORE 36EC 60 PUSH1 0x20 36EE 01 ADD 36EF 91 SWAP2 36F0 50 POP 36F1 5B JUMPDEST 36F2 50 POP 36F3 84 DUP5 36F4 81 DUP2 36F5 03 SUB 36F6 83 DUP4 36F7 52 MSTORE 36F8 88 DUP9 36F9 81 DUP2 36FA 81 DUP2 36FB 51 MLOAD 36FC 81 DUP2 36FD 52 MSTORE 36FE 60 PUSH1 0x20 3700 01 ADD 3701 91 SWAP2 3702 50 POP 3703 80 DUP1 3704 51 MLOAD 3705 90 SWAP1 3706 60 PUSH1 0x20 3708 01 ADD 3709 90 SWAP1 370A 80 DUP1 370B 83 DUP4 370C 83 DUP4 370D 60 PUSH1 0x00 370F 5B JUMPDEST 3710 83 DUP4 3711 81 DUP2 3712 10 LT 3713 15 ISZERO 3714 61 PUSH2 0x372a 3717 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @36EB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @36F7 memory[stack[-4]:stack[-4] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-6] // @36FD memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-10]:stack[-10] + 0x20] // @3701 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @3709 stack[-1] = 0x20 + stack[-10] // @3709 stack[0] = memory[stack[-10]:stack[-10] + 0x20] // @370A stack[1] = memory[stack[-10]:stack[-10] + 0x20] // @370B stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @370C stack[3] = 0x20 + stack[-10] // @370D stack[4] = 0x00 // } // Block ends with conditional jump to 0x372a, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) label_3718: // Incoming jump from 0x3717, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x3717, if not !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Incoming jump from 0x3717, if not !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Inputs[4] // { // @3718 stack[-1] // @3719 stack[-2] // @371B memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @371D stack[-3] // } 3718 80 DUP1 3719 82 DUP3 371A 01 ADD 371B 51 MLOAD 371C 81 DUP2 371D 84 DUP5 371E 01 ADD 371F 52 MSTORE 3720 60 PUSH1 0x20 3722 81 DUP2 3723 01 ADD 3724 90 SWAP1 3725 50 POP 3726 61 PUSH2 0x370f 3729 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @371F memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3724 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x370f label_372A: // Incoming jump from 0x3717, if !(stack[-1] < stack[-4]) // Incoming jump from 0x3717, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Incoming jump from 0x3717, if !(0x00 < memory[stack[-10]:stack[-10] + 0x20]) // Inputs[3] // { // @372F stack[-6] // @372F stack[-5] // @3731 stack[-7] // } 372A 5B JUMPDEST 372B 50 POP 372C 50 POP 372D 50 POP 372E 50 POP 372F 90 SWAP1 3730 50 POP 3731 90 SWAP1 3732 81 DUP2 3733 01 ADD 3734 90 SWAP1 3735 60 PUSH1 0x1f 3737 16 AND 3738 80 DUP1 3739 15 ISZERO 373A 61 PUSH2 0x3757 373D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3734 stack[-7] = stack[-5] + stack[-7] // @3737 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x3757, if !(0x1f & stack[-5]) label_373E: // Incoming jump from 0x373D, if not !(0x1f & stack[-5]) // Inputs[8] // { // @373E stack[-1] // @373F stack[-2] // @3742 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3759 stack[-6] // @375C stack[-3] // @375E stack[-9] // @3761 memory[stack[-9]:stack[-9] + 0x20] // @376A memory[stack[-9]:stack[-9] + 0x20] // } 373E 80 DUP1 373F 82 DUP3 3740 03 SUB 3741 80 DUP1 3742 51 MLOAD 3743 60 PUSH1 0x01 3745 83 DUP4 3746 60 PUSH1 0x20 3748 03 SUB 3749 61 PUSH2 0x0100 374C 0A EXP 374D 03 SUB 374E 19 NOT 374F 16 AND 3750 81 DUP2 3751 52 MSTORE 3752 60 PUSH1 0x20 3754 01 ADD 3755 91 SWAP2 3756 50 POP 3757 5B JUMPDEST 3758 50 POP 3759 84 DUP5 375A 81 DUP2 375B 03 SUB 375C 82 DUP3 375D 52 MSTORE 375E 87 DUP8 375F 81 DUP2 3760 81 DUP2 3761 51 MLOAD 3762 81 DUP2 3763 52 MSTORE 3764 60 PUSH1 0x20 3766 01 ADD 3767 91 SWAP2 3768 50 POP 3769 80 DUP1 376A 51 MLOAD 376B 90 SWAP1 376C 60 PUSH1 0x20 376E 01 ADD 376F 90 SWAP1 3770 80 DUP1 3771 83 DUP4 3772 83 DUP4 3773 60 PUSH1 0x00 3775 5B JUMPDEST 3776 83 DUP4 3777 81 DUP2 3778 10 LT 3779 15 ISZERO 377A 61 PUSH2 0x3790 377D 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @3751 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @375D memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-6] // @3763 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-9]:stack[-9] + 0x20] // @3767 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @376F stack[-1] = 0x20 + stack[-9] // @376F stack[0] = memory[stack[-9]:stack[-9] + 0x20] // @3770 stack[1] = memory[stack[-9]:stack[-9] + 0x20] // @3771 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @3772 stack[3] = 0x20 + stack[-9] // @3773 stack[4] = 0x00 // } // Block ends with conditional jump to 0x3790, if !(0x00 < memory[stack[-9]:stack[-9] + 0x20]) label_377E: // Incoming jump from 0x377D, if not !(0x00 < memory[stack[-9]:stack[-9] + 0x20]) // Incoming jump from 0x377D, if not !(0x00 < memory[stack[-9]:stack[-9] + 0x20]) // Incoming jump from 0x377D, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @377E stack[-1] // @377F stack[-2] // @3781 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3783 stack[-3] // } 377E 80 DUP1 377F 82 DUP3 3780 01 ADD 3781 51 MLOAD 3782 81 DUP2 3783 84 DUP5 3784 01 ADD 3785 52 MSTORE 3786 60 PUSH1 0x20 3788 81 DUP2 3789 01 ADD 378A 90 SWAP1 378B 50 POP 378C 61 PUSH2 0x3775 378F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3785 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @378A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x3775 label_3790: // Incoming jump from 0x377D, if !(0x00 < memory[stack[-9]:stack[-9] + 0x20]) // Incoming jump from 0x377D, if !(0x00 < memory[stack[-9]:stack[-9] + 0x20]) // Incoming jump from 0x377D, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @3795 stack[-6] // @3795 stack[-5] // @3797 stack[-7] // } 3790 5B JUMPDEST 3791 50 POP 3792 50 POP 3793 50 POP 3794 50 POP 3795 90 SWAP1 3796 50 POP 3797 90 SWAP1 3798 81 DUP2 3799 01 ADD 379A 90 SWAP1 379B 60 PUSH1 0x1f 379D 16 AND 379E 80 DUP1 379F 15 ISZERO 37A0 61 PUSH2 0x37bd 37A3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @379A stack[-7] = stack[-5] + stack[-7] // @379D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x37bd, if !(0x1f & stack[-5]) label_37A4: // Incoming jump from 0x37A3, if not !(0x1f & stack[-5]) // Inputs[13] // { // @37A4 stack[-1] // @37A5 stack[-2] // @37A8 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @37BF stack[-12] // @37CC memory[0x40:0x60] // @37D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @37D1 stack[-13] // @37F5 storage[0x09] // @37F6 stack[-20] // @37F7 stack[-17] // @37FA memory[0x40:0x60] // @3812 memory[stack[-20]:stack[-20] + 0x20] // @381B memory[stack[-20]:stack[-20] + 0x20] // } 37A4 80 DUP1 37A5 82 DUP3 37A6 03 SUB 37A7 80 DUP1 37A8 51 MLOAD 37A9 60 PUSH1 0x01 37AB 83 DUP4 37AC 60 PUSH1 0x20 37AE 03 SUB 37AF 61 PUSH2 0x0100 37B2 0A EXP 37B3 03 SUB 37B4 19 NOT 37B5 16 AND 37B6 81 DUP2 37B7 52 MSTORE 37B8 60 PUSH1 0x20 37BA 01 ADD 37BB 91 SWAP2 37BC 50 POP 37BD 5B JUMPDEST 37BE 50 POP 37BF 99 SWAP10 37C0 50 POP 37C1 50 POP 37C2 50 POP 37C3 50 POP 37C4 50 POP 37C5 50 POP 37C6 50 POP 37C7 50 POP 37C8 50 POP 37C9 50 POP 37CA 60 PUSH1 0x40 37CC 51 MLOAD 37CD 80 DUP1 37CE 91 SWAP2 37CF 03 SUB 37D0 90 SWAP1 37D1 A1 LOG1 37D2 7F PUSH32 0x90e6b4da472f8ec07306fc53fed35e13564cad5724e516216889b889b331dbae 37F3 60 PUSH1 0x09 37F5 54 SLOAD 37F6 88 DUP9 37F7 86 DUP7 37F8 60 PUSH1 0x40 37FA 51 MLOAD 37FB 80 DUP1 37FC 84 DUP5 37FD 81 DUP2 37FE 52 MSTORE 37FF 60 PUSH1 0x20 3801 01 ADD 3802 80 DUP1 3803 60 PUSH1 0x20 3805 01 ADD 3806 80 DUP1 3807 60 PUSH1 0x20 3809 01 ADD 380A 83 DUP4 380B 81 DUP2 380C 03 SUB 380D 83 DUP4 380E 52 MSTORE 380F 85 DUP6 3810 81 DUP2 3811 81 DUP2 3812 51 MLOAD 3813 81 DUP2 3814 52 MSTORE 3815 60 PUSH1 0x20 3817 01 ADD 3818 91 SWAP2 3819 50 POP 381A 80 DUP1 381B 51 MLOAD 381C 90 SWAP1 381D 60 PUSH1 0x20 381F 01 ADD 3820 90 SWAP1 3821 80 DUP1 3822 83 DUP4 3823 83 DUP4 3824 60 PUSH1 0x00 3826 5B JUMPDEST 3827 83 DUP4 3828 81 DUP2 3829 10 LT 382A 15 ISZERO 382B 61 PUSH2 0x3841 382E 57 *JUMPI // Stack delta = +1 // Outputs[19] // { // @37B7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @37D1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-13]]); // @37D2 stack[-13] = 0x90e6b4da472f8ec07306fc53fed35e13564cad5724e516216889b889b331dbae // @37F5 stack[-12] = storage[0x09] // @37F6 stack[-11] = stack[-20] // @37F7 stack[-10] = stack[-17] // @37FA stack[-9] = memory[0x40:0x60] // @37FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] // @3801 stack[-8] = 0x20 + memory[0x40:0x60] // @3805 stack[-7] = 0x20 + 0x20 + memory[0x40:0x60] // @380E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @3814 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-20]:stack[-20] + 0x20] // @3818 stack[-6] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3820 stack[-5] = 0x20 + stack[-20] // @3820 stack[-4] = memory[stack[-20]:stack[-20] + 0x20] // @3821 stack[-3] = memory[stack[-20]:stack[-20] + 0x20] // @3822 stack[-2] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3823 stack[-1] = 0x20 + stack[-20] // @3824 stack[0] = 0x00 // } // Block ends with conditional jump to 0x3841, if !(0x00 < memory[stack[-20]:stack[-20] + 0x20]) label_382F: // Incoming jump from 0x382E, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x382E, if not !(0x00 < memory[stack[-20]:stack[-20] + 0x20]) // Incoming jump from 0x382E, if not !(0x00 < memory[stack[-20]:stack[-20] + 0x20]) // Inputs[4] // { // @382F stack[-1] // @3830 stack[-2] // @3832 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3834 stack[-3] // } 382F 80 DUP1 3830 82 DUP3 3831 01 ADD 3832 51 MLOAD 3833 81 DUP2 3834 84 DUP5 3835 01 ADD 3836 52 MSTORE 3837 60 PUSH1 0x20 3839 81 DUP2 383A 01 ADD 383B 90 SWAP1 383C 50 POP 383D 61 PUSH2 0x3826 3840 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3836 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @383B stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x3826 label_3841: // Incoming jump from 0x382E, if !(stack[-1] < stack[-4]) // Incoming jump from 0x382E, if !(0x00 < memory[stack[-20]:stack[-20] + 0x20]) // Incoming jump from 0x382E, if !(0x00 < memory[stack[-20]:stack[-20] + 0x20]) // Inputs[3] // { // @3846 stack[-6] // @3846 stack[-5] // @3848 stack[-7] // } 3841 5B JUMPDEST 3842 50 POP 3843 50 POP 3844 50 POP 3845 50 POP 3846 90 SWAP1 3847 50 POP 3848 90 SWAP1 3849 81 DUP2 384A 01 ADD 384B 90 SWAP1 384C 60 PUSH1 0x1f 384E 16 AND 384F 80 DUP1 3850 15 ISZERO 3851 61 PUSH2 0x386e 3854 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @384B stack[-7] = stack[-5] + stack[-7] // @384E stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x386e, if !(0x1f & stack[-5]) label_3855: // Incoming jump from 0x3854, if not !(0x1f & stack[-5]) // Inputs[8] // { // @3855 stack[-1] // @3856 stack[-2] // @3859 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3870 stack[-5] // @3873 stack[-3] // @3875 stack[-6] // @3878 memory[stack[-6]:stack[-6] + 0x20] // @3881 memory[stack[-6]:stack[-6] + 0x20] // } 3855 80 DUP1 3856 82 DUP3 3857 03 SUB 3858 80 DUP1 3859 51 MLOAD 385A 60 PUSH1 0x01 385C 83 DUP4 385D 60 PUSH1 0x20 385F 03 SUB 3860 61 PUSH2 0x0100 3863 0A EXP 3864 03 SUB 3865 19 NOT 3866 16 AND 3867 81 DUP2 3868 52 MSTORE 3869 60 PUSH1 0x20 386B 01 ADD 386C 91 SWAP2 386D 50 POP 386E 5B JUMPDEST 386F 50 POP 3870 83 DUP4 3871 81 DUP2 3872 03 SUB 3873 82 DUP3 3874 52 MSTORE 3875 84 DUP5 3876 81 DUP2 3877 81 DUP2 3878 51 MLOAD 3879 81 DUP2 387A 52 MSTORE 387B 60 PUSH1 0x20 387D 01 ADD 387E 91 SWAP2 387F 50 POP 3880 80 DUP1 3881 51 MLOAD 3882 90 SWAP1 3883 60 PUSH1 0x20 3885 01 ADD 3886 90 SWAP1 3887 80 DUP1 3888 83 DUP4 3889 83 DUP4 388A 60 PUSH1 0x00 388C 5B JUMPDEST 388D 83 DUP4 388E 81 DUP2 388F 10 LT 3890 15 ISZERO 3891 61 PUSH2 0x38a7 3894 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @3868 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3874 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @387A memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @387E stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @3886 stack[-1] = 0x20 + stack[-6] // @3886 stack[0] = memory[stack[-6]:stack[-6] + 0x20] // @3887 stack[1] = memory[stack[-6]:stack[-6] + 0x20] // @3888 stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @3889 stack[3] = 0x20 + stack[-6] // @388A stack[4] = 0x00 // } // Block ends with conditional jump to 0x38a7, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_3895: // Incoming jump from 0x3894, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3894, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3894, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3895 stack[-1] // @3896 stack[-2] // @3898 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @389A stack[-3] // } 3895 80 DUP1 3896 82 DUP3 3897 01 ADD 3898 51 MLOAD 3899 81 DUP2 389A 84 DUP5 389B 01 ADD 389C 52 MSTORE 389D 60 PUSH1 0x20 389F 81 DUP2 38A0 01 ADD 38A1 90 SWAP1 38A2 50 POP 38A3 61 PUSH2 0x388c 38A6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @389C memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @38A1 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x388c label_38A7: // Incoming jump from 0x3894, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3894, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3894, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @38AC stack[-6] // @38AC stack[-5] // @38AE stack[-7] // } 38A7 5B JUMPDEST 38A8 50 POP 38A9 50 POP 38AA 50 POP 38AB 50 POP 38AC 90 SWAP1 38AD 50 POP 38AE 90 SWAP1 38AF 81 DUP2 38B0 01 ADD 38B1 90 SWAP1 38B2 60 PUSH1 0x1f 38B4 16 AND 38B5 80 DUP1 38B6 15 ISZERO 38B7 61 PUSH2 0x38d4 38BA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @38B1 stack[-7] = stack[-5] + stack[-7] // @38B4 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x38d4, if !(0x1f & stack[-5]) label_38BB: // Incoming jump from 0x38BA, if not !(0x1f & stack[-5]) // Inputs[13] // { // @38BB stack[-1] // @38BC stack[-2] // @38BF memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @38D6 stack[-8] // @38DF memory[0x40:0x60] // @38E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @38E4 stack[-9] // @3908 storage[0x09] // @3909 stack[-22] // @390A stack[-21] // @390D memory[0x40:0x60] // @3925 memory[stack[-22]:stack[-22] + 0x20] // @392E memory[stack[-22]:stack[-22] + 0x20] // } 38BB 80 DUP1 38BC 82 DUP3 38BD 03 SUB 38BE 80 DUP1 38BF 51 MLOAD 38C0 60 PUSH1 0x01 38C2 83 DUP4 38C3 60 PUSH1 0x20 38C5 03 SUB 38C6 61 PUSH2 0x0100 38C9 0A EXP 38CA 03 SUB 38CB 19 NOT 38CC 16 AND 38CD 81 DUP2 38CE 52 MSTORE 38CF 60 PUSH1 0x20 38D1 01 ADD 38D2 91 SWAP2 38D3 50 POP 38D4 5B JUMPDEST 38D5 50 POP 38D6 95 SWAP6 38D7 50 POP 38D8 50 POP 38D9 50 POP 38DA 50 POP 38DB 50 POP 38DC 50 POP 38DD 60 PUSH1 0x40 38DF 51 MLOAD 38E0 80 DUP1 38E1 91 SWAP2 38E2 03 SUB 38E3 90 SWAP1 38E4 A1 LOG1 38E5 7F PUSH32 0x554b8ec88e9796df3410a6b1e9233856c2613d4b93eb5a37e34224567d849969 3906 60 PUSH1 0x09 3908 54 SLOAD 3909 8E DUP15 390A 8E DUP15 390B 60 PUSH1 0x40 390D 51 MLOAD 390E 80 DUP1 390F 84 DUP5 3910 81 DUP2 3911 52 MSTORE 3912 60 PUSH1 0x20 3914 01 ADD 3915 80 DUP1 3916 60 PUSH1 0x20 3918 01 ADD 3919 80 DUP1 391A 60 PUSH1 0x20 391C 01 ADD 391D 83 DUP4 391E 81 DUP2 391F 03 SUB 3920 83 DUP4 3921 52 MSTORE 3922 85 DUP6 3923 81 DUP2 3924 81 DUP2 3925 51 MLOAD 3926 81 DUP2 3927 52 MSTORE 3928 60 PUSH1 0x20 392A 01 ADD 392B 91 SWAP2 392C 50 POP 392D 80 DUP1 392E 51 MLOAD 392F 90 SWAP1 3930 60 PUSH1 0x20 3932 01 ADD 3933 90 SWAP1 3934 80 DUP1 3935 83 DUP4 3936 83 DUP4 3937 60 PUSH1 0x00 3939 5B JUMPDEST 393A 83 DUP4 393B 81 DUP2 393C 10 LT 393D 15 ISZERO 393E 61 PUSH2 0x3954 3941 57 *JUMPI // Stack delta = +5 // Outputs[19] // { // @38CE memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @38E4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-9]]); // @38E5 stack[-9] = 0x554b8ec88e9796df3410a6b1e9233856c2613d4b93eb5a37e34224567d849969 // @3908 stack[-8] = storage[0x09] // @3909 stack[-7] = stack[-22] // @390A stack[-6] = stack[-21] // @390D stack[-5] = memory[0x40:0x60] // @3911 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] // @3914 stack[-4] = 0x20 + memory[0x40:0x60] // @3918 stack[-3] = 0x20 + 0x20 + memory[0x40:0x60] // @3921 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @3927 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-22]:stack[-22] + 0x20] // @392B stack[-2] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3933 stack[0] = memory[stack[-22]:stack[-22] + 0x20] // @3933 stack[-1] = 0x20 + stack[-22] // @3934 stack[1] = memory[stack[-22]:stack[-22] + 0x20] // @3935 stack[2] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @3936 stack[3] = 0x20 + stack[-22] // @3937 stack[4] = 0x00 // } // Block ends with conditional jump to 0x3954, if !(0x00 < memory[stack[-22]:stack[-22] + 0x20]) label_3942: // Incoming jump from 0x3941, if not !(0x00 < memory[stack[-22]:stack[-22] + 0x20]) // Incoming jump from 0x3941, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x3941, if not !(0x00 < memory[stack[-22]:stack[-22] + 0x20]) // Inputs[4] // { // @3942 stack[-1] // @3943 stack[-2] // @3945 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3947 stack[-3] // } 3942 80 DUP1 3943 82 DUP3 3944 01 ADD 3945 51 MLOAD 3946 81 DUP2 3947 84 DUP5 3948 01 ADD 3949 52 MSTORE 394A 60 PUSH1 0x20 394C 81 DUP2 394D 01 ADD 394E 90 SWAP1 394F 50 POP 3950 61 PUSH2 0x3939 3953 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3949 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @394E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x3939 label_3954: // Incoming jump from 0x3941, if !(0x00 < memory[stack[-22]:stack[-22] + 0x20]) // Incoming jump from 0x3941, if !(stack[-1] < stack[-4]) // Incoming jump from 0x3941, if !(0x00 < memory[stack[-22]:stack[-22] + 0x20]) // Inputs[3] // { // @3959 stack[-5] // @3959 stack[-6] // @395B stack[-7] // } 3954 5B JUMPDEST 3955 50 POP 3956 50 POP 3957 50 POP 3958 50 POP 3959 90 SWAP1 395A 50 POP 395B 90 SWAP1 395C 81 DUP2 395D 01 ADD 395E 90 SWAP1 395F 60 PUSH1 0x1f 3961 16 AND 3962 80 DUP1 3963 15 ISZERO 3964 61 PUSH2 0x3981 3967 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @395E stack[-7] = stack[-5] + stack[-7] // @3961 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x3981, if !(0x1f & stack[-5]) label_3968: // Incoming jump from 0x3967, if not !(0x1f & stack[-5]) // Inputs[8] // { // @3968 stack[-1] // @3969 stack[-2] // @396C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3983 stack[-5] // @3986 stack[-3] // @3988 stack[-6] // @398B memory[stack[-6]:stack[-6] + 0x20] // @3994 memory[stack[-6]:stack[-6] + 0x20] // } 3968 80 DUP1 3969 82 DUP3 396A 03 SUB 396B 80 DUP1 396C 51 MLOAD 396D 60 PUSH1 0x01 396F 83 DUP4 3970 60 PUSH1 0x20 3972 03 SUB 3973 61 PUSH2 0x0100 3976 0A EXP 3977 03 SUB 3978 19 NOT 3979 16 AND 397A 81 DUP2 397B 52 MSTORE 397C 60 PUSH1 0x20 397E 01 ADD 397F 91 SWAP2 3980 50 POP 3981 5B JUMPDEST 3982 50 POP 3983 83 DUP4 3984 81 DUP2 3985 03 SUB 3986 82 DUP3 3987 52 MSTORE 3988 84 DUP5 3989 81 DUP2 398A 81 DUP2 398B 51 MLOAD 398C 81 DUP2 398D 52 MSTORE 398E 60 PUSH1 0x20 3990 01 ADD 3991 91 SWAP2 3992 50 POP 3993 80 DUP1 3994 51 MLOAD 3995 90 SWAP1 3996 60 PUSH1 0x20 3998 01 ADD 3999 90 SWAP1 399A 80 DUP1 399B 83 DUP4 399C 83 DUP4 399D 60 PUSH1 0x00 399F 5B JUMPDEST 39A0 83 DUP4 39A1 81 DUP2 39A2 10 LT 39A3 15 ISZERO 39A4 61 PUSH2 0x39ba 39A7 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @397B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3987 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @398D memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @3991 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @3999 stack[-1] = 0x20 + stack[-6] // @3999 stack[0] = memory[stack[-6]:stack[-6] + 0x20] // @399A stack[1] = memory[stack[-6]:stack[-6] + 0x20] // @399B stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @399C stack[3] = 0x20 + stack[-6] // @399D stack[4] = 0x00 // } // Block ends with conditional jump to 0x39ba, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_39A8: // Incoming jump from 0x39A7, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x39A7, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x39A7, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @39A8 stack[-1] // @39A9 stack[-2] // @39AB memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @39AD stack[-3] // } 39A8 80 DUP1 39A9 82 DUP3 39AA 01 ADD 39AB 51 MLOAD 39AC 81 DUP2 39AD 84 DUP5 39AE 01 ADD 39AF 52 MSTORE 39B0 60 PUSH1 0x20 39B2 81 DUP2 39B3 01 ADD 39B4 90 SWAP1 39B5 50 POP 39B6 61 PUSH2 0x399f 39B9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @39AF memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @39B4 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x399f label_39BA: // Incoming jump from 0x39A7, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x39A7, if !(stack[-1] < stack[-4]) // Incoming jump from 0x39A7, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @39BF stack[-6] // @39BF stack[-5] // @39C1 stack[-7] // } 39BA 5B JUMPDEST 39BB 50 POP 39BC 50 POP 39BD 50 POP 39BE 50 POP 39BF 90 SWAP1 39C0 50 POP 39C1 90 SWAP1 39C2 81 DUP2 39C3 01 ADD 39C4 90 SWAP1 39C5 60 PUSH1 0x1f 39C7 16 AND 39C8 80 DUP1 39C9 15 ISZERO 39CA 61 PUSH2 0x39e7 39CD 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @39C4 stack[-7] = stack[-5] + stack[-7] // @39C7 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x39e7, if !(0x1f & stack[-5]) label_39CE: // Incoming jump from 0x39CD, if not !(0x1f & stack[-5]) // Inputs[14] // { // @39CE stack[-1] // @39CF stack[-2] // @39D2 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @39E9 stack[-8] // @39F2 memory[0x40:0x60] // @39F7 stack[-9] // @39F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @3A1B storage[0x09] // @3A1C stack[-15] // @3A22 storage[0x0d] // @3A42 memory[0x40:0x60] // @3A89 memory[0x40:0x60] // @3A8E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @3A90 stack[-11] // } 39CE 80 DUP1 39CF 82 DUP3 39D0 03 SUB 39D1 80 DUP1 39D2 51 MLOAD 39D3 60 PUSH1 0x01 39D5 83 DUP4 39D6 60 PUSH1 0x20 39D8 03 SUB 39D9 61 PUSH2 0x0100 39DC 0A EXP 39DD 03 SUB 39DE 19 NOT 39DF 16 AND 39E0 81 DUP2 39E1 52 MSTORE 39E2 60 PUSH1 0x20 39E4 01 ADD 39E5 91 SWAP2 39E6 50 POP 39E7 5B JUMPDEST 39E8 50 POP 39E9 95 SWAP6 39EA 50 POP 39EB 50 POP 39EC 50 POP 39ED 50 POP 39EE 50 POP 39EF 50 POP 39F0 60 PUSH1 0x40 39F2 51 MLOAD 39F3 80 DUP1 39F4 91 SWAP2 39F5 03 SUB 39F6 90 SWAP1 39F7 A1 LOG1 39F8 7F PUSH32 0x423231a1c91c63d9ab32b93c11c2235d0be62c1f5a0906840e38f2685f2cf928 3A19 60 PUSH1 0x09 3A1B 54 SLOAD 3A1C 87 DUP8 3A1D 60 PUSH1 0x0d 3A1F 60 PUSH1 0x00 3A21 90 SWAP1 3A22 54 SLOAD 3A23 90 SWAP1 3A24 61 PUSH2 0x0100 3A27 0A EXP 3A28 90 SWAP1 3A29 04 DIV 3A2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A3F 16 AND 3A40 60 PUSH1 0x40 3A42 51 MLOAD 3A43 80 DUP1 3A44 84 DUP5 3A45 81 DUP2 3A46 52 MSTORE 3A47 60 PUSH1 0x20 3A49 01 ADD 3A4A 83 DUP4 3A4B 81 DUP2 3A4C 52 MSTORE 3A4D 60 PUSH1 0x20 3A4F 01 ADD 3A50 82 DUP3 3A51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A66 16 AND 3A67 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A7C 16 AND 3A7D 81 DUP2 3A7E 52 MSTORE 3A7F 60 PUSH1 0x20 3A81 01 ADD 3A82 93 SWAP4 3A83 50 POP 3A84 50 POP 3A85 50 POP 3A86 50 POP 3A87 60 PUSH1 0x40 3A89 51 MLOAD 3A8A 80 DUP1 3A8B 91 SWAP2 3A8C 03 SUB 3A8D 90 SWAP1 3A8E A1 LOG1 3A8F 50 POP 3A90 80 DUP1 3A91 80 DUP1 3A92 60 PUSH1 0x01 3A94 01 ADD 3A95 91 SWAP2 3A96 50 POP 3A97 50 POP 3A98 61 PUSH2 0x3454 3A9B 56 *JUMP // Stack delta = -10 // Outputs[7] // { // @39E1 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @39F7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-9]]); // @3A46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] // @3A4C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-15] // @3A7E memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0d] / 0x0100 ** 0x00 // @3A8E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x423231a1c91c63d9ab32b93c11c2235d0be62c1f5a0906840e38f2685f2cf928]); // @3A95 stack[-11] = 0x01 + stack[-11] // } // Block ends with unconditional jump to 0x3454 label_3A9C: // Incoming jump from 0x345E, if 0xff & stack[-1] > stack[-4] // Incoming jump from 0x345E, if 0xff & 0x01 > stack[-4] // Inputs[1] { @3AA9 stack[-13] } 3A9C 5B JUMPDEST 3A9D 50 POP 3A9E 50 POP 3A9F 50 POP 3AA0 50 POP 3AA1 50 POP 3AA2 50 POP 3AA3 50 POP 3AA4 50 POP 3AA5 50 POP 3AA6 50 POP 3AA7 50 POP 3AA8 50 POP 3AA9 56 *JUMP // Stack delta = -13 // Block ends with unconditional jump to stack[-13] label_3AAA: // Incoming call from 0x1937, returns to 0x1938 // Inputs[3] // { // @3AAE storage[0x0a] // @3ACF memory[0x40:0x60] // @3AE2 storage[0x0a] // } 3AAA 5B JUMPDEST 3AAB 60 PUSH1 0x0a 3AAD 80 DUP1 3AAE 54 SLOAD 3AAF 60 PUSH1 0x01 3AB1 81 DUP2 3AB2 60 PUSH1 0x01 3AB4 16 AND 3AB5 15 ISZERO 3AB6 61 PUSH2 0x0100 3AB9 02 MUL 3ABA 03 SUB 3ABB 16 AND 3ABC 60 PUSH1 0x02 3ABE 90 SWAP1 3ABF 04 DIV 3AC0 80 DUP1 3AC1 60 PUSH1 0x1f 3AC3 01 ADD 3AC4 60 PUSH1 0x20 3AC6 80 DUP1 3AC7 91 SWAP2 3AC8 04 DIV 3AC9 02 MUL 3ACA 60 PUSH1 0x20 3ACC 01 ADD 3ACD 60 PUSH1 0x40 3ACF 51 MLOAD 3AD0 90 SWAP1 3AD1 81 DUP2 3AD2 01 ADD 3AD3 60 PUSH1 0x40 3AD5 52 MSTORE 3AD6 80 DUP1 3AD7 92 SWAP3 3AD8 91 SWAP2 3AD9 90 SWAP1 3ADA 81 DUP2 3ADB 81 DUP2 3ADC 52 MSTORE 3ADD 60 PUSH1 0x20 3ADF 01 ADD 3AE0 82 DUP3 3AE1 80 DUP1 3AE2 54 SLOAD 3AE3 60 PUSH1 0x01 3AE5 81 DUP2 3AE6 60 PUSH1 0x01 3AE8 16 AND 3AE9 15 ISZERO 3AEA 61 PUSH2 0x0100 3AED 02 MUL 3AEE 03 SUB 3AEF 16 AND 3AF0 60 PUSH1 0x02 3AF2 90 SWAP1 3AF3 04 DIV 3AF4 80 DUP1 3AF5 15 ISZERO 3AF6 61 PUSH2 0x3b40 3AF9 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @3AD5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) / 0x20 * 0x20 // @3AD7 stack[0] = memory[0x40:0x60] // @3AD8 stack[1] = 0x0a // @3AD9 stack[2] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // @3ADC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // @3ADF stack[3] = 0x20 + memory[0x40:0x60] // @3AE0 stack[4] = 0x0a // @3AF3 stack[5] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // } // Block ends with conditional jump to 0x3b40, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) label_3AFA: // Incoming jump from 0x3AF9, if not !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Inputs[1] { @3AFA stack[-1] } 3AFA 80 DUP1 3AFB 60 PUSH1 0x1f 3AFD 10 LT 3AFE 61 PUSH2 0x3b15 3B01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3b15, if 0x1f < stack[-1] label_3B02: // Incoming jump from 0x3B01, if not 0x1f < stack[-1] // Inputs[4] // { // @3B06 stack[-2] // @3B07 storage[stack[-2]] // @3B0A stack[-3] // @3B0C stack[-1] // } 3B02 61 PUSH2 0x0100 3B05 80 DUP1 3B06 83 DUP4 3B07 54 SLOAD 3B08 04 DIV 3B09 02 MUL 3B0A 83 DUP4 3B0B 52 MSTORE 3B0C 91 SWAP2 3B0D 60 PUSH1 0x20 3B0F 01 ADD 3B10 91 SWAP2 3B11 61 PUSH2 0x3b40 3B14 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @3B0B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @3B10 stack[-1] = stack[-1] // @3B10 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x3b40 label_3B15: // Incoming jump from 0x3B01, if 0x1f < stack[-1] // Inputs[5] // { // @3B16 stack[-3] // @3B17 stack[-1] // @3B19 stack[-2] // @3B21 memory[0x00:0x20] // @3B25 storage[keccak256(memory[0x00:0x20])] // } 3B15 5B JUMPDEST 3B16 82 DUP3 3B17 01 ADD 3B18 91 SWAP2 3B19 90 SWAP1 3B1A 60 PUSH1 0x00 3B1C 52 MSTORE 3B1D 60 PUSH1 0x20 3B1F 60 PUSH1 0x00 3B21 20 SHA3 3B22 90 SWAP1 3B23 5B JUMPDEST 3B24 81 DUP2 3B25 54 SLOAD 3B26 81 DUP2 3B27 52 MSTORE 3B28 90 SWAP1 3B29 60 PUSH1 0x01 3B2B 01 ADD 3B2C 90 SWAP1 3B2D 60 PUSH1 0x20 3B2F 01 ADD 3B30 80 DUP1 3B31 83 DUP4 3B32 11 GT 3B33 61 PUSH2 0x3b23 3B36 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @3B18 stack[-3] = stack[-3] + stack[-1] // @3B1C memory[0x00:0x20] = stack[-2] // @3B27 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @3B2C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @3B2F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x3b23, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_3B37: // Incoming jump from 0x3B36, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x3B36, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @3B37 stack[-3] // @3B38 stack[-1] // } 3B37 82 DUP3 3B38 90 SWAP1 3B39 03 SUB 3B3A 60 PUSH1 0x1f 3B3C 16 AND 3B3D 82 DUP3 3B3E 01 ADD 3B3F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @3B3F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @3B3F stack[-1] = stack[-3] // } // Block continues label_3B40: // Incoming jump from 0x3B3F // Incoming jump from 0x3AF9, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Incoming jump from 0x3B14 // Inputs[1] { @3B46 stack[-7] } 3B40 5B JUMPDEST 3B41 50 POP 3B42 50 POP 3B43 50 POP 3B44 50 POP 3B45 50 POP 3B46 81 DUP2 3B47 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_3B48: // Incoming call from 0x3BCC, returns to 0x3BCD // Incoming call from 0x4538, returns to 0x4539 // Incoming call from 0x1AEC, returns to 0x1AED // Inputs[4] // { // @3B50 stack[-1] // @3B5E memory[0x00:0x40] // @3B62 storage[keccak256(memory[0x00:0x40])] // @3BB6 stack[-2] // } 3B48 5B JUMPDEST 3B49 60 PUSH1 0x00 3B4B 80 DUP1 3B4C 60 PUSH1 0x01 3B4E 60 PUSH1 0x00 3B50 84 DUP5 3B51 81 DUP2 3B52 52 MSTORE 3B53 60 PUSH1 0x20 3B55 01 ADD 3B56 90 SWAP1 3B57 81 DUP2 3B58 52 MSTORE 3B59 60 PUSH1 0x20 3B5B 01 ADD 3B5C 60 PUSH1 0x00 3B5E 20 SHA3 3B5F 60 PUSH1 0x00 3B61 90 SWAP1 3B62 54 SLOAD 3B63 90 SWAP1 3B64 61 PUSH2 0x0100 3B67 0A EXP 3B68 90 SWAP1 3B69 04 DIV 3B6A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B7F 16 AND 3B80 90 SWAP1 3B81 50 POP 3B82 60 PUSH1 0x00 3B84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3B99 16 AND 3B9A 81 DUP2 3B9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3BB0 16 AND 3BB1 14 EQ 3BB2 15 ISZERO 3BB3 91 SWAP2 3BB4 50 POP 3BB5 50 POP 3BB6 91 SWAP2 3BB7 90 SWAP1 3BB8 50 POP 3BB9 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @3B52 memory[0x00:0x20] = stack[-1] // @3B58 memory[0x20:0x40] = 0x01 // @3BB6 stack[-2] = !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // } // Block ends with unconditional jump to stack[-2] label_3BBA: // Incoming call from 0x283E, returns to 0x283F // Incoming call from 0x2E75, returns to 0x2E76 // Incoming call from 0x2C67, returns to 0x2C68 // Incoming call from 0x1C56, returns to 0x1C57 // Incoming call from 0x2D14, returns to 0x2D15 // Incoming call from 0x2BB9, returns to 0x2BBA // Incoming call from 0x47EF, returns to 0x47F0 // Incoming call from 0x1C2D, returns to 0x1C2E // Incoming call from 0x1E0C, returns to 0x1E0D // Inputs[2] // { // @3BBD msg.sender // @3BC0 stack[-1] // } 3BBA 5B JUMPDEST 3BBB 60 PUSH1 0x00 3BBD 33 CALLER 3BBE 90 SWAP1 3BBF 50 POP 3BC0 90 SWAP1 3BC1 56 *JUMP // Stack delta = +0 // Outputs[1] { @3BC0 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_3BC2: // Incoming jump from 0x1E12 // Incoming jump from 0x2E7B // Inputs[1] { @3BC8 stack[-1] } 3BC2 5B JUMPDEST 3BC3 60 PUSH1 0x00 3BC5 61 PUSH2 0x3bcd 3BC8 82 DUP3 3BC9 61 PUSH2 0x3b48 3BCC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3BC3 stack[0] = 0x00 // @3BC5 stack[1] = 0x3bcd // @3BC8 stack[2] = stack[-1] // } // Block ends with call to 0x3b48, returns to 0x3BCD label_3BCD: // Incoming return from call to 0x3B48 at 0x3BCC // Inputs[1] { @3BD1 stack[-1] } 3BCD 5B JUMPDEST 3BCE 61 PUSH2 0x3c22 3BD1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3c22, if stack[-1] label_3BD2: // Incoming jump from 0x3BD1, if not stack[-1] // Inputs[3] // { // @3BD4 memory[0x40:0x60] // @3C1C memory[0x40:0x60] // @3C21 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3BD2 60 PUSH1 0x40 3BD4 51 MLOAD 3BD5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3BF6 81 DUP2 3BF7 52 MSTORE 3BF8 60 PUSH1 0x04 3BFA 01 ADD 3BFB 80 DUP1 3BFC 80 DUP1 3BFD 60 PUSH1 0x20 3BFF 01 ADD 3C00 82 DUP3 3C01 81 DUP2 3C02 03 SUB 3C03 82 DUP3 3C04 52 MSTORE 3C05 60 PUSH1 0x2c 3C07 81 DUP2 3C08 52 MSTORE 3C09 60 PUSH1 0x20 3C0B 01 ADD 3C0C 80 DUP1 3C0D 61 PUSH2 0x4c03 3C10 60 PUSH1 0x2c 3C12 91 SWAP2 3C13 39 CODECOPY 3C14 60 PUSH1 0x40 3C16 01 ADD 3C17 91 SWAP2 3C18 50 POP 3C19 50 POP 3C1A 60 PUSH1 0x40 3C1C 51 MLOAD 3C1D 80 DUP1 3C1E 91 SWAP2 3C1F 03 SUB 3C20 90 SWAP1 3C21 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3BF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3C04 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3C08 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @3C13 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x4c03:0x4c2f] // @3C21 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3C22: // Incoming jump from 0x3BD1, if stack[-1] // Inputs[1] { @3C28 stack[-2] } 3C22 5B JUMPDEST 3C23 60 PUSH1 0x00 3C25 61 PUSH2 0x3c2d 3C28 83 DUP4 3C29 61 PUSH2 0x2456 3C2C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3C23 stack[0] = 0x00 // @3C25 stack[1] = 0x3c2d // @3C28 stack[2] = stack[-2] // } // Block ends with call to 0x2456, returns to 0x3C2D label_3C2D: // Incoming return from call to 0x2456 at 0x3C2C // Inputs[3] // { // @3C2E stack[-2] // @3C2E stack[-1] // @3C47 stack[-5] // } 3C2D 5B JUMPDEST 3C2E 90 SWAP1 3C2F 50 POP 3C30 80 DUP1 3C31 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C46 16 AND 3C47 84 DUP5 3C48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C5D 16 AND 3C5E 14 EQ 3C5F 80 DUP1 3C60 61 PUSH2 0x3c9c 3C63 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3C2E stack[-2] = stack[-1] // @3C5E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x3c9c, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_3C64: // Incoming jump from 0x3C63, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @3C65 stack[-5] // @3C7F stack[-4] // } 3C64 50 POP 3C65 83 DUP4 3C66 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C7B 16 AND 3C7C 61 PUSH2 0x3c84 3C7F 84 DUP5 3C80 61 PUSH2 0x1ae2 3C83 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3C7B stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3C7C stack[0] = 0x3c84 // @3C7F stack[1] = stack[-4] // } // Block ends with call to 0x1ae2, returns to 0x3C84 label_3C84: // Incoming return from call to 0x1AE2 at 0x3C83 // Inputs[2] // { // @3C9A stack[-1] // @3C9B stack[-2] // } 3C84 5B JUMPDEST 3C85 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C9A 16 AND 3C9B 14 EQ // Stack delta = -1 // Outputs[1] { @3C9B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_3C9C: // Incoming jump from 0x3C63, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x3C9B // Inputs[1] { @3C9D stack[-1] } 3C9C 5B JUMPDEST 3C9D 80 DUP1 3C9E 61 PUSH2 0x3cad 3CA1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3cad, if stack[-1] label_3CA2: // Incoming jump from 0x3CA1, if not stack[-1] // Inputs[2] // { // @3CA6 stack[-2] // @3CA7 stack[-5] // } 3CA2 50 POP 3CA3 61 PUSH2 0x3cac 3CA6 81 DUP2 3CA7 85 DUP6 3CA8 61 PUSH2 0x30d9 3CAB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3CA3 stack[-1] = 0x3cac // @3CA6 stack[0] = stack[-2] // @3CA7 stack[1] = stack[-5] // } // Block ends with call to 0x30d9, returns to 0x3CAC label_3CAC: // Incoming return from call to 0x30D9 at 0x3CAB 3CAC 5B JUMPDEST // Stack delta = +0 // Block continues label_3CAD: // Incoming jump from 0x3CAC // Incoming jump from 0x3CA1, if stack[-1] // Inputs[4] // { // @3CAE stack[-1] // @3CAE stack[-3] // @3CB1 stack[-6] // @3CB2 stack[-5] // } 3CAD 5B JUMPDEST 3CAE 91 SWAP2 3CAF 50 POP 3CB0 50 POP 3CB1 92 SWAP3 3CB2 91 SWAP2 3CB3 50 POP 3CB4 50 POP 3CB5 56 *JUMP // Stack delta = -5 // Outputs[1] { @3CB1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_3CB6: // Incoming call from 0x3F29, returns to 0x3F2A // Incoming call from 0x1E72, returns to 0x1E73 // Inputs[2] // { // @3CB7 stack[-3] // @3CD1 stack[-1] // } 3CB6 5B JUMPDEST 3CB7 82 DUP3 3CB8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3CCD 16 AND 3CCE 61 PUSH2 0x3cd6 3CD1 82 DUP3 3CD2 61 PUSH2 0x2456 3CD5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3CCD stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @3CCE stack[1] = 0x3cd6 // @3CD1 stack[2] = stack[-1] // } // Block ends with call to 0x2456, returns to 0x3CD6 label_3CD6: // Incoming return from call to 0x2456 at 0x3CD5 // Inputs[2] // { // @3CEC stack[-1] // @3CED stack[-2] // } 3CD6 5B JUMPDEST 3CD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3CEC 16 AND 3CED 14 EQ 3CEE 61 PUSH2 0x3d42 3CF1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3d42, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_3CF2: // Incoming jump from 0x3CF1, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @3CF4 memory[0x40:0x60] // @3D3C memory[0x40:0x60] // @3D41 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3CF2 60 PUSH1 0x40 3CF4 51 MLOAD 3CF5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3D16 81 DUP2 3D17 52 MSTORE 3D18 60 PUSH1 0x04 3D1A 01 ADD 3D1B 80 DUP1 3D1C 80 DUP1 3D1D 60 PUSH1 0x20 3D1F 01 ADD 3D20 82 DUP3 3D21 81 DUP2 3D22 03 SUB 3D23 82 DUP3 3D24 52 MSTORE 3D25 60 PUSH1 0x29 3D27 81 DUP2 3D28 52 MSTORE 3D29 60 PUSH1 0x20 3D2B 01 ADD 3D2C 80 DUP1 3D2D 61 PUSH2 0x4ce6 3D30 60 PUSH1 0x29 3D32 91 SWAP2 3D33 39 CODECOPY 3D34 60 PUSH1 0x40 3D36 01 ADD 3D37 91 SWAP2 3D38 50 POP 3D39 50 POP 3D3A 60 PUSH1 0x40 3D3C 51 MLOAD 3D3D 80 DUP1 3D3E 91 SWAP2 3D3F 03 SUB 3D40 90 SWAP1 3D41 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3D17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3D24 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3D28 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @3D33 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x4ce6:0x4d0f] // @3D41 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3D42: // Incoming jump from 0x3CF1, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @3D5B stack[-2] } 3D42 5B JUMPDEST 3D43 60 PUSH1 0x00 3D45 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3D5A 16 AND 3D5B 82 DUP3 3D5C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3D71 16 AND 3D72 14 EQ 3D73 15 ISZERO 3D74 61 PUSH2 0x3dc8 3D77 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3dc8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_3D78: // Incoming jump from 0x3D77, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @3D7A memory[0x40:0x60] // @3DC2 memory[0x40:0x60] // @3DC7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3D78 60 PUSH1 0x40 3D7A 51 MLOAD 3D7B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3D9C 81 DUP2 3D9D 52 MSTORE 3D9E 60 PUSH1 0x04 3DA0 01 ADD 3DA1 80 DUP1 3DA2 80 DUP1 3DA3 60 PUSH1 0x20 3DA5 01 ADD 3DA6 82 DUP3 3DA7 81 DUP2 3DA8 03 SUB 3DA9 82 DUP3 3DAA 52 MSTORE 3DAB 60 PUSH1 0x24 3DAD 81 DUP2 3DAE 52 MSTORE 3DAF 60 PUSH1 0x20 3DB1 01 ADD 3DB2 80 DUP1 3DB3 61 PUSH2 0x4bdf 3DB6 60 PUSH1 0x24 3DB8 91 SWAP2 3DB9 39 CODECOPY 3DBA 60 PUSH1 0x40 3DBC 01 ADD 3DBD 91 SWAP2 3DBE 50 POP 3DBF 50 POP 3DC0 60 PUSH1 0x40 3DC2 51 MLOAD 3DC3 80 DUP1 3DC4 91 SWAP2 3DC5 03 SUB 3DC6 90 SWAP1 3DC7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3D9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3DAA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3DAE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @3DB9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x4bdf:0x4c03] // @3DC7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3DC8: // Incoming jump from 0x3D77, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @3DCC stack[-1] } 3DC8 5B JUMPDEST 3DC9 61 PUSH2 0x3dd1 3DCC 81 DUP2 3DCD 61 PUSH2 0x46a5 3DD0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3DC9 stack[0] = 0x3dd1 // @3DCC stack[1] = stack[-1] // } // Block ends with call to 0x46a5, returns to 0x3DD1 label_3DD1: // Incoming return from call to 0x46A5 at 0x3DD0 // Inputs[2] // { // @3DD9 stack[-3] // @3E13 memory[0x00:0x40] // } 3DD1 5B JUMPDEST 3DD2 61 PUSH2 0x3e18 3DD5 60 PUSH1 0x03 3DD7 60 PUSH1 0x00 3DD9 85 DUP6 3DDA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3DEF 16 AND 3DF0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E05 16 AND 3E06 81 DUP2 3E07 52 MSTORE 3E08 60 PUSH1 0x20 3E0A 01 ADD 3E0B 90 SWAP1 3E0C 81 DUP2 3E0D 52 MSTORE 3E0E 60 PUSH1 0x20 3E10 01 ADD 3E11 60 PUSH1 0x00 3E13 20 SHA3 3E14 61 PUSH2 0x4763 3E17 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3DD2 stack[0] = 0x3e18 // @3E07 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @3E0D memory[0x20:0x40] = 0x03 // @3E13 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x4763, returns to 0x3E18 label_3E18: // Incoming return from call to 0x4763 at 0x3E17 // Inputs[2] // { // @3E20 stack[-2] // @3E5A memory[0x00:0x40] // } 3E18 5B JUMPDEST 3E19 61 PUSH2 0x3e5f 3E1C 60 PUSH1 0x03 3E1E 60 PUSH1 0x00 3E20 84 DUP5 3E21 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E36 16 AND 3E37 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E4C 16 AND 3E4D 81 DUP2 3E4E 52 MSTORE 3E4F 60 PUSH1 0x20 3E51 01 ADD 3E52 90 SWAP1 3E53 81 DUP2 3E54 52 MSTORE 3E55 60 PUSH1 0x20 3E57 01 ADD 3E58 60 PUSH1 0x00 3E5A 20 SHA3 3E5B 61 PUSH2 0x4786 3E5E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3E19 stack[0] = 0x3e5f // @3E4E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @3E54 memory[0x20:0x40] = 0x03 // @3E5A stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x4786, returns to 0x3E5F label_3E5F: // Incoming return from call to 0x4786 at 0x3E5E // Inputs[9] // { // @3E60 stack[-2] // @3E65 stack[-1] // @3E73 memory[0x00:0x40] // @3E7B storage[keccak256(memory[0x00:0x40])] // @3ECA stack[-3] // @3F04 memory[0x40:0x60] // @3F07 memory[0x40:0x60] // @3F0C memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @3F10 stack[-4] // } 3E5F 5B JUMPDEST 3E60 81 DUP2 3E61 60 PUSH1 0x01 3E63 60 PUSH1 0x00 3E65 83 DUP4 3E66 81 DUP2 3E67 52 MSTORE 3E68 60 PUSH1 0x20 3E6A 01 ADD 3E6B 90 SWAP1 3E6C 81 DUP2 3E6D 52 MSTORE 3E6E 60 PUSH1 0x20 3E70 01 ADD 3E71 60 PUSH1 0x00 3E73 20 SHA3 3E74 60 PUSH1 0x00 3E76 61 PUSH2 0x0100 3E79 0A EXP 3E7A 81 DUP2 3E7B 54 SLOAD 3E7C 81 DUP2 3E7D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E92 02 MUL 3E93 19 NOT 3E94 16 AND 3E95 90 SWAP1 3E96 83 DUP4 3E97 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3EAC 16 AND 3EAD 02 MUL 3EAE 17 OR 3EAF 90 SWAP1 3EB0 55 SSTORE 3EB1 50 POP 3EB2 80 DUP1 3EB3 82 DUP3 3EB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3EC9 16 AND 3ECA 84 DUP5 3ECB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3EE0 16 AND 3EE1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3F02 60 PUSH1 0x40 3F04 51 MLOAD 3F05 60 PUSH1 0x40 3F07 51 MLOAD 3F08 80 DUP1 3F09 91 SWAP2 3F0A 03 SUB 3F0B 90 SWAP1 3F0C A4 LOG4 3F0D 50 POP 3F0E 50 POP 3F0F 50 POP 3F10 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @3E67 memory[0x00:0x20] = stack[-1] // @3E6D memory[0x20:0x40] = 0x01 // @3EB0 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @3F0C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); // } // Block ends with unconditional jump to stack[-4] label_3F11: // Incoming call from 0x25EB, returns to 0x25EC // Inputs[3] // { // @3F14 stack[-1] // @3F18 storage[0x00 + stack[-1]] // @3F1B stack[-2] // } 3F11 5B JUMPDEST 3F12 60 PUSH1 0x00 3F14 81 DUP2 3F15 60 PUSH1 0x00 3F17 01 ADD 3F18 54 SLOAD 3F19 90 SWAP1 3F1A 50 POP 3F1B 91 SWAP2 3F1C 90 SWAP1 3F1D 50 POP 3F1E 56 *JUMP // Stack delta = -1 // Outputs[1] { @3F1B stack[-2] = storage[0x00 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_3F1F: // Incoming call from 0x2EDC, returns to 0x2EDD // Inputs[3] // { // @3F23 stack[-4] // @3F24 stack[-3] // @3F25 stack[-2] // } 3F1F 5B JUMPDEST 3F20 61 PUSH2 0x3f2a 3F23 84 DUP5 3F24 84 DUP5 3F25 84 DUP5 3F26 61 PUSH2 0x3cb6 3F29 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3F20 stack[0] = 0x3f2a // @3F23 stack[1] = stack[-4] // @3F24 stack[2] = stack[-3] // @3F25 stack[3] = stack[-2] // } // Block ends with call to 0x3cb6, returns to 0x3F2A label_3F2A: // Incoming return from call to 0x3CB6 at 0x3F29 // Inputs[4] // { // @3F2E stack[-4] // @3F2F stack[-3] // @3F30 stack[-2] // @3F31 stack[-1] // } 3F2A 5B JUMPDEST 3F2B 61 PUSH2 0x3f36 3F2E 84 DUP5 3F2F 84 DUP5 3F30 84 DUP5 3F31 84 DUP5 3F32 61 PUSH2 0x479c 3F35 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3F2B stack[0] = 0x3f36 // @3F2E stack[1] = stack[-4] // @3F2F stack[2] = stack[-3] // @3F30 stack[3] = stack[-2] // @3F31 stack[4] = stack[-1] // } // Block ends with call to 0x479c, returns to 0x3F36 label_3F36: // Incoming return from call to 0x479C at 0x3F35 // Inputs[1] { @3F3A stack[-1] } 3F36 5B JUMPDEST 3F37 61 PUSH2 0x3f8b 3F3A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3f8b, if stack[-1] label_3F3B: // Incoming jump from 0x3F3A, if not stack[-1] // Inputs[3] // { // @3F3D memory[0x40:0x60] // @3F85 memory[0x40:0x60] // @3F8A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3F3B 60 PUSH1 0x40 3F3D 51 MLOAD 3F3E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3F5F 81 DUP2 3F60 52 MSTORE 3F61 60 PUSH1 0x04 3F63 01 ADD 3F64 80 DUP1 3F65 80 DUP1 3F66 60 PUSH1 0x20 3F68 01 ADD 3F69 82 DUP3 3F6A 81 DUP2 3F6B 03 SUB 3F6C 82 DUP3 3F6D 52 MSTORE 3F6E 60 PUSH1 0x32 3F70 81 DUP2 3F71 52 MSTORE 3F72 60 PUSH1 0x20 3F74 01 ADD 3F75 80 DUP1 3F76 61 PUSH2 0x4b87 3F79 60 PUSH1 0x32 3F7B 91 SWAP2 3F7C 39 CODECOPY 3F7D 60 PUSH1 0x40 3F7F 01 ADD 3F80 91 SWAP2 3F81 50 POP 3F82 50 POP 3F83 60 PUSH1 0x40 3F85 51 MLOAD 3F86 80 DUP1 3F87 91 SWAP2 3F88 03 SUB 3F89 90 SWAP1 3F8A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3F60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3F6D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3F71 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @3F7C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x32] = code[0x4b87:0x4bb9] // @3F8A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3F8B: // Incoming jump from 0x3F3A, if stack[-1] // Inputs[1] { @3F90 stack[-5] } 3F8B 5B JUMPDEST 3F8C 50 POP 3F8D 50 POP 3F8E 50 POP 3F8F 50 POP 3F90 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_3F91: // Incoming call from 0x2F85, returns to 0x2F86 // Inputs[2] // { // @3F94 address(this) // @3F97 stack[-1] // } 3F91 5B JUMPDEST 3F92 60 PUSH1 0x00 3F94 30 ADDRESS 3F95 90 SWAP1 3F96 50 POP 3F97 90 SWAP1 3F98 56 *JUMP // Stack delta = +0 // Outputs[1] { @3F97 stack[-1] = address(this) } // Block ends with unconditional jump to stack[-1] label_3F99: // Incoming jump from 0x2F8A // Inputs[3] // { // @3F9E stack[-1] // @3FBE memory[0x40:0x60] // @3FFA memory[0x40:0x60] // } 3F99 5B JUMPDEST 3F9A 60 PUSH1 0x60 3F9C 60 PUSH1 0x00 3F9E 82 DUP3 3F9F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3FB4 16 AND 3FB5 60 PUSH1 0x00 3FB7 1B SHL 3FB8 90 SWAP1 3FB9 50 POP 3FBA 60 PUSH1 0x60 3FBC 60 PUSH1 0x40 3FBE 51 MLOAD 3FBF 80 DUP1 3FC0 60 PUSH1 0x40 3FC2 01 ADD 3FC3 60 PUSH1 0x40 3FC5 52 MSTORE 3FC6 80 DUP1 3FC7 60 PUSH1 0x10 3FC9 81 DUP2 3FCA 52 MSTORE 3FCB 60 PUSH1 0x20 3FCD 01 ADD 3FCE 7F PUSH32 0x3031323334353637383961626364656600000000000000000000000000000000 3FEF 81 DUP2 3FF0 52 MSTORE 3FF1 50 POP 3FF2 90 SWAP1 3FF3 50 POP 3FF4 60 PUSH1 0x60 3FF6 60 PUSH1 0x2a 3FF8 60 PUSH1 0x40 3FFA 51 MLOAD 3FFB 90 SWAP1 3FFC 80 DUP1 3FFD 82 DUP3 3FFE 52 MSTORE 3FFF 80 DUP1 4000 60 PUSH1 0x1f 4002 01 ADD 4003 60 PUSH1 0x1f 4005 19 NOT 4006 16 AND 4007 60 PUSH1 0x20 4009 01 ADD 400A 82 DUP3 400B 01 ADD 400C 60 PUSH1 0x40 400E 52 MSTORE 400F 80 DUP1 4010 15 ISZERO 4011 61 PUSH2 0x4029 4014 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @3F9A stack[0] = 0x60 // @3FB8 stack[1] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) << 0x00 // @3FC5 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @3FCA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x10 // @3FF0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3031323334353637383961626364656600000000000000000000000000000000 // @3FF2 stack[2] = memory[0x40:0x60] // @3FF4 stack[3] = 0x60 // @3FFB stack[5] = 0x2a // @3FFB stack[4] = memory[0x40:0x60] // @3FFE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2a // @400E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + 0x2a) // } // Block ends with conditional jump to 0x4029, if !0x2a label_4015: // Incoming jump from 0x4014, if not !0x2a // Inputs[5] // { // @4015 stack[-2] // @401B stack[-1] // @401E code.length // @402B stack[-3] // @4052 memory[stack[-2]:stack[-2] + 0x20] // } 4015 81 DUP2 4016 60 PUSH1 0x20 4018 01 ADD 4019 60 PUSH1 0x01 401B 82 DUP3 401C 02 MUL 401D 80 DUP1 401E 38 CODESIZE 401F 83 DUP4 4020 39 CODECOPY 4021 80 DUP1 4022 82 DUP3 4023 01 ADD 4024 91 SWAP2 4025 50 POP 4026 50 POP 4027 90 SWAP1 4028 50 POP 4029 5B JUMPDEST 402A 50 POP 402B 90 SWAP1 402C 50 POP 402D 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 404E 81 DUP2 404F 60 PUSH1 0x00 4051 81 DUP2 4052 51 MLOAD 4053 81 DUP2 4054 10 LT 4055 61 PUSH2 0x405a 4058 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @4020 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x01] = code[code.length:code.length + stack[-1] * 0x01] // @402B stack[-3] = stack[-2] // @402D stack[-2] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @404E stack[-1] = stack[-2] // @404F stack[0] = 0x00 // } // Block ends with conditional jump to 0x405a, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_4059: // Incoming jump from 0x4058, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x4058, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 4059 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4059 assert(); } // Block terminates label_405A: // Incoming jump from 0x4058, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x4058, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @405D stack[-1] // @405E stack[-2] // @405F stack[-3] // @40AB stack[-4] // @40AF memory[stack[-4]:stack[-4] + 0x20] // } 405A 5B JUMPDEST 405B 60 PUSH1 0x20 405D 01 ADD 405E 01 ADD 405F 90 SWAP1 4060 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4080 19 NOT 4081 16 AND 4082 90 SWAP1 4083 81 DUP2 4084 60 PUSH1 0x00 4086 1A BYTE 4087 90 SWAP1 4088 53 MSTORE8 4089 50 POP 408A 7F PUSH32 0x7800000000000000000000000000000000000000000000000000000000000000 40AB 81 DUP2 40AC 60 PUSH1 0x01 40AE 81 DUP2 40AF 51 MLOAD 40B0 81 DUP2 40B1 10 LT 40B2 61 PUSH2 0x40b7 40B5 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @4088 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @408A stack[-3] = 0x7800000000000000000000000000000000000000000000000000000000000000 // @40AB stack[-2] = stack[-4] // @40AC stack[-1] = 0x01 // } // Block ends with conditional jump to 0x40b7, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_40B6: // Incoming jump from 0x40B5, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 40B6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @40B6 assert(); } // Block terminates label_40B7: // Incoming jump from 0x40B5, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @40BA stack[-1] // @40BB stack[-2] // @40BC stack[-3] // } 40B7 5B JUMPDEST 40B8 60 PUSH1 0x20 40BA 01 ADD 40BB 01 ADD 40BC 90 SWAP1 40BD 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 40DD 19 NOT 40DE 16 AND 40DF 90 SWAP1 40E0 81 DUP2 40E1 60 PUSH1 0x00 40E3 1A BYTE 40E4 90 SWAP1 40E5 53 MSTORE8 40E6 50 POP 40E7 60 PUSH1 0x00 40E9 80 DUP1 40EA 90 SWAP1 40EB 50 POP 40EC 5B JUMPDEST 40ED 60 PUSH1 0x14 40EF 81 DUP2 40F0 10 LT 40F1 15 ISZERO 40F2 61 PUSH2 0x420e 40F5 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @40E5 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @40EA stack[-3] = 0x00 // } // Block ends with conditional jump to 0x420e, if !(0x00 < 0x14) label_40F6: // Incoming jump from 0x40F5, if not !(stack[-1] < 0x14) // Incoming jump from 0x40F5, if not !(0x00 < 0x14) // Inputs[3] // { // @40F6 stack[-3] // @40F9 stack[-4] // @40FC stack[-1] // } 40F6 82 DUP3 40F7 60 PUSH1 0x04 40F9 85 DUP6 40FA 60 PUSH1 0x0c 40FC 84 DUP5 40FD 01 ADD 40FE 60 PUSH1 0x20 4100 81 DUP2 4101 10 LT 4102 61 PUSH2 0x4107 4105 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @40F6 stack[0] = stack[-3] // @40F7 stack[1] = 0x04 // @40F9 stack[2] = stack[-4] // @40FD stack[3] = stack[-1] + 0x0c // } // Block ends with conditional jump to 0x4107, if stack[-1] + 0x0c < 0x20 label_4106: // Incoming jump from 0x4105, if not stack[-1] + 0x0c < 0x20 4106 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4106 assert(); } // Block terminates label_4107: // Incoming jump from 0x4105, if stack[-1] + 0x0c < 0x20 // Inputs[5] // { // @4108 stack[-2] // @4108 stack[-1] // @412E stack[-3] // @4136 stack[-4] // @4137 memory[stack[-4]:stack[-4] + 0x20] // } 4107 5B JUMPDEST 4108 1A BYTE 4109 60 PUSH1 0xf8 410B 1B SHL 410C 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 412C 19 NOT 412D 16 AND 412E 90 SWAP1 412F 1C SHR 4130 60 PUSH1 0xf8 4132 1C SHR 4133 60 PUSH1 0xff 4135 16 AND 4136 81 DUP2 4137 51 MLOAD 4138 81 DUP2 4139 10 LT 413A 61 PUSH2 0x413f 413D 57 *JUMPI // Stack delta = -2 // Outputs[1] { @4135 stack[-3] = 0xff & (((~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (byte(stack[-2], stack[-1]) << 0xf8)) >> stack[-3]) >> 0xf8) } // Block ends with conditional jump to 0x413f, if 0xff & (((~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (byte(stack[-2], stack[-1]) << 0xf8)) >> stack[-3]) >> 0xf8) < memory[stack[-4]:stack[-4] + 0x20] label_413E: // Incoming jump from 0x413D, if not 0xff & (((~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (byte(stack[-2], stack[-1]) << 0xf8)) >> stack[-3]) >> 0xf8) < memory[stack[-4]:stack[-4] + 0x20] 413E FE *ASSERT // Stack delta = +0 // Outputs[1] { @413E assert(); } // Block terminates label_413F: // Incoming jump from 0x413D, if 0xff & (((~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (byte(stack[-2], stack[-1]) << 0xf8)) >> stack[-3]) >> 0xf8) < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @4142 stack[-1] // @4143 stack[-2] // @4144 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @414B stack[-4] // @414E stack[-3] // @4154 memory[stack[-4]:stack[-4] + 0x20] // } 413F 5B JUMPDEST 4140 60 PUSH1 0x20 4142 01 ADD 4143 01 ADD 4144 51 MLOAD 4145 60 PUSH1 0xf8 4147 1C SHR 4148 60 PUSH1 0xf8 414A 1B SHL 414B 82 DUP3 414C 60 PUSH1 0x02 414E 83 DUP4 414F 02 MUL 4150 60 PUSH1 0x02 4152 01 ADD 4153 81 DUP2 4154 51 MLOAD 4155 81 DUP2 4156 10 LT 4157 61 PUSH2 0x415c 415A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @414A stack[-2] = (memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8) << 0xf8 // @414B stack[-1] = stack[-4] // @4152 stack[0] = 0x02 + stack[-3] * 0x02 // } // Block ends with conditional jump to 0x415c, if 0x02 + stack[-3] * 0x02 < memory[stack[-4]:stack[-4] + 0x20] label_415B: // Incoming jump from 0x415A, if not 0x02 + stack[-3] * 0x02 < memory[stack[-4]:stack[-4] + 0x20] 415B FE *ASSERT // Stack delta = +0 // Outputs[1] { @415B assert(); } // Block terminates label_415C: // Incoming jump from 0x415A, if 0x02 + stack[-3] * 0x02 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @415F stack[-1] // @4160 stack[-2] // @4161 stack[-3] // @418C stack[-6] // @4192 stack[-7] // @4195 stack[-4] // } 415C 5B JUMPDEST 415D 60 PUSH1 0x20 415F 01 ADD 4160 01 ADD 4161 90 SWAP1 4162 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4182 19 NOT 4183 16 AND 4184 90 SWAP1 4185 81 DUP2 4186 60 PUSH1 0x00 4188 1A BYTE 4189 90 SWAP1 418A 53 MSTORE8 418B 50 POP 418C 82 DUP3 418D 60 PUSH1 0x0f 418F 60 PUSH1 0xf8 4191 1B SHL 4192 85 DUP6 4193 60 PUSH1 0x0c 4195 84 DUP5 4196 01 ADD 4197 60 PUSH1 0x20 4199 81 DUP2 419A 10 LT 419B 61 PUSH2 0x41a0 419E 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @418A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @418C stack[-3] = stack[-6] // @4191 stack[-2] = 0x0f << 0xf8 // @4192 stack[-1] = stack[-7] // @4196 stack[0] = stack[-4] + 0x0c // } // Block ends with conditional jump to 0x41a0, if stack[-4] + 0x0c < 0x20 label_419F: // Incoming jump from 0x419E, if not stack[-4] + 0x0c < 0x20 419F FE *ASSERT // Stack delta = +0 // Outputs[1] { @419F assert(); } // Block terminates label_41A0: // Incoming jump from 0x419E, if stack[-4] + 0x0c < 0x20 // Inputs[5] // { // @41A1 stack[-2] // @41A1 stack[-1] // @41A5 stack[-3] // @41AC stack[-4] // @41AD memory[stack[-4]:stack[-4] + 0x20] // } 41A0 5B JUMPDEST 41A1 1A BYTE 41A2 60 PUSH1 0xf8 41A4 1B SHL 41A5 16 AND 41A6 60 PUSH1 0xf8 41A8 1C SHR 41A9 60 PUSH1 0xff 41AB 16 AND 41AC 81 DUP2 41AD 51 MLOAD 41AE 81 DUP2 41AF 10 LT 41B0 61 PUSH2 0x41b5 41B3 57 *JUMPI // Stack delta = -2 // Outputs[1] { @41AB stack[-3] = 0xff & (((byte(stack[-2], stack[-1]) << 0xf8) & stack[-3]) >> 0xf8) } // Block ends with conditional jump to 0x41b5, if 0xff & (((byte(stack[-2], stack[-1]) << 0xf8) & stack[-3]) >> 0xf8) < memory[stack[-4]:stack[-4] + 0x20] label_41B4: // Incoming jump from 0x41B3, if not 0xff & (((byte(stack[-2], stack[-1]) << 0xf8) & stack[-3]) >> 0xf8) < memory[stack[-4]:stack[-4] + 0x20] 41B4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @41B4 assert(); } // Block terminates label_41B5: // Incoming jump from 0x41B3, if 0xff & (((byte(stack[-2], stack[-1]) << 0xf8) & stack[-3]) >> 0xf8) < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @41B8 stack[-1] // @41B9 stack[-2] // @41BA memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @41C1 stack[-4] // @41C4 stack[-3] // @41CA memory[stack[-4]:stack[-4] + 0x20] // } 41B5 5B JUMPDEST 41B6 60 PUSH1 0x20 41B8 01 ADD 41B9 01 ADD 41BA 51 MLOAD 41BB 60 PUSH1 0xf8 41BD 1C SHR 41BE 60 PUSH1 0xf8 41C0 1B SHL 41C1 82 DUP3 41C2 60 PUSH1 0x02 41C4 83 DUP4 41C5 02 MUL 41C6 60 PUSH1 0x03 41C8 01 ADD 41C9 81 DUP2 41CA 51 MLOAD 41CB 81 DUP2 41CC 10 LT 41CD 61 PUSH2 0x41d2 41D0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @41C0 stack[-2] = (memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8) << 0xf8 // @41C1 stack[-1] = stack[-4] // @41C8 stack[0] = 0x03 + stack[-3] * 0x02 // } // Block ends with conditional jump to 0x41d2, if 0x03 + stack[-3] * 0x02 < memory[stack[-4]:stack[-4] + 0x20] label_41D1: // Incoming jump from 0x41D0, if not 0x03 + stack[-3] * 0x02 < memory[stack[-4]:stack[-4] + 0x20] 41D1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @41D1 assert(); } // Block terminates label_41D2: // Incoming jump from 0x41D0, if 0x03 + stack[-3] * 0x02 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @41D5 stack[-1] // @41D6 stack[-2] // @41D7 stack[-3] // @4202 stack[-4] // } 41D2 5B JUMPDEST 41D3 60 PUSH1 0x20 41D5 01 ADD 41D6 01 ADD 41D7 90 SWAP1 41D8 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 41F8 19 NOT 41F9 16 AND 41FA 90 SWAP1 41FB 81 DUP2 41FC 60 PUSH1 0x00 41FE 1A BYTE 41FF 90 SWAP1 4200 53 MSTORE8 4201 50 POP 4202 80 DUP1 4203 80 DUP1 4204 60 PUSH1 0x01 4206 01 ADD 4207 91 SWAP2 4208 50 POP 4209 50 POP 420A 61 PUSH2 0x40ec 420D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @4200 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @4207 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x40ec label_420E: // Incoming jump from 0x40F5, if !(stack[-1] < 0x14) // Incoming jump from 0x40F5, if !(0x00 < 0x14) // Inputs[4] // { // @4210 stack[-2] // @4211 stack[-5] // @4216 stack[-7] // @4217 stack[-6] // } 420E 5B JUMPDEST 420F 50 POP 4210 80 DUP1 4211 93 SWAP4 4212 50 POP 4213 50 POP 4214 50 POP 4215 50 POP 4216 91 SWAP2 4217 90 SWAP1 4218 50 POP 4219 56 *JUMP // Stack delta = -6 // Outputs[1] { @4216 stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_421A: // Incoming call from 0x2F93, returns to 0x2F94 // Inputs[1] { @421F stack[-1] } 421A 5B JUMPDEST 421B 60 PUSH1 0x60 421D 60 PUSH1 0x00 421F 82 DUP3 4220 14 EQ 4221 15 ISZERO 4222 61 PUSH2 0x4262 4225 57 *JUMPI // Stack delta = +1 // Outputs[1] { @421B stack[0] = 0x60 } // Block ends with conditional jump to 0x4262, if !(stack[-1] == 0x00) label_4226: // Incoming jump from 0x4225, if not !(stack[-1] == 0x00) // Inputs[2] // { // @4228 memory[0x40:0x60] // @425C stack[-1] // } 4226 60 PUSH1 0x40 4228 51 MLOAD 4229 80 DUP1 422A 60 PUSH1 0x40 422C 01 ADD 422D 60 PUSH1 0x40 422F 52 MSTORE 4230 80 DUP1 4231 60 PUSH1 0x01 4233 81 DUP2 4234 52 MSTORE 4235 60 PUSH1 0x20 4237 01 ADD 4238 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 4259 81 DUP2 425A 52 MSTORE 425B 50 POP 425C 90 SWAP1 425D 50 POP 425E 61 PUSH2 0x4342 4261 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @422F memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @4234 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @425A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @425C stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x4342 label_4262: // Incoming jump from 0x4225, if !(stack[-1] == 0x00) // Inputs[1] { @4265 stack[-2] } 4262 5B JUMPDEST 4263 60 PUSH1 0x00 4265 82 DUP3 4266 90 SWAP1 4267 50 POP 4268 60 PUSH1 0x00 426A 5B JUMPDEST 426B 60 PUSH1 0x00 426D 82 DUP3 426E 14 EQ 426F 61 PUSH2 0x428c 4272 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @4266 stack[0] = stack[-2] // @4268 stack[1] = 0x00 // } // Block ends with conditional jump to 0x428c, if stack[-2] == 0x00 label_4273: // Incoming jump from 0x4272, if not stack[-2] == 0x00 // Incoming jump from 0x4272, if not stack[-2] == 0x00 // Inputs[2] // { // @4273 stack[-1] // @427D stack[-2] // } 4273 80 DUP1 4274 80 DUP1 4275 60 PUSH1 0x01 4277 01 ADD 4278 91 SWAP2 4279 50 POP 427A 50 POP 427B 60 PUSH1 0x0a 427D 82 DUP3 427E 81 DUP2 427F 61 PUSH2 0x4284 4282 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @4278 stack[-1] = 0x01 + stack[-1] // @427B stack[0] = 0x0a // @427D stack[1] = stack[-2] // } // Block ends with conditional jump to 0x4284, if 0x0a label_4283: // Incoming jump from 0x4282, if not 0x0a 4283 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4283 assert(); } // Block terminates label_4284: // Incoming jump from 0x4282, if 0x0a // Inputs[3] // { // @4285 stack[-1] // @4285 stack[-2] // @4286 stack[-4] // } 4284 5B JUMPDEST 4285 04 DIV 4286 91 SWAP2 4287 50 POP 4288 61 PUSH2 0x426a 428B 56 *JUMP // Stack delta = -2 // Outputs[1] { @4286 stack[-4] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x426a label_428C: // Incoming jump from 0x4272, if stack[-2] == 0x00 // Incoming jump from 0x4272, if stack[-2] == 0x00 // Inputs[2] // { // @428F stack[-1] // @4292 memory[0x40:0x60] // } 428C 5B JUMPDEST 428D 60 PUSH1 0x60 428F 81 DUP2 4290 60 PUSH1 0x40 4292 51 MLOAD 4293 90 SWAP1 4294 80 DUP1 4295 82 DUP3 4296 52 MSTORE 4297 80 DUP1 4298 60 PUSH1 0x1f 429A 01 ADD 429B 60 PUSH1 0x1f 429D 19 NOT 429E 16 AND 429F 60 PUSH1 0x20 42A1 01 ADD 42A2 82 DUP3 42A3 01 ADD 42A4 60 PUSH1 0x40 42A6 52 MSTORE 42A7 80 DUP1 42A8 15 ISZERO 42A9 61 PUSH2 0x42c1 42AC 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @428D stack[0] = 0x60 // @4293 stack[1] = memory[0x40:0x60] // @4293 stack[2] = stack[-1] // @4296 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @42A6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x42c1, if !stack[-1] label_42AD: // Incoming jump from 0x42AC, if not !stack[-1] // Inputs[6] // { // @42AD stack[-2] // @42B3 stack[-1] // @42B6 code.length // @42C3 stack[-3] // @42C9 stack[-4] // @42D0 stack[-7] // } 42AD 81 DUP2 42AE 60 PUSH1 0x20 42B0 01 ADD 42B1 60 PUSH1 0x01 42B3 82 DUP3 42B4 02 MUL 42B5 80 DUP1 42B6 38 CODESIZE 42B7 83 DUP4 42B8 39 CODECOPY 42B9 80 DUP1 42BA 82 DUP3 42BB 01 ADD 42BC 91 SWAP2 42BD 50 POP 42BE 50 POP 42BF 90 SWAP1 42C0 50 POP 42C1 5B JUMPDEST 42C2 50 POP 42C3 90 SWAP1 42C4 50 POP 42C5 60 PUSH1 0x00 42C7 60 PUSH1 0x01 42C9 83 DUP4 42CA 03 SUB 42CB 90 SWAP1 42CC 50 POP 42CD 5B JUMPDEST 42CE 60 PUSH1 0x00 42D0 86 DUP7 42D1 14 EQ 42D2 61 PUSH2 0x433a 42D5 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @42B8 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x01] = code[code.length:code.length + stack[-1] * 0x01] // @42C3 stack[-3] = stack[-2] // @42CB stack[-2] = stack[-4] - 0x01 // } // Block ends with conditional jump to 0x433a, if stack[-7] == 0x00 label_42D6: // Incoming jump from 0x42D5, if not stack[-7] == 0x00 // Incoming jump from 0x42D5, if not stack[-7] == 0x00 // Incoming jump from 0x42D5, if not stack[-6] == 0x00 // Inputs[1] { @42D8 stack[-6] } 42D6 60 PUSH1 0x0a 42D8 86 DUP7 42D9 81 DUP2 42DA 61 PUSH2 0x42df 42DD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @42D6 stack[0] = 0x0a // @42D8 stack[1] = stack[-6] // } // Block ends with conditional jump to 0x42df, if 0x0a label_42DE: // Incoming jump from 0x42DD, if not 0x0a 42DE FE *ASSERT // Stack delta = +0 // Outputs[1] { @42DE assert(); } // Block terminates label_42DF: // Incoming jump from 0x42DD, if 0x0a // Inputs[5] // { // @42E0 stack[-2] // @42E0 stack[-1] // @42E7 stack[-4] // @42E8 stack[-3] // @42F1 memory[stack[-4]:stack[-4] + 0x20] // } 42DF 5B JUMPDEST 42E0 06 MOD 42E1 60 PUSH1 0x30 42E3 01 ADD 42E4 60 PUSH1 0xf8 42E6 1B SHL 42E7 82 DUP3 42E8 82 DUP3 42E9 80 DUP1 42EA 60 PUSH1 0x01 42EC 90 SWAP1 42ED 03 SUB 42EE 93 SWAP4 42EF 50 POP 42F0 81 DUP2 42F1 51 MLOAD 42F2 81 DUP2 42F3 10 LT 42F4 61 PUSH2 0x42f9 42F7 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @42E6 stack[-2] = 0x30 + stack[-1] % stack[-2] << 0xf8 // @42E7 stack[-1] = stack[-4] // @42E8 stack[0] = stack[-3] // @42EE stack[-3] = stack[-3] - 0x01 // } // Block ends with conditional jump to 0x42f9, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_42F8: // Incoming jump from 0x42F7, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 42F8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @42F8 assert(); } // Block terminates label_42F9: // Incoming jump from 0x42F7, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @42FC stack[-1] // @42FD stack[-2] // @42FE stack[-3] // @432B stack[-9] // } 42F9 5B JUMPDEST 42FA 60 PUSH1 0x20 42FC 01 ADD 42FD 01 ADD 42FE 90 SWAP1 42FF 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 431F 19 NOT 4320 16 AND 4321 90 SWAP1 4322 81 DUP2 4323 60 PUSH1 0x00 4325 1A BYTE 4326 90 SWAP1 4327 53 MSTORE8 4328 50 POP 4329 60 PUSH1 0x0a 432B 86 DUP7 432C 81 DUP2 432D 61 PUSH2 0x4332 4330 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @4327 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @4329 stack[-3] = 0x0a // @432B stack[-2] = stack[-9] // } // Block ends with conditional jump to 0x4332, if 0x0a label_4331: // Incoming jump from 0x4330, if not 0x0a 4331 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4331 assert(); } // Block terminates label_4332: // Incoming jump from 0x4330, if 0x0a // Inputs[3] // { // @4333 stack[-1] // @4333 stack[-2] // @4334 stack[-8] // } 4332 5B JUMPDEST 4333 04 DIV 4334 95 SWAP6 4335 50 POP 4336 61 PUSH2 0x42cd 4339 56 *JUMP // Stack delta = -2 // Outputs[1] { @4334 stack[-8] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x42cd label_433A: // Incoming jump from 0x42D5, if stack[-7] == 0x00 // Incoming jump from 0x42D5, if stack[-7] == 0x00 // Incoming jump from 0x42D5, if stack[-6] == 0x00 // Inputs[2] // { // @433B stack[-2] // @433C stack[-5] // } 433A 5B JUMPDEST 433B 81 DUP2 433C 94 SWAP5 433D 50 POP 433E 50 POP 433F 50 POP 4340 50 POP 4341 50 POP // Stack delta = -4 // Outputs[1] { @433C stack[-5] = stack[-2] } // Block continues label_4342: // Incoming jump from 0x4261 // Incoming jump from 0x4341 // Inputs[3] // { // @4343 stack[-1] // @4343 stack[-3] // @4344 stack[-2] // } 4342 5B JUMPDEST 4343 91 SWAP2 4344 90 SWAP1 4345 50 POP 4346 56 *JUMP // Stack delta = -2 // Outputs[1] { @4343 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_4347: // Incoming call from 0x3215, returns to 0x3216 // Inputs[1] { @4360 stack[-1] } 4347 5B JUMPDEST 4348 60 PUSH1 0x00 434A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 435F 16 AND 4360 81 DUP2 4361 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4376 16 AND 4377 14 EQ 4378 15 ISZERO 4379 61 PUSH2 0x43cd 437C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x43cd, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_437D: // Incoming jump from 0x437C, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @437F memory[0x40:0x60] // @43C7 memory[0x40:0x60] // @43CC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 437D 60 PUSH1 0x40 437F 51 MLOAD 4380 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 43A1 81 DUP2 43A2 52 MSTORE 43A3 60 PUSH1 0x04 43A5 01 ADD 43A6 80 DUP1 43A7 80 DUP1 43A8 60 PUSH1 0x20 43AA 01 ADD 43AB 82 DUP3 43AC 81 DUP2 43AD 03 SUB 43AE 82 DUP3 43AF 52 MSTORE 43B0 60 PUSH1 0x26 43B2 81 DUP2 43B3 52 MSTORE 43B4 60 PUSH1 0x20 43B6 01 ADD 43B7 80 DUP1 43B8 61 PUSH2 0x4bb9 43BB 60 PUSH1 0x26 43BD 91 SWAP2 43BE 39 CODECOPY 43BF 60 PUSH1 0x40 43C1 01 ADD 43C2 91 SWAP2 43C3 50 POP 43C4 50 POP 43C5 60 PUSH1 0x40 43C7 51 MLOAD 43C8 80 DUP1 43C9 91 SWAP2 43CA 03 SUB 43CB 90 SWAP1 43CC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @43A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @43AF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @43B3 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @43BE memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x4bb9:0x4bdf] // @43CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_43CD: // Incoming jump from 0x437C, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @43CE stack[-1] // @43EA storage[0x08] // @4441 memory[0x40:0x60] // @4444 memory[0x40:0x60] // @4449 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @4454 storage[0x08] // @448C stack[-2] // } 43CD 5B JUMPDEST 43CE 80 DUP1 43CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 43E4 16 AND 43E5 60 PUSH1 0x08 43E7 60 PUSH1 0x00 43E9 90 SWAP1 43EA 54 SLOAD 43EB 90 SWAP1 43EC 61 PUSH2 0x0100 43EF 0A EXP 43F0 90 SWAP1 43F1 04 DIV 43F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4407 16 AND 4408 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 441D 16 AND 441E 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 443F 60 PUSH1 0x40 4441 51 MLOAD 4442 60 PUSH1 0x40 4444 51 MLOAD 4445 80 DUP1 4446 91 SWAP2 4447 03 SUB 4448 90 SWAP1 4449 A3 LOG3 444A 80 DUP1 444B 60 PUSH1 0x08 444D 60 PUSH1 0x00 444F 61 PUSH2 0x0100 4452 0A EXP 4453 81 DUP2 4454 54 SLOAD 4455 81 DUP2 4456 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 446B 02 MUL 446C 19 NOT 446D 16 AND 446E 90 SWAP1 446F 83 DUP4 4470 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4485 16 AND 4486 02 MUL 4487 17 OR 4488 90 SWAP1 4489 55 SSTORE 448A 50 POP 448B 50 POP 448C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @4449 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @4489 storage[0x08] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x08]) // } // Block ends with unconditional jump to stack[-2] label_448D: // Incoming call from 0x363D, returns to 0x363E // Inputs[1] { @44A6 stack[-2] } 448D 5B JUMPDEST 448E 60 PUSH1 0x00 4490 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 44A5 16 AND 44A6 82 DUP3 44A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 44BC 16 AND 44BD 14 EQ 44BE 15 ISZERO 44BF 61 PUSH2 0x4530 44C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4530, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_44C3: // Incoming jump from 0x44C2, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @44C5 memory[0x40:0x60] // @452A memory[0x40:0x60] // @452F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 44C3 60 PUSH1 0x40 44C5 51 MLOAD 44C6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 44E7 81 DUP2 44E8 52 MSTORE 44E9 60 PUSH1 0x04 44EB 01 ADD 44EC 80 DUP1 44ED 80 DUP1 44EE 60 PUSH1 0x20 44F0 01 ADD 44F1 82 DUP3 44F2 81 DUP2 44F3 03 SUB 44F4 82 DUP3 44F5 52 MSTORE 44F6 60 PUSH1 0x20 44F8 81 DUP2 44F9 52 MSTORE 44FA 60 PUSH1 0x20 44FC 01 ADD 44FD 80 DUP1 44FE 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 451F 81 DUP2 4520 52 MSTORE 4521 50 POP 4522 60 PUSH1 0x20 4524 01 ADD 4525 91 SWAP2 4526 50 POP 4527 50 POP 4528 60 PUSH1 0x40 452A 51 MLOAD 452B 80 DUP1 452C 91 SWAP2 452D 03 SUB 452E 90 SWAP1 452F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @44E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @44F5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @44F9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @4520 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @452F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_4530: // Incoming jump from 0x44C2, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @4534 stack[-1] } 4530 5B JUMPDEST 4531 61 PUSH2 0x4539 4534 81 DUP2 4535 61 PUSH2 0x3b48 4538 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4531 stack[0] = 0x4539 // @4534 stack[1] = stack[-1] // } // Block ends with call to 0x3b48, returns to 0x4539 label_4539: // Incoming return from call to 0x3B48 at 0x4538 // Inputs[1] { @453A stack[-1] } 4539 5B JUMPDEST 453A 15 ISZERO 453B 61 PUSH2 0x45ac 453E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x45ac, if !stack[-1] label_453F: // Incoming jump from 0x453E, if not !stack[-1] // Inputs[3] // { // @4541 memory[0x40:0x60] // @45A6 memory[0x40:0x60] // @45AB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 453F 60 PUSH1 0x40 4541 51 MLOAD 4542 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 4563 81 DUP2 4564 52 MSTORE 4565 60 PUSH1 0x04 4567 01 ADD 4568 80 DUP1 4569 80 DUP1 456A 60 PUSH1 0x20 456C 01 ADD 456D 82 DUP3 456E 81 DUP2 456F 03 SUB 4570 82 DUP3 4571 52 MSTORE 4572 60 PUSH1 0x1c 4574 81 DUP2 4575 52 MSTORE 4576 60 PUSH1 0x20 4578 01 ADD 4579 80 DUP1 457A 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 459B 81 DUP2 459C 52 MSTORE 459D 50 POP 459E 60 PUSH1 0x20 45A0 01 ADD 45A1 91 SWAP2 45A2 50 POP 45A3 50 POP 45A4 60 PUSH1 0x40 45A6 51 MLOAD 45A7 80 DUP1 45A8 91 SWAP2 45A9 03 SUB 45AA 90 SWAP1 45AB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4564 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @4571 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @4575 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1c // @459C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @45AB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_45AC: // Incoming jump from 0x453E, if !stack[-1] // Inputs[5] // { // @45AD stack[-2] // @45B2 stack[-1] // @45C0 memory[0x00:0x40] // @45C8 storage[keccak256(memory[0x00:0x40])] // @4640 memory[0x00:0x40] // } 45AC 5B JUMPDEST 45AD 81 DUP2 45AE 60 PUSH1 0x01 45B0 60 PUSH1 0x00 45B2 83 DUP4 45B3 81 DUP2 45B4 52 MSTORE 45B5 60 PUSH1 0x20 45B7 01 ADD 45B8 90 SWAP1 45B9 81 DUP2 45BA 52 MSTORE 45BB 60 PUSH1 0x20 45BD 01 ADD 45BE 60 PUSH1 0x00 45C0 20 SHA3 45C1 60 PUSH1 0x00 45C3 61 PUSH2 0x0100 45C6 0A EXP 45C7 81 DUP2 45C8 54 SLOAD 45C9 81 DUP2 45CA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 45DF 02 MUL 45E0 19 NOT 45E1 16 AND 45E2 90 SWAP1 45E3 83 DUP4 45E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 45F9 16 AND 45FA 02 MUL 45FB 17 OR 45FC 90 SWAP1 45FD 55 SSTORE 45FE 50 POP 45FF 61 PUSH2 0x4645 4602 60 PUSH1 0x03 4604 60 PUSH1 0x00 4606 84 DUP5 4607 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 461C 16 AND 461D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4632 16 AND 4633 81 DUP2 4634 52 MSTORE 4635 60 PUSH1 0x20 4637 01 ADD 4638 90 SWAP1 4639 81 DUP2 463A 52 MSTORE 463B 60 PUSH1 0x20 463D 01 ADD 463E 60 PUSH1 0x00 4640 20 SHA3 4641 61 PUSH2 0x4786 4644 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @45B4 memory[0x00:0x20] = stack[-1] // @45BA memory[0x20:0x40] = 0x01 // @45FD storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @45FF stack[0] = 0x4645 // @4634 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @463A memory[0x20:0x40] = 0x03 // @4640 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x4786, returns to 0x4645 label_4645: // Incoming return from call to 0x4786 at 0x4644 // Inputs[6] // { // @4646 stack[-1] // @4647 stack[-2] // @4699 memory[0x40:0x60] // @469C memory[0x40:0x60] // @46A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @46A4 stack[-3] // } 4645 5B JUMPDEST 4646 80 DUP1 4647 82 DUP3 4648 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 465D 16 AND 465E 60 PUSH1 0x00 4660 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4675 16 AND 4676 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 4697 60 PUSH1 0x40 4699 51 MLOAD 469A 60 PUSH1 0x40 469C 51 MLOAD 469D 80 DUP1 469E 91 SWAP2 469F 03 SUB 46A0 90 SWAP1 46A1 A4 LOG4 46A2 50 POP 46A3 50 POP 46A4 56 *JUMP // Stack delta = -3 // Outputs[1] { @46A1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_46A5: // Incoming call from 0x3DD0, returns to 0x3DD1 // Inputs[3] // { // @46C2 stack[-1] // @46D0 memory[0x00:0x40] // @46D4 storage[keccak256(memory[0x00:0x40])] // } 46A5 5B JUMPDEST 46A6 60 PUSH1 0x00 46A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 46BD 16 AND 46BE 60 PUSH1 0x02 46C0 60 PUSH1 0x00 46C2 83 DUP4 46C3 81 DUP2 46C4 52 MSTORE 46C5 60 PUSH1 0x20 46C7 01 ADD 46C8 90 SWAP1 46C9 81 DUP2 46CA 52 MSTORE 46CB 60 PUSH1 0x20 46CD 01 ADD 46CE 60 PUSH1 0x00 46D0 20 SHA3 46D1 60 PUSH1 0x00 46D3 90 SWAP1 46D4 54 SLOAD 46D5 90 SWAP1 46D6 61 PUSH2 0x0100 46D9 0A EXP 46DA 90 SWAP1 46DB 04 DIV 46DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 46F1 16 AND 46F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4707 16 AND 4708 14 EQ 4709 61 PUSH2 0x4760 470C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @46C4 memory[0x00:0x20] = stack[-1] // @46CA memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x4760, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 label_470D: // Incoming jump from 0x470C, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[4] // { // @4713 stack[-1] // @4721 memory[0x00:0x40] // @4729 storage[keccak256(memory[0x00:0x40])] // @4762 stack[-2] // } 470D 60 PUSH1 0x00 470F 60 PUSH1 0x02 4711 60 PUSH1 0x00 4713 83 DUP4 4714 81 DUP2 4715 52 MSTORE 4716 60 PUSH1 0x20 4718 01 ADD 4719 90 SWAP1 471A 81 DUP2 471B 52 MSTORE 471C 60 PUSH1 0x20 471E 01 ADD 471F 60 PUSH1 0x00 4721 20 SHA3 4722 60 PUSH1 0x00 4724 61 PUSH2 0x0100 4727 0A EXP 4728 81 DUP2 4729 54 SLOAD 472A 81 DUP2 472B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4740 02 MUL 4741 19 NOT 4742 16 AND 4743 90 SWAP1 4744 83 DUP4 4745 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 475A 16 AND 475B 02 MUL 475C 17 OR 475D 90 SWAP1 475E 55 SSTORE 475F 50 POP 4760 5B JUMPDEST 4761 50 POP 4762 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @4715 memory[0x00:0x20] = stack[-1] // @471B memory[0x20:0x40] = 0x02 // @475E storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_4763: // Incoming call from 0x3E17, returns to 0x3E18 // Inputs[2] // { // @4769 stack[-1] // @476D storage[0x00 + stack[-1]] // } 4763 5B JUMPDEST 4764 61 PUSH2 0x477b 4767 60 PUSH1 0x01 4769 82 DUP3 476A 60 PUSH1 0x00 476C 01 ADD 476D 54 SLOAD 476E 61 PUSH2 0x498c 4771 90 SWAP1 4772 91 SWAP2 4773 90 SWAP1 4774 63 PUSH4 0xffffffff 4779 16 AND 477A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4764 stack[0] = 0x477b // @4772 stack[1] = storage[0x00 + stack[-1]] // @4773 stack[2] = 0x01 // } // Block ends with call to 0xffffffff & 0x498c, returns to 0x477B label_477B: // Incoming return from call to 0x498C at 0x477A // Inputs[3] // { // @477C stack[-2] // @4780 stack[-1] // @4785 stack[-3] // } 477B 5B JUMPDEST 477C 81 DUP2 477D 60 PUSH1 0x00 477F 01 ADD 4780 81 DUP2 4781 90 SWAP1 4782 55 SSTORE 4783 50 POP 4784 50 POP 4785 56 *JUMP // Stack delta = -3 // Outputs[1] { @4782 storage[0x00 + stack[-2]] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_4786: // Incoming call from 0x4644, returns to 0x4645 // Incoming call from 0x3E5E, returns to 0x3E5F // Inputs[3] // { // @4789 stack[-1] // @4791 storage[0x00 + stack[-1]] // @479B stack[-2] // } 4786 5B JUMPDEST 4787 60 PUSH1 0x01 4789 81 DUP2 478A 60 PUSH1 0x00 478C 01 ADD 478D 60 PUSH1 0x00 478F 82 DUP3 4790 82 DUP3 4791 54 SLOAD 4792 01 ADD 4793 92 SWAP3 4794 50 POP 4795 50 POP 4796 81 DUP2 4797 90 SWAP1 4798 55 SSTORE 4799 50 POP 479A 50 POP 479B 56 *JUMP // Stack delta = -2 // Outputs[1] { @4798 storage[0x00 + stack[-1]] = storage[0x00 + stack[-1]] + 0x01 } // Block ends with unconditional jump to stack[-2] label_479C: // Incoming call from 0x3F35, returns to 0x3F36 // Inputs[1] { @47A2 stack[-3] } 479C 5B JUMPDEST 479D 60 PUSH1 0x00 479F 61 PUSH2 0x47bd 47A2 84 DUP5 47A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 47B8 16 AND 47B9 61 PUSH2 0x49d6 47BC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @479D stack[0] = 0x00 // @479F stack[1] = 0x47bd // @47B8 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x49d6, returns to 0x47BD label_47BD: // Incoming return from call to 0x49D6 at 0x47BC // Inputs[1] { @47C1 stack[-1] } 47BD 5B JUMPDEST 47BE 61 PUSH2 0x47ca 47C1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x47ca, if stack[-1] label_47C2: // Incoming jump from 0x47C1, if not stack[-1] // Inputs[1] { @47C4 stack[-1] } 47C2 60 PUSH1 0x01 47C4 90 SWAP1 47C5 50 POP 47C6 61 PUSH2 0x4984 47C9 56 *JUMP // Stack delta = +0 // Outputs[1] { @47C4 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x4984 label_47CA: // Incoming jump from 0x47C1, if stack[-1] // Inputs[1] { @47CD stack[-4] } 47CA 5B JUMPDEST 47CB 60 PUSH1 0x00 47CD 84 DUP5 47CE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 47E3 16 AND 47E4 63 PUSH4 0x150b7a02 47E9 61 PUSH2 0x47f0 47EC 61 PUSH2 0x3bba 47EF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @47CB stack[0] = 0x00 // @47E3 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @47E4 stack[2] = 0x150b7a02 // @47E9 stack[3] = 0x47f0 // } // Block ends with call to 0x3bba, returns to 0x47F0 label_47F0: // Incoming return from call to 0x3BBA at 0x47EF // Inputs[8] // { // @47F1 stack[-9] // @47F2 stack[-7] // @47F3 stack[-6] // @47F6 memory[0x40:0x60] // @47F7 stack[-2] // @4807 stack[-1] // @487D memory[stack[-6]:stack[-6] + 0x20] // @4886 memory[stack[-6]:stack[-6] + 0x20] // } 47F0 5B JUMPDEST 47F1 88 DUP9 47F2 87 DUP8 47F3 87 DUP8 47F4 60 PUSH1 0x40 47F6 51 MLOAD 47F7 85 DUP6 47F8 63 PUSH4 0xffffffff 47FD 16 AND 47FE 60 PUSH1 0xe0 4800 1B SHL 4801 81 DUP2 4802 52 MSTORE 4803 60 PUSH1 0x04 4805 01 ADD 4806 80 DUP1 4807 85 DUP6 4808 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 481D 16 AND 481E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4833 16 AND 4834 81 DUP2 4835 52 MSTORE 4836 60 PUSH1 0x20 4838 01 ADD 4839 84 DUP5 483A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 484F 16 AND 4850 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 4865 16 AND 4866 81 DUP2 4867 52 MSTORE 4868 60 PUSH1 0x20 486A 01 ADD 486B 83 DUP4 486C 81 DUP2 486D 52 MSTORE 486E 60 PUSH1 0x20 4870 01 ADD 4871 80 DUP1 4872 60 PUSH1 0x20 4874 01 ADD 4875 82 DUP3 4876 81 DUP2 4877 03 SUB 4878 82 DUP3 4879 52 MSTORE 487A 83 DUP4 487B 81 DUP2 487C 81 DUP2 487D 51 MLOAD 487E 81 DUP2 487F 52 MSTORE 4880 60 PUSH1 0x20 4882 01 ADD 4883 91 SWAP2 4884 50 POP 4885 80 DUP1 4886 51 MLOAD 4887 90 SWAP1 4888 60 PUSH1 0x20 488A 01 ADD 488B 90 SWAP1 488C 80 DUP1 488D 83 DUP4 488E 83 DUP4 488F 60 PUSH1 0x00 4891 5B JUMPDEST 4892 83 DUP4 4893 81 DUP2 4894 10 LT 4895 15 ISZERO 4896 61 PUSH2 0x48ac 4899 57 *JUMPI // Stack delta = +12 // Outputs[18] // { // @47F1 stack[0] = stack[-9] // @47F2 stack[1] = stack[-7] // @47F3 stack[2] = stack[-6] // @4802 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @4805 stack[3] = 0x04 + memory[0x40:0x60] // @4835 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @4867 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @486D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-7] // @4870 stack[4] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @4879 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @487F memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @4883 stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @488B stack[6] = 0x20 + stack[-6] // @488B stack[7] = memory[stack[-6]:stack[-6] + 0x20] // @488C stack[8] = memory[stack[-6]:stack[-6] + 0x20] // @488D stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @488E stack[10] = 0x20 + stack[-6] // @488F stack[11] = 0x00 // } // Block ends with conditional jump to 0x48ac, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_489A: // Incoming jump from 0x4899, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x4899, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @489A stack[-1] // @489B stack[-2] // @489D memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @489F stack[-3] // } 489A 80 DUP1 489B 82 DUP3 489C 01 ADD 489D 51 MLOAD 489E 81 DUP2 489F 84 DUP5 48A0 01 ADD 48A1 52 MSTORE 48A2 60 PUSH1 0x20 48A4 81 DUP2 48A5 01 ADD 48A6 90 SWAP1 48A7 50 POP 48A8 61 PUSH2 0x4891 48AB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @48A1 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @48A6 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x4891 label_48AC: // Incoming jump from 0x4899, if !(stack[-1] < stack[-4]) // Incoming jump from 0x4899, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @48B1 stack[-6] // @48B1 stack[-5] // @48B3 stack[-7] // } 48AC 5B JUMPDEST 48AD 50 POP 48AE 50 POP 48AF 50 POP 48B0 50 POP 48B1 90 SWAP1 48B2 50 POP 48B3 90 SWAP1 48B4 81 DUP2 48B5 01 ADD 48B6 90 SWAP1 48B7 60 PUSH1 0x1f 48B9 16 AND 48BA 80 DUP1 48BB 15 ISZERO 48BC 61 PUSH2 0x48d9 48BF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @48B6 stack[-7] = stack[-5] + stack[-7] // @48B9 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x48d9, if !(0x1f & stack[-5]) label_48C0: // Incoming jump from 0x48BF, if not !(0x1f & stack[-5]) // Inputs[7] // { // @48C0 stack[-1] // @48C1 stack[-2] // @48C4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @48DB stack[-8] // @48E6 memory[0x40:0x60] // @48ED stack[-10] // @48EF address(stack[-10]).code.length // } 48C0 80 DUP1 48C1 82 DUP3 48C2 03 SUB 48C3 80 DUP1 48C4 51 MLOAD 48C5 60 PUSH1 0x01 48C7 83 DUP4 48C8 60 PUSH1 0x20 48CA 03 SUB 48CB 61 PUSH2 0x0100 48CE 0A EXP 48CF 03 SUB 48D0 19 NOT 48D1 16 AND 48D2 81 DUP2 48D3 52 MSTORE 48D4 60 PUSH1 0x20 48D6 01 ADD 48D7 91 SWAP2 48D8 50 POP 48D9 5B JUMPDEST 48DA 50 POP 48DB 95 SWAP6 48DC 50 POP 48DD 50 POP 48DE 50 POP 48DF 50 POP 48E0 50 POP 48E1 50 POP 48E2 60 PUSH1 0x20 48E4 60 PUSH1 0x40 48E6 51 MLOAD 48E7 80 DUP1 48E8 83 DUP4 48E9 03 SUB 48EA 81 DUP2 48EB 60 PUSH1 0x00 48ED 87 DUP8 48EE 80 DUP1 48EF 3B EXTCODESIZE 48F0 15 ISZERO 48F1 80 DUP1 48F2 15 ISZERO 48F3 61 PUSH2 0x48fb 48F6 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @48D3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @48DB stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @48E2 stack[-7] = 0x20 // @48E6 stack[-6] = memory[0x40:0x60] // @48E9 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @48EA stack[-4] = memory[0x40:0x60] // @48EB stack[-3] = 0x00 // @48ED stack[-2] = stack[-10] // @48F0 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x48fb, if !!address(stack[-10]).code.length label_48F7: // Incoming jump from 0x48F6, if not !!address(stack[-10]).code.length // Incoming jump from 0x48F6, if not !!address(stack[-10]).code.length // Inputs[1] { @48FA memory[0x00:0x00] } 48F7 60 PUSH1 0x00 48F9 80 DUP1 48FA FD *REVERT // Stack delta = +0 // Outputs[1] { @48FA revert(memory[0x00:0x00]); } // Block terminates label_48FB: // Incoming jump from 0x48F6, if !!address(stack[-10]).code.length // Incoming jump from 0x48F6, if !!address(stack[-10]).code.length // Inputs[9] // { // @48FD msg.gas // @48FE stack[-4] // @48FE stack[-3] // @48FE stack[-2] // @48FE stack[-5] // @48FE stack[-7] // @48FE stack[-6] // @48FE address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @48FE memory[stack[-4]:stack[-4] + stack[-5]] // } 48FB 5B JUMPDEST 48FC 50 POP 48FD 5A GAS 48FE F1 CALL 48FF 15 ISZERO 4900 80 DUP1 4901 15 ISZERO 4902 61 PUSH2 0x490f 4905 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @48FE memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @48FF stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x490f, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_4906: // Incoming jump from 0x4905, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @4906 returndata.length // @490A returndata[0x00:0x00 + returndata.length] // @490B returndata.length // @490E memory[0x00:0x00 + returndata.length] // } 4906 3D RETURNDATASIZE 4907 60 PUSH1 0x00 4909 80 DUP1 490A 3E RETURNDATACOPY 490B 3D RETURNDATASIZE 490C 60 PUSH1 0x00 490E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @490A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @490E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_490F: // Incoming jump from 0x4905, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @4916 memory[0x40:0x60] // @4917 returndata.length // } 490F 5B JUMPDEST 4910 50 POP 4911 50 POP 4912 50 POP 4913 50 POP 4914 60 PUSH1 0x40 4916 51 MLOAD 4917 3D RETURNDATASIZE 4918 60 PUSH1 0x20 491A 81 DUP2 491B 10 LT 491C 15 ISZERO 491D 61 PUSH2 0x4925 4920 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4916 stack[-4] = memory[0x40:0x60] // @4917 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x4925, if !(returndata.length < 0x20) label_4921: // Incoming jump from 0x4920, if not !(returndata.length < 0x20) // Inputs[1] { @4924 memory[0x00:0x00] } 4921 60 PUSH1 0x00 4923 80 DUP1 4924 FD *REVERT // Stack delta = +0 // Outputs[1] { @4924 revert(memory[0x00:0x00]); } // Block terminates label_4925: // Incoming jump from 0x4920, if !(returndata.length < 0x20) // Inputs[5] // { // @4926 stack[-2] // @4927 stack[-1] // @492B memory[stack[-2]:stack[-2] + 0x20] // @4937 stack[-3] // @4981 stack[-4] // } 4925 5B JUMPDEST 4926 81 DUP2 4927 01 ADD 4928 90 SWAP1 4929 80 DUP1 492A 80 DUP1 492B 51 MLOAD 492C 90 SWAP1 492D 60 PUSH1 0x20 492F 01 ADD 4930 90 SWAP1 4931 92 SWAP3 4932 91 SWAP2 4933 90 SWAP1 4934 50 POP 4935 50 POP 4936 50 POP 4937 90 SWAP1 4938 50 POP 4939 63 PUSH4 0x150b7a02 493E 60 PUSH1 0xe0 4940 1B SHL 4941 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 495E 19 NOT 495F 16 AND 4960 81 DUP2 4961 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 497E 19 NOT 497F 16 AND 4980 14 EQ 4981 91 SWAP2 4982 50 POP 4983 50 POP // Stack delta = -3 // Outputs[1] { @4981 stack[-4] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0) } // Block continues label_4984: // Incoming jump from 0x4983 // Incoming jump from 0x47C9 // Inputs[3] // { // @4985 stack[-1] // @4985 stack[-6] // @4986 stack[-5] // } 4984 5B JUMPDEST 4985 94 SWAP5 4986 93 SWAP4 4987 50 POP 4988 50 POP 4989 50 POP 498A 50 POP 498B 56 *JUMP // Stack delta = -5 // Outputs[1] { @4985 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_498C: // Incoming call from 0x477A, returns to 0x477B // Inputs[3] // { // @4992 stack[-2] // @4993 stack[-1] // @4996 memory[0x40:0x60] // } 498C 5B JUMPDEST 498D 60 PUSH1 0x00 498F 61 PUSH2 0x49ce 4992 83 DUP4 4993 83 DUP4 4994 60 PUSH1 0x40 4996 51 MLOAD 4997 80 DUP1 4998 60 PUSH1 0x40 499A 01 ADD 499B 60 PUSH1 0x40 499D 52 MSTORE 499E 80 DUP1 499F 60 PUSH1 0x1e 49A1 81 DUP2 49A2 52 MSTORE 49A3 60 PUSH1 0x20 49A5 01 ADD 49A6 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 49C7 81 DUP2 49C8 52 MSTORE 49C9 50 POP 49CA 61 PUSH2 0x4a21 49CD 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @498D stack[0] = 0x00 // @498F stack[1] = 0x49ce // @4992 stack[2] = stack[-2] // @4993 stack[3] = stack[-1] // @4996 stack[4] = memory[0x40:0x60] // @499D memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @49A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @49C8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x4a21, returns to 0x49CE label_49CE: // Incoming return from call to 0x4A21 at 0x49CD // Inputs[4] // { // @49CF stack[-2] // @49CF stack[-1] // @49D1 stack[-5] // @49D2 stack[-4] // } 49CE 5B JUMPDEST 49CF 90 SWAP1 49D0 50 POP 49D1 92 SWAP3 49D2 91 SWAP2 49D3 50 POP 49D4 50 POP 49D5 56 *JUMP // Stack delta = -4 // Outputs[1] { @49D1 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_49D6: // Incoming call from 0x47BC, returns to 0x47BD // Inputs[2] // { // @4A02 stack[-1] // @4A03 keccak256(address(stack[-1]).code) // } 49D6 5B JUMPDEST 49D7 60 PUSH1 0x00 49D9 80 DUP1 49DA 60 PUSH1 0x00 49DC 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 49FD 60 PUSH1 0x00 49FF 1B SHL 4A00 90 SWAP1 4A01 50 POP 4A02 83 DUP4 4A03 3F EXTCODEHASH 4A04 91 SWAP2 4A05 50 POP 4A06 60 PUSH1 0x00 4A08 80 DUP1 4A09 1B SHL 4A0A 82 DUP3 4A0B 14 EQ 4A0C 15 ISZERO 4A0D 80 DUP1 4A0E 15 ISZERO 4A0F 61 PUSH2 0x4a18 4A12 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @49D7 stack[0] = 0x00 // @4A00 stack[2] = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 << 0x00 // @4A04 stack[1] = keccak256(address(stack[-1]).code) // @4A0C stack[3] = !(keccak256(address(stack[-1]).code) == 0x00 << 0x00) // } // Block ends with conditional jump to 0x4a18, if !!(keccak256(address(stack[-1]).code) == 0x00 << 0x00) label_4A13: // Incoming jump from 0x4A12, if not !!(keccak256(address(stack[-1]).code) == 0x00 << 0x00) // Inputs[5] // { // @4A14 stack[-2] // @4A15 stack[-3] // @4A19 stack[-4] // @4A1D stack[-6] // @4A1E stack[-5] // } 4A13 50 POP 4A14 80 DUP1 4A15 82 DUP3 4A16 14 EQ 4A17 15 ISZERO 4A18 5B JUMPDEST 4A19 92 SWAP3 4A1A 50 POP 4A1B 50 POP 4A1C 50 POP 4A1D 91 SWAP2 4A1E 90 SWAP1 4A1F 50 POP 4A20 56 *JUMP // Stack delta = -5 // Outputs[1] { @4A1D stack[-6] = !(stack[-3] == stack[-2]) } // Block ends with unconditional jump to stack[-6] label_4A21: // Incoming call from 0x49CD, returns to 0x49CE // Inputs[3] // { // @4A24 stack[-3] // @4A25 stack[-2] // @4A28 stack[-1] // } 4A21 5B JUMPDEST 4A22 60 PUSH1 0x00 4A24 83 DUP4 4A25 83 DUP4 4A26 11 GT 4A27 15 ISZERO 4A28 82 DUP3 4A29 90 SWAP1 4A2A 61 PUSH2 0x4ace 4A2D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @4A22 stack[0] = 0x00 // @4A29 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x4ace, if !(stack[-2] > stack[-3]) label_4A2E: // Incoming jump from 0x4A2D, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @4A30 memory[0x40:0x60] // @4A61 stack[-1] // @4A64 memory[stack[-1]:stack[-1] + 0x20] // @4A6D memory[stack[-1]:stack[-1] + 0x20] // } 4A2E 60 PUSH1 0x40 4A30 51 MLOAD 4A31 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 4A52 81 DUP2 4A53 52 MSTORE 4A54 60 PUSH1 0x04 4A56 01 ADD 4A57 80 DUP1 4A58 80 DUP1 4A59 60 PUSH1 0x20 4A5B 01 ADD 4A5C 82 DUP3 4A5D 81 DUP2 4A5E 03 SUB 4A5F 82 DUP3 4A60 52 MSTORE 4A61 83 DUP4 4A62 81 DUP2 4A63 81 DUP2 4A64 51 MLOAD 4A65 81 DUP2 4A66 52 MSTORE 4A67 60 PUSH1 0x20 4A69 01 ADD 4A6A 91 SWAP2 4A6B 50 POP 4A6C 80 DUP1 4A6D 51 MLOAD 4A6E 90 SWAP1 4A6F 60 PUSH1 0x20 4A71 01 ADD 4A72 90 SWAP1 4A73 80 DUP1 4A74 83 DUP4 4A75 83 DUP4 4A76 60 PUSH1 0x00 4A78 5B JUMPDEST 4A79 83 DUP4 4A7A 81 DUP2 4A7B 10 LT 4A7C 15 ISZERO 4A7D 61 PUSH2 0x4a93 4A80 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @4A53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @4A56 stack[0] = 0x04 + memory[0x40:0x60] // @4A57 stack[1] = 0x04 + memory[0x40:0x60] // @4A60 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @4A66 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @4A6A stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @4A72 stack[3] = 0x20 + stack[-1] // @4A72 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @4A73 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @4A74 stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @4A75 stack[7] = 0x20 + stack[-1] // @4A76 stack[8] = 0x00 // } // Block ends with conditional jump to 0x4a93, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_4A81: // Incoming jump from 0x4A80, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x4A80, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @4A81 stack[-1] // @4A82 stack[-2] // @4A84 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @4A86 stack[-3] // } 4A81 80 DUP1 4A82 82 DUP3 4A83 01 ADD 4A84 51 MLOAD 4A85 81 DUP2 4A86 84 DUP5 4A87 01 ADD 4A88 52 MSTORE 4A89 60 PUSH1 0x20 4A8B 81 DUP2 4A8C 01 ADD 4A8D 90 SWAP1 4A8E 50 POP 4A8F 61 PUSH2 0x4a78 4A92 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @4A88 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @4A8D stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x4a78 label_4A93: // Incoming jump from 0x4A80, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x4A80, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @4A98 stack[-6] // @4A98 stack[-5] // @4A9A stack[-7] // } 4A93 5B JUMPDEST 4A94 50 POP 4A95 50 POP 4A96 50 POP 4A97 50 POP 4A98 90 SWAP1 4A99 50 POP 4A9A 90 SWAP1 4A9B 81 DUP2 4A9C 01 ADD 4A9D 90 SWAP1 4A9E 60 PUSH1 0x1f 4AA0 16 AND 4AA1 80 DUP1 4AA2 15 ISZERO 4AA3 61 PUSH2 0x4ac0 4AA6 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @4A9D stack[-7] = stack[-5] + stack[-7] // @4AA0 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x4ac0, if !(0x1f & stack[-5]) label_4AA7: // Incoming jump from 0x4AA6, if not !(0x1f & stack[-5]) // Inputs[6] // { // @4AA7 stack[-1] // @4AA8 stack[-2] // @4AAB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @4AC2 stack[-5] // @4AC8 memory[0x40:0x60] // @4ACD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 4AA7 80 DUP1 4AA8 82 DUP3 4AA9 03 SUB 4AAA 80 DUP1 4AAB 51 MLOAD 4AAC 60 PUSH1 0x01 4AAE 83 DUP4 4AAF 60 PUSH1 0x20 4AB1 03 SUB 4AB2 61 PUSH2 0x0100 4AB5 0A EXP 4AB6 03 SUB 4AB7 19 NOT 4AB8 16 AND 4AB9 81 DUP2 4ABA 52 MSTORE 4ABB 60 PUSH1 0x20 4ABD 01 ADD 4ABE 91 SWAP2 4ABF 50 POP 4AC0 5B JUMPDEST 4AC1 50 POP 4AC2 92 SWAP3 4AC3 50 POP 4AC4 50 POP 4AC5 50 POP 4AC6 60 PUSH1 0x40 4AC8 51 MLOAD 4AC9 80 DUP1 4ACA 91 SWAP2 4ACB 03 SUB 4ACC 90 SWAP1 4ACD FD *REVERT // Stack delta = -5 // Outputs[2] // { // @4ABA memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @4ACD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_4ACE: // Incoming jump from 0x4A2D, if !(stack[-2] > stack[-3]) // Inputs[4] // { // @4AD2 stack[-4] // @4AD3 stack[-5] // @4AD8 stack[-2] // @4ADB stack[-6] // } 4ACE 5B JUMPDEST 4ACF 50 POP 4AD0 60 PUSH1 0x00 4AD2 83 DUP4 4AD3 85 DUP6 4AD4 03 SUB 4AD5 90 SWAP1 4AD6 50 POP 4AD7 80 DUP1 4AD8 91 SWAP2 4AD9 50 POP 4ADA 50 POP 4ADB 93 SWAP4 4ADC 92 SWAP3 4ADD 50 POP 4ADE 50 POP 4ADF 50 POP 4AE0 56 *JUMP // Stack delta = -5 // Outputs[1] { @4ADB stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_4AE1: // Incoming call from 0x2F72, returns to 0x2F73 // Incoming call from 0x34BC, returns to 0x34BD // Incoming call from 0x358E, returns to 0x358F // Incoming call from 0x3492, returns to 0x3493 // Incoming call from 0x32BF, returns to 0x32C0 // Incoming call from 0x34E6, returns to 0x34E7 // Incoming call from 0x3510, returns to 0x3511 // Incoming call from 0x3564, returns to 0x3565 // Incoming call from 0x3609, returns to 0x360A // Incoming call from 0x32A8, returns to 0x32A9 // Incoming call from 0x353A, returns to 0x353B // Inputs[5] // { // @4AE2 stack[-3] // @4AE4 storage[stack[-3]] // @4AFE memory[0x00:0x20] // @4B09 stack[-2] // @4B0A stack[-1] // } 4AE1 5B JUMPDEST 4AE2 82 DUP3 4AE3 80 DUP1 4AE4 54 SLOAD 4AE5 60 PUSH1 0x01 4AE7 81 DUP2 4AE8 60 PUSH1 0x01 4AEA 16 AND 4AEB 15 ISZERO 4AEC 61 PUSH2 0x0100 4AEF 02 MUL 4AF0 03 SUB 4AF1 16 AND 4AF2 60 PUSH1 0x02 4AF4 90 SWAP1 4AF5 04 DIV 4AF6 90 SWAP1 4AF7 60 PUSH1 0x00 4AF9 52 MSTORE 4AFA 60 PUSH1 0x20 4AFC 60 PUSH1 0x00 4AFE 20 SHA3 4AFF 90 SWAP1 4B00 60 PUSH1 0x1f 4B02 01 ADD 4B03 60 PUSH1 0x20 4B05 90 SWAP1 4B06 04 DIV 4B07 81 DUP2 4B08 01 ADD 4B09 92 SWAP3 4B0A 82 DUP3 4B0B 60 PUSH1 0x1f 4B0D 10 LT 4B0E 61 PUSH2 0x4b22 4B11 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @4AF9 memory[0x00:0x20] = stack[-3] // @4AFF stack[0] = keccak256(memory[0x00:0x20]) // @4B09 stack[1] = stack[-2] // @4B09 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x4b22, if 0x1f < stack[-1] label_4B12: // Incoming jump from 0x4B11, if not 0x1f < stack[-1] // Inputs[4] // { // @4B12 stack[-1] // @4B13 memory[stack[-1]:stack[-1] + 0x20] // @4B18 stack[-3] // @4B1C stack[-5] // } 4B12 80 DUP1 4B13 51 MLOAD 4B14 60 PUSH1 0xff 4B16 19 NOT 4B17 16 AND 4B18 83 DUP4 4B19 80 DUP1 4B1A 01 ADD 4B1B 17 OR 4B1C 85 DUP6 4B1D 55 SSTORE 4B1E 61 PUSH2 0x4b50 4B21 56 *JUMP // Stack delta = +0 // Outputs[1] { @4B1D storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x4b50 label_4B22: // Incoming jump from 0x4B11, if 0x1f < stack[-1] // Inputs[2] // { // @4B23 stack[-3] // @4B29 stack[-5] // } 4B22 5B JUMPDEST 4B23 82 DUP3 4B24 80 DUP1 4B25 01 ADD 4B26 60 PUSH1 0x01 4B28 01 ADD 4B29 85 DUP6 4B2A 55 SSTORE 4B2B 82 DUP3 4B2C 15 ISZERO 4B2D 61 PUSH2 0x4b50 4B30 57 *JUMPI // Stack delta = +0 // Outputs[1] { @4B2A storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x4b50, if !stack[-3] label_4B31: // Incoming jump from 0x4B30, if not !stack[-3] // Inputs[2] // { // @4B31 stack[-1] // @4B31 stack[-3] // } 4B31 91 SWAP2 4B32 82 DUP3 4B33 01 ADD 4B34 5B JUMPDEST 4B35 82 DUP3 4B36 81 DUP2 4B37 11 GT 4B38 15 ISZERO 4B39 61 PUSH2 0x4b4f 4B3C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @4B31 stack[-3] = stack[-1] // @4B33 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x4b4f, if !(stack[-1] + stack[-3] > stack[-1]) label_4B3D: // Incoming jump from 0x4B3C, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x4B3C, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @4B3D stack[-3] // @4B3E memory[stack[-3]:stack[-3] + 0x20] // @4B3F stack[-2] // @4B41 stack[-1] // } 4B3D 82 DUP3 4B3E 51 MLOAD 4B3F 82 DUP3 4B40 55 SSTORE 4B41 91 SWAP2 4B42 60 PUSH1 0x20 4B44 01 ADD 4B45 91 SWAP2 4B46 90 SWAP1 4B47 60 PUSH1 0x01 4B49 01 ADD 4B4A 90 SWAP1 4B4B 61 PUSH2 0x4b34 4B4E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @4B40 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @4B45 stack[-3] = 0x20 + stack[-3] // @4B4A stack[-2] = 0x01 + stack[-2] // @4B4A stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x4b34 label_4B4F: // Incoming jump from 0x4B3C, if !(stack[-1] > stack[-3]) // Incoming jump from 0x4B3C, if !(stack[-1] + stack[-3] > stack[-1]) 4B4F 5B JUMPDEST // Stack delta = +0 // Block continues label_4B50: // Incoming jump from 0x4B4F // Incoming jump from 0x4B21 // Incoming jump from 0x4B30, if !stack[-3] // Inputs[3] // { // @4B52 stack[-3] // @4B52 stack[-2] // @4B57 stack[-4] // } 4B50 5B JUMPDEST 4B51 50 POP 4B52 90 SWAP1 4B53 50 POP 4B54 61 PUSH2 0x4b5d 4B57 91 SWAP2 4B58 90 SWAP1 4B59 61 PUSH2 0x4b61 4B5C 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @4B57 stack[-4] = 0x4b5d // @4B58 stack[-2] = stack[-2] // @4B58 stack[-3] = stack[-4] // } // Block ends with call to 0x4b61, returns to 0x4B5D label_4B5D: // Incoming return from call to 0x4B61 at 0x4B5C // Inputs[2] // { // @4B5F stack[-2] // @4B5F stack[-3] // } 4B5D 5B JUMPDEST 4B5E 50 POP 4B5F 90 SWAP1 4B60 56 *JUMP // Stack delta = -2 // Outputs[1] { @4B5F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_4B61: // Incoming call from 0x4B5C, returns to 0x4B5D // Inputs[2] // { // @4B65 stack[-2] // @4B66 stack[-1] // } 4B61 5B JUMPDEST 4B62 61 PUSH2 0x4b83 4B65 91 SWAP2 4B66 90 SWAP1 4B67 5B JUMPDEST 4B68 80 DUP1 4B69 82 DUP3 4B6A 11 GT 4B6B 15 ISZERO 4B6C 61 PUSH2 0x4b7f 4B6F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @4B65 stack[-2] = 0x4b83 // @4B66 stack[-1] = stack[-2] // @4B66 stack[0] = stack[-1] // } // Block ends with conditional call to 0x4b7f, returns to 0x4B83, if !(stack[-2] > stack[-1]) label_4B70: // Incoming jump from 0x4B6F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x4B6F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @4B72 stack[-1] } 4B70 60 PUSH1 0x00 4B72 81 DUP2 4B73 60 PUSH1 0x00 4B75 90 SWAP1 4B76 55 SSTORE 4B77 50 POP 4B78 60 PUSH1 0x01 4B7A 01 ADD 4B7B 61 PUSH2 0x4b67 4B7E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @4B76 storage[stack[-1]] = 0x00 // @4B7A stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x4b67 label_4B7F: // Incoming jump from 0x4B6F, if !(stack[-2] > stack[-1]) // Incoming call from 0x4B6F, returns to 0x4B83, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @4B81 stack[-2] // @4B81 stack[-3] // } 4B7F 5B JUMPDEST 4B80 50 POP 4B81 90 SWAP1 4B82 56 *JUMP // Stack delta = -2 // Outputs[1] { @4B81 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_4B83: // Incoming return from call to 0x4B7F at 0x4B6F // Inputs[2] // { // @4B84 stack[-2] // @4B84 stack[-1] // } 4B83 5B JUMPDEST 4B84 90 SWAP1 4B85 56 *JUMP // Stack delta = -1 // Outputs[1] { @4B84 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] 4B86 FE *ASSERT 4B87 45 GASLIMIT 4B88 52 MSTORE 4B89 43 NUMBER 4B8A 37 CALLDATACOPY 4B8B 32 ORIGIN 4B8C 31 BALANCE 4B8D 3A GASPRICE 4B8E 20 SHA3 4B8F 74 PUSH21 0x72616e7366657220746f206e6f6e20455243373231 4BA5 52 MSTORE 4BA6 65 PUSH6 0x636569766572 4BAD 20 SHA3 4BAE 69 PUSH10 0x6d706c656d656e746572 4BB9 4F 4F 4BBA 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 4BD3 7A PUSH27 0x65726f20616464726573734552433732313a207472616e73666572 4BEF 20 SHA3 4BF0 74 PUSH21 0x6f20746865207a65726f2061646472657373455243 4C06 37 CALLDATACOPY 4C07 32 ORIGIN 4C08 31 BALANCE 4C09 3A GASPRICE 4C0A 20 SHA3 4C0B 6F PUSH16 0x70657261746f7220717565727920666f 4C1C 72 PUSH19 0x206e6f6e6578697374656e7420746f6b656e45 4C30 52 MSTORE 4C31 43 NUMBER 4C32 37 CALLDATACOPY 4C33 32 ORIGIN 4C34 31 BALANCE 4C35 3A GASPRICE 4C36 20 SHA3 4C37 61 PUSH2 0x7070 4C3A 72 PUSH19 0x6f76652063616c6c6572206973206e6f74206f 4C4E 77 PUSH24 0x6e6572206e6f7220617070726f76656420666f7220616c6c 4C67 45 GASLIMIT 4C68 52 MSTORE 4C69 43 NUMBER 4C6A 37 CALLDATACOPY 4C6B 32 ORIGIN 4C6C 31 BALANCE 4C6D 3A GASPRICE 4C6E 20 SHA3 4C6F 62 PUSH3 0x616c61 4C73 6E PUSH15 0x636520717565727920666f72207468 4C83 65 PUSH6 0x207a65726f20 4C8A 61 PUSH2 0x6464 4C8D 72 PUSH19 0x6573734552433732313a206f776e6572207175 4CA1 65 PUSH6 0x727920666f72 4CA8 20 SHA3 4CA9 6E PUSH15 0x6f6e6578697374656e7420746f6b65 4CB9 6E PUSH15 0x4552433732313a20617070726f7665 4CC9 64 PUSH5 0x2071756572 4CCF 79 PUSH26 0x20666f72206e6f6e6578697374656e7420746f6b656e45524337 4CEA 32 ORIGIN 4CEB 31 BALANCE 4CEC 3A GASPRICE 4CED 20 SHA3 4CEE 74 PUSH21 0x72616e73666572206f6620746f6b656e2074686174 4D04 20 SHA3 4D05 69 PUSH10 0x73206e6f74206f776e45 4D10 52 MSTORE 4D11 43 NUMBER 4D12 37 CALLDATACOPY 4D13 32 ORIGIN 4D14 31 BALANCE 4D15 3A GASPRICE 4D16 20 SHA3 4D17 61 PUSH2 0x7070 4D1A 72 PUSH19 0x6f76616c20746f2063757272656e74206f776e 4D2E 65 PUSH6 0x724552433732 4D35 31 BALANCE 4D36 3A GASPRICE 4D37 20 SHA3 4D38 74 PUSH21 0x72616e736665722063616c6c6572206973206e6f74 4D4E 20 SHA3 4D4F 6F PUSH16 0x776e6572206e6f7220617070726f7665 4D60 64 PUSH5 0xa265627a7a 4D66 72 PUSH19 0x31582092eff0c8c79cdb135c776ae1ea3c1be9 4D7A C0 C0 4D7B BB BB 4D7C DC DC 4D7D 7E PUSH31 0x864c8c2909bb4037191afab964736f6c634300050e0032