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 0x02f2 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x02f2, 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 0x722e141d 0019 11 GT 001A 61 PUSH2 0x018f 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x018f, if 0x722e141d > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x722e141d > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb27a87b0 0024 11 GT 0025 61 PUSH2 0x00e1 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e1, if 0xb27a87b0 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb27a87b0 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd73b2a6c 002F 11 GT 0030 61 PUSH2 0x008a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008a, if 0xd73b2a6c > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd73b2a6c > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe985e9c5 003A 11 GT 003B 61 PUSH2 0x0064 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xe985e9c5 > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x07c0 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c0, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xefd0cbf9 0050 14 EQ 0051 61 PUSH2 0x0809 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0809, if 0xefd0cbf9 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xefd0cbf9 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x081c 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x081c, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x003E, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xd73b2a6c 006B 14 EQ 006C 61 PUSH2 0x0775 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0775, if 0xd73b2a6c == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xd73b2a6c == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xd87a1eeb 0076 14 EQ 0077 61 PUSH2 0x078b 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x078b, if 0xd87a1eeb == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xd87a1eeb == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xe2146963 0081 14 EQ 0082 61 PUSH2 0x07a0 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a0, if 0xe2146963 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xe2146963 == stack[-1] // Inputs[1] { @0089 memory[0x00:0x00] } 0086 60 PUSH1 0x00 0088 80 DUP1 0089 FD *REVERT // Stack delta = +0 // Outputs[1] { @0089 revert(memory[0x00:0x00]); } // Block terminates label_008A: // Incoming jump from 0x0033, if 0xd73b2a6c > stack[-1] // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0xc0ac9983 0091 11 GT 0092 61 PUSH2 0x00bb 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bb, if 0xc0ac9983 > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xc0ac9983 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xc0ac9983 009C 14 EQ 009D 61 PUSH2 0x072a 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x072a, if 0xc0ac9983 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xc0ac9983 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xc87b56dd 00A7 14 EQ 00A8 61 PUSH2 0x073f 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073f, if 0xc87b56dd == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xd7224ba0 00B2 14 EQ 00B3 61 PUSH2 0x075f 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x075f, if 0xd7224ba0 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xd7224ba0 == stack[-1] // Inputs[1] { @00BA memory[0x00:0x00] } 00B7 60 PUSH1 0x00 00B9 80 DUP1 00BA FD *REVERT // Stack delta = +0 // Outputs[1] { @00BA revert(memory[0x00:0x00]); } // Block terminates label_00BB: // Incoming jump from 0x0095, if 0xc0ac9983 > stack[-1] // Inputs[1] { @00BC stack[-1] } 00BB 5B JUMPDEST 00BC 80 DUP1 00BD 63 PUSH4 0xb27a87b0 00C2 14 EQ 00C3 61 PUSH2 0x06d7 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d7, if 0xb27a87b0 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0xb27a87b0 == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0xb6183b05 00CD 14 EQ 00CE 61 PUSH2 0x06ea 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ea, if 0xb6183b05 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0xb6183b05 == stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D2 80 DUP1 00D3 63 PUSH4 0xb88d4fde 00D8 14 EQ 00D9 61 PUSH2 0x070a 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070a, if 0xb88d4fde == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00E0 memory[0x00:0x00] } 00DD 60 PUSH1 0x00 00DF 80 DUP1 00E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E0 revert(memory[0x00:0x00]); } // Block terminates label_00E1: // Incoming jump from 0x0028, if 0xb27a87b0 > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E1 5B JUMPDEST 00E2 80 DUP1 00E3 63 PUSH4 0x8da5cb5b 00E8 11 GT 00E9 61 PUSH2 0x0143 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0143, if 0x8da5cb5b > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x9a5d140b 00F3 11 GT 00F4 61 PUSH2 0x011d 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011d, if 0x9a5d140b > stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x9a5d140b > stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x9a5d140b 00FE 14 EQ 00FF 61 PUSH2 0x0681 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0681, if 0x9a5d140b == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x9a5d140b == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0xa035b1fe 0109 14 EQ 010A 61 PUSH2 0x06a1 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a1, if 0xa035b1fe == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0xa035b1fe == stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0xa22cb465 0114 14 EQ 0115 61 PUSH2 0x06b7 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b7, if 0xa22cb465 == stack[-1] label_0119: // Incoming jump from 0x0118, if not 0xa22cb465 == stack[-1] // Inputs[1] { @011C memory[0x00:0x00] } 0119 60 PUSH1 0x00 011B 80 DUP1 011C FD *REVERT // Stack delta = +0 // Outputs[1] { @011C revert(memory[0x00:0x00]); } // Block terminates label_011D: // Incoming jump from 0x00F7, if 0x9a5d140b > stack[-1] // Inputs[1] { @011E stack[-1] } 011D 5B JUMPDEST 011E 80 DUP1 011F 63 PUSH4 0x8da5cb5b 0124 14 EQ 0125 61 PUSH2 0x062e 0128 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062e, if 0x8da5cb5b == stack[-1] label_0129: // Incoming jump from 0x0128, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0129 stack[-1] } 0129 80 DUP1 012A 63 PUSH4 0x91b7f5ed 012F 14 EQ 0130 61 PUSH2 0x064c 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064c, if 0x91b7f5ed == stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x91b7f5ed == stack[-1] // Inputs[1] { @0134 stack[-1] } 0134 80 DUP1 0135 63 PUSH4 0x95d89b41 013A 14 EQ 013B 61 PUSH2 0x066c 013E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066c, if 0x95d89b41 == stack[-1] label_013F: // Incoming jump from 0x013E, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0142 memory[0x00:0x00] } 013F 60 PUSH1 0x00 0141 80 DUP1 0142 FD *REVERT // Stack delta = +0 // Outputs[1] { @0142 revert(memory[0x00:0x00]); } // Block terminates label_0143: // Incoming jump from 0x00EC, if 0x8da5cb5b > stack[-1] // Inputs[1] { @0144 stack[-1] } 0143 5B JUMPDEST 0144 80 DUP1 0145 63 PUSH4 0x800fffd0 014A 11 GT 014B 61 PUSH2 0x0174 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0174, if 0x800fffd0 > stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x800fffd0 > stack[-1] // Inputs[1] { @014F stack[-1] } 014F 80 DUP1 0150 63 PUSH4 0x800fffd0 0155 14 EQ 0156 61 PUSH2 0x05b4 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b4, if 0x800fffd0 == stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x800fffd0 == stack[-1] // Inputs[1] { @015A stack[-1] } 015A 80 DUP1 015B 63 PUSH4 0x851a7708 0160 14 EQ 0161 61 PUSH2 0x05e1 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e1, if 0x851a7708 == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x851a7708 == stack[-1] // Inputs[1] { @0165 stack[-1] } 0165 80 DUP1 0166 63 PUSH4 0x85cb593b 016B 14 EQ 016C 61 PUSH2 0x060e 016F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060e, if 0x85cb593b == stack[-1] label_0170: // Incoming jump from 0x016F, if not 0x85cb593b == stack[-1] // Inputs[1] { @0173 memory[0x00:0x00] } 0170 60 PUSH1 0x00 0172 80 DUP1 0173 FD *REVERT // Stack delta = +0 // Outputs[1] { @0173 revert(memory[0x00:0x00]); } // Block terminates label_0174: // Incoming jump from 0x014E, if 0x800fffd0 > stack[-1] // Inputs[1] { @0175 stack[-1] } 0174 5B JUMPDEST 0175 80 DUP1 0176 63 PUSH4 0x722e141d 017B 14 EQ 017C 61 PUSH2 0x0589 017F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0589, if 0x722e141d == stack[-1] label_0180: // Incoming jump from 0x017F, if not 0x722e141d == stack[-1] // Inputs[1] { @0180 stack[-1] } 0180 80 DUP1 0181 63 PUSH4 0x75dadb32 0186 14 EQ 0187 61 PUSH2 0x059f 018A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x059f, if 0x75dadb32 == stack[-1] label_018B: // Incoming jump from 0x018A, if not 0x75dadb32 == stack[-1] // Inputs[1] { @018E memory[0x00:0x00] } 018B 60 PUSH1 0x00 018D 80 DUP1 018E FD *REVERT // Stack delta = +0 // Outputs[1] { @018E revert(memory[0x00:0x00]); } // Block terminates label_018F: // Incoming jump from 0x001D, if 0x722e141d > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0190 stack[-1] } 018F 5B JUMPDEST 0190 80 DUP1 0191 63 PUSH4 0x42842e0e 0196 11 GT 0197 61 PUSH2 0x0248 019A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0248, if 0x42842e0e > stack[-1] label_019B: // Incoming jump from 0x019A, if not 0x42842e0e > stack[-1] // Inputs[1] { @019B stack[-1] } 019B 80 DUP1 019C 63 PUSH4 0x5ca8a780 01A1 11 GT 01A2 61 PUSH2 0x01fc 01A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fc, if 0x5ca8a780 > stack[-1] label_01A6: // Incoming jump from 0x01A5, if not 0x5ca8a780 > stack[-1] // Inputs[1] { @01A6 stack[-1] } 01A6 80 DUP1 01A7 63 PUSH4 0x706c1e6f 01AC 11 GT 01AD 61 PUSH2 0x01d6 01B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d6, if 0x706c1e6f > stack[-1] label_01B1: // Incoming jump from 0x01B0, if not 0x706c1e6f > stack[-1] // Inputs[1] { @01B1 stack[-1] } 01B1 80 DUP1 01B2 63 PUSH4 0x706c1e6f 01B7 14 EQ 01B8 61 PUSH2 0x054c 01BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054c, if 0x706c1e6f == stack[-1] label_01BC: // Incoming jump from 0x01BB, if not 0x706c1e6f == stack[-1] // Inputs[1] { @01BC stack[-1] } 01BC 80 DUP1 01BD 63 PUSH4 0x70a08231 01C2 14 EQ 01C3 61 PUSH2 0x0554 01C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0554, if 0x70a08231 == stack[-1] label_01C7: // Incoming jump from 0x01C6, if not 0x70a08231 == stack[-1] // Inputs[1] { @01C7 stack[-1] } 01C7 80 DUP1 01C8 63 PUSH4 0x715018a6 01CD 14 EQ 01CE 61 PUSH2 0x0574 01D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0574, if 0x715018a6 == stack[-1] label_01D2: // Incoming jump from 0x01D1, if not 0x715018a6 == stack[-1] // Inputs[1] { @01D5 memory[0x00:0x00] } 01D2 60 PUSH1 0x00 01D4 80 DUP1 01D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D5 revert(memory[0x00:0x00]); } // Block terminates label_01D6: // Incoming jump from 0x01B0, if 0x706c1e6f > stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D6 5B JUMPDEST 01D7 80 DUP1 01D8 63 PUSH4 0x5ca8a780 01DD 14 EQ 01DE 61 PUSH2 0x0503 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0503, if 0x5ca8a780 == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0x5ca8a780 == stack[-1] // Inputs[1] { @01E2 stack[-1] } 01E2 80 DUP1 01E3 63 PUSH4 0x6352211e 01E8 14 EQ 01E9 61 PUSH2 0x0516 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0516, if 0x6352211e == stack[-1] label_01ED: // Incoming jump from 0x01EC, if not 0x6352211e == stack[-1] // Inputs[1] { @01ED stack[-1] } 01ED 80 DUP1 01EE 63 PUSH4 0x6ac5db19 01F3 14 EQ 01F4 61 PUSH2 0x0536 01F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0536, if 0x6ac5db19 == stack[-1] label_01F8: // Incoming jump from 0x01F7, if not 0x6ac5db19 == stack[-1] // Inputs[1] { @01FB memory[0x00:0x00] } 01F8 60 PUSH1 0x00 01FA 80 DUP1 01FB FD *REVERT // Stack delta = +0 // Outputs[1] { @01FB revert(memory[0x00:0x00]); } // Block terminates label_01FC: // Incoming jump from 0x01A5, if 0x5ca8a780 > stack[-1] // Inputs[1] { @01FD stack[-1] } 01FC 5B JUMPDEST 01FD 80 DUP1 01FE 63 PUSH4 0x4f6ccce7 0203 11 GT 0204 61 PUSH2 0x022d 0207 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022d, if 0x4f6ccce7 > stack[-1] label_0208: // Incoming jump from 0x0207, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0208 stack[-1] } 0208 80 DUP1 0209 63 PUSH4 0x4f6ccce7 020E 14 EQ 020F 61 PUSH2 0x04ad 0212 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ad, if 0x4f6ccce7 == stack[-1] label_0213: // Incoming jump from 0x0212, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0213 stack[-1] } 0213 80 DUP1 0214 63 PUSH4 0x55f804b3 0219 14 EQ 021A 61 PUSH2 0x04cd 021D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cd, if 0x55f804b3 == stack[-1] label_021E: // Incoming jump from 0x021D, if not 0x55f804b3 == stack[-1] // Inputs[1] { @021E stack[-1] } 021E 80 DUP1 021F 63 PUSH4 0x571d34af 0224 14 EQ 0225 61 PUSH2 0x04ed 0228 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ed, if 0x571d34af == stack[-1] label_0229: // Incoming jump from 0x0228, if not 0x571d34af == stack[-1] // Inputs[1] { @022C memory[0x00:0x00] } 0229 60 PUSH1 0x00 022B 80 DUP1 022C FD *REVERT // Stack delta = +0 // Outputs[1] { @022C revert(memory[0x00:0x00]); } // Block terminates label_022D: // Incoming jump from 0x0207, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @022E stack[-1] } 022D 5B JUMPDEST 022E 80 DUP1 022F 63 PUSH4 0x42842e0e 0234 14 EQ 0235 61 PUSH2 0x0477 0238 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0477, if 0x42842e0e == stack[-1] label_0239: // Incoming jump from 0x0238, if not 0x42842e0e == stack[-1] // Inputs[1] { @0239 stack[-1] } 0239 80 DUP1 023A 63 PUSH4 0x4f297ccc 023F 14 EQ 0240 61 PUSH2 0x0497 0243 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0x4f297ccc == stack[-1] label_0244: // Incoming jump from 0x0243, if not 0x4f297ccc == stack[-1] // Inputs[1] { @0247 memory[0x00:0x00] } 0244 60 PUSH1 0x00 0246 80 DUP1 0247 FD *REVERT // Stack delta = +0 // Outputs[1] { @0247 revert(memory[0x00:0x00]); } // Block terminates label_0248: // Incoming jump from 0x019A, if 0x42842e0e > stack[-1] // Inputs[1] { @0249 stack[-1] } 0248 5B JUMPDEST 0249 80 DUP1 024A 63 PUSH4 0x0a99c9fe 024F 11 GT 0250 61 PUSH2 0x02aa 0253 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02aa, if 0x0a99c9fe > stack[-1] label_0254: // Incoming jump from 0x0253, if not 0x0a99c9fe > stack[-1] // Inputs[1] { @0254 stack[-1] } 0254 80 DUP1 0255 63 PUSH4 0x23b872dd 025A 11 GT 025B 61 PUSH2 0x0284 025E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0284, if 0x23b872dd > stack[-1] label_025F: // Incoming jump from 0x025E, if not 0x23b872dd > stack[-1] // Inputs[1] { @025F stack[-1] } 025F 80 DUP1 0260 63 PUSH4 0x23b872dd 0265 14 EQ 0266 61 PUSH2 0x0417 0269 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0417, if 0x23b872dd == stack[-1] label_026A: // Incoming jump from 0x0269, if not 0x23b872dd == stack[-1] // Inputs[1] { @026A stack[-1] } 026A 80 DUP1 026B 63 PUSH4 0x2f745c59 0270 14 EQ 0271 61 PUSH2 0x0437 0274 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0437, if 0x2f745c59 == stack[-1] label_0275: // Incoming jump from 0x0274, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0275 stack[-1] } 0275 80 DUP1 0276 63 PUSH4 0x39a2e659 027B 14 EQ 027C 61 PUSH2 0x0457 027F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0457, if 0x39a2e659 == stack[-1] label_0280: // Incoming jump from 0x027F, if not 0x39a2e659 == stack[-1] // Inputs[1] { @0283 memory[0x00:0x00] } 0280 60 PUSH1 0x00 0282 80 DUP1 0283 FD *REVERT // Stack delta = +0 // Outputs[1] { @0283 revert(memory[0x00:0x00]); } // Block terminates label_0284: // Incoming jump from 0x025E, if 0x23b872dd > stack[-1] // Inputs[1] { @0285 stack[-1] } 0284 5B JUMPDEST 0285 80 DUP1 0286 63 PUSH4 0x0a99c9fe 028B 14 EQ 028C 61 PUSH2 0x03cc 028F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cc, if 0x0a99c9fe == stack[-1] label_0290: // Incoming jump from 0x028F, if not 0x0a99c9fe == stack[-1] // Inputs[1] { @0290 stack[-1] } 0290 80 DUP1 0291 63 PUSH4 0x18160ddd 0296 14 EQ 0297 61 PUSH2 0x03e2 029A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e2, if 0x18160ddd == stack[-1] label_029B: // Incoming jump from 0x029A, if not 0x18160ddd == stack[-1] // Inputs[1] { @029B stack[-1] } 029B 80 DUP1 029C 63 PUSH4 0x19165587 02A1 14 EQ 02A2 61 PUSH2 0x03f7 02A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f7, if 0x19165587 == stack[-1] label_02A6: // Incoming jump from 0x02A5, if not 0x19165587 == stack[-1] // Inputs[1] { @02A9 memory[0x00:0x00] } 02A6 60 PUSH1 0x00 02A8 80 DUP1 02A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A9 revert(memory[0x00:0x00]); } // Block terminates label_02AA: // Incoming jump from 0x0253, if 0x0a99c9fe > stack[-1] // Inputs[1] { @02AB stack[-1] } 02AA 5B JUMPDEST 02AB 80 DUP1 02AC 63 PUSH4 0x081812fc 02B1 11 GT 02B2 61 PUSH2 0x02db 02B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02db, if 0x081812fc > stack[-1] label_02B6: // Incoming jump from 0x02B5, if not 0x081812fc > stack[-1] // Inputs[1] { @02B6 stack[-1] } 02B6 80 DUP1 02B7 63 PUSH4 0x081812fc 02BC 14 EQ 02BD 61 PUSH2 0x034e 02C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034e, if 0x081812fc == stack[-1] label_02C1: // Incoming jump from 0x02C0, if not 0x081812fc == stack[-1] // Inputs[1] { @02C1 stack[-1] } 02C1 80 DUP1 02C2 63 PUSH4 0x095ea7b3 02C7 14 EQ 02C8 61 PUSH2 0x0386 02CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0386, if 0x095ea7b3 == stack[-1] label_02CC: // Incoming jump from 0x02CB, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @02CC stack[-1] } 02CC 80 DUP1 02CD 63 PUSH4 0x0a23b725 02D2 14 EQ 02D3 61 PUSH2 0x03a8 02D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a8, if 0x0a23b725 == stack[-1] label_02D7: // Incoming jump from 0x02D6, if not 0x0a23b725 == stack[-1] // Inputs[1] { @02DA memory[0x00:0x00] } 02D7 60 PUSH1 0x00 02D9 80 DUP1 02DA FD *REVERT // Stack delta = +0 // Outputs[1] { @02DA revert(memory[0x00:0x00]); } // Block terminates label_02DB: // Incoming jump from 0x02B5, if 0x081812fc > stack[-1] // Inputs[1] { @02DC stack[-1] } 02DB 5B JUMPDEST 02DC 80 DUP1 02DD 63 PUSH4 0x01ffc9a7 02E2 14 EQ 02E3 61 PUSH2 0x02f7 02E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f7, if 0x01ffc9a7 == stack[-1] label_02E7: // Incoming jump from 0x02E6, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @02E7 stack[-1] } 02E7 80 DUP1 02E8 63 PUSH4 0x06fdde03 02ED 14 EQ 02EE 61 PUSH2 0x032c 02F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032c, if 0x06fdde03 == stack[-1] label_02F2: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x02F1, if not 0x06fdde03 == stack[-1] // Inputs[1] { @02F6 memory[0x00:0x00] } 02F2 5B JUMPDEST 02F3 60 PUSH1 0x00 02F5 80 DUP1 02F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F6 revert(memory[0x00:0x00]); } // Block terminates label_02F7: // Incoming jump from 0x02E6, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @02F8 msg.value } 02F7 5B JUMPDEST 02F8 34 CALLVALUE 02F9 80 DUP1 02FA 15 ISZERO 02FB 61 PUSH2 0x0303 02FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0303, if !msg.value label_02FF: // Incoming jump from 0x02FE, if not !msg.value // Inputs[1] { @0302 memory[0x00:0x00] } 02FF 60 PUSH1 0x00 0301 80 DUP1 0302 FD *REVERT // Stack delta = +0 // Outputs[1] { @0302 revert(memory[0x00:0x00]); } // Block terminates label_0303: // Incoming jump from 0x02FE, if !msg.value // Inputs[1] { @030B msg.data.length } 0303 5B JUMPDEST 0304 50 POP 0305 61 PUSH2 0x0317 0308 61 PUSH2 0x0312 030B 36 CALLDATASIZE 030C 60 PUSH1 0x04 030E 61 PUSH2 0x308b 0311 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0305 stack[-1] = 0x0317 // @0308 stack[0] = 0x0312 // @030B stack[1] = msg.data.length // @030C stack[2] = 0x04 // } // Block ends with call to 0x308b, returns to 0x0312 label_0312: // Incoming return from call to 0x308B at 0x0311 0312 5B JUMPDEST 0313 61 PUSH2 0x083c 0316 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x083c label_0317: // Incoming return from call to 0x0312 at 0x0311 // Inputs[2] // { // @031A memory[0x40:0x60] // @031B stack[-1] // } 0317 5B JUMPDEST 0318 60 PUSH1 0x40 031A 51 MLOAD 031B 90 SWAP1 031C 15 ISZERO 031D 15 ISZERO 031E 81 DUP2 031F 52 MSTORE 0320 60 PUSH1 0x20 0322 01 ADD // Stack delta = +0 // Outputs[2] // { // @031F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0322 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0323: // Incoming jump from 0x03CB // Incoming jump from 0x0322 // Incoming jump from 0x0385 // Inputs[3] // { // @0326 memory[0x40:0x60] // @0328 stack[-1] // @032B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0323 5B JUMPDEST 0324 60 PUSH1 0x40 0326 51 MLOAD 0327 80 DUP1 0328 91 SWAP2 0329 03 SUB 032A 90 SWAP1 032B F3 *RETURN // Stack delta = -1 // Outputs[1] { @032B return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_032C: // Incoming jump from 0x02F1, if 0x06fdde03 == stack[-1] // Inputs[1] { @032D msg.value } 032C 5B JUMPDEST 032D 34 CALLVALUE 032E 80 DUP1 032F 15 ISZERO 0330 61 PUSH2 0x0338 0333 57 *JUMPI // Stack delta = +1 // Outputs[1] { @032D stack[0] = msg.value } // Block ends with conditional jump to 0x0338, if !msg.value label_0334: // Incoming jump from 0x0333, if not !msg.value // Inputs[1] { @0337 memory[0x00:0x00] } 0334 60 PUSH1 0x00 0336 80 DUP1 0337 FD *REVERT // Stack delta = +0 // Outputs[1] { @0337 revert(memory[0x00:0x00]); } // Block terminates label_0338: // Incoming jump from 0x0333, if !msg.value 0338 5B JUMPDEST 0339 50 POP 033A 61 PUSH2 0x0341 033D 61 PUSH2 0x090d 0340 56 *JUMP // Stack delta = +0 // Outputs[1] { @033A stack[-1] = 0x0341 } // Block ends with call to 0x090d, returns to 0x0341 label_0341: // Incoming return from call to 0x090D at 0x0340 // Incoming return from call to 0x1C09 at 0x073E // Incoming return from call to 0x1D28 at 0x079F // Incoming return from call to 0x075A at 0x0759 // Incoming return from call to 0x148D at 0x0680 // Incoming return from call to 0x1333 at 0x05B3 // Inputs[2] // { // @0344 memory[0x40:0x60] // @0348 stack[-1] // } 0341 5B JUMPDEST 0342 60 PUSH1 0x40 0344 51 MLOAD 0345 61 PUSH2 0x0323 0348 91 SWAP2 0349 90 SWAP1 034A 61 PUSH2 0x3100 034D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0348 stack[-1] = 0x0323 // @0349 stack[1] = memory[0x40:0x60] // @0349 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x3100 label_034E: // Incoming jump from 0x02C0, if 0x081812fc == stack[-1] // Inputs[1] { @034F msg.value } 034E 5B JUMPDEST 034F 34 CALLVALUE 0350 80 DUP1 0351 15 ISZERO 0352 61 PUSH2 0x035a 0355 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034F stack[0] = msg.value } // Block ends with conditional jump to 0x035a, if !msg.value label_0356: // Incoming jump from 0x0355, if not !msg.value // Inputs[1] { @0359 memory[0x00:0x00] } 0356 60 PUSH1 0x00 0358 80 DUP1 0359 FD *REVERT // Stack delta = +0 // Outputs[1] { @0359 revert(memory[0x00:0x00]); } // Block terminates label_035A: // Incoming jump from 0x0355, if !msg.value // Inputs[1] { @0362 msg.data.length } 035A 5B JUMPDEST 035B 50 POP 035C 61 PUSH2 0x036e 035F 61 PUSH2 0x0369 0362 36 CALLDATASIZE 0363 60 PUSH1 0x04 0365 61 PUSH2 0x3113 0368 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @035C stack[-1] = 0x036e // @035F stack[0] = 0x0369 // @0362 stack[1] = msg.data.length // @0363 stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x0369 label_0369: // Incoming return from call to 0x3113 at 0x0368 0369 5B JUMPDEST 036A 61 PUSH2 0x099f 036D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x099f label_036E: // Incoming jump from 0x064B // Incoming return from call to 0x0369 at 0x0368 // Incoming return from call to 0x0531 at 0x0530 // Inputs[2] // { // @0371 memory[0x40:0x60] // @037B stack[-1] // } 036E 5B JUMPDEST 036F 60 PUSH1 0x40 0371 51 MLOAD 0372 60 PUSH1 0x01 0374 60 PUSH1 0x01 0376 60 PUSH1 0xa0 0378 1B SHL 0379 03 SUB 037A 90 SWAP1 037B 91 SWAP2 037C 16 AND 037D 81 DUP2 037E 52 MSTORE 037F 60 PUSH1 0x20 0381 01 ADD 0382 61 PUSH2 0x0323 0385 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @037E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0381 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0323 label_0386: // Incoming jump from 0x02CB, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0387 msg.value } 0386 5B JUMPDEST 0387 34 CALLVALUE 0388 80 DUP1 0389 15 ISZERO 038A 61 PUSH2 0x0392 038D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0387 stack[0] = msg.value } // Block ends with conditional jump to 0x0392, if !msg.value label_038E: // Incoming jump from 0x038D, if not !msg.value // Inputs[1] { @0391 memory[0x00:0x00] } 038E 60 PUSH1 0x00 0390 80 DUP1 0391 FD *REVERT // Stack delta = +0 // Outputs[1] { @0391 revert(memory[0x00:0x00]); } // Block terminates label_0392: // Incoming jump from 0x038D, if !msg.value // Inputs[1] { @039A msg.data.length } 0392 5B JUMPDEST 0393 50 POP 0394 61 PUSH2 0x03a6 0397 61 PUSH2 0x03a1 039A 36 CALLDATASIZE 039B 60 PUSH1 0x04 039D 61 PUSH2 0x3141 03A0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0394 stack[-1] = 0x03a6 // @0397 stack[0] = 0x03a1 // @039A stack[1] = msg.data.length // @039B stack[2] = 0x04 // } // Block ends with call to 0x3141, returns to 0x03A1 label_03A1: // Incoming return from call to 0x3141 at 0x03A0 03A1 5B JUMPDEST 03A2 61 PUSH2 0x0a3f 03A5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a3f label_03A6: // Incoming return from call to 0x0412 at 0x0411 // Incoming return from call to 0x03A1 at 0x03A0 // Incoming return from call to 0x06D2 at 0x06D1 // Incoming return from call to 0x0472 at 0x0471 // Incoming return from call to 0x116D at 0x0553 // Incoming return from call to 0x0667 at 0x0666 // Incoming return from call to 0x12CD at 0x0588 // Incoming return from call to 0x069C at 0x069B // Incoming return from call to 0x07BB at 0x07BA 03A6 5B JUMPDEST 03A7 00 *STOP // Stack delta = +0 // Outputs[1] { @03A7 stop(); } // Block terminates label_03A8: // Incoming jump from 0x02D6, if 0x0a23b725 == stack[-1] // Inputs[1] { @03A9 msg.value } 03A8 5B JUMPDEST 03A9 34 CALLVALUE 03AA 80 DUP1 03AB 15 ISZERO 03AC 61 PUSH2 0x03b4 03AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A9 stack[0] = msg.value } // Block ends with conditional jump to 0x03b4, if !msg.value label_03B0: // Incoming jump from 0x03AF, if not !msg.value // Inputs[1] { @03B3 memory[0x00:0x00] } 03B0 60 PUSH1 0x00 03B2 80 DUP1 03B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B3 revert(memory[0x00:0x00]); } // Block terminates label_03B4: // Incoming jump from 0x03AF, if !msg.value // Inputs[1] { @03BB storage[0x11] } 03B4 5B JUMPDEST 03B5 50 POP 03B6 61 PUSH2 0x03be 03B9 60 PUSH1 0x11 03BB 54 SLOAD 03BC 81 DUP2 03BD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03B6 stack[-1] = 0x03be // @03BB stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x03be label_03BE: // Incoming jump from 0x04AC // Incoming jump from 0x059E // Incoming return from call to 0x056F at 0x056E // Incoming return from call to 0x0452 at 0x0451 // Incoming return from call to 0x05FC at 0x05FB // Incoming jump from 0x03F6 // Incoming jump from 0x0502 // Incoming return from call to 0x04C8 at 0x04C7 // Incoming jump from 0x078A // Incoming jump from 0x054B // Incoming jump from 0x0774 // Incoming return from call to 0x05CF at 0x05CE // Incoming jump from 0x03BD // Incoming jump from 0x03E1 // Incoming jump from 0x06B6 // Inputs[2] // { // @03C1 memory[0x40:0x60] // @03C2 stack[-1] // } 03BE 5B JUMPDEST 03BF 60 PUSH1 0x40 03C1 51 MLOAD 03C2 90 SWAP1 03C3 81 DUP2 03C4 52 MSTORE 03C5 60 PUSH1 0x20 03C7 01 ADD 03C8 61 PUSH2 0x0323 03CB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03C7 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0323 label_03CC: // Incoming jump from 0x028F, if 0x0a99c9fe == stack[-1] // Inputs[1] { @03CD msg.value } 03CC 5B JUMPDEST 03CD 34 CALLVALUE 03CE 80 DUP1 03CF 15 ISZERO 03D0 61 PUSH2 0x03d8 03D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CD stack[0] = msg.value } // Block ends with conditional jump to 0x03d8, if !msg.value label_03D4: // Incoming jump from 0x03D3, if not !msg.value // Inputs[1] { @03D7 memory[0x00:0x00] } 03D4 60 PUSH1 0x00 03D6 80 DUP1 03D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D7 revert(memory[0x00:0x00]); } // Block terminates label_03D8: // Incoming jump from 0x03D3, if !msg.value // Inputs[1] { @03DF storage[0x0e] } 03D8 5B JUMPDEST 03D9 50 POP 03DA 61 PUSH2 0x03be 03DD 60 PUSH1 0x0e 03DF 54 SLOAD 03E0 81 DUP2 03E1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03DA stack[-1] = 0x03be // @03DF stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x03be label_03E2: // Incoming jump from 0x029A, if 0x18160ddd == stack[-1] // Inputs[1] { @03E3 msg.value } 03E2 5B JUMPDEST 03E3 34 CALLVALUE 03E4 80 DUP1 03E5 15 ISZERO 03E6 61 PUSH2 0x03ee 03E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E3 stack[0] = msg.value } // Block ends with conditional jump to 0x03ee, if !msg.value label_03EA: // Incoming jump from 0x03E9, if not !msg.value // Inputs[1] { @03ED memory[0x00:0x00] } 03EA 60 PUSH1 0x00 03EC 80 DUP1 03ED FD *REVERT // Stack delta = +0 // Outputs[1] { @03ED revert(memory[0x00:0x00]); } // Block terminates label_03EE: // Incoming jump from 0x03E9, if !msg.value // Inputs[1] { @03F2 storage[0x00] } 03EE 5B JUMPDEST 03EF 50 POP 03F0 60 PUSH1 0x00 03F2 54 SLOAD 03F3 61 PUSH2 0x03be 03F6 56 *JUMP // Stack delta = +0 // Outputs[1] { @03F2 stack[-1] = storage[0x00] } // Block ends with unconditional jump to 0x03be label_03F7: // Incoming jump from 0x02A5, if 0x19165587 == stack[-1] // Inputs[1] { @03F8 msg.value } 03F7 5B JUMPDEST 03F8 34 CALLVALUE 03F9 80 DUP1 03FA 15 ISZERO 03FB 61 PUSH2 0x0403 03FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0403, if !msg.value label_03FF: // Incoming jump from 0x03FE, if not !msg.value // Inputs[1] { @0402 memory[0x00:0x00] } 03FF 60 PUSH1 0x00 0401 80 DUP1 0402 FD *REVERT // Stack delta = +0 // Outputs[1] { @0402 revert(memory[0x00:0x00]); } // Block terminates label_0403: // Incoming jump from 0x03FE, if !msg.value // Inputs[1] { @040B msg.data.length } 0403 5B JUMPDEST 0404 50 POP 0405 61 PUSH2 0x03a6 0408 61 PUSH2 0x0412 040B 36 CALLDATASIZE 040C 60 PUSH1 0x04 040E 61 PUSH2 0x316d 0411 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0405 stack[-1] = 0x03a6 // @0408 stack[0] = 0x0412 // @040B stack[1] = msg.data.length // @040C stack[2] = 0x04 // } // Block ends with call to 0x316d, returns to 0x0412 label_0412: // Incoming return from call to 0x316D at 0x0411 0412 5B JUMPDEST 0413 61 PUSH2 0x0b72 0416 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b72 label_0417: // Incoming jump from 0x0269, if 0x23b872dd == stack[-1] // Inputs[1] { @0418 msg.value } 0417 5B JUMPDEST 0418 34 CALLVALUE 0419 80 DUP1 041A 15 ISZERO 041B 61 PUSH2 0x0423 041E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0418 stack[0] = msg.value } // Block ends with conditional jump to 0x0423, if !msg.value label_041F: // Incoming jump from 0x041E, if not !msg.value // Inputs[1] { @0422 memory[0x00:0x00] } 041F 60 PUSH1 0x00 0421 80 DUP1 0422 FD *REVERT // Stack delta = +0 // Outputs[1] { @0422 revert(memory[0x00:0x00]); } // Block terminates label_0423: // Incoming jump from 0x041E, if !msg.value // Inputs[1] { @042B msg.data.length } 0423 5B JUMPDEST 0424 50 POP 0425 61 PUSH2 0x03a6 0428 61 PUSH2 0x0432 042B 36 CALLDATASIZE 042C 60 PUSH1 0x04 042E 61 PUSH2 0x318a 0431 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0425 stack[-1] = 0x03a6 // @0428 stack[0] = 0x0432 // @042B stack[1] = msg.data.length // @042C stack[2] = 0x04 // } // Block ends with call to 0x318a, returns to 0x0432 label_0432: // Incoming return from call to 0x318A at 0x0431 0432 5B JUMPDEST 0433 61 PUSH2 0x0bed 0436 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bed label_0437: // Incoming jump from 0x0274, if 0x2f745c59 == stack[-1] // Inputs[1] { @0438 msg.value } 0437 5B JUMPDEST 0438 34 CALLVALUE 0439 80 DUP1 043A 15 ISZERO 043B 61 PUSH2 0x0443 043E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0438 stack[0] = msg.value } // Block ends with conditional jump to 0x0443, if !msg.value label_043F: // Incoming jump from 0x043E, if not !msg.value // Inputs[1] { @0442 memory[0x00:0x00] } 043F 60 PUSH1 0x00 0441 80 DUP1 0442 FD *REVERT // Stack delta = +0 // Outputs[1] { @0442 revert(memory[0x00:0x00]); } // Block terminates label_0443: // Incoming jump from 0x043E, if !msg.value // Inputs[1] { @044B msg.data.length } 0443 5B JUMPDEST 0444 50 POP 0445 61 PUSH2 0x03be 0448 61 PUSH2 0x0452 044B 36 CALLDATASIZE 044C 60 PUSH1 0x04 044E 61 PUSH2 0x3141 0451 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0445 stack[-1] = 0x03be // @0448 stack[0] = 0x0452 // @044B stack[1] = msg.data.length // @044C stack[2] = 0x04 // } // Block ends with call to 0x3141, returns to 0x0452 label_0452: // Incoming return from call to 0x3141 at 0x0451 0452 5B JUMPDEST 0453 61 PUSH2 0x0bf8 0456 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf8 label_0457: // Incoming jump from 0x027F, if 0x39a2e659 == stack[-1] // Inputs[1] { @0458 msg.value } 0457 5B JUMPDEST 0458 34 CALLVALUE 0459 80 DUP1 045A 15 ISZERO 045B 61 PUSH2 0x0463 045E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0458 stack[0] = msg.value } // Block ends with conditional jump to 0x0463, if !msg.value label_045F: // Incoming jump from 0x045E, if not !msg.value // Inputs[1] { @0462 memory[0x00:0x00] } 045F 60 PUSH1 0x00 0461 80 DUP1 0462 FD *REVERT // Stack delta = +0 // Outputs[1] { @0462 revert(memory[0x00:0x00]); } // Block terminates label_0463: // Incoming jump from 0x045E, if !msg.value // Inputs[1] { @046B msg.data.length } 0463 5B JUMPDEST 0464 50 POP 0465 61 PUSH2 0x03a6 0468 61 PUSH2 0x0472 046B 36 CALLDATASIZE 046C 60 PUSH1 0x04 046E 61 PUSH2 0x3113 0471 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0465 stack[-1] = 0x03a6 // @0468 stack[0] = 0x0472 // @046B stack[1] = msg.data.length // @046C stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x0472 label_0472: // Incoming return from call to 0x3113 at 0x0471 0472 5B JUMPDEST 0473 61 PUSH2 0x0d90 0476 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d90 label_0477: // Incoming jump from 0x0238, if 0x42842e0e == stack[-1] // Inputs[1] { @0478 msg.value } 0477 5B JUMPDEST 0478 34 CALLVALUE 0479 80 DUP1 047A 15 ISZERO 047B 61 PUSH2 0x0483 047E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0478 stack[0] = msg.value } // Block ends with conditional jump to 0x0483, if !msg.value label_047F: // Incoming jump from 0x047E, if not !msg.value // Inputs[1] { @0482 memory[0x00:0x00] } 047F 60 PUSH1 0x00 0481 80 DUP1 0482 FD *REVERT // Stack delta = +0 // Outputs[1] { @0482 revert(memory[0x00:0x00]); } // Block terminates label_0483: // Incoming jump from 0x047E, if !msg.value // Inputs[1] { @048B msg.data.length } 0483 5B JUMPDEST 0484 50 POP 0485 61 PUSH2 0x03a6 0488 61 PUSH2 0x0492 048B 36 CALLDATASIZE 048C 60 PUSH1 0x04 048E 61 PUSH2 0x318a 0491 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0485 stack[-1] = 0x03a6 // @0488 stack[0] = 0x0492 // @048B stack[1] = msg.data.length // @048C stack[2] = 0x04 // } // Block ends with call to 0x318a, returns to 0x0492 label_0492: // Incoming return from call to 0x318A at 0x0491 0492 5B JUMPDEST 0493 61 PUSH2 0x0def 0496 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0def label_0497: // Incoming jump from 0x0243, if 0x4f297ccc == stack[-1] // Inputs[1] { @0498 msg.value } 0497 5B JUMPDEST 0498 34 CALLVALUE 0499 80 DUP1 049A 15 ISZERO 049B 61 PUSH2 0x04a3 049E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0498 stack[0] = msg.value } // Block ends with conditional jump to 0x04a3, if !msg.value label_049F: // Incoming jump from 0x049E, if not !msg.value // Inputs[1] { @04A2 memory[0x00:0x00] } 049F 60 PUSH1 0x00 04A1 80 DUP1 04A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A2 revert(memory[0x00:0x00]); } // Block terminates label_04A3: // Incoming jump from 0x049E, if !msg.value // Inputs[1] { @04AA storage[0x12] } 04A3 5B JUMPDEST 04A4 50 POP 04A5 61 PUSH2 0x03be 04A8 60 PUSH1 0x12 04AA 54 SLOAD 04AB 81 DUP2 04AC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04A5 stack[-1] = 0x03be // @04AA stack[0] = storage[0x12] // } // Block ends with unconditional jump to 0x03be label_04AD: // Incoming jump from 0x0212, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @04AE msg.value } 04AD 5B JUMPDEST 04AE 34 CALLVALUE 04AF 80 DUP1 04B0 15 ISZERO 04B1 61 PUSH2 0x04b9 04B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AE stack[0] = msg.value } // Block ends with conditional jump to 0x04b9, if !msg.value label_04B5: // Incoming jump from 0x04B4, if not !msg.value // Inputs[1] { @04B8 memory[0x00:0x00] } 04B5 60 PUSH1 0x00 04B7 80 DUP1 04B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B8 revert(memory[0x00:0x00]); } // Block terminates label_04B9: // Incoming jump from 0x04B4, if !msg.value // Inputs[1] { @04C1 msg.data.length } 04B9 5B JUMPDEST 04BA 50 POP 04BB 61 PUSH2 0x03be 04BE 61 PUSH2 0x04c8 04C1 36 CALLDATASIZE 04C2 60 PUSH1 0x04 04C4 61 PUSH2 0x3113 04C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04BB stack[-1] = 0x03be // @04BE stack[0] = 0x04c8 // @04C1 stack[1] = msg.data.length // @04C2 stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x04C8 label_04C8: // Incoming return from call to 0x3113 at 0x04C7 04C8 5B JUMPDEST 04C9 61 PUSH2 0x0e0a 04CC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e0a label_04CD: // Incoming jump from 0x021D, if 0x55f804b3 == stack[-1] // Inputs[1] { @04CE msg.value } 04CD 5B JUMPDEST 04CE 34 CALLVALUE 04CF 80 DUP1 04D0 15 ISZERO 04D1 61 PUSH2 0x04d9 04D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CE stack[0] = msg.value } // Block ends with conditional jump to 0x04d9, if !msg.value label_04D5: // Incoming jump from 0x04D4, if not !msg.value // Inputs[1] { @04D8 memory[0x00:0x00] } 04D5 60 PUSH1 0x00 04D7 80 DUP1 04D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D8 revert(memory[0x00:0x00]); } // Block terminates label_04D9: // Incoming jump from 0x04D4, if !msg.value // Inputs[1] { @04E1 msg.data.length } 04D9 5B JUMPDEST 04DA 50 POP 04DB 61 PUSH2 0x03a6 04DE 61 PUSH2 0x04e8 04E1 36 CALLDATASIZE 04E2 60 PUSH1 0x04 04E4 61 PUSH2 0x3277 04E7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04DB stack[-1] = 0x03a6 // @04DE stack[0] = 0x04e8 // @04E1 stack[1] = msg.data.length // @04E2 stack[2] = 0x04 // } // Block ends with call to 0x3277, returns to 0x04E8 label_04E8: // Incoming return from call to 0x3277 at 0x04E7 04E8 5B JUMPDEST 04E9 61 PUSH2 0x0e86 04EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e86 label_04ED: // Incoming jump from 0x0228, if 0x571d34af == stack[-1] // Inputs[1] { @04EE msg.value } 04ED 5B JUMPDEST 04EE 34 CALLVALUE 04EF 80 DUP1 04F0 15 ISZERO 04F1 61 PUSH2 0x04f9 04F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04EE stack[0] = msg.value } // Block ends with conditional jump to 0x04f9, if !msg.value label_04F5: // Incoming jump from 0x04F4, if not !msg.value // Inputs[1] { @04F8 memory[0x00:0x00] } 04F5 60 PUSH1 0x00 04F7 80 DUP1 04F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F8 revert(memory[0x00:0x00]); } // Block terminates label_04F9: // Incoming jump from 0x04F4, if !msg.value // Inputs[1] { @0500 storage[0x15] } 04F9 5B JUMPDEST 04FA 50 POP 04FB 61 PUSH2 0x03be 04FE 60 PUSH1 0x15 0500 54 SLOAD 0501 81 DUP2 0502 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04FB stack[-1] = 0x03be // @0500 stack[0] = storage[0x15] // } // Block ends with unconditional jump to 0x03be label_0503: // Incoming jump from 0x01E1, if 0x5ca8a780 == stack[-1] // Inputs[1] { @050A msg.data.length } 0503 5B JUMPDEST 0504 61 PUSH2 0x03a6 0507 61 PUSH2 0x0511 050A 36 CALLDATASIZE 050B 60 PUSH1 0x04 050D 61 PUSH2 0x32f5 0510 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0504 stack[0] = 0x03a6 // @0507 stack[1] = 0x0511 // @050A stack[2] = msg.data.length // @050B stack[3] = 0x04 // } // Block ends with call to 0x32f5, returns to 0x0511 label_0511: // Incoming return from call to 0x32F5 at 0x0510 0511 5B JUMPDEST 0512 61 PUSH2 0x0ef7 0515 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ef7 label_0516: // Incoming jump from 0x01EC, if 0x6352211e == stack[-1] // Inputs[1] { @0517 msg.value } 0516 5B JUMPDEST 0517 34 CALLVALUE 0518 80 DUP1 0519 15 ISZERO 051A 61 PUSH2 0x0522 051D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0517 stack[0] = msg.value } // Block ends with conditional jump to 0x0522, if !msg.value label_051E: // Incoming jump from 0x051D, if not !msg.value // Inputs[1] { @0521 memory[0x00:0x00] } 051E 60 PUSH1 0x00 0520 80 DUP1 0521 FD *REVERT // Stack delta = +0 // Outputs[1] { @0521 revert(memory[0x00:0x00]); } // Block terminates label_0522: // Incoming jump from 0x051D, if !msg.value // Inputs[1] { @052A msg.data.length } 0522 5B JUMPDEST 0523 50 POP 0524 61 PUSH2 0x036e 0527 61 PUSH2 0x0531 052A 36 CALLDATASIZE 052B 60 PUSH1 0x04 052D 61 PUSH2 0x3113 0530 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0524 stack[-1] = 0x036e // @0527 stack[0] = 0x0531 // @052A stack[1] = msg.data.length // @052B stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x0531 label_0531: // Incoming return from call to 0x3113 at 0x0530 0531 5B JUMPDEST 0532 61 PUSH2 0x115b 0535 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x115b label_0536: // Incoming jump from 0x01F7, if 0x6ac5db19 == stack[-1] // Inputs[1] { @0537 msg.value } 0536 5B JUMPDEST 0537 34 CALLVALUE 0538 80 DUP1 0539 15 ISZERO 053A 61 PUSH2 0x0542 053D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0537 stack[0] = msg.value } // Block ends with conditional jump to 0x0542, if !msg.value label_053E: // Incoming jump from 0x053D, if not !msg.value // Inputs[1] { @0541 memory[0x00:0x00] } 053E 60 PUSH1 0x00 0540 80 DUP1 0541 FD *REVERT // Stack delta = +0 // Outputs[1] { @0541 revert(memory[0x00:0x00]); } // Block terminates label_0542: // Incoming jump from 0x053D, if !msg.value // Inputs[1] { @0549 storage[0x10] } 0542 5B JUMPDEST 0543 50 POP 0544 61 PUSH2 0x03be 0547 60 PUSH1 0x10 0549 54 SLOAD 054A 81 DUP2 054B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0544 stack[-1] = 0x03be // @0549 stack[0] = storage[0x10] // } // Block ends with unconditional jump to 0x03be label_054C: // Incoming jump from 0x01BB, if 0x706c1e6f == stack[-1] 054C 5B JUMPDEST 054D 61 PUSH2 0x03a6 0550 61 PUSH2 0x116d 0553 56 *JUMP // Stack delta = +1 // Outputs[1] { @054D stack[0] = 0x03a6 } // Block ends with call to 0x116d, returns to 0x03A6 label_0554: // Incoming jump from 0x01C6, if 0x70a08231 == stack[-1] // Inputs[1] { @0555 msg.value } 0554 5B JUMPDEST 0555 34 CALLVALUE 0556 80 DUP1 0557 15 ISZERO 0558 61 PUSH2 0x0560 055B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0555 stack[0] = msg.value } // Block ends with conditional jump to 0x0560, if !msg.value label_055C: // Incoming jump from 0x055B, if not !msg.value // Inputs[1] { @055F memory[0x00:0x00] } 055C 60 PUSH1 0x00 055E 80 DUP1 055F FD *REVERT // Stack delta = +0 // Outputs[1] { @055F revert(memory[0x00:0x00]); } // Block terminates label_0560: // Incoming jump from 0x055B, if !msg.value // Inputs[1] { @0568 msg.data.length } 0560 5B JUMPDEST 0561 50 POP 0562 61 PUSH2 0x03be 0565 61 PUSH2 0x056f 0568 36 CALLDATASIZE 0569 60 PUSH1 0x04 056B 61 PUSH2 0x316d 056E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0562 stack[-1] = 0x03be // @0565 stack[0] = 0x056f // @0568 stack[1] = msg.data.length // @0569 stack[2] = 0x04 // } // Block ends with call to 0x316d, returns to 0x056F label_056F: // Incoming return from call to 0x316D at 0x056E 056F 5B JUMPDEST 0570 61 PUSH2 0x122a 0573 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x122a label_0574: // Incoming jump from 0x01D1, if 0x715018a6 == stack[-1] // Inputs[1] { @0575 msg.value } 0574 5B JUMPDEST 0575 34 CALLVALUE 0576 80 DUP1 0577 15 ISZERO 0578 61 PUSH2 0x0580 057B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0575 stack[0] = msg.value } // Block ends with conditional jump to 0x0580, if !msg.value label_057C: // Incoming jump from 0x057B, if not !msg.value // Inputs[1] { @057F memory[0x00:0x00] } 057C 60 PUSH1 0x00 057E 80 DUP1 057F FD *REVERT // Stack delta = +0 // Outputs[1] { @057F revert(memory[0x00:0x00]); } // Block terminates label_0580: // Incoming jump from 0x057B, if !msg.value 0580 5B JUMPDEST 0581 50 POP 0582 61 PUSH2 0x03a6 0585 61 PUSH2 0x12cd 0588 56 *JUMP // Stack delta = +0 // Outputs[1] { @0582 stack[-1] = 0x03a6 } // Block ends with call to 0x12cd, returns to 0x03A6 label_0589: // Incoming jump from 0x017F, if 0x722e141d == stack[-1] // Inputs[1] { @058A msg.value } 0589 5B JUMPDEST 058A 34 CALLVALUE 058B 80 DUP1 058C 15 ISZERO 058D 61 PUSH2 0x0595 0590 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058A stack[0] = msg.value } // Block ends with conditional jump to 0x0595, if !msg.value label_0591: // Incoming jump from 0x0590, if not !msg.value // Inputs[1] { @0594 memory[0x00:0x00] } 0591 60 PUSH1 0x00 0593 80 DUP1 0594 FD *REVERT // Stack delta = +0 // Outputs[1] { @0594 revert(memory[0x00:0x00]); } // Block terminates label_0595: // Incoming jump from 0x0590, if !msg.value // Inputs[1] { @059C storage[0x14] } 0595 5B JUMPDEST 0596 50 POP 0597 61 PUSH2 0x03be 059A 60 PUSH1 0x14 059C 54 SLOAD 059D 81 DUP2 059E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0597 stack[-1] = 0x03be // @059C stack[0] = storage[0x14] // } // Block ends with unconditional jump to 0x03be label_059F: // Incoming jump from 0x018A, if 0x75dadb32 == stack[-1] // Inputs[1] { @05A0 msg.value } 059F 5B JUMPDEST 05A0 34 CALLVALUE 05A1 80 DUP1 05A2 15 ISZERO 05A3 61 PUSH2 0x05ab 05A6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A0 stack[0] = msg.value } // Block ends with conditional jump to 0x05ab, if !msg.value label_05A7: // Incoming jump from 0x05A6, if not !msg.value // Inputs[1] { @05AA memory[0x00:0x00] } 05A7 60 PUSH1 0x00 05A9 80 DUP1 05AA FD *REVERT // Stack delta = +0 // Outputs[1] { @05AA revert(memory[0x00:0x00]); } // Block terminates label_05AB: // Incoming jump from 0x05A6, if !msg.value 05AB 5B JUMPDEST 05AC 50 POP 05AD 61 PUSH2 0x0341 05B0 61 PUSH2 0x1333 05B3 56 *JUMP // Stack delta = +0 // Outputs[1] { @05AD stack[-1] = 0x0341 } // Block ends with call to 0x1333, returns to 0x0341 label_05B4: // Incoming jump from 0x0159, if 0x800fffd0 == stack[-1] // Inputs[1] { @05B5 msg.value } 05B4 5B JUMPDEST 05B5 34 CALLVALUE 05B6 80 DUP1 05B7 15 ISZERO 05B8 61 PUSH2 0x05c0 05BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B5 stack[0] = msg.value } // Block ends with conditional jump to 0x05c0, if !msg.value label_05BC: // Incoming jump from 0x05BB, if not !msg.value // Inputs[1] { @05BF memory[0x00:0x00] } 05BC 60 PUSH1 0x00 05BE 80 DUP1 05BF FD *REVERT // Stack delta = +0 // Outputs[1] { @05BF revert(memory[0x00:0x00]); } // Block terminates label_05C0: // Incoming jump from 0x05BB, if !msg.value // Inputs[1] { @05C8 msg.data.length } 05C0 5B JUMPDEST 05C1 50 POP 05C2 61 PUSH2 0x03be 05C5 61 PUSH2 0x05cf 05C8 36 CALLDATASIZE 05C9 60 PUSH1 0x04 05CB 61 PUSH2 0x316d 05CE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C2 stack[-1] = 0x03be // @05C5 stack[0] = 0x05cf // @05C8 stack[1] = msg.data.length // @05C9 stack[2] = 0x04 // } // Block ends with call to 0x316d, returns to 0x05CF label_05CF: // Incoming return from call to 0x316D at 0x05CE // Inputs[4] // { // @05D7 stack[-1] // @05DD memory[0x00:0x40] // @05DE storage[keccak256(memory[0x00:0x40])] // @05DF stack[-2] // } 05CF 5B JUMPDEST 05D0 60 PUSH1 0x0d 05D2 60 PUSH1 0x20 05D4 52 MSTORE 05D5 60 PUSH1 0x00 05D7 90 SWAP1 05D8 81 DUP2 05D9 52 MSTORE 05DA 60 PUSH1 0x40 05DC 90 SWAP1 05DD 20 SHA3 05DE 54 SLOAD 05DF 81 DUP2 05E0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @05D4 memory[0x20:0x40] = 0x0d // @05D9 memory[0x00:0x20] = stack[-1] // @05DE stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_05E1: // Incoming jump from 0x0164, if 0x851a7708 == stack[-1] // Inputs[1] { @05E2 msg.value } 05E1 5B JUMPDEST 05E2 34 CALLVALUE 05E3 80 DUP1 05E4 15 ISZERO 05E5 61 PUSH2 0x05ed 05E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E2 stack[0] = msg.value } // Block ends with conditional jump to 0x05ed, if !msg.value label_05E9: // Incoming jump from 0x05E8, if not !msg.value // Inputs[1] { @05EC memory[0x00:0x00] } 05E9 60 PUSH1 0x00 05EB 80 DUP1 05EC FD *REVERT // Stack delta = +0 // Outputs[1] { @05EC revert(memory[0x00:0x00]); } // Block terminates label_05ED: // Incoming jump from 0x05E8, if !msg.value // Inputs[1] { @05F5 msg.data.length } 05ED 5B JUMPDEST 05EE 50 POP 05EF 61 PUSH2 0x03be 05F2 61 PUSH2 0x05fc 05F5 36 CALLDATASIZE 05F6 60 PUSH1 0x04 05F8 61 PUSH2 0x316d 05FB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05EF stack[-1] = 0x03be // @05F2 stack[0] = 0x05fc // @05F5 stack[1] = msg.data.length // @05F6 stack[2] = 0x04 // } // Block ends with call to 0x316d, returns to 0x05FC label_05FC: // Incoming return from call to 0x316D at 0x05FB // Inputs[4] // { // @0604 stack[-1] // @060A memory[0x00:0x40] // @060B storage[keccak256(memory[0x00:0x40])] // @060C stack[-2] // } 05FC 5B JUMPDEST 05FD 60 PUSH1 0x0c 05FF 60 PUSH1 0x20 0601 52 MSTORE 0602 60 PUSH1 0x00 0604 90 SWAP1 0605 81 DUP2 0606 52 MSTORE 0607 60 PUSH1 0x40 0609 90 SWAP1 060A 20 SHA3 060B 54 SLOAD 060C 81 DUP2 060D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0601 memory[0x20:0x40] = 0x0c // @0606 memory[0x00:0x20] = stack[-1] // @060B stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_060E: // Incoming jump from 0x016F, if 0x85cb593b == stack[-1] // Inputs[1] { @060F msg.value } 060E 5B JUMPDEST 060F 34 CALLVALUE 0610 80 DUP1 0611 15 ISZERO 0612 61 PUSH2 0x061a 0615 57 *JUMPI // Stack delta = +1 // Outputs[1] { @060F stack[0] = msg.value } // Block ends with conditional jump to 0x061a, if !msg.value label_0616: // Incoming jump from 0x0615, if not !msg.value // Inputs[1] { @0619 memory[0x00:0x00] } 0616 60 PUSH1 0x00 0618 80 DUP1 0619 FD *REVERT // Stack delta = +0 // Outputs[1] { @0619 revert(memory[0x00:0x00]); } // Block terminates label_061A: // Incoming jump from 0x0615, if !msg.value // Inputs[1] { @0622 msg.data.length } 061A 5B JUMPDEST 061B 50 POP 061C 61 PUSH2 0x03a6 061F 61 PUSH2 0x0629 0622 36 CALLDATASIZE 0623 60 PUSH1 0x04 0625 61 PUSH2 0x3277 0628 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @061C stack[-1] = 0x03a6 // @061F stack[0] = 0x0629 // @0622 stack[1] = msg.data.length // @0623 stack[2] = 0x04 // } // Block ends with call to 0x3277, returns to 0x0629 label_0629: // Incoming return from call to 0x3277 at 0x0628 0629 5B JUMPDEST 062A 61 PUSH2 0x13c1 062D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13c1 label_062E: // Incoming jump from 0x0128, if 0x8da5cb5b == stack[-1] // Inputs[1] { @062F msg.value } 062E 5B JUMPDEST 062F 34 CALLVALUE 0630 80 DUP1 0631 15 ISZERO 0632 61 PUSH2 0x063a 0635 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062F stack[0] = msg.value } // Block ends with conditional jump to 0x063a, if !msg.value label_0636: // Incoming jump from 0x0635, if not !msg.value // Inputs[1] { @0639 memory[0x00:0x00] } 0636 60 PUSH1 0x00 0638 80 DUP1 0639 FD *REVERT // Stack delta = +0 // Outputs[1] { @0639 revert(memory[0x00:0x00]); } // Block terminates label_063A: // Incoming jump from 0x0635, if !msg.value // Inputs[1] { @063E storage[0x09] } 063A 5B JUMPDEST 063B 50 POP 063C 60 PUSH1 0x09 063E 54 SLOAD 063F 60 PUSH1 0x01 0641 60 PUSH1 0x01 0643 60 PUSH1 0xa0 0645 1B SHL 0646 03 SUB 0647 16 AND 0648 61 PUSH2 0x036e 064B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0647 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x09] } // Block ends with unconditional jump to 0x036e label_064C: // Incoming jump from 0x0133, if 0x91b7f5ed == stack[-1] // Inputs[1] { @064D msg.value } 064C 5B JUMPDEST 064D 34 CALLVALUE 064E 80 DUP1 064F 15 ISZERO 0650 61 PUSH2 0x0658 0653 57 *JUMPI // Stack delta = +1 // Outputs[1] { @064D stack[0] = msg.value } // Block ends with conditional jump to 0x0658, if !msg.value label_0654: // Incoming jump from 0x0653, if not !msg.value // Inputs[1] { @0657 memory[0x00:0x00] } 0654 60 PUSH1 0x00 0656 80 DUP1 0657 FD *REVERT // Stack delta = +0 // Outputs[1] { @0657 revert(memory[0x00:0x00]); } // Block terminates label_0658: // Incoming jump from 0x0653, if !msg.value // Inputs[1] { @0660 msg.data.length } 0658 5B JUMPDEST 0659 50 POP 065A 61 PUSH2 0x03a6 065D 61 PUSH2 0x0667 0660 36 CALLDATASIZE 0661 60 PUSH1 0x04 0663 61 PUSH2 0x3113 0666 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @065A stack[-1] = 0x03a6 // @065D stack[0] = 0x0667 // @0660 stack[1] = msg.data.length // @0661 stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x0667 label_0667: // Incoming return from call to 0x3113 at 0x0666 0667 5B JUMPDEST 0668 61 PUSH2 0x142e 066B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x142e label_066C: // Incoming jump from 0x013E, if 0x95d89b41 == stack[-1] // Inputs[1] { @066D msg.value } 066C 5B JUMPDEST 066D 34 CALLVALUE 066E 80 DUP1 066F 15 ISZERO 0670 61 PUSH2 0x0678 0673 57 *JUMPI // Stack delta = +1 // Outputs[1] { @066D stack[0] = msg.value } // Block ends with conditional jump to 0x0678, if !msg.value label_0674: // Incoming jump from 0x0673, if not !msg.value // Inputs[1] { @0677 memory[0x00:0x00] } 0674 60 PUSH1 0x00 0676 80 DUP1 0677 FD *REVERT // Stack delta = +0 // Outputs[1] { @0677 revert(memory[0x00:0x00]); } // Block terminates label_0678: // Incoming jump from 0x0673, if !msg.value 0678 5B JUMPDEST 0679 50 POP 067A 61 PUSH2 0x0341 067D 61 PUSH2 0x148d 0680 56 *JUMP // Stack delta = +0 // Outputs[1] { @067A stack[-1] = 0x0341 } // Block ends with call to 0x148d, returns to 0x0341 label_0681: // Incoming jump from 0x0102, if 0x9a5d140b == stack[-1] // Inputs[1] { @0682 msg.value } 0681 5B JUMPDEST 0682 34 CALLVALUE 0683 80 DUP1 0684 15 ISZERO 0685 61 PUSH2 0x068d 0688 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0682 stack[0] = msg.value } // Block ends with conditional jump to 0x068d, if !msg.value label_0689: // Incoming jump from 0x0688, if not !msg.value // Inputs[1] { @068C memory[0x00:0x00] } 0689 60 PUSH1 0x00 068B 80 DUP1 068C FD *REVERT // Stack delta = +0 // Outputs[1] { @068C revert(memory[0x00:0x00]); } // Block terminates label_068D: // Incoming jump from 0x0688, if !msg.value // Inputs[1] { @0695 msg.data.length } 068D 5B JUMPDEST 068E 50 POP 068F 61 PUSH2 0x03a6 0692 61 PUSH2 0x069c 0695 36 CALLDATASIZE 0696 60 PUSH1 0x04 0698 61 PUSH2 0x3113 069B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @068F stack[-1] = 0x03a6 // @0692 stack[0] = 0x069c // @0695 stack[1] = msg.data.length // @0696 stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x069C label_069C: // Incoming return from call to 0x3113 at 0x069B 069C 5B JUMPDEST 069D 61 PUSH2 0x149c 06A0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x149c label_06A1: // Incoming jump from 0x010D, if 0xa035b1fe == stack[-1] // Inputs[1] { @06A2 msg.value } 06A1 5B JUMPDEST 06A2 34 CALLVALUE 06A3 80 DUP1 06A4 15 ISZERO 06A5 61 PUSH2 0x06ad 06A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A2 stack[0] = msg.value } // Block ends with conditional jump to 0x06ad, if !msg.value label_06A9: // Incoming jump from 0x06A8, if not !msg.value // Inputs[1] { @06AC memory[0x00:0x00] } 06A9 60 PUSH1 0x00 06AB 80 DUP1 06AC FD *REVERT // Stack delta = +0 // Outputs[1] { @06AC revert(memory[0x00:0x00]); } // Block terminates label_06AD: // Incoming jump from 0x06A8, if !msg.value // Inputs[1] { @06B4 storage[0x13] } 06AD 5B JUMPDEST 06AE 50 POP 06AF 61 PUSH2 0x03be 06B2 60 PUSH1 0x13 06B4 54 SLOAD 06B5 81 DUP2 06B6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06AF stack[-1] = 0x03be // @06B4 stack[0] = storage[0x13] // } // Block ends with unconditional jump to 0x03be label_06B7: // Incoming jump from 0x0118, if 0xa22cb465 == stack[-1] // Inputs[1] { @06B8 msg.value } 06B7 5B JUMPDEST 06B8 34 CALLVALUE 06B9 80 DUP1 06BA 15 ISZERO 06BB 61 PUSH2 0x06c3 06BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B8 stack[0] = msg.value } // Block ends with conditional jump to 0x06c3, if !msg.value label_06BF: // Incoming jump from 0x06BE, if not !msg.value // Inputs[1] { @06C2 memory[0x00:0x00] } 06BF 60 PUSH1 0x00 06C1 80 DUP1 06C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C2 revert(memory[0x00:0x00]); } // Block terminates label_06C3: // Incoming jump from 0x06BE, if !msg.value // Inputs[1] { @06CB msg.data.length } 06C3 5B JUMPDEST 06C4 50 POP 06C5 61 PUSH2 0x03a6 06C8 61 PUSH2 0x06d2 06CB 36 CALLDATASIZE 06CC 60 PUSH1 0x04 06CE 61 PUSH2 0x3353 06D1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06C5 stack[-1] = 0x03a6 // @06C8 stack[0] = 0x06d2 // @06CB stack[1] = msg.data.length // @06CC stack[2] = 0x04 // } // Block ends with call to 0x3353, returns to 0x06D2 label_06D2: // Incoming return from call to 0x3353 at 0x06D1 06D2 5B JUMPDEST 06D3 61 PUSH2 0x168b 06D6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x168b label_06D7: // Incoming jump from 0x00C6, if 0xb27a87b0 == stack[-1] // Inputs[1] { @06DE msg.data.length } 06D7 5B JUMPDEST 06D8 61 PUSH2 0x03a6 06DB 61 PUSH2 0x06e5 06DE 36 CALLDATASIZE 06DF 60 PUSH1 0x04 06E1 61 PUSH2 0x3391 06E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06D8 stack[0] = 0x03a6 // @06DB stack[1] = 0x06e5 // @06DE stack[2] = msg.data.length // @06DF stack[3] = 0x04 // } // Block ends with call to 0x3391, returns to 0x06E5 label_06E5: // Incoming return from call to 0x3391 at 0x06E4 06E5 5B JUMPDEST 06E6 61 PUSH2 0x1750 06E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1750 label_06EA: // Incoming jump from 0x00D1, if 0xb6183b05 == stack[-1] // Inputs[1] { @06EB msg.value } 06EA 5B JUMPDEST 06EB 34 CALLVALUE 06EC 80 DUP1 06ED 15 ISZERO 06EE 61 PUSH2 0x06f6 06F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06EB stack[0] = msg.value } // Block ends with conditional jump to 0x06f6, if !msg.value label_06F2: // Incoming jump from 0x06F1, if not !msg.value // Inputs[1] { @06F5 memory[0x00:0x00] } 06F2 60 PUSH1 0x00 06F4 80 DUP1 06F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F5 revert(memory[0x00:0x00]); } // Block terminates label_06F6: // Incoming jump from 0x06F1, if !msg.value // Inputs[1] { @06FE msg.data.length } 06F6 5B JUMPDEST 06F7 50 POP 06F8 61 PUSH2 0x03a6 06FB 61 PUSH2 0x0705 06FE 36 CALLDATASIZE 06FF 60 PUSH1 0x04 0701 61 PUSH2 0x33e4 0704 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06F8 stack[-1] = 0x03a6 // @06FB stack[0] = 0x0705 // @06FE stack[1] = msg.data.length // @06FF stack[2] = 0x04 // } // Block ends with call to 0x33e4, returns to 0x0705 label_0705: // Incoming return from call to 0x33E4 at 0x0704 0705 5B JUMPDEST 0706 61 PUSH2 0x191e 0709 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x191e label_070A: // Incoming jump from 0x00DC, if 0xb88d4fde == stack[-1] // Inputs[1] { @070B msg.value } 070A 5B JUMPDEST 070B 34 CALLVALUE 070C 80 DUP1 070D 15 ISZERO 070E 61 PUSH2 0x0716 0711 57 *JUMPI // Stack delta = +1 // Outputs[1] { @070B stack[0] = msg.value } // Block ends with conditional jump to 0x0716, if !msg.value label_0712: // Incoming jump from 0x0711, if not !msg.value // Inputs[1] { @0715 memory[0x00:0x00] } 0712 60 PUSH1 0x00 0714 80 DUP1 0715 FD *REVERT // Stack delta = +0 // Outputs[1] { @0715 revert(memory[0x00:0x00]); } // Block terminates label_0716: // Incoming jump from 0x0711, if !msg.value // Inputs[1] { @071E msg.data.length } 0716 5B JUMPDEST 0717 50 POP 0718 61 PUSH2 0x03a6 071B 61 PUSH2 0x0725 071E 36 CALLDATASIZE 071F 60 PUSH1 0x04 0721 61 PUSH2 0x346b 0724 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0718 stack[-1] = 0x03a6 // @071B stack[0] = 0x0725 // @071E stack[1] = msg.data.length // @071F stack[2] = 0x04 // } // Block ends with call to 0x346b, returns to 0x0725 label_0725: // Incoming return from call to 0x346B at 0x0724 0725 5B JUMPDEST 0726 61 PUSH2 0x1b7a 0729 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b7a label_072A: // Incoming jump from 0x00A0, if 0xc0ac9983 == stack[-1] // Inputs[1] { @072B msg.value } 072A 5B JUMPDEST 072B 34 CALLVALUE 072C 80 DUP1 072D 15 ISZERO 072E 61 PUSH2 0x0736 0731 57 *JUMPI // Stack delta = +1 // Outputs[1] { @072B stack[0] = msg.value } // Block ends with conditional jump to 0x0736, if !msg.value label_0732: // Incoming jump from 0x0731, if not !msg.value // Inputs[1] { @0735 memory[0x00:0x00] } 0732 60 PUSH1 0x00 0734 80 DUP1 0735 FD *REVERT // Stack delta = +0 // Outputs[1] { @0735 revert(memory[0x00:0x00]); } // Block terminates label_0736: // Incoming jump from 0x0731, if !msg.value 0736 5B JUMPDEST 0737 50 POP 0738 61 PUSH2 0x0341 073B 61 PUSH2 0x1c09 073E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0738 stack[-1] = 0x0341 } // Block ends with call to 0x1c09, returns to 0x0341 label_073F: // Incoming jump from 0x00AB, if 0xc87b56dd == stack[-1] // Inputs[1] { @0740 msg.value } 073F 5B JUMPDEST 0740 34 CALLVALUE 0741 80 DUP1 0742 15 ISZERO 0743 61 PUSH2 0x074b 0746 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0740 stack[0] = msg.value } // Block ends with conditional jump to 0x074b, if !msg.value label_0747: // Incoming jump from 0x0746, if not !msg.value // Inputs[1] { @074A memory[0x00:0x00] } 0747 60 PUSH1 0x00 0749 80 DUP1 074A FD *REVERT // Stack delta = +0 // Outputs[1] { @074A revert(memory[0x00:0x00]); } // Block terminates label_074B: // Incoming jump from 0x0746, if !msg.value // Inputs[1] { @0753 msg.data.length } 074B 5B JUMPDEST 074C 50 POP 074D 61 PUSH2 0x0341 0750 61 PUSH2 0x075a 0753 36 CALLDATASIZE 0754 60 PUSH1 0x04 0756 61 PUSH2 0x3113 0759 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @074D stack[-1] = 0x0341 // @0750 stack[0] = 0x075a // @0753 stack[1] = msg.data.length // @0754 stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x075A label_075A: // Incoming return from call to 0x3113 at 0x0759 075A 5B JUMPDEST 075B 61 PUSH2 0x1c16 075E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1c16 label_075F: // Incoming jump from 0x00B6, if 0xd7224ba0 == stack[-1] // Inputs[1] { @0760 msg.value } 075F 5B JUMPDEST 0760 34 CALLVALUE 0761 80 DUP1 0762 15 ISZERO 0763 61 PUSH2 0x076b 0766 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0760 stack[0] = msg.value } // Block ends with conditional jump to 0x076b, if !msg.value label_0767: // Incoming jump from 0x0766, if not !msg.value // Inputs[1] { @076A memory[0x00:0x00] } 0767 60 PUSH1 0x00 0769 80 DUP1 076A FD *REVERT // Stack delta = +0 // Outputs[1] { @076A revert(memory[0x00:0x00]); } // Block terminates label_076B: // Incoming jump from 0x0766, if !msg.value // Inputs[1] { @0772 storage[0x07] } 076B 5B JUMPDEST 076C 50 POP 076D 61 PUSH2 0x03be 0770 60 PUSH1 0x07 0772 54 SLOAD 0773 81 DUP2 0774 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @076D stack[-1] = 0x03be // @0772 stack[0] = storage[0x07] // } // Block ends with unconditional jump to 0x03be label_0775: // Incoming jump from 0x006F, if 0xd73b2a6c == stack[-1] // Inputs[1] { @0776 msg.value } 0775 5B JUMPDEST 0776 34 CALLVALUE 0777 80 DUP1 0778 15 ISZERO 0779 61 PUSH2 0x0781 077C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0776 stack[0] = msg.value } // Block ends with conditional jump to 0x0781, if !msg.value label_077D: // Incoming jump from 0x077C, if not !msg.value // Inputs[1] { @0780 memory[0x00:0x00] } 077D 60 PUSH1 0x00 077F 80 DUP1 0780 FD *REVERT // Stack delta = +0 // Outputs[1] { @0780 revert(memory[0x00:0x00]); } // Block terminates label_0781: // Incoming jump from 0x077C, if !msg.value // Inputs[1] { @0788 storage[0x0f] } 0781 5B JUMPDEST 0782 50 POP 0783 61 PUSH2 0x03be 0786 60 PUSH1 0x0f 0788 54 SLOAD 0789 81 DUP2 078A 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0783 stack[-1] = 0x03be // @0788 stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x03be label_078B: // Incoming jump from 0x007A, if 0xd87a1eeb == stack[-1] // Inputs[1] { @078C msg.value } 078B 5B JUMPDEST 078C 34 CALLVALUE 078D 80 DUP1 078E 15 ISZERO 078F 61 PUSH2 0x0797 0792 57 *JUMPI // Stack delta = +1 // Outputs[1] { @078C stack[0] = msg.value } // Block ends with conditional jump to 0x0797, if !msg.value label_0793: // Incoming jump from 0x0792, if not !msg.value // Inputs[1] { @0796 memory[0x00:0x00] } 0793 60 PUSH1 0x00 0795 80 DUP1 0796 FD *REVERT // Stack delta = +0 // Outputs[1] { @0796 revert(memory[0x00:0x00]); } // Block terminates label_0797: // Incoming jump from 0x0792, if !msg.value 0797 5B JUMPDEST 0798 50 POP 0799 61 PUSH2 0x0341 079C 61 PUSH2 0x1d28 079F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0799 stack[-1] = 0x0341 } // Block ends with call to 0x1d28, returns to 0x0341 label_07A0: // Incoming jump from 0x0085, if 0xe2146963 == stack[-1] // Inputs[1] { @07A1 msg.value } 07A0 5B JUMPDEST 07A1 34 CALLVALUE 07A2 80 DUP1 07A3 15 ISZERO 07A4 61 PUSH2 0x07ac 07A7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07A1 stack[0] = msg.value } // Block ends with conditional jump to 0x07ac, if !msg.value label_07A8: // Incoming jump from 0x07A7, if not !msg.value // 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 jump from 0x07A7, if !msg.value // Inputs[1] { @07B4 msg.data.length } 07AC 5B JUMPDEST 07AD 50 POP 07AE 61 PUSH2 0x03a6 07B1 61 PUSH2 0x07bb 07B4 36 CALLDATASIZE 07B5 60 PUSH1 0x04 07B7 61 PUSH2 0x3113 07BA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07AE stack[-1] = 0x03a6 // @07B1 stack[0] = 0x07bb // @07B4 stack[1] = msg.data.length // @07B5 stack[2] = 0x04 // } // Block ends with call to 0x3113, returns to 0x07BB label_07BB: // Incoming return from call to 0x3113 at 0x07BA 07BB 5B JUMPDEST 07BC 61 PUSH2 0x1d35 07BF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d35 label_07C0: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @07C1 msg.value } 07C0 5B JUMPDEST 07C1 34 CALLVALUE 07C2 80 DUP1 07C3 15 ISZERO 07C4 61 PUSH2 0x07cc 07C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07C1 stack[0] = msg.value } // Block ends with conditional jump to 0x07cc, if !msg.value label_07C8: // Incoming jump from 0x07C7, if not !msg.value // Inputs[1] { @07CB memory[0x00:0x00] } 07C8 60 PUSH1 0x00 07CA 80 DUP1 07CB FD *REVERT // Stack delta = +0 // Outputs[1] { @07CB revert(memory[0x00:0x00]); } // Block terminates label_07CC: // Incoming jump from 0x07C7, if !msg.value // Inputs[1] { @07D4 msg.data.length } 07CC 5B JUMPDEST 07CD 50 POP 07CE 61 PUSH2 0x0317 07D1 61 PUSH2 0x07db 07D4 36 CALLDATASIZE 07D5 60 PUSH1 0x04 07D7 61 PUSH2 0x34eb 07DA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07CE stack[-1] = 0x0317 // @07D1 stack[0] = 0x07db // @07D4 stack[1] = msg.data.length // @07D5 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x34eb label_07DB: // Incoming call from 0x1FCB, returns to 0x1FCC // Incoming call from 0x0AEF, returns to 0x0AF0 // Inputs[6] // { // @07E4 stack[-2] // @07F7 memory[0x00:0x40] // @07F8 stack[-1] // @0802 memory[0x00:0x40] // @0803 storage[keccak256(memory[0x00:0x40])] // @0807 stack[-3] // } 07DB 5B JUMPDEST 07DC 60 PUSH1 0x01 07DE 60 PUSH1 0x01 07E0 60 PUSH1 0xa0 07E2 1B SHL 07E3 03 SUB 07E4 91 SWAP2 07E5 82 DUP3 07E6 16 AND 07E7 60 PUSH1 0x00 07E9 90 SWAP1 07EA 81 DUP2 07EB 52 MSTORE 07EC 60 PUSH1 0x06 07EE 60 PUSH1 0x20 07F0 90 SWAP1 07F1 81 DUP2 07F2 52 MSTORE 07F3 60 PUSH1 0x40 07F5 80 DUP1 07F6 83 DUP4 07F7 20 SHA3 07F8 93 SWAP4 07F9 90 SWAP1 07FA 94 SWAP5 07FB 16 AND 07FC 82 DUP3 07FD 52 MSTORE 07FE 91 SWAP2 07FF 90 SWAP1 0800 91 SWAP2 0801 52 MSTORE 0802 20 SHA3 0803 54 SLOAD 0804 60 PUSH1 0xff 0806 16 AND 0807 90 SWAP1 0808 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @07EB memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @07F2 memory[0x20:0x40] = 0x06 // @07FD memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0801 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0807 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0809: // Incoming jump from 0x0054, if 0xefd0cbf9 == stack[-1] // Inputs[1] { @0810 msg.data.length } 0809 5B JUMPDEST 080A 61 PUSH2 0x03a6 080D 61 PUSH2 0x0817 0810 36 CALLDATASIZE 0811 60 PUSH1 0x04 0813 61 PUSH2 0x3113 0816 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @080A stack[0] = 0x03a6 // @080D stack[1] = 0x0817 // @0810 stack[2] = msg.data.length // @0811 stack[3] = 0x04 // } // Block ends with call to 0x3113, returns to 0x0817 label_0817: // Incoming return from call to 0x3113 at 0x0816 0817 5B JUMPDEST 0818 61 PUSH2 0x1d94 081B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d94 label_081C: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @081D msg.value } 081C 5B JUMPDEST 081D 34 CALLVALUE 081E 80 DUP1 081F 15 ISZERO 0820 61 PUSH2 0x0828 0823 57 *JUMPI // Stack delta = +1 // Outputs[1] { @081D stack[0] = msg.value } // Block ends with conditional jump to 0x0828, if !msg.value label_0824: // Incoming jump from 0x0823, if not !msg.value // Inputs[1] { @0827 memory[0x00:0x00] } 0824 60 PUSH1 0x00 0826 80 DUP1 0827 FD *REVERT // Stack delta = +0 // Outputs[1] { @0827 revert(memory[0x00:0x00]); } // Block terminates label_0828: // Incoming jump from 0x0823, if !msg.value // Inputs[1] { @0830 msg.data.length } 0828 5B JUMPDEST 0829 50 POP 082A 61 PUSH2 0x03a6 082D 61 PUSH2 0x0837 0830 36 CALLDATASIZE 0831 60 PUSH1 0x04 0833 61 PUSH2 0x316d 0836 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @082A stack[-1] = 0x03a6 // @082D stack[0] = 0x0837 // @0830 stack[1] = msg.data.length // @0831 stack[2] = 0x04 // } // Block ends with call to 0x316d, returns to 0x0837 label_0837: // Incoming return from call to 0x316D at 0x0836 0837 5B JUMPDEST 0838 61 PUSH2 0x1e30 083B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1e30 label_083C: // Incoming jump from 0x0316 // Inputs[1] { @0848 stack[-1] } 083C 5B JUMPDEST 083D 60 PUSH1 0x00 083F 60 PUSH1 0x01 0841 60 PUSH1 0x01 0843 60 PUSH1 0xe0 0845 1B SHL 0846 03 SUB 0847 19 NOT 0848 82 DUP3 0849 16 AND 084A 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 086B 14 EQ 086C 80 DUP1 086D 61 PUSH2 0x089f 0870 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @083D stack[0] = 0x00 // @086B stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x089f, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0871: // Incoming jump from 0x0870, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @087B stack[-3] } 0871 50 POP 0872 60 PUSH1 0x01 0874 60 PUSH1 0x01 0876 60 PUSH1 0xe0 0878 1B SHL 0879 03 SUB 087A 19 NOT 087B 82 DUP3 087C 16 AND 087D 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 089E 14 EQ 089F 5B JUMPDEST 08A0 80 DUP1 08A1 61 PUSH2 0x08d3 08A4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @089E stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x08d3, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_08A5: // Incoming jump from 0x08A4, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x08A4, if not stack[-1] // Inputs[1] { @08AF stack[-3] } 08A5 50 POP 08A6 60 PUSH1 0x01 08A8 60 PUSH1 0x01 08AA 60 PUSH1 0xe0 08AC 1B SHL 08AD 03 SUB 08AE 19 NOT 08AF 82 DUP3 08B0 16 AND 08B1 7F PUSH32 0x780e9d6300000000000000000000000000000000000000000000000000000000 08D2 14 EQ 08D3 5B JUMPDEST 08D4 80 DUP1 08D5 61 PUSH2 0x0907 08D8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @08D2 stack[-1] = 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0907, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_08D9: // Incoming jump from 0x08D8, if not 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x08D8, if not stack[-1] // Inputs[2] // { // @0904 stack[-3] // @0908 stack[-4] // } 08D9 50 POP 08DA 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 08FB 60 PUSH1 0x01 08FD 60 PUSH1 0x01 08FF 60 PUSH1 0xe0 0901 1B SHL 0902 03 SUB 0903 19 NOT 0904 83 DUP4 0905 16 AND 0906 14 EQ 0907 5B JUMPDEST 0908 92 SWAP3 0909 91 SWAP2 090A 50 POP 090B 50 POP 090C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0908 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-4] label_090D: // Incoming call from 0x0340, returns to 0x0341 // Inputs[1] { @0913 storage[0x01] } 090D 5B JUMPDEST 090E 60 PUSH1 0x60 0910 60 PUSH1 0x01 0912 80 DUP1 0913 54 SLOAD 0914 61 PUSH2 0x091c 0917 90 SWAP1 0918 61 PUSH2 0x3519 091B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @090E stack[0] = 0x60 // @0910 stack[1] = 0x01 // @0917 stack[2] = 0x091c // @0917 stack[3] = storage[0x01] // } // Block ends with call to 0x3519, returns to 0x091C label_091C: // Incoming return from call to 0x3519 at 0x149B // Incoming return from call to 0x3519 at 0x091B // Inputs[4] // { // @091D stack[-1] // @092C memory[0x40:0x60] // @0934 stack[-2] // @093F storage[stack[-2]] // } 091C 5B JUMPDEST 091D 80 DUP1 091E 60 PUSH1 0x1f 0920 01 ADD 0921 60 PUSH1 0x20 0923 80 DUP1 0924 91 SWAP2 0925 04 DIV 0926 02 MUL 0927 60 PUSH1 0x20 0929 01 ADD 092A 60 PUSH1 0x40 092C 51 MLOAD 092D 90 SWAP1 092E 81 DUP2 092F 01 ADD 0930 60 PUSH1 0x40 0932 52 MSTORE 0933 80 DUP1 0934 92 SWAP3 0935 91 SWAP2 0936 90 SWAP1 0937 81 DUP2 0938 81 DUP2 0939 52 MSTORE 093A 60 PUSH1 0x20 093C 01 ADD 093D 82 DUP3 093E 80 DUP1 093F 54 SLOAD 0940 61 PUSH2 0x0948 0943 90 SWAP1 0944 61 PUSH2 0x3519 0947 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0932 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0934 stack[-2] = memory[0x40:0x60] // @0935 stack[-1] = stack[-2] // @0936 stack[0] = stack[-1] // @0939 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @093C stack[1] = 0x20 + memory[0x40:0x60] // @093D stack[2] = stack[-2] // @0943 stack[4] = storage[stack[-2]] // @0943 stack[3] = 0x0948 // } // Block ends with call to 0x3519, returns to 0x0948 label_0948: // Incoming return from call to 0x3519 at 0x0947 // Inputs[1] { @0949 stack[-1] } 0948 5B JUMPDEST 0949 80 DUP1 094A 15 ISZERO 094B 61 PUSH2 0x0995 094E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0995, if !stack[-1] label_094F: // Incoming jump from 0x094E, if not !stack[-1] // Inputs[1] { @094F stack[-1] } 094F 80 DUP1 0950 60 PUSH1 0x1f 0952 10 LT 0953 61 PUSH2 0x096a 0956 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x096a, if 0x1f < stack[-1] label_0957: // Incoming jump from 0x0956, if not 0x1f < stack[-1] // Inputs[4] // { // @095B stack[-2] // @095C storage[stack[-2]] // @095F stack[-3] // @0961 stack[-1] // } 0957 61 PUSH2 0x0100 095A 80 DUP1 095B 83 DUP4 095C 54 SLOAD 095D 04 DIV 095E 02 MUL 095F 83 DUP4 0960 52 MSTORE 0961 91 SWAP2 0962 60 PUSH1 0x20 0964 01 ADD 0965 91 SWAP2 0966 61 PUSH2 0x0995 0969 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0960 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0965 stack[-1] = stack[-1] // @0965 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0995 label_096A: // Incoming jump from 0x0956, if 0x1f < stack[-1] // Inputs[5] // { // @096B stack[-3] // @096C stack[-1] // @096E stack[-2] // @0976 memory[0x00:0x20] // @097A storage[keccak256(memory[0x00:0x20])] // } 096A 5B JUMPDEST 096B 82 DUP3 096C 01 ADD 096D 91 SWAP2 096E 90 SWAP1 096F 60 PUSH1 0x00 0971 52 MSTORE 0972 60 PUSH1 0x20 0974 60 PUSH1 0x00 0976 20 SHA3 0977 90 SWAP1 0978 5B JUMPDEST 0979 81 DUP2 097A 54 SLOAD 097B 81 DUP2 097C 52 MSTORE 097D 90 SWAP1 097E 60 PUSH1 0x01 0980 01 ADD 0981 90 SWAP1 0982 60 PUSH1 0x20 0984 01 ADD 0985 80 DUP1 0986 83 DUP4 0987 11 GT 0988 61 PUSH2 0x0978 098B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @096D stack[-3] = stack[-3] + stack[-1] // @0971 memory[0x00:0x20] = stack[-2] // @097C memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0981 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0984 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0978, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_098C: // Incoming jump from 0x098B, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x098B, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @098C stack[-3] // @098D stack[-1] // } 098C 82 DUP3 098D 90 SWAP1 098E 03 SUB 098F 60 PUSH1 0x1f 0991 16 AND 0992 82 DUP3 0993 01 ADD 0994 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0994 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0994 stack[-1] = stack[-3] // } // Block continues label_0995: // Incoming jump from 0x094E, if !stack[-1] // Incoming jump from 0x0994 // Incoming jump from 0x0969 // Inputs[3] // { // @099B stack[-7] // @099B stack[-6] // @099D stack[-8] // } 0995 5B JUMPDEST 0996 50 POP 0997 50 POP 0998 50 POP 0999 50 POP 099A 50 POP 099B 90 SWAP1 099C 50 POP 099D 90 SWAP1 099E 56 *JUMP // Stack delta = -7 // Outputs[1] { @099D stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_099F: // Incoming call from 0x1FAE, returns to 0x1FAF // Incoming jump from 0x036D // Inputs[2] // { // @09A5 stack[-1] // @09A8 storage[0x00] // } 099F 5B JUMPDEST 09A0 60 PUSH1 0x00 09A2 61 PUSH2 0x09ac 09A5 82 DUP3 09A6 60 PUSH1 0x00 09A8 54 SLOAD 09A9 11 GT 09AA 90 SWAP1 09AB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09A0 stack[0] = 0x00 // @09AA stack[1] = storage[0x00] > stack[-1] // } // Block ends with unconditional jump to 0x09ac label_09AC: // Incoming jump from 0x09AB // Inputs[1] { @09B0 stack[-1] } 09AC 5B JUMPDEST 09AD 61 PUSH2 0x0a23 09B0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a23, if stack[-1] label_09B1: // Incoming jump from 0x09B0, if not stack[-1] // Inputs[1] { @09B3 memory[0x40:0x60] } 09B1 60 PUSH1 0x40 09B3 51 MLOAD 09B4 62 PUSH3 0x461bcd 09B8 60 PUSH1 0xe5 09BA 1B SHL 09BB 81 DUP2 09BC 52 MSTORE 09BD 60 PUSH1 0x20 09BF 60 PUSH1 0x04 09C1 82 DUP3 09C2 01 ADD 09C3 52 MSTORE 09C4 60 PUSH1 0x2d 09C6 60 PUSH1 0x24 09C8 82 DUP3 09C9 01 ADD 09CA 52 MSTORE 09CB 7F PUSH32 0x455243373231413a20617070726f76656420717565727920666f72206e6f6e65 09EC 60 PUSH1 0x44 09EE 82 DUP3 09EF 01 ADD 09F0 52 MSTORE 09F1 7F PUSH32 0x78697374656e7420746f6b656e00000000000000000000000000000000000000 0A12 60 PUSH1 0x64 0A14 82 DUP3 0A15 01 ADD 0A16 52 MSTORE 0A17 60 PUSH1 0x84 0A19 01 ADD // Stack delta = +1 // Outputs[6] // { // @09BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @09F0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f76656420717565727920666f72206e6f6e65 // @0A16 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x78697374656e7420746f6b656e00000000000000000000000000000000000000 // @0A19 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0A1A: // Incoming jump from 0x12A7 // Incoming jump from 0x2BF7 // Incoming jump from 0x14F5 // Incoming jump from 0x2EE1 // Incoming jump from 0x1D8E // Incoming jump from 0x1546 // Incoming jump from 0x20CB // Incoming jump from 0x2E75 // Incoming jump from 0x291F // Incoming jump from 0x1326 // Incoming jump from 0x1E89 // Incoming jump from 0x2403 // Incoming jump from 0x1DFF // Incoming jump from 0x0D8F // Incoming jump from 0x2147 // Incoming jump from 0x0AD3 // Incoming jump from 0x24EF // Incoming jump from 0x2454 // Incoming jump from 0x2629 // Incoming jump from 0x1615 // Incoming jump from 0x0C76 // Incoming jump from 0x2977 // Incoming jump from 0x1487 // Incoming jump from 0x2F98 // Incoming jump from 0x1C6E // Incoming jump from 0x2040 // Incoming jump from 0x2A0D // Incoming jump from 0x16E3 // Incoming jump from 0x0A19 // Incoming jump from 0x11C6 // Incoming jump from 0x0E81 // Incoming jump from 0x0DE9 // Incoming jump from 0x1F05 // Incoming jump from 0x141A // Incoming jump from 0x0B61 // Incoming jump from 0x2DF8 // Incoming jump from 0x0EDF // Inputs[3] // { // @0A1D memory[0x40:0x60] // @0A1F stack[-1] // @0A22 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A1A 5B JUMPDEST 0A1B 60 PUSH1 0x40 0A1D 51 MLOAD 0A1E 80 DUP1 0A1F 91 SWAP2 0A20 03 SUB 0A21 90 SWAP1 0A22 FD *REVERT // Stack delta = -1 // Outputs[1] { @0A22 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0A23: // Incoming jump from 0x09B0, if stack[-1] // Inputs[4] // { // @0A27 stack[-2] // @0A32 memory[0x00:0x40] // @0A33 storage[keccak256(memory[0x00:0x40])] // @0A3D stack[-3] // } 0A23 5B JUMPDEST 0A24 50 POP 0A25 60 PUSH1 0x00 0A27 90 SWAP1 0A28 81 DUP2 0A29 52 MSTORE 0A2A 60 PUSH1 0x05 0A2C 60 PUSH1 0x20 0A2E 52 MSTORE 0A2F 60 PUSH1 0x40 0A31 90 SWAP1 0A32 20 SHA3 0A33 54 SLOAD 0A34 60 PUSH1 0x01 0A36 60 PUSH1 0x01 0A38 60 PUSH1 0xa0 0A3A 1B SHL 0A3B 03 SUB 0A3C 16 AND 0A3D 90 SWAP1 0A3E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A29 memory[0x00:0x20] = stack[-2] // @0A2E memory[0x20:0x40] = 0x05 // @0A3D stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0A3F: // Incoming jump from 0x03A5 // Inputs[1] { @0A45 stack[-1] } 0A3F 5B JUMPDEST 0A40 60 PUSH1 0x00 0A42 61 PUSH2 0x0a4a 0A45 82 DUP3 0A46 61 PUSH2 0x115b 0A49 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A40 stack[0] = 0x00 // @0A42 stack[1] = 0x0a4a // @0A45 stack[2] = stack[-1] // } // Block ends with call to 0x115b, returns to 0x0A4A label_0A4A: // Incoming return from call to 0x115B at 0x0A49 // Inputs[3] // { // @0A4B stack[-2] // @0A4B stack[-1] // @0A57 stack[-4] // } 0A4A 5B JUMPDEST 0A4B 90 SWAP1 0A4C 50 POP 0A4D 80 DUP1 0A4E 60 PUSH1 0x01 0A50 60 PUSH1 0x01 0A52 60 PUSH1 0xa0 0A54 1B SHL 0A55 03 SUB 0A56 16 AND 0A57 83 DUP4 0A58 60 PUSH1 0x01 0A5A 60 PUSH1 0x01 0A5C 60 PUSH1 0xa0 0A5E 1B SHL 0A5F 03 SUB 0A60 16 AND 0A61 14 EQ 0A62 15 ISZERO 0A63 61 PUSH2 0x0ad4 0A66 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0A4B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0ad4, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0A67: // Incoming jump from 0x0A66, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0A69 memory[0x40:0x60] } 0A67 60 PUSH1 0x40 0A69 51 MLOAD 0A6A 62 PUSH3 0x461bcd 0A6E 60 PUSH1 0xe5 0A70 1B SHL 0A71 81 DUP2 0A72 52 MSTORE 0A73 60 PUSH1 0x20 0A75 60 PUSH1 0x04 0A77 82 DUP3 0A78 01 ADD 0A79 52 MSTORE 0A7A 60 PUSH1 0x22 0A7C 60 PUSH1 0x24 0A7E 82 DUP3 0A7F 01 ADD 0A80 52 MSTORE 0A81 7F PUSH32 0x455243373231413a20617070726f76616c20746f2063757272656e74206f776e 0AA2 60 PUSH1 0x44 0AA4 82 DUP3 0AA5 01 ADD 0AA6 52 MSTORE 0AA7 7F PUSH32 0x6572000000000000000000000000000000000000000000000000000000000000 0AC8 60 PUSH1 0x64 0ACA 82 DUP3 0ACB 01 ADD 0ACC 52 MSTORE 0ACD 60 PUSH1 0x84 0ACF 01 ADD 0AD0 61 PUSH2 0x0a1a 0AD3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A72 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A79 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A80 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @0AA6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f76616c20746f2063757272656e74206f776e // @0ACC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6572000000000000000000000000000000000000000000000000000000000000 // @0ACF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0AD4: // Incoming jump from 0x0A66, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0AD5 msg.sender // @0ADE stack[-1] // } 0AD4 5B JUMPDEST 0AD5 33 CALLER 0AD6 60 PUSH1 0x01 0AD8 60 PUSH1 0x01 0ADA 60 PUSH1 0xa0 0ADC 1B SHL 0ADD 03 SUB 0ADE 82 DUP3 0ADF 16 AND 0AE0 14 EQ 0AE1 80 DUP1 0AE2 61 PUSH2 0x0af0 0AE5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AE0 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x0af0, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0AE6: // Incoming jump from 0x0AE5, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0AEA stack[-2] // @0AEB msg.sender // } 0AE6 50 POP 0AE7 61 PUSH2 0x0af0 0AEA 81 DUP2 0AEB 33 CALLER 0AEC 61 PUSH2 0x07db 0AEF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AE7 stack[-1] = 0x0af0 // @0AEA stack[0] = stack[-2] // @0AEB stack[1] = msg.sender // } // Block ends with call to 0x07db, returns to 0x0AF0 label_0AF0: // Incoming return from call to 0x07DB at 0x0AEF // Incoming jump from 0x0AE5, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @0AF4 stack[-1] } 0AF0 5B JUMPDEST 0AF1 61 PUSH2 0x0b62 0AF4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b62, if stack[-1] label_0AF5: // Incoming jump from 0x0AF4, if not stack[-1] // Inputs[1] { @0AF7 memory[0x40:0x60] } 0AF5 60 PUSH1 0x40 0AF7 51 MLOAD 0AF8 62 PUSH3 0x461bcd 0AFC 60 PUSH1 0xe5 0AFE 1B SHL 0AFF 81 DUP2 0B00 52 MSTORE 0B01 60 PUSH1 0x20 0B03 60 PUSH1 0x04 0B05 82 DUP3 0B06 01 ADD 0B07 52 MSTORE 0B08 60 PUSH1 0x39 0B0A 60 PUSH1 0x24 0B0C 82 DUP3 0B0D 01 ADD 0B0E 52 MSTORE 0B0F 7F PUSH32 0x455243373231413a20617070726f76652063616c6c6572206973206e6f74206f 0B30 60 PUSH1 0x44 0B32 82 DUP3 0B33 01 ADD 0B34 52 MSTORE 0B35 7F PUSH32 0x776e6572206e6f7220617070726f76656420666f7220616c6c00000000000000 0B56 60 PUSH1 0x64 0B58 82 DUP3 0B59 01 ADD 0B5A 52 MSTORE 0B5B 60 PUSH1 0x84 0B5D 01 ADD 0B5E 61 PUSH2 0x0a1a 0B61 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0B00 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B07 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B0E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x39 // @0B34 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f76652063616c6c6572206973206e6f74206f // @0B5A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f76656420666f7220616c6c00000000000000 // @0B5D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0B62: // Incoming jump from 0x0AF4, if stack[-1] // Inputs[3] // { // @0B66 stack[-3] // @0B67 stack[-2] // @0B68 stack[-1] // } 0B62 5B JUMPDEST 0B63 61 PUSH2 0x0b6d 0B66 83 DUP4 0B67 83 DUP4 0B68 83 DUP4 0B69 61 PUSH2 0x1f0f 0B6C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B63 stack[0] = 0x0b6d // @0B66 stack[1] = stack[-3] // @0B67 stack[2] = stack[-2] // @0B68 stack[3] = stack[-1] // } // Block ends with call to 0x1f0f, returns to 0x0B6D label_0B6D: // Incoming jump from 0x164F, if !(stack[-1] < stack[-2]) // Incoming jump from 0x164F, if !(0x00 < stack[-1]) // Incoming return from call to 0x1F0F at 0x0B6C // Inputs[1] { @0B71 stack[-4] } 0B6D 5B JUMPDEST 0B6E 50 POP 0B6F 50 POP 0B70 50 POP 0B71 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0B72: // Incoming jump from 0x0416 // Inputs[5] // { // @0B75 storage[0x16] // @0B78 memory[0x40:0x60] // @0BA4 stack[-1] // @0BBD memory[0x40:0x60] // @0BC6 address(storage[0x16] & (0x01 << 0xa0) - 0x01).code.length // } 0B72 5B JUMPDEST 0B73 60 PUSH1 0x16 0B75 54 SLOAD 0B76 60 PUSH1 0x40 0B78 51 MLOAD 0B79 7F PUSH32 0x1916558700000000000000000000000000000000000000000000000000000000 0B9A 81 DUP2 0B9B 52 MSTORE 0B9C 60 PUSH1 0x01 0B9E 60 PUSH1 0x01 0BA0 60 PUSH1 0xa0 0BA2 1B SHL 0BA3 03 SUB 0BA4 83 DUP4 0BA5 81 DUP2 0BA6 16 AND 0BA7 60 PUSH1 0x04 0BA9 83 DUP4 0BAA 01 ADD 0BAB 52 MSTORE 0BAC 90 SWAP1 0BAD 91 SWAP2 0BAE 16 AND 0BAF 90 SWAP1 0BB0 63 PUSH4 0x19165587 0BB5 90 SWAP1 0BB6 60 PUSH1 0x24 0BB8 01 ADD 0BB9 60 PUSH1 0x00 0BBB 60 PUSH1 0x40 0BBD 51 MLOAD 0BBE 80 DUP1 0BBF 83 DUP4 0BC0 03 SUB 0BC1 81 DUP2 0BC2 60 PUSH1 0x00 0BC4 87 DUP8 0BC5 80 DUP1 0BC6 3B EXTCODESIZE 0BC7 15 ISZERO 0BC8 80 DUP1 0BC9 15 ISZERO 0BCA 61 PUSH2 0x0bd2 0BCD 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0B9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1916558700000000000000000000000000000000000000000000000000000000 // @0BAB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0BAF stack[0] = storage[0x16] & (0x01 << 0xa0) - 0x01 // @0BB5 stack[1] = 0x19165587 // @0BB8 stack[2] = 0x24 + memory[0x40:0x60] // @0BB9 stack[3] = 0x00 // @0BBD stack[4] = memory[0x40:0x60] // @0BC0 stack[5] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @0BC1 stack[6] = memory[0x40:0x60] // @0BC2 stack[7] = 0x00 // @0BC4 stack[8] = storage[0x16] & (0x01 << 0xa0) - 0x01 // @0BC7 stack[9] = !address(storage[0x16] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0bd2, if !!address(storage[0x16] & (0x01 << 0xa0) - 0x01).code.length label_0BCE: // Incoming jump from 0x0BCD, if not !!address(storage[0x16] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0BD1 memory[0x00:0x00] } 0BCE 60 PUSH1 0x00 0BD0 80 DUP1 0BD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BD1 revert(memory[0x00:0x00]); } // Block terminates label_0BD2: // Incoming jump from 0x0BCD, if !!address(storage[0x16] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @0BD4 msg.gas // @0BD5 stack[-2] // @0BD5 stack[-3] // @0BD5 stack[-5] // @0BD5 memory[stack[-4]:stack[-4] + stack[-5]] // @0BD5 stack[-4] // @0BD5 stack[-6] // @0BD5 stack[-7] // @0BD5 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0BD2 5B JUMPDEST 0BD3 50 POP 0BD4 5A GAS 0BD5 F1 CALL 0BD6 15 ISZERO 0BD7 80 DUP1 0BD8 15 ISZERO 0BD9 61 PUSH2 0x0be6 0BDC 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0BD5 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0BD6 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 0x0be6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0BDD: // Incoming jump from 0x0BDC, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0BDD returndata.length // @0BE1 returndata[0x00:0x00 + returndata.length] // @0BE2 returndata.length // @0BE5 memory[0x00:0x00 + returndata.length] // } 0BDD 3D RETURNDATASIZE 0BDE 60 PUSH1 0x00 0BE0 80 DUP1 0BE1 3E RETURNDATACOPY 0BE2 3D RETURNDATASIZE 0BE3 60 PUSH1 0x00 0BE5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BE1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BE5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BE6: // Incoming jump from 0x0BDC, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0BEC stack[-6] } 0BE6 5B JUMPDEST 0BE7 50 POP 0BE8 50 POP 0BE9 50 POP 0BEA 50 POP 0BEB 50 POP 0BEC 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0BED: // Incoming jump from 0x0436 // Inputs[3] // { // @0BF1 stack[-3] // @0BF2 stack[-2] // @0BF3 stack[-1] // } 0BED 5B JUMPDEST 0BEE 61 PUSH2 0x0b6d 0BF1 83 DUP4 0BF2 83 DUP4 0BF3 83 DUP4 0BF4 61 PUSH2 0x1f78 0BF7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BEE stack[0] = 0x0b6d // @0BF1 stack[1] = stack[-3] // @0BF2 stack[2] = stack[-2] // @0BF3 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1f78 label_0BF8: // Incoming jump from 0x0456 // Inputs[1] { @0BFE stack[-2] } 0BF8 5B JUMPDEST 0BF9 60 PUSH1 0x00 0BFB 61 PUSH2 0x0c03 0BFE 83 DUP4 0BFF 61 PUSH2 0x122a 0C02 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BF9 stack[0] = 0x00 // @0BFB stack[1] = 0x0c03 // @0BFE stack[2] = stack[-2] // } // Block ends with call to 0x122a, returns to 0x0C03 label_0C03: // Incoming return from call to 0x122A at 0x0C02 // Inputs[2] // { // @0C04 stack[-3] // @0C05 stack[-1] // } 0C03 5B JUMPDEST 0C04 82 DUP3 0C05 10 LT 0C06 61 PUSH2 0x0c77 0C09 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c77, if stack[-3] < stack[-1] label_0C0A: // Incoming jump from 0x0C09, if not stack[-3] < stack[-1] // Inputs[1] { @0C0C memory[0x40:0x60] } 0C0A 60 PUSH1 0x40 0C0C 51 MLOAD 0C0D 62 PUSH3 0x461bcd 0C11 60 PUSH1 0xe5 0C13 1B SHL 0C14 81 DUP2 0C15 52 MSTORE 0C16 60 PUSH1 0x20 0C18 60 PUSH1 0x04 0C1A 82 DUP3 0C1B 01 ADD 0C1C 52 MSTORE 0C1D 60 PUSH1 0x22 0C1F 60 PUSH1 0x24 0C21 82 DUP3 0C22 01 ADD 0C23 52 MSTORE 0C24 7F PUSH32 0x455243373231413a206f776e657220696e646578206f7574206f6620626f756e 0C45 60 PUSH1 0x44 0C47 82 DUP3 0C48 01 ADD 0C49 52 MSTORE 0C4A 7F PUSH32 0x6473000000000000000000000000000000000000000000000000000000000000 0C6B 60 PUSH1 0x64 0C6D 82 DUP3 0C6E 01 ADD 0C6F 52 MSTORE 0C70 60 PUSH1 0x84 0C72 01 ADD 0C73 61 PUSH2 0x0a1a 0C76 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C1C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C23 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @0C49 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a206f776e657220696e646578206f7574206f6620626f756e // @0C6F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6473000000000000000000000000000000000000000000000000000000000000 // @0C72 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0C77: // Incoming jump from 0x0C09, if stack[-3] < stack[-1] // Inputs[1] { @0C7B storage[0x00] } 0C77 5B JUMPDEST 0C78 60 PUSH1 0x00 0C7A 80 DUP1 0C7B 54 SLOAD 0C7C 90 SWAP1 0C7D 80 DUP1 0C7E 80 DUP1 0C7F 5B JUMPDEST 0C80 83 DUP4 0C81 81 DUP2 0C82 10 LT 0C83 15 ISZERO 0C84 61 PUSH2 0x0d21 0C87 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0C7C stack[0] = storage[0x00] // @0C7C stack[1] = 0x00 // @0C7D stack[2] = 0x00 // @0C7E stack[3] = 0x00 // } // Block ends with conditional jump to 0x0d21, if !(0x00 < storage[0x00]) label_0C88: // Incoming jump from 0x0C87, if not !(0x00 < storage[0x00]) // Incoming jump from 0x0C87, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0C8A stack[-1] // @0C99 memory[0x00:0x40] // @0C9B memory[0x40:0x60] // @0CA2 storage[keccak256(memory[0x00:0x40])] // } 0C88 60 PUSH1 0x00 0C8A 81 DUP2 0C8B 81 DUP2 0C8C 52 MSTORE 0C8D 60 PUSH1 0x03 0C8F 60 PUSH1 0x20 0C91 90 SWAP1 0C92 81 DUP2 0C93 52 MSTORE 0C94 60 PUSH1 0x40 0C96 91 SWAP2 0C97 82 DUP3 0C98 90 SWAP1 0C99 20 SHA3 0C9A 82 DUP3 0C9B 51 MLOAD 0C9C 80 DUP1 0C9D 84 DUP5 0C9E 01 ADD 0C9F 90 SWAP1 0CA0 93 SWAP4 0CA1 52 MSTORE 0CA2 54 SLOAD 0CA3 60 PUSH1 0x01 0CA5 60 PUSH1 0x01 0CA7 60 PUSH1 0xa0 0CA9 1B SHL 0CAA 03 SUB 0CAB 81 DUP2 0CAC 16 AND 0CAD 80 DUP1 0CAE 84 DUP5 0CAF 52 MSTORE 0CB0 60 PUSH1 0x01 0CB2 60 PUSH1 0xa0 0CB4 1B SHL 0CB5 90 SWAP1 0CB6 91 SWAP2 0CB7 04 DIV 0CB8 67 PUSH8 0xffffffffffffffff 0CC1 16 AND 0CC2 91 SWAP2 0CC3 83 DUP4 0CC4 01 ADD 0CC5 91 SWAP2 0CC6 90 SWAP1 0CC7 91 SWAP2 0CC8 52 MSTORE 0CC9 15 ISZERO 0CCA 61 PUSH2 0x0cd2 0CCD 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0C8C memory[0x00:0x20] = stack[-1] // @0C93 memory[0x20:0x40] = 0x03 // @0CA0 stack[0] = memory[0x40:0x60] // @0CA1 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0CAF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0CC8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // } // Block ends with conditional jump to 0x0cd2, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_0CCE: // Incoming jump from 0x0CCD, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @0CCE stack[-1] // @0CCF memory[stack[-1]:stack[-1] + 0x20] // @0CD0 stack[-3] // @0CD3 stack[-8] // } 0CCE 80 DUP1 0CCF 51 MLOAD 0CD0 92 SWAP3 0CD1 50 POP 0CD2 5B JUMPDEST 0CD3 87 DUP8 0CD4 60 PUSH1 0x01 0CD6 60 PUSH1 0x01 0CD8 60 PUSH1 0xa0 0CDA 1B SHL 0CDB 03 SUB 0CDC 16 AND 0CDD 83 DUP4 0CDE 60 PUSH1 0x01 0CE0 60 PUSH1 0x01 0CE2 60 PUSH1 0xa0 0CE4 1B SHL 0CE5 03 SUB 0CE6 16 AND 0CE7 14 EQ 0CE8 15 ISZERO 0CE9 61 PUSH2 0x0d0e 0CEC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0CD0 stack[-3] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0d0e, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) label_0CED: // Incoming jump from 0x0CEC, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0CEC, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[2] // { // @0CED stack[-7] // @0CEE stack[-4] // } 0CED 86 DUP7 0CEE 84 DUP5 0CEF 14 EQ 0CF0 15 ISZERO 0CF1 61 PUSH2 0x0d00 0CF4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d00, if !(stack[-4] == stack[-7]) label_0CF5: // Incoming jump from 0x0CF4, if not !(stack[-4] == stack[-7]) // Inputs[3] // { // @0CF6 stack[-2] // @0CF6 stack[-6] // @0CFB stack[-5] // } 0CF5 50 POP 0CF6 93 SWAP4 0CF7 50 POP 0CF8 61 PUSH2 0x0907 0CFB 92 SWAP3 0CFC 50 POP 0CFD 50 POP 0CFE 50 POP 0CFF 56 *JUMP // Stack delta = -5 // Outputs[1] { @0CF6 stack[-6] = stack[-2] } // Block ends with unconditional jump to 0x0907 label_0D00: // Incoming jump from 0x0CF4, if !(stack[-4] == stack[-7]) // Inputs[1] { @0D01 stack[-4] } 0D00 5B JUMPDEST 0D01 83 DUP4 0D02 61 PUSH2 0x0d0a 0D05 81 DUP2 0D06 61 PUSH2 0x356a 0D09 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D01 stack[0] = stack[-4] // @0D02 stack[1] = 0x0d0a // @0D05 stack[2] = stack[-4] // } // Block ends with call to 0x356a, returns to 0x0D0A label_0D0A: // Incoming return from call to 0x356A at 0x0D09 // Inputs[2] // { // @0D0B stack[-6] // @0D0B stack[-1] // } 0D0A 5B JUMPDEST 0D0B 94 SWAP5 0D0C 50 POP 0D0D 50 POP // Stack delta = -2 // Outputs[1] { @0D0B stack[-6] = stack[-1] } // Block continues label_0D0E: // Incoming jump from 0x0D0D // Incoming jump from 0x0CEC, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0CEC, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[1] { @0D10 stack[-2] } 0D0E 5B JUMPDEST 0D0F 50 POP 0D10 80 DUP1 0D11 61 PUSH2 0x0d19 0D14 81 DUP2 0D15 61 PUSH2 0x356a 0D18 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D10 stack[-1] = stack[-2] // @0D11 stack[0] = 0x0d19 // @0D14 stack[1] = stack[-2] // } // Block ends with call to 0x356a, returns to 0x0D19 label_0D19: // Incoming return from call to 0x356A at 0x0D18 // Inputs[2] // { // @0D1A stack[-3] // @0D1A stack[-1] // } 0D19 5B JUMPDEST 0D1A 91 SWAP2 0D1B 50 POP 0D1C 50 POP 0D1D 61 PUSH2 0x0c7f 0D20 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D1A stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0c7f label_0D21: // Incoming jump from 0x0C87, if !(0x00 < storage[0x00]) // Incoming jump from 0x0C87, if !(stack[-1] < stack[-4]) // Inputs[1] { @0D25 memory[0x40:0x60] } 0D21 5B JUMPDEST 0D22 50 POP 0D23 60 PUSH1 0x40 0D25 51 MLOAD 0D26 62 PUSH3 0x461bcd 0D2A 60 PUSH1 0xe5 0D2C 1B SHL 0D2D 81 DUP2 0D2E 52 MSTORE 0D2F 60 PUSH1 0x20 0D31 60 PUSH1 0x04 0D33 82 DUP3 0D34 01 ADD 0D35 52 MSTORE 0D36 60 PUSH1 0x2e 0D38 60 PUSH1 0x24 0D3A 82 DUP3 0D3B 01 ADD 0D3C 52 MSTORE 0D3D 7F PUSH32 0x455243373231413a20756e61626c6520746f2067657420746f6b656e206f6620 0D5E 60 PUSH1 0x44 0D60 82 DUP3 0D61 01 ADD 0D62 52 MSTORE 0D63 7F PUSH32 0x6f776e657220627920696e646578000000000000000000000000000000000000 0D84 60 PUSH1 0x64 0D86 82 DUP3 0D87 01 ADD 0D88 52 MSTORE 0D89 60 PUSH1 0x84 0D8B 01 ADD 0D8C 61 PUSH2 0x0a1a 0D8F 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @0D2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D35 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D3C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2e // @0D62 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20756e61626c6520746f2067657420746f6b656e206f6620 // @0D88 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6f776e657220627920696e646578000000000000000000000000000000000000 // @0D8B stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0D90: // Incoming jump from 0x0476 // Inputs[2] // { // @0D93 storage[0x09] // @0D9D msg.sender // } 0D90 5B JUMPDEST 0D91 60 PUSH1 0x09 0D93 54 SLOAD 0D94 60 PUSH1 0x01 0D96 60 PUSH1 0x01 0D98 60 PUSH1 0xa0 0D9A 1B SHL 0D9B 03 SUB 0D9C 16 AND 0D9D 33 CALLER 0D9E 14 EQ 0D9F 61 PUSH2 0x0dea 0DA2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dea, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_0DA3: // Incoming jump from 0x0DA2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @0DA5 memory[0x40:0x60] } 0DA3 60 PUSH1 0x40 0DA5 51 MLOAD 0DA6 62 PUSH3 0x461bcd 0DAA 60 PUSH1 0xe5 0DAC 1B SHL 0DAD 81 DUP2 0DAE 52 MSTORE 0DAF 60 PUSH1 0x20 0DB1 60 PUSH1 0x04 0DB3 82 DUP3 0DB4 01 ADD 0DB5 81 DUP2 0DB6 90 SWAP1 0DB7 52 MSTORE 0DB8 60 PUSH1 0x24 0DBA 82 DUP3 0DBB 01 ADD 0DBC 52 MSTORE 0DBD 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0DDE 60 PUSH1 0x44 0DE0 82 DUP3 0DE1 01 ADD 0DE2 52 MSTORE 0DE3 60 PUSH1 0x64 0DE5 01 ADD 0DE6 61 PUSH2 0x0a1a 0DE9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0DAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DB7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DBC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0DE2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0DE5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0DEA: // Incoming jump from 0x0DA2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[2] // { // @0DED stack[-1] // @0DEE stack[-2] // } 0DEA 5B JUMPDEST 0DEB 60 PUSH1 0x15 0DED 55 SSTORE 0DEE 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DED storage[0x15] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0DEF: // Incoming jump from 0x0496 // Inputs[4] // { // @0DF3 stack[-3] // @0DF4 stack[-2] // @0DF5 stack[-1] // @0DF8 memory[0x40:0x60] // } 0DEF 5B JUMPDEST 0DF0 61 PUSH2 0x0b6d 0DF3 83 DUP4 0DF4 83 DUP4 0DF5 83 DUP4 0DF6 60 PUSH1 0x40 0DF8 51 MLOAD 0DF9 80 DUP1 0DFA 60 PUSH1 0x20 0DFC 01 ADD 0DFD 60 PUSH1 0x40 0DFF 52 MSTORE 0E00 80 DUP1 0E01 60 PUSH1 0x00 0E03 81 DUP2 0E04 52 MSTORE 0E05 50 POP 0E06 61 PUSH2 0x1b7a 0E09 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0DF0 stack[0] = 0x0b6d // @0DF3 stack[1] = stack[-3] // @0DF4 stack[2] = stack[-2] // @0DF5 stack[3] = stack[-1] // @0DF8 stack[4] = memory[0x40:0x60] // @0DFF memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0E04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1b7a label_0E0A: // Incoming jump from 0x04CC // Inputs[2] // { // @0E0E storage[0x00] // @0E0F stack[-1] // } 0E0A 5B JUMPDEST 0E0B 60 PUSH1 0x00 0E0D 80 DUP1 0E0E 54 SLOAD 0E0F 82 DUP3 0E10 10 LT 0E11 61 PUSH2 0x0e82 0E14 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E0B stack[0] = 0x00 } // Block ends with conditional jump to 0x0e82, if stack[-1] < storage[0x00] label_0E15: // Incoming jump from 0x0E14, if not stack[-1] < storage[0x00] // Inputs[1] { @0E17 memory[0x40:0x60] } 0E15 60 PUSH1 0x40 0E17 51 MLOAD 0E18 62 PUSH3 0x461bcd 0E1C 60 PUSH1 0xe5 0E1E 1B SHL 0E1F 81 DUP2 0E20 52 MSTORE 0E21 60 PUSH1 0x20 0E23 60 PUSH1 0x04 0E25 82 DUP3 0E26 01 ADD 0E27 52 MSTORE 0E28 60 PUSH1 0x23 0E2A 60 PUSH1 0x24 0E2C 82 DUP3 0E2D 01 ADD 0E2E 52 MSTORE 0E2F 7F PUSH32 0x455243373231413a20676c6f62616c20696e646578206f7574206f6620626f75 0E50 60 PUSH1 0x44 0E52 82 DUP3 0E53 01 ADD 0E54 52 MSTORE 0E55 7F PUSH32 0x6e64730000000000000000000000000000000000000000000000000000000000 0E76 60 PUSH1 0x64 0E78 82 DUP3 0E79 01 ADD 0E7A 52 MSTORE 0E7B 60 PUSH1 0x84 0E7D 01 ADD 0E7E 61 PUSH2 0x0a1a 0E81 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0E20 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E27 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E2E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @0E54 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20676c6f62616c20696e646578206f7574206f6620626f75 // @0E7A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e64730000000000000000000000000000000000000000000000000000000000 // @0E7D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0E82: // Incoming call from 0x3069, returns to 0x0E82, if !(stack[-4] > stack[-2]) // Incoming return from call to 0x0E82 at 0x3069 // Incoming jump from 0x3069, if !(stack[-2] > stack[-1]) // Incoming jump from 0x0E14, if stack[-1] < storage[0x00] // Inputs[2] // { // @0E84 stack[-2] // @0E84 stack[-3] // } 0E82 5B JUMPDEST 0E83 50 POP 0E84 90 SWAP1 0E85 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E84 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0E86: // Incoming jump from 0x04EC // Inputs[2] // { // @0E89 storage[0x09] // @0E93 msg.sender // } 0E86 5B JUMPDEST 0E87 60 PUSH1 0x09 0E89 54 SLOAD 0E8A 60 PUSH1 0x01 0E8C 60 PUSH1 0x01 0E8E 60 PUSH1 0xa0 0E90 1B SHL 0E91 03 SUB 0E92 16 AND 0E93 33 CALLER 0E94 14 EQ 0E95 61 PUSH2 0x0ee0 0E98 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ee0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_0E99: // Incoming jump from 0x0E98, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @0E9B memory[0x40:0x60] } 0E99 60 PUSH1 0x40 0E9B 51 MLOAD 0E9C 62 PUSH3 0x461bcd 0EA0 60 PUSH1 0xe5 0EA2 1B SHL 0EA3 81 DUP2 0EA4 52 MSTORE 0EA5 60 PUSH1 0x20 0EA7 60 PUSH1 0x04 0EA9 82 DUP3 0EAA 01 ADD 0EAB 81 DUP2 0EAC 90 SWAP1 0EAD 52 MSTORE 0EAE 60 PUSH1 0x24 0EB0 82 DUP3 0EB1 01 ADD 0EB2 52 MSTORE 0EB3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0ED4 60 PUSH1 0x44 0ED6 82 DUP3 0ED7 01 ADD 0ED8 52 MSTORE 0ED9 60 PUSH1 0x64 0EDB 01 ADD 0EDC 61 PUSH2 0x0a1a 0EDF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EAD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EB2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0ED8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0EDB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_0EE0: // Incoming jump from 0x0E98, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[2] // { // @0EE1 stack[-1] // @0EE2 memory[stack[-1]:stack[-1] + 0x20] // } 0EE0 5B JUMPDEST 0EE1 80 DUP1 0EE2 51 MLOAD 0EE3 61 PUSH2 0x0ef3 0EE6 90 SWAP1 0EE7 60 PUSH1 0x0b 0EE9 90 SWAP1 0EEA 60 PUSH1 0x20 0EEC 84 DUP5 0EED 01 ADD 0EEE 90 SWAP1 0EEF 61 PUSH2 0x2fe5 0EF2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EE6 stack[0] = 0x0ef3 // @0EE9 stack[1] = 0x0b // @0EEE stack[2] = stack[-1] + 0x20 // @0EEE stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2fe5 label_0EF3: // Incoming return from call to 0x28A1 at 0x26A2 // Inputs[1] { @0EF6 stack[-3] } 0EF3 5B JUMPDEST 0EF4 50 POP 0EF5 50 POP 0EF6 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0EF7: // Incoming jump from 0x0515 // Inputs[5] // { // @0EFB stack[-5] // @0EFC stack[-4] // @0EFD stack[-3] // @0F0E memory[0x40:0x60] // @0F25 msg.data[stack[-4]:stack[-4] + stack[-3]] // } 0EF7 5B JUMPDEST 0EF8 61 PUSH2 0x0f37 0EFB 85 DUP6 0EFC 85 DUP6 0EFD 85 DUP6 0EFE 80 DUP1 0EFF 80 DUP1 0F00 60 PUSH1 0x1f 0F02 01 ADD 0F03 60 PUSH1 0x20 0F05 80 DUP1 0F06 91 SWAP2 0F07 04 DIV 0F08 02 MUL 0F09 60 PUSH1 0x20 0F0B 01 ADD 0F0C 60 PUSH1 0x40 0F0E 51 MLOAD 0F0F 90 SWAP1 0F10 81 DUP2 0F11 01 ADD 0F12 60 PUSH1 0x40 0F14 52 MSTORE 0F15 80 DUP1 0F16 93 SWAP4 0F17 92 SWAP3 0F18 91 SWAP2 0F19 90 SWAP1 0F1A 81 DUP2 0F1B 81 DUP2 0F1C 52 MSTORE 0F1D 60 PUSH1 0x20 0F1F 01 ADD 0F20 83 DUP4 0F21 83 DUP4 0F22 80 DUP1 0F23 82 DUP3 0F24 84 DUP5 0F25 37 CALLDATACOPY 0F26 60 PUSH1 0x00 0F28 92 SWAP3 0F29 01 ADD 0F2A 91 SWAP2 0F2B 90 SWAP1 0F2C 91 SWAP2 0F2D 52 MSTORE 0F2E 50 POP 0F2F 61 PUSH2 0x233a 0F32 92 SWAP3 0F33 50 POP 0F34 50 POP 0F35 50 POP 0F36 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @0EF8 stack[0] = 0x0f37 // @0EFB stack[1] = stack[-5] // @0F14 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-3]) / 0x20 * 0x20 // @0F16 stack[2] = memory[0x40:0x60] // @0F1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0F25 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-3]] = msg.data[stack[-4]:stack[-4] + stack[-3]] // @0F2D memory[0x20 + memory[0x40:0x60] + stack[-3]:0x20 + memory[0x40:0x60] + stack[-3] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x233a 0F37 5B JUMPDEST 0F38 61 PUSH2 0x0f83 0F3B 57 *JUMPI 0F3C 60 PUSH1 0x40 0F3E 51 MLOAD 0F3F 62 PUSH3 0x461bcd 0F43 60 PUSH1 0xe5 0F45 1B SHL 0F46 81 DUP2 0F47 52 MSTORE 0F48 60 PUSH1 0x20 0F4A 60 PUSH1 0x04 0F4C 82 DUP3 0F4D 01 ADD 0F4E 52 MSTORE 0F4F 60 PUSH1 0x12 0F51 60 PUSH1 0x24 0F53 82 DUP3 0F54 01 ADD 0F55 52 MSTORE 0F56 7F PUSH32 0x5369676e617475726520696e76616c69642e0000000000000000000000000000 0F77 60 PUSH1 0x44 0F79 82 DUP3 0F7A 01 ADD 0F7B 52 MSTORE 0F7C 60 PUSH1 0x64 0F7E 01 ADD 0F7F 61 PUSH2 0x0a1a 0F82 56 *JUMP 0F83 5B JUMPDEST 0F84 84 DUP5 0F85 61 PUSH2 0x1019 0F88 60 PUSH1 0x1b 0F8A 80 DUP1 0F8B 54 SLOAD 0F8C 61 PUSH2 0x0f94 0F8F 90 SWAP1 0F90 61 PUSH2 0x3519 0F93 56 *JUMP 0F94 5B JUMPDEST 0F95 80 DUP1 0F96 60 PUSH1 0x1f 0F98 01 ADD 0F99 60 PUSH1 0x20 0F9B 80 DUP1 0F9C 91 SWAP2 0F9D 04 DIV 0F9E 02 MUL 0F9F 60 PUSH1 0x20 0FA1 01 ADD 0FA2 60 PUSH1 0x40 0FA4 51 MLOAD 0FA5 90 SWAP1 0FA6 81 DUP2 0FA7 01 ADD 0FA8 60 PUSH1 0x40 0FAA 52 MSTORE 0FAB 80 DUP1 0FAC 92 SWAP3 0FAD 91 SWAP2 0FAE 90 SWAP1 0FAF 81 DUP2 0FB0 81 DUP2 0FB1 52 MSTORE 0FB2 60 PUSH1 0x20 0FB4 01 ADD 0FB5 82 DUP3 0FB6 80 DUP1 0FB7 54 SLOAD 0FB8 61 PUSH2 0x0fc0 0FBB 90 SWAP1 0FBC 61 PUSH2 0x3519 0FBF 56 *JUMP 0FC0 5B JUMPDEST 0FC1 80 DUP1 0FC2 15 ISZERO 0FC3 61 PUSH2 0x100d 0FC6 57 *JUMPI 0FC7 80 DUP1 0FC8 60 PUSH1 0x1f 0FCA 10 LT 0FCB 61 PUSH2 0x0fe2 0FCE 57 *JUMPI 0FCF 61 PUSH2 0x0100 0FD2 80 DUP1 0FD3 83 DUP4 0FD4 54 SLOAD 0FD5 04 DIV 0FD6 02 MUL 0FD7 83 DUP4 0FD8 52 MSTORE 0FD9 91 SWAP2 0FDA 60 PUSH1 0x20 0FDC 01 ADD 0FDD 91 SWAP2 0FDE 61 PUSH2 0x100d 0FE1 56 *JUMP 0FE2 5B JUMPDEST 0FE3 82 DUP3 0FE4 01 ADD 0FE5 91 SWAP2 0FE6 90 SWAP1 0FE7 60 PUSH1 0x00 0FE9 52 MSTORE 0FEA 60 PUSH1 0x20 0FEC 60 PUSH1 0x00 0FEE 20 SHA3 0FEF 90 SWAP1 0FF0 5B JUMPDEST 0FF1 81 DUP2 0FF2 54 SLOAD 0FF3 81 DUP2 0FF4 52 MSTORE 0FF5 90 SWAP1 0FF6 60 PUSH1 0x01 0FF8 01 ADD 0FF9 90 SWAP1 0FFA 60 PUSH1 0x20 0FFC 01 ADD 0FFD 80 DUP1 0FFE 83 DUP4 0FFF 11 GT 1000 61 PUSH2 0x0ff0 1003 57 *JUMPI 1004 82 DUP3 1005 90 SWAP1 1006 03 SUB 1007 60 PUSH1 0x1f 1009 16 AND 100A 82 DUP3 100B 01 ADD 100C 91 SWAP2 100D 5B JUMPDEST 100E 50 POP 100F 50 POP 1010 50 POP 1011 50 POP 1012 50 POP 1013 33 CALLER 1014 84 DUP5 1015 61 PUSH2 0x2372 1018 56 *JUMP 1019 5B JUMPDEST 101A 14 EQ 101B 61 PUSH2 0x1056 101E 57 *JUMPI 101F 60 PUSH1 0x40 1021 51 MLOAD 1022 62 PUSH3 0x461bcd 1026 60 PUSH1 0xe5 1028 1B SHL 1029 81 DUP2 102A 52 MSTORE 102B 60 PUSH1 0x20 102D 60 PUSH1 0x04 102F 82 DUP3 1030 01 ADD 1031 52 MSTORE 1032 60 PUSH1 0x0d 1034 60 PUSH1 0x24 1036 82 DUP3 1037 01 ADD 1038 52 MSTORE 1039 6C PUSH13 0x2430b9b41034b73b30b634b217 1047 60 PUSH1 0x99 1049 1B SHL 104A 60 PUSH1 0x44 104C 82 DUP3 104D 01 ADD 104E 52 MSTORE 104F 60 PUSH1 0x64 1051 01 ADD 1052 61 PUSH2 0x0a1a 1055 56 *JUMP 1056 5B JUMPDEST 1057 33 CALLER 1058 60 PUSH1 0x00 105A 90 SWAP1 105B 81 DUP2 105C 52 MSTORE 105D 60 PUSH1 0x0c 105F 60 PUSH1 0x20 1061 52 MSTORE 1062 60 PUSH1 0x40 1064 90 SWAP1 1065 20 SHA3 1066 54 SLOAD 1067 81 DUP2 1068 90 SWAP1 1069 61 PUSH2 0x1073 106C 90 SWAP1 106D 84 DUP5 106E 90 SWAP1 106F 61 PUSH2 0x3585 1072 56 *JUMP 1073 5B JUMPDEST 1074 11 GT 1075 15 ISZERO 1076 61 PUSH2 0x10c1 1079 57 *JUMPI 107A 60 PUSH1 0x40 107C 51 MLOAD 107D 62 PUSH3 0x461bcd 1081 60 PUSH1 0xe5 1083 1B SHL 1084 81 DUP2 1085 52 MSTORE 1086 60 PUSH1 0x20 1088 60 PUSH1 0x04 108A 82 DUP3 108B 01 ADD 108C 52 MSTORE 108D 60 PUSH1 0x1a 108F 60 PUSH1 0x24 1091 82 DUP3 1092 01 ADD 1093 52 MSTORE 1094 7F PUSH32 0x596f752063616e6e6f74206d696e742074686973206d616e792e000000000000 10B5 60 PUSH1 0x44 10B7 82 DUP3 10B8 01 ADD 10B9 52 MSTORE 10BA 60 PUSH1 0x64 10BC 01 ADD 10BD 61 PUSH2 0x0a1a 10C0 56 *JUMP 10C1 5B JUMPDEST 10C2 60 PUSH1 0x14 10C4 54 SLOAD 10C5 33 CALLER 10C6 60 PUSH1 0x00 10C8 90 SWAP1 10C9 81 DUP2 10CA 52 MSTORE 10CB 60 PUSH1 0x0c 10CD 60 PUSH1 0x20 10CF 52 MSTORE 10D0 60 PUSH1 0x40 10D2 90 SWAP1 10D3 20 SHA3 10D4 54 SLOAD 10D5 61 PUSH2 0x10df 10D8 90 SWAP1 10D9 84 DUP5 10DA 90 SWAP1 10DB 61 PUSH2 0x3585 10DE 56 *JUMP 10DF 5B JUMPDEST 10E0 11 GT 10E1 15 ISZERO 10E2 61 PUSH2 0x112d 10E5 57 *JUMPI 10E6 60 PUSH1 0x40 10E8 51 MLOAD 10E9 62 PUSH3 0x461bcd 10ED 60 PUSH1 0xe5 10EF 1B SHL 10F0 81 DUP2 10F1 52 MSTORE 10F2 60 PUSH1 0x20 10F4 60 PUSH1 0x04 10F6 82 DUP3 10F7 01 ADD 10F8 52 MSTORE 10F9 60 PUSH1 0x1a 10FB 60 PUSH1 0x24 10FD 82 DUP3 10FE 01 ADD 10FF 52 MSTORE 1100 7F PUSH32 0x596f752063616e6e6f74206d696e742074686973206d616e792e000000000000 1121 60 PUSH1 0x44 1123 82 DUP3 1124 01 ADD 1125 52 MSTORE 1126 60 PUSH1 0x64 1128 01 ADD 1129 61 PUSH2 0x0a1a 112C 56 *JUMP 112D 5B JUMPDEST 112E 33 CALLER 112F 60 PUSH1 0x00 1131 90 SWAP1 1132 81 DUP2 1133 52 MSTORE 1134 60 PUSH1 0x0c 1136 60 PUSH1 0x20 1138 52 MSTORE 1139 60 PUSH1 0x40 113B 81 DUP2 113C 20 SHA3 113D 80 DUP1 113E 54 SLOAD 113F 84 DUP5 1140 92 SWAP3 1141 90 SWAP1 1142 61 PUSH2 0x114c 1145 90 SWAP1 1146 84 DUP5 1147 90 SWAP1 1148 61 PUSH2 0x3585 114B 56 *JUMP 114C 5B JUMPDEST 114D 90 SWAP1 114E 91 SWAP2 114F 55 SSTORE 1150 50 POP 1151 61 PUSH2 0x0be6 1154 90 SWAP1 1155 50 POP 1156 82 DUP3 1157 61 PUSH2 0x23a8 115A 56 *JUMP label_115B: // Incoming jump from 0x0535 // Incoming call from 0x0A49, returns to 0x0A4A // Inputs[1] { @1161 stack[-1] } 115B 5B JUMPDEST 115C 60 PUSH1 0x00 115E 61 PUSH2 0x1166 1161 82 DUP3 1162 61 PUSH2 0x245f 1165 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @115C stack[0] = 0x00 // @115E stack[1] = 0x1166 // @1161 stack[2] = stack[-1] // } // Block ends with call to 0x245f, returns to 0x1166 label_1166: // Incoming return from call to 0x245F at 0x1165 // Inputs[4] // { // @1167 stack[-1] // @1167 memory[stack[-1]:stack[-1] + 0x20] // @1168 stack[-4] // @1169 stack[-3] // } 1166 5B JUMPDEST 1167 51 MLOAD 1168 92 SWAP3 1169 91 SWAP2 116A 50 POP 116B 50 POP 116C 56 *JUMP // Stack delta = -3 // Outputs[1] { @1168 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_116D: // Incoming call from 0x0553, returns to 0x03A6 // Inputs[2] // { // @1170 storage[0x09] // @117A msg.sender // } 116D 5B JUMPDEST 116E 60 PUSH1 0x09 1170 54 SLOAD 1171 60 PUSH1 0x01 1173 60 PUSH1 0x01 1175 60 PUSH1 0xa0 1177 1B SHL 1178 03 SUB 1179 16 AND 117A 33 CALLER 117B 14 EQ 117C 61 PUSH2 0x11c7 117F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11c7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_1180: // Incoming jump from 0x117F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @1182 memory[0x40:0x60] } 1180 60 PUSH1 0x40 1182 51 MLOAD 1183 62 PUSH3 0x461bcd 1187 60 PUSH1 0xe5 1189 1B SHL 118A 81 DUP2 118B 52 MSTORE 118C 60 PUSH1 0x20 118E 60 PUSH1 0x04 1190 82 DUP3 1191 01 ADD 1192 81 DUP2 1193 90 SWAP1 1194 52 MSTORE 1195 60 PUSH1 0x24 1197 82 DUP3 1198 01 ADD 1199 52 MSTORE 119A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 11BB 60 PUSH1 0x44 11BD 82 DUP3 11BE 01 ADD 11BF 52 MSTORE 11C0 60 PUSH1 0x64 11C2 01 ADD 11C3 61 PUSH2 0x0a1a 11C6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @118B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1194 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1199 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @11BF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @11C2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_11C7: // Incoming jump from 0x117F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[8] // { // @11CA storage[0x16] // @11CD memory[0x40:0x60] // @11DB address(this).balance // @11DB address(this) // @11E3 msg.gas // @11E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @11E4 address((0x01 << 0xa0) - 0x01 & storage[0x16]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @11E9 returndata.length // } 11C7 5B JUMPDEST 11C8 60 PUSH1 0x16 11CA 54 SLOAD 11CB 60 PUSH1 0x40 11CD 51 MLOAD 11CE 60 PUSH1 0x00 11D0 91 SWAP2 11D1 60 PUSH1 0x01 11D3 60 PUSH1 0x01 11D5 60 PUSH1 0xa0 11D7 1B SHL 11D8 03 SUB 11D9 16 AND 11DA 90 SWAP1 11DB 47 SELFBALANCE 11DC 90 SWAP1 11DD 83 DUP4 11DE 81 DUP2 11DF 81 DUP2 11E0 81 DUP2 11E1 85 DUP6 11E2 87 DUP8 11E3 5A GAS 11E4 F1 CALL 11E5 92 SWAP3 11E6 50 POP 11E7 50 POP 11E8 50 POP 11E9 3D RETURNDATASIZE 11EA 80 DUP1 11EB 60 PUSH1 0x00 11ED 81 DUP2 11EE 14 EQ 11EF 61 PUSH2 0x1214 11F2 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @11D0 stack[0] = 0x00 // @11E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x16]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @11E5 stack[1] = address((0x01 << 0xa0) - 0x01 & storage[0x16]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @11E9 stack[2] = returndata.length // @11EA stack[3] = returndata.length // } // Block ends with conditional jump to 0x1214, if returndata.length == 0x00 label_11F3: // Incoming jump from 0x11F2, if not returndata.length == 0x00 // Inputs[6] // { // @11F5 memory[0x40:0x60] // @11F6 stack[-2] // @11FD returndata.length // @1205 returndata.length // @1208 returndata.length // @120F returndata[0x00:0x00 + returndata.length] // } 11F3 60 PUSH1 0x40 11F5 51 MLOAD 11F6 91 SWAP2 11F7 50 POP 11F8 60 PUSH1 0x1f 11FA 19 NOT 11FB 60 PUSH1 0x3f 11FD 3D RETURNDATASIZE 11FE 01 ADD 11FF 16 AND 1200 82 DUP3 1201 01 ADD 1202 60 PUSH1 0x40 1204 52 MSTORE 1205 3D RETURNDATASIZE 1206 82 DUP3 1207 52 MSTORE 1208 3D RETURNDATASIZE 1209 60 PUSH1 0x00 120B 60 PUSH1 0x20 120D 84 DUP5 120E 01 ADD 120F 3E RETURNDATACOPY 1210 61 PUSH2 0x1219 1213 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @11F6 stack[-2] = memory[0x40:0x60] // @1204 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1207 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @120F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1219 label_1214: // Incoming jump from 0x11F2, if returndata.length == 0x00 // Inputs[3] // { // @1217 stack[-2] // @121C stack[-4] // @121C stack[-3] // } 1214 5B JUMPDEST 1215 60 PUSH1 0x60 1217 91 SWAP2 1218 50 POP 1219 5B JUMPDEST 121A 50 POP 121B 50 POP 121C 90 SWAP1 121D 50 POP 121E 80 DUP1 121F 61 PUSH2 0x1227 1222 57 *JUMPI // Stack delta = -3 // Outputs[1] { @121C stack[-4] = stack[-3] } // Block ends with conditional jump to 0x1227, if stack[-3] label_1223: // Incoming jump from 0x1222, if not stack[-3] // Incoming jump from 0x1222, if not stack[-3] // Inputs[1] { @1226 memory[0x00:0x00] } 1223 60 PUSH1 0x00 1225 80 DUP1 1226 FD *REVERT // Stack delta = +0 // Outputs[1] { @1226 revert(memory[0x00:0x00]); } // Block terminates label_1227: // Incoming return from call to 0x262A at 0x1F0E // Incoming jump from 0x1222, if stack[-3] // Incoming return from call to 0x2689 at 0x245E // Incoming jump from 0x3086, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x2689 at 0x1578 // Incoming jump from 0x313C, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1222, if stack[-3] // Inputs[1] { @1229 stack[-2] } 1227 5B JUMPDEST 1228 50 POP 1229 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_122A: // Incoming jump from 0x0573 // Incoming call from 0x0C02, returns to 0x0C03 // Inputs[1] { @1235 stack[-1] } 122A 5B JUMPDEST 122B 60 PUSH1 0x00 122D 60 PUSH1 0x01 122F 60 PUSH1 0x01 1231 60 PUSH1 0xa0 1233 1B SHL 1234 03 SUB 1235 82 DUP3 1236 16 AND 1237 61 PUSH2 0x12a8 123A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @122B stack[0] = 0x00 } // Block ends with conditional jump to 0x12a8, if stack[-1] & (0x01 << 0xa0) - 0x01 label_123B: // Incoming jump from 0x123A, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @123D memory[0x40:0x60] } 123B 60 PUSH1 0x40 123D 51 MLOAD 123E 62 PUSH3 0x461bcd 1242 60 PUSH1 0xe5 1244 1B SHL 1245 81 DUP2 1246 52 MSTORE 1247 60 PUSH1 0x20 1249 60 PUSH1 0x04 124B 82 DUP3 124C 01 ADD 124D 52 MSTORE 124E 60 PUSH1 0x2b 1250 60 PUSH1 0x24 1252 82 DUP3 1253 01 ADD 1254 52 MSTORE 1255 7F PUSH32 0x455243373231413a2062616c616e636520717565727920666f7220746865207a 1276 60 PUSH1 0x44 1278 82 DUP3 1279 01 ADD 127A 52 MSTORE 127B 7F PUSH32 0x65726f2061646472657373000000000000000000000000000000000000000000 129C 60 PUSH1 0x64 129E 82 DUP3 129F 01 ADD 12A0 52 MSTORE 12A1 60 PUSH1 0x84 12A3 01 ADD 12A4 61 PUSH2 0x0a1a 12A7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1246 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @124D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1254 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @127A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a2062616c616e636520717565727920666f7220746865207a // @12A0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000 // @12A3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_12A8: // Incoming jump from 0x123A, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @12B2 stack[-2] // @12C0 memory[0x00:0x40] // @12C1 storage[keccak256(memory[0x00:0x40])] // @12CB stack[-3] // } 12A8 5B JUMPDEST 12A9 50 POP 12AA 60 PUSH1 0x01 12AC 60 PUSH1 0x01 12AE 60 PUSH1 0xa0 12B0 1B SHL 12B1 03 SUB 12B2 16 AND 12B3 60 PUSH1 0x00 12B5 90 SWAP1 12B6 81 DUP2 12B7 52 MSTORE 12B8 60 PUSH1 0x04 12BA 60 PUSH1 0x20 12BC 52 MSTORE 12BD 60 PUSH1 0x40 12BF 90 SWAP1 12C0 20 SHA3 12C1 54 SLOAD 12C2 60 PUSH1 0x01 12C4 60 PUSH1 0x01 12C6 60 PUSH1 0x80 12C8 1B SHL 12C9 03 SUB 12CA 16 AND 12CB 90 SWAP1 12CC 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @12B7 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @12BC memory[0x20:0x40] = 0x04 // @12CB stack[-3] = (0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_12CD: // Incoming call from 0x0588, returns to 0x03A6 // Inputs[2] // { // @12D0 storage[0x09] // @12DA msg.sender // } 12CD 5B JUMPDEST 12CE 60 PUSH1 0x09 12D0 54 SLOAD 12D1 60 PUSH1 0x01 12D3 60 PUSH1 0x01 12D5 60 PUSH1 0xa0 12D7 1B SHL 12D8 03 SUB 12D9 16 AND 12DA 33 CALLER 12DB 14 EQ 12DC 61 PUSH2 0x1327 12DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1327, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_12E0: // Incoming jump from 0x12DF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @12E2 memory[0x40:0x60] } 12E0 60 PUSH1 0x40 12E2 51 MLOAD 12E3 62 PUSH3 0x461bcd 12E7 60 PUSH1 0xe5 12E9 1B SHL 12EA 81 DUP2 12EB 52 MSTORE 12EC 60 PUSH1 0x20 12EE 60 PUSH1 0x04 12F0 82 DUP3 12F1 01 ADD 12F2 81 DUP2 12F3 90 SWAP1 12F4 52 MSTORE 12F5 60 PUSH1 0x24 12F7 82 DUP3 12F8 01 ADD 12F9 52 MSTORE 12FA 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 131B 60 PUSH1 0x44 131D 82 DUP3 131E 01 ADD 131F 52 MSTORE 1320 60 PUSH1 0x64 1322 01 ADD 1323 61 PUSH2 0x0a1a 1326 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @12EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12F4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12F9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @131F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1322 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1327: // Incoming jump from 0x12DF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] 1327 5B JUMPDEST 1328 61 PUSH2 0x1331 132B 60 PUSH1 0x00 132D 61 PUSH2 0x262a 1330 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1328 stack[0] = 0x1331 // @132B stack[1] = 0x00 // } // Block ends with call to 0x262a, returns to 0x1331 label_1331: // Incoming return from call to 0x262A at 0x1330 // Inputs[1] { @1332 stack[-1] } 1331 5B JUMPDEST 1332 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1333: // Incoming call from 0x05B3, returns to 0x0341 // Inputs[1] { @1337 storage[0x0a] } 1333 5B JUMPDEST 1334 60 PUSH1 0x0a 1336 80 DUP1 1337 54 SLOAD 1338 61 PUSH2 0x1340 133B 90 SWAP1 133C 61 PUSH2 0x3519 133F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1334 stack[0] = 0x0a // @133B stack[1] = 0x1340 // @133B stack[2] = storage[0x0a] // } // Block ends with call to 0x3519, returns to 0x1340 label_1340: // Incoming return from call to 0x3519 at 0x1C15 // Incoming return from call to 0x3519 at 0x1D34 // Incoming return from call to 0x3519 at 0x133F // Inputs[4] // { // @1341 stack[-1] // @1350 memory[0x40:0x60] // @1358 stack[-2] // @1363 storage[stack[-2]] // } 1340 5B JUMPDEST 1341 80 DUP1 1342 60 PUSH1 0x1f 1344 01 ADD 1345 60 PUSH1 0x20 1347 80 DUP1 1348 91 SWAP2 1349 04 DIV 134A 02 MUL 134B 60 PUSH1 0x20 134D 01 ADD 134E 60 PUSH1 0x40 1350 51 MLOAD 1351 90 SWAP1 1352 81 DUP2 1353 01 ADD 1354 60 PUSH1 0x40 1356 52 MSTORE 1357 80 DUP1 1358 92 SWAP3 1359 91 SWAP2 135A 90 SWAP1 135B 81 DUP2 135C 81 DUP2 135D 52 MSTORE 135E 60 PUSH1 0x20 1360 01 ADD 1361 82 DUP3 1362 80 DUP1 1363 54 SLOAD 1364 61 PUSH2 0x136c 1367 90 SWAP1 1368 61 PUSH2 0x3519 136B 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1356 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1358 stack[-2] = memory[0x40:0x60] // @1359 stack[-1] = stack[-2] // @135A stack[0] = stack[-1] // @135D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1360 stack[1] = 0x20 + memory[0x40:0x60] // @1361 stack[2] = stack[-2] // @1367 stack[4] = storage[stack[-2]] // @1367 stack[3] = 0x136c // } // Block ends with call to 0x3519, returns to 0x136C label_136C: // Incoming return from call to 0x3519 at 0x136B // Inputs[1] { @136D stack[-1] } 136C 5B JUMPDEST 136D 80 DUP1 136E 15 ISZERO 136F 61 PUSH2 0x13b9 1372 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13b9, if !stack[-1] label_1373: // Incoming jump from 0x1372, if not !stack[-1] // Inputs[1] { @1373 stack[-1] } 1373 80 DUP1 1374 60 PUSH1 0x1f 1376 10 LT 1377 61 PUSH2 0x138e 137A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x138e, if 0x1f < stack[-1] label_137B: // Incoming jump from 0x137A, if not 0x1f < stack[-1] // Inputs[4] // { // @137F stack[-2] // @1380 storage[stack[-2]] // @1383 stack[-3] // @1385 stack[-1] // } 137B 61 PUSH2 0x0100 137E 80 DUP1 137F 83 DUP4 1380 54 SLOAD 1381 04 DIV 1382 02 MUL 1383 83 DUP4 1384 52 MSTORE 1385 91 SWAP2 1386 60 PUSH1 0x20 1388 01 ADD 1389 91 SWAP2 138A 61 PUSH2 0x13b9 138D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1384 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1389 stack[-1] = stack[-1] // @1389 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x13b9 label_138E: // Incoming jump from 0x137A, if 0x1f < stack[-1] // Inputs[5] // { // @138F stack[-3] // @1390 stack[-1] // @1392 stack[-2] // @139A memory[0x00:0x20] // @139E storage[keccak256(memory[0x00:0x20])] // } 138E 5B JUMPDEST 138F 82 DUP3 1390 01 ADD 1391 91 SWAP2 1392 90 SWAP1 1393 60 PUSH1 0x00 1395 52 MSTORE 1396 60 PUSH1 0x20 1398 60 PUSH1 0x00 139A 20 SHA3 139B 90 SWAP1 139C 5B JUMPDEST 139D 81 DUP2 139E 54 SLOAD 139F 81 DUP2 13A0 52 MSTORE 13A1 90 SWAP1 13A2 60 PUSH1 0x01 13A4 01 ADD 13A5 90 SWAP1 13A6 60 PUSH1 0x20 13A8 01 ADD 13A9 80 DUP1 13AA 83 DUP4 13AB 11 GT 13AC 61 PUSH2 0x139c 13AF 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1391 stack[-3] = stack[-3] + stack[-1] // @1395 memory[0x00:0x20] = stack[-2] // @13A0 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @13A5 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @13A8 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x139c, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_13B0: // Incoming jump from 0x13AF, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x13AF, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @13B0 stack[-3] // @13B1 stack[-1] // } 13B0 82 DUP3 13B1 90 SWAP1 13B2 03 SUB 13B3 60 PUSH1 0x1f 13B5 16 AND 13B6 82 DUP3 13B7 01 ADD 13B8 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @13B8 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @13B8 stack[-1] = stack[-3] // } // Block continues label_13B9: // Incoming jump from 0x1372, if !stack[-1] // Incoming jump from 0x138D // Incoming jump from 0x13B8 // Inputs[1] { @13BF stack[-7] } 13B9 5B JUMPDEST 13BA 50 POP 13BB 50 POP 13BC 50 POP 13BD 50 POP 13BE 50 POP 13BF 81 DUP2 13C0 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_13C1: // Incoming jump from 0x062D // Inputs[2] // { // @13C4 storage[0x09] // @13CE msg.sender // } 13C1 5B JUMPDEST 13C2 60 PUSH1 0x09 13C4 54 SLOAD 13C5 60 PUSH1 0x01 13C7 60 PUSH1 0x01 13C9 60 PUSH1 0xa0 13CB 1B SHL 13CC 03 SUB 13CD 16 AND 13CE 33 CALLER 13CF 14 EQ 13D0 61 PUSH2 0x141b 13D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x141b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_13D4: // Incoming jump from 0x13D3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @13D6 memory[0x40:0x60] } 13D4 60 PUSH1 0x40 13D6 51 MLOAD 13D7 62 PUSH3 0x461bcd 13DB 60 PUSH1 0xe5 13DD 1B SHL 13DE 81 DUP2 13DF 52 MSTORE 13E0 60 PUSH1 0x20 13E2 60 PUSH1 0x04 13E4 82 DUP3 13E5 01 ADD 13E6 81 DUP2 13E7 90 SWAP1 13E8 52 MSTORE 13E9 60 PUSH1 0x24 13EB 82 DUP3 13EC 01 ADD 13ED 52 MSTORE 13EE 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 140F 60 PUSH1 0x44 1411 82 DUP3 1412 01 ADD 1413 52 MSTORE 1414 60 PUSH1 0x64 1416 01 ADD 1417 61 PUSH2 0x0a1a 141A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @13DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13ED memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1413 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1416 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_141B: // Incoming jump from 0x13D3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[2] // { // @141C stack[-1] // @141D memory[stack[-1]:stack[-1] + 0x20] // } 141B 5B JUMPDEST 141C 80 DUP1 141D 51 MLOAD 141E 61 PUSH2 0x0ef3 1421 90 SWAP1 1422 60 PUSH1 0x0a 1424 90 SWAP1 1425 60 PUSH1 0x20 1427 84 DUP5 1428 01 ADD 1429 90 SWAP1 142A 61 PUSH2 0x2fe5 142D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1421 stack[0] = 0x0ef3 // @1424 stack[1] = 0x0a // @1429 stack[2] = stack[-1] + 0x20 // @1429 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2fe5 label_142E: // Incoming jump from 0x066B // Inputs[2] // { // @1431 storage[0x09] // @143B msg.sender // } 142E 5B JUMPDEST 142F 60 PUSH1 0x09 1431 54 SLOAD 1432 60 PUSH1 0x01 1434 60 PUSH1 0x01 1436 60 PUSH1 0xa0 1438 1B SHL 1439 03 SUB 143A 16 AND 143B 33 CALLER 143C 14 EQ 143D 61 PUSH2 0x1488 1440 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1488, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_1441: // Incoming jump from 0x1440, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @1443 memory[0x40:0x60] } 1441 60 PUSH1 0x40 1443 51 MLOAD 1444 62 PUSH3 0x461bcd 1448 60 PUSH1 0xe5 144A 1B SHL 144B 81 DUP2 144C 52 MSTORE 144D 60 PUSH1 0x20 144F 60 PUSH1 0x04 1451 82 DUP3 1452 01 ADD 1453 81 DUP2 1454 90 SWAP1 1455 52 MSTORE 1456 60 PUSH1 0x24 1458 82 DUP3 1459 01 ADD 145A 52 MSTORE 145B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 147C 60 PUSH1 0x44 147E 82 DUP3 147F 01 ADD 1480 52 MSTORE 1481 60 PUSH1 0x64 1483 01 ADD 1484 61 PUSH2 0x0a1a 1487 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @144C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1455 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @145A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1480 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1483 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1488: // Incoming jump from 0x1440, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[2] // { // @148B stack[-1] // @148C stack[-2] // } 1488 5B JUMPDEST 1489 60 PUSH1 0x13 148B 55 SSTORE 148C 56 *JUMP // Stack delta = -2 // Outputs[1] { @148B storage[0x13] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_148D: // Incoming call from 0x0680, returns to 0x0341 // Inputs[1] { @1493 storage[0x02] } 148D 5B JUMPDEST 148E 60 PUSH1 0x60 1490 60 PUSH1 0x02 1492 80 DUP1 1493 54 SLOAD 1494 61 PUSH2 0x091c 1497 90 SWAP1 1498 61 PUSH2 0x3519 149B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @148E stack[0] = 0x60 // @1490 stack[1] = 0x02 // @1497 stack[2] = 0x091c // @1497 stack[3] = storage[0x02] // } // Block ends with call to 0x3519, returns to 0x091C label_149C: // Incoming jump from 0x06A0 // Inputs[2] // { // @149F storage[0x09] // @14A9 msg.sender // } 149C 5B JUMPDEST 149D 60 PUSH1 0x09 149F 54 SLOAD 14A0 60 PUSH1 0x01 14A2 60 PUSH1 0x01 14A4 60 PUSH1 0xa0 14A6 1B SHL 14A7 03 SUB 14A8 16 AND 14A9 33 CALLER 14AA 14 EQ 14AB 61 PUSH2 0x14f6 14AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14f6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_14AF: // Incoming jump from 0x14AE, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @14B1 memory[0x40:0x60] } 14AF 60 PUSH1 0x40 14B1 51 MLOAD 14B2 62 PUSH3 0x461bcd 14B6 60 PUSH1 0xe5 14B8 1B SHL 14B9 81 DUP2 14BA 52 MSTORE 14BB 60 PUSH1 0x20 14BD 60 PUSH1 0x04 14BF 82 DUP3 14C0 01 ADD 14C1 81 DUP2 14C2 90 SWAP1 14C3 52 MSTORE 14C4 60 PUSH1 0x24 14C6 82 DUP3 14C7 01 ADD 14C8 52 MSTORE 14C9 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 14EA 60 PUSH1 0x44 14EC 82 DUP3 14ED 01 ADD 14EE 52 MSTORE 14EF 60 PUSH1 0x64 14F1 01 ADD 14F2 61 PUSH2 0x0a1a 14F5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @14BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14C8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @14EE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @14F1 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_14F6: // Incoming jump from 0x14AE, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[3] // { // @14F9 storage[0x0f] // @14FA stack[-1] // @1500 storage[0x00] // } 14F6 5B JUMPDEST 14F7 60 PUSH1 0x0f 14F9 54 SLOAD 14FA 81 DUP2 14FB 61 PUSH2 0x1503 14FE 60 PUSH1 0x00 1500 54 SLOAD 1501 90 SWAP1 1502 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14F9 stack[0] = storage[0x0f] // @14FA stack[1] = stack[-1] // @1501 stack[2] = storage[0x00] // } // Block ends with unconditional jump to 0x1503 label_1503: // Incoming jump from 0x1502 // Inputs[2] // { // @1507 stack[-2] // @1508 stack[-1] // } 1503 5B JUMPDEST 1504 61 PUSH2 0x150d 1507 91 SWAP2 1508 90 SWAP1 1509 61 PUSH2 0x3585 150C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1507 stack[-2] = 0x150d // @1508 stack[-1] = stack[-2] // @1508 stack[0] = stack[-1] // } // Block ends with call to 0x3585, returns to 0x150D label_150D: // Incoming return from call to 0x3585 at 0x150C // Inputs[2] // { // @150E stack[-2] // @150E stack[-1] // } 150D 5B JUMPDEST 150E 11 GT 150F 15 ISZERO 1510 61 PUSH2 0x1547 1513 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1547, if !(stack[-1] > stack[-2]) label_1514: // Incoming jump from 0x1513, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1516 memory[0x40:0x60] } 1514 60 PUSH1 0x40 1516 51 MLOAD 1517 62 PUSH3 0x461bcd 151B 60 PUSH1 0xe5 151D 1B SHL 151E 81 DUP2 151F 52 MSTORE 1520 60 PUSH1 0x20 1522 60 PUSH1 0x04 1524 82 DUP3 1525 01 ADD 1526 52 MSTORE 1527 60 PUSH1 0x09 1529 60 PUSH1 0x24 152B 82 DUP3 152C 01 ADD 152D 52 MSTORE 152E 68 PUSH9 0x29b7b6321037baba17 1538 60 PUSH1 0xb9 153A 1B SHL 153B 60 PUSH1 0x44 153D 82 DUP3 153E 01 ADD 153F 52 MSTORE 1540 60 PUSH1 0x64 1542 01 ADD 1543 61 PUSH2 0x0a1a 1546 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @151F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1526 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @152D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @153F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x29b7b6321037baba17 << 0xb9 // @1542 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1547: // Incoming jump from 0x1513, if !(stack[-1] > stack[-2]) // Inputs[1] { @1569 stack[-1] } 1547 5B JUMPDEST 1548 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 1569 81 DUP2 156A 10 LT 156B 15 ISZERO 156C 61 PUSH2 0x1579 156F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1579, if !(stack[-1] < 0x0000000000000000000000000000000000000000000000000000000000000004) label_1570: // Incoming jump from 0x156F, if not !(stack[-1] < 0x0000000000000000000000000000000000000000000000000000000000000004) // Inputs[2] // { // @1573 msg.sender // @1574 stack[-1] // } 1570 61 PUSH2 0x1227 1573 33 CALLER 1574 82 DUP3 1575 61 PUSH2 0x2689 1578 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1570 stack[0] = 0x1227 // @1573 stack[1] = msg.sender // @1574 stack[2] = stack[-1] // } // Block ends with call to 0x2689, returns to 0x1227 label_1579: // Incoming jump from 0x156F, if !(stack[-1] < 0x0000000000000000000000000000000000000000000000000000000000000004) // Inputs[1] { @159E stack[-1] } 1579 5B JUMPDEST 157A 61 PUSH2 0x15a3 157D 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 159E 82 DUP3 159F 61 PUSH2 0x35b3 15A2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @157A stack[0] = 0x15a3 // @157D stack[1] = 0x0000000000000000000000000000000000000000000000000000000000000004 // @159E stack[2] = stack[-1] // } // Block ends with call to 0x35b3, returns to 0x15A3 label_15A3: // Incoming return from call to 0x35B3 at 0x15A2 // Inputs[1] { @15A4 stack[-1] } 15A3 5B JUMPDEST 15A4 15 ISZERO 15A5 61 PUSH2 0x1616 15A8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1616, if !stack[-1] label_15A9: // Incoming jump from 0x15A8, if not !stack[-1] // Inputs[1] { @15AB memory[0x40:0x60] } 15A9 60 PUSH1 0x40 15AB 51 MLOAD 15AC 62 PUSH3 0x461bcd 15B0 60 PUSH1 0xe5 15B2 1B SHL 15B3 81 DUP2 15B4 52 MSTORE 15B5 60 PUSH1 0x20 15B7 60 PUSH1 0x04 15B9 82 DUP3 15BA 01 ADD 15BB 52 MSTORE 15BC 60 PUSH1 0x2d 15BE 60 PUSH1 0x24 15C0 82 DUP3 15C1 01 ADD 15C2 52 MSTORE 15C3 7F PUSH32 0x43616e206f6e6c79206d696e742061206d756c7469706c65206f662074686520 15E4 60 PUSH1 0x44 15E6 82 DUP3 15E7 01 ADD 15E8 52 MSTORE 15E9 7F PUSH32 0x6d6178426174636853697a652e00000000000000000000000000000000000000 160A 60 PUSH1 0x64 160C 82 DUP3 160D 01 ADD 160E 52 MSTORE 160F 60 PUSH1 0x84 1611 01 ADD 1612 61 PUSH2 0x0a1a 1615 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @15B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15BB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15C2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @15E8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e206f6e6c79206d696e742061206d756c7469706c65206f662074686520 // @160E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6d6178426174636853697a652e00000000000000000000000000000000000000 // @1611 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1616: // Incoming jump from 0x15A8, if !stack[-1] // Inputs[1] { @163D stack[-1] } 1616 5B JUMPDEST 1617 60 PUSH1 0x00 1619 61 PUSH2 0x1642 161C 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 163D 83 DUP4 163E 61 PUSH2 0x35c7 1641 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1617 stack[0] = 0x00 // @1619 stack[1] = 0x1642 // @161C stack[2] = 0x0000000000000000000000000000000000000000000000000000000000000004 // @163D stack[3] = stack[-1] // } // Block ends with call to 0x35c7, returns to 0x1642 label_1642: // Incoming return from call to 0x35C7 at 0x1641 // Inputs[2] // { // @1643 stack[-1] // @1643 stack[-2] // } 1642 5B JUMPDEST 1643 90 SWAP1 1644 50 POP 1645 60 PUSH1 0x00 1647 5B JUMPDEST 1648 81 DUP2 1649 81 DUP2 164A 10 LT 164B 15 ISZERO 164C 61 PUSH2 0x0b6d 164F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1643 stack[-2] = stack[-1] // @1645 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0b6d, if !(0x00 < stack[-1]) label_1650: // Incoming jump from 0x164F, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x164F, if not !(0x00 < stack[-1]) // Inputs[1] { @1653 msg.sender } 1650 61 PUSH2 0x1679 1653 33 CALLER 1654 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 1675 61 PUSH2 0x2689 1678 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1650 stack[0] = 0x1679 // @1653 stack[1] = msg.sender // @1654 stack[2] = 0x0000000000000000000000000000000000000000000000000000000000000004 // } // Block ends with call to 0x2689, returns to 0x1679 label_1679: // Incoming return from call to 0x2689 at 0x1678 // Inputs[1] { @167A stack[-1] } 1679 5B JUMPDEST 167A 80 DUP1 167B 61 PUSH2 0x1683 167E 81 DUP2 167F 61 PUSH2 0x356a 1682 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @167A stack[0] = stack[-1] // @167B stack[1] = 0x1683 // @167E stack[2] = stack[-1] // } // Block ends with call to 0x356a, returns to 0x1683 label_1683: // Incoming return from call to 0x356A at 0x1682 // Inputs[2] // { // @1684 stack[-3] // @1684 stack[-1] // } 1683 5B JUMPDEST 1684 91 SWAP2 1685 50 POP 1686 50 POP 1687 61 PUSH2 0x1647 168A 56 *JUMP // Stack delta = -2 // Outputs[1] { @1684 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1647 label_168B: // Incoming jump from 0x06D6 // Inputs[2] // { // @1694 stack[-2] // @1696 msg.sender // } 168B 5B JUMPDEST 168C 60 PUSH1 0x01 168E 60 PUSH1 0x01 1690 60 PUSH1 0xa0 1692 1B SHL 1693 03 SUB 1694 82 DUP3 1695 16 AND 1696 33 CALLER 1697 14 EQ 1698 15 ISZERO 1699 61 PUSH2 0x16e4 169C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16e4, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_169D: // Incoming jump from 0x169C, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @169F memory[0x40:0x60] } 169D 60 PUSH1 0x40 169F 51 MLOAD 16A0 62 PUSH3 0x461bcd 16A4 60 PUSH1 0xe5 16A6 1B SHL 16A7 81 DUP2 16A8 52 MSTORE 16A9 60 PUSH1 0x20 16AB 60 PUSH1 0x04 16AD 82 DUP3 16AE 01 ADD 16AF 52 MSTORE 16B0 60 PUSH1 0x1a 16B2 60 PUSH1 0x24 16B4 82 DUP3 16B5 01 ADD 16B6 52 MSTORE 16B7 7F PUSH32 0x455243373231413a20617070726f766520746f2063616c6c6572000000000000 16D8 60 PUSH1 0x44 16DA 82 DUP3 16DB 01 ADD 16DC 52 MSTORE 16DD 60 PUSH1 0x64 16DF 01 ADD 16E0 61 PUSH2 0x0a1a 16E3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @16A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16AF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16B6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @16DC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20617070726f766520746f2063616c6c6572000000000000 // @16DF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_16E4: // Incoming jump from 0x169C, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @16E5 msg.sender // @16F6 memory[0x00:0x40] // @16FF stack[-2] // @170A memory[0x00:0x40] // @170C storage[keccak256(memory[0x00:0x40])] // @1711 stack[-1] // @171B memory[0x40:0x60] // @1747 memory[0x40:0x60] // @174C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @174F stack[-3] // } 16E4 5B JUMPDEST 16E5 33 CALLER 16E6 60 PUSH1 0x00 16E8 81 DUP2 16E9 81 DUP2 16EA 52 MSTORE 16EB 60 PUSH1 0x06 16ED 60 PUSH1 0x20 16EF 90 SWAP1 16F0 81 DUP2 16F1 52 MSTORE 16F2 60 PUSH1 0x40 16F4 80 DUP1 16F5 83 DUP4 16F6 20 SHA3 16F7 60 PUSH1 0x01 16F9 60 PUSH1 0x01 16FB 60 PUSH1 0xa0 16FD 1B SHL 16FE 03 SUB 16FF 87 DUP8 1700 16 AND 1701 80 DUP1 1702 85 DUP6 1703 52 MSTORE 1704 90 SWAP1 1705 83 DUP4 1706 52 MSTORE 1707 92 SWAP3 1708 81 DUP2 1709 90 SWAP1 170A 20 SHA3 170B 80 DUP1 170C 54 SLOAD 170D 60 PUSH1 0xff 170F 19 NOT 1710 16 AND 1711 86 DUP7 1712 15 ISZERO 1713 15 ISZERO 1714 90 SWAP1 1715 81 DUP2 1716 17 OR 1717 90 SWAP1 1718 91 SWAP2 1719 55 SSTORE 171A 90 SWAP1 171B 51 MLOAD 171C 90 SWAP1 171D 81 DUP2 171E 52 MSTORE 171F 91 SWAP2 1720 92 SWAP3 1721 91 SWAP2 1722 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1743 91 SWAP2 1744 01 ADD 1745 60 PUSH1 0x40 1747 51 MLOAD 1748 80 DUP1 1749 91 SWAP2 174A 03 SUB 174B 90 SWAP1 174C A3 LOG3 174D 50 POP 174E 50 POP 174F 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @16EA memory[0x00:0x20] = msg.sender // @16F1 memory[0x20:0x40] = 0x06 // @1703 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1706 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1719 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @171E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @174C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_1750: // Incoming jump from 0x06E9 // Inputs[5] // { // @1754 stack[-4] // @1755 stack[-3] // @1756 stack[-2] // @1767 memory[0x40:0x60] // @177E msg.data[stack[-3]:stack[-3] + stack[-2]] // } 1750 5B JUMPDEST 1751 61 PUSH2 0x1790 1754 84 DUP5 1755 84 DUP5 1756 84 DUP5 1757 80 DUP1 1758 80 DUP1 1759 60 PUSH1 0x1f 175B 01 ADD 175C 60 PUSH1 0x20 175E 80 DUP1 175F 91 SWAP2 1760 04 DIV 1761 02 MUL 1762 60 PUSH1 0x20 1764 01 ADD 1765 60 PUSH1 0x40 1767 51 MLOAD 1768 90 SWAP1 1769 81 DUP2 176A 01 ADD 176B 60 PUSH1 0x40 176D 52 MSTORE 176E 80 DUP1 176F 93 SWAP4 1770 92 SWAP3 1771 91 SWAP2 1772 90 SWAP1 1773 81 DUP2 1774 81 DUP2 1775 52 MSTORE 1776 60 PUSH1 0x20 1778 01 ADD 1779 83 DUP4 177A 83 DUP4 177B 80 DUP1 177C 82 DUP3 177D 84 DUP5 177E 37 CALLDATACOPY 177F 60 PUSH1 0x00 1781 92 SWAP3 1782 01 ADD 1783 91 SWAP2 1784 90 SWAP1 1785 91 SWAP2 1786 52 MSTORE 1787 50 POP 1788 61 PUSH2 0x233a 178B 92 SWAP3 178C 50 POP 178D 50 POP 178E 50 POP 178F 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1751 stack[0] = 0x1790 // @1754 stack[1] = stack[-4] // @176D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @176F stack[2] = memory[0x40:0x60] // @1775 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @177E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1786 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x233a 1790 5B JUMPDEST 1791 61 PUSH2 0x1802 1794 57 *JUMPI 1795 60 PUSH1 0x40 1797 51 MLOAD 1798 62 PUSH3 0x461bcd 179C 60 PUSH1 0xe5 179E 1B SHL 179F 81 DUP2 17A0 52 MSTORE 17A1 60 PUSH1 0x20 17A3 60 PUSH1 0x04 17A5 82 DUP3 17A6 01 ADD 17A7 52 MSTORE 17A8 60 PUSH1 0x21 17AA 60 PUSH1 0x24 17AC 82 DUP3 17AD 01 ADD 17AE 52 MSTORE 17AF 7F PUSH32 0x5468697320686173682773207369676e617475726520697320696e76616c6964 17D0 60 PUSH1 0x44 17D2 82 DUP3 17D3 01 ADD 17D4 52 MSTORE 17D5 7F PUSH32 0x2e00000000000000000000000000000000000000000000000000000000000000 17F6 60 PUSH1 0x64 17F8 82 DUP3 17F9 01 ADD 17FA 52 MSTORE 17FB 60 PUSH1 0x84 17FD 01 ADD 17FE 61 PUSH2 0x0a1a 1801 56 *JUMP 1802 5B JUMPDEST 1803 83 DUP4 1804 61 PUSH2 0x180c 1807 33 CALLER 1808 61 PUSH2 0x26a3 180B 56 *JUMP 180C 5B JUMPDEST 180D 14 EQ 180E 61 PUSH2 0x187f 1811 57 *JUMPI 1812 60 PUSH1 0x40 1814 51 MLOAD 1815 62 PUSH3 0x461bcd 1819 60 PUSH1 0xe5 181B 1B SHL 181C 81 DUP2 181D 52 MSTORE 181E 60 PUSH1 0x20 1820 60 PUSH1 0x04 1822 82 DUP3 1823 01 ADD 1824 52 MSTORE 1825 60 PUSH1 0x30 1827 60 PUSH1 0x24 1829 82 DUP3 182A 01 ADD 182B 52 MSTORE 182C 7F PUSH32 0x5468652061646472657373206861736820646f6573206e6f74206d6174636820 184D 60 PUSH1 0x44 184F 82 DUP3 1850 01 ADD 1851 52 MSTORE 1852 7F PUSH32 0x746865207369676e656420686173682e00000000000000000000000000000000 1873 60 PUSH1 0x64 1875 82 DUP3 1876 01 ADD 1877 52 MSTORE 1878 60 PUSH1 0x84 187A 01 ADD 187B 61 PUSH2 0x0a1a 187E 56 *JUMP 187F 5B JUMPDEST 1880 60 PUSH1 0x14 1882 54 SLOAD 1883 33 CALLER 1884 60 PUSH1 0x00 1886 90 SWAP1 1887 81 DUP2 1888 52 MSTORE 1889 60 PUSH1 0x0c 188B 60 PUSH1 0x20 188D 52 MSTORE 188E 60 PUSH1 0x40 1890 90 SWAP1 1891 20 SHA3 1892 54 SLOAD 1893 61 PUSH2 0x189d 1896 90 SWAP1 1897 83 DUP4 1898 90 SWAP1 1899 61 PUSH2 0x3585 189C 56 *JUMP 189D 5B JUMPDEST 189E 11 GT 189F 15 ISZERO 18A0 61 PUSH2 0x18eb 18A3 57 *JUMPI 18A4 60 PUSH1 0x40 18A6 51 MLOAD 18A7 62 PUSH3 0x461bcd 18AB 60 PUSH1 0xe5 18AD 1B SHL 18AE 81 DUP2 18AF 52 MSTORE 18B0 60 PUSH1 0x20 18B2 60 PUSH1 0x04 18B4 82 DUP3 18B5 01 ADD 18B6 52 MSTORE 18B7 60 PUSH1 0x1a 18B9 60 PUSH1 0x24 18BB 82 DUP3 18BC 01 ADD 18BD 52 MSTORE 18BE 7F PUSH32 0x596f752063616e6e6f74206d696e742074686973206d616e792e000000000000 18DF 60 PUSH1 0x44 18E1 82 DUP3 18E2 01 ADD 18E3 52 MSTORE 18E4 60 PUSH1 0x64 18E6 01 ADD 18E7 61 PUSH2 0x0a1a 18EA 56 *JUMP 18EB 5B JUMPDEST 18EC 61 PUSH2 0x18f4 18EF 81 DUP2 18F0 61 PUSH2 0x23a8 18F3 56 *JUMP 18F4 5B JUMPDEST 18F5 33 CALLER 18F6 60 PUSH1 0x00 18F8 90 SWAP1 18F9 81 DUP2 18FA 52 MSTORE 18FB 60 PUSH1 0x0c 18FD 60 PUSH1 0x20 18FF 52 MSTORE 1900 60 PUSH1 0x40 1902 81 DUP2 1903 20 SHA3 1904 80 DUP1 1905 54 SLOAD 1906 83 DUP4 1907 92 SWAP3 1908 90 SWAP1 1909 61 PUSH2 0x1913 190C 90 SWAP1 190D 84 DUP5 190E 90 SWAP1 190F 61 PUSH2 0x3585 1912 56 *JUMP 1913 5B JUMPDEST 1914 90 SWAP1 1915 91 SWAP2 1916 55 SSTORE 1917 50 POP 1918 50 POP 1919 50 POP 191A 50 POP 191B 50 POP 191C 50 POP 191D 56 *JUMP label_191E: // Incoming jump from 0x0709 // Inputs[5] // { // @1922 stack[-3] // @1923 stack[-2] // @1924 stack[-1] // @1935 memory[0x40:0x60] // @194C msg.data[stack[-2]:stack[-2] + stack[-1]] // } 191E 5B JUMPDEST 191F 61 PUSH2 0x195e 1922 83 DUP4 1923 83 DUP4 1924 83 DUP4 1925 80 DUP1 1926 80 DUP1 1927 60 PUSH1 0x1f 1929 01 ADD 192A 60 PUSH1 0x20 192C 80 DUP1 192D 91 SWAP2 192E 04 DIV 192F 02 MUL 1930 60 PUSH1 0x20 1932 01 ADD 1933 60 PUSH1 0x40 1935 51 MLOAD 1936 90 SWAP1 1937 81 DUP2 1938 01 ADD 1939 60 PUSH1 0x40 193B 52 MSTORE 193C 80 DUP1 193D 93 SWAP4 193E 92 SWAP3 193F 91 SWAP2 1940 90 SWAP1 1941 81 DUP2 1942 81 DUP2 1943 52 MSTORE 1944 60 PUSH1 0x20 1946 01 ADD 1947 83 DUP4 1948 83 DUP4 1949 80 DUP1 194A 82 DUP3 194B 84 DUP5 194C 37 CALLDATACOPY 194D 60 PUSH1 0x00 194F 92 SWAP3 1950 01 ADD 1951 91 SWAP2 1952 90 SWAP1 1953 91 SWAP2 1954 52 MSTORE 1955 50 POP 1956 61 PUSH2 0x233a 1959 92 SWAP3 195A 50 POP 195B 50 POP 195C 50 POP 195D 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @191F stack[0] = 0x195e // @1922 stack[1] = stack[-3] // @193B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @193D stack[2] = memory[0x40:0x60] // @1943 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @194C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @1954 memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x233a 195E 5B JUMPDEST 195F 61 PUSH2 0x19aa 1962 57 *JUMPI 1963 60 PUSH1 0x40 1965 51 MLOAD 1966 62 PUSH3 0x461bcd 196A 60 PUSH1 0xe5 196C 1B SHL 196D 81 DUP2 196E 52 MSTORE 196F 60 PUSH1 0x20 1971 60 PUSH1 0x04 1973 82 DUP3 1974 01 ADD 1975 52 MSTORE 1976 60 PUSH1 0x12 1978 60 PUSH1 0x24 197A 82 DUP3 197B 01 ADD 197C 52 MSTORE 197D 7F PUSH32 0x5369676e617475726520696e76616c69642e0000000000000000000000000000 199E 60 PUSH1 0x44 19A0 82 DUP3 19A1 01 ADD 19A2 52 MSTORE 19A3 60 PUSH1 0x64 19A5 01 ADD 19A6 61 PUSH2 0x0a1a 19A9 56 *JUMP 19AA 5B JUMPDEST 19AB 82 DUP3 19AC 61 PUSH2 0x1a41 19AF 60 PUSH1 0x1a 19B1 80 DUP1 19B2 54 SLOAD 19B3 61 PUSH2 0x19bb 19B6 90 SWAP1 19B7 61 PUSH2 0x3519 19BA 56 *JUMP 19BB 5B JUMPDEST 19BC 80 DUP1 19BD 60 PUSH1 0x1f 19BF 01 ADD 19C0 60 PUSH1 0x20 19C2 80 DUP1 19C3 91 SWAP2 19C4 04 DIV 19C5 02 MUL 19C6 60 PUSH1 0x20 19C8 01 ADD 19C9 60 PUSH1 0x40 19CB 51 MLOAD 19CC 90 SWAP1 19CD 81 DUP2 19CE 01 ADD 19CF 60 PUSH1 0x40 19D1 52 MSTORE 19D2 80 DUP1 19D3 92 SWAP3 19D4 91 SWAP2 19D5 90 SWAP1 19D6 81 DUP2 19D7 81 DUP2 19D8 52 MSTORE 19D9 60 PUSH1 0x20 19DB 01 ADD 19DC 82 DUP3 19DD 80 DUP1 19DE 54 SLOAD 19DF 61 PUSH2 0x19e7 19E2 90 SWAP1 19E3 61 PUSH2 0x3519 19E6 56 *JUMP 19E7 5B JUMPDEST 19E8 80 DUP1 19E9 15 ISZERO 19EA 61 PUSH2 0x1a34 19ED 57 *JUMPI 19EE 80 DUP1 19EF 60 PUSH1 0x1f 19F1 10 LT 19F2 61 PUSH2 0x1a09 19F5 57 *JUMPI 19F6 61 PUSH2 0x0100 19F9 80 DUP1 19FA 83 DUP4 19FB 54 SLOAD 19FC 04 DIV 19FD 02 MUL 19FE 83 DUP4 19FF 52 MSTORE 1A00 91 SWAP2 1A01 60 PUSH1 0x20 1A03 01 ADD 1A04 91 SWAP2 1A05 61 PUSH2 0x1a34 1A08 56 *JUMP 1A09 5B JUMPDEST 1A0A 82 DUP3 1A0B 01 ADD 1A0C 91 SWAP2 1A0D 90 SWAP1 1A0E 60 PUSH1 0x00 1A10 52 MSTORE 1A11 60 PUSH1 0x20 1A13 60 PUSH1 0x00 1A15 20 SHA3 1A16 90 SWAP1 1A17 5B JUMPDEST 1A18 81 DUP2 1A19 54 SLOAD 1A1A 81 DUP2 1A1B 52 MSTORE 1A1C 90 SWAP1 1A1D 60 PUSH1 0x01 1A1F 01 ADD 1A20 90 SWAP1 1A21 60 PUSH1 0x20 1A23 01 ADD 1A24 80 DUP1 1A25 83 DUP4 1A26 11 GT 1A27 61 PUSH2 0x1a17 1A2A 57 *JUMPI 1A2B 82 DUP3 1A2C 90 SWAP1 1A2D 03 SUB 1A2E 60 PUSH1 0x1f 1A30 16 AND 1A31 82 DUP3 1A32 01 ADD 1A33 91 SWAP2 1A34 5B JUMPDEST 1A35 50 POP 1A36 50 POP 1A37 50 POP 1A38 50 POP 1A39 50 POP 1A3A 33 CALLER 1A3B 88 DUP9 1A3C 88 DUP9 1A3D 61 PUSH2 0x26d6 1A40 56 *JUMP 1A41 5B JUMPDEST 1A42 14 EQ 1A43 61 PUSH2 0x1a7e 1A46 57 *JUMPI 1A47 60 PUSH1 0x40 1A49 51 MLOAD 1A4A 62 PUSH3 0x461bcd 1A4E 60 PUSH1 0xe5 1A50 1B SHL 1A51 81 DUP2 1A52 52 MSTORE 1A53 60 PUSH1 0x20 1A55 60 PUSH1 0x04 1A57 82 DUP3 1A58 01 ADD 1A59 52 MSTORE 1A5A 60 PUSH1 0x0d 1A5C 60 PUSH1 0x24 1A5E 82 DUP3 1A5F 01 ADD 1A60 52 MSTORE 1A61 6C PUSH13 0x2430b9b41034b73b30b634b217 1A6F 60 PUSH1 0x99 1A71 1B SHL 1A72 60 PUSH1 0x44 1A74 82 DUP3 1A75 01 ADD 1A76 52 MSTORE 1A77 60 PUSH1 0x64 1A79 01 ADD 1A7A 61 PUSH2 0x0a1a 1A7D 56 *JUMP 1A7E 5B JUMPDEST 1A7F 60 PUSH1 0x00 1A81 84 DUP5 1A82 81 DUP2 1A83 52 MSTORE 1A84 60 PUSH1 0x17 1A86 60 PUSH1 0x20 1A88 52 MSTORE 1A89 60 PUSH1 0x40 1A8B 90 SWAP1 1A8C 20 SHA3 1A8D 54 SLOAD 1A8E 60 PUSH1 0xff 1A90 16 AND 1A91 15 ISZERO 1A92 61 PUSH2 0x1add 1A95 57 *JUMPI 1A96 60 PUSH1 0x40 1A98 51 MLOAD 1A99 62 PUSH3 0x461bcd 1A9D 60 PUSH1 0xe5 1A9F 1B SHL 1AA0 81 DUP2 1AA1 52 MSTORE 1AA2 60 PUSH1 0x20 1AA4 60 PUSH1 0x04 1AA6 82 DUP3 1AA7 01 ADD 1AA8 52 MSTORE 1AA9 60 PUSH1 0x13 1AAB 60 PUSH1 0x24 1AAD 82 DUP3 1AAE 01 ADD 1AAF 52 MSTORE 1AB0 7F PUSH32 0x4e6f6e636520616c726561647920757365642e00000000000000000000000000 1AD1 60 PUSH1 0x44 1AD3 82 DUP3 1AD4 01 ADD 1AD5 52 MSTORE 1AD6 60 PUSH1 0x64 1AD8 01 ADD 1AD9 61 PUSH2 0x0a1a 1ADC 56 *JUMP 1ADD 5B JUMPDEST 1ADE 33 CALLER 1ADF 61 PUSH2 0x1ae7 1AE2 87 DUP8 1AE3 61 PUSH2 0x115b 1AE6 56 *JUMP 1AE7 5B JUMPDEST 1AE8 60 PUSH1 0x01 1AEA 60 PUSH1 0x01 1AEC 60 PUSH1 0xa0 1AEE 1B SHL 1AEF 03 SUB 1AF0 16 AND 1AF1 14 EQ 1AF2 61 PUSH2 0x1b3d 1AF5 57 *JUMPI 1AF6 60 PUSH1 0x40 1AF8 51 MLOAD 1AF9 62 PUSH3 0x461bcd 1AFD 60 PUSH1 0xe5 1AFF 1B SHL 1B00 81 DUP2 1B01 52 MSTORE 1B02 60 PUSH1 0x20 1B04 60 PUSH1 0x04 1B06 82 DUP3 1B07 01 ADD 1B08 52 MSTORE 1B09 60 PUSH1 0x1a 1B0B 60 PUSH1 0x24 1B0D 82 DUP3 1B0E 01 ADD 1B0F 52 MSTORE 1B10 7F PUSH32 0x596f7520646f206e6f74206f776e207468697320746f6b656e2e000000000000 1B31 60 PUSH1 0x44 1B33 82 DUP3 1B34 01 ADD 1B35 52 MSTORE 1B36 60 PUSH1 0x64 1B38 01 ADD 1B39 61 PUSH2 0x0a1a 1B3C 56 *JUMP 1B3D 5B JUMPDEST 1B3E 60 PUSH1 0x00 1B40 84 DUP5 1B41 81 DUP2 1B42 52 MSTORE 1B43 60 PUSH1 0x17 1B45 60 PUSH1 0x20 1B47 90 SWAP1 1B48 81 DUP2 1B49 52 MSTORE 1B4A 60 PUSH1 0x40 1B4C 80 DUP1 1B4D 83 DUP4 1B4E 20 SHA3 1B4F 80 DUP1 1B50 54 SLOAD 1B51 60 PUSH1 0xff 1B53 19 NOT 1B54 16 AND 1B55 60 PUSH1 0x01 1B57 17 OR 1B58 90 SWAP1 1B59 55 SSTORE 1B5A 88 DUP9 1B5B 83 DUP4 1B5C 52 MSTORE 1B5D 60 PUSH1 0x18 1B5F 82 DUP3 1B60 52 MSTORE 1B61 90 SWAP1 1B62 91 SWAP2 1B63 20 SHA3 1B64 86 DUP7 1B65 51 MLOAD 1B66 61 PUSH2 0x1b71 1B69 92 SWAP3 1B6A 88 DUP9 1B6B 01 ADD 1B6C 90 SWAP1 1B6D 61 PUSH2 0x2fe5 1B70 56 *JUMP 1B71 5B JUMPDEST 1B72 50 POP 1B73 50 POP 1B74 50 POP 1B75 50 POP 1B76 50 POP 1B77 50 POP 1B78 50 POP 1B79 56 *JUMP label_1B7A: // Incoming jump from 0x0729 // Incoming jump from 0x0E09 // Inputs[3] // { // @1B7E stack[-4] // @1B7F stack[-3] // @1B80 stack[-2] // } 1B7A 5B JUMPDEST 1B7B 61 PUSH2 0x1b85 1B7E 84 DUP5 1B7F 84 DUP5 1B80 84 DUP5 1B81 61 PUSH2 0x1f78 1B84 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B7B stack[0] = 0x1b85 // @1B7E stack[1] = stack[-4] // @1B7F stack[2] = stack[-3] // @1B80 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1f78 1B85 5B JUMPDEST 1B86 61 PUSH2 0x1b91 1B89 84 DUP5 1B8A 84 DUP5 1B8B 84 DUP5 1B8C 84 DUP5 1B8D 61 PUSH2 0x2710 1B90 56 *JUMP 1B91 5B JUMPDEST 1B92 61 PUSH2 0x1c03 1B95 57 *JUMPI 1B96 60 PUSH1 0x40 1B98 51 MLOAD 1B99 62 PUSH3 0x461bcd 1B9D 60 PUSH1 0xe5 1B9F 1B SHL 1BA0 81 DUP2 1BA1 52 MSTORE 1BA2 60 PUSH1 0x20 1BA4 60 PUSH1 0x04 1BA6 82 DUP3 1BA7 01 ADD 1BA8 52 MSTORE 1BA9 60 PUSH1 0x33 1BAB 60 PUSH1 0x24 1BAD 82 DUP3 1BAE 01 ADD 1BAF 52 MSTORE 1BB0 7F PUSH32 0x455243373231413a207472616e7366657220746f206e6f6e2045524337323152 1BD1 60 PUSH1 0x44 1BD3 82 DUP3 1BD4 01 ADD 1BD5 52 MSTORE 1BD6 7F PUSH32 0x6563656976657220696d706c656d656e74657200000000000000000000000000 1BF7 60 PUSH1 0x64 1BF9 82 DUP3 1BFA 01 ADD 1BFB 52 MSTORE 1BFC 60 PUSH1 0x84 1BFE 01 ADD 1BFF 61 PUSH2 0x0a1a 1C02 56 *JUMP label_1C03: // Incoming jump from 0x30CB, if !(stack[-1] > stack[-4]) // Inputs[1] { @1C08 stack[-5] } 1C03 5B JUMPDEST 1C04 50 POP 1C05 50 POP 1C06 50 POP 1C07 50 POP 1C08 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1C09: // Incoming call from 0x073E, returns to 0x0341 // Inputs[1] { @1C0D storage[0x1a] } 1C09 5B JUMPDEST 1C0A 60 PUSH1 0x1a 1C0C 80 DUP1 1C0D 54 SLOAD 1C0E 61 PUSH2 0x1340 1C11 90 SWAP1 1C12 61 PUSH2 0x3519 1C15 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C0A stack[0] = 0x1a // @1C11 stack[1] = 0x1340 // @1C11 stack[2] = storage[0x1a] // } // Block ends with call to 0x3519, returns to 0x1340 label_1C16: // Incoming jump from 0x075E // Inputs[2] // { // @1C1C stack[-1] // @1C1F storage[0x00] // } 1C16 5B JUMPDEST 1C17 60 PUSH1 0x60 1C19 61 PUSH2 0x1c23 1C1C 82 DUP3 1C1D 60 PUSH1 0x00 1C1F 54 SLOAD 1C20 11 GT 1C21 90 SWAP1 1C22 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C17 stack[0] = 0x60 // @1C21 stack[1] = storage[0x00] > stack[-1] // } // Block ends with unconditional jump to 0x1c23 label_1C23: // Incoming jump from 0x1C22 // Inputs[1] { @1C27 stack[-1] } 1C23 5B JUMPDEST 1C24 61 PUSH2 0x1c6f 1C27 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c6f, if stack[-1] label_1C28: // Incoming jump from 0x1C27, if not stack[-1] // Inputs[1] { @1C2A memory[0x40:0x60] } 1C28 60 PUSH1 0x40 1C2A 51 MLOAD 1C2B 62 PUSH3 0x461bcd 1C2F 60 PUSH1 0xe5 1C31 1B SHL 1C32 81 DUP2 1C33 52 MSTORE 1C34 60 PUSH1 0x20 1C36 60 PUSH1 0x04 1C38 82 DUP3 1C39 01 ADD 1C3A 52 MSTORE 1C3B 60 PUSH1 0x14 1C3D 60 PUSH1 0x24 1C3F 82 DUP3 1C40 01 ADD 1C41 52 MSTORE 1C42 7F PUSH32 0x546f6b656e20646f6573206e6f74206578697374000000000000000000000000 1C63 60 PUSH1 0x44 1C65 82 DUP3 1C66 01 ADD 1C67 52 MSTORE 1C68 60 PUSH1 0x64 1C6A 01 ADD 1C6B 61 PUSH2 0x0a1a 1C6E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1C33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1C3A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C41 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1C67 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546f6b656e20646f6573206e6f74206578697374000000000000000000000000 // @1C6A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1C6F: // Incoming jump from 0x1C27, if stack[-1] // Inputs[3] // { // @1C72 stack[-2] // @1C7D memory[0x00:0x40] // @1C7F storage[keccak256(memory[0x00:0x40])] // } 1C6F 5B JUMPDEST 1C70 60 PUSH1 0x00 1C72 82 DUP3 1C73 81 DUP2 1C74 52 MSTORE 1C75 60 PUSH1 0x18 1C77 60 PUSH1 0x20 1C79 52 MSTORE 1C7A 60 PUSH1 0x40 1C7C 81 DUP2 1C7D 20 SHA3 1C7E 80 DUP1 1C7F 54 SLOAD 1C80 61 PUSH2 0x1c88 1C83 90 SWAP1 1C84 61 PUSH2 0x3519 1C87 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1C70 stack[0] = 0x00 // @1C74 memory[0x00:0x20] = stack[-2] // @1C79 memory[0x20:0x40] = 0x18 // @1C7D stack[1] = keccak256(memory[0x00:0x40]) // @1C83 stack[2] = 0x1c88 // @1C83 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3519, returns to 0x1C88 label_1C88: // Incoming return from call to 0x3519 at 0x1C87 // Inputs[4] // { // @1C89 stack[-1] // @1C98 memory[0x40:0x60] // @1CA0 stack[-2] // @1CAB storage[stack[-2]] // } 1C88 5B JUMPDEST 1C89 80 DUP1 1C8A 60 PUSH1 0x1f 1C8C 01 ADD 1C8D 60 PUSH1 0x20 1C8F 80 DUP1 1C90 91 SWAP2 1C91 04 DIV 1C92 02 MUL 1C93 60 PUSH1 0x20 1C95 01 ADD 1C96 60 PUSH1 0x40 1C98 51 MLOAD 1C99 90 SWAP1 1C9A 81 DUP2 1C9B 01 ADD 1C9C 60 PUSH1 0x40 1C9E 52 MSTORE 1C9F 80 DUP1 1CA0 92 SWAP3 1CA1 91 SWAP2 1CA2 90 SWAP1 1CA3 81 DUP2 1CA4 81 DUP2 1CA5 52 MSTORE 1CA6 60 PUSH1 0x20 1CA8 01 ADD 1CA9 82 DUP3 1CAA 80 DUP1 1CAB 54 SLOAD 1CAC 61 PUSH2 0x1cb4 1CAF 90 SWAP1 1CB0 61 PUSH2 0x3519 1CB3 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1C9E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1CA0 stack[-2] = memory[0x40:0x60] // @1CA1 stack[-1] = stack[-2] // @1CA2 stack[0] = stack[-1] // @1CA5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1CA8 stack[1] = 0x20 + memory[0x40:0x60] // @1CA9 stack[2] = stack[-2] // @1CAF stack[4] = storage[stack[-2]] // @1CAF stack[3] = 0x1cb4 // } // Block ends with call to 0x3519, returns to 0x1CB4 label_1CB4: // Incoming return from call to 0x3519 at 0x1CB3 // Inputs[1] { @1CB5 stack[-1] } 1CB4 5B JUMPDEST 1CB5 80 DUP1 1CB6 15 ISZERO 1CB7 61 PUSH2 0x1d01 1CBA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d01, if !stack[-1] label_1CBB: // Incoming jump from 0x1CBA, if not !stack[-1] // Inputs[1] { @1CBB stack[-1] } 1CBB 80 DUP1 1CBC 60 PUSH1 0x1f 1CBE 10 LT 1CBF 61 PUSH2 0x1cd6 1CC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1cd6, if 0x1f < stack[-1] label_1CC3: // Incoming jump from 0x1CC2, if not 0x1f < stack[-1] // Inputs[4] // { // @1CC7 stack[-2] // @1CC8 storage[stack[-2]] // @1CCB stack[-3] // @1CCD stack[-1] // } 1CC3 61 PUSH2 0x0100 1CC6 80 DUP1 1CC7 83 DUP4 1CC8 54 SLOAD 1CC9 04 DIV 1CCA 02 MUL 1CCB 83 DUP4 1CCC 52 MSTORE 1CCD 91 SWAP2 1CCE 60 PUSH1 0x20 1CD0 01 ADD 1CD1 91 SWAP2 1CD2 61 PUSH2 0x1d01 1CD5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1CCC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1CD1 stack[-1] = stack[-1] // @1CD1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1d01 label_1CD6: // Incoming jump from 0x1CC2, if 0x1f < stack[-1] // Inputs[5] // { // @1CD7 stack[-3] // @1CD8 stack[-1] // @1CDA stack[-2] // @1CE2 memory[0x00:0x20] // @1CE6 storage[keccak256(memory[0x00:0x20])] // } 1CD6 5B JUMPDEST 1CD7 82 DUP3 1CD8 01 ADD 1CD9 91 SWAP2 1CDA 90 SWAP1 1CDB 60 PUSH1 0x00 1CDD 52 MSTORE 1CDE 60 PUSH1 0x20 1CE0 60 PUSH1 0x00 1CE2 20 SHA3 1CE3 90 SWAP1 1CE4 5B JUMPDEST 1CE5 81 DUP2 1CE6 54 SLOAD 1CE7 81 DUP2 1CE8 52 MSTORE 1CE9 90 SWAP1 1CEA 60 PUSH1 0x01 1CEC 01 ADD 1CED 90 SWAP1 1CEE 60 PUSH1 0x20 1CF0 01 ADD 1CF1 80 DUP1 1CF2 83 DUP4 1CF3 11 GT 1CF4 61 PUSH2 0x1ce4 1CF7 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1CD9 stack[-3] = stack[-3] + stack[-1] // @1CDD memory[0x00:0x20] = stack[-2] // @1CE8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1CED stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1CF0 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1ce4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1CF8: // Incoming jump from 0x1CF7, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1CF7, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1CF8 stack[-3] // @1CF9 stack[-1] // } 1CF8 82 DUP3 1CF9 90 SWAP1 1CFA 03 SUB 1CFB 60 PUSH1 0x1f 1CFD 16 AND 1CFE 82 DUP3 1CFF 01 ADD 1D00 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1D00 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1D00 stack[-1] = stack[-3] // } // Block continues label_1D01: // Incoming jump from 0x1D00 // Incoming jump from 0x1CBA, if !stack[-1] // Incoming jump from 0x1CD5 // Inputs[3] // { // @1D07 stack[-6] // @1D07 stack[-7] // @1D0C memory[stack[-6]:stack[-6] + 0x20] // } 1D01 5B JUMPDEST 1D02 50 POP 1D03 50 POP 1D04 50 POP 1D05 50 POP 1D06 50 POP 1D07 90 SWAP1 1D08 50 POP 1D09 60 PUSH1 0x00 1D0B 81 DUP2 1D0C 51 MLOAD 1D0D 11 GT 1D0E 15 ISZERO 1D0F 61 PUSH2 0x1d18 1D12 57 *JUMPI // Stack delta = -6 // Outputs[1] { @1D07 stack[-7] = stack[-6] } // Block ends with conditional jump to 0x1d18, if !(memory[stack[-6]:stack[-6] + 0x20] > 0x00) label_1D13: // Incoming jump from 0x1D12, if not !(memory[stack[-6]:stack[-6] + 0x20] > 0x00) // Inputs[3] // { // @1D13 stack[-4] // @1D13 stack[-1] // @1D14 stack[-3] // } 1D13 92 SWAP3 1D14 91 SWAP2 1D15 50 POP 1D16 50 POP 1D17 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D13 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D18: // Incoming jump from 0x1D12, if !(memory[stack[-6]:stack[-6] + 0x20] > 0x00) // Inputs[1] { @1D1C stack[-3] } 1D18 5B JUMPDEST 1D19 61 PUSH2 0x1d21 1D1C 83 DUP4 1D1D 61 PUSH2 0x2861 1D20 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D19 stack[0] = 0x1d21 // @1D1C stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x2861 label_1D21: // Incoming return from call to 0x312C at 0x3189 // Incoming return from call to 0x3075 at 0x30A7 // Incoming return from call to 0x31E1 at 0x3276 // Incoming return from call to 0x30D4 at 0x3112 // Incoming return from call to 0x2D55 at 0x28A0 // Inputs[3] // { // @1D22 stack[-1] // @1D22 stack[-5] // @1D23 stack[-4] // } 1D21 5B JUMPDEST 1D22 93 SWAP4 1D23 92 SWAP3 1D24 50 POP 1D25 50 POP 1D26 50 POP 1D27 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D22 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1D28: // Incoming call from 0x079F, returns to 0x0341 // Inputs[1] { @1D2C storage[0x1b] } 1D28 5B JUMPDEST 1D29 60 PUSH1 0x1b 1D2B 80 DUP1 1D2C 54 SLOAD 1D2D 61 PUSH2 0x1340 1D30 90 SWAP1 1D31 61 PUSH2 0x3519 1D34 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D29 stack[0] = 0x1b // @1D30 stack[1] = 0x1340 // @1D30 stack[2] = storage[0x1b] // } // Block ends with call to 0x3519, returns to 0x1340 label_1D35: // Incoming jump from 0x07BF // Inputs[2] // { // @1D38 storage[0x09] // @1D42 msg.sender // } 1D35 5B JUMPDEST 1D36 60 PUSH1 0x09 1D38 54 SLOAD 1D39 60 PUSH1 0x01 1D3B 60 PUSH1 0x01 1D3D 60 PUSH1 0xa0 1D3F 1B SHL 1D40 03 SUB 1D41 16 AND 1D42 33 CALLER 1D43 14 EQ 1D44 61 PUSH2 0x1d8f 1D47 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d8f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_1D48: // Incoming jump from 0x1D47, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @1D4A memory[0x40:0x60] } 1D48 60 PUSH1 0x40 1D4A 51 MLOAD 1D4B 62 PUSH3 0x461bcd 1D4F 60 PUSH1 0xe5 1D51 1B SHL 1D52 81 DUP2 1D53 52 MSTORE 1D54 60 PUSH1 0x20 1D56 60 PUSH1 0x04 1D58 82 DUP3 1D59 01 ADD 1D5A 81 DUP2 1D5B 90 SWAP1 1D5C 52 MSTORE 1D5D 60 PUSH1 0x24 1D5F 82 DUP3 1D60 01 ADD 1D61 52 MSTORE 1D62 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1D83 60 PUSH1 0x44 1D85 82 DUP3 1D86 01 ADD 1D87 52 MSTORE 1D88 60 PUSH1 0x64 1D8A 01 ADD 1D8B 61 PUSH2 0x0a1a 1D8E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1D53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D5C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D61 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1D87 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1D8A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1D8F: // Incoming jump from 0x1D47, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[2] // { // @1D92 stack[-1] // @1D93 stack[-2] // } 1D8F 5B JUMPDEST 1D90 60 PUSH1 0x14 1D92 55 SSTORE 1D93 56 *JUMP // Stack delta = -2 // Outputs[1] { @1D92 storage[0x14] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1D94: // Incoming jump from 0x081B // Inputs[5] // { // @1D97 storage[0x15] // @1D98 msg.sender // @1DA6 memory[0x00:0x40] // @1DA7 storage[keccak256(memory[0x00:0x40])] // @1DAC stack[-1] // } 1D94 5B JUMPDEST 1D95 60 PUSH1 0x15 1D97 54 SLOAD 1D98 33 CALLER 1D99 60 PUSH1 0x00 1D9B 90 SWAP1 1D9C 81 DUP2 1D9D 52 MSTORE 1D9E 60 PUSH1 0x0d 1DA0 60 PUSH1 0x20 1DA2 52 MSTORE 1DA3 60 PUSH1 0x40 1DA5 90 SWAP1 1DA6 20 SHA3 1DA7 54 SLOAD 1DA8 61 PUSH2 0x1db2 1DAB 90 SWAP1 1DAC 83 DUP4 1DAD 90 SWAP1 1DAE 61 PUSH2 0x3585 1DB1 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1D97 stack[0] = storage[0x15] // @1D9D memory[0x00:0x20] = msg.sender // @1DA2 memory[0x20:0x40] = 0x0d // @1DAB stack[1] = 0x1db2 // @1DAD stack[2] = stack[-1] // @1DAD stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3585, returns to 0x1DB2 label_1DB2: // Incoming return from call to 0x3585 at 0x1DB1 // Inputs[2] // { // @1DB3 stack[-1] // @1DB3 stack[-2] // } 1DB2 5B JUMPDEST 1DB3 11 GT 1DB4 15 ISZERO 1DB5 61 PUSH2 0x1e00 1DB8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1e00, if !(stack[-1] > stack[-2]) label_1DB9: // Incoming jump from 0x1DB8, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1DBB memory[0x40:0x60] } 1DB9 60 PUSH1 0x40 1DBB 51 MLOAD 1DBC 62 PUSH3 0x461bcd 1DC0 60 PUSH1 0xe5 1DC2 1B SHL 1DC3 81 DUP2 1DC4 52 MSTORE 1DC5 60 PUSH1 0x20 1DC7 60 PUSH1 0x04 1DC9 82 DUP3 1DCA 01 ADD 1DCB 52 MSTORE 1DCC 60 PUSH1 0x1a 1DCE 60 PUSH1 0x24 1DD0 82 DUP3 1DD1 01 ADD 1DD2 52 MSTORE 1DD3 7F PUSH32 0x596f752063616e6e6f74206d696e742074686973206d616e792e000000000000 1DF4 60 PUSH1 0x44 1DF6 82 DUP3 1DF7 01 ADD 1DF8 52 MSTORE 1DF9 60 PUSH1 0x64 1DFB 01 ADD 1DFC 61 PUSH2 0x0a1a 1DFF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1DC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DCB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DD2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @1DF8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752063616e6e6f74206d696e742074686973206d616e792e000000000000 // @1DFB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1E00: // Incoming jump from 0x1DB8, if !(stack[-1] > stack[-2]) // Inputs[1] { @1E04 stack[-1] } 1E00 5B JUMPDEST 1E01 61 PUSH2 0x1e09 1E04 81 DUP2 1E05 61 PUSH2 0x23a8 1E08 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E01 stack[0] = 0x1e09 // @1E04 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x23a8 1E09 5B JUMPDEST 1E0A 33 CALLER 1E0B 60 PUSH1 0x00 1E0D 90 SWAP1 1E0E 81 DUP2 1E0F 52 MSTORE 1E10 60 PUSH1 0x0d 1E12 60 PUSH1 0x20 1E14 52 MSTORE 1E15 60 PUSH1 0x40 1E17 81 DUP2 1E18 20 SHA3 1E19 80 DUP1 1E1A 54 SLOAD 1E1B 83 DUP4 1E1C 92 SWAP3 1E1D 90 SWAP1 1E1E 61 PUSH2 0x1e28 1E21 90 SWAP1 1E22 84 DUP5 1E23 90 SWAP1 1E24 61 PUSH2 0x3585 1E27 56 *JUMP 1E28 5B JUMPDEST 1E29 90 SWAP1 1E2A 91 SWAP2 1E2B 55 SSTORE 1E2C 50 POP 1E2D 50 POP 1E2E 50 POP 1E2F 56 *JUMP label_1E30: // Incoming jump from 0x083B // Inputs[2] // { // @1E33 storage[0x09] // @1E3D msg.sender // } 1E30 5B JUMPDEST 1E31 60 PUSH1 0x09 1E33 54 SLOAD 1E34 60 PUSH1 0x01 1E36 60 PUSH1 0x01 1E38 60 PUSH1 0xa0 1E3A 1B SHL 1E3B 03 SUB 1E3C 16 AND 1E3D 33 CALLER 1E3E 14 EQ 1E3F 61 PUSH2 0x1e8a 1E42 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e8a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_1E43: // Incoming jump from 0x1E42, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @1E45 memory[0x40:0x60] } 1E43 60 PUSH1 0x40 1E45 51 MLOAD 1E46 62 PUSH3 0x461bcd 1E4A 60 PUSH1 0xe5 1E4C 1B SHL 1E4D 81 DUP2 1E4E 52 MSTORE 1E4F 60 PUSH1 0x20 1E51 60 PUSH1 0x04 1E53 82 DUP3 1E54 01 ADD 1E55 81 DUP2 1E56 90 SWAP1 1E57 52 MSTORE 1E58 60 PUSH1 0x24 1E5A 82 DUP3 1E5B 01 ADD 1E5C 52 MSTORE 1E5D 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1E7E 60 PUSH1 0x44 1E80 82 DUP3 1E81 01 ADD 1E82 52 MSTORE 1E83 60 PUSH1 0x64 1E85 01 ADD 1E86 61 PUSH2 0x0a1a 1E89 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1E4E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E57 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E5C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1E82 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1E85 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1E8A: // Incoming jump from 0x1E42, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @1E93 stack[-1] } 1E8A 5B JUMPDEST 1E8B 60 PUSH1 0x01 1E8D 60 PUSH1 0x01 1E8F 60 PUSH1 0xa0 1E91 1B SHL 1E92 03 SUB 1E93 81 DUP2 1E94 16 AND 1E95 61 PUSH2 0x1f06 1E98 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f06, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1E99: // Incoming jump from 0x1E98, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E9B memory[0x40:0x60] } 1E99 60 PUSH1 0x40 1E9B 51 MLOAD 1E9C 62 PUSH3 0x461bcd 1EA0 60 PUSH1 0xe5 1EA2 1B SHL 1EA3 81 DUP2 1EA4 52 MSTORE 1EA5 60 PUSH1 0x20 1EA7 60 PUSH1 0x04 1EA9 82 DUP3 1EAA 01 ADD 1EAB 52 MSTORE 1EAC 60 PUSH1 0x26 1EAE 60 PUSH1 0x24 1EB0 82 DUP3 1EB1 01 ADD 1EB2 52 MSTORE 1EB3 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1ED4 60 PUSH1 0x44 1ED6 82 DUP3 1ED7 01 ADD 1ED8 52 MSTORE 1ED9 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 1EFA 60 PUSH1 0x64 1EFC 82 DUP3 1EFD 01 ADD 1EFE 52 MSTORE 1EFF 60 PUSH1 0x84 1F01 01 ADD 1F02 61 PUSH2 0x0a1a 1F05 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1EA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1EAB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1EB2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1ED8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1EFE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1F01 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_1F06: // Incoming jump from 0x1E98, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1F0A stack[-1] } 1F06 5B JUMPDEST 1F07 61 PUSH2 0x1227 1F0A 81 DUP2 1F0B 61 PUSH2 0x262a 1F0E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F07 stack[0] = 0x1227 // @1F0A stack[1] = stack[-1] // } // Block ends with call to 0x262a, returns to 0x1227 label_1F0F: // Incoming call from 0x0B6C, returns to 0x0B6D // Incoming call from 0x2157, returns to 0x2158 // Inputs[8] // { // @1F12 stack[-2] // @1F1E memory[0x00:0x40] // @1F20 storage[keccak256(memory[0x00:0x40])] // @1F40 stack[-3] // @1F4A memory[0x40:0x60] // @1F4E stack[-1] // @1F73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1F77 stack[-4] // } 1F0F 5B JUMPDEST 1F10 60 PUSH1 0x00 1F12 82 DUP3 1F13 81 DUP2 1F14 52 MSTORE 1F15 60 PUSH1 0x05 1F17 60 PUSH1 0x20 1F19 52 MSTORE 1F1A 60 PUSH1 0x40 1F1C 80 DUP1 1F1D 82 DUP3 1F1E 20 SHA3 1F1F 80 DUP1 1F20 54 SLOAD 1F21 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F36 19 NOT 1F37 16 AND 1F38 60 PUSH1 0x01 1F3A 60 PUSH1 0x01 1F3C 60 PUSH1 0xa0 1F3E 1B SHL 1F3F 03 SUB 1F40 87 DUP8 1F41 81 DUP2 1F42 16 AND 1F43 91 SWAP2 1F44 82 DUP3 1F45 17 OR 1F46 90 SWAP1 1F47 92 SWAP3 1F48 55 SSTORE 1F49 91 SWAP2 1F4A 51 MLOAD 1F4B 85 DUP6 1F4C 93 SWAP4 1F4D 91 SWAP2 1F4E 85 DUP6 1F4F 16 AND 1F50 91 SWAP2 1F51 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1F72 91 SWAP2 1F73 A4 LOG4 1F74 50 POP 1F75 50 POP 1F76 50 POP 1F77 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1F14 memory[0x00:0x20] = stack[-2] // @1F19 memory[0x20:0x40] = 0x05 // @1F48 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1F73 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_1F78: // Incoming jump from 0x1B84 // Incoming jump from 0x0BF7 // Inputs[1] { @1F7E stack[-1] } 1F78 5B JUMPDEST 1F79 60 PUSH1 0x00 1F7B 61 PUSH2 0x1f83 1F7E 82 DUP3 1F7F 61 PUSH2 0x245f 1F82 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F79 stack[0] = 0x00 // @1F7B stack[1] = 0x1f83 // @1F7E stack[2] = stack[-1] // } // Block ends with call to 0x245f, returns to 0x1F83 label_1F83: // Incoming return from call to 0x245F at 0x1F82 // Inputs[4] // { // @1F84 stack[-1] // @1F85 memory[stack[-1]:stack[-1] + 0x20] // @1F87 stack[-2] // @1F95 msg.sender // } 1F83 5B JUMPDEST 1F84 80 DUP1 1F85 51 MLOAD 1F86 90 SWAP1 1F87 91 SWAP2 1F88 50 POP 1F89 60 PUSH1 0x00 1F8B 90 SWAP1 1F8C 60 PUSH1 0x01 1F8E 60 PUSH1 0x01 1F90 60 PUSH1 0xa0 1F92 1B SHL 1F93 03 SUB 1F94 16 AND 1F95 33 CALLER 1F96 60 PUSH1 0x01 1F98 60 PUSH1 0x01 1F9A 60 PUSH1 0xa0 1F9C 1B SHL 1F9D 03 SUB 1F9E 16 AND 1F9F 14 EQ 1FA0 80 DUP1 1FA1 61 PUSH2 0x1fba 1FA4 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1F87 stack[-2] = stack[-1] // @1F8B stack[-1] = 0x00 // @1F9F stack[0] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x1fba, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] label_1FA5: // Incoming jump from 0x1FA4, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @1FA6 msg.sender // @1FAA stack[-4] // } 1FA5 50 POP 1FA6 33 CALLER 1FA7 61 PUSH2 0x1faf 1FAA 84 DUP5 1FAB 61 PUSH2 0x099f 1FAE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FA6 stack[-1] = msg.sender // @1FA7 stack[0] = 0x1faf // @1FAA stack[1] = stack[-4] // } // Block ends with call to 0x099f, returns to 0x1FAF label_1FAF: // Incoming return from call to 0x099F at 0x1FAE // Inputs[2] // { // @1FB8 stack[-1] // @1FB9 stack[-2] // } 1FAF 5B JUMPDEST 1FB0 60 PUSH1 0x01 1FB2 60 PUSH1 0x01 1FB4 60 PUSH1 0xa0 1FB6 1B SHL 1FB7 03 SUB 1FB8 16 AND 1FB9 14 EQ // Stack delta = -1 // Outputs[1] { @1FB9 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1FBA: // Incoming jump from 0x1FA4, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x1FB9 // Inputs[1] { @1FBB stack[-1] } 1FBA 5B JUMPDEST 1FBB 80 DUP1 1FBC 61 PUSH2 0x1fcc 1FBF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1fcc, if stack[-1] label_1FC0: // Incoming jump from 0x1FBF, if not stack[-1] // Inputs[3] // { // @1FC1 stack[-3] // @1FC2 memory[stack[-3]:stack[-3] + 0x20] // @1FC7 msg.sender // } 1FC0 50 POP 1FC1 81 DUP2 1FC2 51 MLOAD 1FC3 61 PUSH2 0x1fcc 1FC6 90 SWAP1 1FC7 33 CALLER 1FC8 61 PUSH2 0x07db 1FCB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FC6 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @1FC6 stack[-1] = 0x1fcc // @1FC7 stack[1] = msg.sender // } // Block ends with call to 0x07db, returns to 0x1FCC label_1FCC: // Incoming jump from 0x1FBF, if stack[-1] // Incoming return from call to 0x07DB at 0x1FCB // Inputs[2] // { // @1FCD stack[-2] // @1FCD stack[-1] // } 1FCC 5B JUMPDEST 1FCD 90 SWAP1 1FCE 50 POP 1FCF 80 DUP1 1FD0 61 PUSH2 0x2041 1FD3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1FCD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2041, if stack[-1] label_1FD4: // Incoming jump from 0x1FD3, if not stack[-1] // Inputs[1] { @1FD6 memory[0x40:0x60] } 1FD4 60 PUSH1 0x40 1FD6 51 MLOAD 1FD7 62 PUSH3 0x461bcd 1FDB 60 PUSH1 0xe5 1FDD 1B SHL 1FDE 81 DUP2 1FDF 52 MSTORE 1FE0 60 PUSH1 0x20 1FE2 60 PUSH1 0x04 1FE4 82 DUP3 1FE5 01 ADD 1FE6 52 MSTORE 1FE7 60 PUSH1 0x32 1FE9 60 PUSH1 0x24 1FEB 82 DUP3 1FEC 01 ADD 1FED 52 MSTORE 1FEE 7F PUSH32 0x455243373231413a207472616e736665722063616c6c6572206973206e6f7420 200F 60 PUSH1 0x44 2011 82 DUP3 2012 01 ADD 2013 52 MSTORE 2014 7F PUSH32 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 2035 60 PUSH1 0x64 2037 82 DUP3 2038 01 ADD 2039 52 MSTORE 203A 60 PUSH1 0x84 203C 01 ADD 203D 61 PUSH2 0x0a1a 2040 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1FDF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1FE6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1FED memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x32 // @2013 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e736665722063616c6c6572206973206e6f7420 // @2039 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 // @203C stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2041: // Incoming jump from 0x1FD3, if stack[-1] // Inputs[3] // { // @2042 stack[-5] // @204C stack[-2] // @2050 memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 2041 5B JUMPDEST 2042 84 DUP5 2043 60 PUSH1 0x01 2045 60 PUSH1 0x01 2047 60 PUSH1 0xa0 2049 1B SHL 204A 03 SUB 204B 16 AND 204C 82 DUP3 204D 60 PUSH1 0x00 204F 01 ADD 2050 51 MLOAD 2051 60 PUSH1 0x01 2053 60 PUSH1 0x01 2055 60 PUSH1 0xa0 2057 1B SHL 2058 03 SUB 2059 16 AND 205A 14 EQ 205B 61 PUSH2 0x20cc 205E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20cc, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_205F: // Incoming jump from 0x205E, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @2061 memory[0x40:0x60] } 205F 60 PUSH1 0x40 2061 51 MLOAD 2062 62 PUSH3 0x461bcd 2066 60 PUSH1 0xe5 2068 1B SHL 2069 81 DUP2 206A 52 MSTORE 206B 60 PUSH1 0x20 206D 60 PUSH1 0x04 206F 82 DUP3 2070 01 ADD 2071 52 MSTORE 2072 60 PUSH1 0x26 2074 60 PUSH1 0x24 2076 82 DUP3 2077 01 ADD 2078 52 MSTORE 2079 7F PUSH32 0x455243373231413a207472616e736665722066726f6d20696e636f7272656374 209A 60 PUSH1 0x44 209C 82 DUP3 209D 01 ADD 209E 52 MSTORE 209F 7F PUSH32 0x206f776e65720000000000000000000000000000000000000000000000000000 20C0 60 PUSH1 0x64 20C2 82 DUP3 20C3 01 ADD 20C4 52 MSTORE 20C5 60 PUSH1 0x84 20C7 01 ADD 20C8 61 PUSH2 0x0a1a 20CB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @206A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2071 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2078 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @209E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e736665722066726f6d20696e636f7272656374 // @20C4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x206f776e65720000000000000000000000000000000000000000000000000000 // @20C7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_20CC: // Incoming jump from 0x205E, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @20D5 stack[-4] } 20CC 5B JUMPDEST 20CD 60 PUSH1 0x01 20CF 60 PUSH1 0x01 20D1 60 PUSH1 0xa0 20D3 1B SHL 20D4 03 SUB 20D5 84 DUP5 20D6 16 AND 20D7 61 PUSH2 0x2148 20DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2148, if stack[-4] & (0x01 << 0xa0) - 0x01 label_20DB: // Incoming jump from 0x20DA, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @20DD memory[0x40:0x60] } 20DB 60 PUSH1 0x40 20DD 51 MLOAD 20DE 62 PUSH3 0x461bcd 20E2 60 PUSH1 0xe5 20E4 1B SHL 20E5 81 DUP2 20E6 52 MSTORE 20E7 60 PUSH1 0x20 20E9 60 PUSH1 0x04 20EB 82 DUP3 20EC 01 ADD 20ED 52 MSTORE 20EE 60 PUSH1 0x25 20F0 60 PUSH1 0x24 20F2 82 DUP3 20F3 01 ADD 20F4 52 MSTORE 20F5 7F PUSH32 0x455243373231413a207472616e7366657220746f20746865207a65726f206164 2116 60 PUSH1 0x44 2118 82 DUP3 2119 01 ADD 211A 52 MSTORE 211B 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 213C 60 PUSH1 0x64 213E 82 DUP3 213F 01 ADD 2140 52 MSTORE 2141 60 PUSH1 0x84 2143 01 ADD 2144 61 PUSH2 0x0a1a 2147 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @20E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20ED memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @20F4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @211A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e7366657220746f20746865207a65726f206164 // @2140 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373000000000000000000000000000000000000000000000000000000 // @2143 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2148: // Incoming jump from 0x20DA, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @214E stack[-3] // @214F stack[-2] // @2153 memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 2148 5B JUMPDEST 2149 61 PUSH2 0x2158 214C 60 PUSH1 0x00 214E 84 DUP5 214F 84 DUP5 2150 60 PUSH1 0x00 2152 01 ADD 2153 51 MLOAD 2154 61 PUSH2 0x1f0f 2157 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2149 stack[0] = 0x2158 // @214C stack[1] = 0x00 // @214E stack[2] = stack[-3] // @2153 stack[3] = memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } // Block ends with call to 0x1f0f, returns to 0x2158 label_2158: // Incoming return from call to 0x1F0F at 0x2157 // Inputs[3] // { // @2161 stack[-5] // @2170 memory[0x00:0x40] // @2172 storage[keccak256(memory[0x00:0x40])] // } 2158 5B JUMPDEST 2159 60 PUSH1 0x01 215B 60 PUSH1 0x01 215D 60 PUSH1 0xa0 215F 1B SHL 2160 03 SUB 2161 85 DUP6 2162 16 AND 2163 60 PUSH1 0x00 2165 90 SWAP1 2166 81 DUP2 2167 52 MSTORE 2168 60 PUSH1 0x04 216A 60 PUSH1 0x20 216C 52 MSTORE 216D 60 PUSH1 0x40 216F 81 DUP2 2170 20 SHA3 2171 80 DUP1 2172 54 SLOAD 2173 60 PUSH1 0x01 2175 92 SWAP3 2176 90 SWAP1 2177 61 PUSH2 0x218a 217A 90 SWAP1 217B 84 DUP5 217C 90 SWAP1 217D 60 PUSH1 0x01 217F 60 PUSH1 0x01 2181 60 PUSH1 0x80 2183 1B SHL 2184 03 SUB 2185 16 AND 2186 61 PUSH2 0x35db 2189 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @2167 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @216C memory[0x20:0x40] = 0x04 // @2170 stack[1] = keccak256(memory[0x00:0x40]) // @2175 stack[0] = 0x01 // @2176 stack[2] = 0x00 // @217A stack[3] = 0x218a // @217C stack[4] = 0x01 // @2185 stack[5] = (0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x35db, returns to 0x218A label_218A: // Incoming return from call to 0x35DB at 0x2189 // Inputs[8] // { // @218B stack[-3] // @218C storage[stack[-3]] // @2190 stack[-2] // @21A3 stack[-1] // @21B3 stack[-8] // @21C2 memory[0x00:0x40] // @21C4 storage[keccak256(memory[0x00:0x40])] // @21C7 stack[-4] // } 218A 5B JUMPDEST 218B 82 DUP3 218C 54 SLOAD 218D 61 PUSH2 0x0100 2190 92 SWAP3 2191 90 SWAP1 2192 92 SWAP3 2193 0A EXP 2194 60 PUSH1 0x01 2196 60 PUSH1 0x01 2198 60 PUSH1 0x80 219A 1B SHL 219B 03 SUB 219C 81 DUP2 219D 81 DUP2 219E 02 MUL 219F 19 NOT 21A0 90 SWAP1 21A1 93 SWAP4 21A2 16 AND 21A3 91 SWAP2 21A4 83 DUP4 21A5 16 AND 21A6 02 MUL 21A7 17 OR 21A8 90 SWAP1 21A9 91 SWAP2 21AA 55 SSTORE 21AB 60 PUSH1 0x01 21AD 60 PUSH1 0x01 21AF 60 PUSH1 0xa0 21B1 1B SHL 21B2 03 SUB 21B3 86 DUP7 21B4 16 AND 21B5 60 PUSH1 0x00 21B7 90 SWAP1 21B8 81 DUP2 21B9 52 MSTORE 21BA 60 PUSH1 0x04 21BC 60 PUSH1 0x20 21BE 52 MSTORE 21BF 60 PUSH1 0x40 21C1 81 DUP2 21C2 20 SHA3 21C3 80 DUP1 21C4 54 SLOAD 21C5 60 PUSH1 0x01 21C7 94 SWAP5 21C8 50 POP 21C9 90 SWAP1 21CA 92 SWAP3 21CB 61 PUSH2 0x21d6 21CE 91 SWAP2 21CF 85 DUP6 21D0 91 SWAP2 21D1 16 AND 21D2 61 PUSH2 0x3603 21D5 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @21AA storage[stack[-3]] = ((0x01 << 0x80) - 0x01 & stack[-1]) * 0x0100 ** stack[-2] | (storage[stack[-3]] & ~((0x01 << 0x80) - 0x01 * 0x0100 ** stack[-2])) // @21B7 stack[-2] = 0x00 // @21B9 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @21BE memory[0x20:0x40] = 0x04 // @21C7 stack[-4] = 0x01 // @21CA stack[-3] = keccak256(memory[0x00:0x40]) // @21CE stack[-1] = 0x21d6 // @21D0 stack[0] = 0x01 // @21D1 stack[1] = (0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3603, returns to 0x21D6 label_21D6: // Incoming return from call to 0x3603 at 0x21D5 // Inputs[12] // { // @21D7 stack[-3] // @21D8 storage[stack[-3]] // @21E1 stack[-1] // @21E7 stack[-2] // @21FD memory[0x40:0x60] // @220C stack[-8] // @2219 block.timestamp // @2226 stack[-7] // @2230 memory[0x00:0x40] // @2232 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2234 storage[keccak256(memory[0x00:0x40])] // @2236 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // } 21D6 5B JUMPDEST 21D7 82 DUP3 21D8 54 SLOAD 21D9 60 PUSH1 0x01 21DB 60 PUSH1 0x01 21DD 60 PUSH1 0x80 21DF 1B SHL 21E0 03 SUB 21E1 91 SWAP2 21E2 82 DUP3 21E3 16 AND 21E4 61 PUSH2 0x0100 21E7 93 SWAP4 21E8 90 SWAP1 21E9 93 SWAP4 21EA 0A EXP 21EB 92 SWAP3 21EC 83 DUP4 21ED 02 MUL 21EE 91 SWAP2 21EF 90 SWAP1 21F0 92 SWAP3 21F1 02 MUL 21F2 19 NOT 21F3 90 SWAP1 21F4 91 SWAP2 21F5 16 AND 21F6 17 OR 21F7 90 SWAP1 21F8 55 SSTORE 21F9 50 POP 21FA 60 PUSH1 0x40 21FC 80 DUP1 21FD 51 MLOAD 21FE 80 DUP1 21FF 82 DUP3 2200 01 ADD 2201 82 DUP3 2202 52 MSTORE 2203 60 PUSH1 0x01 2205 60 PUSH1 0x01 2207 60 PUSH1 0xa0 2209 1B SHL 220A 03 SUB 220B 80 DUP1 220C 87 DUP8 220D 16 AND 220E 82 DUP3 220F 52 MSTORE 2210 67 PUSH8 0xffffffffffffffff 2219 42 TIMESTAMP 221A 81 DUP2 221B 16 AND 221C 60 PUSH1 0x20 221E 80 DUP1 221F 85 DUP6 2220 01 ADD 2221 91 SWAP2 2222 82 DUP3 2223 52 MSTORE 2224 60 PUSH1 0x00 2226 89 DUP10 2227 81 DUP2 2228 52 MSTORE 2229 60 PUSH1 0x03 222B 90 SWAP1 222C 91 SWAP2 222D 52 MSTORE 222E 94 SWAP5 222F 85 DUP6 2230 20 SHA3 2231 93 SWAP4 2232 51 MLOAD 2233 84 DUP5 2234 54 SLOAD 2235 91 SWAP2 2236 51 MLOAD 2237 90 SWAP1 2238 92 SWAP3 2239 16 AND 223A 60 PUSH1 0x01 223C 60 PUSH1 0xa0 223E 1B SHL 223F 02 MUL 2240 60 PUSH1 0x01 2242 60 PUSH1 0x01 2244 60 PUSH1 0xe0 2246 1B SHL 2247 03 SUB 2248 19 NOT 2249 90 SWAP1 224A 91 SWAP2 224B 16 AND 224C 91 SWAP2 224D 90 SWAP1 224E 92 SWAP3 224F 16 AND 2250 17 OR 2251 17 OR 2252 90 SWAP1 2253 55 SSTORE 2254 61 PUSH2 0x225e 2257 84 DUP5 2258 60 PUSH1 0x01 225A 61 PUSH2 0x3585 225D 56 *JUMP // Stack delta = +0 // Outputs[11] // { // @21F8 storage[stack[-3]] = (storage[stack[-3]] & ~(0x0100 ** stack[-2] * ((0x01 << 0x80) - 0x01))) | 0x0100 ** stack[-2] * ((0x01 << 0x80) - 0x01 & stack[-1]) // @2202 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @220F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @2223 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & block.timestamp // @2228 memory[0x00:0x20] = stack[-7] // @222D memory[0x20:0x40] = 0x03 // @222E stack[-4] = 0x00 // @2253 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @2254 stack[-3] = 0x225e // @2257 stack[-2] = stack[-7] // @2258 stack[-1] = 0x01 // } // Block ends with call to 0x3585, returns to 0x225E label_225E: // Incoming return from call to 0x3585 at 0x225D // Inputs[4] // { // @2261 stack[-1] // @226C memory[0x00:0x40] // @226D storage[keccak256(memory[0x00:0x40])] // @226F stack[-2] // } 225E 5B JUMPDEST 225F 60 PUSH1 0x00 2261 81 DUP2 2262 81 DUP2 2263 52 MSTORE 2264 60 PUSH1 0x03 2266 60 PUSH1 0x20 2268 52 MSTORE 2269 60 PUSH1 0x40 226B 90 SWAP1 226C 20 SHA3 226D 54 SLOAD 226E 90 SWAP1 226F 91 SWAP2 2270 50 POP 2271 60 PUSH1 0x01 2273 60 PUSH1 0x01 2275 60 PUSH1 0xa0 2277 1B SHL 2278 03 SUB 2279 16 AND 227A 61 PUSH2 0x22f0 227D 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @2263 memory[0x00:0x20] = stack[-1] // @2268 memory[0x20:0x40] = 0x03 // @226F stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x22f0, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_227E: // Incoming jump from 0x227D, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @2281 stack[-1] // @2284 storage[0x00] // } 227E 61 PUSH2 0x2288 2281 81 DUP2 2282 60 PUSH1 0x00 2284 54 SLOAD 2285 11 GT 2286 90 SWAP1 2287 56 *JUMP // Stack delta = +1 // Outputs[1] { @2286 stack[0] = storage[0x00] > stack[-1] } // Block ends with unconditional jump to 0x2288 label_2288: // Incoming jump from 0x2287 // Inputs[1] { @2289 stack[-1] } 2288 5B JUMPDEST 2289 15 ISZERO 228A 61 PUSH2 0x22f0 228D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x22f0, if !stack[-1] label_228E: // Incoming jump from 0x228D, if not !stack[-1] // Inputs[9] // { // @2291 memory[0x40:0x60] // @2297 stack[-3] // @2298 memory[stack[-3]:stack[-3] + 0x20] // @22AB memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @22C0 stack[-1] // @22CB memory[0x00:0x40] // @22CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @22CF storage[keccak256(memory[0x00:0x40])] // @22D1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // } 228E 60 PUSH1 0x40 2290 80 DUP1 2291 51 MLOAD 2292 80 DUP1 2293 82 DUP3 2294 01 ADD 2295 82 DUP3 2296 52 MSTORE 2297 84 DUP5 2298 51 MLOAD 2299 60 PUSH1 0x01 229B 60 PUSH1 0x01 229D 60 PUSH1 0xa0 229F 1B SHL 22A0 03 SUB 22A1 90 SWAP1 22A2 81 DUP2 22A3 16 AND 22A4 82 DUP3 22A5 52 MSTORE 22A6 60 PUSH1 0x20 22A8 80 DUP1 22A9 87 DUP8 22AA 01 ADD 22AB 51 MLOAD 22AC 67 PUSH8 0xffffffffffffffff 22B5 90 SWAP1 22B6 81 DUP2 22B7 16 AND 22B8 82 DUP3 22B9 85 DUP6 22BA 01 ADD 22BB 90 SWAP1 22BC 81 DUP2 22BD 52 MSTORE 22BE 60 PUSH1 0x00 22C0 87 DUP8 22C1 81 DUP2 22C2 52 MSTORE 22C3 60 PUSH1 0x03 22C5 90 SWAP1 22C6 93 SWAP4 22C7 52 MSTORE 22C8 94 SWAP5 22C9 90 SWAP1 22CA 91 SWAP2 22CB 20 SHA3 22CC 92 SWAP3 22CD 51 MLOAD 22CE 83 DUP4 22CF 54 SLOAD 22D0 94 SWAP5 22D1 51 MLOAD 22D2 90 SWAP1 22D3 91 SWAP2 22D4 16 AND 22D5 60 PUSH1 0x01 22D7 60 PUSH1 0xa0 22D9 1B SHL 22DA 02 MUL 22DB 60 PUSH1 0x01 22DD 60 PUSH1 0x01 22DF 60 PUSH1 0xe0 22E1 1B SHL 22E2 03 SUB 22E3 19 NOT 22E4 90 SWAP1 22E5 94 SWAP5 22E6 16 AND 22E7 91 SWAP2 22E8 16 AND 22E9 17 OR 22EA 91 SWAP2 22EB 90 SWAP1 22EC 91 SWAP2 22ED 17 OR 22EE 90 SWAP1 22EF 55 SSTORE // Stack delta = +0 // Outputs[6] // { // @2296 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @22A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-3]:stack[-3] + 0x20] // @22BD memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @22C2 memory[0x00:0x20] = stack[-1] // @22C7 memory[0x20:0x40] = 0x03 // @22EF storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // } // Block continues label_22F0: // Incoming jump from 0x227D, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x22EF // Incoming jump from 0x228D, if !stack[-1] // Inputs[6] // { // @22F1 stack[-4] // @22F2 stack[-5] // @22FC stack[-6] // @2329 memory[0x40:0x60] // @232C memory[0x40:0x60] // @2331 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 22F0 5B JUMPDEST 22F1 83 DUP4 22F2 85 DUP6 22F3 60 PUSH1 0x01 22F5 60 PUSH1 0x01 22F7 60 PUSH1 0xa0 22F9 1B SHL 22FA 03 SUB 22FB 16 AND 22FC 87 DUP8 22FD 60 PUSH1 0x01 22FF 60 PUSH1 0x01 2301 60 PUSH1 0xa0 2303 1B SHL 2304 03 SUB 2305 16 AND 2306 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2327 60 PUSH1 0x40 2329 51 MLOAD 232A 60 PUSH1 0x40 232C 51 MLOAD 232D 80 DUP1 232E 91 SWAP2 232F 03 SUB 2330 90 SWAP1 2331 A4 LOG4 // Stack delta = +0 // Outputs[1] { @2331 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block continues label_2332: // Incoming jump from 0x2331 // Incoming jump from 0x2C22 // Inputs[1] { @2339 stack[-7] } 2332 5B JUMPDEST 2333 50 POP 2334 50 POP 2335 50 POP 2336 50 POP 2337 50 POP 2338 50 POP 2339 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_233A: // Incoming jump from 0x195D // Incoming jump from 0x178F // Incoming jump from 0x0F36 // Inputs[1] { @2342 storage[0x09] } 233A 5B JUMPDEST 233B 60 PUSH1 0x00 233D 61 PUSH2 0x234e 2340 60 PUSH1 0x09 2342 54 SLOAD 2343 60 PUSH1 0x01 2345 60 PUSH1 0x01 2347 60 PUSH1 0xa0 2349 1B SHL 234A 03 SUB 234B 16 AND 234C 90 SWAP1 234D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @233B stack[0] = 0x00 // @234C stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x09] // } // Block ends with unconditional jump to 0x234e label_234E: // Incoming jump from 0x234D // Inputs[3] // { // @2357 stack[-1] // @235B stack[-4] // @235C stack[-3] // } 234E 5B JUMPDEST 234F 60 PUSH1 0x01 2351 60 PUSH1 0x01 2353 60 PUSH1 0xa0 2355 1B SHL 2356 03 SUB 2357 16 AND 2358 61 PUSH2 0x2361 235B 84 DUP5 235C 84 DUP5 235D 61 PUSH2 0x2895 2360 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2357 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2358 stack[0] = 0x2361 // @235B stack[1] = stack[-4] // @235C stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x2895 2361 5B JUMPDEST 2362 60 PUSH1 0x01 2364 60 PUSH1 0x01 2366 60 PUSH1 0xa0 2368 1B SHL 2369 03 SUB 236A 16 AND 236B 14 EQ 236C 93 SWAP4 236D 92 SWAP3 236E 50 POP 236F 50 POP 2370 50 POP 2371 56 *JUMP 2372 5B JUMPDEST 2373 60 PUSH1 0x00 2375 83 DUP4 2376 83 DUP4 2377 83 DUP4 2378 60 PUSH1 0x40 237A 51 MLOAD 237B 60 PUSH1 0x20 237D 01 ADD 237E 61 PUSH2 0x2389 2381 93 SWAP4 2382 92 SWAP3 2383 91 SWAP2 2384 90 SWAP1 2385 61 PUSH2 0x362e 2388 56 *JUMP 2389 5B JUMPDEST 238A 60 PUSH1 0x40 238C 51 MLOAD 238D 60 PUSH1 0x20 238F 81 DUP2 2390 83 DUP4 2391 03 SUB 2392 03 SUB 2393 81 DUP2 2394 52 MSTORE 2395 90 SWAP1 2396 60 PUSH1 0x40 2398 52 MSTORE 2399 80 DUP1 239A 51 MLOAD 239B 90 SWAP1 239C 60 PUSH1 0x20 239E 01 ADD 239F 20 SHA3 23A0 90 SWAP1 23A1 50 POP 23A2 93 SWAP4 23A3 92 SWAP3 23A4 50 POP 23A5 50 POP 23A6 50 POP 23A7 56 *JUMP label_23A8: // Incoming jump from 0x1E08 // Inputs[3] // { // @23A9 msg.value // @23AC storage[0x13] // @23AD stack[-1] // } 23A8 5B JUMPDEST 23A9 34 CALLVALUE 23AA 60 PUSH1 0x13 23AC 54 SLOAD 23AD 82 DUP3 23AE 61 PUSH2 0x23b7 23B1 91 SWAP2 23B2 90 SWAP1 23B3 61 PUSH2 0x366d 23B6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23A9 stack[0] = msg.value // @23B1 stack[1] = 0x23b7 // @23B2 stack[2] = storage[0x13] // @23B2 stack[3] = stack[-1] // } // Block ends with call to 0x366d, returns to 0x23B7 label_23B7: // Incoming return from call to 0x366D at 0x23B6 // Inputs[2] // { // @23B8 stack[-1] // @23B8 stack[-2] // } 23B7 5B JUMPDEST 23B8 14 EQ 23B9 61 PUSH2 0x2404 23BC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2404, if stack[-1] == stack[-2] label_23BD: // Incoming jump from 0x23BC, if not stack[-1] == stack[-2] // Inputs[1] { @23BF memory[0x40:0x60] } 23BD 60 PUSH1 0x40 23BF 51 MLOAD 23C0 62 PUSH3 0x461bcd 23C4 60 PUSH1 0xe5 23C6 1B SHL 23C7 81 DUP2 23C8 52 MSTORE 23C9 60 PUSH1 0x20 23CB 60 PUSH1 0x04 23CD 82 DUP3 23CE 01 ADD 23CF 52 MSTORE 23D0 60 PUSH1 0x0f 23D2 60 PUSH1 0x24 23D4 82 DUP3 23D5 01 ADD 23D6 52 MSTORE 23D7 7F PUSH32 0x496e76616c696420616d6f756e742e0000000000000000000000000000000000 23F8 60 PUSH1 0x44 23FA 82 DUP3 23FB 01 ADD 23FC 52 MSTORE 23FD 60 PUSH1 0x64 23FF 01 ADD 2400 61 PUSH2 0x0a1a 2403 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @23C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @23CF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @23D6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @23FC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e76616c696420616d6f756e742e0000000000000000000000000000000000 // @23FF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2404: // Incoming jump from 0x23BC, if stack[-1] == stack[-2] // Inputs[3] // { // @2407 storage[0x10] // @2408 stack[-1] // @240E storage[0x00] // } 2404 5B JUMPDEST 2405 60 PUSH1 0x10 2407 54 SLOAD 2408 81 DUP2 2409 61 PUSH2 0x2411 240C 60 PUSH1 0x00 240E 54 SLOAD 240F 90 SWAP1 2410 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2407 stack[0] = storage[0x10] // @2408 stack[1] = stack[-1] // @240F stack[2] = storage[0x00] // } // Block ends with unconditional jump to 0x2411 label_2411: // Incoming jump from 0x2410 // Inputs[2] // { // @2415 stack[-2] // @2416 stack[-1] // } 2411 5B JUMPDEST 2412 61 PUSH2 0x241b 2415 91 SWAP2 2416 90 SWAP1 2417 61 PUSH2 0x3585 241A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2415 stack[-2] = 0x241b // @2416 stack[-1] = stack[-2] // @2416 stack[0] = stack[-1] // } // Block ends with call to 0x3585, returns to 0x241B label_241B: // Incoming return from call to 0x3585 at 0x241A // Inputs[2] // { // @241C stack[-1] // @241C stack[-2] // } 241B 5B JUMPDEST 241C 11 GT 241D 15 ISZERO 241E 61 PUSH2 0x2455 2421 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2455, if !(stack[-1] > stack[-2]) label_2422: // Incoming jump from 0x2421, if not !(stack[-1] > stack[-2]) // Inputs[1] { @2424 memory[0x40:0x60] } 2422 60 PUSH1 0x40 2424 51 MLOAD 2425 62 PUSH3 0x461bcd 2429 60 PUSH1 0xe5 242B 1B SHL 242C 81 DUP2 242D 52 MSTORE 242E 60 PUSH1 0x20 2430 60 PUSH1 0x04 2432 82 DUP3 2433 01 ADD 2434 52 MSTORE 2435 60 PUSH1 0x09 2437 60 PUSH1 0x24 2439 82 DUP3 243A 01 ADD 243B 52 MSTORE 243C 68 PUSH9 0x29b7b6321037baba17 2446 60 PUSH1 0xb9 2448 1B SHL 2449 60 PUSH1 0x44 244B 82 DUP3 244C 01 ADD 244D 52 MSTORE 244E 60 PUSH1 0x64 2450 01 ADD 2451 61 PUSH2 0x0a1a 2454 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @242D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2434 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @243B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @244D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x29b7b6321037baba17 << 0xb9 // @2450 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2455: // Incoming jump from 0x2421, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @2459 msg.sender // @245A stack[-1] // } 2455 5B JUMPDEST 2456 61 PUSH2 0x1227 2459 33 CALLER 245A 82 DUP3 245B 61 PUSH2 0x2689 245E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2456 stack[0] = 0x1227 // @2459 stack[1] = msg.sender // @245A stack[2] = stack[-1] // } // Block ends with call to 0x2689, returns to 0x1227 label_245F: // Incoming call from 0x1165, returns to 0x1166 // Incoming call from 0x1F82, returns to 0x1F83 // Inputs[3] // { // @2463 memory[0x40:0x60] // @2477 stack[-1] // @247A storage[0x00] // } 245F 5B JUMPDEST 2460 60 PUSH1 0x40 2462 80 DUP1 2463 51 MLOAD 2464 80 DUP1 2465 82 DUP3 2466 01 ADD 2467 90 SWAP1 2468 91 SWAP2 2469 52 MSTORE 246A 60 PUSH1 0x00 246C 80 DUP1 246D 82 DUP3 246E 52 MSTORE 246F 60 PUSH1 0x20 2471 82 DUP3 2472 01 ADD 2473 52 MSTORE 2474 61 PUSH2 0x247e 2477 82 DUP3 2478 60 PUSH1 0x00 247A 54 SLOAD 247B 11 GT 247C 90 SWAP1 247D 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2468 stack[0] = memory[0x40:0x60] // @2469 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @246E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2473 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @247C stack[1] = storage[0x00] > stack[-1] // } // Block ends with unconditional jump to 0x247e label_247E: // Incoming jump from 0x247D // Inputs[1] { @2482 stack[-1] } 247E 5B JUMPDEST 247F 61 PUSH2 0x24f0 2482 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x24f0, if stack[-1] label_2483: // Incoming jump from 0x2482, if not stack[-1] // Inputs[1] { @2485 memory[0x40:0x60] } 2483 60 PUSH1 0x40 2485 51 MLOAD 2486 62 PUSH3 0x461bcd 248A 60 PUSH1 0xe5 248C 1B SHL 248D 81 DUP2 248E 52 MSTORE 248F 60 PUSH1 0x20 2491 60 PUSH1 0x04 2493 82 DUP3 2494 01 ADD 2495 52 MSTORE 2496 60 PUSH1 0x2a 2498 60 PUSH1 0x24 249A 82 DUP3 249B 01 ADD 249C 52 MSTORE 249D 7F PUSH32 0x455243373231413a206f776e657220717565727920666f72206e6f6e65786973 24BE 60 PUSH1 0x44 24C0 82 DUP3 24C1 01 ADD 24C2 52 MSTORE 24C3 7F PUSH32 0x74656e7420746f6b656e00000000000000000000000000000000000000000000 24E4 60 PUSH1 0x64 24E6 82 DUP3 24E7 01 ADD 24E8 52 MSTORE 24E9 60 PUSH1 0x84 24EB 01 ADD 24EC 61 PUSH2 0x0a1a 24EF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @248E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2495 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @249C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @24C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a206f776e657220717565727920666f72206e6f6e65786973 // @24E8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x74656e7420746f6b656e00000000000000000000000000000000000000000000 // @24EB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_24F0: // Incoming jump from 0x2482, if stack[-1] // Inputs[1] { @2514 stack[-2] } 24F0 5B JUMPDEST 24F1 60 PUSH1 0x00 24F3 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 2514 83 DUP4 2515 10 LT 2516 61 PUSH2 0x2551 2519 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24F1 stack[0] = 0x00 } // Block ends with conditional jump to 0x2551, if stack[-2] < 0x0000000000000000000000000000000000000000000000000000000000000004 label_251A: // Incoming jump from 0x2519, if not stack[-2] < 0x0000000000000000000000000000000000000000000000000000000000000004 // Inputs[1] { @253E stack[-3] } 251A 61 PUSH2 0x2543 251D 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 253E 84 DUP5 253F 61 PUSH2 0x368c 2542 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @251A stack[0] = 0x2543 // @251D stack[1] = 0x0000000000000000000000000000000000000000000000000000000000000004 // @253E stack[2] = stack[-3] // } // Block ends with call to 0x368c, returns to 0x2543 label_2543: // Incoming return from call to 0x368C at 0x2542 // Inputs[1] { @2547 stack[-1] } 2543 5B JUMPDEST 2544 61 PUSH2 0x254e 2547 90 SWAP1 2548 60 PUSH1 0x01 254A 61 PUSH2 0x3585 254D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2547 stack[0] = stack[-1] // @2547 stack[-1] = 0x254e // @2548 stack[1] = 0x01 // } // Block ends with call to 0x3585, returns to 0x254E label_254E: // Incoming return from call to 0x3585 at 0x254D // Inputs[2] // { // @254F stack[-1] // @254F stack[-2] // } 254E 5B JUMPDEST 254F 90 SWAP1 2550 50 POP // Stack delta = -1 // Outputs[1] { @254F stack[-2] = stack[-1] } // Block continues label_2551: // Incoming jump from 0x2550 // Incoming jump from 0x2519, if stack[-2] < 0x0000000000000000000000000000000000000000000000000000000000000004 // Inputs[2] // { // @2552 stack[-3] // @2554 stack[-1] // } 2551 5B JUMPDEST 2552 82 DUP3 2553 5B JUMPDEST 2554 81 DUP2 2555 81 DUP2 2556 10 LT 2557 61 PUSH2 0x25bb 255A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2552 stack[0] = stack[-3] } // Block ends with conditional jump to 0x25bb, if stack[-3] < stack[-1] label_255B: // Incoming jump from 0x255A, if not stack[-3] < stack[-1] // Incoming jump from 0x255A, if not stack[-1] < stack[-2] // Inputs[4] // { // @255D stack[-1] // @256C memory[0x00:0x40] // @256E memory[0x40:0x60] // @2575 storage[keccak256(memory[0x00:0x40])] // } 255B 60 PUSH1 0x00 255D 81 DUP2 255E 81 DUP2 255F 52 MSTORE 2560 60 PUSH1 0x03 2562 60 PUSH1 0x20 2564 90 SWAP1 2565 81 DUP2 2566 52 MSTORE 2567 60 PUSH1 0x40 2569 91 SWAP2 256A 82 DUP3 256B 90 SWAP1 256C 20 SHA3 256D 82 DUP3 256E 51 MLOAD 256F 80 DUP1 2570 84 DUP5 2571 01 ADD 2572 90 SWAP1 2573 93 SWAP4 2574 52 MSTORE 2575 54 SLOAD 2576 60 PUSH1 0x01 2578 60 PUSH1 0x01 257A 60 PUSH1 0xa0 257C 1B SHL 257D 03 SUB 257E 81 DUP2 257F 16 AND 2580 80 DUP1 2581 84 DUP5 2582 52 MSTORE 2583 60 PUSH1 0x01 2585 60 PUSH1 0xa0 2587 1B SHL 2588 90 SWAP1 2589 91 SWAP2 258A 04 DIV 258B 67 PUSH8 0xffffffffffffffff 2594 16 AND 2595 91 SWAP2 2596 83 DUP4 2597 01 ADD 2598 91 SWAP2 2599 90 SWAP1 259A 91 SWAP2 259B 52 MSTORE 259C 15 ISZERO 259D 61 PUSH2 0x25a8 25A0 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @255F memory[0x00:0x20] = stack[-1] // @2566 memory[0x20:0x40] = 0x03 // @2573 stack[0] = memory[0x40:0x60] // @2574 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2582 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @259B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // } // Block ends with conditional jump to 0x25a8, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_25A1: // Incoming jump from 0x25A0, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @25A1 stack[-6] // @25A1 stack[-1] // @25A2 stack[-5] // } 25A1 94 SWAP5 25A2 93 SWAP4 25A3 50 POP 25A4 50 POP 25A5 50 POP 25A6 50 POP 25A7 56 *JUMP // Stack delta = -5 // Outputs[1] { @25A1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_25A8: // Incoming jump from 0x25A0, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @25AA stack[-2] } 25A8 5B JUMPDEST 25A9 50 POP 25AA 80 DUP1 25AB 61 PUSH2 0x25b3 25AE 81 DUP2 25AF 61 PUSH2 0x36a3 25B2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @25AA stack[-1] = stack[-2] // @25AB stack[0] = 0x25b3 // @25AE stack[1] = stack[-2] // } // Block ends with call to 0x36a3, returns to 0x25B3 label_25B3: // Incoming return from call to 0x36A3 at 0x25B2 // Inputs[2] // { // @25B4 stack[-1] // @25B4 stack[-3] // } 25B3 5B JUMPDEST 25B4 91 SWAP2 25B5 50 POP 25B6 50 POP 25B7 61 PUSH2 0x2553 25BA 56 *JUMP // Stack delta = -2 // Outputs[1] { @25B4 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x2553 label_25BB: // Incoming jump from 0x255A, if stack[-3] < stack[-1] // Incoming jump from 0x255A, if stack[-1] < stack[-2] // Inputs[1] { @25BF memory[0x40:0x60] } 25BB 5B JUMPDEST 25BC 50 POP 25BD 60 PUSH1 0x40 25BF 51 MLOAD 25C0 62 PUSH3 0x461bcd 25C4 60 PUSH1 0xe5 25C6 1B SHL 25C7 81 DUP2 25C8 52 MSTORE 25C9 60 PUSH1 0x20 25CB 60 PUSH1 0x04 25CD 82 DUP3 25CE 01 ADD 25CF 52 MSTORE 25D0 60 PUSH1 0x2f 25D2 60 PUSH1 0x24 25D4 82 DUP3 25D5 01 ADD 25D6 52 MSTORE 25D7 7F PUSH32 0x455243373231413a20756e61626c6520746f2064657465726d696e6520746865 25F8 60 PUSH1 0x44 25FA 82 DUP3 25FB 01 ADD 25FC 52 MSTORE 25FD 7F PUSH32 0x206f776e6572206f6620746f6b656e0000000000000000000000000000000000 261E 60 PUSH1 0x64 2620 82 DUP3 2621 01 ADD 2622 52 MSTORE 2623 60 PUSH1 0x84 2625 01 ADD 2626 61 PUSH2 0x0a1a 2629 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @25C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @25CF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @25D6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @25FC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20756e61626c6520746f2064657465726d696e6520746865 // @2622 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x206f776e6572206f6620746f6b656e0000000000000000000000000000000000 // @2625 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_262A: // Incoming call from 0x1330, returns to 0x1331 // Incoming call from 0x1F0E, returns to 0x1227 // Inputs[5] // { // @262E storage[0x09] // @2637 stack[-1] // @2659 memory[0x40:0x60] // @2685 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2688 stack[-2] // } 262A 5B JUMPDEST 262B 60 PUSH1 0x09 262D 80 DUP1 262E 54 SLOAD 262F 60 PUSH1 0x01 2631 60 PUSH1 0x01 2633 60 PUSH1 0xa0 2635 1B SHL 2636 03 SUB 2637 83 DUP4 2638 81 DUP2 2639 16 AND 263A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 264F 19 NOT 2650 83 DUP4 2651 16 AND 2652 81 DUP2 2653 17 OR 2654 90 SWAP1 2655 93 SWAP4 2656 55 SSTORE 2657 60 PUSH1 0x40 2659 51 MLOAD 265A 91 SWAP2 265B 16 AND 265C 91 SWAP2 265D 90 SWAP1 265E 82 DUP3 265F 90 SWAP1 2660 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 2681 90 SWAP1 2682 60 PUSH1 0x00 2684 90 SWAP1 2685 A3 LOG3 2686 50 POP 2687 50 POP 2688 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2656 storage[0x09] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x09] & ~0xffffffffffffffffffffffffffffffffffffffff) // @2685 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x09] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_2689: // Incoming call from 0x1678, returns to 0x1679 // Incoming call from 0x1578, returns to 0x1227 // Incoming call from 0x245E, returns to 0x1227 // Inputs[3] // { // @268D stack[-2] // @268E stack[-1] // @2691 memory[0x40:0x60] // } 2689 5B JUMPDEST 268A 61 PUSH2 0x0ef3 268D 82 DUP3 268E 82 DUP3 268F 60 PUSH1 0x40 2691 51 MLOAD 2692 80 DUP1 2693 60 PUSH1 0x20 2695 01 ADD 2696 60 PUSH1 0x40 2698 52 MSTORE 2699 80 DUP1 269A 60 PUSH1 0x00 269C 81 DUP2 269D 52 MSTORE 269E 50 POP 269F 61 PUSH2 0x28a1 26A2 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @268A stack[0] = 0x0ef3 // @268D stack[1] = stack[-2] // @268E stack[2] = stack[-1] // @2691 stack[3] = memory[0x40:0x60] // @2698 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @269D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x28a1, returns to 0x0EF3 26A3 5B JUMPDEST 26A4 60 PUSH1 0x00 26A6 60 PUSH1 0x0a 26A8 82 DUP3 26A9 60 PUSH1 0x40 26AB 51 MLOAD 26AC 60 PUSH1 0x20 26AE 01 ADD 26AF 61 PUSH2 0x26b9 26B2 92 SWAP3 26B3 91 SWAP2 26B4 90 SWAP1 26B5 61 PUSH2 0x3754 26B8 56 *JUMP 26B9 5B JUMPDEST 26BA 60 PUSH1 0x40 26BC 51 MLOAD 26BD 60 PUSH1 0x20 26BF 81 DUP2 26C0 83 DUP4 26C1 03 SUB 26C2 03 SUB 26C3 81 DUP2 26C4 52 MSTORE 26C5 90 SWAP1 26C6 60 PUSH1 0x40 26C8 52 MSTORE 26C9 80 DUP1 26CA 51 MLOAD 26CB 90 SWAP1 26CC 60 PUSH1 0x20 26CE 01 ADD 26CF 20 SHA3 26D0 90 SWAP1 26D1 50 POP 26D2 91 SWAP2 26D3 90 SWAP1 26D4 50 POP 26D5 56 *JUMP 26D6 5B JUMPDEST 26D7 60 PUSH1 0x00 26D9 84 DUP5 26DA 84 DUP5 26DB 84 DUP5 26DC 84 DUP5 26DD 60 PUSH1 0x40 26DF 51 MLOAD 26E0 60 PUSH1 0x20 26E2 01 ADD 26E3 61 PUSH2 0x26ef 26E6 94 SWAP5 26E7 93 SWAP4 26E8 92 SWAP3 26E9 91 SWAP2 26EA 90 SWAP1 26EB 61 PUSH2 0x3781 26EE 56 *JUMP 26EF 5B JUMPDEST 26F0 60 PUSH1 0x40 26F2 51 MLOAD 26F3 60 PUSH1 0x20 26F5 81 DUP2 26F6 83 DUP4 26F7 03 SUB 26F8 03 SUB 26F9 81 DUP2 26FA 52 MSTORE 26FB 90 SWAP1 26FC 60 PUSH1 0x40 26FE 52 MSTORE 26FF 80 DUP1 2700 51 MLOAD 2701 90 SWAP1 2702 60 PUSH1 0x20 2704 01 ADD 2705 20 SHA3 2706 90 SWAP1 2707 50 POP label_2708: // Incoming return from call to 0x3257 at 0x32AB // Incoming jump from 0x2860 // Incoming jump from 0x2CDC, if !stack[-7] // Incoming jump from 0x2CDC, if !stack[-5] // Incoming jump from 0x2CDC, if !stack[-7] // Inputs[3] // { // @2709 stack[-1] // @2709 stack[-6] // @270A stack[-5] // } 2708 5B JUMPDEST 2709 94 SWAP5 270A 93 SWAP4 270B 50 POP 270C 50 POP 270D 50 POP 270E 50 POP 270F 56 *JUMP // Stack delta = -5 // Outputs[1] { @2709 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2710: // Incoming call from 0x2B85, returns to 0x2B86 // Inputs[2] // { // @271B stack[-3] // @271D address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 2710 5B JUMPDEST 2711 60 PUSH1 0x00 2713 60 PUSH1 0x01 2715 60 PUSH1 0x01 2717 60 PUSH1 0xa0 2719 1B SHL 271A 03 SUB 271B 84 DUP5 271C 16 AND 271D 3B EXTCODESIZE 271E 15 ISZERO 271F 61 PUSH2 0x2859 2722 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2711 stack[0] = 0x00 } // Block ends with conditional jump to 0x2859, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_2723: // Incoming jump from 0x2722, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @2725 memory[0x40:0x60] // @2738 stack[-4] // @2745 msg.sender // @2747 stack[-5] // @2749 stack[-3] // @274B stack[-2] // } 2723 60 PUSH1 0x40 2725 51 MLOAD 2726 63 PUSH4 0x0a85bd01 272B 60 PUSH1 0xe1 272D 1B SHL 272E 81 DUP2 272F 52 MSTORE 2730 60 PUSH1 0x01 2732 60 PUSH1 0x01 2734 60 PUSH1 0xa0 2736 1B SHL 2737 03 SUB 2738 85 DUP6 2739 16 AND 273A 90 SWAP1 273B 63 PUSH4 0x150b7a02 2740 90 SWAP1 2741 61 PUSH2 0x2754 2744 90 SWAP1 2745 33 CALLER 2746 90 SWAP1 2747 89 DUP10 2748 90 SWAP1 2749 88 DUP9 274A 90 SWAP1 274B 88 DUP9 274C 90 SWAP1 274D 60 PUSH1 0x04 274F 01 ADD 2750 61 PUSH2 0x37d5 2753 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @272F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @273A stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2740 stack[1] = 0x150b7a02 // @2744 stack[2] = 0x2754 // @2746 stack[3] = msg.sender // @2748 stack[4] = stack[-5] // @274A stack[5] = stack[-3] // @274C stack[6] = stack[-2] // @274F stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x37d5 2754 5B JUMPDEST 2755 60 PUSH1 0x20 2757 60 PUSH1 0x40 2759 51 MLOAD 275A 80 DUP1 275B 83 DUP4 275C 03 SUB 275D 81 DUP2 275E 60 PUSH1 0x00 2760 87 DUP8 2761 5A GAS 2762 F1 CALL 2763 92 SWAP3 2764 50 POP 2765 50 POP 2766 50 POP 2767 80 DUP1 2768 15 ISZERO 2769 61 PUSH2 0x278f 276C 57 *JUMPI 276D 50 POP 276E 60 PUSH1 0x40 2770 80 DUP1 2771 51 MLOAD 2772 60 PUSH1 0x1f 2774 3D RETURNDATASIZE 2775 90 SWAP1 2776 81 DUP2 2777 01 ADD 2778 60 PUSH1 0x1f 277A 19 NOT 277B 16 AND 277C 82 DUP3 277D 01 ADD 277E 90 SWAP1 277F 92 SWAP3 2780 52 MSTORE 2781 61 PUSH2 0x278c 2784 91 SWAP2 2785 81 DUP2 2786 01 ADD 2787 90 SWAP1 2788 61 PUSH2 0x3807 278B 56 *JUMP 278C 5B JUMPDEST 278D 60 PUSH1 0x01 278F 5B JUMPDEST 2790 61 PUSH2 0x283f 2793 57 *JUMPI 2794 3D RETURNDATASIZE 2795 80 DUP1 2796 80 DUP1 2797 15 ISZERO 2798 61 PUSH2 0x27bd 279B 57 *JUMPI 279C 60 PUSH1 0x40 279E 51 MLOAD 279F 91 SWAP2 27A0 50 POP 27A1 60 PUSH1 0x1f 27A3 19 NOT 27A4 60 PUSH1 0x3f 27A6 3D RETURNDATASIZE 27A7 01 ADD 27A8 16 AND 27A9 82 DUP3 27AA 01 ADD 27AB 60 PUSH1 0x40 27AD 52 MSTORE 27AE 3D RETURNDATASIZE 27AF 82 DUP3 27B0 52 MSTORE 27B1 3D RETURNDATASIZE 27B2 60 PUSH1 0x00 27B4 60 PUSH1 0x20 27B6 84 DUP5 27B7 01 ADD 27B8 3E RETURNDATACOPY 27B9 61 PUSH2 0x27c2 27BC 56 *JUMP 27BD 5B JUMPDEST 27BE 60 PUSH1 0x60 27C0 91 SWAP2 27C1 50 POP 27C2 5B JUMPDEST 27C3 50 POP 27C4 80 DUP1 27C5 51 MLOAD 27C6 61 PUSH2 0x2837 27C9 57 *JUMPI 27CA 60 PUSH1 0x40 27CC 51 MLOAD 27CD 62 PUSH3 0x461bcd 27D1 60 PUSH1 0xe5 27D3 1B SHL 27D4 81 DUP2 27D5 52 MSTORE 27D6 60 PUSH1 0x20 27D8 60 PUSH1 0x04 27DA 82 DUP3 27DB 01 ADD 27DC 52 MSTORE 27DD 60 PUSH1 0x33 27DF 60 PUSH1 0x24 27E1 82 DUP3 27E2 01 ADD 27E3 52 MSTORE 27E4 7F PUSH32 0x455243373231413a207472616e7366657220746f206e6f6e2045524337323152 2805 60 PUSH1 0x44 2807 82 DUP3 2808 01 ADD 2809 52 MSTORE 280A 7F PUSH32 0x6563656976657220696d706c656d656e74657200000000000000000000000000 282B 60 PUSH1 0x64 282D 82 DUP3 282E 01 ADD 282F 52 MSTORE 2830 60 PUSH1 0x84 2832 01 ADD 2833 61 PUSH2 0x0a1a 2836 56 *JUMP 2837 5B JUMPDEST 2838 80 DUP1 2839 51 MLOAD 283A 81 DUP2 283B 60 PUSH1 0x20 283D 01 ADD 283E FD *REVERT 283F 5B JUMPDEST 2840 60 PUSH1 0x01 2842 60 PUSH1 0x01 2844 60 PUSH1 0xe0 2846 1B SHL 2847 03 SUB 2848 19 NOT 2849 16 AND 284A 63 PUSH4 0x0a85bd01 284F 60 PUSH1 0xe1 2851 1B SHL 2852 14 EQ 2853 90 SWAP1 2854 50 POP 2855 61 PUSH2 0x2708 2858 56 *JUMP label_2859: // Incoming jump from 0x2722, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length 2859 5B JUMPDEST 285A 50 POP 285B 60 PUSH1 0x01 285D 61 PUSH2 0x2708 2860 56 *JUMP // Stack delta = +0 // Outputs[1] { @285B stack[-1] = 0x01 } // Block ends with unconditional jump to 0x2708 label_2861: // Incoming jump from 0x1D20 // Inputs[1] { @2869 stack[-1] } 2861 5B JUMPDEST 2862 60 PUSH1 0x60 2864 60 PUSH1 0x0b 2866 61 PUSH2 0x286e 2869 83 DUP4 286A 61 PUSH2 0x2c23 286D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2862 stack[0] = 0x60 // @2864 stack[1] = 0x0b // @2866 stack[2] = 0x286e // @2869 stack[3] = stack[-1] // } // Block ends with call to 0x2c23, returns to 0x286E label_286E: // Incoming return from call to 0x2C23 at 0x286D // Inputs[3] // { // @2871 memory[0x40:0x60] // @2878 stack[-2] // @2879 stack[-1] // } 286E 5B JUMPDEST 286F 60 PUSH1 0x40 2871 51 MLOAD 2872 60 PUSH1 0x20 2874 01 ADD 2875 61 PUSH2 0x287f 2878 92 SWAP3 2879 91 SWAP2 287A 90 SWAP1 287B 61 PUSH2 0x3824 287E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2878 stack[-2] = 0x287f // @2879 stack[-1] = stack[-2] // @287A stack[1] = 0x20 + memory[0x40:0x60] // @287A stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x3824 287F 5B JUMPDEST 2880 60 PUSH1 0x40 2882 51 MLOAD 2883 60 PUSH1 0x20 2885 81 DUP2 2886 83 DUP4 2887 03 SUB 2888 03 SUB 2889 81 DUP2 288A 52 MSTORE 288B 90 SWAP1 288C 60 PUSH1 0x40 288E 52 MSTORE 288F 90 SWAP1 2890 50 POP 2891 91 SWAP2 2892 90 SWAP1 2893 50 POP 2894 56 *JUMP label_2895: // Incoming jump from 0x2360 // Inputs[2] // { // @289B stack[-2] // @289C stack[-1] // } 2895 5B JUMPDEST 2896 60 PUSH1 0x00 2898 61 PUSH2 0x1d21 289B 83 DUP4 289C 83 DUP4 289D 61 PUSH2 0x2d55 28A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2896 stack[0] = 0x00 // @2898 stack[1] = 0x1d21 // @289B stack[2] = stack[-2] // @289C stack[3] = stack[-1] // } // Block ends with call to 0x2d55, returns to 0x1D21 label_28A1: // Incoming call from 0x26A2, returns to 0x0EF3 // Inputs[2] // { // @28A4 storage[0x00] // @28AD stack[-3] // } 28A1 5B JUMPDEST 28A2 60 PUSH1 0x00 28A4 54 SLOAD 28A5 60 PUSH1 0x01 28A7 60 PUSH1 0x01 28A9 60 PUSH1 0xa0 28AB 1B SHL 28AC 03 SUB 28AD 84 DUP5 28AE 16 AND 28AF 61 PUSH2 0x2920 28B2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28A4 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x2920, if stack[-3] & (0x01 << 0xa0) - 0x01 label_28B3: // Incoming jump from 0x28B2, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @28B5 memory[0x40:0x60] } 28B3 60 PUSH1 0x40 28B5 51 MLOAD 28B6 62 PUSH3 0x461bcd 28BA 60 PUSH1 0xe5 28BC 1B SHL 28BD 81 DUP2 28BE 52 MSTORE 28BF 60 PUSH1 0x20 28C1 60 PUSH1 0x04 28C3 82 DUP3 28C4 01 ADD 28C5 52 MSTORE 28C6 60 PUSH1 0x21 28C8 60 PUSH1 0x24 28CA 82 DUP3 28CB 01 ADD 28CC 52 MSTORE 28CD 7F PUSH32 0x455243373231413a206d696e7420746f20746865207a65726f20616464726573 28EE 60 PUSH1 0x44 28F0 82 DUP3 28F1 01 ADD 28F2 52 MSTORE 28F3 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 2914 60 PUSH1 0x64 2916 82 DUP3 2917 01 ADD 2918 52 MSTORE 2919 60 PUSH1 0x84 291B 01 ADD 291C 61 PUSH2 0x0a1a 291F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @28BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @28C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @28CC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @28F2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a206d696e7420746f20746865207a65726f20616464726573 // @2918 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @291B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2920: // Incoming jump from 0x28B2, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2924 stack[-1] // @2927 storage[0x00] // } 2920 5B JUMPDEST 2921 61 PUSH2 0x292b 2924 81 DUP2 2925 60 PUSH1 0x00 2927 54 SLOAD 2928 11 GT 2929 90 SWAP1 292A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2929 stack[0] = storage[0x00] > stack[-1] } // Block ends with unconditional jump to 0x292b label_292B: // Incoming jump from 0x292A // Inputs[1] { @292C stack[-1] } 292B 5B JUMPDEST 292C 15 ISZERO 292D 61 PUSH2 0x2978 2930 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2978, if !stack[-1] label_2931: // Incoming jump from 0x2930, if not !stack[-1] // Inputs[1] { @2933 memory[0x40:0x60] } 2931 60 PUSH1 0x40 2933 51 MLOAD 2934 62 PUSH3 0x461bcd 2938 60 PUSH1 0xe5 293A 1B SHL 293B 81 DUP2 293C 52 MSTORE 293D 60 PUSH1 0x20 293F 60 PUSH1 0x04 2941 82 DUP3 2942 01 ADD 2943 52 MSTORE 2944 60 PUSH1 0x1d 2946 60 PUSH1 0x24 2948 82 DUP3 2949 01 ADD 294A 52 MSTORE 294B 7F PUSH32 0x455243373231413a20746f6b656e20616c7265616479206d696e746564000000 296C 60 PUSH1 0x44 296E 82 DUP3 296F 01 ADD 2970 52 MSTORE 2971 60 PUSH1 0x64 2973 01 ADD 2974 61 PUSH2 0x0a1a 2977 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @293C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2943 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @294A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @2970 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a20746f6b656e20616c7265616479206d696e746564000000 // @2973 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2978: // Incoming jump from 0x2930, if !stack[-1] // Inputs[1] { @299A stack[-3] } 2978 5B JUMPDEST 2979 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000004 299A 83 DUP4 299B 11 GT 299C 15 ISZERO 299D 61 PUSH2 0x2a0e 29A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a0e, if !(stack[-3] > 0x0000000000000000000000000000000000000000000000000000000000000004) label_29A1: // Incoming jump from 0x29A0, if not !(stack[-3] > 0x0000000000000000000000000000000000000000000000000000000000000004) // Inputs[1] { @29A3 memory[0x40:0x60] } 29A1 60 PUSH1 0x40 29A3 51 MLOAD 29A4 62 PUSH3 0x461bcd 29A8 60 PUSH1 0xe5 29AA 1B SHL 29AB 81 DUP2 29AC 52 MSTORE 29AD 60 PUSH1 0x20 29AF 60 PUSH1 0x04 29B1 82 DUP3 29B2 01 ADD 29B3 52 MSTORE 29B4 60 PUSH1 0x22 29B6 60 PUSH1 0x24 29B8 82 DUP3 29B9 01 ADD 29BA 52 MSTORE 29BB 7F PUSH32 0x455243373231413a207175616e7469747920746f206d696e7420746f6f206869 29DC 60 PUSH1 0x44 29DE 82 DUP3 29DF 01 ADD 29E0 52 MSTORE 29E1 7F PUSH32 0x6768000000000000000000000000000000000000000000000000000000000000 2A02 60 PUSH1 0x64 2A04 82 DUP3 2A05 01 ADD 2A06 52 MSTORE 2A07 60 PUSH1 0x84 2A09 01 ADD 2A0A 61 PUSH2 0x0a1a 2A0D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @29AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @29B3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @29BA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @29E0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207175616e7469747920746f206d696e7420746f6f206869 // @2A06 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6768000000000000000000000000000000000000000000000000000000000000 // @2A09 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2A0E: // Incoming jump from 0x29A0, if !(stack[-3] > 0x0000000000000000000000000000000000000000000000000000000000000004) // Inputs[7] // { // @2A17 stack[-4] // @2A2A memory[0x00:0x40] // @2A2C memory[0x40:0x60] // @2A33 storage[keccak256(memory[0x00:0x40])] // @2A5F memory[0x40:0x60] // @2A67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2A71 stack[-3] // } 2A0E 5B JUMPDEST 2A0F 60 PUSH1 0x01 2A11 60 PUSH1 0x01 2A13 60 PUSH1 0xa0 2A15 1B SHL 2A16 03 SUB 2A17 84 DUP5 2A18 16 AND 2A19 60 PUSH1 0x00 2A1B 90 SWAP1 2A1C 81 DUP2 2A1D 52 MSTORE 2A1E 60 PUSH1 0x04 2A20 60 PUSH1 0x20 2A22 90 SWAP1 2A23 81 DUP2 2A24 52 MSTORE 2A25 60 PUSH1 0x40 2A27 91 SWAP2 2A28 82 DUP3 2A29 90 SWAP1 2A2A 20 SHA3 2A2B 82 DUP3 2A2C 51 MLOAD 2A2D 80 DUP1 2A2E 84 DUP5 2A2F 01 ADD 2A30 84 DUP5 2A31 52 MSTORE 2A32 90 SWAP1 2A33 54 SLOAD 2A34 60 PUSH1 0x01 2A36 60 PUSH1 0x01 2A38 60 PUSH1 0x80 2A3A 1B SHL 2A3B 03 SUB 2A3C 80 DUP1 2A3D 82 DUP3 2A3E 16 AND 2A3F 83 DUP4 2A40 52 MSTORE 2A41 70 PUSH17 0x0100000000000000000000000000000000 2A53 90 SWAP1 2A54 91 SWAP2 2A55 04 DIV 2A56 16 AND 2A57 91 SWAP2 2A58 81 DUP2 2A59 01 ADD 2A5A 91 SWAP2 2A5B 90 SWAP1 2A5C 91 SWAP2 2A5D 52 MSTORE 2A5E 81 DUP2 2A5F 51 MLOAD 2A60 80 DUP1 2A61 83 DUP4 2A62 01 ADD 2A63 90 SWAP1 2A64 92 SWAP3 2A65 52 MSTORE 2A66 80 DUP1 2A67 51 MLOAD 2A68 90 SWAP1 2A69 91 SWAP2 2A6A 90 SWAP1 2A6B 81 DUP2 2A6C 90 SWAP1 2A6D 61 PUSH2 0x2a77 2A70 90 SWAP1 2A71 87 DUP8 2A72 90 SWAP1 2A73 61 PUSH2 0x3603 2A76 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @2A1D memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2A24 memory[0x20:0x40] = 0x04 // @2A31 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2A40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x80) - 0x01 // @2A5D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[keccak256(memory[0x00:0x40])] / 0x0100000000000000000000000000000000 & (0x01 << 0x80) - 0x01 // @2A65 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2A69 stack[0] = memory[0x40:0x60] // @2A6A stack[1] = memory[0x40:0x60] // @2A6C stack[2] = memory[0x40:0x60] // @2A70 stack[3] = 0x2a77 // @2A72 stack[4] = stack[-3] // @2A72 stack[5] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } // Block ends with call to 0x3603, returns to 0x2A77 label_2A77: // Incoming return from call to 0x3603 at 0x2A76 // Inputs[5] // { // @2A80 stack[-1] // @2A81 stack[-2] // @2A86 stack[-7] // @2A87 stack[-4] // @2A8B memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } 2A77 5B JUMPDEST 2A78 60 PUSH1 0x01 2A7A 60 PUSH1 0x01 2A7C 60 PUSH1 0x80 2A7E 1B SHL 2A7F 03 SUB 2A80 16 AND 2A81 81 DUP2 2A82 52 MSTORE 2A83 60 PUSH1 0x20 2A85 01 ADD 2A86 85 DUP6 2A87 83 DUP4 2A88 60 PUSH1 0x20 2A8A 01 ADD 2A8B 51 MLOAD 2A8C 61 PUSH2 0x2a95 2A8F 91 SWAP2 2A90 90 SWAP1 2A91 61 PUSH2 0x3603 2A94 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2A82 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0x80) - 0x01 & stack[-1] // @2A85 stack[-2] = 0x20 + stack[-2] // @2A8F stack[-1] = 0x2a95 // @2A90 stack[0] = stack[-7] // @2A90 stack[1] = memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with call to 0x3603, returns to 0x2A95 label_2A95: // Incoming return from call to 0x3603 at 0x2A94 // Inputs[15] // { // @2A9E stack[-1] // @2AA2 stack[-2] // @2AAD stack[-8] // @2ABF memory[0x00:0x40] // @2AC0 stack[-3] // @2AC1 memory[stack[-3]:stack[-3] + 0x20] // @2AC5 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] // @2AE7 memory[0x40:0x60] // @2AF9 block.timestamp // @2B02 stack[-5] // @2B0C memory[0x00:0x40] // @2B0E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2B10 storage[keccak256(memory[0x00:0x40])] // @2B12 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] // @2B3A stack[-7] // } 2A95 5B JUMPDEST 2A96 60 PUSH1 0x01 2A98 60 PUSH1 0x01 2A9A 60 PUSH1 0x80 2A9C 1B SHL 2A9D 03 SUB 2A9E 90 SWAP1 2A9F 81 DUP2 2AA0 16 AND 2AA1 90 SWAP1 2AA2 91 SWAP2 2AA3 52 MSTORE 2AA4 60 PUSH1 0x01 2AA6 60 PUSH1 0x01 2AA8 60 PUSH1 0xa0 2AAA 1B SHL 2AAB 03 SUB 2AAC 80 DUP1 2AAD 88 DUP9 2AAE 16 AND 2AAF 60 PUSH1 0x00 2AB1 81 DUP2 2AB2 81 DUP2 2AB3 52 MSTORE 2AB4 60 PUSH1 0x04 2AB6 60 PUSH1 0x20 2AB8 90 SWAP1 2AB9 81 DUP2 2ABA 52 MSTORE 2ABB 60 PUSH1 0x40 2ABD 80 DUP1 2ABE 83 DUP4 2ABF 20 SHA3 2AC0 87 DUP8 2AC1 51 MLOAD 2AC2 97 SWAP8 2AC3 83 DUP4 2AC4 01 ADD 2AC5 51 MLOAD 2AC6 87 DUP8 2AC7 16 AND 2AC8 70 PUSH17 0x0100000000000000000000000000000000 2ADA 02 MUL 2ADB 97 SWAP8 2ADC 90 SWAP1 2ADD 96 SWAP7 2ADE 16 AND 2ADF 96 SWAP7 2AE0 90 SWAP1 2AE1 96 SWAP7 2AE2 17 OR 2AE3 90 SWAP1 2AE4 94 SWAP5 2AE5 55 SSTORE 2AE6 84 DUP5 2AE7 51 MLOAD 2AE8 80 DUP1 2AE9 86 DUP7 2AEA 01 ADD 2AEB 86 DUP7 2AEC 52 MSTORE 2AED 91 SWAP2 2AEE 82 DUP3 2AEF 52 MSTORE 2AF0 67 PUSH8 0xffffffffffffffff 2AF9 42 TIMESTAMP 2AFA 81 DUP2 2AFB 16 AND 2AFC 83 DUP4 2AFD 86 DUP7 2AFE 01 ADD 2AFF 90 SWAP1 2B00 81 DUP2 2B01 52 MSTORE 2B02 88 DUP9 2B03 83 DUP4 2B04 52 MSTORE 2B05 60 PUSH1 0x03 2B07 90 SWAP1 2B08 95 SWAP6 2B09 52 MSTORE 2B0A 94 SWAP5 2B0B 81 DUP2 2B0C 20 SHA3 2B0D 91 SWAP2 2B0E 51 MLOAD 2B0F 82 DUP3 2B10 54 SLOAD 2B11 94 SWAP5 2B12 51 MLOAD 2B13 90 SWAP1 2B14 95 SWAP6 2B15 16 AND 2B16 60 PUSH1 0x01 2B18 60 PUSH1 0xa0 2B1A 1B SHL 2B1B 02 MUL 2B1C 60 PUSH1 0x01 2B1E 60 PUSH1 0x01 2B20 60 PUSH1 0xe0 2B22 1B SHL 2B23 03 SUB 2B24 19 NOT 2B25 90 SWAP1 2B26 94 SWAP5 2B27 16 AND 2B28 94 SWAP5 2B29 90 SWAP1 2B2A 92 SWAP3 2B2B 16 AND 2B2C 93 SWAP4 2B2D 90 SWAP1 2B2E 93 SWAP4 2B2F 17 OR 2B30 91 SWAP2 2B31 90 SWAP1 2B32 91 SWAP2 2B33 17 OR 2B34 90 SWAP1 2B35 91 SWAP2 2B36 55 SSTORE 2B37 82 DUP3 2B38 90 SWAP1 2B39 5B JUMPDEST 2B3A 85 DUP6 2B3B 81 DUP2 2B3C 10 LT 2B3D 15 ISZERO 2B3E 61 PUSH2 0x2c18 2B41 57 *JUMPI // Stack delta = -1 // Outputs[12] // { // @2AA3 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0x80) - 0x01 & stack[-1] // @2AB3 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @2ABA memory[0x20:0x40] = 0x04 // @2AE5 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & memory[stack[-3]:stack[-3] + 0x20]) | 0x0100000000000000000000000000000000 * ((0x01 << 0x80) - 0x01 & memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20]) // @2AEC memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2AEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @2B01 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffff & block.timestamp // @2B04 memory[0x00:0x20] = stack[-5] // @2B09 memory[0x20:0x40] = 0x03 // @2B36 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20]) // @2B38 stack[-2] = 0x00 // @2B38 stack[-3] = stack[-5] // } // Block ends with conditional jump to 0x2c18, if !(0x00 < stack[-7]) label_2B42: // Incoming jump from 0x2B41, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x2B41, if not !(0x00 < stack[-7]) // Inputs[5] // { // @2B44 memory[0x40:0x60] // @2B45 stack[-2] // @2B4F stack[-7] // @2B79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2B81 stack[-5] // } 2B42 60 PUSH1 0x40 2B44 51 MLOAD 2B45 82 DUP3 2B46 90 SWAP1 2B47 60 PUSH1 0x01 2B49 60 PUSH1 0x01 2B4B 60 PUSH1 0xa0 2B4D 1B SHL 2B4E 03 SUB 2B4F 89 DUP10 2B50 16 AND 2B51 90 SWAP1 2B52 60 PUSH1 0x00 2B54 90 SWAP1 2B55 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2B76 90 SWAP1 2B77 82 DUP3 2B78 90 SWAP1 2B79 A4 LOG4 2B7A 61 PUSH2 0x2b86 2B7D 60 PUSH1 0x00 2B7F 88 DUP9 2B80 84 DUP5 2B81 88 DUP9 2B82 61 PUSH2 0x2710 2B85 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @2B79 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @2B7A stack[0] = 0x2b86 // @2B7D stack[1] = 0x00 // @2B7F stack[2] = stack[-7] // @2B80 stack[3] = stack[-2] // @2B81 stack[4] = stack[-5] // } // Block ends with call to 0x2710, returns to 0x2B86 label_2B86: // Incoming return from call to 0x2710 at 0x2B85 // Inputs[1] { @2B8A stack[-1] } 2B86 5B JUMPDEST 2B87 61 PUSH2 0x2bf8 2B8A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2bf8, if stack[-1] label_2B8B: // Incoming jump from 0x2B8A, if not stack[-1] // Inputs[1] { @2B8D memory[0x40:0x60] } 2B8B 60 PUSH1 0x40 2B8D 51 MLOAD 2B8E 62 PUSH3 0x461bcd 2B92 60 PUSH1 0xe5 2B94 1B SHL 2B95 81 DUP2 2B96 52 MSTORE 2B97 60 PUSH1 0x20 2B99 60 PUSH1 0x04 2B9B 82 DUP3 2B9C 01 ADD 2B9D 52 MSTORE 2B9E 60 PUSH1 0x33 2BA0 60 PUSH1 0x24 2BA2 82 DUP3 2BA3 01 ADD 2BA4 52 MSTORE 2BA5 7F PUSH32 0x455243373231413a207472616e7366657220746f206e6f6e2045524337323152 2BC6 60 PUSH1 0x44 2BC8 82 DUP3 2BC9 01 ADD 2BCA 52 MSTORE 2BCB 7F PUSH32 0x6563656976657220696d706c656d656e74657200000000000000000000000000 2BEC 60 PUSH1 0x64 2BEE 82 DUP3 2BEF 01 ADD 2BF0 52 MSTORE 2BF1 60 PUSH1 0x84 2BF3 01 ADD 2BF4 61 PUSH2 0x0a1a 2BF7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2B96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2B9D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2BA4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x33 // @2BCA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231413a207472616e7366657220746f206e6f6e2045524337323152 // @2BF0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6563656976657220696d706c656d656e74657200000000000000000000000000 // @2BF3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2BF8: // Incoming jump from 0x2B8A, if stack[-1] // Inputs[1] { @2BF9 stack[-2] } 2BF8 5B JUMPDEST 2BF9 81 DUP2 2BFA 61 PUSH2 0x2c02 2BFD 81 DUP2 2BFE 61 PUSH2 0x356a 2C01 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2BF9 stack[0] = stack[-2] // @2BFA stack[1] = 0x2c02 // @2BFD stack[2] = stack[-2] // } // Block ends with call to 0x356a, returns to 0x2C02 label_2C02: // Incoming return from call to 0x356A at 0x2C01 // Inputs[3] // { // @2C03 stack[-4] // @2C03 stack[-1] // @2C06 stack[-3] // } 2C02 5B JUMPDEST 2C03 92 SWAP3 2C04 50 POP 2C05 50 POP 2C06 80 DUP1 2C07 80 DUP1 2C08 61 PUSH2 0x2c10 2C0B 90 SWAP1 2C0C 61 PUSH2 0x356a 2C0F 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2C03 stack[-4] = stack[-1] // @2C06 stack[-2] = stack[-3] // @2C0B stack[0] = stack[-3] // @2C0B stack[-1] = 0x2c10 // } // Block ends with call to 0x356a, returns to 0x2C10 label_2C10: // Incoming return from call to 0x356A at 0x2C0F // Inputs[2] // { // @2C11 stack[-3] // @2C11 stack[-1] // } 2C10 5B JUMPDEST 2C11 91 SWAP2 2C12 50 POP 2C13 50 POP 2C14 61 PUSH2 0x2b39 2C17 56 *JUMP // Stack delta = -2 // Outputs[1] { @2C11 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x2b39 label_2C18: // Incoming jump from 0x2B41, if !(stack[-1] < stack[-6]) // Incoming jump from 0x2B41, if !(0x00 < stack[-7]) // Inputs[1] { @2C1C stack[-2] } 2C18 5B JUMPDEST 2C19 50 POP 2C1A 60 PUSH1 0x00 2C1C 81 DUP2 2C1D 90 SWAP1 2C1E 55 SSTORE 2C1F 61 PUSH2 0x2332 2C22 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C1E storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x2332 label_2C23: // Incoming call from 0x286D, returns to 0x286E // Inputs[1] { @2C26 stack[-1] } 2C23 5B JUMPDEST 2C24 60 PUSH1 0x60 2C26 81 DUP2 2C27 61 PUSH2 0x2c63 2C2A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C24 stack[0] = 0x60 } // Block ends with conditional jump to 0x2c63, if stack[-1] label_2C2B: // Incoming jump from 0x2C2A, if not stack[-1] // Inputs[2] // { // @2C30 memory[0x40:0x60] // @2C61 stack[-3] // } 2C2B 50 POP 2C2C 50 POP 2C2D 60 PUSH1 0x40 2C2F 80 DUP1 2C30 51 MLOAD 2C31 80 DUP1 2C32 82 DUP3 2C33 01 ADD 2C34 90 SWAP1 2C35 91 SWAP2 2C36 52 MSTORE 2C37 60 PUSH1 0x01 2C39 81 DUP2 2C3A 52 MSTORE 2C3B 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 2C5C 60 PUSH1 0x20 2C5E 82 DUP3 2C5F 01 ADD 2C60 52 MSTORE 2C61 90 SWAP1 2C62 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @2C36 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2C3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @2C60 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @2C61 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_2C63: // Incoming jump from 0x2C2A, if stack[-1] // Inputs[1] { @2C64 stack[-2] } 2C63 5B JUMPDEST 2C64 81 DUP2 2C65 60 PUSH1 0x00 2C67 5B JUMPDEST 2C68 81 DUP2 2C69 15 ISZERO 2C6A 61 PUSH2 0x2c8d 2C6D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C64 stack[0] = stack[-2] // @2C65 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2c8d, if !stack[-2] label_2C6E: // Incoming jump from 0x2C6D, if not !stack[-2] // Incoming jump from 0x2C6D, if not !stack[-2] // Inputs[1] { @2C6E stack[-1] } 2C6E 80 DUP1 2C6F 61 PUSH2 0x2c77 2C72 81 DUP2 2C73 61 PUSH2 0x356a 2C76 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C6E stack[0] = stack[-1] // @2C6F stack[1] = 0x2c77 // @2C72 stack[2] = stack[-1] // } // Block ends with call to 0x356a, returns to 0x2C77 label_2C77: // Incoming return from call to 0x356A at 0x2C76 // Inputs[4] // { // @2C78 stack[-1] // @2C78 stack[-3] // @2C7D stack[-2] // @2C81 stack[-4] // } 2C77 5B JUMPDEST 2C78 91 SWAP2 2C79 50 POP 2C7A 61 PUSH2 0x2c86 2C7D 90 SWAP1 2C7E 50 POP 2C7F 60 PUSH1 0x0a 2C81 83 DUP4 2C82 61 PUSH2 0x35c7 2C85 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2C78 stack[-3] = stack[-1] // @2C7D stack[-2] = 0x2c86 // @2C7F stack[-1] = 0x0a // @2C81 stack[0] = stack[-4] // } // Block ends with call to 0x35c7, returns to 0x2C86 label_2C86: // Incoming return from call to 0x35C7 at 0x2C85 // Inputs[2] // { // @2C87 stack[-3] // @2C87 stack[-1] // } 2C86 5B JUMPDEST 2C87 91 SWAP2 2C88 50 POP 2C89 61 PUSH2 0x2c67 2C8C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2C87 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x2c67 label_2C8D: // Incoming jump from 0x2C6D, if !stack[-2] // Incoming jump from 0x2C6D, if !stack[-2] // Inputs[1] { @2C90 stack[-1] } 2C8D 5B JUMPDEST 2C8E 60 PUSH1 0x00 2C90 81 DUP2 2C91 67 PUSH8 0xffffffffffffffff 2C9A 81 DUP2 2C9B 11 GT 2C9C 15 ISZERO 2C9D 61 PUSH2 0x2ca8 2CA0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C8E stack[0] = 0x00 // @2C90 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2ca8, if !(stack[-1] > 0xffffffffffffffff) label_2CA1: // Incoming jump from 0x2CA0, if not !(stack[-1] > 0xffffffffffffffff) 2CA1 61 PUSH2 0x2ca8 2CA4 61 PUSH2 0x31cb 2CA7 56 *JUMP // Stack delta = +1 // Outputs[1] { @2CA1 stack[0] = 0x2ca8 } // Block ends with unconditional jump to 0x31cb label_2CA8: // Incoming jump from 0x2CA0, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2CAB memory[0x40:0x60] // @2CAC stack[-1] // } 2CA8 5B JUMPDEST 2CA9 60 PUSH1 0x40 2CAB 51 MLOAD 2CAC 90 SWAP1 2CAD 80 DUP1 2CAE 82 DUP3 2CAF 52 MSTORE 2CB0 80 DUP1 2CB1 60 PUSH1 0x1f 2CB3 01 ADD 2CB4 60 PUSH1 0x1f 2CB6 19 NOT 2CB7 16 AND 2CB8 60 PUSH1 0x20 2CBA 01 ADD 2CBB 82 DUP3 2CBC 01 ADD 2CBD 60 PUSH1 0x40 2CBF 52 MSTORE 2CC0 80 DUP1 2CC1 15 ISZERO 2CC2 61 PUSH2 0x2cd2 2CC5 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2CAC stack[-1] = memory[0x40:0x60] // @2CAC stack[0] = stack[-1] // @2CAF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2CBF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x2cd2, if !stack[-1] label_2CC6: // Incoming jump from 0x2CC5, if not !stack[-1] // Inputs[6] // { // @2CC8 stack[-2] // @2CCA stack[-1] // @2CCC msg.data.length // @2CCE msg.data[msg.data.length:msg.data.length + stack[-1]] // @2CD4 stack[-3] // @2CD7 stack[-7] // } 2CC6 60 PUSH1 0x20 2CC8 82 DUP3 2CC9 01 ADD 2CCA 81 DUP2 2CCB 80 DUP1 2CCC 36 CALLDATASIZE 2CCD 83 DUP4 2CCE 37 CALLDATACOPY 2CCF 01 ADD 2CD0 90 SWAP1 2CD1 50 POP 2CD2 5B JUMPDEST 2CD3 50 POP 2CD4 90 SWAP1 2CD5 50 POP 2CD6 5B JUMPDEST 2CD7 84 DUP5 2CD8 15 ISZERO 2CD9 61 PUSH2 0x2708 2CDC 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2CCE memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @2CD4 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x2708, if !stack[-7] label_2CDD: // Incoming jump from 0x2CDC, if not !stack[-7] // Incoming jump from 0x2CDC, if not !stack[-5] // Incoming jump from 0x2CDC, if not !stack[-7] // Inputs[1] { @2CE2 stack[-2] } 2CDD 61 PUSH2 0x2ce7 2CE0 60 PUSH1 0x01 2CE2 83 DUP4 2CE3 61 PUSH2 0x368c 2CE6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2CDD stack[0] = 0x2ce7 // @2CE0 stack[1] = 0x01 // @2CE2 stack[2] = stack[-2] // } // Block ends with call to 0x368c, returns to 0x2CE7 label_2CE7: // Incoming return from call to 0x368C at 0x2CE6 // Inputs[3] // { // @2CE8 stack[-3] // @2CE8 stack[-1] // @2CEF stack[-6] // } 2CE7 5B JUMPDEST 2CE8 91 SWAP2 2CE9 50 POP 2CEA 61 PUSH2 0x2cf4 2CED 60 PUSH1 0x0a 2CEF 86 DUP7 2CF0 61 PUSH2 0x35b3 2CF3 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2CE8 stack[-3] = stack[-1] // @2CEA stack[-1] = 0x2cf4 // @2CED stack[0] = 0x0a // @2CEF stack[1] = stack[-6] // } // Block ends with call to 0x35b3, returns to 0x2CF4 label_2CF4: // Incoming return from call to 0x35B3 at 0x2CF3 // Inputs[1] { @2CF8 stack[-1] } 2CF4 5B JUMPDEST 2CF5 61 PUSH2 0x2cff 2CF8 90 SWAP1 2CF9 60 PUSH1 0x30 2CFB 61 PUSH2 0x3585 2CFE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2CF8 stack[0] = stack[-1] // @2CF8 stack[-1] = 0x2cff // @2CF9 stack[1] = 0x30 // } // Block ends with call to 0x3585, returns to 0x2CFF label_2CFF: // Incoming return from call to 0x3585 at 0x2CFE // Inputs[4] // { // @2D02 stack[-1] // @2D03 stack[-2] // @2D04 stack[-3] // @2D06 memory[stack[-2]:stack[-2] + 0x20] // } 2CFF 5B JUMPDEST 2D00 60 PUSH1 0xf8 2D02 1B SHL 2D03 81 DUP2 2D04 83 DUP4 2D05 81 DUP2 2D06 51 MLOAD 2D07 81 DUP2 2D08 10 LT 2D09 61 PUSH2 0x2d14 2D0C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2D02 stack[-1] = stack[-1] << 0xf8 // @2D03 stack[0] = stack[-2] // @2D04 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x2d14, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_2D0D: // Incoming jump from 0x2D0C, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 2D0D 61 PUSH2 0x2d14 2D10 61 PUSH2 0x3840 2D13 56 *JUMP // Stack delta = +1 // Outputs[1] { @2D0D stack[0] = 0x2d14 } // Block ends with unconditional jump to 0x3840 label_2D14: // Incoming jump from 0x2D0C, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @2D17 stack[-1] // @2D18 stack[-2] // @2D19 stack[-3] // @2D49 stack[-8] // } 2D14 5B JUMPDEST 2D15 60 PUSH1 0x20 2D17 01 ADD 2D18 01 ADD 2D19 90 SWAP1 2D1A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2D3A 19 NOT 2D3B 16 AND 2D3C 90 SWAP1 2D3D 81 DUP2 2D3E 60 PUSH1 0x00 2D40 1A BYTE 2D41 90 SWAP1 2D42 53 MSTORE8 2D43 50 POP 2D44 61 PUSH2 0x2d4e 2D47 60 PUSH1 0x0a 2D49 86 DUP7 2D4A 61 PUSH2 0x35c7 2D4D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2D42 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @2D44 stack[-3] = 0x2d4e // @2D47 stack[-2] = 0x0a // @2D49 stack[-1] = stack[-8] // } // Block ends with call to 0x35c7, returns to 0x2D4E label_2D4E: // Incoming return from call to 0x35C7 at 0x2D4D // Inputs[2] // { // @2D4F stack[-1] // @2D4F stack[-6] // } 2D4E 5B JUMPDEST 2D4F 94 SWAP5 2D50 50 POP 2D51 61 PUSH2 0x2cd6 2D54 56 *JUMP // Stack delta = -1 // Outputs[1] { @2D4F stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x2cd6 label_2D55: // Incoming call from 0x28A0, returns to 0x1D21 // Inputs[2] // { // @2D58 stack[-1] // @2D59 memory[stack[-1]:stack[-1] + 0x20] // } 2D55 5B JUMPDEST 2D56 60 PUSH1 0x00 2D58 81 DUP2 2D59 51 MLOAD 2D5A 60 PUSH1 0x41 2D5C 14 EQ 2D5D 15 ISZERO 2D5E 61 PUSH2 0x2d89 2D61 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D56 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d89, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) label_2D62: // Incoming jump from 0x2D61, if not !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @2D64 stack[-2] // @2D66 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2D6B memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @2D70 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @2D77 stack[-3] // } 2D62 60 PUSH1 0x20 2D64 82 DUP3 2D65 01 ADD 2D66 51 MLOAD 2D67 60 PUSH1 0x40 2D69 83 DUP4 2D6A 01 ADD 2D6B 51 MLOAD 2D6C 60 PUSH1 0x60 2D6E 84 DUP5 2D6F 01 ADD 2D70 51 MLOAD 2D71 60 PUSH1 0x00 2D73 1A BYTE 2D74 61 PUSH2 0x2d7f 2D77 86 DUP7 2D78 82 DUP3 2D79 85 DUP6 2D7A 85 DUP6 2D7B 61 PUSH2 0x2df9 2D7E 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @2D66 stack[0] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2D6B stack[1] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @2D73 stack[2] = byte(memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20], 0x00) // @2D74 stack[3] = 0x2d7f // @2D77 stack[4] = stack[-3] // @2D78 stack[5] = byte(memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20], 0x00) // @2D79 stack[6] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2D7A stack[7] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with call to 0x2df9, returns to 0x2D7F label_2D7F: // Incoming return from call to 0x2DF9 at 0x2D7E // Inputs[2] // { // @2D80 stack[-5] // @2D80 stack[-1] // } 2D7F 5B JUMPDEST 2D80 93 SWAP4 2D81 50 POP 2D82 50 POP 2D83 50 POP 2D84 50 POP 2D85 61 PUSH2 0x0907 2D88 56 *JUMP // Stack delta = -4 // Outputs[1] { @2D80 stack[-5] = stack[-1] } // Block ends with unconditional jump to 0x0907 label_2D89: // Incoming jump from 0x2D61, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @2D8A stack[-2] // @2D8B memory[stack[-2]:stack[-2] + 0x20] // } 2D89 5B JUMPDEST 2D8A 81 DUP2 2D8B 51 MLOAD 2D8C 60 PUSH1 0x40 2D8E 14 EQ 2D8F 15 ISZERO 2D90 61 PUSH2 0x2db1 2D93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2db1, if !(0x40 == memory[stack[-2]:stack[-2] + 0x20]) label_2D94: // Incoming jump from 0x2D93, if not !(0x40 == memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @2D96 stack[-2] // @2D98 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2D9D memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @2DA1 stack[-3] // } 2D94 60 PUSH1 0x20 2D96 82 DUP3 2D97 01 ADD 2D98 51 MLOAD 2D99 60 PUSH1 0x40 2D9B 83 DUP4 2D9C 01 ADD 2D9D 51 MLOAD 2D9E 61 PUSH2 0x2da8 2DA1 85 DUP6 2DA2 83 DUP4 2DA3 83 DUP4 2DA4 61 PUSH2 0x2fa2 2DA7 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2D98 stack[0] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2D9D stack[1] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @2D9E stack[2] = 0x2da8 // @2DA1 stack[3] = stack[-3] // @2DA2 stack[4] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2DA3 stack[5] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with call to 0x2fa2, returns to 0x2DA8 label_2DA8: // Incoming return from call to 0x2FA2 at 0x2DA7 // Inputs[2] // { // @2DA9 stack[-4] // @2DA9 stack[-1] // } 2DA8 5B JUMPDEST 2DA9 92 SWAP3 2DAA 50 POP 2DAB 50 POP 2DAC 50 POP 2DAD 61 PUSH2 0x0907 2DB0 56 *JUMP // Stack delta = -3 // Outputs[1] { @2DA9 stack[-4] = stack[-1] } // Block ends with unconditional jump to 0x0907 label_2DB1: // Incoming jump from 0x2D93, if !(0x40 == memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @2DB4 memory[0x40:0x60] } 2DB1 5B JUMPDEST 2DB2 60 PUSH1 0x40 2DB4 51 MLOAD 2DB5 62 PUSH3 0x461bcd 2DB9 60 PUSH1 0xe5 2DBB 1B SHL 2DBC 81 DUP2 2DBD 52 MSTORE 2DBE 60 PUSH1 0x20 2DC0 60 PUSH1 0x04 2DC2 82 DUP3 2DC3 01 ADD 2DC4 52 MSTORE 2DC5 60 PUSH1 0x1f 2DC7 60 PUSH1 0x24 2DC9 82 DUP3 2DCA 01 ADD 2DCB 52 MSTORE 2DCC 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 2DED 60 PUSH1 0x44 2DEF 82 DUP3 2DF0 01 ADD 2DF1 52 MSTORE 2DF2 60 PUSH1 0x64 2DF4 01 ADD 2DF5 61 PUSH2 0x0a1a 2DF8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2DBD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2DC4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2DCB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @2DF1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @2DF4 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2DF9: // Incoming call from 0x2D7E, returns to 0x2D7F // Incoming call from 0x2FDA, returns to 0x2FDB // Inputs[1] { @2E1D stack[-1] } 2DF9 5B JUMPDEST 2DFA 60 PUSH1 0x00 2DFC 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 2E1D 82 DUP3 2E1E 11 GT 2E1F 15 ISZERO 2E20 61 PUSH2 0x2e76 2E23 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2DFA stack[0] = 0x00 } // Block ends with conditional jump to 0x2e76, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_2E24: // Incoming jump from 0x2E23, if not !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @2E26 memory[0x40:0x60] } 2E24 60 PUSH1 0x40 2E26 51 MLOAD 2E27 62 PUSH3 0x461bcd 2E2B 60 PUSH1 0xe5 2E2D 1B SHL 2E2E 81 DUP2 2E2F 52 MSTORE 2E30 60 PUSH1 0x20 2E32 60 PUSH1 0x04 2E34 82 DUP3 2E35 01 ADD 2E36 52 MSTORE 2E37 60 PUSH1 0x22 2E39 60 PUSH1 0x24 2E3B 82 DUP3 2E3C 01 ADD 2E3D 52 MSTORE 2E3E 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 2E5F 60 PUSH1 0x44 2E61 82 DUP3 2E62 01 ADD 2E63 52 MSTORE 2E64 61 PUSH2 0x7565 2E67 60 PUSH1 0xf0 2E69 1B SHL 2E6A 60 PUSH1 0x64 2E6C 82 DUP3 2E6D 01 ADD 2E6E 52 MSTORE 2E6F 60 PUSH1 0x84 2E71 01 ADD 2E72 61 PUSH2 0x0a1a 2E75 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2E2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2E36 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2E3D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @2E63 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @2E6E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @2E71 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2E76: // Incoming jump from 0x2E23, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @2E77 stack[-4] } 2E76 5B JUMPDEST 2E77 83 DUP4 2E78 60 PUSH1 0xff 2E7A 16 AND 2E7B 60 PUSH1 0x1b 2E7D 14 EQ 2E7E 80 DUP1 2E7F 61 PUSH2 0x2e8b 2E82 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E7D stack[0] = 0x1b == 0xff & stack[-4] } // Block ends with conditional jump to 0x2e8b, if 0x1b == 0xff & stack[-4] label_2E83: // Incoming jump from 0x2E82, if not 0x1b == 0xff & stack[-4] // Inputs[1] { @2E84 stack[-5] } 2E83 50 POP 2E84 83 DUP4 2E85 60 PUSH1 0xff 2E87 16 AND 2E88 60 PUSH1 0x1c 2E8A 14 EQ 2E8B 5B JUMPDEST 2E8C 61 PUSH2 0x2ee2 2E8F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ee2, if 0x1c == 0xff & stack[-5] label_2E90: // Incoming jump from 0x2E8F, if not stack[-1] // Incoming jump from 0x2E8F, if not 0x1c == 0xff & stack[-5] // Inputs[1] { @2E92 memory[0x40:0x60] } 2E90 60 PUSH1 0x40 2E92 51 MLOAD 2E93 62 PUSH3 0x461bcd 2E97 60 PUSH1 0xe5 2E99 1B SHL 2E9A 81 DUP2 2E9B 52 MSTORE 2E9C 60 PUSH1 0x20 2E9E 60 PUSH1 0x04 2EA0 82 DUP3 2EA1 01 ADD 2EA2 52 MSTORE 2EA3 60 PUSH1 0x22 2EA5 60 PUSH1 0x24 2EA7 82 DUP3 2EA8 01 ADD 2EA9 52 MSTORE 2EAA 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 2ECB 60 PUSH1 0x44 2ECD 82 DUP3 2ECE 01 ADD 2ECF 52 MSTORE 2ED0 61 PUSH2 0x7565 2ED3 60 PUSH1 0xf0 2ED5 1B SHL 2ED6 60 PUSH1 0x64 2ED8 82 DUP3 2ED9 01 ADD 2EDA 52 MSTORE 2EDB 60 PUSH1 0x84 2EDD 01 ADD 2EDE 61 PUSH2 0x0a1a 2EE1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2E9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2EA2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2EA9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @2ECF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @2EDA memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @2EDD stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2EE2: // Incoming jump from 0x2E8F, if stack[-1] // Incoming jump from 0x2E8F, if 0x1c == 0xff & stack[-5] // Inputs[9] // { // @2EE6 memory[0x40:0x60] // @2EF3 stack[-5] // @2EF8 stack[-4] // @2F05 stack[-3] // @2F0C stack[-2] // @2F19 memory[0x40:0x60] // @2F24 msg.gas // @2F25 address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @2F25 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2EE2 5B JUMPDEST 2EE3 60 PUSH1 0x40 2EE5 80 DUP1 2EE6 51 MLOAD 2EE7 60 PUSH1 0x00 2EE9 80 DUP1 2EEA 82 DUP3 2EEB 52 MSTORE 2EEC 60 PUSH1 0x20 2EEE 82 DUP3 2EEF 01 ADD 2EF0 80 DUP1 2EF1 84 DUP5 2EF2 52 MSTORE 2EF3 88 DUP9 2EF4 90 SWAP1 2EF5 52 MSTORE 2EF6 60 PUSH1 0xff 2EF8 87 DUP8 2EF9 16 AND 2EFA 92 SWAP3 2EFB 82 DUP3 2EFC 01 ADD 2EFD 92 SWAP3 2EFE 90 SWAP1 2EFF 92 SWAP3 2F00 52 MSTORE 2F01 60 PUSH1 0x60 2F03 81 DUP2 2F04 01 ADD 2F05 85 DUP6 2F06 90 SWAP1 2F07 52 MSTORE 2F08 60 PUSH1 0x80 2F0A 81 DUP2 2F0B 01 ADD 2F0C 84 DUP5 2F0D 90 SWAP1 2F0E 52 MSTORE 2F0F 60 PUSH1 0x01 2F11 90 SWAP1 2F12 60 PUSH1 0xa0 2F14 01 ADD 2F15 60 PUSH1 0x20 2F17 60 PUSH1 0x40 2F19 51 MLOAD 2F1A 60 PUSH1 0x20 2F1C 81 DUP2 2F1D 03 SUB 2F1E 90 SWAP1 2F1F 80 DUP1 2F20 84 DUP5 2F21 03 SUB 2F22 90 SWAP1 2F23 85 DUP6 2F24 5A GAS 2F25 FA STATICCALL 2F26 15 ISZERO 2F27 80 DUP1 2F28 15 ISZERO 2F29 61 PUSH2 0x2f36 2F2C 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @2EEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2EF2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @2EF5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-5] // @2EFF stack[0] = 0x00 // @2F00 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-4] & 0xff // @2F07 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-3] // @2F0E memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-2] // @2F11 stack[1] = 0x01 // @2F14 stack[2] = 0xa0 + memory[0x40:0x60] // @2F25 memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @2F26 stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x2f36, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_2F2D: // Incoming jump from 0x2F2C, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @2F2D returndata.length // @2F31 returndata[0x00:0x00 + returndata.length] // @2F32 returndata.length // @2F35 memory[0x00:0x00 + returndata.length] // } 2F2D 3D RETURNDATASIZE 2F2E 60 PUSH1 0x00 2F30 80 DUP1 2F31 3E RETURNDATACOPY 2F32 3D RETURNDATASIZE 2F33 60 PUSH1 0x00 2F35 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2F31 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2F35 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2F36: // Incoming jump from 0x2F2C, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @2F3B memory[0x40:0x60] // @2F40 memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @2F41 stack[-4] // } 2F36 5B JUMPDEST 2F37 50 POP 2F38 50 POP 2F39 60 PUSH1 0x40 2F3B 51 MLOAD 2F3C 60 PUSH1 0x1f 2F3E 19 NOT 2F3F 01 ADD 2F40 51 MLOAD 2F41 91 SWAP2 2F42 50 POP 2F43 50 POP 2F44 60 PUSH1 0x01 2F46 60 PUSH1 0x01 2F48 60 PUSH1 0xa0 2F4A 1B SHL 2F4B 03 SUB 2F4C 81 DUP2 2F4D 16 AND 2F4E 61 PUSH2 0x2f99 2F51 57 *JUMPI // Stack delta = -3 // Outputs[1] { @2F41 stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x2f99, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_2F52: // Incoming jump from 0x2F51, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2F54 memory[0x40:0x60] } 2F52 60 PUSH1 0x40 2F54 51 MLOAD 2F55 62 PUSH3 0x461bcd 2F59 60 PUSH1 0xe5 2F5B 1B SHL 2F5C 81 DUP2 2F5D 52 MSTORE 2F5E 60 PUSH1 0x20 2F60 60 PUSH1 0x04 2F62 82 DUP3 2F63 01 ADD 2F64 52 MSTORE 2F65 60 PUSH1 0x18 2F67 60 PUSH1 0x24 2F69 82 DUP3 2F6A 01 ADD 2F6B 52 MSTORE 2F6C 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 2F8D 60 PUSH1 0x44 2F8F 82 DUP3 2F90 01 ADD 2F91 52 MSTORE 2F92 60 PUSH1 0x64 2F94 01 ADD 2F95 61 PUSH2 0x0a1a 2F98 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2F5D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2F64 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2F6B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @2F91 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 // @2F94 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1a label_2F99: // Incoming jump from 0x2F51, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2F9A stack[-7] // @2F9A stack[-1] // @2F9B stack[-6] // } 2F99 5B JUMPDEST 2F9A 95 SWAP6 2F9B 94 SWAP5 2F9C 50 POP 2F9D 50 POP 2F9E 50 POP 2F9F 50 POP 2FA0 50 POP 2FA1 56 *JUMP // Stack delta = -6 // Outputs[1] { @2F9A stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_2FA2: // Incoming call from 0x2DA7, returns to 0x2DA8 // Inputs[3] // { // @2FC6 stack[-1] // @2FD3 stack[-3] // @2FD5 stack[-2] // } 2FA2 5B JUMPDEST 2FA3 60 PUSH1 0x00 2FA5 7F PUSH32 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2FC6 82 DUP3 2FC7 16 AND 2FC8 60 PUSH1 0xff 2FCA 83 DUP4 2FCB 90 SWAP1 2FCC 1C SHR 2FCD 60 PUSH1 0x1b 2FCF 01 ADD 2FD0 61 PUSH2 0x2fdb 2FD3 86 DUP7 2FD4 82 DUP3 2FD5 87 DUP8 2FD6 85 DUP6 2FD7 61 PUSH2 0x2df9 2FDA 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @2FA3 stack[0] = 0x00 // @2FC7 stack[1] = stack[-1] & 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @2FCF stack[2] = 0x1b + (stack[-1] >> 0xff) // @2FD0 stack[3] = 0x2fdb // @2FD3 stack[4] = stack[-3] // @2FD4 stack[5] = 0x1b + (stack[-1] >> 0xff) // @2FD5 stack[6] = stack[-2] // @2FD6 stack[7] = stack[-1] & 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // } // Block ends with call to 0x2df9, returns to 0x2FDB label_2FDB: // Incoming return from call to 0x30D4 at 0x3806 // Incoming return from call to 0x2DF9 at 0x2FDA // Inputs[3] // { // @2FDC stack[-8] // @2FDC stack[-1] // @2FDD stack[-7] // } 2FDB 5B JUMPDEST 2FDC 96 SWAP7 2FDD 95 SWAP6 2FDE 50 POP 2FDF 50 POP 2FE0 50 POP 2FE1 50 POP 2FE2 50 POP 2FE3 50 POP 2FE4 56 *JUMP // Stack delta = -7 // Outputs[1] { @2FDC stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2FE5: // Incoming jump from 0x142D // Incoming jump from 0x0EF2 // Inputs[2] // { // @2FE6 stack[-3] // @2FE8 storage[stack[-3]] // } 2FE5 5B JUMPDEST 2FE6 82 DUP3 2FE7 80 DUP1 2FE8 54 SLOAD 2FE9 61 PUSH2 0x2ff1 2FEC 90 SWAP1 2FED 61 PUSH2 0x3519 2FF0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2FE6 stack[0] = stack[-3] // @2FEC stack[1] = 0x2ff1 // @2FEC stack[2] = storage[stack[-3]] // } // Block ends with call to 0x3519, returns to 0x2FF1 label_2FF1: // Incoming return from call to 0x3519 at 0x2FF0 // Inputs[5] // { // @2FF2 stack[-1] // @2FF2 stack[-2] // @2FFA memory[0x00:0x20] // @3005 stack[-4] // @3006 stack[-3] // } 2FF1 5B JUMPDEST 2FF2 90 SWAP1 2FF3 60 PUSH1 0x00 2FF5 52 MSTORE 2FF6 60 PUSH1 0x20 2FF8 60 PUSH1 0x00 2FFA 20 SHA3 2FFB 90 SWAP1 2FFC 60 PUSH1 0x1f 2FFE 01 ADD 2FFF 60 PUSH1 0x20 3001 90 SWAP1 3002 04 DIV 3003 81 DUP2 3004 01 ADD 3005 92 SWAP3 3006 82 DUP3 3007 61 PUSH2 0x3013 300A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2FF5 memory[0x00:0x20] = stack[-2] // @2FFB stack[-2] = keccak256(memory[0x00:0x20]) // @3005 stack[-1] = stack[-4] // @3005 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x3013, if stack[-3] label_300B: // Incoming jump from 0x300A, if not stack[-3] // Inputs[1] { @300D stack[-5] } 300B 60 PUSH1 0x00 300D 85 DUP6 300E 55 SSTORE 300F 61 PUSH2 0x3059 3012 56 *JUMP // Stack delta = +0 // Outputs[1] { @300E storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x3059 label_3013: // Incoming jump from 0x300A, if stack[-3] // Inputs[1] { @3014 stack[-3] } 3013 5B JUMPDEST 3014 82 DUP3 3015 60 PUSH1 0x1f 3017 10 LT 3018 61 PUSH2 0x302c 301B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x302c, if 0x1f < stack[-3] label_301C: // Incoming jump from 0x301B, if not 0x1f < stack[-3] // Inputs[4] // { // @301C stack[-1] // @301D memory[stack[-1]:stack[-1] + 0x20] // @3022 stack[-3] // @3026 stack[-5] // } 301C 80 DUP1 301D 51 MLOAD 301E 60 PUSH1 0xff 3020 19 NOT 3021 16 AND 3022 83 DUP4 3023 80 DUP1 3024 01 ADD 3025 17 OR 3026 85 DUP6 3027 55 SSTORE 3028 61 PUSH2 0x3059 302B 56 *JUMP // Stack delta = +0 // Outputs[1] { @3027 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x3059 label_302C: // Incoming jump from 0x301B, if 0x1f < stack[-3] // Inputs[2] // { // @302D stack[-3] // @3033 stack[-5] // } 302C 5B JUMPDEST 302D 82 DUP3 302E 80 DUP1 302F 01 ADD 3030 60 PUSH1 0x01 3032 01 ADD 3033 85 DUP6 3034 55 SSTORE 3035 82 DUP3 3036 15 ISZERO 3037 61 PUSH2 0x3059 303A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3034 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x3059, if !stack[-3] label_303B: // Incoming jump from 0x303A, if not !stack[-3] // Inputs[2] // { // @303B stack[-1] // @303B stack[-3] // } 303B 91 SWAP2 303C 82 DUP3 303D 01 ADD 303E 5B JUMPDEST 303F 82 DUP3 3040 81 DUP2 3041 11 GT 3042 15 ISZERO 3043 61 PUSH2 0x3059 3046 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @303B stack[-3] = stack[-1] // @303D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x3059, if !(stack[-1] + stack[-3] > stack[-1]) label_3047: // Incoming jump from 0x3046, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x3046, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @3047 stack[-3] // @3048 memory[stack[-3]:stack[-3] + 0x20] // @3049 stack[-2] // @304B stack[-1] // } 3047 82 DUP3 3048 51 MLOAD 3049 82 DUP3 304A 55 SSTORE 304B 91 SWAP2 304C 60 PUSH1 0x20 304E 01 ADD 304F 91 SWAP2 3050 90 SWAP1 3051 60 PUSH1 0x01 3053 01 ADD 3054 90 SWAP1 3055 61 PUSH2 0x303e 3058 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @304A storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @304F stack[-3] = 0x20 + stack[-3] // @3054 stack[-2] = 0x01 + stack[-2] // @3054 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x303e label_3059: // Incoming jump from 0x3046, if !(stack[-1] > stack[-3]) // Incoming jump from 0x302B // Incoming jump from 0x3012 // Incoming jump from 0x3046, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x303A, if !stack[-3] // Inputs[3] // { // @305E stack[-4] // @305F stack[-3] // @3062 stack[-2] // } 3059 5B JUMPDEST 305A 50 POP 305B 61 PUSH2 0x0e82 305E 92 SWAP3 305F 91 SWAP2 3060 50 POP 3061 5B JUMPDEST 3062 80 DUP1 3063 82 DUP3 3064 11 GT 3065 15 ISZERO 3066 61 PUSH2 0x0e82 3069 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @305E stack[-4] = 0x0e82 // @305F stack[-3] = stack[-4] // } // Block ends with conditional call to 0x0e82, returns to 0x0E82, if !(stack[-4] > stack[-2]) label_306A: // Incoming jump from 0x3069, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x3069, if not !(stack[-4] > stack[-2]) // Inputs[1] { @306C stack[-1] } 306A 60 PUSH1 0x00 306C 81 DUP2 306D 55 SSTORE 306E 60 PUSH1 0x01 3070 01 ADD 3071 61 PUSH2 0x3061 3074 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @306D storage[stack[-1]] = 0x00 // @3070 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x3061 label_3075: // Incoming call from 0x30A7, returns to 0x1D21 // Inputs[1] { @307F stack[-1] } 3075 5B JUMPDEST 3076 60 PUSH1 0x01 3078 60 PUSH1 0x01 307A 60 PUSH1 0xe0 307C 1B SHL 307D 03 SUB 307E 19 NOT 307F 81 DUP2 3080 16 AND 3081 81 DUP2 3082 14 EQ 3083 61 PUSH2 0x1227 3086 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1227, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_3087: // Incoming jump from 0x3086, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @308A memory[0x00:0x00] } 3087 60 PUSH1 0x00 3089 80 DUP1 308A FD *REVERT // Stack delta = +0 // Outputs[1] { @308A revert(memory[0x00:0x00]); } // Block terminates label_308B: // Incoming call from 0x0311, returns to 0x0312 // Inputs[2] // { // @3090 stack[-1] // @3091 stack[-2] // } 308B 5B JUMPDEST 308C 60 PUSH1 0x00 308E 60 PUSH1 0x20 3090 82 DUP3 3091 84 DUP5 3092 03 SUB 3093 12 SLT 3094 15 ISZERO 3095 61 PUSH2 0x309d 3098 57 *JUMPI // Stack delta = +1 // Outputs[1] { @308C stack[0] = 0x00 } // Block ends with conditional jump to 0x309d, if !(stack[-2] - stack[-1] i< 0x20) label_3099: // Incoming jump from 0x3098, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @309C memory[0x00:0x00] } 3099 60 PUSH1 0x00 309B 80 DUP1 309C FD *REVERT // Stack delta = +0 // Outputs[1] { @309C revert(memory[0x00:0x00]); } // Block terminates label_309D: // Incoming jump from 0x3098, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @309E stack[-2] // @309F msg.data[stack[-2]:stack[-2] + 0x20] // } 309D 5B JUMPDEST 309E 81 DUP2 309F 35 CALLDATALOAD 30A0 61 PUSH2 0x1d21 30A3 81 DUP2 30A4 61 PUSH2 0x3075 30A7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @309F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @30A0 stack[1] = 0x1d21 // @30A3 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3075, returns to 0x1D21 label_30A8: // Incoming call from 0x30EB, returns to 0x30EC // Incoming call from 0x383F, returns to 0x3625 // Inputs[1] { @30AC stack[-3] } 30A8 5B JUMPDEST 30A9 60 PUSH1 0x00 30AB 5B JUMPDEST 30AC 83 DUP4 30AD 81 DUP2 30AE 10 LT 30AF 15 ISZERO 30B0 61 PUSH2 0x30c3 30B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @30A9 stack[0] = 0x00 } // Block ends with conditional jump to 0x30c3, if !(0x00 < stack[-3]) label_30B4: // Incoming jump from 0x30B3, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x30B3, if not !(0x00 < stack[-3]) // Inputs[4] // { // @30B4 stack[-2] // @30B5 stack[-1] // @30B7 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @30B8 stack[-3] // } 30B4 81 DUP2 30B5 81 DUP2 30B6 01 ADD 30B7 51 MLOAD 30B8 83 DUP4 30B9 82 DUP3 30BA 01 ADD 30BB 52 MSTORE 30BC 60 PUSH1 0x20 30BE 01 ADD 30BF 61 PUSH2 0x30ab 30C2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @30BB memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @30BE stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x30ab label_30C3: // Incoming jump from 0x30B3, if !(stack[-1] < stack[-4]) // Incoming jump from 0x30B3, if !(0x00 < stack[-3]) // Inputs[2] // { // @30C4 stack[-4] // @30C5 stack[-1] // } 30C3 5B JUMPDEST 30C4 83 DUP4 30C5 81 DUP2 30C6 11 GT 30C7 15 ISZERO 30C8 61 PUSH2 0x1c03 30CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c03, if !(stack[-1] > stack[-4]) label_30CC: // Incoming jump from 0x30CB, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @30D0 stack[-4] // @30D1 stack[-3] // @30D3 stack[-5] // } 30CC 50 POP 30CD 50 POP 30CE 60 PUSH1 0x00 30D0 91 SWAP2 30D1 01 ADD 30D2 52 MSTORE 30D3 56 *JUMP // Stack delta = -5 // Outputs[1] { @30D2 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_30D4: // Incoming call from 0x3112, returns to 0x1D21 // Incoming call from 0x3806, returns to 0x2FDB // Inputs[3] // { // @30D7 stack[-1] // @30D8 memory[stack[-1]:stack[-1] + 0x20] // @30DA stack[-2] // } 30D4 5B JUMPDEST 30D5 60 PUSH1 0x00 30D7 81 DUP2 30D8 51 MLOAD 30D9 80 DUP1 30DA 84 DUP5 30DB 52 MSTORE 30DC 61 PUSH2 0x30ec 30DF 81 DUP2 30E0 60 PUSH1 0x20 30E2 86 DUP7 30E3 01 ADD 30E4 60 PUSH1 0x20 30E6 86 DUP7 30E7 01 ADD 30E8 61 PUSH2 0x30a8 30EB 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @30D5 stack[0] = 0x00 // @30D8 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @30DB memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @30DC stack[2] = 0x30ec // @30DF stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @30E3 stack[4] = stack[-2] + 0x20 // @30E7 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x30a8, returns to 0x30EC label_30EC: // Incoming return from call to 0x30A8 at 0x30EB // Inputs[4] // { // @30EF stack[-1] // @30F4 stack[-4] // @30F5 stack[-2] // @30FB stack[-5] // } 30EC 5B JUMPDEST 30ED 60 PUSH1 0x1f 30EF 01 ADD 30F0 60 PUSH1 0x1f 30F2 19 NOT 30F3 16 AND 30F4 92 SWAP3 30F5 90 SWAP1 30F6 92 SWAP3 30F7 01 ADD 30F8 60 PUSH1 0x20 30FA 01 ADD 30FB 92 SWAP3 30FC 91 SWAP2 30FD 50 POP 30FE 50 POP 30FF 56 *JUMP // Stack delta = -4 // Outputs[1] { @30FB stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_3100: // Incoming jump from 0x034D // Inputs[2] // { // @3103 stack[-1] // @310E stack[-2] // } 3100 5B JUMPDEST 3101 60 PUSH1 0x20 3103 81 DUP2 3104 52 MSTORE 3105 60 PUSH1 0x00 3107 61 PUSH2 0x1d21 310A 60 PUSH1 0x20 310C 83 DUP4 310D 01 ADD 310E 84 DUP5 310F 61 PUSH2 0x30d4 3112 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @3104 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3105 stack[0] = 0x00 // @3107 stack[1] = 0x1d21 // @310D stack[2] = stack[-1] + 0x20 // @310E stack[3] = stack[-2] // } // Block ends with call to 0x30d4, returns to 0x1D21 label_3113: // Incoming call from 0x069B, returns to 0x069C // Incoming call from 0x0816, returns to 0x0817 // Incoming call from 0x0368, returns to 0x0369 // Incoming call from 0x0530, returns to 0x0531 // Incoming call from 0x0471, returns to 0x0472 // Incoming call from 0x0759, returns to 0x075A // Incoming call from 0x04C7, returns to 0x04C8 // Incoming call from 0x0666, returns to 0x0667 // Incoming call from 0x07BA, returns to 0x07BB // Inputs[2] // { // @3118 stack[-1] // @3119 stack[-2] // } 3113 5B JUMPDEST 3114 60 PUSH1 0x00 3116 60 PUSH1 0x20 3118 82 DUP3 3119 84 DUP5 311A 03 SUB 311B 12 SLT 311C 15 ISZERO 311D 61 PUSH2 0x3125 3120 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3114 stack[0] = 0x00 } // Block ends with conditional jump to 0x3125, if !(stack[-2] - stack[-1] i< 0x20) label_3121: // Incoming jump from 0x3120, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3124 memory[0x00:0x00] } 3121 60 PUSH1 0x00 3123 80 DUP1 3124 FD *REVERT // Stack delta = +0 // Outputs[1] { @3124 revert(memory[0x00:0x00]); } // Block terminates label_3125: // Incoming jump from 0x3120, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @3127 msg.data[stack[-2]:stack[-2] + 0x20] // @3127 stack[-2] // @3128 stack[-4] // @3129 stack[-3] // } 3125 5B JUMPDEST 3126 50 POP 3127 35 CALLDATALOAD 3128 91 SWAP2 3129 90 SWAP1 312A 50 POP 312B 56 *JUMP // Stack delta = -3 // Outputs[1] { @3128 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_312C: // Incoming call from 0x3370, returns to 0x3371 // Incoming call from 0x31A9, returns to 0x31AA // Incoming call from 0x3189, returns to 0x1D21 // Incoming call from 0x349B, returns to 0x349C // Incoming call from 0x3518, returns to 0x3386 // Incoming call from 0x315E, returns to 0x315F // Incoming call from 0x31B9, returns to 0x31BA // Incoming call from 0x348B, returns to 0x348C // Incoming call from 0x3508, returns to 0x3509 // Inputs[1] { @3135 stack[-1] } 312C 5B JUMPDEST 312D 60 PUSH1 0x01 312F 60 PUSH1 0x01 3131 60 PUSH1 0xa0 3133 1B SHL 3134 03 SUB 3135 81 DUP2 3136 16 AND 3137 81 DUP2 3138 14 EQ 3139 61 PUSH2 0x1227 313C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1227, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_313D: // Incoming jump from 0x313C, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @3140 memory[0x00:0x00] } 313D 60 PUSH1 0x00 313F 80 DUP1 3140 FD *REVERT // Stack delta = +0 // Outputs[1] { @3140 revert(memory[0x00:0x00]); } // Block terminates label_3141: // Incoming call from 0x0451, returns to 0x0452 // Incoming call from 0x03A0, returns to 0x03A1 // Inputs[2] // { // @3147 stack[-1] // @3148 stack[-2] // } 3141 5B JUMPDEST 3142 60 PUSH1 0x00 3144 80 DUP1 3145 60 PUSH1 0x40 3147 83 DUP4 3148 85 DUP6 3149 03 SUB 314A 12 SLT 314B 15 ISZERO 314C 61 PUSH2 0x3154 314F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3142 stack[0] = 0x00 // @3144 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3154, if !(stack[-2] - stack[-1] i< 0x40) label_3150: // Incoming jump from 0x314F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3153 memory[0x00:0x00] } 3150 60 PUSH1 0x00 3152 80 DUP1 3153 FD *REVERT // Stack delta = +0 // Outputs[1] { @3153 revert(memory[0x00:0x00]); } // Block terminates label_3154: // Incoming jump from 0x314F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3155 stack[-3] // @3156 msg.data[stack[-3]:stack[-3] + 0x20] // } 3154 5B JUMPDEST 3155 82 DUP3 3156 35 CALLDATALOAD 3157 61 PUSH2 0x315f 315A 81 DUP2 315B 61 PUSH2 0x312c 315E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3156 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3157 stack[1] = 0x315f // @315A stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x312c, returns to 0x315F label_315F: // Incoming return from call to 0x312C at 0x315E // Inputs[5] // { // @3160 stack[-6] // @3160 stack[-1] // @3163 stack[-4] // @3167 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @3168 stack[-5] // } 315F 5B JUMPDEST 3160 94 SWAP5 3161 60 PUSH1 0x20 3163 93 SWAP4 3164 90 SWAP1 3165 93 SWAP4 3166 01 ADD 3167 35 CALLDATALOAD 3168 93 SWAP4 3169 50 POP 316A 50 POP 316B 50 POP 316C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3160 stack[-6] = stack[-1] // @3168 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_316D: // Incoming call from 0x0411, returns to 0x0412 // Incoming call from 0x056E, returns to 0x056F // Incoming call from 0x05CE, returns to 0x05CF // Incoming call from 0x05FB, returns to 0x05FC // Incoming call from 0x0836, returns to 0x0837 // Inputs[2] // { // @3172 stack[-1] // @3173 stack[-2] // } 316D 5B JUMPDEST 316E 60 PUSH1 0x00 3170 60 PUSH1 0x20 3172 82 DUP3 3173 84 DUP5 3174 03 SUB 3175 12 SLT 3176 15 ISZERO 3177 61 PUSH2 0x317f 317A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @316E stack[0] = 0x00 } // Block ends with conditional jump to 0x317f, if !(stack[-2] - stack[-1] i< 0x20) label_317B: // Incoming jump from 0x317A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @317E memory[0x00:0x00] } 317B 60 PUSH1 0x00 317D 80 DUP1 317E FD *REVERT // Stack delta = +0 // Outputs[1] { @317E revert(memory[0x00:0x00]); } // Block terminates label_317F: // Incoming jump from 0x317A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3180 stack[-2] // @3181 msg.data[stack[-2]:stack[-2] + 0x20] // } 317F 5B JUMPDEST 3180 81 DUP2 3181 35 CALLDATALOAD 3182 61 PUSH2 0x1d21 3185 81 DUP2 3186 61 PUSH2 0x312c 3189 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3181 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @3182 stack[1] = 0x1d21 // @3185 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x312c, returns to 0x1D21 label_318A: // Incoming call from 0x0431, returns to 0x0432 // Incoming call from 0x0491, returns to 0x0492 // Inputs[2] // { // @3192 stack[-1] // @3193 stack[-2] // } 318A 5B JUMPDEST 318B 60 PUSH1 0x00 318D 80 DUP1 318E 60 PUSH1 0x00 3190 60 PUSH1 0x60 3192 84 DUP5 3193 86 DUP7 3194 03 SUB 3195 12 SLT 3196 15 ISZERO 3197 61 PUSH2 0x319f 319A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @318B stack[0] = 0x00 // @318D stack[1] = 0x00 // @318E stack[2] = 0x00 // } // Block ends with conditional jump to 0x319f, if !(stack[-2] - stack[-1] i< 0x60) label_319B: // Incoming jump from 0x319A, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @319E memory[0x00:0x00] } 319B 60 PUSH1 0x00 319D 80 DUP1 319E FD *REVERT // Stack delta = +0 // Outputs[1] { @319E revert(memory[0x00:0x00]); } // Block terminates label_319F: // Incoming jump from 0x319A, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @31A0 stack[-4] // @31A1 msg.data[stack[-4]:stack[-4] + 0x20] // } 319F 5B JUMPDEST 31A0 83 DUP4 31A1 35 CALLDATALOAD 31A2 61 PUSH2 0x31aa 31A5 81 DUP2 31A6 61 PUSH2 0x312c 31A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @31A1 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @31A2 stack[1] = 0x31aa // @31A5 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x312c, returns to 0x31AA label_31AA: // Incoming return from call to 0x312C at 0x31A9 // Inputs[4] // { // @31AB stack[-1] // @31AB stack[-4] // @31AF stack[-5] // @31B1 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 31AA 5B JUMPDEST 31AB 92 SWAP3 31AC 50 POP 31AD 60 PUSH1 0x20 31AF 84 DUP5 31B0 01 ADD 31B1 35 CALLDATALOAD 31B2 61 PUSH2 0x31ba 31B5 81 DUP2 31B6 61 PUSH2 0x312c 31B9 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @31AB stack[-4] = stack[-1] // @31B1 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @31B2 stack[0] = 0x31ba // @31B5 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x312c, returns to 0x31BA label_31BA: // Incoming return from call to 0x312C at 0x31B9 // Inputs[6] // { // @31BB stack[-1] // @31BB stack[-4] // @31BC stack[-7] // @31BE stack[-6] // @31C4 stack[-5] // @31C8 msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 31BA 5B JUMPDEST 31BB 92 SWAP3 31BC 95 SWAP6 31BD 92 SWAP3 31BE 94 SWAP5 31BF 50 POP 31C0 50 POP 31C1 50 POP 31C2 60 PUSH1 0x40 31C4 91 SWAP2 31C5 90 SWAP1 31C6 91 SWAP2 31C7 01 ADD 31C8 35 CALLDATALOAD 31C9 90 SWAP1 31CA 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @31BC stack[-7] = stack[-4] // @31BE stack[-6] = stack[-1] // @31C9 stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_31CB: // Incoming jump from 0x2CA7 // Incoming jump from 0x31FB // Incoming jump from 0x3223 // Inputs[1] { @31E0 memory[0x00:0x24] } 31CB 5B JUMPDEST 31CC 63 PUSH4 0x4e487b71 31D1 60 PUSH1 0xe0 31D3 1B SHL 31D4 60 PUSH1 0x00 31D6 52 MSTORE 31D7 60 PUSH1 0x41 31D9 60 PUSH1 0x04 31DB 52 MSTORE 31DC 60 PUSH1 0x24 31DE 60 PUSH1 0x00 31E0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @31D6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @31DB memory[0x04:0x24] = 0x41 // @31E0 revert(memory[0x00:0x24]); // } // Block terminates label_31E1: // Incoming call from 0x3276, returns to 0x1D21 // Incoming call from 0x34DE, returns to 0x34DF // Inputs[1] { @31EE stack[-2] } 31E1 5B JUMPDEST 31E2 60 PUSH1 0x00 31E4 67 PUSH8 0xffffffffffffffff 31ED 80 DUP1 31EE 84 DUP5 31EF 11 GT 31F0 15 ISZERO 31F1 61 PUSH2 0x31fc 31F4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @31E2 stack[0] = 0x00 // @31E4 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x31fc, if !(stack[-2] > 0xffffffffffffffff) label_31F5: // Incoming jump from 0x31F4, if not !(stack[-2] > 0xffffffffffffffff) 31F5 61 PUSH2 0x31fc 31F8 61 PUSH2 0x31cb 31FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @31F5 stack[0] = 0x31fc } // Block ends with unconditional jump to 0x31cb label_31FC: // Incoming jump from 0x31F4, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @31FF memory[0x40:0x60] // @3202 stack[-4] // @3211 stack[-1] // } 31FC 5B JUMPDEST 31FD 60 PUSH1 0x40 31FF 51 MLOAD 3200 60 PUSH1 0x1f 3202 85 DUP6 3203 01 ADD 3204 60 PUSH1 0x1f 3206 19 NOT 3207 90 SWAP1 3208 81 DUP2 3209 16 AND 320A 60 PUSH1 0x3f 320C 01 ADD 320D 16 AND 320E 81 DUP2 320F 01 ADD 3210 90 SWAP1 3211 82 DUP3 3212 82 DUP3 3213 11 GT 3214 81 DUP2 3215 83 DUP4 3216 10 LT 3217 17 OR 3218 15 ISZERO 3219 61 PUSH2 0x3224 321C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3210 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @3210 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x3224, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_321D: // Incoming jump from 0x321C, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 321D 61 PUSH2 0x3224 3220 61 PUSH2 0x31cb 3223 56 *JUMP // Stack delta = +1 // Outputs[1] { @321D stack[0] = 0x3224 } // Block ends with unconditional jump to 0x31cb label_3224: // Incoming jump from 0x321C, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @3225 stack[-2] // @3229 stack[-1] // @322A stack[-4] // @322C stack[-6] // @322F stack[-7] // @3231 stack[-5] // } 3224 5B JUMPDEST 3225 81 DUP2 3226 60 PUSH1 0x40 3228 52 MSTORE 3229 80 DUP1 322A 93 SWAP4 322B 50 POP 322C 85 DUP6 322D 81 DUP2 322E 52 MSTORE 322F 86 DUP7 3230 86 DUP7 3231 86 DUP7 3232 01 ADD 3233 11 GT 3234 15 ISZERO 3235 61 PUSH2 0x323d 3238 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @3228 memory[0x40:0x60] = stack[-2] // @322A stack[-4] = stack[-1] // @322E memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x323d, if !(stack[-5] + stack[-6] > stack[-7]) label_3239: // Incoming jump from 0x3238, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @323C memory[0x00:0x00] } 3239 60 PUSH1 0x00 323B 80 DUP1 323C FD *REVERT // Stack delta = +0 // Outputs[1] { @323C revert(memory[0x00:0x00]); } // Block terminates label_323D: // Incoming jump from 0x3238, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @323E stack[-6] // @323F stack[-5] // @3242 stack[-1] // @3244 msg.data[stack[-5]:stack[-5] + stack[-6]] // @3251 stack[-8] // @3251 stack[-4] // @3252 stack[-7] // } 323D 5B JUMPDEST 323E 85 DUP6 323F 85 DUP6 3240 60 PUSH1 0x20 3242 83 DUP4 3243 01 ADD 3244 37 CALLDATACOPY 3245 60 PUSH1 0x00 3247 60 PUSH1 0x20 3249 87 DUP8 324A 83 DUP4 324B 01 ADD 324C 01 ADD 324D 52 MSTORE 324E 50 POP 324F 50 POP 3250 50 POP 3251 93 SWAP4 3252 92 SWAP3 3253 50 POP 3254 50 POP 3255 50 POP 3256 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @3244 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @324D memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @3251 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_3257: // Incoming call from 0x3427, returns to 0x3428 // Incoming call from 0x32AB, returns to 0x2708 // Inputs[2] // { // @325A stack[-2] // @325D stack[-1] // } 3257 5B JUMPDEST 3258 60 PUSH1 0x00 325A 82 DUP3 325B 60 PUSH1 0x1f 325D 83 DUP4 325E 01 ADD 325F 12 SLT 3260 61 PUSH2 0x3268 3263 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3258 stack[0] = 0x00 } // Block ends with conditional jump to 0x3268, if stack[-1] + 0x1f i< stack[-2] label_3264: // Incoming jump from 0x3263, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @3267 memory[0x00:0x00] } 3264 60 PUSH1 0x00 3266 80 DUP1 3267 FD *REVERT // Stack delta = +0 // Outputs[1] { @3267 revert(memory[0x00:0x00]); } // Block terminates label_3268: // Incoming jump from 0x3263, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @326C stack[-3] // @326D stack[-2] // @326E msg.data[stack[-2]:stack[-2] + 0x20] // } 3268 5B JUMPDEST 3269 61 PUSH2 0x1d21 326C 83 DUP4 326D 83 DUP4 326E 35 CALLDATALOAD 326F 60 PUSH1 0x20 3271 85 DUP6 3272 01 ADD 3273 61 PUSH2 0x31e1 3276 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3269 stack[0] = 0x1d21 // @326C stack[1] = stack[-3] // @326E stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @3272 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x31e1, returns to 0x1D21 label_3277: // Incoming call from 0x04E7, returns to 0x04E8 // Incoming call from 0x0628, returns to 0x0629 // Inputs[2] // { // @327C stack[-1] // @327D stack[-2] // } 3277 5B JUMPDEST 3278 60 PUSH1 0x00 327A 60 PUSH1 0x20 327C 82 DUP3 327D 84 DUP5 327E 03 SUB 327F 12 SLT 3280 15 ISZERO 3281 61 PUSH2 0x3289 3284 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3278 stack[0] = 0x00 } // Block ends with conditional jump to 0x3289, if !(stack[-2] - stack[-1] i< 0x20) label_3285: // Incoming jump from 0x3284, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3288 memory[0x00:0x00] } 3285 60 PUSH1 0x00 3287 80 DUP1 3288 FD *REVERT // Stack delta = +0 // Outputs[1] { @3288 revert(memory[0x00:0x00]); } // Block terminates label_3289: // Incoming jump from 0x3284, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @328A stack[-2] // @328B msg.data[stack[-2]:stack[-2] + 0x20] // } 3289 5B JUMPDEST 328A 81 DUP2 328B 35 CALLDATALOAD 328C 67 PUSH8 0xffffffffffffffff 3295 81 DUP2 3296 11 GT 3297 15 ISZERO 3298 61 PUSH2 0x32a0 329B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @328B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x32a0, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_329C: // Incoming jump from 0x329B, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @329F memory[0x00:0x00] } 329C 60 PUSH1 0x00 329E 80 DUP1 329F FD *REVERT // Stack delta = +0 // Outputs[1] { @329F revert(memory[0x00:0x00]); } // Block terminates label_32A0: // Incoming jump from 0x329B, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @32A4 stack[-4] // @32A5 stack[-1] // @32A6 stack[-3] // } 32A0 5B JUMPDEST 32A1 61 PUSH2 0x2708 32A4 84 DUP5 32A5 82 DUP3 32A6 85 DUP6 32A7 01 ADD 32A8 61 PUSH2 0x3257 32AB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @32A1 stack[0] = 0x2708 // @32A4 stack[1] = stack[-4] // @32A7 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x3257, returns to 0x2708 label_32AC: // Incoming call from 0x33D0, returns to 0x33D1 // Incoming call from 0x3336, returns to 0x3337 // Incoming call from 0x3458, returns to 0x3459 // Inputs[2] // { // @32B0 stack[-2] // @32B3 stack[-1] // } 32AC 5B JUMPDEST 32AD 60 PUSH1 0x00 32AF 80 DUP1 32B0 83 DUP4 32B1 60 PUSH1 0x1f 32B3 84 DUP5 32B4 01 ADD 32B5 12 SLT 32B6 61 PUSH2 0x32be 32B9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @32AD stack[0] = 0x00 // @32AF stack[1] = 0x00 // } // Block ends with conditional jump to 0x32be, if stack[-1] + 0x1f i< stack[-2] label_32BA: // Incoming jump from 0x32B9, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @32BD memory[0x00:0x00] } 32BA 60 PUSH1 0x00 32BC 80 DUP1 32BD FD *REVERT // Stack delta = +0 // Outputs[1] { @32BD revert(memory[0x00:0x00]); } // Block terminates label_32BE: // Incoming jump from 0x32B9, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @32C0 stack[-3] // @32C1 msg.data[stack[-3]:stack[-3] + 0x20] // } 32BE 5B JUMPDEST 32BF 50 POP 32C0 81 DUP2 32C1 35 CALLDATALOAD 32C2 67 PUSH8 0xffffffffffffffff 32CB 81 DUP2 32CC 11 GT 32CD 15 ISZERO 32CE 61 PUSH2 0x32d6 32D1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @32C1 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x32d6, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_32D2: // Incoming jump from 0x32D1, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @32D5 memory[0x00:0x00] } 32D2 60 PUSH1 0x00 32D4 80 DUP1 32D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @32D5 revert(memory[0x00:0x00]); } // Block terminates label_32D6: // Incoming jump from 0x32D1, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @32D9 stack[-3] // @32DB stack[-2] // @32DD stack[-4] // @32E0 stack[-1] // } 32D6 5B JUMPDEST 32D7 60 PUSH1 0x20 32D9 83 DUP4 32DA 01 ADD 32DB 91 SWAP2 32DC 50 POP 32DD 83 DUP4 32DE 60 PUSH1 0x20 32E0 82 DUP3 32E1 85 DUP6 32E2 01 ADD 32E3 01 ADD 32E4 11 GT 32E5 15 ISZERO 32E6 61 PUSH2 0x32ee 32E9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @32DB stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x32ee, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_32EA: // Incoming jump from 0x32E9, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @32ED memory[0x00:0x00] } 32EA 60 PUSH1 0x00 32EC 80 DUP1 32ED FD *REVERT // Stack delta = +0 // Outputs[1] { @32ED revert(memory[0x00:0x00]); } // Block terminates label_32EE: // Incoming jump from 0x32E9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[5] // { // @32EF stack[-4] // @32EF stack[-1] // @32F1 stack[-2] // @32F1 stack[-5] // @32F2 stack[-3] // } 32EE 5B JUMPDEST 32EF 92 SWAP3 32F0 50 POP 32F1 92 SWAP3 32F2 90 SWAP1 32F3 50 POP 32F4 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @32EF stack[-4] = stack[-1] // @32F1 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_32F5: // Incoming call from 0x0510, returns to 0x0511 // Inputs[2] // { // @3300 stack[-1] // @3301 stack[-2] // } 32F5 5B JUMPDEST 32F6 60 PUSH1 0x00 32F8 80 DUP1 32F9 60 PUSH1 0x00 32FB 80 DUP1 32FC 60 PUSH1 0x00 32FE 60 PUSH1 0x80 3300 86 DUP7 3301 88 DUP9 3302 03 SUB 3303 12 SLT 3304 15 ISZERO 3305 61 PUSH2 0x330d 3308 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @32F6 stack[0] = 0x00 // @32F8 stack[1] = 0x00 // @32F9 stack[2] = 0x00 // @32FB stack[3] = 0x00 // @32FC stack[4] = 0x00 // } // Block ends with conditional jump to 0x330d, if !(stack[-2] - stack[-1] i< 0x80) label_3309: // Incoming jump from 0x3308, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @330C memory[0x00:0x00] } 3309 60 PUSH1 0x00 330B 80 DUP1 330C FD *REVERT // Stack delta = +0 // Outputs[1] { @330C revert(memory[0x00:0x00]); } // Block terminates label_330D: // Incoming jump from 0x3308, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[4] // { // @330E stack[-6] // @330F msg.data[stack[-6]:stack[-6] + 0x20] // @3310 stack[-5] // @3316 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 330D 5B JUMPDEST 330E 85 DUP6 330F 35 CALLDATALOAD 3310 94 SWAP5 3311 50 POP 3312 60 PUSH1 0x20 3314 86 DUP7 3315 01 ADD 3316 35 CALLDATALOAD 3317 67 PUSH8 0xffffffffffffffff 3320 81 DUP2 3321 11 GT 3322 15 ISZERO 3323 61 PUSH2 0x332b 3326 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @3310 stack[-5] = msg.data[stack[-6]:stack[-6] + 0x20] // @3316 stack[0] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x332b, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > 0xffffffffffffffff) label_3327: // Incoming jump from 0x3326, if not !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @332A memory[0x00:0x00] } 3327 60 PUSH1 0x00 3329 80 DUP1 332A FD *REVERT // Stack delta = +0 // Outputs[1] { @332A revert(memory[0x00:0x00]); } // Block terminates label_332B: // Incoming jump from 0x3326, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @332F stack[-8] // @3330 stack[-1] // @3331 stack[-7] // } 332B 5B JUMPDEST 332C 61 PUSH2 0x3337 332F 88 DUP9 3330 82 DUP3 3331 89 DUP10 3332 01 ADD 3333 61 PUSH2 0x32ac 3336 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @332C stack[0] = 0x3337 // @332F stack[1] = stack[-8] // @3332 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x32ac, returns to 0x3337 label_3337: // Incoming return from call to 0x32AC at 0x3336 // Inputs[10] // { // @3338 stack[-1] // @3338 stack[-8] // @3339 stack[-11] // @333A stack[-2] // @333B stack[-10] // @333E stack[-9] // @3343 msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @334A msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @334B stack[-7] // @334D stack[-6] // } 3337 5B JUMPDEST 3338 96 SWAP7 3339 99 SWAP10 333A 90 SWAP1 333B 98 SWAP9 333C 50 POP 333D 95 SWAP6 333E 96 SWAP7 333F 60 PUSH1 0x40 3341 81 DUP2 3342 01 ADD 3343 35 CALLDATALOAD 3344 96 SWAP7 3345 60 PUSH1 0x60 3347 90 SWAP1 3348 91 SWAP2 3349 01 ADD 334A 35 CALLDATALOAD 334B 95 SWAP6 334C 50 POP 334D 93 SWAP4 334E 50 POP 334F 50 POP 3350 50 POP 3351 50 POP 3352 56 *JUMP // Stack delta = -6 // Outputs[5] // { // @3339 stack[-11] = stack[-8] // @333B stack[-10] = stack[-2] // @333E stack[-9] = stack[-1] // @3344 stack[-8] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @334B stack[-7] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with unconditional jump to stack[-11] label_3353: // Incoming call from 0x06D1, returns to 0x06D2 // Inputs[2] // { // @3359 stack[-1] // @335A stack[-2] // } 3353 5B JUMPDEST 3354 60 PUSH1 0x00 3356 80 DUP1 3357 60 PUSH1 0x40 3359 83 DUP4 335A 85 DUP6 335B 03 SUB 335C 12 SLT 335D 15 ISZERO 335E 61 PUSH2 0x3366 3361 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3354 stack[0] = 0x00 // @3356 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3366, if !(stack[-2] - stack[-1] i< 0x40) label_3362: // Incoming jump from 0x3361, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3365 memory[0x00:0x00] } 3362 60 PUSH1 0x00 3364 80 DUP1 3365 FD *REVERT // Stack delta = +0 // Outputs[1] { @3365 revert(memory[0x00:0x00]); } // Block terminates label_3366: // Incoming jump from 0x3361, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3367 stack[-3] // @3368 msg.data[stack[-3]:stack[-3] + 0x20] // } 3366 5B JUMPDEST 3367 82 DUP3 3368 35 CALLDATALOAD 3369 61 PUSH2 0x3371 336C 81 DUP2 336D 61 PUSH2 0x312c 3370 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3368 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3369 stack[1] = 0x3371 // @336C stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x312c, returns to 0x3371 label_3371: // Incoming return from call to 0x312C at 0x3370 // Inputs[4] // { // @3372 stack[-3] // @3372 stack[-1] // @3376 stack[-4] // @3378 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 3371 5B JUMPDEST 3372 91 SWAP2 3373 50 POP 3374 60 PUSH1 0x20 3376 83 DUP4 3377 01 ADD 3378 35 CALLDATALOAD 3379 80 DUP1 337A 15 ISZERO 337B 15 ISZERO 337C 81 DUP2 337D 14 EQ 337E 61 PUSH2 0x3386 3381 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3372 stack[-3] = stack[-1] // @3378 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x3386, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_3382: // Incoming jump from 0x3381, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @3385 memory[0x00:0x00] } 3382 60 PUSH1 0x00 3384 80 DUP1 3385 FD *REVERT // Stack delta = +0 // Outputs[1] { @3385 revert(memory[0x00:0x00]); } // Block terminates label_3386: // Incoming jump from 0x3381, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Incoming return from call to 0x312C at 0x3518 // Inputs[6] // { // @3387 stack[-1] // @3388 stack[-2] // @338B stack[-5] // @338D stack[-6] // @338D stack[-3] // @338E stack[-4] // } 3386 5B JUMPDEST 3387 80 DUP1 3388 91 SWAP2 3389 50 POP 338A 50 POP 338B 92 SWAP3 338C 50 POP 338D 92 SWAP3 338E 90 SWAP1 338F 50 POP 3390 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @338B stack[-5] = stack[-1] // @338D stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_3391: // Incoming call from 0x06E4, returns to 0x06E5 // Inputs[2] // { // @339A stack[-1] // @339B stack[-2] // } 3391 5B JUMPDEST 3392 60 PUSH1 0x00 3394 80 DUP1 3395 60 PUSH1 0x00 3397 80 DUP1 3398 60 PUSH1 0x60 339A 85 DUP6 339B 87 DUP8 339C 03 SUB 339D 12 SLT 339E 15 ISZERO 339F 61 PUSH2 0x33a7 33A2 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @3392 stack[0] = 0x00 // @3394 stack[1] = 0x00 // @3395 stack[2] = 0x00 // @3397 stack[3] = 0x00 // } // Block ends with conditional jump to 0x33a7, if !(stack[-2] - stack[-1] i< 0x60) label_33A3: // Incoming jump from 0x33A2, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @33A6 memory[0x00:0x00] } 33A3 60 PUSH1 0x00 33A5 80 DUP1 33A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @33A6 revert(memory[0x00:0x00]); } // Block terminates label_33A7: // Incoming jump from 0x33A2, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[4] // { // @33A8 stack[-5] // @33A9 msg.data[stack[-5]:stack[-5] + 0x20] // @33AA stack[-4] // @33B0 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 33A7 5B JUMPDEST 33A8 84 DUP5 33A9 35 CALLDATALOAD 33AA 93 SWAP4 33AB 50 POP 33AC 60 PUSH1 0x20 33AE 85 DUP6 33AF 01 ADD 33B0 35 CALLDATALOAD 33B1 67 PUSH8 0xffffffffffffffff 33BA 81 DUP2 33BB 11 GT 33BC 15 ISZERO 33BD 61 PUSH2 0x33c5 33C0 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @33AA stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @33B0 stack[0] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x33c5, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_33C1: // Incoming jump from 0x33C0, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @33C4 memory[0x00:0x00] } 33C1 60 PUSH1 0x00 33C3 80 DUP1 33C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @33C4 revert(memory[0x00:0x00]); } // Block terminates label_33C5: // Incoming jump from 0x33C0, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @33C9 stack[-7] // @33CA stack[-1] // @33CB stack[-6] // } 33C5 5B JUMPDEST 33C6 61 PUSH2 0x33d1 33C9 87 DUP8 33CA 82 DUP3 33CB 88 DUP9 33CC 01 ADD 33CD 61 PUSH2 0x32ac 33D0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @33C6 stack[0] = 0x33d1 // @33C9 stack[1] = stack[-7] // @33CC stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x32ac, returns to 0x33D1 label_33D1: // Incoming return from call to 0x32AC at 0x33D0 // Inputs[8] // { // @33D2 stack[-1] // @33D2 stack[-7] // @33D3 stack[-10] // @33D4 stack[-2] // @33D5 stack[-9] // @33D8 stack[-8] // @33DC msg.data[0x40 + stack[-8]:0x40 + stack[-8] + 0x20] // @33DE stack[-6] // } 33D1 5B JUMPDEST 33D2 95 SWAP6 33D3 98 SWAP9 33D4 90 SWAP1 33D5 97 SWAP8 33D6 50 POP 33D7 94 SWAP5 33D8 95 SWAP6 33D9 60 PUSH1 0x40 33DB 01 ADD 33DC 35 CALLDATALOAD 33DD 94 SWAP5 33DE 93 SWAP4 33DF 50 POP 33E0 50 POP 33E1 50 POP 33E2 50 POP 33E3 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @33D3 stack[-10] = stack[-7] // @33D5 stack[-9] = stack[-2] // @33D8 stack[-8] = stack[-1] // @33DD stack[-7] = msg.data[0x40 + stack[-8]:0x40 + stack[-8] + 0x20] // } // Block ends with unconditional jump to stack[-10] label_33E4: // Incoming call from 0x0704, returns to 0x0705 // Inputs[2] // { // @33F0 stack[-1] // @33F1 stack[-2] // } 33E4 5B JUMPDEST 33E5 60 PUSH1 0x00 33E7 80 DUP1 33E8 60 PUSH1 0x00 33EA 80 DUP1 33EB 60 PUSH1 0x00 33ED 80 DUP1 33EE 60 PUSH1 0xa0 33F0 87 DUP8 33F1 89 DUP10 33F2 03 SUB 33F3 12 SLT 33F4 15 ISZERO 33F5 61 PUSH2 0x33fd 33F8 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @33E5 stack[0] = 0x00 // @33E7 stack[1] = 0x00 // @33E8 stack[2] = 0x00 // @33EA stack[3] = 0x00 // @33EB stack[4] = 0x00 // @33ED stack[5] = 0x00 // } // Block ends with conditional jump to 0x33fd, if !(stack[-2] - stack[-1] i< 0xa0) label_33F9: // Incoming jump from 0x33F8, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @33FC memory[0x00:0x00] } 33F9 60 PUSH1 0x00 33FB 80 DUP1 33FC FD *REVERT // Stack delta = +0 // Outputs[1] { @33FC revert(memory[0x00:0x00]); } // Block terminates label_33FD: // Incoming jump from 0x33F8, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[4] // { // @33FE stack[-7] // @33FF msg.data[stack[-7]:stack[-7] + 0x20] // @3400 stack[-6] // @3406 msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 33FD 5B JUMPDEST 33FE 86 DUP7 33FF 35 CALLDATALOAD 3400 95 SWAP6 3401 50 POP 3402 60 PUSH1 0x20 3404 87 DUP8 3405 01 ADD 3406 35 CALLDATALOAD 3407 67 PUSH8 0xffffffffffffffff 3410 80 DUP1 3411 82 DUP3 3412 11 GT 3413 15 ISZERO 3414 61 PUSH2 0x341c 3417 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @3400 stack[-6] = msg.data[stack[-7]:stack[-7] + 0x20] // @3406 stack[0] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @3407 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x341c, if !(msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] > 0xffffffffffffffff) label_3418: // Incoming jump from 0x3417, if not !(msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @341B memory[0x00:0x00] } 3418 60 PUSH1 0x00 341A 80 DUP1 341B FD *REVERT // Stack delta = +0 // Outputs[1] { @341B revert(memory[0x00:0x00]); } // Block terminates label_341C: // Incoming jump from 0x3417, if !(msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3420 stack[-10] // @3421 stack[-2] // @3422 stack[-9] // } 341C 5B JUMPDEST 341D 61 PUSH2 0x3428 3420 8A DUP11 3421 83 DUP4 3422 8B DUP12 3423 01 ADD 3424 61 PUSH2 0x3257 3427 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @341D stack[0] = 0x3428 // @3420 stack[1] = stack[-10] // @3423 stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x3257, returns to 0x3428 label_3428: // Incoming return from call to 0x3257 at 0x3427 // Inputs[10] // { // @3429 stack[-8] // @3429 stack[-1] // @342D stack[-10] // @342F msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] // @3430 stack[-7] // @3436 msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @3437 stack[-6] // @343D msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @343E stack[-3] // @3440 stack[-2] // } 3428 5B JUMPDEST 3429 96 SWAP7 342A 50 POP 342B 60 PUSH1 0x40 342D 89 DUP10 342E 01 ADD 342F 35 CALLDATALOAD 3430 95 SWAP6 3431 50 POP 3432 60 PUSH1 0x60 3434 89 DUP10 3435 01 ADD 3436 35 CALLDATALOAD 3437 94 SWAP5 3438 50 POP 3439 60 PUSH1 0x80 343B 89 DUP10 343C 01 ADD 343D 35 CALLDATALOAD 343E 91 SWAP2 343F 50 POP 3440 80 DUP1 3441 82 DUP3 3442 11 GT 3443 15 ISZERO 3444 61 PUSH2 0x344c 3447 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @3429 stack[-8] = stack[-1] // @3430 stack[-7] = msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] // @3437 stack[-6] = msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @343E stack[-3] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x344c, if !(msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] > stack[-2]) label_3448: // Incoming jump from 0x3447, if not !(msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @344B memory[0x00:0x00] } 3448 60 PUSH1 0x00 344A 80 DUP1 344B FD *REVERT // Stack delta = +0 // Outputs[1] { @344B revert(memory[0x00:0x00]); } // Block terminates label_344C: // Incoming jump from 0x3447, if !(msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @3451 stack[-10] // @3452 stack[-2] // @3453 stack[-9] // } 344C 5B JUMPDEST 344D 50 POP 344E 61 PUSH2 0x3459 3451 89 DUP10 3452 82 DUP3 3453 8A DUP11 3454 01 ADD 3455 61 PUSH2 0x32ac 3458 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @344E stack[-1] = 0x3459 // @3451 stack[0] = stack[-10] // @3454 stack[1] = stack[-9] + stack[-2] // } // Block ends with call to 0x32ac, returns to 0x3459 label_3459: // Incoming return from call to 0x32AC at 0x3458 // Inputs[10] // { // @345A stack[-1] // @345A stack[-9] // @345B stack[-12] // @345C stack[-8] // @345D stack[-11] // @345F stack[-2] // @345F stack[-7] // @3460 stack[-10] // @3462 stack[-6] // @3462 stack[-3] // } 3459 5B JUMPDEST 345A 97 SWAP8 345B 9A SWAP11 345C 96 SWAP7 345D 99 SWAP10 345E 50 POP 345F 94 SWAP5 3460 97 SWAP8 3461 50 POP 3462 92 SWAP3 3463 95 SWAP6 3464 93 SWAP4 3465 94 SWAP5 3466 92 SWAP3 3467 50 POP 3468 50 POP 3469 50 POP 346A 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @345B stack[-12] = stack[-9] // @345D stack[-11] = stack[-8] // @3460 stack[-10] = stack[-7] // @3463 stack[-9] = stack[-6] // @3464 stack[-7] = stack[-1] // @3465 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-12] label_346B: // Incoming call from 0x0724, returns to 0x0725 // Inputs[2] // { // @3474 stack[-1] // @3475 stack[-2] // } 346B 5B JUMPDEST 346C 60 PUSH1 0x00 346E 80 DUP1 346F 60 PUSH1 0x00 3471 80 DUP1 3472 60 PUSH1 0x80 3474 85 DUP6 3475 87 DUP8 3476 03 SUB 3477 12 SLT 3478 15 ISZERO 3479 61 PUSH2 0x3481 347C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @346C stack[0] = 0x00 // @346E stack[1] = 0x00 // @346F stack[2] = 0x00 // @3471 stack[3] = 0x00 // } // Block ends with conditional jump to 0x3481, if !(stack[-2] - stack[-1] i< 0x80) label_347D: // Incoming jump from 0x347C, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @3480 memory[0x00:0x00] } 347D 60 PUSH1 0x00 347F 80 DUP1 3480 FD *REVERT // Stack delta = +0 // Outputs[1] { @3480 revert(memory[0x00:0x00]); } // Block terminates label_3481: // Incoming jump from 0x347C, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3482 stack[-5] // @3483 msg.data[stack[-5]:stack[-5] + 0x20] // } 3481 5B JUMPDEST 3482 84 DUP5 3483 35 CALLDATALOAD 3484 61 PUSH2 0x348c 3487 81 DUP2 3488 61 PUSH2 0x312c 348B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3483 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @3484 stack[1] = 0x348c // @3487 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x312c, returns to 0x348C label_348C: // Incoming return from call to 0x312C at 0x348B // Inputs[4] // { // @348D stack[-1] // @348D stack[-5] // @3491 stack[-6] // @3493 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 348C 5B JUMPDEST 348D 93 SWAP4 348E 50 POP 348F 60 PUSH1 0x20 3491 85 DUP6 3492 01 ADD 3493 35 CALLDATALOAD 3494 61 PUSH2 0x349c 3497 81 DUP2 3498 61 PUSH2 0x312c 349B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @348D stack[-5] = stack[-1] // @3493 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @3494 stack[0] = 0x349c // @3497 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x312c, returns to 0x349C label_349C: // Incoming return from call to 0x312C at 0x349B // Inputs[6] // { // @349D stack[-1] // @349D stack[-4] // @34A1 stack[-6] // @34A3 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @34A4 stack[-3] // @34AA msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 349C 5B JUMPDEST 349D 92 SWAP3 349E 50 POP 349F 60 PUSH1 0x40 34A1 85 DUP6 34A2 01 ADD 34A3 35 CALLDATALOAD 34A4 91 SWAP2 34A5 50 POP 34A6 60 PUSH1 0x60 34A8 85 DUP6 34A9 01 ADD 34AA 35 CALLDATALOAD 34AB 67 PUSH8 0xffffffffffffffff 34B4 81 DUP2 34B5 11 GT 34B6 15 ISZERO 34B7 61 PUSH2 0x34bf 34BA 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @349D stack[-4] = stack[-1] // @34A4 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @34AA stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x34bf, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_34BB: // Incoming jump from 0x34BA, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @34BE memory[0x00:0x00] } 34BB 60 PUSH1 0x00 34BD 80 DUP1 34BE FD *REVERT // Stack delta = +0 // Outputs[1] { @34BE revert(memory[0x00:0x00]); } // Block terminates label_34BF: // Incoming jump from 0x34BA, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @34C0 stack[-6] // @34C1 stack[-1] // @34C6 stack[-7] // } 34BF 5B JUMPDEST 34C0 85 DUP6 34C1 01 ADD 34C2 60 PUSH1 0x1f 34C4 81 DUP2 34C5 01 ADD 34C6 87 DUP8 34C7 13 SGT 34C8 61 PUSH2 0x34d0 34CB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @34C1 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x34d0, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_34CC: // Incoming jump from 0x34CB, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @34CF memory[0x00:0x00] } 34CC 60 PUSH1 0x00 34CE 80 DUP1 34CF FD *REVERT // Stack delta = +0 // Outputs[1] { @34CF revert(memory[0x00:0x00]); } // Block terminates label_34D0: // Incoming jump from 0x34CB, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @34D4 stack[-7] // @34D5 stack[-1] // @34D6 msg.data[stack[-1]:stack[-1] + 0x20] // } 34D0 5B JUMPDEST 34D1 61 PUSH2 0x34df 34D4 87 DUP8 34D5 82 DUP3 34D6 35 CALLDATALOAD 34D7 60 PUSH1 0x20 34D9 84 DUP5 34DA 01 ADD 34DB 61 PUSH2 0x31e1 34DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @34D1 stack[0] = 0x34df // @34D4 stack[1] = stack[-7] // @34D6 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @34DA stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x31e1, returns to 0x34DF label_34DF: // Incoming return from call to 0x31E1 at 0x34DE // Inputs[8] // { // @34E0 stack[-1] // @34E0 stack[-3] // @34E3 stack[-6] // @34E4 stack[-9] // @34E5 stack[-5] // @34E6 stack[-8] // @34E8 stack[-4] // @34E8 stack[-7] // } 34DF 5B JUMPDEST 34E0 91 SWAP2 34E1 50 POP 34E2 50 POP 34E3 92 SWAP3 34E4 95 SWAP6 34E5 91 SWAP2 34E6 94 SWAP5 34E7 50 POP 34E8 92 SWAP3 34E9 50 POP 34EA 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @34E3 stack[-6] = stack[-1] // @34E4 stack[-9] = stack[-6] // @34E6 stack[-8] = stack[-5] // @34E8 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_34EB: // Incoming jump from 0x07DA // Inputs[2] // { // @34F1 stack[-1] // @34F2 stack[-2] // } 34EB 5B JUMPDEST 34EC 60 PUSH1 0x00 34EE 80 DUP1 34EF 60 PUSH1 0x40 34F1 83 DUP4 34F2 85 DUP6 34F3 03 SUB 34F4 12 SLT 34F5 15 ISZERO 34F6 61 PUSH2 0x34fe 34F9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34EC stack[0] = 0x00 // @34EE stack[1] = 0x00 // } // Block ends with conditional jump to 0x34fe, if !(stack[-2] - stack[-1] i< 0x40) label_34FA: // Incoming jump from 0x34F9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @34FD memory[0x00:0x00] } 34FA 60 PUSH1 0x00 34FC 80 DUP1 34FD FD *REVERT // Stack delta = +0 // Outputs[1] { @34FD revert(memory[0x00:0x00]); } // Block terminates label_34FE: // Incoming jump from 0x34F9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @34FF stack[-3] // @3500 msg.data[stack[-3]:stack[-3] + 0x20] // } 34FE 5B JUMPDEST 34FF 82 DUP3 3500 35 CALLDATALOAD 3501 61 PUSH2 0x3509 3504 81 DUP2 3505 61 PUSH2 0x312c 3508 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3500 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3501 stack[1] = 0x3509 // @3504 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x312c, returns to 0x3509 label_3509: // Incoming return from call to 0x312C at 0x3508 // Inputs[4] // { // @350A stack[-1] // @350A stack[-3] // @350E stack[-4] // @3510 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 3509 5B JUMPDEST 350A 91 SWAP2 350B 50 POP 350C 60 PUSH1 0x20 350E 83 DUP4 350F 01 ADD 3510 35 CALLDATALOAD 3511 61 PUSH2 0x3386 3514 81 DUP2 3515 61 PUSH2 0x312c 3518 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @350A stack[-3] = stack[-1] // @3510 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @3511 stack[0] = 0x3386 // @3514 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x312c, returns to 0x3386 label_3519: // Incoming call from 0x1CB3, returns to 0x1CB4 // Incoming call from 0x136B, returns to 0x136C // Incoming call from 0x1C87, returns to 0x1C88 // Incoming call from 0x2FF0, returns to 0x2FF1 // Incoming call from 0x1C15, returns to 0x1340 // Incoming call from 0x133F, returns to 0x1340 // Incoming call from 0x0947, returns to 0x0948 // Incoming call from 0x091B, returns to 0x091C // Incoming call from 0x1D34, returns to 0x1340 // Incoming call from 0x149B, returns to 0x091C // Inputs[1] { @351C stack[-1] } 3519 5B JUMPDEST 351A 60 PUSH1 0x01 351C 81 DUP2 351D 81 DUP2 351E 1C SHR 351F 90 SWAP1 3520 82 DUP3 3521 16 AND 3522 80 DUP1 3523 61 PUSH2 0x352d 3526 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @351F stack[0] = stack[-1] >> 0x01 // @3521 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x352d, if stack[-1] & 0x01 label_3527: // Incoming jump from 0x3526, if not stack[-1] & 0x01 // Inputs[2] // { // @3529 stack[-2] // @3532 stack[-1] // } 3527 60 PUSH1 0x7f 3529 82 DUP3 352A 16 AND 352B 91 SWAP2 352C 50 POP 352D 5B JUMPDEST 352E 60 PUSH1 0x20 3530 82 DUP3 3531 10 LT 3532 81 DUP2 3533 14 EQ 3534 15 ISZERO 3535 61 PUSH2 0x354e 3538 57 *JUMPI // Stack delta = +0 // Outputs[1] { @352B stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x354e, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_3539: // Incoming jump from 0x3538, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x3538, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @354D memory[0x00:0x24] } 3539 63 PUSH4 0x4e487b71 353E 60 PUSH1 0xe0 3540 1B SHL 3541 60 PUSH1 0x00 3543 52 MSTORE 3544 60 PUSH1 0x22 3546 60 PUSH1 0x04 3548 52 MSTORE 3549 60 PUSH1 0x24 354B 60 PUSH1 0x00 354D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3543 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3548 memory[0x04:0x24] = 0x22 // @354D revert(memory[0x00:0x24]); // } // Block terminates label_354E: // Incoming jump from 0x3538, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x3538, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @3550 stack[-4] // @3550 stack[-2] // @3551 stack[-3] // } 354E 5B JUMPDEST 354F 50 POP 3550 91 SWAP2 3551 90 SWAP1 3552 50 POP 3553 56 *JUMP // Stack delta = -3 // Outputs[1] { @3550 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_3554: // Incoming jump from 0x35FA // Incoming jump from 0x357D // Incoming jump from 0x36B1 // Incoming jump from 0x3686 // Incoming jump from 0x3597 // Incoming jump from 0x369D // Incoming jump from 0x3624 // Inputs[1] { @3569 memory[0x00:0x24] } 3554 5B JUMPDEST 3555 63 PUSH4 0x4e487b71 355A 60 PUSH1 0xe0 355C 1B SHL 355D 60 PUSH1 0x00 355F 52 MSTORE 3560 60 PUSH1 0x11 3562 60 PUSH1 0x04 3564 52 MSTORE 3565 60 PUSH1 0x24 3567 60 PUSH1 0x00 3569 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @355F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3564 memory[0x04:0x24] = 0x11 // @3569 revert(memory[0x00:0x24]); // } // Block terminates label_356A: // Incoming call from 0x2C01, returns to 0x2C02 // Incoming call from 0x1682, returns to 0x1683 // Incoming call from 0x0D09, returns to 0x0D0A // Incoming call from 0x2C76, returns to 0x2C77 // Incoming call from 0x0D18, returns to 0x0D19 // Incoming call from 0x2C0F, returns to 0x2C10 // Inputs[1] { @3570 stack[-1] } 356A 5B JUMPDEST 356B 60 PUSH1 0x00 356D 60 PUSH1 0x00 356F 19 NOT 3570 82 DUP3 3571 14 EQ 3572 15 ISZERO 3573 61 PUSH2 0x357e 3576 57 *JUMPI // Stack delta = +1 // Outputs[1] { @356B stack[0] = 0x00 } // Block ends with conditional jump to 0x357e, if !(stack[-1] == ~0x00) label_3577: // Incoming jump from 0x3576, if not !(stack[-1] == ~0x00) 3577 61 PUSH2 0x357e 357A 61 PUSH2 0x3554 357D 56 *JUMP // Stack delta = +1 // Outputs[1] { @3577 stack[0] = 0x357e } // Block ends with unconditional jump to 0x3554 label_357E: // Incoming jump from 0x3576, if !(stack[-1] == ~0x00) // Inputs[2] // { // @3582 stack[-2] // @3583 stack[-3] // } 357E 5B JUMPDEST 357F 50 POP 3580 60 PUSH1 0x01 3582 01 ADD 3583 90 SWAP1 3584 56 *JUMP // Stack delta = -2 // Outputs[1] { @3583 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_3585: // Incoming call from 0x2CFE, returns to 0x2CFF // Incoming call from 0x225D, returns to 0x225E // Incoming call from 0x241A, returns to 0x241B // Incoming call from 0x1DB1, returns to 0x1DB2 // Incoming call from 0x150C, returns to 0x150D // Incoming call from 0x254D, returns to 0x254E // Inputs[2] // { // @3588 stack[-2] // @358A stack[-1] // } 3585 5B JUMPDEST 3586 60 PUSH1 0x00 3588 82 DUP3 3589 19 NOT 358A 82 DUP3 358B 11 GT 358C 15 ISZERO 358D 61 PUSH2 0x3598 3590 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3586 stack[0] = 0x00 } // Block ends with conditional jump to 0x3598, if !(stack[-1] > ~stack[-2]) label_3591: // Incoming jump from 0x3590, if not !(stack[-1] > ~stack[-2]) 3591 61 PUSH2 0x3598 3594 61 PUSH2 0x3554 3597 56 *JUMP // Stack delta = +1 // Outputs[1] { @3591 stack[0] = 0x3598 } // Block ends with unconditional jump to 0x3554 label_3598: // Incoming jump from 0x3590, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @359A stack[-2] // @359A stack[-3] // @359B stack[-4] // } 3598 5B JUMPDEST 3599 50 POP 359A 01 ADD 359B 90 SWAP1 359C 56 *JUMP // Stack delta = -3 // Outputs[1] { @359B stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_359D: // Incoming jump from 0x35C1 // Incoming jump from 0x35D5 // Inputs[1] { @35B2 memory[0x00:0x24] } 359D 5B JUMPDEST 359E 63 PUSH4 0x4e487b71 35A3 60 PUSH1 0xe0 35A5 1B SHL 35A6 60 PUSH1 0x00 35A8 52 MSTORE 35A9 60 PUSH1 0x12 35AB 60 PUSH1 0x04 35AD 52 MSTORE 35AE 60 PUSH1 0x24 35B0 60 PUSH1 0x00 35B2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @35A8 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @35AD memory[0x04:0x24] = 0x12 // @35B2 revert(memory[0x00:0x24]); // } // Block terminates label_35B3: // Incoming call from 0x2CF3, returns to 0x2CF4 // Incoming call from 0x15A2, returns to 0x15A3 // Inputs[1] { @35B6 stack[-2] } 35B3 5B JUMPDEST 35B4 60 PUSH1 0x00 35B6 82 DUP3 35B7 61 PUSH2 0x35c2 35BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35B4 stack[0] = 0x00 } // Block ends with conditional jump to 0x35c2, if stack[-2] label_35BB: // Incoming jump from 0x35BA, if not stack[-2] 35BB 61 PUSH2 0x35c2 35BE 61 PUSH2 0x359d 35C1 56 *JUMP // Stack delta = +1 // Outputs[1] { @35BB stack[0] = 0x35c2 } // Block ends with unconditional jump to 0x359d label_35C2: // Incoming jump from 0x35BA, if stack[-2] // Inputs[3] // { // @35C4 stack[-2] // @35C4 stack[-3] // @35C5 stack[-4] // } 35C2 5B JUMPDEST 35C3 50 POP 35C4 06 MOD 35C5 90 SWAP1 35C6 56 *JUMP // Stack delta = -3 // Outputs[1] { @35C5 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_35C7: // Incoming call from 0x2C85, returns to 0x2C86 // Incoming call from 0x1641, returns to 0x1642 // Incoming call from 0x2D4D, returns to 0x2D4E // Inputs[1] { @35CA stack[-2] } 35C7 5B JUMPDEST 35C8 60 PUSH1 0x00 35CA 82 DUP3 35CB 61 PUSH2 0x35d6 35CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35C8 stack[0] = 0x00 } // Block ends with conditional jump to 0x35d6, if stack[-2] label_35CF: // Incoming jump from 0x35CE, if not stack[-2] 35CF 61 PUSH2 0x35d6 35D2 61 PUSH2 0x359d 35D5 56 *JUMP // Stack delta = +1 // Outputs[1] { @35CF stack[0] = 0x35d6 } // Block ends with unconditional jump to 0x359d label_35D6: // Incoming jump from 0x35CE, if stack[-2] // Inputs[3] // { // @35D8 stack[-2] // @35D8 stack[-3] // @35D9 stack[-4] // } 35D6 5B JUMPDEST 35D7 50 POP 35D8 04 DIV 35D9 90 SWAP1 35DA 56 *JUMP // Stack delta = -3 // Outputs[1] { @35D9 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_35DB: // Incoming call from 0x2189, returns to 0x218A // Inputs[2] // { // @35E6 stack[-2] // @35EA stack[-1] // } 35DB 5B JUMPDEST 35DC 60 PUSH1 0x00 35DE 60 PUSH1 0x01 35E0 60 PUSH1 0x01 35E2 60 PUSH1 0x80 35E4 1B SHL 35E5 03 SUB 35E6 83 DUP4 35E7 81 DUP2 35E8 16 AND 35E9 90 SWAP1 35EA 83 DUP4 35EB 16 AND 35EC 81 DUP2 35ED 81 DUP2 35EE 10 LT 35EF 15 ISZERO 35F0 61 PUSH2 0x35fb 35F3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @35DC stack[0] = 0x00 // @35E9 stack[1] = (0x01 << 0x80) - 0x01 & stack[-2] // @35EB stack[2] = stack[-1] & (0x01 << 0x80) - 0x01 // } // Block ends with conditional jump to 0x35fb, if !(stack[-1] & (0x01 << 0x80) - 0x01 < (0x01 << 0x80) - 0x01 & stack[-2]) label_35F4: // Incoming jump from 0x35F3, if not !(stack[-1] & (0x01 << 0x80) - 0x01 < (0x01 << 0x80) - 0x01 & stack[-2]) 35F4 61 PUSH2 0x35fb 35F7 61 PUSH2 0x3554 35FA 56 *JUMP // Stack delta = +1 // Outputs[1] { @35F4 stack[0] = 0x35fb } // Block ends with unconditional jump to 0x3554 label_35FB: // Incoming jump from 0x35F3, if !(stack[-1] & (0x01 << 0x80) - 0x01 < (0x01 << 0x80) - 0x01 & stack[-2]) // Inputs[4] // { // @35FC stack[-2] // @35FC stack[-1] // @35FD stack[-6] // @35FE stack[-5] // } 35FB 5B JUMPDEST 35FC 03 SUB 35FD 93 SWAP4 35FE 92 SWAP3 35FF 50 POP 3600 50 POP 3601 50 POP 3602 56 *JUMP // Stack delta = -5 // Outputs[1] { @35FD stack[-6] = stack[-1] - stack[-2] } // Block ends with unconditional jump to stack[-6] label_3603: // Incoming call from 0x2A94, returns to 0x2A95 // Incoming call from 0x21D5, returns to 0x21D6 // Incoming call from 0x2A76, returns to 0x2A77 // Inputs[2] // { // @360F stack[-1] // @3612 stack[-2] // } 3603 5B JUMPDEST 3604 60 PUSH1 0x00 3606 60 PUSH1 0x01 3608 60 PUSH1 0x01 360A 60 PUSH1 0x80 360C 1B SHL 360D 03 SUB 360E 80 DUP1 360F 83 DUP4 3610 16 AND 3611 81 DUP2 3612 85 DUP6 3613 16 AND 3614 80 DUP1 3615 83 DUP4 3616 03 SUB 3617 82 DUP3 3618 11 GT 3619 15 ISZERO 361A 61 PUSH2 0x3625 361D 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @3604 stack[0] = 0x00 // @360D stack[1] = (0x01 << 0x80) - 0x01 // @3610 stack[2] = stack[-1] & (0x01 << 0x80) - 0x01 // @3613 stack[3] = stack[-2] & (0x01 << 0x80) - 0x01 // } // Block ends with conditional jump to 0x3625, if !(stack[-1] & (0x01 << 0x80) - 0x01 > (0x01 << 0x80) - 0x01 - (stack[-2] & (0x01 << 0x80) - 0x01)) label_361E: // Incoming jump from 0x361D, if not !(stack[-1] & (0x01 << 0x80) - 0x01 > (0x01 << 0x80) - 0x01 - (stack[-2] & (0x01 << 0x80) - 0x01)) 361E 61 PUSH2 0x3625 3621 61 PUSH2 0x3554 3624 56 *JUMP // Stack delta = +1 // Outputs[1] { @361E stack[0] = 0x3625 } // Block ends with unconditional jump to 0x3554 label_3625: // Incoming return from call to 0x30A8 at 0x383F // Incoming jump from 0x361D, if !(stack[-1] & (0x01 << 0x80) - 0x01 > (0x01 << 0x80) - 0x01 - (stack[-2] & (0x01 << 0x80) - 0x01)) // Inputs[4] // { // @3626 stack[-1] // @3626 stack[-2] // @3627 stack[-7] // @3628 stack[-6] // } 3625 5B JUMPDEST 3626 01 ADD 3627 94 SWAP5 3628 93 SWAP4 3629 50 POP 362A 50 POP 362B 50 POP 362C 50 POP 362D 56 *JUMP // Stack delta = -6 // Outputs[1] { @3627 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 362E 5B JUMPDEST 362F 60 PUSH1 0x00 3631 84 DUP5 3632 51 MLOAD 3633 61 PUSH2 0x3640 3636 81 DUP2 3637 84 DUP5 3638 60 PUSH1 0x20 363A 89 DUP10 363B 01 ADD 363C 61 PUSH2 0x30a8 363F 56 *JUMP 3640 5B JUMPDEST 3641 60 PUSH1 0x60 3643 94 SWAP5 3644 90 SWAP1 3645 94 SWAP5 3646 1B SHL 3647 6B PUSH12 0xffffffffffffffffffffffff 3654 19 NOT 3655 16 AND 3656 91 SWAP2 3657 90 SWAP1 3658 93 SWAP4 3659 01 ADD 365A 90 SWAP1 365B 81 DUP2 365C 52 MSTORE 365D 60 PUSH1 0x14 365F 81 DUP2 3660 01 ADD 3661 91 SWAP2 3662 90 SWAP1 3663 91 SWAP2 3664 52 MSTORE 3665 60 PUSH1 0x34 3667 01 ADD 3668 92 SWAP3 3669 91 SWAP2 366A 50 POP 366B 50 POP 366C 56 *JUMP label_366D: // Incoming call from 0x23B6, returns to 0x23B7 // Inputs[2] // { // @3670 stack[-1] // @3675 stack[-2] // } 366D 5B JUMPDEST 366E 60 PUSH1 0x00 3670 81 DUP2 3671 60 PUSH1 0x00 3673 19 NOT 3674 04 DIV 3675 83 DUP4 3676 11 GT 3677 82 DUP3 3678 15 ISZERO 3679 15 ISZERO 367A 16 AND 367B 15 ISZERO 367C 61 PUSH2 0x3687 367F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @366E stack[0] = 0x00 } // Block ends with conditional jump to 0x3687, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_3680: // Incoming jump from 0x367F, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 3680 61 PUSH2 0x3687 3683 61 PUSH2 0x3554 3686 56 *JUMP // Stack delta = +1 // Outputs[1] { @3680 stack[0] = 0x3687 } // Block ends with unconditional jump to 0x3554 label_3687: // Incoming jump from 0x367F, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @3689 stack[-3] // @3689 stack[-2] // @368A stack[-4] // } 3687 5B JUMPDEST 3688 50 POP 3689 02 MUL 368A 90 SWAP1 368B 56 *JUMP // Stack delta = -3 // Outputs[1] { @368A stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_368C: // Incoming call from 0x2CE6, returns to 0x2CE7 // Incoming call from 0x2542, returns to 0x2543 // Inputs[2] // { // @368F stack[-2] // @3690 stack[-1] // } 368C 5B JUMPDEST 368D 60 PUSH1 0x00 368F 82 DUP3 3690 82 DUP3 3691 10 LT 3692 15 ISZERO 3693 61 PUSH2 0x369e 3696 57 *JUMPI // Stack delta = +1 // Outputs[1] { @368D stack[0] = 0x00 } // Block ends with conditional jump to 0x369e, if !(stack[-1] < stack[-2]) label_3697: // Incoming jump from 0x3696, if not !(stack[-1] < stack[-2]) 3697 61 PUSH2 0x369e 369A 61 PUSH2 0x3554 369D 56 *JUMP // Stack delta = +1 // Outputs[1] { @3697 stack[0] = 0x369e } // Block ends with unconditional jump to 0x3554 label_369E: // Incoming jump from 0x3696, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @36A0 stack[-3] // @36A0 stack[-2] // @36A1 stack[-4] // } 369E 5B JUMPDEST 369F 50 POP 36A0 03 SUB 36A1 90 SWAP1 36A2 56 *JUMP // Stack delta = -3 // Outputs[1] { @36A1 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_36A3: // Incoming call from 0x25B2, returns to 0x25B3 // Inputs[1] { @36A6 stack[-1] } 36A3 5B JUMPDEST 36A4 60 PUSH1 0x00 36A6 81 DUP2 36A7 61 PUSH2 0x36b2 36AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @36A4 stack[0] = 0x00 } // Block ends with conditional jump to 0x36b2, if stack[-1] label_36AB: // Incoming jump from 0x36AA, if not stack[-1] 36AB 61 PUSH2 0x36b2 36AE 61 PUSH2 0x3554 36B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @36AB stack[0] = 0x36b2 } // Block ends with unconditional jump to 0x3554 label_36B2: // Incoming jump from 0x36AA, if stack[-1] // Inputs[2] // { // @36B7 stack[-2] // @36B8 stack[-3] // } 36B2 5B JUMPDEST 36B3 50 POP 36B4 60 PUSH1 0x00 36B6 19 NOT 36B7 01 ADD 36B8 90 SWAP1 36B9 56 *JUMP // Stack delta = -2 // Outputs[1] { @36B8 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_36BA: // Incoming call from 0x382F, returns to 0x3830 // Inputs[2] // { // @36BB stack[-1] // @36BC storage[stack[-1]] // } 36BA 5B JUMPDEST 36BB 80 DUP1 36BC 54 SLOAD 36BD 60 PUSH1 0x00 36BF 90 SWAP1 36C0 60 PUSH1 0x01 36C2 81 DUP2 36C3 81 DUP2 36C4 1C SHR 36C5 90 SWAP1 36C6 80 DUP1 36C7 83 DUP4 36C8 16 AND 36C9 80 DUP1 36CA 61 PUSH2 0x36d4 36CD 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @36BF stack[0] = 0x00 // @36BF stack[1] = storage[stack[-1]] // @36C5 stack[2] = storage[stack[-1]] >> 0x01 // @36C5 stack[3] = 0x01 // @36C8 stack[4] = storage[stack[-1]] & 0x01 // } // Block ends with conditional jump to 0x36d4, if storage[stack[-1]] & 0x01 label_36CE: // Incoming jump from 0x36CD, if not storage[stack[-1]] & 0x01 // Inputs[2] // { // @36D0 stack[-3] // @36DA stack[-1] // } 36CE 60 PUSH1 0x7f 36D0 83 DUP4 36D1 16 AND 36D2 92 SWAP3 36D3 50 POP 36D4 5B JUMPDEST 36D5 60 PUSH1 0x20 36D7 80 DUP1 36D8 84 DUP5 36D9 10 LT 36DA 82 DUP3 36DB 14 EQ 36DC 15 ISZERO 36DD 61 PUSH2 0x36f6 36E0 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @36D2 stack[-3] = stack[-3] & 0x7f // @36D5 stack[0] = 0x20 // } // Block ends with conditional jump to 0x36f6, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_36E1: // Incoming jump from 0x36E0, if not !(stack[-1] == (stack[-3] < 0x20)) // Incoming jump from 0x36E0, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Inputs[1] { @36F5 memory[0x00:0x24] } 36E1 63 PUSH4 0x4e487b71 36E6 60 PUSH1 0xe0 36E8 1B SHL 36E9 60 PUSH1 0x00 36EB 52 MSTORE 36EC 60 PUSH1 0x22 36EE 60 PUSH1 0x04 36F0 52 MSTORE 36F1 60 PUSH1 0x24 36F3 60 PUSH1 0x00 36F5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @36EB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @36F0 memory[0x04:0x24] = 0x22 // @36F5 revert(memory[0x00:0x24]); // } // Block terminates label_36F6: // Incoming jump from 0x36E0, if !(stack[-1] == (stack[-3] < 0x20)) // Incoming jump from 0x36E0, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Inputs[1] { @36F7 stack[-2] } 36F6 5B JUMPDEST 36F7 81 DUP2 36F8 80 DUP1 36F9 15 ISZERO 36FA 61 PUSH2 0x370a 36FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @36F7 stack[0] = stack[-2] } // Block ends with conditional jump to 0x370a, if !stack[-2] label_36FE: // Incoming jump from 0x36FD, if not !stack[-2] // Inputs[1] { @3700 stack[-1] } 36FE 60 PUSH1 0x01 3700 81 DUP2 3701 14 EQ 3702 61 PUSH2 0x371b 3705 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x371b, if stack[-1] == 0x01 label_3706: // Incoming jump from 0x3705, if not stack[-1] == 0x01 3706 61 PUSH2 0x3748 3709 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x3748 label_370A: // Incoming jump from 0x36FD, if !stack[-2] // Inputs[4] // { // @370E stack[-6] // @3710 stack[-9] // @3712 stack[-5] // @3715 stack[-7] // } 370A 5B JUMPDEST 370B 60 PUSH1 0xff 370D 19 NOT 370E 86 DUP7 370F 16 AND 3710 89 DUP10 3711 52 MSTORE 3712 84 DUP5 3713 89 DUP10 3714 01 ADD 3715 96 SWAP7 3716 50 POP 3717 61 PUSH2 0x3748 371A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3711 memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @3715 stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x3748 label_371B: // Incoming jump from 0x3705, if stack[-1] == 0x01 // Inputs[3] // { // @371E stack[-8] // @3724 memory[0x00:0x20] // @3728 stack[-5] // } 371B 5B JUMPDEST 371C 60 PUSH1 0x00 371E 88 DUP9 371F 81 DUP2 3720 52 MSTORE 3721 60 PUSH1 0x20 3723 90 SWAP1 3724 20 SHA3 3725 60 PUSH1 0x00 3727 5B JUMPDEST 3728 86 DUP7 3729 81 DUP2 372A 10 LT 372B 15 ISZERO 372C 61 PUSH2 0x3740 372F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @3720 memory[0x00:0x20] = stack[-8] // @3724 stack[0] = keccak256(memory[0x00:0x20]) // @3725 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3740, if !(0x00 < stack[-5]) label_3730: // Incoming jump from 0x372F, if not !(0x00 < stack[-5]) // Incoming jump from 0x372F, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @3730 stack[-2] // @3731 storage[stack[-2]] // @3732 stack[-11] // @3733 stack[-1] // @3737 stack[-6] // @373A stack[-4] // } 3730 81 DUP2 3731 54 SLOAD 3732 8B DUP12 3733 82 DUP3 3734 01 ADD 3735 52 MSTORE 3736 90 SWAP1 3737 85 DUP6 3738 01 ADD 3739 90 SWAP1 373A 83 DUP4 373B 01 ADD 373C 61 PUSH2 0x3727 373F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @3735 memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @3739 stack[-2] = stack[-6] + stack[-2] // @373B stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x3727 label_3740: // Incoming jump from 0x372F, if !(0x00 < stack[-5]) // Incoming jump from 0x372F, if !(stack[-1] < stack[-7]) // Inputs[4] // { // @3743 stack[-7] // @3744 stack[-11] // @3746 stack[-9] // @374F stack[-12] // } 3740 5B JUMPDEST 3741 50 POP 3742 50 POP 3743 84 DUP5 3744 89 DUP10 3745 01 ADD 3746 96 SWAP7 3747 50 POP 3748 5B JUMPDEST 3749 50 POP 374A 50 POP 374B 50 POP 374C 50 POP 374D 50 POP 374E 50 POP 374F 92 SWAP3 3750 91 SWAP2 3751 50 POP 3752 50 POP 3753 56 *JUMP // Stack delta = -11 // Outputs[1] { @374F stack[-12] = stack[-11] + stack[-7] } // Block ends with unconditional jump to stack[-12] 3754 5B JUMPDEST 3755 60 PUSH1 0x00 3757 61 PUSH2 0x3760 375A 82 DUP3 375B 85 DUP6 375C 61 PUSH2 0x36ba 375F 56 *JUMP 3760 5B JUMPDEST 3761 60 PUSH1 0x60 3763 93 SWAP4 3764 90 SWAP1 3765 93 SWAP4 3766 1B SHL 3767 6B PUSH12 0xffffffffffffffffffffffff 3774 19 NOT 3775 16 AND 3776 83 DUP4 3777 52 MSTORE 3778 50 POP 3779 50 POP 377A 60 PUSH1 0x14 377C 01 ADD 377D 91 SWAP2 377E 90 SWAP1 377F 50 POP 3780 56 *JUMP 3781 5B JUMPDEST 3782 60 PUSH1 0x00 3784 85 DUP6 3785 51 MLOAD 3786 61 PUSH2 0x3793 3789 81 DUP2 378A 84 DUP5 378B 60 PUSH1 0x20 378D 8A DUP11 378E 01 ADD 378F 61 PUSH2 0x30a8 3792 56 *JUMP 3793 5B JUMPDEST 3794 60 PUSH1 0x60 3796 86 DUP7 3797 90 SWAP1 3798 1B SHL 3799 6B PUSH12 0xffffffffffffffffffffffff 37A6 19 NOT 37A7 16 AND 37A8 90 SWAP1 37A9 83 DUP4 37AA 01 ADD 37AB 90 SWAP1 37AC 81 DUP2 37AD 52 MSTORE 37AE 84 DUP5 37AF 51 MLOAD 37B0 61 PUSH2 0x37c0 37B3 81 DUP2 37B4 60 PUSH1 0x14 37B6 84 DUP5 37B7 01 ADD 37B8 60 PUSH1 0x20 37BA 89 DUP10 37BB 01 ADD 37BC 61 PUSH2 0x30a8 37BF 56 *JUMP 37C0 5B JUMPDEST 37C1 01 ADD 37C2 60 PUSH1 0x14 37C4 81 DUP2 37C5 01 ADD 37C6 93 SWAP4 37C7 90 SWAP1 37C8 93 SWAP4 37C9 52 MSTORE 37CA 50 POP 37CB 50 POP 37CC 60 PUSH1 0x34 37CE 01 ADD 37CF 93 SWAP4 37D0 92 SWAP3 37D1 50 POP 37D2 50 POP 37D3 50 POP 37D4 56 *JUMP label_37D5: // Incoming jump from 0x2753 // Inputs[5] // { // @37E1 stack[-5] // @37E3 stack[-1] // @37E6 stack[-4] // @37EE stack[-3] // @3802 stack[-2] // } 37D5 5B JUMPDEST 37D6 60 PUSH1 0x00 37D8 60 PUSH1 0x01 37DA 60 PUSH1 0x01 37DC 60 PUSH1 0xa0 37DE 1B SHL 37DF 03 SUB 37E0 80 DUP1 37E1 87 DUP8 37E2 16 AND 37E3 83 DUP4 37E4 52 MSTORE 37E5 80 DUP1 37E6 86 DUP7 37E7 16 AND 37E8 60 PUSH1 0x20 37EA 84 DUP5 37EB 01 ADD 37EC 52 MSTORE 37ED 50 POP 37EE 83 DUP4 37EF 60 PUSH1 0x40 37F1 83 DUP4 37F2 01 ADD 37F3 52 MSTORE 37F4 60 PUSH1 0x80 37F6 60 PUSH1 0x60 37F8 83 DUP4 37F9 01 ADD 37FA 52 MSTORE 37FB 61 PUSH2 0x2fdb 37FE 60 PUSH1 0x80 3800 83 DUP4 3801 01 ADD 3802 84 DUP5 3803 61 PUSH2 0x30d4 3806 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @37D6 stack[0] = 0x00 // @37E4 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @37EC memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @37F3 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @37FA memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @37FB stack[1] = 0x2fdb // @3801 stack[2] = stack[-1] + 0x80 // @3802 stack[3] = stack[-2] // } // Block ends with call to 0x30d4, returns to 0x2FDB 3807 5B JUMPDEST 3808 60 PUSH1 0x00 380A 60 PUSH1 0x20 380C 82 DUP3 380D 84 DUP5 380E 03 SUB 380F 12 SLT 3810 15 ISZERO 3811 61 PUSH2 0x3819 3814 57 *JUMPI 3815 60 PUSH1 0x00 3817 80 DUP1 3818 FD *REVERT 3819 5B JUMPDEST 381A 81 DUP2 381B 51 MLOAD 381C 61 PUSH2 0x1d21 381F 81 DUP2 3820 61 PUSH2 0x3075 3823 56 *JUMP label_3824: // Incoming jump from 0x287E // Inputs[2] // { // @382A stack[-1] // @382B stack[-3] // } 3824 5B JUMPDEST 3825 60 PUSH1 0x00 3827 61 PUSH2 0x3830 382A 82 DUP3 382B 85 DUP6 382C 61 PUSH2 0x36ba 382F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3825 stack[0] = 0x00 // @3827 stack[1] = 0x3830 // @382A stack[2] = stack[-1] // @382B stack[3] = stack[-3] // } // Block ends with call to 0x36ba, returns to 0x3830 label_3830: // Incoming return from call to 0x36BA at 0x382F // Inputs[3] // { // @3831 stack[-4] // @3832 memory[stack[-4]:stack[-4] + 0x20] // @3837 stack[-1] // } 3830 5B JUMPDEST 3831 83 DUP4 3832 51 MLOAD 3833 61 PUSH2 0x3625 3836 81 DUP2 3837 83 DUP4 3838 60 PUSH1 0x20 383A 88 DUP9 383B 01 ADD 383C 61 PUSH2 0x30a8 383F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3832 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @3833 stack[1] = 0x3625 // @3836 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @3837 stack[3] = stack[-1] // @383B stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x30a8, returns to 0x3625 label_3840: // Incoming jump from 0x2D13 // Inputs[1] { @3855 memory[0x00:0x24] } 3840 5B JUMPDEST 3841 63 PUSH4 0x4e487b71 3846 60 PUSH1 0xe0 3848 1B SHL 3849 60 PUSH1 0x00 384B 52 MSTORE 384C 60 PUSH1 0x32 384E 60 PUSH1 0x04 3850 52 MSTORE 3851 60 PUSH1 0x24 3853 60 PUSH1 0x00 3855 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @384B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3850 memory[0x04:0x24] = 0x32 // @3855 revert(memory[0x00:0x24]); // } // Block terminates 3856 FE *ASSERT 3857 A2 LOG2 3858 64 PUSH5 0x6970667358 385E 22 22 385F 12 SLT 3860 20 SHA3 3861 29 29 3862 1B SHL 3863 98 SWAP9 3864 2D 2D 3865 71 PUSH18 0xbe25300c595c254320a78d46182c0b0a318d 3878 26 26 3879 ED ED 387A B0 PUSH 387B 85 DUP6 387C CC CC 387D EA EA 387E C9 C9 387F 02 MUL 3880 CE CE 3881 64 PUSH5 0x736f6c6343 3887 00 *STOP 3888 08 ADDMOD 3889 0A EXP 388A 00 *STOP 388B 33 CALLER