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 0x021a 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x021a, 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 0x6352211e 0019 11 GT 001A 61 PUSH2 0x0123 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0123, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa035b1fe 0024 11 GT 0025 61 PUSH2 0x00ab 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ab, if 0xa035b1fe > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa035b1fe > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xe8a3d485 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xe8a3d485 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xe8a3d485 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe8a3d485 003A 14 EQ 003B 61 PUSH2 0x0617 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0617, if 0xe8a3d485 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x062c 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062c, 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 0xf053dc5c 0050 14 EQ 0051 61 PUSH2 0x064c 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064c, if 0xf053dc5c == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf053dc5c == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x066c 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066c, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xff1b6556 0066 14 EQ 0067 61 PUSH2 0x068c 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068c, if 0xff1b6556 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xff1b6556 == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0033, if 0xe8a3d485 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xa035b1fe 0076 14 EQ 0077 61 PUSH2 0x0581 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0581, if 0xa035b1fe == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa035b1fe == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xa22cb465 0081 14 EQ 0082 61 PUSH2 0x0597 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0597, if 0xa22cb465 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xacec338a 008C 14 EQ 008D 61 PUSH2 0x05b7 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b7, if 0xacec338a == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xacec338a == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xb88d4fde 0097 14 EQ 0098 61 PUSH2 0x05d7 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d7, if 0xb88d4fde == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xc87b56dd 00A2 14 EQ 00A3 61 PUSH2 0x05f7 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f7, if 0xc87b56dd == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00AA memory[0x00:0x00] } 00A7 60 PUSH1 0x00 00A9 80 DUP1 00AA FD *REVERT // Stack delta = +0 // Outputs[1] { @00AA revert(memory[0x00:0x00]); } // Block terminates label_00AB: // Incoming jump from 0x0028, if 0xa035b1fe > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x86758912 00B2 11 GT 00B3 61 PUSH2 0x00f2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f2, if 0x86758912 > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x86758912 > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x86758912 00BD 14 EQ 00BE 61 PUSH2 0x04fb 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fb, if 0x86758912 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x86758912 == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x87d2d93f 00C8 14 EQ 00C9 61 PUSH2 0x051b 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051b, if 0x87d2d93f == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x87d2d93f == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x8da5cb5b 00D3 14 EQ 00D4 61 PUSH2 0x052e 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052e, if 0x8da5cb5b == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x938e3d7b 00DE 14 EQ 00DF 61 PUSH2 0x054c 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054c, if 0x938e3d7b == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x938e3d7b == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x95d89b41 00E9 14 EQ 00EA 61 PUSH2 0x056c 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056c, if 0x95d89b41 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00F1 memory[0x00:0x00] } 00EE 60 PUSH1 0x00 00F0 80 DUP1 00F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F1 revert(memory[0x00:0x00]); } // Block terminates label_00F2: // Incoming jump from 0x00B6, if 0x86758912 > stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F2 5B JUMPDEST 00F3 80 DUP1 00F4 63 PUSH4 0x6352211e 00F9 14 EQ 00FA 61 PUSH2 0x0491 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0491, if 0x6352211e == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x6352211e == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x6c0360eb 0104 14 EQ 0105 61 PUSH2 0x04b1 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b1, if 0x6c0360eb == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x6c0360eb == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x70a08231 010F 14 EQ 0110 61 PUSH2 0x04c6 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c6, if 0x70a08231 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x70a08231 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x715018a6 011A 14 EQ 011B 61 PUSH2 0x04e6 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e6, if 0x715018a6 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x715018a6 == stack[-1] // Inputs[1] { @0122 memory[0x00:0x00] } 011F 60 PUSH1 0x00 0121 80 DUP1 0122 FD *REVERT // Stack delta = +0 // Outputs[1] { @0122 revert(memory[0x00:0x00]); } // Block terminates label_0123: // Incoming jump from 0x001D, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0124 stack[-1] } 0123 5B JUMPDEST 0124 80 DUP1 0125 63 PUSH4 0x23b872dd 012A 11 GT 012B 61 PUSH2 0x01a6 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a6, if 0x23b872dd > stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x23b872dd > stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x38af3eed 0135 11 GT 0136 61 PUSH2 0x0175 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x38af3eed > stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x38af3eed > stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x38af3eed 0140 14 EQ 0141 61 PUSH2 0x03fc 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fc, if 0x38af3eed == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x38af3eed == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x3ccfd60b 014B 14 EQ 014C 61 PUSH2 0x041c 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041c, if 0x3ccfd60b == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x42842e0e 0156 14 EQ 0157 61 PUSH2 0x0431 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0431, if 0x42842e0e == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x42842e0e == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x484b973c 0161 14 EQ 0162 61 PUSH2 0x0451 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0451, if 0x484b973c == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x484b973c == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x55f804b3 016C 14 EQ 016D 61 PUSH2 0x0471 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0471, if 0x55f804b3 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0174 memory[0x00:0x00] } 0171 60 PUSH1 0x00 0173 80 DUP1 0174 FD *REVERT // Stack delta = +0 // Outputs[1] { @0174 revert(memory[0x00:0x00]); } // Block terminates label_0175: // Incoming jump from 0x0139, if 0x38af3eed > stack[-1] // Inputs[1] { @0176 stack[-1] } 0175 5B JUMPDEST 0176 80 DUP1 0177 63 PUSH4 0x23b872dd 017C 14 EQ 017D 61 PUSH2 0x0378 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0378, if 0x23b872dd == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x23b872dd == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x2a55205a 0187 14 EQ 0188 61 PUSH2 0x0398 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0398, if 0x2a55205a == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x2a55205a == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x2a9e63c6 0192 14 EQ 0193 61 PUSH2 0x03c6 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c6, if 0x2a9e63c6 == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x2a9e63c6 == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x2eb4a7ab 019D 14 EQ 019E 61 PUSH2 0x03e6 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e6, if 0x2eb4a7ab == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x2eb4a7ab == stack[-1] // Inputs[1] { @01A5 memory[0x00:0x00] } 01A2 60 PUSH1 0x00 01A4 80 DUP1 01A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A5 revert(memory[0x00:0x00]); } // Block terminates label_01A6: // Incoming jump from 0x012E, if 0x23b872dd > stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A6 5B JUMPDEST 01A7 80 DUP1 01A8 63 PUSH4 0x0a398b88 01AD 11 GT 01AE 61 PUSH2 0x01ed 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ed, if 0x0a398b88 > stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x0a398b88 > stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x0a398b88 01B8 14 EQ 01B9 61 PUSH2 0x02c6 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c6, if 0x0a398b88 == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x0a398b88 == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x10969523 01C3 14 EQ 01C4 61 PUSH2 0x0309 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0309, if 0x10969523 == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x10969523 == stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C8 80 DUP1 01C9 63 PUSH4 0x18160ddd 01CE 14 EQ 01CF 61 PUSH2 0x0329 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0329, if 0x18160ddd == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x18160ddd == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x1c31f710 01D9 14 EQ 01DA 61 PUSH2 0x033e 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033e, if 0x1c31f710 == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x1c31f710 == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x22f3e2d4 01E4 14 EQ 01E5 61 PUSH2 0x035e 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035e, if 0x22f3e2d4 == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x22f3e2d4 == stack[-1] // Inputs[1] { @01EC memory[0x00:0x00] } 01E9 60 PUSH1 0x00 01EB 80 DUP1 01EC FD *REVERT // Stack delta = +0 // Outputs[1] { @01EC revert(memory[0x00:0x00]); } // Block terminates label_01ED: // Incoming jump from 0x01B1, if 0x0a398b88 > stack[-1] // Inputs[1] { @01EE stack[-1] } 01ED 5B JUMPDEST 01EE 80 DUP1 01EF 63 PUSH4 0x01ffc9a7 01F4 14 EQ 01F5 61 PUSH2 0x021f 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021f, if 0x01ffc9a7 == stack[-1] label_01F9: // Incoming jump from 0x01F8, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01F9 stack[-1] } 01F9 80 DUP1 01FA 63 PUSH4 0x06fdde03 01FF 14 EQ 0200 61 PUSH2 0x0255 0203 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0255, if 0x06fdde03 == stack[-1] label_0204: // Incoming jump from 0x0203, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0204 stack[-1] } 0204 80 DUP1 0205 63 PUSH4 0x081812fc 020A 14 EQ 020B 61 PUSH2 0x0277 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x081812fc == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x081812fc == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x095ea7b3 0215 14 EQ 0216 61 PUSH2 0x02a4 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a4, if 0x095ea7b3 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @021E memory[0x00:0x00] } 021A 5B JUMPDEST 021B 60 PUSH1 0x00 021D 80 DUP1 021E FD *REVERT // Stack delta = +0 // Outputs[1] { @021E revert(memory[0x00:0x00]); } // Block terminates label_021F: // Incoming jump from 0x01F8, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0220 msg.value } 021F 5B JUMPDEST 0220 34 CALLVALUE 0221 80 DUP1 0222 15 ISZERO 0223 61 PUSH2 0x022b 0226 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0220 stack[0] = msg.value } // Block ends with conditional jump to 0x022b, if !msg.value label_0227: // Incoming jump from 0x0226, if not !msg.value // Inputs[1] { @022A memory[0x00:0x00] } 0227 60 PUSH1 0x00 0229 80 DUP1 022A FD *REVERT // Stack delta = +0 // Outputs[1] { @022A revert(memory[0x00:0x00]); } // Block terminates label_022B: // Incoming jump from 0x0226, if !msg.value // Inputs[1] { @0233 msg.data.length } 022B 5B JUMPDEST 022C 50 POP 022D 61 PUSH2 0x023f 0230 61 PUSH2 0x023a 0233 36 CALLDATASIZE 0234 60 PUSH1 0x04 0236 61 PUSH2 0x18b3 0239 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @022D stack[-1] = 0x023f // @0230 stack[0] = 0x023a // @0233 stack[1] = msg.data.length // @0234 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x18b3 023A 5B JUMPDEST 023B 61 PUSH2 0x06a1 023E 56 *JUMP label_023F: // Incoming jump from 0x0377 // Inputs[2] // { // @0242 memory[0x40:0x60] // @0246 stack[-1] // } 023F 5B JUMPDEST 0240 60 PUSH1 0x40 0242 51 MLOAD 0243 61 PUSH2 0x024c 0246 91 SWAP2 0247 90 SWAP1 0248 61 PUSH2 0x18de 024B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0246 stack[-1] = 0x024c // @0247 stack[1] = memory[0x40:0x60] // @0247 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x18de label_024C: // Incoming return from call to 0x194A at 0x0276 // Inputs[3] // { // @024F memory[0x40:0x60] // @0251 stack[-1] // @0254 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 024C 5B JUMPDEST 024D 60 PUSH1 0x40 024F 51 MLOAD 0250 80 DUP1 0251 91 SWAP2 0252 03 SUB 0253 90 SWAP1 0254 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0254 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0255: // Incoming jump from 0x0203, if 0x06fdde03 == stack[-1] // Inputs[1] { @0256 msg.value } 0255 5B JUMPDEST 0256 34 CALLVALUE 0257 80 DUP1 0258 15 ISZERO 0259 61 PUSH2 0x0261 025C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0256 stack[0] = msg.value } // Block ends with conditional jump to 0x0261, if !msg.value label_025D: // Incoming jump from 0x025C, if not !msg.value // Inputs[1] { @0260 memory[0x00:0x00] } 025D 60 PUSH1 0x00 025F 80 DUP1 0260 FD *REVERT // Stack delta = +0 // Outputs[1] { @0260 revert(memory[0x00:0x00]); } // Block terminates label_0261: // Incoming jump from 0x025C, if !msg.value 0261 5B JUMPDEST 0262 50 POP 0263 61 PUSH2 0x026a 0266 61 PUSH2 0x06cc 0269 56 *JUMP // Stack delta = +0 // Outputs[1] { @0263 stack[-1] = 0x026a } // Block ends with call to 0x06cc, returns to 0x026A label_026A: // Incoming return from call to 0x0EEA at 0x06A0 // Incoming return from call to 0x0A98 at 0x04C5 // Incoming return from call to 0x0E54 at 0x062B // Incoming return from call to 0x0D32 at 0x0580 // Incoming return from call to 0x06CC at 0x0269 // Inputs[2] // { // @026D memory[0x40:0x60] // @0271 stack[-1] // } 026A 5B JUMPDEST 026B 60 PUSH1 0x40 026D 51 MLOAD 026E 61 PUSH2 0x024c 0271 91 SWAP2 0272 90 SWAP1 0273 61 PUSH2 0x194a 0276 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0271 stack[-1] = 0x024c // @0272 stack[1] = memory[0x40:0x60] // @0272 stack[0] = stack[-1] // } // Block ends with call to 0x194a, returns to 0x024C label_0277: // Incoming jump from 0x020E, if 0x081812fc == stack[-1] // Inputs[1] { @0278 msg.value } 0277 5B JUMPDEST 0278 34 CALLVALUE 0279 80 DUP1 027A 15 ISZERO 027B 61 PUSH2 0x0283 027E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0278 stack[0] = msg.value } // Block ends with conditional jump to 0x0283, if !msg.value label_027F: // Incoming jump from 0x027E, if not !msg.value // Inputs[1] { @0282 memory[0x00:0x00] } 027F 60 PUSH1 0x00 0281 80 DUP1 0282 FD *REVERT // Stack delta = +0 // Outputs[1] { @0282 revert(memory[0x00:0x00]); } // Block terminates label_0283: // Incoming jump from 0x027E, if !msg.value // Inputs[1] { @028B msg.data.length } 0283 5B JUMPDEST 0284 50 POP 0285 61 PUSH2 0x0297 0288 61 PUSH2 0x0292 028B 36 CALLDATASIZE 028C 60 PUSH1 0x04 028E 61 PUSH2 0x196c 0291 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0285 stack[-1] = 0x0297 // @0288 stack[0] = 0x0292 // @028B stack[1] = msg.data.length // @028C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x196c 0292 5B JUMPDEST 0293 61 PUSH2 0x075e 0296 56 *JUMP label_0297: // Incoming jump from 0x066B // Incoming jump from 0x041B // Incoming jump from 0x054B // Inputs[2] // { // @029A memory[0x40:0x60] // @029E stack[-1] // } 0297 5B JUMPDEST 0298 60 PUSH1 0x40 029A 51 MLOAD 029B 61 PUSH2 0x024c 029E 91 SWAP2 029F 90 SWAP1 02A0 61 PUSH2 0x19a7 02A3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @029E stack[-1] = 0x024c // @029F stack[1] = memory[0x40:0x60] // @029F stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x19a7 label_02A4: // Incoming jump from 0x0219, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02A5 msg.value } 02A4 5B JUMPDEST 02A5 34 CALLVALUE 02A6 80 DUP1 02A7 15 ISZERO 02A8 61 PUSH2 0x02b0 02AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A5 stack[0] = msg.value } // Block ends with conditional jump to 0x02b0, if !msg.value label_02AC: // Incoming jump from 0x02AB, if not !msg.value // Inputs[1] { @02AF memory[0x00:0x00] } 02AC 60 PUSH1 0x00 02AE 80 DUP1 02AF FD *REVERT // Stack delta = +0 // Outputs[1] { @02AF revert(memory[0x00:0x00]); } // Block terminates label_02B0: // Incoming jump from 0x02AB, if !msg.value // Inputs[1] { @02B8 msg.data.length } 02B0 5B JUMPDEST 02B1 50 POP 02B2 61 PUSH2 0x02c4 02B5 61 PUSH2 0x02bf 02B8 36 CALLDATASIZE 02B9 60 PUSH1 0x04 02BB 61 PUSH2 0x19c9 02BE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B2 stack[-1] = 0x02c4 // @02B5 stack[0] = 0x02bf // @02B8 stack[1] = msg.data.length // @02B9 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x19c9 02BF 5B JUMPDEST 02C0 61 PUSH2 0x07b7 02C3 56 *JUMP label_02C4: // Incoming return from call to 0x0B6A at 0x04FA // Incoming return from call to 0x096D at 0x0430 02C4 5B JUMPDEST 02C5 00 *STOP // Stack delta = +0 // Outputs[1] { @02C5 stop(); } // Block terminates label_02C6: // Incoming jump from 0x01BC, if 0x0a398b88 == stack[-1] // Inputs[1] { @02C7 msg.value } 02C6 5B JUMPDEST 02C7 34 CALLVALUE 02C8 80 DUP1 02C9 15 ISZERO 02CA 61 PUSH2 0x02d2 02CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C7 stack[0] = msg.value } // Block ends with conditional jump to 0x02d2, if !msg.value label_02CE: // Incoming jump from 0x02CD, if not !msg.value // Inputs[1] { @02D1 memory[0x00:0x00] } 02CE 60 PUSH1 0x00 02D0 80 DUP1 02D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D1 revert(memory[0x00:0x00]); } // Block terminates label_02D2: // Incoming jump from 0x02CD, if !msg.value // Inputs[1] { @02DA msg.data.length } 02D2 5B JUMPDEST 02D3 50 POP 02D4 61 PUSH2 0x02fc 02D7 61 PUSH2 0x02e1 02DA 36 CALLDATASIZE 02DB 60 PUSH1 0x04 02DD 61 PUSH2 0x1a06 02E0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D4 stack[-1] = 0x02fc // @02D7 stack[0] = 0x02e1 // @02DA stack[1] = msg.data.length // @02DB stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1a06 02E1 5B JUMPDEST 02E2 60 PUSH1 0x01 02E4 60 PUSH1 0x01 02E6 60 PUSH1 0xa0 02E8 1B SHL 02E9 03 SUB 02EA 16 AND 02EB 60 PUSH1 0x00 02ED 90 SWAP1 02EE 81 DUP2 02EF 52 MSTORE 02F0 60 PUSH1 0x0f 02F2 60 PUSH1 0x20 02F4 52 MSTORE 02F5 60 PUSH1 0x40 02F7 90 SWAP1 02F8 20 SHA3 02F9 54 SLOAD 02FA 90 SWAP1 02FB 56 *JUMP label_02FC: // Incoming jump from 0x0596 // Incoming jump from 0x033D // Incoming jump from 0x03FB // Inputs[2] // { // @02FF memory[0x40:0x60] // @0303 stack[-1] // } 02FC 5B JUMPDEST 02FD 60 PUSH1 0x40 02FF 51 MLOAD 0300 61 PUSH2 0x024c 0303 91 SWAP2 0304 90 SWAP1 0305 61 PUSH2 0x1a2d 0308 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0303 stack[-1] = 0x024c // @0304 stack[1] = memory[0x40:0x60] // @0304 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1a2d label_0309: // Incoming jump from 0x01C7, if 0x10969523 == stack[-1] // Inputs[1] { @030A msg.value } 0309 5B JUMPDEST 030A 34 CALLVALUE 030B 80 DUP1 030C 15 ISZERO 030D 61 PUSH2 0x0315 0310 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030A stack[0] = msg.value } // Block ends with conditional jump to 0x0315, if !msg.value label_0311: // Incoming jump from 0x0310, if not !msg.value // Inputs[1] { @0314 memory[0x00:0x00] } 0311 60 PUSH1 0x00 0313 80 DUP1 0314 FD *REVERT // Stack delta = +0 // Outputs[1] { @0314 revert(memory[0x00:0x00]); } // Block terminates label_0315: // Incoming jump from 0x0310, if !msg.value // Inputs[1] { @031D msg.data.length } 0315 5B JUMPDEST 0316 50 POP 0317 61 PUSH2 0x02c4 031A 61 PUSH2 0x0324 031D 36 CALLDATASIZE 031E 60 PUSH1 0x04 0320 61 PUSH2 0x1a86 0323 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0317 stack[-1] = 0x02c4 // @031A stack[0] = 0x0324 // @031D stack[1] = msg.data.length // @031E stack[2] = 0x04 // } // Block ends with call to 0x1a86, returns to 0x0324 label_0324: // Incoming return from call to 0x1A86 at 0x0323 0324 5B JUMPDEST 0325 61 PUSH2 0x083d 0328 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x083d label_0329: // Incoming jump from 0x01D2, if 0x18160ddd == stack[-1] // Inputs[1] { @032A msg.value } 0329 5B JUMPDEST 032A 34 CALLVALUE 032B 80 DUP1 032C 15 ISZERO 032D 61 PUSH2 0x0335 0330 57 *JUMPI // Stack delta = +1 // Outputs[1] { @032A stack[0] = msg.value } // Block ends with conditional jump to 0x0335, if !msg.value label_0331: // Incoming jump from 0x0330, if not !msg.value // Inputs[1] { @0334 memory[0x00:0x00] } 0331 60 PUSH1 0x00 0333 80 DUP1 0334 FD *REVERT // Stack delta = +0 // Outputs[1] { @0334 revert(memory[0x00:0x00]); } // Block terminates label_0335: // Incoming jump from 0x0330, if !msg.value // Inputs[1] { @0339 storage[0x09] } 0335 5B JUMPDEST 0336 50 POP 0337 60 PUSH1 0x09 0339 54 SLOAD 033A 61 PUSH2 0x02fc 033D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0339 stack[-1] = storage[0x09] } // Block ends with unconditional jump to 0x02fc label_033E: // Incoming jump from 0x01DD, if 0x1c31f710 == stack[-1] // Inputs[1] { @033F msg.value } 033E 5B JUMPDEST 033F 34 CALLVALUE 0340 80 DUP1 0341 15 ISZERO 0342 61 PUSH2 0x034a 0345 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033F stack[0] = msg.value } // Block ends with conditional jump to 0x034a, if !msg.value label_0346: // Incoming jump from 0x0345, if not !msg.value // Inputs[1] { @0349 memory[0x00:0x00] } 0346 60 PUSH1 0x00 0348 80 DUP1 0349 FD *REVERT // Stack delta = +0 // Outputs[1] { @0349 revert(memory[0x00:0x00]); } // Block terminates label_034A: // Incoming jump from 0x0345, if !msg.value // Inputs[1] { @0352 msg.data.length } 034A 5B JUMPDEST 034B 50 POP 034C 61 PUSH2 0x02c4 034F 61 PUSH2 0x0359 0352 36 CALLDATASIZE 0353 60 PUSH1 0x04 0355 61 PUSH2 0x1a06 0358 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @034C stack[-1] = 0x02c4 // @034F stack[0] = 0x0359 // @0352 stack[1] = msg.data.length // @0353 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1a06 0359 5B JUMPDEST 035A 61 PUSH2 0x0873 035D 56 *JUMP label_035E: // Incoming jump from 0x01E8, if 0x22f3e2d4 == stack[-1] // Inputs[1] { @035F msg.value } 035E 5B JUMPDEST 035F 34 CALLVALUE 0360 80 DUP1 0361 15 ISZERO 0362 61 PUSH2 0x036a 0365 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035F stack[0] = msg.value } // Block ends with conditional jump to 0x036a, if !msg.value label_0366: // Incoming jump from 0x0365, if not !msg.value // Inputs[1] { @0369 memory[0x00:0x00] } 0366 60 PUSH1 0x00 0368 80 DUP1 0369 FD *REVERT // Stack delta = +0 // Outputs[1] { @0369 revert(memory[0x00:0x00]); } // Block terminates label_036A: // Incoming jump from 0x0365, if !msg.value // Inputs[1] { @036E storage[0x0c] } 036A 5B JUMPDEST 036B 50 POP 036C 60 PUSH1 0x0c 036E 54 SLOAD 036F 61 PUSH2 0x023f 0372 90 SWAP1 0373 60 PUSH1 0xff 0375 16 AND 0376 81 DUP2 0377 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0372 stack[-1] = 0x023f // @0375 stack[0] = 0xff & storage[0x0c] // } // Block ends with unconditional jump to 0x023f label_0378: // Incoming jump from 0x0180, if 0x23b872dd == stack[-1] // Inputs[1] { @0379 msg.value } 0378 5B JUMPDEST 0379 34 CALLVALUE 037A 80 DUP1 037B 15 ISZERO 037C 61 PUSH2 0x0384 037F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0379 stack[0] = msg.value } // Block ends with conditional jump to 0x0384, if !msg.value label_0380: // Incoming jump from 0x037F, if not !msg.value // Inputs[1] { @0383 memory[0x00:0x00] } 0380 60 PUSH1 0x00 0382 80 DUP1 0383 FD *REVERT // Stack delta = +0 // Outputs[1] { @0383 revert(memory[0x00:0x00]); } // Block terminates label_0384: // Incoming jump from 0x037F, if !msg.value // Inputs[1] { @038C msg.data.length } 0384 5B JUMPDEST 0385 50 POP 0386 61 PUSH2 0x02c4 0389 61 PUSH2 0x0393 038C 36 CALLDATASIZE 038D 60 PUSH1 0x04 038F 61 PUSH2 0x1ace 0392 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0386 stack[-1] = 0x02c4 // @0389 stack[0] = 0x0393 // @038C stack[1] = msg.data.length // @038D stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1ace 0393 5B JUMPDEST 0394 61 PUSH2 0x08bf 0397 56 *JUMP label_0398: // Incoming jump from 0x018B, if 0x2a55205a == stack[-1] // Inputs[1] { @0399 msg.value } 0398 5B JUMPDEST 0399 34 CALLVALUE 039A 80 DUP1 039B 15 ISZERO 039C 61 PUSH2 0x03a4 039F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0399 stack[0] = msg.value } // Block ends with conditional jump to 0x03a4, if !msg.value label_03A0: // Incoming jump from 0x039F, if not !msg.value // Inputs[1] { @03A3 memory[0x00:0x00] } 03A0 60 PUSH1 0x00 03A2 80 DUP1 03A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A3 revert(memory[0x00:0x00]); } // Block terminates label_03A4: // Incoming jump from 0x039F, if !msg.value // Inputs[1] { @03AC msg.data.length } 03A4 5B JUMPDEST 03A5 50 POP 03A6 61 PUSH2 0x03b8 03A9 61 PUSH2 0x03b3 03AC 36 CALLDATASIZE 03AD 60 PUSH1 0x04 03AF 61 PUSH2 0x1b1e 03B2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03A6 stack[-1] = 0x03b8 // @03A9 stack[0] = 0x03b3 // @03AC stack[1] = msg.data.length // @03AD stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1b1e 03B3 5B JUMPDEST 03B4 61 PUSH2 0x08f0 03B7 56 *JUMP 03B8 5B JUMPDEST 03B9 60 PUSH1 0x40 03BB 51 MLOAD 03BC 61 PUSH2 0x024c 03BF 92 SWAP3 03C0 91 SWAP2 03C1 90 SWAP1 03C2 61 PUSH2 0x1b40 03C5 56 *JUMP label_03C6: // Incoming jump from 0x0196, if 0x2a9e63c6 == stack[-1] // Inputs[1] { @03C7 msg.value } 03C6 5B JUMPDEST 03C7 34 CALLVALUE 03C8 80 DUP1 03C9 15 ISZERO 03CA 61 PUSH2 0x03d2 03CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C7 stack[0] = msg.value } // Block ends with conditional jump to 0x03d2, if !msg.value label_03CE: // Incoming jump from 0x03CD, if not !msg.value // Inputs[1] { @03D1 memory[0x00:0x00] } 03CE 60 PUSH1 0x00 03D0 80 DUP1 03D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D1 revert(memory[0x00:0x00]); } // Block terminates label_03D2: // Incoming jump from 0x03CD, if !msg.value // Inputs[1] { @03DA msg.data.length } 03D2 5B JUMPDEST 03D3 50 POP 03D4 61 PUSH2 0x02c4 03D7 61 PUSH2 0x03e1 03DA 36 CALLDATASIZE 03DB 60 PUSH1 0x04 03DD 61 PUSH2 0x1a06 03E0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D4 stack[-1] = 0x02c4 // @03D7 stack[0] = 0x03e1 // @03DA stack[1] = msg.data.length // @03DB stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1a06 03E1 5B JUMPDEST 03E2 61 PUSH2 0x0921 03E5 56 *JUMP label_03E6: // Incoming jump from 0x01A1, if 0x2eb4a7ab == stack[-1] // Inputs[1] { @03E7 msg.value } 03E6 5B JUMPDEST 03E7 34 CALLVALUE 03E8 80 DUP1 03E9 15 ISZERO 03EA 61 PUSH2 0x03f2 03ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E7 stack[0] = msg.value } // Block ends with conditional jump to 0x03f2, if !msg.value label_03EE: // Incoming jump from 0x03ED, if not !msg.value // Inputs[1] { @03F1 memory[0x00:0x00] } 03EE 60 PUSH1 0x00 03F0 80 DUP1 03F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F1 revert(memory[0x00:0x00]); } // Block terminates label_03F2: // Incoming jump from 0x03ED, if !msg.value // Inputs[1] { @03F9 storage[0x0e] } 03F2 5B JUMPDEST 03F3 50 POP 03F4 61 PUSH2 0x02fc 03F7 60 PUSH1 0x0e 03F9 54 SLOAD 03FA 81 DUP2 03FB 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03F4 stack[-1] = 0x02fc // @03F9 stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x02fc label_03FC: // Incoming jump from 0x0144, if 0x38af3eed == stack[-1] // Inputs[1] { @03FD msg.value } 03FC 5B JUMPDEST 03FD 34 CALLVALUE 03FE 80 DUP1 03FF 15 ISZERO 0400 61 PUSH2 0x0408 0403 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FD stack[0] = msg.value } // Block ends with conditional jump to 0x0408, if !msg.value label_0404: // Incoming jump from 0x0403, if not !msg.value // Inputs[1] { @0407 memory[0x00:0x00] } 0404 60 PUSH1 0x00 0406 80 DUP1 0407 FD *REVERT // Stack delta = +0 // Outputs[1] { @0407 revert(memory[0x00:0x00]); } // Block terminates label_0408: // Incoming jump from 0x0403, if !msg.value // Inputs[1] { @040C storage[0x10] } 0408 5B JUMPDEST 0409 50 POP 040A 60 PUSH1 0x10 040C 54 SLOAD 040D 61 PUSH2 0x0297 0410 90 SWAP1 0411 60 PUSH1 0x01 0413 60 PUSH1 0x01 0415 60 PUSH1 0xa0 0417 1B SHL 0418 03 SUB 0419 16 AND 041A 81 DUP2 041B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0410 stack[-1] = 0x0297 // @0419 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x10] // } // Block ends with unconditional jump to 0x0297 label_041C: // Incoming jump from 0x014F, if 0x3ccfd60b == stack[-1] // Inputs[1] { @041D msg.value } 041C 5B JUMPDEST 041D 34 CALLVALUE 041E 80 DUP1 041F 15 ISZERO 0420 61 PUSH2 0x0428 0423 57 *JUMPI // Stack delta = +1 // Outputs[1] { @041D stack[0] = msg.value } // Block ends with conditional jump to 0x0428, if !msg.value label_0424: // Incoming jump from 0x0423, if not !msg.value // Inputs[1] { @0427 memory[0x00:0x00] } 0424 60 PUSH1 0x00 0426 80 DUP1 0427 FD *REVERT // Stack delta = +0 // Outputs[1] { @0427 revert(memory[0x00:0x00]); } // Block terminates label_0428: // Incoming jump from 0x0423, if !msg.value 0428 5B JUMPDEST 0429 50 POP 042A 61 PUSH2 0x02c4 042D 61 PUSH2 0x096d 0430 56 *JUMP // Stack delta = +0 // Outputs[1] { @042A stack[-1] = 0x02c4 } // Block ends with call to 0x096d, returns to 0x02C4 label_0431: // Incoming jump from 0x015A, if 0x42842e0e == stack[-1] // Inputs[1] { @0432 msg.value } 0431 5B JUMPDEST 0432 34 CALLVALUE 0433 80 DUP1 0434 15 ISZERO 0435 61 PUSH2 0x043d 0438 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0432 stack[0] = msg.value } // Block ends with conditional jump to 0x043d, if !msg.value label_0439: // Incoming jump from 0x0438, if not !msg.value // Inputs[1] { @043C memory[0x00:0x00] } 0439 60 PUSH1 0x00 043B 80 DUP1 043C FD *REVERT // Stack delta = +0 // Outputs[1] { @043C revert(memory[0x00:0x00]); } // Block terminates label_043D: // Incoming jump from 0x0438, if !msg.value // Inputs[1] { @0445 msg.data.length } 043D 5B JUMPDEST 043E 50 POP 043F 61 PUSH2 0x02c4 0442 61 PUSH2 0x044c 0445 36 CALLDATASIZE 0446 60 PUSH1 0x04 0448 61 PUSH2 0x1ace 044B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @043F stack[-1] = 0x02c4 // @0442 stack[0] = 0x044c // @0445 stack[1] = msg.data.length // @0446 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1ace 044C 5B JUMPDEST 044D 61 PUSH2 0x09d3 0450 56 *JUMP label_0451: // Incoming jump from 0x0165, if 0x484b973c == stack[-1] // Inputs[1] { @0452 msg.value } 0451 5B JUMPDEST 0452 34 CALLVALUE 0453 80 DUP1 0454 15 ISZERO 0455 61 PUSH2 0x045d 0458 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0452 stack[0] = msg.value } // Block ends with conditional jump to 0x045d, if !msg.value label_0459: // Incoming jump from 0x0458, if not !msg.value // Inputs[1] { @045C memory[0x00:0x00] } 0459 60 PUSH1 0x00 045B 80 DUP1 045C FD *REVERT // Stack delta = +0 // Outputs[1] { @045C revert(memory[0x00:0x00]); } // Block terminates label_045D: // Incoming jump from 0x0458, if !msg.value // Inputs[1] { @0465 msg.data.length } 045D 5B JUMPDEST 045E 50 POP 045F 61 PUSH2 0x02c4 0462 61 PUSH2 0x046c 0465 36 CALLDATASIZE 0466 60 PUSH1 0x04 0468 61 PUSH2 0x19c9 046B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045F stack[-1] = 0x02c4 // @0462 stack[0] = 0x046c // @0465 stack[1] = msg.data.length // @0466 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x19c9 046C 5B JUMPDEST 046D 61 PUSH2 0x09ee 0470 56 *JUMP label_0471: // Incoming jump from 0x0170, if 0x55f804b3 == stack[-1] // Inputs[1] { @0472 msg.value } 0471 5B JUMPDEST 0472 34 CALLVALUE 0473 80 DUP1 0474 15 ISZERO 0475 61 PUSH2 0x047d 0478 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0472 stack[0] = msg.value } // Block ends with conditional jump to 0x047d, if !msg.value label_0479: // Incoming jump from 0x0478, if not !msg.value // Inputs[1] { @047C memory[0x00:0x00] } 0479 60 PUSH1 0x00 047B 80 DUP1 047C FD *REVERT // Stack delta = +0 // Outputs[1] { @047C revert(memory[0x00:0x00]); } // Block terminates label_047D: // Incoming jump from 0x0478, if !msg.value // Inputs[1] { @0485 msg.data.length } 047D 5B JUMPDEST 047E 50 POP 047F 61 PUSH2 0x02c4 0482 61 PUSH2 0x048c 0485 36 CALLDATASIZE 0486 60 PUSH1 0x04 0488 61 PUSH2 0x1c4e 048B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @047F stack[-1] = 0x02c4 // @0482 stack[0] = 0x048c // @0485 stack[1] = msg.data.length // @0486 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c4e 048C 5B JUMPDEST 048D 61 PUSH2 0x0a26 0490 56 *JUMP label_0491: // Incoming jump from 0x00FD, if 0x6352211e == stack[-1] // Inputs[1] { @0492 msg.value } 0491 5B JUMPDEST 0492 34 CALLVALUE 0493 80 DUP1 0494 15 ISZERO 0495 61 PUSH2 0x049d 0498 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0492 stack[0] = msg.value } // Block ends with conditional jump to 0x049d, if !msg.value label_0499: // Incoming jump from 0x0498, if not !msg.value // Inputs[1] { @049C memory[0x00:0x00] } 0499 60 PUSH1 0x00 049B 80 DUP1 049C FD *REVERT // Stack delta = +0 // Outputs[1] { @049C revert(memory[0x00:0x00]); } // Block terminates label_049D: // Incoming jump from 0x0498, if !msg.value // Inputs[1] { @04A5 msg.data.length } 049D 5B JUMPDEST 049E 50 POP 049F 61 PUSH2 0x0297 04A2 61 PUSH2 0x04ac 04A5 36 CALLDATASIZE 04A6 60 PUSH1 0x04 04A8 61 PUSH2 0x196c 04AB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @049F stack[-1] = 0x0297 // @04A2 stack[0] = 0x04ac // @04A5 stack[1] = msg.data.length // @04A6 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x196c 04AC 5B JUMPDEST 04AD 61 PUSH2 0x0a63 04B0 56 *JUMP label_04B1: // Incoming jump from 0x0108, if 0x6c0360eb == stack[-1] // Inputs[1] { @04B2 msg.value } 04B1 5B JUMPDEST 04B2 34 CALLVALUE 04B3 80 DUP1 04B4 15 ISZERO 04B5 61 PUSH2 0x04bd 04B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B2 stack[0] = msg.value } // Block ends with conditional jump to 0x04bd, if !msg.value label_04B9: // Incoming jump from 0x04B8, if not !msg.value // Inputs[1] { @04BC memory[0x00:0x00] } 04B9 60 PUSH1 0x00 04BB 80 DUP1 04BC FD *REVERT // Stack delta = +0 // Outputs[1] { @04BC revert(memory[0x00:0x00]); } // Block terminates label_04BD: // Incoming jump from 0x04B8, if !msg.value 04BD 5B JUMPDEST 04BE 50 POP 04BF 61 PUSH2 0x026a 04C2 61 PUSH2 0x0a98 04C5 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BF stack[-1] = 0x026a } // Block ends with call to 0x0a98, returns to 0x026A label_04C6: // Incoming jump from 0x0113, if 0x70a08231 == stack[-1] // Inputs[1] { @04C7 msg.value } 04C6 5B JUMPDEST 04C7 34 CALLVALUE 04C8 80 DUP1 04C9 15 ISZERO 04CA 61 PUSH2 0x04d2 04CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C7 stack[0] = msg.value } // Block ends with conditional jump to 0x04d2, if !msg.value label_04CE: // Incoming jump from 0x04CD, if not !msg.value // Inputs[1] { @04D1 memory[0x00:0x00] } 04CE 60 PUSH1 0x00 04D0 80 DUP1 04D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D1 revert(memory[0x00:0x00]); } // Block terminates label_04D2: // Incoming jump from 0x04CD, if !msg.value // Inputs[1] { @04DA msg.data.length } 04D2 5B JUMPDEST 04D3 50 POP 04D4 61 PUSH2 0x02fc 04D7 61 PUSH2 0x04e1 04DA 36 CALLDATASIZE 04DB 60 PUSH1 0x04 04DD 61 PUSH2 0x1a06 04E0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D4 stack[-1] = 0x02fc // @04D7 stack[0] = 0x04e1 // @04DA stack[1] = msg.data.length // @04DB stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1a06 04E1 5B JUMPDEST 04E2 61 PUSH2 0x0b26 04E5 56 *JUMP label_04E6: // Incoming jump from 0x011E, if 0x715018a6 == stack[-1] // Inputs[1] { @04E7 msg.value } 04E6 5B JUMPDEST 04E7 34 CALLVALUE 04E8 80 DUP1 04E9 15 ISZERO 04EA 61 PUSH2 0x04f2 04ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E7 stack[0] = msg.value } // Block ends with conditional jump to 0x04f2, if !msg.value label_04EE: // Incoming jump from 0x04ED, if not !msg.value // Inputs[1] { @04F1 memory[0x00:0x00] } 04EE 60 PUSH1 0x00 04F0 80 DUP1 04F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F1 revert(memory[0x00:0x00]); } // Block terminates label_04F2: // Incoming jump from 0x04ED, if !msg.value 04F2 5B JUMPDEST 04F3 50 POP 04F4 61 PUSH2 0x02c4 04F7 61 PUSH2 0x0b6a 04FA 56 *JUMP // Stack delta = +0 // Outputs[1] { @04F4 stack[-1] = 0x02c4 } // Block ends with call to 0x0b6a, returns to 0x02C4 label_04FB: // Incoming jump from 0x00C1, if 0x86758912 == stack[-1] // Inputs[1] { @04FC msg.value } 04FB 5B JUMPDEST 04FC 34 CALLVALUE 04FD 80 DUP1 04FE 15 ISZERO 04FF 61 PUSH2 0x0507 0502 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04FC stack[0] = msg.value } // Block ends with conditional jump to 0x0507, if !msg.value label_0503: // Incoming jump from 0x0502, if not !msg.value // Inputs[1] { @0506 memory[0x00:0x00] } 0503 60 PUSH1 0x00 0505 80 DUP1 0506 FD *REVERT // Stack delta = +0 // Outputs[1] { @0506 revert(memory[0x00:0x00]); } // Block terminates label_0507: // Incoming jump from 0x0502, if !msg.value // Inputs[1] { @050F msg.data.length } 0507 5B JUMPDEST 0508 50 POP 0509 61 PUSH2 0x02c4 050C 61 PUSH2 0x0516 050F 36 CALLDATASIZE 0510 60 PUSH1 0x04 0512 61 PUSH2 0x196c 0515 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0509 stack[-1] = 0x02c4 // @050C stack[0] = 0x0516 // @050F stack[1] = msg.data.length // @0510 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x196c 0516 5B JUMPDEST 0517 61 PUSH2 0x0ba0 051A 56 *JUMP label_051B: // Incoming jump from 0x00CC, if 0x87d2d93f == stack[-1] // Inputs[1] { @0522 msg.data.length } 051B 5B JUMPDEST 051C 61 PUSH2 0x02c4 051F 61 PUSH2 0x0529 0522 36 CALLDATASIZE 0523 60 PUSH1 0x04 0525 61 PUSH2 0x1cd4 0528 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @051C stack[0] = 0x02c4 // @051F stack[1] = 0x0529 // @0522 stack[2] = msg.data.length // @0523 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1cd4 0529 5B JUMPDEST 052A 61 PUSH2 0x0bcf 052D 56 *JUMP label_052E: // Incoming jump from 0x00D7, if 0x8da5cb5b == stack[-1] // Inputs[1] { @052F msg.value } 052E 5B JUMPDEST 052F 34 CALLVALUE 0530 80 DUP1 0531 15 ISZERO 0532 61 PUSH2 0x053a 0535 57 *JUMPI // Stack delta = +1 // Outputs[1] { @052F stack[0] = msg.value } // Block ends with conditional jump to 0x053a, if !msg.value label_0536: // Incoming jump from 0x0535, if not !msg.value // Inputs[1] { @0539 memory[0x00:0x00] } 0536 60 PUSH1 0x00 0538 80 DUP1 0539 FD *REVERT // Stack delta = +0 // Outputs[1] { @0539 revert(memory[0x00:0x00]); } // Block terminates label_053A: // Incoming jump from 0x0535, if !msg.value // Inputs[1] { @053E storage[0x06] } 053A 5B JUMPDEST 053B 50 POP 053C 60 PUSH1 0x06 053E 54 SLOAD 053F 60 PUSH1 0x01 0541 60 PUSH1 0x01 0543 60 PUSH1 0xa0 0545 1B SHL 0546 03 SUB 0547 16 AND 0548 61 PUSH2 0x0297 054B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0547 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x06] } // Block ends with unconditional jump to 0x0297 label_054C: // Incoming jump from 0x00E2, if 0x938e3d7b == stack[-1] // Inputs[1] { @054D msg.value } 054C 5B JUMPDEST 054D 34 CALLVALUE 054E 80 DUP1 054F 15 ISZERO 0550 61 PUSH2 0x0558 0553 57 *JUMPI // Stack delta = +1 // Outputs[1] { @054D stack[0] = msg.value } // Block ends with conditional jump to 0x0558, if !msg.value label_0554: // Incoming jump from 0x0553, if not !msg.value // Inputs[1] { @0557 memory[0x00:0x00] } 0554 60 PUSH1 0x00 0556 80 DUP1 0557 FD *REVERT // Stack delta = +0 // Outputs[1] { @0557 revert(memory[0x00:0x00]); } // Block terminates label_0558: // Incoming jump from 0x0553, if !msg.value // Inputs[1] { @0560 msg.data.length } 0558 5B JUMPDEST 0559 50 POP 055A 61 PUSH2 0x02c4 055D 61 PUSH2 0x0567 0560 36 CALLDATASIZE 0561 60 PUSH1 0x04 0563 61 PUSH2 0x1c4e 0566 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055A stack[-1] = 0x02c4 // @055D stack[0] = 0x0567 // @0560 stack[1] = msg.data.length // @0561 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1c4e 0567 5B JUMPDEST 0568 61 PUSH2 0x0cf5 056B 56 *JUMP label_056C: // Incoming jump from 0x00ED, if 0x95d89b41 == stack[-1] // Inputs[1] { @056D msg.value } 056C 5B JUMPDEST 056D 34 CALLVALUE 056E 80 DUP1 056F 15 ISZERO 0570 61 PUSH2 0x0578 0573 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056D stack[0] = msg.value } // Block ends with conditional jump to 0x0578, if !msg.value label_0574: // Incoming jump from 0x0573, if not !msg.value // Inputs[1] { @0577 memory[0x00:0x00] } 0574 60 PUSH1 0x00 0576 80 DUP1 0577 FD *REVERT // Stack delta = +0 // Outputs[1] { @0577 revert(memory[0x00:0x00]); } // Block terminates label_0578: // Incoming jump from 0x0573, if !msg.value 0578 5B JUMPDEST 0579 50 POP 057A 61 PUSH2 0x026a 057D 61 PUSH2 0x0d32 0580 56 *JUMP // Stack delta = +0 // Outputs[1] { @057A stack[-1] = 0x026a } // Block ends with call to 0x0d32, returns to 0x026A label_0581: // Incoming jump from 0x007A, if 0xa035b1fe == stack[-1] // Inputs[1] { @0582 msg.value } 0581 5B JUMPDEST 0582 34 CALLVALUE 0583 80 DUP1 0584 15 ISZERO 0585 61 PUSH2 0x058d 0588 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0582 stack[0] = msg.value } // Block ends with conditional jump to 0x058d, if !msg.value label_0589: // Incoming jump from 0x0588, if not !msg.value // Inputs[1] { @058C memory[0x00:0x00] } 0589 60 PUSH1 0x00 058B 80 DUP1 058C FD *REVERT // Stack delta = +0 // Outputs[1] { @058C revert(memory[0x00:0x00]); } // Block terminates label_058D: // Incoming jump from 0x0588, if !msg.value // Inputs[1] { @0594 storage[0x0d] } 058D 5B JUMPDEST 058E 50 POP 058F 61 PUSH2 0x02fc 0592 60 PUSH1 0x0d 0594 54 SLOAD 0595 81 DUP2 0596 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @058F stack[-1] = 0x02fc // @0594 stack[0] = storage[0x0d] // } // Block ends with unconditional jump to 0x02fc label_0597: // Incoming jump from 0x0085, if 0xa22cb465 == stack[-1] // Inputs[1] { @0598 msg.value } 0597 5B JUMPDEST 0598 34 CALLVALUE 0599 80 DUP1 059A 15 ISZERO 059B 61 PUSH2 0x05a3 059E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0598 stack[0] = msg.value } // Block ends with conditional jump to 0x05a3, if !msg.value label_059F: // Incoming jump from 0x059E, if not !msg.value // Inputs[1] { @05A2 memory[0x00:0x00] } 059F 60 PUSH1 0x00 05A1 80 DUP1 05A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A2 revert(memory[0x00:0x00]); } // Block terminates label_05A3: // Incoming jump from 0x059E, if !msg.value // Inputs[1] { @05AB msg.data.length } 05A3 5B JUMPDEST 05A4 50 POP 05A5 61 PUSH2 0x02c4 05A8 61 PUSH2 0x05b2 05AB 36 CALLDATASIZE 05AC 60 PUSH1 0x04 05AE 61 PUSH2 0x1d57 05B1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05A5 stack[-1] = 0x02c4 // @05A8 stack[0] = 0x05b2 // @05AB stack[1] = msg.data.length // @05AC stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1d57 05B2 5B JUMPDEST 05B3 61 PUSH2 0x0d41 05B6 56 *JUMP label_05B7: // Incoming jump from 0x0090, if 0xacec338a == stack[-1] // Inputs[1] { @05B8 msg.value } 05B7 5B JUMPDEST 05B8 34 CALLVALUE 05B9 80 DUP1 05BA 15 ISZERO 05BB 61 PUSH2 0x05c3 05BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B8 stack[0] = msg.value } // Block ends with conditional jump to 0x05c3, if !msg.value label_05BF: // Incoming jump from 0x05BE, if not !msg.value // Inputs[1] { @05C2 memory[0x00:0x00] } 05BF 60 PUSH1 0x00 05C1 80 DUP1 05C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C2 revert(memory[0x00:0x00]); } // Block terminates label_05C3: // Incoming jump from 0x05BE, if !msg.value // Inputs[1] { @05CB msg.data.length } 05C3 5B JUMPDEST 05C4 50 POP 05C5 61 PUSH2 0x02c4 05C8 61 PUSH2 0x05d2 05CB 36 CALLDATASIZE 05CC 60 PUSH1 0x04 05CE 61 PUSH2 0x1d8a 05D1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C5 stack[-1] = 0x02c4 // @05C8 stack[0] = 0x05d2 // @05CB stack[1] = msg.data.length // @05CC stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1d8a 05D2 5B JUMPDEST 05D3 61 PUSH2 0x0d4c 05D6 56 *JUMP label_05D7: // Incoming jump from 0x009B, if 0xb88d4fde == stack[-1] // Inputs[1] { @05D8 msg.value } 05D7 5B JUMPDEST 05D8 34 CALLVALUE 05D9 80 DUP1 05DA 15 ISZERO 05DB 61 PUSH2 0x05e3 05DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D8 stack[0] = msg.value } // Block ends with conditional jump to 0x05e3, if !msg.value label_05DF: // Incoming jump from 0x05DE, if not !msg.value // Inputs[1] { @05E2 memory[0x00:0x00] } 05DF 60 PUSH1 0x00 05E1 80 DUP1 05E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E2 revert(memory[0x00:0x00]); } // Block terminates label_05E3: // Incoming jump from 0x05DE, if !msg.value // Inputs[1] { @05EB msg.data.length } 05E3 5B JUMPDEST 05E4 50 POP 05E5 61 PUSH2 0x02c4 05E8 61 PUSH2 0x05f2 05EB 36 CALLDATASIZE 05EC 60 PUSH1 0x04 05EE 61 PUSH2 0x1dab 05F1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E5 stack[-1] = 0x02c4 // @05E8 stack[0] = 0x05f2 // @05EB stack[1] = msg.data.length // @05EC stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1dab 05F2 5B JUMPDEST 05F3 61 PUSH2 0x0d89 05F6 56 *JUMP label_05F7: // Incoming jump from 0x00A6, if 0xc87b56dd == stack[-1] // Inputs[1] { @05F8 msg.value } 05F7 5B JUMPDEST 05F8 34 CALLVALUE 05F9 80 DUP1 05FA 15 ISZERO 05FB 61 PUSH2 0x0603 05FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0603, if !msg.value label_05FF: // Incoming jump from 0x05FE, if not !msg.value // Inputs[1] { @0602 memory[0x00:0x00] } 05FF 60 PUSH1 0x00 0601 80 DUP1 0602 FD *REVERT // Stack delta = +0 // Outputs[1] { @0602 revert(memory[0x00:0x00]); } // Block terminates label_0603: // Incoming jump from 0x05FE, if !msg.value // Inputs[1] { @060B msg.data.length } 0603 5B JUMPDEST 0604 50 POP 0605 61 PUSH2 0x026a 0608 61 PUSH2 0x0612 060B 36 CALLDATASIZE 060C 60 PUSH1 0x04 060E 61 PUSH2 0x196c 0611 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0605 stack[-1] = 0x026a // @0608 stack[0] = 0x0612 // @060B stack[1] = msg.data.length // @060C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x196c 0612 5B JUMPDEST 0613 61 PUSH2 0x0dc1 0616 56 *JUMP label_0617: // Incoming jump from 0x003E, if 0xe8a3d485 == stack[-1] // Inputs[1] { @0618 msg.value } 0617 5B JUMPDEST 0618 34 CALLVALUE 0619 80 DUP1 061A 15 ISZERO 061B 61 PUSH2 0x0623 061E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0618 stack[0] = msg.value } // Block ends with conditional jump to 0x0623, if !msg.value label_061F: // Incoming jump from 0x061E, if not !msg.value // Inputs[1] { @0622 memory[0x00:0x00] } 061F 60 PUSH1 0x00 0621 80 DUP1 0622 FD *REVERT // Stack delta = +0 // Outputs[1] { @0622 revert(memory[0x00:0x00]); } // Block terminates label_0623: // Incoming jump from 0x061E, if !msg.value 0623 5B JUMPDEST 0624 50 POP 0625 61 PUSH2 0x026a 0628 61 PUSH2 0x0e54 062B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0625 stack[-1] = 0x026a } // Block ends with call to 0x0e54, returns to 0x026A label_062C: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @062D msg.value } 062C 5B JUMPDEST 062D 34 CALLVALUE 062E 80 DUP1 062F 15 ISZERO 0630 61 PUSH2 0x0638 0633 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062D stack[0] = msg.value } // Block ends with conditional jump to 0x0638, if !msg.value label_0634: // Incoming jump from 0x0633, if not !msg.value // Inputs[1] { @0637 memory[0x00:0x00] } 0634 60 PUSH1 0x00 0636 80 DUP1 0637 FD *REVERT // Stack delta = +0 // Outputs[1] { @0637 revert(memory[0x00:0x00]); } // Block terminates label_0638: // Incoming jump from 0x0633, if !msg.value // Inputs[1] { @0640 msg.data.length } 0638 5B JUMPDEST 0639 50 POP 063A 61 PUSH2 0x023f 063D 61 PUSH2 0x0647 0640 36 CALLDATASIZE 0641 60 PUSH1 0x04 0643 61 PUSH2 0x1e1e 0646 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @063A stack[-1] = 0x023f // @063D stack[0] = 0x0647 // @0640 stack[1] = msg.data.length // @0641 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1e1e 0647 5B JUMPDEST 0648 61 PUSH2 0x0e63 064B 56 *JUMP label_064C: // Incoming jump from 0x0054, if 0xf053dc5c == 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] { @065C storage[0x11] } 0658 5B JUMPDEST 0659 50 POP 065A 60 PUSH1 0x11 065C 54 SLOAD 065D 61 PUSH2 0x0297 0660 90 SWAP1 0661 60 PUSH1 0x01 0663 60 PUSH1 0x01 0665 60 PUSH1 0xa0 0667 1B SHL 0668 03 SUB 0669 16 AND 066A 81 DUP2 066B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0660 stack[-1] = 0x0297 // @0669 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x11] // } // Block ends with unconditional jump to 0x0297 label_066C: // Incoming jump from 0x005F, if 0xf2fde38b == 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 // Inputs[1] { @0680 msg.data.length } 0678 5B JUMPDEST 0679 50 POP 067A 61 PUSH2 0x02c4 067D 61 PUSH2 0x0687 0680 36 CALLDATASIZE 0681 60 PUSH1 0x04 0683 61 PUSH2 0x1a06 0686 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @067A stack[-1] = 0x02c4 // @067D stack[0] = 0x0687 // @0680 stack[1] = msg.data.length // @0681 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1a06 0687 5B JUMPDEST 0688 61 PUSH2 0x0e91 068B 56 *JUMP label_068C: // Incoming jump from 0x006A, if 0xff1b6556 == stack[-1] // Inputs[1] { @068D msg.value } 068C 5B JUMPDEST 068D 34 CALLVALUE 068E 80 DUP1 068F 15 ISZERO 0690 61 PUSH2 0x0698 0693 57 *JUMPI // Stack delta = +1 // Outputs[1] { @068D stack[0] = msg.value } // Block ends with conditional jump to 0x0698, if !msg.value label_0694: // Incoming jump from 0x0693, if not !msg.value // Inputs[1] { @0697 memory[0x00:0x00] } 0694 60 PUSH1 0x00 0696 80 DUP1 0697 FD *REVERT // Stack delta = +0 // Outputs[1] { @0697 revert(memory[0x00:0x00]); } // Block terminates label_0698: // Incoming jump from 0x0693, if !msg.value 0698 5B JUMPDEST 0699 50 POP 069A 61 PUSH2 0x026a 069D 61 PUSH2 0x0eea 06A0 56 *JUMP // Stack delta = +0 // Outputs[1] { @069A stack[-1] = 0x026a } // Block ends with call to 0x0eea, returns to 0x026A 06A1 5B JUMPDEST 06A2 60 PUSH1 0x00 06A4 60 PUSH1 0x01 06A6 60 PUSH1 0x01 06A8 60 PUSH1 0xe0 06AA 1B SHL 06AB 03 SUB 06AC 19 NOT 06AD 82 DUP3 06AE 16 AND 06AF 63 PUSH4 0x152a902d 06B4 60 PUSH1 0xe1 06B6 1B SHL 06B7 14 EQ 06B8 80 DUP1 06B9 61 PUSH2 0x06c6 06BC 57 *JUMPI 06BD 50 POP 06BE 61 PUSH2 0x06c6 06C1 82 DUP3 06C2 61 PUSH2 0x0ef7 06C5 56 *JUMP label_06C6: // Incoming return from call to 0x195B at 0x196B // Incoming return from call to 0x1FA8 at 0x1FEC // Incoming return from call to 0x1891 at 0x18B2 // Incoming return from call to 0x1D44 at 0x1D56 // Incoming return from call to 0x1A27 at 0x1A3A // Incoming return from call to 0x18D4 at 0x18EB // Incoming jump from 0x199D // Inputs[3] // { // @06C7 stack[-4] // @06C7 stack[-1] // @06C8 stack[-3] // } 06C6 5B JUMPDEST 06C7 92 SWAP3 06C8 91 SWAP2 06C9 50 POP 06CA 50 POP 06CB 56 *JUMP // Stack delta = -3 // Outputs[1] { @06C7 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_06CC: // Incoming call from 0x0269, returns to 0x026A // Inputs[1] { @06D2 storage[0x00] } 06CC 5B JUMPDEST 06CD 60 PUSH1 0x60 06CF 60 PUSH1 0x00 06D1 80 DUP1 06D2 54 SLOAD 06D3 61 PUSH2 0x06db 06D6 90 SWAP1 06D7 61 PUSH2 0x1e67 06DA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06CD stack[0] = 0x60 // @06CF stack[1] = 0x00 // @06D6 stack[2] = 0x06db // @06D6 stack[3] = storage[0x00] // } // Block ends with call to 0x1e67, returns to 0x06DB label_06DB: // Incoming return from call to 0x1E67 at 0x06DA // Incoming return from call to 0x1E67 at 0x0E62 // Incoming return from call to 0x1E67 at 0x0D40 // Inputs[4] // { // @06DC stack[-1] // @06EB memory[0x40:0x60] // @06F3 stack[-2] // @06FE storage[stack[-2]] // } 06DB 5B JUMPDEST 06DC 80 DUP1 06DD 60 PUSH1 0x1f 06DF 01 ADD 06E0 60 PUSH1 0x20 06E2 80 DUP1 06E3 91 SWAP2 06E4 04 DIV 06E5 02 MUL 06E6 60 PUSH1 0x20 06E8 01 ADD 06E9 60 PUSH1 0x40 06EB 51 MLOAD 06EC 90 SWAP1 06ED 81 DUP2 06EE 01 ADD 06EF 60 PUSH1 0x40 06F1 52 MSTORE 06F2 80 DUP1 06F3 92 SWAP3 06F4 91 SWAP2 06F5 90 SWAP1 06F6 81 DUP2 06F7 81 DUP2 06F8 52 MSTORE 06F9 60 PUSH1 0x20 06FB 01 ADD 06FC 82 DUP3 06FD 80 DUP1 06FE 54 SLOAD 06FF 61 PUSH2 0x0707 0702 90 SWAP1 0703 61 PUSH2 0x1e67 0706 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06F1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06F3 stack[-2] = memory[0x40:0x60] // @06F4 stack[-1] = stack[-2] // @06F5 stack[0] = stack[-1] // @06F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06FB stack[1] = 0x20 + memory[0x40:0x60] // @06FC stack[2] = stack[-2] // @0702 stack[4] = storage[stack[-2]] // @0702 stack[3] = 0x0707 // } // Block ends with call to 0x1e67, returns to 0x0707 label_0707: // Incoming return from call to 0x1E67 at 0x0706 // Inputs[1] { @0708 stack[-1] } 0707 5B JUMPDEST 0708 80 DUP1 0709 15 ISZERO 070A 61 PUSH2 0x0754 070D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0754, if !stack[-1] label_070E: // Incoming jump from 0x070D, if not !stack[-1] // Inputs[1] { @070E stack[-1] } 070E 80 DUP1 070F 60 PUSH1 0x1f 0711 10 LT 0712 61 PUSH2 0x0729 0715 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0729, if 0x1f < stack[-1] label_0716: // Incoming jump from 0x0715, if not 0x1f < stack[-1] // Inputs[4] // { // @071A stack[-2] // @071B storage[stack[-2]] // @071E stack[-3] // @0720 stack[-1] // } 0716 61 PUSH2 0x0100 0719 80 DUP1 071A 83 DUP4 071B 54 SLOAD 071C 04 DIV 071D 02 MUL 071E 83 DUP4 071F 52 MSTORE 0720 91 SWAP2 0721 60 PUSH1 0x20 0723 01 ADD 0724 91 SWAP2 0725 61 PUSH2 0x0754 0728 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @071F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0724 stack[-1] = stack[-1] // @0724 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0754 label_0729: // Incoming jump from 0x0715, if 0x1f < stack[-1] // Inputs[5] // { // @072A stack[-3] // @072B stack[-1] // @072D stack[-2] // @0735 memory[0x00:0x20] // @0739 storage[keccak256(memory[0x00:0x20])] // } 0729 5B JUMPDEST 072A 82 DUP3 072B 01 ADD 072C 91 SWAP2 072D 90 SWAP1 072E 60 PUSH1 0x00 0730 52 MSTORE 0731 60 PUSH1 0x20 0733 60 PUSH1 0x00 0735 20 SHA3 0736 90 SWAP1 0737 5B JUMPDEST 0738 81 DUP2 0739 54 SLOAD 073A 81 DUP2 073B 52 MSTORE 073C 90 SWAP1 073D 60 PUSH1 0x01 073F 01 ADD 0740 90 SWAP1 0741 60 PUSH1 0x20 0743 01 ADD 0744 80 DUP1 0745 83 DUP4 0746 11 GT 0747 61 PUSH2 0x0737 074A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @072C stack[-3] = stack[-3] + stack[-1] // @0730 memory[0x00:0x20] = stack[-2] // @073B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0740 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0743 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0737, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_074B: // Incoming jump from 0x074A, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x074A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @074B stack[-3] // @074C stack[-1] // } 074B 82 DUP3 074C 90 SWAP1 074D 03 SUB 074E 60 PUSH1 0x1f 0750 16 AND 0751 82 DUP3 0752 01 ADD 0753 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0753 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0753 stack[-1] = stack[-3] // } // Block continues label_0754: // Incoming jump from 0x070D, if !stack[-1] // Incoming jump from 0x0753 // Incoming jump from 0x0728 // Inputs[3] // { // @075A stack[-6] // @075A stack[-7] // @075C stack[-8] // } 0754 5B JUMPDEST 0755 50 POP 0756 50 POP 0757 50 POP 0758 50 POP 0759 50 POP 075A 90 SWAP1 075B 50 POP 075C 90 SWAP1 075D 56 *JUMP // Stack delta = -7 // Outputs[1] { @075C stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] 075E 5B JUMPDEST 075F 60 PUSH1 0x00 0761 81 DUP2 0762 81 DUP2 0763 52 MSTORE 0764 60 PUSH1 0x02 0766 60 PUSH1 0x20 0768 52 MSTORE 0769 60 PUSH1 0x40 076B 81 DUP2 076C 20 SHA3 076D 54 SLOAD 076E 60 PUSH1 0x01 0770 60 PUSH1 0x01 0772 60 PUSH1 0xa0 0774 1B SHL 0775 03 SUB 0776 16 AND 0777 61 PUSH2 0x079b 077A 57 *JUMPI 077B 60 PUSH1 0x40 077D 51 MLOAD 077E 62 PUSH3 0x461bcd 0782 60 PUSH1 0xe5 0784 1B SHL 0785 81 DUP2 0786 52 MSTORE 0787 60 PUSH1 0x04 0789 01 ADD 078A 61 PUSH2 0x0792 078D 90 SWAP1 078E 61 PUSH2 0x1ee0 0791 56 *JUMP 0792 5B JUMPDEST 0793 60 PUSH1 0x40 0795 51 MLOAD 0796 80 DUP1 0797 91 SWAP2 0798 03 SUB 0799 90 SWAP1 079A FD *REVERT 079B 5B JUMPDEST 079C 50 POP 079D 60 PUSH1 0x00 079F 90 SWAP1 07A0 81 DUP2 07A1 52 MSTORE 07A2 60 PUSH1 0x04 07A4 60 PUSH1 0x20 07A6 52 MSTORE 07A7 60 PUSH1 0x40 07A9 90 SWAP1 07AA 20 SHA3 07AB 54 SLOAD 07AC 60 PUSH1 0x01 07AE 60 PUSH1 0x01 07B0 60 PUSH1 0xa0 07B2 1B SHL 07B3 03 SUB 07B4 16 AND 07B5 90 SWAP1 07B6 56 *JUMP 07B7 5B JUMPDEST 07B8 60 PUSH1 0x00 07BA 61 PUSH2 0x07c2 07BD 82 DUP3 07BE 61 PUSH2 0x0a63 07C1 56 *JUMP 07C2 5B JUMPDEST 07C3 90 SWAP1 07C4 50 POP 07C5 80 DUP1 07C6 60 PUSH1 0x01 07C8 60 PUSH1 0x01 07CA 60 PUSH1 0xa0 07CC 1B SHL 07CD 03 SUB 07CE 16 AND 07CF 83 DUP4 07D0 60 PUSH1 0x01 07D2 60 PUSH1 0x01 07D4 60 PUSH1 0xa0 07D6 1B SHL 07D7 03 SUB 07D8 16 AND 07D9 14 EQ 07DA 15 ISZERO 07DB 61 PUSH2 0x07f6 07DE 57 *JUMPI 07DF 60 PUSH1 0x40 07E1 51 MLOAD 07E2 62 PUSH3 0x461bcd 07E6 60 PUSH1 0xe5 07E8 1B SHL 07E9 81 DUP2 07EA 52 MSTORE 07EB 60 PUSH1 0x04 07ED 01 ADD 07EE 61 PUSH2 0x0792 07F1 90 SWAP1 07F2 61 PUSH2 0x1f2e 07F5 56 *JUMP 07F6 5B JUMPDEST 07F7 33 CALLER 07F8 60 PUSH1 0x01 07FA 60 PUSH1 0x01 07FC 60 PUSH1 0xa0 07FE 1B SHL 07FF 03 SUB 0800 82 DUP3 0801 16 AND 0802 14 EQ 0803 80 DUP1 0804 61 PUSH2 0x0812 0807 57 *JUMPI 0808 50 POP 0809 61 PUSH2 0x0812 080C 81 DUP2 080D 33 CALLER 080E 61 PUSH2 0x0e63 0811 56 *JUMP 0812 5B JUMPDEST 0813 61 PUSH2 0x082e 0816 57 *JUMPI 0817 60 PUSH1 0x40 0819 51 MLOAD 081A 62 PUSH3 0x461bcd 081E 60 PUSH1 0xe5 0820 1B SHL 0821 81 DUP2 0822 52 MSTORE 0823 60 PUSH1 0x04 0825 01 ADD 0826 61 PUSH2 0x0792 0829 90 SWAP1 082A 61 PUSH2 0x1f98 082D 56 *JUMP 082E 5B JUMPDEST 082F 61 PUSH2 0x0838 0832 83 DUP4 0833 83 DUP4 0834 61 PUSH2 0x0f47 0837 56 *JUMP 0838 5B JUMPDEST 0839 50 POP 083A 50 POP 083B 50 POP 083C 56 *JUMP label_083D: // Incoming jump from 0x0328 // Inputs[2] // { // @0840 storage[0x06] // @084A msg.sender // } 083D 5B JUMPDEST 083E 60 PUSH1 0x06 0840 54 SLOAD 0841 60 PUSH1 0x01 0843 60 PUSH1 0x01 0845 60 PUSH1 0xa0 0847 1B SHL 0848 03 SUB 0849 16 AND 084A 33 CALLER 084B 14 EQ 084C 61 PUSH2 0x0867 084F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0867, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0850: // Incoming jump from 0x084F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0852 memory[0x40:0x60] } 0850 60 PUSH1 0x40 0852 51 MLOAD 0853 62 PUSH3 0x461bcd 0857 60 PUSH1 0xe5 0859 1B SHL 085A 81 DUP2 085B 52 MSTORE 085C 60 PUSH1 0x04 085E 01 ADD 085F 61 PUSH2 0x0792 0862 90 SWAP1 0863 61 PUSH2 0x1fdd 0866 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @085B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0862 stack[0] = 0x0792 // @0862 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1fdd label_0867: // Incoming jump from 0x084F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @086D stack[-2] // @086E stack[-1] // } 0867 5B JUMPDEST 0868 61 PUSH2 0x0838 086B 60 PUSH1 0x08 086D 83 DUP4 086E 83 DUP4 086F 61 PUSH2 0x1784 0872 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0868 stack[0] = 0x0838 // @086B stack[1] = 0x08 // @086D stack[2] = stack[-2] // @086E stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1784 0873 5B JUMPDEST 0874 60 PUSH1 0x06 0876 54 SLOAD 0877 60 PUSH1 0x01 0879 60 PUSH1 0x01 087B 60 PUSH1 0xa0 087D 1B SHL 087E 03 SUB 087F 16 AND 0880 33 CALLER 0881 14 EQ 0882 61 PUSH2 0x089d 0885 57 *JUMPI 0886 60 PUSH1 0x40 0888 51 MLOAD 0889 62 PUSH3 0x461bcd 088D 60 PUSH1 0xe5 088F 1B SHL 0890 81 DUP2 0891 52 MSTORE 0892 60 PUSH1 0x04 0894 01 ADD 0895 61 PUSH2 0x0792 0898 90 SWAP1 0899 61 PUSH2 0x1fdd 089C 56 *JUMP 089D 5B JUMPDEST 089E 60 PUSH1 0x10 08A0 80 DUP1 08A1 54 SLOAD 08A2 60 PUSH1 0x01 08A4 60 PUSH1 0x01 08A6 60 PUSH1 0xa0 08A8 1B SHL 08A9 03 SUB 08AA 19 NOT 08AB 16 AND 08AC 60 PUSH1 0x01 08AE 60 PUSH1 0x01 08B0 60 PUSH1 0xa0 08B2 1B SHL 08B3 03 SUB 08B4 92 SWAP3 08B5 90 SWAP1 08B6 92 SWAP3 08B7 16 AND 08B8 91 SWAP2 08B9 90 SWAP1 08BA 91 SWAP2 08BB 17 OR 08BC 90 SWAP1 08BD 55 SSTORE 08BE 56 *JUMP 08BF 5B JUMPDEST 08C0 61 PUSH2 0x08c9 08C3 33 CALLER 08C4 82 DUP3 08C5 61 PUSH2 0x0fb5 08C8 56 *JUMP 08C9 5B JUMPDEST 08CA 61 PUSH2 0x08e5 08CD 57 *JUMPI 08CE 60 PUSH1 0x40 08D0 51 MLOAD 08D1 62 PUSH3 0x461bcd 08D5 60 PUSH1 0xe5 08D7 1B SHL 08D8 81 DUP2 08D9 52 MSTORE 08DA 60 PUSH1 0x04 08DC 01 ADD 08DD 61 PUSH2 0x0792 08E0 90 SWAP1 08E1 61 PUSH2 0x203b 08E4 56 *JUMP 08E5 5B JUMPDEST 08E6 61 PUSH2 0x0838 08E9 83 DUP4 08EA 83 DUP4 08EB 83 DUP4 08EC 61 PUSH2 0x1047 08EF 56 *JUMP 08F0 5B JUMPDEST 08F1 60 PUSH1 0x00 08F3 80 DUP1 08F4 61 PUSH2 0x08fe 08F7 60 PUSH1 0x64 08F9 84 DUP5 08FA 61 PUSH2 0x2077 08FD 56 *JUMP 08FE 5B JUMPDEST 08FF 61 PUSH2 0x0909 0902 90 SWAP1 0903 60 PUSH1 0x05 0905 61 PUSH2 0x208b 0908 56 *JUMP 0909 5B JUMPDEST 090A 60 PUSH1 0x11 090C 54 SLOAD 090D 60 PUSH1 0x01 090F 60 PUSH1 0x01 0911 60 PUSH1 0xa0 0913 1B SHL 0914 03 SUB 0915 16 AND 0916 92 SWAP3 0917 50 POP 0918 90 SWAP1 0919 50 POP label_091A: // Incoming jump from 0x1A7E, if !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) // Inputs[5] // { // @091B stack[-1] // @091B stack[-4] // @091D stack[-5] // @091D stack[-2] // @091E stack[-3] // } 091A 5B JUMPDEST 091B 92 SWAP3 091C 50 POP 091D 92 SWAP3 091E 90 SWAP1 091F 50 POP 0920 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @091B stack[-4] = stack[-1] // @091D stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] 0921 5B JUMPDEST 0922 60 PUSH1 0x06 0924 54 SLOAD 0925 60 PUSH1 0x01 0927 60 PUSH1 0x01 0929 60 PUSH1 0xa0 092B 1B SHL 092C 03 SUB 092D 16 AND 092E 33 CALLER 092F 14 EQ 0930 61 PUSH2 0x094b 0933 57 *JUMPI 0934 60 PUSH1 0x40 0936 51 MLOAD 0937 62 PUSH3 0x461bcd 093B 60 PUSH1 0xe5 093D 1B SHL 093E 81 DUP2 093F 52 MSTORE 0940 60 PUSH1 0x04 0942 01 ADD 0943 61 PUSH2 0x0792 0946 90 SWAP1 0947 61 PUSH2 0x1fdd 094A 56 *JUMP 094B 5B JUMPDEST 094C 60 PUSH1 0x11 094E 80 DUP1 094F 54 SLOAD 0950 60 PUSH1 0x01 0952 60 PUSH1 0x01 0954 60 PUSH1 0xa0 0956 1B SHL 0957 03 SUB 0958 19 NOT 0959 16 AND 095A 60 PUSH1 0x01 095C 60 PUSH1 0x01 095E 60 PUSH1 0xa0 0960 1B SHL 0961 03 SUB 0962 92 SWAP3 0963 90 SWAP1 0964 92 SWAP3 0965 16 AND 0966 91 SWAP2 0967 90 SWAP1 0968 91 SWAP2 0969 17 OR 096A 90 SWAP1 096B 55 SSTORE 096C 56 *JUMP label_096D: // Incoming call from 0x0430, returns to 0x02C4 // Inputs[2] // { // @0970 storage[0x06] // @097A msg.sender // } 096D 5B JUMPDEST 096E 60 PUSH1 0x06 0970 54 SLOAD 0971 60 PUSH1 0x01 0973 60 PUSH1 0x01 0975 60 PUSH1 0xa0 0977 1B SHL 0978 03 SUB 0979 16 AND 097A 33 CALLER 097B 14 EQ 097C 61 PUSH2 0x0997 097F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0997, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0980: // Incoming jump from 0x097F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0982 memory[0x40:0x60] } 0980 60 PUSH1 0x40 0982 51 MLOAD 0983 62 PUSH3 0x461bcd 0987 60 PUSH1 0xe5 0989 1B SHL 098A 81 DUP2 098B 52 MSTORE 098C 60 PUSH1 0x04 098E 01 ADD 098F 61 PUSH2 0x0792 0992 90 SWAP1 0993 61 PUSH2 0x1fdd 0996 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @098B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0992 stack[0] = 0x0792 // @0992 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1fdd label_0997: // Incoming jump from 0x097F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[6] // { // @099A storage[0x10] // @099D memory[0x40:0x60] // @09AA address(this).balance // @09AA address(this) // @09BA address(storage[0x10] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @09BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0997 5B JUMPDEST 0998 60 PUSH1 0x10 099A 54 SLOAD 099B 60 PUSH1 0x40 099D 51 MLOAD 099E 60 PUSH1 0x01 09A0 60 PUSH1 0x01 09A2 60 PUSH1 0xa0 09A4 1B SHL 09A5 03 SUB 09A6 90 SWAP1 09A7 91 SWAP2 09A8 16 AND 09A9 90 SWAP1 09AA 47 SELFBALANCE 09AB 80 DUP1 09AC 15 ISZERO 09AD 61 PUSH2 0x08fc 09B0 02 MUL 09B1 91 SWAP2 09B2 60 PUSH1 0x00 09B4 81 DUP2 09B5 81 DUP2 09B6 81 DUP2 09B7 85 DUP6 09B8 88 DUP9 09B9 88 DUP9 09BA F1 CALL 09BB 93 SWAP4 09BC 50 POP 09BD 50 POP 09BE 50 POP 09BF 50 POP 09C0 15 ISZERO 09C1 80 DUP1 09C2 15 ISZERO 09C3 61 PUSH2 0x09d0 09C6 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @09BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x10] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @09C0 stack[0] = !address(storage[0x10] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x09d0, if !!address(storage[0x10] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_09C7: // Incoming jump from 0x09C6, if not !!address(storage[0x10] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @09C7 returndata.length // @09CB returndata[0x00:0x00 + returndata.length] // @09CC returndata.length // @09CF memory[0x00:0x00 + returndata.length] // } 09C7 3D RETURNDATASIZE 09C8 60 PUSH1 0x00 09CA 80 DUP1 09CB 3E RETURNDATACOPY 09CC 3D RETURNDATASIZE 09CD 60 PUSH1 0x00 09CF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09CB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @09CF revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_09D0: // Incoming jump from 0x18A3, if stack[-2] == stack[-1] // Incoming jump from 0x09C6, if !!address(storage[0x10] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x18A3, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @09D2 stack[-2] } 09D0 5B JUMPDEST 09D1 50 POP 09D2 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 09D3 5B JUMPDEST 09D4 61 PUSH2 0x0838 09D7 83 DUP4 09D8 83 DUP4 09D9 83 DUP4 09DA 60 PUSH1 0x40 09DC 51 MLOAD 09DD 80 DUP1 09DE 60 PUSH1 0x20 09E0 01 ADD 09E1 60 PUSH1 0x40 09E3 52 MSTORE 09E4 80 DUP1 09E5 60 PUSH1 0x00 09E7 81 DUP2 09E8 52 MSTORE 09E9 50 POP 09EA 61 PUSH2 0x0d89 09ED 56 *JUMP 09EE 5B JUMPDEST 09EF 60 PUSH1 0x06 09F1 54 SLOAD 09F2 60 PUSH1 0x01 09F4 60 PUSH1 0x01 09F6 60 PUSH1 0xa0 09F8 1B SHL 09F9 03 SUB 09FA 16 AND 09FB 33 CALLER 09FC 14 EQ 09FD 61 PUSH2 0x0a18 0A00 57 *JUMPI 0A01 60 PUSH1 0x40 0A03 51 MLOAD 0A04 62 PUSH3 0x461bcd 0A08 60 PUSH1 0xe5 0A0A 1B SHL 0A0B 81 DUP2 0A0C 52 MSTORE 0A0D 60 PUSH1 0x04 0A0F 01 ADD 0A10 61 PUSH2 0x0792 0A13 90 SWAP1 0A14 61 PUSH2 0x1fdd 0A17 56 *JUMP 0A18 5B JUMPDEST 0A19 61 PUSH2 0x0a22 0A1C 82 DUP3 0A1D 82 DUP3 0A1E 61 PUSH2 0x1169 0A21 56 *JUMP 0A22 5B JUMPDEST 0A23 50 POP 0A24 50 POP 0A25 56 *JUMP 0A26 5B JUMPDEST 0A27 60 PUSH1 0x06 0A29 54 SLOAD 0A2A 60 PUSH1 0x01 0A2C 60 PUSH1 0x01 0A2E 60 PUSH1 0xa0 0A30 1B SHL 0A31 03 SUB 0A32 16 AND 0A33 33 CALLER 0A34 14 EQ 0A35 61 PUSH2 0x0a50 0A38 57 *JUMPI 0A39 60 PUSH1 0x40 0A3B 51 MLOAD 0A3C 62 PUSH3 0x461bcd 0A40 60 PUSH1 0xe5 0A42 1B SHL 0A43 81 DUP2 0A44 52 MSTORE 0A45 60 PUSH1 0x04 0A47 01 ADD 0A48 61 PUSH2 0x0792 0A4B 90 SWAP1 0A4C 61 PUSH2 0x1fdd 0A4F 56 *JUMP 0A50 5B JUMPDEST 0A51 80 DUP1 0A52 51 MLOAD 0A53 61 PUSH2 0x0a22 0A56 90 SWAP1 0A57 60 PUSH1 0x0a 0A59 90 SWAP1 0A5A 60 PUSH1 0x20 0A5C 84 DUP5 0A5D 01 ADD 0A5E 90 SWAP1 0A5F 61 PUSH2 0x1808 0A62 56 *JUMP 0A63 5B JUMPDEST 0A64 60 PUSH1 0x00 0A66 81 DUP2 0A67 81 DUP2 0A68 52 MSTORE 0A69 60 PUSH1 0x02 0A6B 60 PUSH1 0x20 0A6D 52 MSTORE 0A6E 60 PUSH1 0x40 0A70 81 DUP2 0A71 20 SHA3 0A72 54 SLOAD 0A73 60 PUSH1 0x01 0A75 60 PUSH1 0x01 0A77 60 PUSH1 0xa0 0A79 1B SHL 0A7A 03 SUB 0A7B 16 AND 0A7C 80 DUP1 0A7D 61 PUSH2 0x06c6 0A80 57 *JUMPI 0A81 60 PUSH1 0x40 0A83 51 MLOAD 0A84 62 PUSH3 0x461bcd 0A88 60 PUSH1 0xe5 0A8A 1B SHL 0A8B 81 DUP2 0A8C 52 MSTORE 0A8D 60 PUSH1 0x04 0A8F 01 ADD 0A90 61 PUSH2 0x0792 0A93 90 SWAP1 0A94 61 PUSH2 0x20f0 0A97 56 *JUMP label_0A98: // Incoming call from 0x04C5, returns to 0x026A // Inputs[1] { @0A9C storage[0x0a] } 0A98 5B JUMPDEST 0A99 60 PUSH1 0x0a 0A9B 80 DUP1 0A9C 54 SLOAD 0A9D 61 PUSH2 0x0aa5 0AA0 90 SWAP1 0AA1 61 PUSH2 0x1e67 0AA4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A99 stack[0] = 0x0a // @0AA0 stack[1] = 0x0aa5 // @0AA0 stack[2] = storage[0x0a] // } // Block ends with call to 0x1e67, returns to 0x0AA5 label_0AA5: // Incoming return from call to 0x1E67 at 0x0AA4 // Incoming return from call to 0x1E67 at 0x0EF6 // Inputs[4] // { // @0AA6 stack[-1] // @0AB5 memory[0x40:0x60] // @0ABD stack[-2] // @0AC8 storage[stack[-2]] // } 0AA5 5B JUMPDEST 0AA6 80 DUP1 0AA7 60 PUSH1 0x1f 0AA9 01 ADD 0AAA 60 PUSH1 0x20 0AAC 80 DUP1 0AAD 91 SWAP2 0AAE 04 DIV 0AAF 02 MUL 0AB0 60 PUSH1 0x20 0AB2 01 ADD 0AB3 60 PUSH1 0x40 0AB5 51 MLOAD 0AB6 90 SWAP1 0AB7 81 DUP2 0AB8 01 ADD 0AB9 60 PUSH1 0x40 0ABB 52 MSTORE 0ABC 80 DUP1 0ABD 92 SWAP3 0ABE 91 SWAP2 0ABF 90 SWAP1 0AC0 81 DUP2 0AC1 81 DUP2 0AC2 52 MSTORE 0AC3 60 PUSH1 0x20 0AC5 01 ADD 0AC6 82 DUP3 0AC7 80 DUP1 0AC8 54 SLOAD 0AC9 61 PUSH2 0x0ad1 0ACC 90 SWAP1 0ACD 61 PUSH2 0x1e67 0AD0 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0ABB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0ABD stack[-2] = memory[0x40:0x60] // @0ABE stack[-1] = stack[-2] // @0ABF stack[0] = stack[-1] // @0AC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AC5 stack[1] = 0x20 + memory[0x40:0x60] // @0AC6 stack[2] = stack[-2] // @0ACC stack[4] = storage[stack[-2]] // @0ACC stack[3] = 0x0ad1 // } // Block ends with call to 0x1e67, returns to 0x0AD1 label_0AD1: // Incoming return from call to 0x1E67 at 0x0AD0 // Inputs[1] { @0AD2 stack[-1] } 0AD1 5B JUMPDEST 0AD2 80 DUP1 0AD3 15 ISZERO 0AD4 61 PUSH2 0x0b1e 0AD7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b1e, if !stack[-1] label_0AD8: // Incoming jump from 0x0AD7, if not !stack[-1] // Inputs[1] { @0AD8 stack[-1] } 0AD8 80 DUP1 0AD9 60 PUSH1 0x1f 0ADB 10 LT 0ADC 61 PUSH2 0x0af3 0ADF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0af3, if 0x1f < stack[-1] label_0AE0: // Incoming jump from 0x0ADF, if not 0x1f < stack[-1] // Inputs[4] // { // @0AE4 stack[-2] // @0AE5 storage[stack[-2]] // @0AE8 stack[-3] // @0AEA stack[-1] // } 0AE0 61 PUSH2 0x0100 0AE3 80 DUP1 0AE4 83 DUP4 0AE5 54 SLOAD 0AE6 04 DIV 0AE7 02 MUL 0AE8 83 DUP4 0AE9 52 MSTORE 0AEA 91 SWAP2 0AEB 60 PUSH1 0x20 0AED 01 ADD 0AEE 91 SWAP2 0AEF 61 PUSH2 0x0b1e 0AF2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AE9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0AEE stack[-1] = stack[-1] // @0AEE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b1e label_0AF3: // Incoming jump from 0x0ADF, if 0x1f < stack[-1] // Inputs[5] // { // @0AF4 stack[-3] // @0AF5 stack[-1] // @0AF7 stack[-2] // @0AFF memory[0x00:0x20] // @0B03 storage[keccak256(memory[0x00:0x20])] // } 0AF3 5B JUMPDEST 0AF4 82 DUP3 0AF5 01 ADD 0AF6 91 SWAP2 0AF7 90 SWAP1 0AF8 60 PUSH1 0x00 0AFA 52 MSTORE 0AFB 60 PUSH1 0x20 0AFD 60 PUSH1 0x00 0AFF 20 SHA3 0B00 90 SWAP1 0B01 5B JUMPDEST 0B02 81 DUP2 0B03 54 SLOAD 0B04 81 DUP2 0B05 52 MSTORE 0B06 90 SWAP1 0B07 60 PUSH1 0x01 0B09 01 ADD 0B0A 90 SWAP1 0B0B 60 PUSH1 0x20 0B0D 01 ADD 0B0E 80 DUP1 0B0F 83 DUP4 0B10 11 GT 0B11 61 PUSH2 0x0b01 0B14 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AF6 stack[-3] = stack[-3] + stack[-1] // @0AFA memory[0x00:0x20] = stack[-2] // @0B05 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B0A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B0D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b01, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B15: // Incoming jump from 0x0B14, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0B14, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0B15 stack[-3] // @0B16 stack[-1] // } 0B15 82 DUP3 0B16 90 SWAP1 0B17 03 SUB 0B18 60 PUSH1 0x1f 0B1A 16 AND 0B1B 82 DUP3 0B1C 01 ADD 0B1D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B1D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B1D stack[-1] = stack[-3] // } // Block continues label_0B1E: // Incoming jump from 0x0AF2 // Incoming jump from 0x0AD7, if !stack[-1] // Incoming jump from 0x0B1D // Inputs[1] { @0B24 stack[-7] } 0B1E 5B JUMPDEST 0B1F 50 POP 0B20 50 POP 0B21 50 POP 0B22 50 POP 0B23 50 POP 0B24 81 DUP2 0B25 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] 0B26 5B JUMPDEST 0B27 60 PUSH1 0x00 0B29 60 PUSH1 0x01 0B2B 60 PUSH1 0x01 0B2D 60 PUSH1 0xa0 0B2F 1B SHL 0B30 03 SUB 0B31 82 DUP3 0B32 16 AND 0B33 61 PUSH2 0x0b4e 0B36 57 *JUMPI 0B37 60 PUSH1 0x40 0B39 51 MLOAD 0B3A 62 PUSH3 0x461bcd 0B3E 60 PUSH1 0xe5 0B40 1B SHL 0B41 81 DUP2 0B42 52 MSTORE 0B43 60 PUSH1 0x04 0B45 01 ADD 0B46 61 PUSH2 0x0792 0B49 90 SWAP1 0B4A 61 PUSH2 0x2147 0B4D 56 *JUMP 0B4E 5B JUMPDEST 0B4F 50 POP 0B50 60 PUSH1 0x01 0B52 60 PUSH1 0x01 0B54 60 PUSH1 0xa0 0B56 1B SHL 0B57 03 SUB 0B58 16 AND 0B59 60 PUSH1 0x00 0B5B 90 SWAP1 0B5C 81 DUP2 0B5D 52 MSTORE 0B5E 60 PUSH1 0x03 0B60 60 PUSH1 0x20 0B62 52 MSTORE 0B63 60 PUSH1 0x40 0B65 90 SWAP1 0B66 20 SHA3 0B67 54 SLOAD 0B68 90 SWAP1 0B69 56 *JUMP label_0B6A: // Incoming call from 0x04FA, returns to 0x02C4 // Inputs[2] // { // @0B6D storage[0x06] // @0B77 msg.sender // } 0B6A 5B JUMPDEST 0B6B 60 PUSH1 0x06 0B6D 54 SLOAD 0B6E 60 PUSH1 0x01 0B70 60 PUSH1 0x01 0B72 60 PUSH1 0xa0 0B74 1B SHL 0B75 03 SUB 0B76 16 AND 0B77 33 CALLER 0B78 14 EQ 0B79 61 PUSH2 0x0b94 0B7C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b94, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0B7D: // Incoming jump from 0x0B7C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0B7F memory[0x40:0x60] } 0B7D 60 PUSH1 0x40 0B7F 51 MLOAD 0B80 62 PUSH3 0x461bcd 0B84 60 PUSH1 0xe5 0B86 1B SHL 0B87 81 DUP2 0B88 52 MSTORE 0B89 60 PUSH1 0x04 0B8B 01 ADD 0B8C 61 PUSH2 0x0792 0B8F 90 SWAP1 0B90 61 PUSH2 0x1fdd 0B93 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B8F stack[0] = 0x0792 // @0B8F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1fdd label_0B94: // Incoming jump from 0x0B7C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] 0B94 5B JUMPDEST 0B95 61 PUSH2 0x0b9e 0B98 60 PUSH1 0x00 0B9A 61 PUSH2 0x11d5 0B9D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B95 stack[0] = 0x0b9e // @0B98 stack[1] = 0x00 // } // Block ends with call to 0x11d5, returns to 0x0B9E label_0B9E: // Incoming return from call to 0x11D5 at 0x0B9D // Inputs[1] { @0B9F stack[-1] } 0B9E 5B JUMPDEST 0B9F 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] 0BA0 5B JUMPDEST 0BA1 60 PUSH1 0x06 0BA3 54 SLOAD 0BA4 60 PUSH1 0x01 0BA6 60 PUSH1 0x01 0BA8 60 PUSH1 0xa0 0BAA 1B SHL 0BAB 03 SUB 0BAC 16 AND 0BAD 33 CALLER 0BAE 14 EQ 0BAF 61 PUSH2 0x0bca 0BB2 57 *JUMPI 0BB3 60 PUSH1 0x40 0BB5 51 MLOAD 0BB6 62 PUSH3 0x461bcd 0BBA 60 PUSH1 0xe5 0BBC 1B SHL 0BBD 81 DUP2 0BBE 52 MSTORE 0BBF 60 PUSH1 0x04 0BC1 01 ADD 0BC2 61 PUSH2 0x0792 0BC5 90 SWAP1 0BC6 61 PUSH2 0x1fdd 0BC9 56 *JUMP 0BCA 5B JUMPDEST 0BCB 60 PUSH1 0x0e 0BCD 55 SSTORE 0BCE 56 *JUMP 0BCF 5B JUMPDEST 0BD0 60 PUSH1 0x02 0BD2 60 PUSH1 0x07 0BD4 54 SLOAD 0BD5 14 EQ 0BD6 15 ISZERO 0BD7 61 PUSH2 0x0bf2 0BDA 57 *JUMPI 0BDB 60 PUSH1 0x40 0BDD 51 MLOAD 0BDE 62 PUSH3 0x461bcd 0BE2 60 PUSH1 0xe5 0BE4 1B SHL 0BE5 81 DUP2 0BE6 52 MSTORE 0BE7 60 PUSH1 0x04 0BE9 01 ADD 0BEA 61 PUSH2 0x0792 0BED 90 SWAP1 0BEE 61 PUSH2 0x218b 0BF1 56 *JUMP 0BF2 5B JUMPDEST 0BF3 60 PUSH1 0x02 0BF5 60 PUSH1 0x07 0BF7 55 SSTORE 0BF8 60 PUSH1 0x0c 0BFA 54 SLOAD 0BFB 33 CALLER 0BFC 90 SWAP1 0BFD 60 PUSH1 0xff 0BFF 16 AND 0C00 61 PUSH2 0x0c1b 0C03 57 *JUMPI 0C04 60 PUSH1 0x40 0C06 51 MLOAD 0C07 62 PUSH3 0x461bcd 0C0B 60 PUSH1 0xe5 0C0D 1B SHL 0C0E 81 DUP2 0C0F 52 MSTORE 0C10 60 PUSH1 0x04 0C12 01 ADD 0C13 61 PUSH2 0x0792 0C16 90 SWAP1 0C17 61 PUSH2 0x21c0 0C1A 56 *JUMP 0C1B 5B JUMPDEST 0C1C 60 PUSH1 0x01 0C1E 60 PUSH1 0x01 0C20 60 PUSH1 0xa0 0C22 1B SHL 0C23 03 SUB 0C24 81 DUP2 0C25 16 AND 0C26 60 PUSH1 0x00 0C28 90 SWAP1 0C29 81 DUP2 0C2A 52 MSTORE 0C2B 60 PUSH1 0x0f 0C2D 60 PUSH1 0x20 0C2F 52 MSTORE 0C30 60 PUSH1 0x40 0C32 90 SWAP1 0C33 20 SHA3 0C34 54 SLOAD 0C35 61 PUSH2 0x0c3e 0C38 90 SWAP1 0C39 83 DUP4 0C3A 61 PUSH2 0x21d0 0C3D 56 *JUMP 0C3E 5B JUMPDEST 0C3F 85 DUP6 0C40 11 GT 0C41 15 ISZERO 0C42 61 PUSH2 0x0c5d 0C45 57 *JUMPI 0C46 60 PUSH1 0x40 0C48 51 MLOAD 0C49 62 PUSH3 0x461bcd 0C4D 60 PUSH1 0xe5 0C4F 1B SHL 0C50 81 DUP2 0C51 52 MSTORE 0C52 60 PUSH1 0x04 0C54 01 ADD 0C55 61 PUSH2 0x0792 0C58 90 SWAP1 0C59 61 PUSH2 0x221b 0C5C 56 *JUMP 0C5D 5B JUMPDEST 0C5E 61 PUSH2 0x0c69 0C61 84 DUP5 0C62 84 DUP5 0C63 83 DUP4 0C64 85 DUP6 0C65 61 PUSH2 0x1227 0C68 56 *JUMP 0C69 5B JUMPDEST 0C6A 61 PUSH2 0x0c85 0C6D 57 *JUMPI 0C6E 60 PUSH1 0x40 0C70 51 MLOAD 0C71 62 PUSH3 0x461bcd 0C75 60 PUSH1 0xe5 0C77 1B SHL 0C78 81 DUP2 0C79 52 MSTORE 0C7A 60 PUSH1 0x04 0C7C 01 ADD 0C7D 61 PUSH2 0x0792 0C80 90 SWAP1 0C81 61 PUSH2 0x224f 0C84 56 *JUMP 0C85 5B JUMPDEST 0C86 84 DUP5 0C87 60 PUSH1 0x0d 0C89 54 SLOAD 0C8A 61 PUSH2 0x0c93 0C8D 91 SWAP2 0C8E 90 SWAP1 0C8F 61 PUSH2 0x208b 0C92 56 *JUMP 0C93 5B JUMPDEST 0C94 34 CALLVALUE 0C95 14 EQ 0C96 61 PUSH2 0x0cb1 0C99 57 *JUMPI 0C9A 60 PUSH1 0x40 0C9C 51 MLOAD 0C9D 62 PUSH3 0x461bcd 0CA1 60 PUSH1 0xe5 0CA3 1B SHL 0CA4 81 DUP2 0CA5 52 MSTORE 0CA6 60 PUSH1 0x04 0CA8 01 ADD 0CA9 61 PUSH2 0x0792 0CAC 90 SWAP1 0CAD 61 PUSH2 0x2293 0CB0 56 *JUMP 0CB1 5B JUMPDEST 0CB2 60 PUSH1 0x01 0CB4 60 PUSH1 0x01 0CB6 60 PUSH1 0xa0 0CB8 1B SHL 0CB9 03 SUB 0CBA 81 DUP2 0CBB 16 AND 0CBC 60 PUSH1 0x00 0CBE 90 SWAP1 0CBF 81 DUP2 0CC0 52 MSTORE 0CC1 60 PUSH1 0x0f 0CC3 60 PUSH1 0x20 0CC5 52 MSTORE 0CC6 60 PUSH1 0x40 0CC8 81 DUP2 0CC9 20 SHA3 0CCA 80 DUP1 0CCB 54 SLOAD 0CCC 87 DUP8 0CCD 92 SWAP3 0CCE 90 SWAP1 0CCF 61 PUSH2 0x0cd9 0CD2 90 SWAP1 0CD3 84 DUP5 0CD4 90 SWAP1 0CD5 61 PUSH2 0x22a3 0CD8 56 *JUMP 0CD9 5B JUMPDEST 0CDA 90 SWAP1 0CDB 91 SWAP2 0CDC 55 SSTORE 0CDD 50 POP 0CDE 61 PUSH2 0x0ce9 0CE1 90 SWAP1 0CE2 50 POP 0CE3 81 DUP2 0CE4 86 DUP7 0CE5 61 PUSH2 0x1169 0CE8 56 *JUMP 0CE9 5B JUMPDEST 0CEA 50 POP 0CEB 50 POP 0CEC 60 PUSH1 0x01 0CEE 60 PUSH1 0x07 0CF0 55 SSTORE 0CF1 50 POP 0CF2 50 POP 0CF3 50 POP 0CF4 56 *JUMP 0CF5 5B JUMPDEST 0CF6 60 PUSH1 0x06 0CF8 54 SLOAD 0CF9 60 PUSH1 0x01 0CFB 60 PUSH1 0x01 0CFD 60 PUSH1 0xa0 0CFF 1B SHL 0D00 03 SUB 0D01 16 AND 0D02 33 CALLER 0D03 14 EQ 0D04 61 PUSH2 0x0d1f 0D07 57 *JUMPI 0D08 60 PUSH1 0x40 0D0A 51 MLOAD 0D0B 62 PUSH3 0x461bcd 0D0F 60 PUSH1 0xe5 0D11 1B SHL 0D12 81 DUP2 0D13 52 MSTORE 0D14 60 PUSH1 0x04 0D16 01 ADD 0D17 61 PUSH2 0x0792 0D1A 90 SWAP1 0D1B 61 PUSH2 0x1fdd 0D1E 56 *JUMP 0D1F 5B JUMPDEST 0D20 80 DUP1 0D21 51 MLOAD 0D22 61 PUSH2 0x0a22 0D25 90 SWAP1 0D26 60 PUSH1 0x0b 0D28 90 SWAP1 0D29 60 PUSH1 0x20 0D2B 84 DUP5 0D2C 01 ADD 0D2D 90 SWAP1 0D2E 61 PUSH2 0x1808 0D31 56 *JUMP label_0D32: // Incoming call from 0x0580, returns to 0x026A // Inputs[1] { @0D38 storage[0x01] } 0D32 5B JUMPDEST 0D33 60 PUSH1 0x60 0D35 60 PUSH1 0x01 0D37 80 DUP1 0D38 54 SLOAD 0D39 61 PUSH2 0x06db 0D3C 90 SWAP1 0D3D 61 PUSH2 0x1e67 0D40 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D33 stack[0] = 0x60 // @0D35 stack[1] = 0x01 // @0D3C stack[2] = 0x06db // @0D3C stack[3] = storage[0x01] // } // Block ends with call to 0x1e67, returns to 0x06DB 0D41 5B JUMPDEST 0D42 61 PUSH2 0x0a22 0D45 33 CALLER 0D46 83 DUP4 0D47 83 DUP4 0D48 61 PUSH2 0x12a8 0D4B 56 *JUMP 0D4C 5B JUMPDEST 0D4D 60 PUSH1 0x06 0D4F 54 SLOAD 0D50 60 PUSH1 0x01 0D52 60 PUSH1 0x01 0D54 60 PUSH1 0xa0 0D56 1B SHL 0D57 03 SUB 0D58 16 AND 0D59 33 CALLER 0D5A 14 EQ 0D5B 61 PUSH2 0x0d76 0D5E 57 *JUMPI 0D5F 60 PUSH1 0x40 0D61 51 MLOAD 0D62 62 PUSH3 0x461bcd 0D66 60 PUSH1 0xe5 0D68 1B SHL 0D69 81 DUP2 0D6A 52 MSTORE 0D6B 60 PUSH1 0x04 0D6D 01 ADD 0D6E 61 PUSH2 0x0792 0D71 90 SWAP1 0D72 61 PUSH2 0x1fdd 0D75 56 *JUMP 0D76 5B JUMPDEST 0D77 60 PUSH1 0x0c 0D79 80 DUP1 0D7A 54 SLOAD 0D7B 60 PUSH1 0xff 0D7D 19 NOT 0D7E 16 AND 0D7F 91 SWAP2 0D80 15 ISZERO 0D81 15 ISZERO 0D82 91 SWAP2 0D83 90 SWAP1 0D84 91 SWAP2 0D85 17 OR 0D86 90 SWAP1 0D87 55 SSTORE 0D88 56 *JUMP 0D89 5B JUMPDEST 0D8A 61 PUSH2 0x0d93 0D8D 33 CALLER 0D8E 83 DUP4 0D8F 61 PUSH2 0x0fb5 0D92 56 *JUMP 0D93 5B JUMPDEST 0D94 61 PUSH2 0x0daf 0D97 57 *JUMPI 0D98 60 PUSH1 0x40 0D9A 51 MLOAD 0D9B 62 PUSH3 0x461bcd 0D9F 60 PUSH1 0xe5 0DA1 1B SHL 0DA2 81 DUP2 0DA3 52 MSTORE 0DA4 60 PUSH1 0x04 0DA6 01 ADD 0DA7 61 PUSH2 0x0792 0DAA 90 SWAP1 0DAB 61 PUSH2 0x203b 0DAE 56 *JUMP 0DAF 5B JUMPDEST 0DB0 61 PUSH2 0x0dbb 0DB3 84 DUP5 0DB4 84 DUP5 0DB5 84 DUP5 0DB6 84 DUP5 0DB7 61 PUSH2 0x134b 0DBA 56 *JUMP label_0DBB: // Incoming jump from 0x190F, if !(stack[-1] > stack[-4]) // Inputs[1] { @0DC0 stack[-5] } 0DBB 5B JUMPDEST 0DBC 50 POP 0DBD 50 POP 0DBE 50 POP 0DBF 50 POP 0DC0 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] 0DC1 5B JUMPDEST 0DC2 60 PUSH1 0x00 0DC4 81 DUP2 0DC5 81 DUP2 0DC6 52 MSTORE 0DC7 60 PUSH1 0x02 0DC9 60 PUSH1 0x20 0DCB 52 MSTORE 0DCC 60 PUSH1 0x40 0DCE 90 SWAP1 0DCF 20 SHA3 0DD0 54 SLOAD 0DD1 60 PUSH1 0x60 0DD3 90 SWAP1 0DD4 60 PUSH1 0x01 0DD6 60 PUSH1 0x01 0DD8 60 PUSH1 0xa0 0DDA 1B SHL 0DDB 03 SUB 0DDC 16 AND 0DDD 61 PUSH2 0x0df8 0DE0 57 *JUMPI 0DE1 60 PUSH1 0x40 0DE3 51 MLOAD 0DE4 62 PUSH3 0x461bcd 0DE8 60 PUSH1 0xe5 0DEA 1B SHL 0DEB 81 DUP2 0DEC 52 MSTORE 0DED 60 PUSH1 0x04 0DEF 01 ADD 0DF0 61 PUSH2 0x0792 0DF3 90 SWAP1 0DF4 61 PUSH2 0x2307 0DF7 56 *JUMP 0DF8 5B JUMPDEST 0DF9 60 PUSH1 0x00 0DFB 61 PUSH2 0x0e02 0DFE 61 PUSH2 0x137e 0E01 56 *JUMP 0E02 5B JUMPDEST 0E03 90 SWAP1 0E04 50 POP 0E05 60 PUSH1 0x00 0E07 81 DUP2 0E08 51 MLOAD 0E09 11 GT 0E0A 61 PUSH2 0x0e22 0E0D 57 *JUMPI 0E0E 60 PUSH1 0x40 0E10 51 MLOAD 0E11 80 DUP1 0E12 60 PUSH1 0x20 0E14 01 ADD 0E15 60 PUSH1 0x40 0E17 52 MSTORE 0E18 80 DUP1 0E19 60 PUSH1 0x00 0E1B 81 DUP2 0E1C 52 MSTORE 0E1D 50 POP 0E1E 61 PUSH2 0x0e4d 0E21 56 *JUMP 0E22 5B JUMPDEST 0E23 80 DUP1 0E24 61 PUSH2 0x0e2c 0E27 84 DUP5 0E28 61 PUSH2 0x138d 0E2B 56 *JUMP 0E2C 5B JUMPDEST 0E2D 60 PUSH1 0x40 0E2F 51 MLOAD 0E30 60 PUSH1 0x20 0E32 01 ADD 0E33 61 PUSH2 0x0e3d 0E36 92 SWAP3 0E37 91 SWAP2 0E38 90 SWAP1 0E39 61 PUSH2 0x2339 0E3C 56 *JUMP 0E3D 5B JUMPDEST 0E3E 60 PUSH1 0x40 0E40 51 MLOAD 0E41 60 PUSH1 0x20 0E43 81 DUP2 0E44 83 DUP4 0E45 03 SUB 0E46 03 SUB 0E47 81 DUP2 0E48 52 MSTORE 0E49 90 SWAP1 0E4A 60 PUSH1 0x40 0E4C 52 MSTORE label_0E4D: // Incoming return from call to 0x1918 at 0x195A // Inputs[3] // { // @0E4E stack[-5] // @0E4E stack[-1] // @0E4F stack[-4] // } 0E4D 5B JUMPDEST 0E4E 93 SWAP4 0E4F 92 SWAP3 0E50 50 POP 0E51 50 POP 0E52 50 POP 0E53 56 *JUMP // Stack delta = -4 // Outputs[1] { @0E4E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0E54: // Incoming call from 0x062B, returns to 0x026A // Inputs[1] { @0E5A storage[0x0b] } 0E54 5B JUMPDEST 0E55 60 PUSH1 0x60 0E57 60 PUSH1 0x0b 0E59 80 DUP1 0E5A 54 SLOAD 0E5B 61 PUSH2 0x06db 0E5E 90 SWAP1 0E5F 61 PUSH2 0x1e67 0E62 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E55 stack[0] = 0x60 // @0E57 stack[1] = 0x0b // @0E5E stack[2] = 0x06db // @0E5E stack[3] = storage[0x0b] // } // Block ends with call to 0x1e67, returns to 0x06DB 0E63 5B JUMPDEST 0E64 60 PUSH1 0x01 0E66 60 PUSH1 0x01 0E68 60 PUSH1 0xa0 0E6A 1B SHL 0E6B 03 SUB 0E6C 91 SWAP2 0E6D 82 DUP3 0E6E 16 AND 0E6F 60 PUSH1 0x00 0E71 90 SWAP1 0E72 81 DUP2 0E73 52 MSTORE 0E74 60 PUSH1 0x05 0E76 60 PUSH1 0x20 0E78 90 SWAP1 0E79 81 DUP2 0E7A 52 MSTORE 0E7B 60 PUSH1 0x40 0E7D 80 DUP1 0E7E 83 DUP4 0E7F 20 SHA3 0E80 93 SWAP4 0E81 90 SWAP1 0E82 94 SWAP5 0E83 16 AND 0E84 82 DUP3 0E85 52 MSTORE 0E86 91 SWAP2 0E87 90 SWAP1 0E88 91 SWAP2 0E89 52 MSTORE 0E8A 20 SHA3 0E8B 54 SLOAD 0E8C 60 PUSH1 0xff 0E8E 16 AND 0E8F 90 SWAP1 0E90 56 *JUMP 0E91 5B JUMPDEST 0E92 60 PUSH1 0x06 0E94 54 SLOAD 0E95 60 PUSH1 0x01 0E97 60 PUSH1 0x01 0E99 60 PUSH1 0xa0 0E9B 1B SHL 0E9C 03 SUB 0E9D 16 AND 0E9E 33 CALLER 0E9F 14 EQ 0EA0 61 PUSH2 0x0ebb 0EA3 57 *JUMPI 0EA4 60 PUSH1 0x40 0EA6 51 MLOAD 0EA7 62 PUSH3 0x461bcd 0EAB 60 PUSH1 0xe5 0EAD 1B SHL 0EAE 81 DUP2 0EAF 52 MSTORE 0EB0 60 PUSH1 0x04 0EB2 01 ADD 0EB3 61 PUSH2 0x0792 0EB6 90 SWAP1 0EB7 61 PUSH2 0x1fdd 0EBA 56 *JUMP 0EBB 5B JUMPDEST 0EBC 60 PUSH1 0x01 0EBE 60 PUSH1 0x01 0EC0 60 PUSH1 0xa0 0EC2 1B SHL 0EC3 03 SUB 0EC4 81 DUP2 0EC5 16 AND 0EC6 61 PUSH2 0x0ee1 0EC9 57 *JUMPI 0ECA 60 PUSH1 0x40 0ECC 51 MLOAD 0ECD 62 PUSH3 0x461bcd 0ED1 60 PUSH1 0xe5 0ED3 1B SHL 0ED4 81 DUP2 0ED5 52 MSTORE 0ED6 60 PUSH1 0x04 0ED8 01 ADD 0ED9 61 PUSH2 0x0792 0EDC 90 SWAP1 0EDD 61 PUSH2 0x2394 0EE0 56 *JUMP 0EE1 5B JUMPDEST 0EE2 61 PUSH2 0x09d0 0EE5 81 DUP2 0EE6 61 PUSH2 0x11d5 0EE9 56 *JUMP label_0EEA: // Incoming call from 0x06A0, returns to 0x026A // Inputs[1] { @0EEE storage[0x08] } 0EEA 5B JUMPDEST 0EEB 60 PUSH1 0x08 0EED 80 DUP1 0EEE 54 SLOAD 0EEF 61 PUSH2 0x0aa5 0EF2 90 SWAP1 0EF3 61 PUSH2 0x1e67 0EF6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EEB stack[0] = 0x08 // @0EF2 stack[1] = 0x0aa5 // @0EF2 stack[2] = storage[0x08] // } // Block ends with call to 0x1e67, returns to 0x0AA5 0EF7 5B JUMPDEST 0EF8 60 PUSH1 0x00 0EFA 60 PUSH1 0x01 0EFC 60 PUSH1 0x01 0EFE 60 PUSH1 0xe0 0F00 1B SHL 0F01 03 SUB 0F02 19 NOT 0F03 82 DUP3 0F04 16 AND 0F05 63 PUSH4 0x80ac58cd 0F0A 60 PUSH1 0xe0 0F0C 1B SHL 0F0D 14 EQ 0F0E 80 DUP1 0F0F 61 PUSH2 0x0f28 0F12 57 *JUMPI 0F13 50 POP 0F14 60 PUSH1 0x01 0F16 60 PUSH1 0x01 0F18 60 PUSH1 0xe0 0F1A 1B SHL 0F1B 03 SUB 0F1C 19 NOT 0F1D 82 DUP3 0F1E 16 AND 0F1F 63 PUSH4 0x5b5e139f 0F24 60 PUSH1 0xe0 0F26 1B SHL 0F27 14 EQ 0F28 5B JUMPDEST 0F29 80 DUP1 0F2A 61 PUSH2 0x06c6 0F2D 57 *JUMPI 0F2E 50 POP 0F2F 63 PUSH4 0x01ffc9a7 0F34 60 PUSH1 0xe0 0F36 1B SHL 0F37 60 PUSH1 0x01 0F39 60 PUSH1 0x01 0F3B 60 PUSH1 0xe0 0F3D 1B SHL 0F3E 03 SUB 0F3F 19 NOT 0F40 83 DUP4 0F41 16 AND 0F42 14 EQ 0F43 61 PUSH2 0x06c6 0F46 56 *JUMP 0F47 5B JUMPDEST 0F48 60 PUSH1 0x00 0F4A 81 DUP2 0F4B 81 DUP2 0F4C 52 MSTORE 0F4D 60 PUSH1 0x04 0F4F 60 PUSH1 0x20 0F51 52 MSTORE 0F52 60 PUSH1 0x40 0F54 90 SWAP1 0F55 20 SHA3 0F56 80 DUP1 0F57 54 SLOAD 0F58 60 PUSH1 0x01 0F5A 60 PUSH1 0x01 0F5C 60 PUSH1 0xa0 0F5E 1B SHL 0F5F 03 SUB 0F60 19 NOT 0F61 16 AND 0F62 60 PUSH1 0x01 0F64 60 PUSH1 0x01 0F66 60 PUSH1 0xa0 0F68 1B SHL 0F69 03 SUB 0F6A 84 DUP5 0F6B 16 AND 0F6C 90 SWAP1 0F6D 81 DUP2 0F6E 17 OR 0F6F 90 SWAP1 0F70 91 SWAP2 0F71 55 SSTORE 0F72 81 DUP2 0F73 90 SWAP1 0F74 61 PUSH2 0x0f7c 0F77 82 DUP3 0F78 61 PUSH2 0x0a63 0F7B 56 *JUMP 0F7C 5B JUMPDEST 0F7D 60 PUSH1 0x01 0F7F 60 PUSH1 0x01 0F81 60 PUSH1 0xa0 0F83 1B SHL 0F84 03 SUB 0F85 16 AND 0F86 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0FA7 60 PUSH1 0x40 0FA9 51 MLOAD 0FAA 60 PUSH1 0x40 0FAC 51 MLOAD 0FAD 80 DUP1 0FAE 91 SWAP2 0FAF 03 SUB 0FB0 90 SWAP1 0FB1 A4 LOG4 0FB2 50 POP 0FB3 50 POP 0FB4 56 *JUMP 0FB5 5B JUMPDEST 0FB6 60 PUSH1 0x00 0FB8 81 DUP2 0FB9 81 DUP2 0FBA 52 MSTORE 0FBB 60 PUSH1 0x02 0FBD 60 PUSH1 0x20 0FBF 52 MSTORE 0FC0 60 PUSH1 0x40 0FC2 81 DUP2 0FC3 20 SHA3 0FC4 54 SLOAD 0FC5 60 PUSH1 0x01 0FC7 60 PUSH1 0x01 0FC9 60 PUSH1 0xa0 0FCB 1B SHL 0FCC 03 SUB 0FCD 16 AND 0FCE 61 PUSH2 0x0fe9 0FD1 57 *JUMPI 0FD2 60 PUSH1 0x40 0FD4 51 MLOAD 0FD5 62 PUSH3 0x461bcd 0FD9 60 PUSH1 0xe5 0FDB 1B SHL 0FDC 81 DUP2 0FDD 52 MSTORE 0FDE 60 PUSH1 0x04 0FE0 01 ADD 0FE1 61 PUSH2 0x0792 0FE4 90 SWAP1 0FE5 61 PUSH2 0x23ed 0FE8 56 *JUMP 0FE9 5B JUMPDEST 0FEA 60 PUSH1 0x00 0FEC 61 PUSH2 0x0ff4 0FEF 83 DUP4 0FF0 61 PUSH2 0x0a63 0FF3 56 *JUMP 0FF4 5B JUMPDEST 0FF5 90 SWAP1 0FF6 50 POP 0FF7 80 DUP1 0FF8 60 PUSH1 0x01 0FFA 60 PUSH1 0x01 0FFC 60 PUSH1 0xa0 0FFE 1B SHL 0FFF 03 SUB 1000 16 AND 1001 84 DUP5 1002 60 PUSH1 0x01 1004 60 PUSH1 0x01 1006 60 PUSH1 0xa0 1008 1B SHL 1009 03 SUB 100A 16 AND 100B 14 EQ 100C 80 DUP1 100D 61 PUSH2 0x102f 1010 57 *JUMPI 1011 50 POP 1012 83 DUP4 1013 60 PUSH1 0x01 1015 60 PUSH1 0x01 1017 60 PUSH1 0xa0 1019 1B SHL 101A 03 SUB 101B 16 AND 101C 61 PUSH2 0x1024 101F 84 DUP5 1020 61 PUSH2 0x075e 1023 56 *JUMP 1024 5B JUMPDEST 1025 60 PUSH1 0x01 1027 60 PUSH1 0x01 1029 60 PUSH1 0xa0 102B 1B SHL 102C 03 SUB 102D 16 AND 102E 14 EQ 102F 5B JUMPDEST 1030 80 DUP1 1031 61 PUSH2 0x103f 1034 57 *JUMPI 1035 50 POP 1036 61 PUSH2 0x103f 1039 81 DUP2 103A 85 DUP6 103B 61 PUSH2 0x0e63 103E 56 *JUMP label_103F: // Incoming return from call to 0x1C2A at 0x1C88 // Incoming return from call to 0x1BF1 at 0x1C4D // Inputs[3] // { // @1040 stack[-1] // @1040 stack[-6] // @1041 stack[-5] // } 103F 5B JUMPDEST 1040 94 SWAP5 1041 93 SWAP4 1042 50 POP 1043 50 POP 1044 50 POP 1045 50 POP 1046 56 *JUMP // Stack delta = -5 // Outputs[1] { @1040 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 1047 5B JUMPDEST 1048 82 DUP3 1049 60 PUSH1 0x01 104B 60 PUSH1 0x01 104D 60 PUSH1 0xa0 104F 1B SHL 1050 03 SUB 1051 16 AND 1052 61 PUSH2 0x105a 1055 82 DUP3 1056 61 PUSH2 0x0a63 1059 56 *JUMP 105A 5B JUMPDEST 105B 60 PUSH1 0x01 105D 60 PUSH1 0x01 105F 60 PUSH1 0xa0 1061 1B SHL 1062 03 SUB 1063 16 AND 1064 14 EQ 1065 61 PUSH2 0x1080 1068 57 *JUMPI 1069 60 PUSH1 0x40 106B 51 MLOAD 106C 62 PUSH3 0x461bcd 1070 60 PUSH1 0xe5 1072 1B SHL 1073 81 DUP2 1074 52 MSTORE 1075 60 PUSH1 0x04 1077 01 ADD 1078 61 PUSH2 0x0792 107B 90 SWAP1 107C 61 PUSH2 0x2443 107F 56 *JUMP 1080 5B JUMPDEST 1081 60 PUSH1 0x01 1083 60 PUSH1 0x01 1085 60 PUSH1 0xa0 1087 1B SHL 1088 03 SUB 1089 82 DUP3 108A 16 AND 108B 61 PUSH2 0x10a6 108E 57 *JUMPI 108F 60 PUSH1 0x40 1091 51 MLOAD 1092 62 PUSH3 0x461bcd 1096 60 PUSH1 0xe5 1098 1B SHL 1099 81 DUP2 109A 52 MSTORE 109B 60 PUSH1 0x04 109D 01 ADD 109E 61 PUSH2 0x0792 10A1 90 SWAP1 10A2 61 PUSH2 0x2494 10A5 56 *JUMP 10A6 5B JUMPDEST 10A7 61 PUSH2 0x10b1 10AA 60 PUSH1 0x00 10AC 82 DUP3 10AD 61 PUSH2 0x0f47 10B0 56 *JUMP 10B1 5B JUMPDEST 10B2 60 PUSH1 0x01 10B4 60 PUSH1 0x01 10B6 60 PUSH1 0xa0 10B8 1B SHL 10B9 03 SUB 10BA 83 DUP4 10BB 16 AND 10BC 60 PUSH1 0x00 10BE 90 SWAP1 10BF 81 DUP2 10C0 52 MSTORE 10C1 60 PUSH1 0x03 10C3 60 PUSH1 0x20 10C5 52 MSTORE 10C6 60 PUSH1 0x40 10C8 81 DUP2 10C9 20 SHA3 10CA 80 DUP1 10CB 54 SLOAD 10CC 60 PUSH1 0x01 10CE 92 SWAP3 10CF 90 SWAP1 10D0 61 PUSH2 0x10da 10D3 90 SWAP1 10D4 84 DUP5 10D5 90 SWAP1 10D6 61 PUSH2 0x21d0 10D9 56 *JUMP 10DA 5B JUMPDEST 10DB 90 SWAP1 10DC 91 SWAP2 10DD 55 SSTORE 10DE 50 POP 10DF 50 POP 10E0 60 PUSH1 0x01 10E2 60 PUSH1 0x01 10E4 60 PUSH1 0xa0 10E6 1B SHL 10E7 03 SUB 10E8 82 DUP3 10E9 16 AND 10EA 60 PUSH1 0x00 10EC 90 SWAP1 10ED 81 DUP2 10EE 52 MSTORE 10EF 60 PUSH1 0x03 10F1 60 PUSH1 0x20 10F3 52 MSTORE 10F4 60 PUSH1 0x40 10F6 81 DUP2 10F7 20 SHA3 10F8 80 DUP1 10F9 54 SLOAD 10FA 60 PUSH1 0x01 10FC 92 SWAP3 10FD 90 SWAP1 10FE 61 PUSH2 0x1108 1101 90 SWAP1 1102 84 DUP5 1103 90 SWAP1 1104 61 PUSH2 0x22a3 1107 56 *JUMP 1108 5B JUMPDEST 1109 90 SWAP1 110A 91 SWAP2 110B 55 SSTORE 110C 50 POP 110D 50 POP 110E 60 PUSH1 0x00 1110 81 DUP2 1111 81 DUP2 1112 52 MSTORE 1113 60 PUSH1 0x02 1115 60 PUSH1 0x20 1117 52 MSTORE 1118 60 PUSH1 0x40 111A 80 DUP1 111B 82 DUP3 111C 20 SHA3 111D 80 DUP1 111E 54 SLOAD 111F 60 PUSH1 0x01 1121 60 PUSH1 0x01 1123 60 PUSH1 0xa0 1125 1B SHL 1126 03 SUB 1127 19 NOT 1128 16 AND 1129 60 PUSH1 0x01 112B 60 PUSH1 0x01 112D 60 PUSH1 0xa0 112F 1B SHL 1130 03 SUB 1131 86 DUP7 1132 81 DUP2 1133 16 AND 1134 91 SWAP2 1135 82 DUP3 1136 17 OR 1137 90 SWAP1 1138 92 SWAP3 1139 55 SSTORE 113A 91 SWAP2 113B 51 MLOAD 113C 84 DUP5 113D 93 SWAP4 113E 91 SWAP2 113F 87 DUP8 1140 16 AND 1141 91 SWAP2 1142 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1163 91 SWAP2 1164 A4 LOG4 1165 50 POP 1166 50 POP 1167 50 POP 1168 56 *JUMP 1169 5B JUMPDEST 116A 61 PUSH2 0x1388 116D 81 DUP2 116E 60 PUSH1 0x09 1170 54 SLOAD 1171 61 PUSH2 0x117a 1174 91 SWAP2 1175 90 SWAP1 1176 61 PUSH2 0x22a3 1179 56 *JUMP 117A 5B JUMPDEST 117B 11 GT 117C 15 ISZERO 117D 61 PUSH2 0x1198 1180 57 *JUMPI 1181 60 PUSH1 0x40 1183 51 MLOAD 1184 62 PUSH3 0x461bcd 1188 60 PUSH1 0xe5 118A 1B SHL 118B 81 DUP2 118C 52 MSTORE 118D 60 PUSH1 0x04 118F 01 ADD 1190 61 PUSH2 0x0792 1193 90 SWAP1 1194 61 PUSH2 0x24d8 1197 56 *JUMP 1198 5B JUMPDEST 1199 60 PUSH1 0x01 119B 5B JUMPDEST 119C 81 DUP2 119D 81 DUP2 119E 11 GT 119F 61 PUSH2 0x0838 11A2 57 *JUMPI 11A3 60 PUSH1 0x09 11A5 80 DUP1 11A6 54 SLOAD 11A7 90 SWAP1 11A8 60 PUSH1 0x00 11AA 61 PUSH2 0x11b2 11AD 83 DUP4 11AE 61 PUSH2 0x24e8 11B1 56 *JUMP 11B2 5B JUMPDEST 11B3 91 SWAP2 11B4 90 SWAP1 11B5 50 POP 11B6 55 SSTORE 11B7 50 POP 11B8 61 PUSH2 0x11c3 11BB 83 DUP4 11BC 60 PUSH1 0x09 11BE 54 SLOAD 11BF 61 PUSH2 0x148b 11C2 56 *JUMP 11C3 5B JUMPDEST 11C4 80 DUP1 11C5 61 PUSH2 0x11cd 11C8 81 DUP2 11C9 61 PUSH2 0x24e8 11CC 56 *JUMP 11CD 5B JUMPDEST 11CE 91 SWAP2 11CF 50 POP 11D0 50 POP 11D1 61 PUSH2 0x119b 11D4 56 *JUMP label_11D5: // Incoming call from 0x0B9D, returns to 0x0B9E // Inputs[5] // { // @11D9 storage[0x06] // @11E2 stack[-1] // @11F7 memory[0x40:0x60] // @1223 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1226 stack[-2] // } 11D5 5B JUMPDEST 11D6 60 PUSH1 0x06 11D8 80 DUP1 11D9 54 SLOAD 11DA 60 PUSH1 0x01 11DC 60 PUSH1 0x01 11DE 60 PUSH1 0xa0 11E0 1B SHL 11E1 03 SUB 11E2 83 DUP4 11E3 81 DUP2 11E4 16 AND 11E5 60 PUSH1 0x01 11E7 60 PUSH1 0x01 11E9 60 PUSH1 0xa0 11EB 1B SHL 11EC 03 SUB 11ED 19 NOT 11EE 83 DUP4 11EF 16 AND 11F0 81 DUP2 11F1 17 OR 11F2 90 SWAP1 11F3 93 SWAP4 11F4 55 SSTORE 11F5 60 PUSH1 0x40 11F7 51 MLOAD 11F8 91 SWAP2 11F9 16 AND 11FA 91 SWAP2 11FB 90 SWAP1 11FC 82 DUP3 11FD 90 SWAP1 11FE 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 121F 90 SWAP1 1220 60 PUSH1 0x00 1222 90 SWAP1 1223 A3 LOG3 1224 50 POP 1225 50 POP 1226 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @11F4 storage[0x06] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x06] & ~((0x01 << 0xa0) - 0x01)) // @1223 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1227 5B JUMPDEST 1228 60 PUSH1 0x00 122A 80 DUP1 122B 83 DUP4 122C 61 PUSH2 0x1234 122F 84 DUP5 1230 61 PUSH2 0x138d 1233 56 *JUMP 1234 5B JUMPDEST 1235 60 PUSH1 0x40 1237 51 MLOAD 1238 60 PUSH1 0x20 123A 01 ADD 123B 61 PUSH2 0x1245 123E 92 SWAP3 123F 91 SWAP2 1240 90 SWAP1 1241 61 PUSH2 0x252b 1244 56 *JUMP 1245 5B JUMPDEST 1246 60 PUSH1 0x40 1248 51 MLOAD 1249 60 PUSH1 0x20 124B 81 DUP2 124C 83 DUP4 124D 03 SUB 124E 03 SUB 124F 81 DUP2 1250 52 MSTORE 1251 90 SWAP1 1252 60 PUSH1 0x40 1254 52 MSTORE 1255 80 DUP1 1256 51 MLOAD 1257 90 SWAP1 1258 60 PUSH1 0x20 125A 01 ADD 125B 20 SHA3 125C 90 SWAP1 125D 50 POP 125E 61 PUSH2 0x129e 1261 86 DUP7 1262 86 DUP7 1263 80 DUP1 1264 80 DUP1 1265 60 PUSH1 0x20 1267 02 MUL 1268 60 PUSH1 0x20 126A 01 ADD 126B 60 PUSH1 0x40 126D 51 MLOAD 126E 90 SWAP1 126F 81 DUP2 1270 01 ADD 1271 60 PUSH1 0x40 1273 52 MSTORE 1274 80 DUP1 1275 93 SWAP4 1276 92 SWAP3 1277 91 SWAP2 1278 90 SWAP1 1279 81 DUP2 127A 81 DUP2 127B 52 MSTORE 127C 60 PUSH1 0x20 127E 01 ADD 127F 83 DUP4 1280 83 DUP4 1281 60 PUSH1 0x20 1283 02 MUL 1284 80 DUP1 1285 82 DUP3 1286 84 DUP5 1287 37 CALLDATACOPY 1288 60 PUSH1 0x00 128A 92 SWAP3 128B 01 ADD 128C 91 SWAP2 128D 90 SWAP1 128E 91 SWAP2 128F 52 MSTORE 1290 50 POP 1291 50 POP 1292 60 PUSH1 0x0e 1294 54 SLOAD 1295 91 SWAP2 1296 50 POP 1297 84 DUP5 1298 90 SWAP1 1299 50 POP 129A 61 PUSH2 0x14a5 129D 56 *JUMP 129E 5B JUMPDEST 129F 96 SWAP7 12A0 95 SWAP6 12A1 50 POP 12A2 50 POP 12A3 50 POP 12A4 50 POP 12A5 50 POP 12A6 50 POP 12A7 56 *JUMP 12A8 5B JUMPDEST 12A9 81 DUP2 12AA 60 PUSH1 0x01 12AC 60 PUSH1 0x01 12AE 60 PUSH1 0xa0 12B0 1B SHL 12B1 03 SUB 12B2 16 AND 12B3 83 DUP4 12B4 60 PUSH1 0x01 12B6 60 PUSH1 0x01 12B8 60 PUSH1 0xa0 12BA 1B SHL 12BB 03 SUB 12BC 16 AND 12BD 14 EQ 12BE 15 ISZERO 12BF 61 PUSH2 0x12da 12C2 57 *JUMPI 12C3 60 PUSH1 0x40 12C5 51 MLOAD 12C6 62 PUSH3 0x461bcd 12CA 60 PUSH1 0xe5 12CC 1B SHL 12CD 81 DUP2 12CE 52 MSTORE 12CF 60 PUSH1 0x04 12D1 01 ADD 12D2 61 PUSH2 0x0792 12D5 90 SWAP1 12D6 61 PUSH2 0x257b 12D9 56 *JUMP 12DA 5B JUMPDEST 12DB 60 PUSH1 0x01 12DD 60 PUSH1 0x01 12DF 60 PUSH1 0xa0 12E1 1B SHL 12E2 03 SUB 12E3 83 DUP4 12E4 81 DUP2 12E5 16 AND 12E6 60 PUSH1 0x00 12E8 81 DUP2 12E9 81 DUP2 12EA 52 MSTORE 12EB 60 PUSH1 0x05 12ED 60 PUSH1 0x20 12EF 90 SWAP1 12F0 81 DUP2 12F1 52 MSTORE 12F2 60 PUSH1 0x40 12F4 80 DUP1 12F5 83 DUP4 12F6 20 SHA3 12F7 94 SWAP5 12F8 87 DUP8 12F9 16 AND 12FA 80 DUP1 12FB 84 DUP5 12FC 52 MSTORE 12FD 94 SWAP5 12FE 90 SWAP1 12FF 91 SWAP2 1300 52 MSTORE 1301 90 SWAP1 1302 81 DUP2 1303 90 SWAP1 1304 20 SHA3 1305 80 DUP1 1306 54 SLOAD 1307 60 PUSH1 0xff 1309 19 NOT 130A 16 AND 130B 85 DUP6 130C 15 ISZERO 130D 15 ISZERO 130E 17 OR 130F 90 SWAP1 1310 55 SSTORE 1311 51 MLOAD 1312 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1333 90 SWAP1 1334 61 PUSH2 0x133e 1337 90 SWAP1 1338 85 DUP6 1339 90 SWAP1 133A 61 PUSH2 0x18de 133D 56 *JUMP 133E 5B JUMPDEST 133F 60 PUSH1 0x40 1341 51 MLOAD 1342 80 DUP1 1343 91 SWAP2 1344 03 SUB 1345 90 SWAP1 1346 A3 LOG3 1347 50 POP 1348 50 POP 1349 50 POP 134A 56 *JUMP 134B 5B JUMPDEST 134C 61 PUSH2 0x1356 134F 84 DUP5 1350 84 DUP5 1351 84 DUP5 1352 61 PUSH2 0x1047 1355 56 *JUMP 1356 5B JUMPDEST 1357 61 PUSH2 0x1362 135A 84 DUP5 135B 84 DUP5 135C 84 DUP5 135D 84 DUP5 135E 61 PUSH2 0x14bb 1361 56 *JUMP 1362 5B JUMPDEST 1363 61 PUSH2 0x0dbb 1366 57 *JUMPI 1367 60 PUSH1 0x40 1369 51 MLOAD 136A 62 PUSH3 0x461bcd 136E 60 PUSH1 0xe5 1370 1B SHL 1371 81 DUP2 1372 52 MSTORE 1373 60 PUSH1 0x04 1375 01 ADD 1376 61 PUSH2 0x0792 1379 90 SWAP1 137A 61 PUSH2 0x25da 137D 56 *JUMP 137E 5B JUMPDEST 137F 60 PUSH1 0x60 1381 60 PUSH1 0x0a 1383 80 DUP1 1384 54 SLOAD 1385 61 PUSH2 0x06db 1388 90 SWAP1 1389 61 PUSH2 0x1e67 138C 56 *JUMP 138D 5B JUMPDEST 138E 60 PUSH1 0x60 1390 81 DUP2 1391 61 PUSH2 0x13b1 1394 57 *JUMPI 1395 50 POP 1396 50 POP 1397 60 PUSH1 0x40 1399 80 DUP1 139A 51 MLOAD 139B 80 DUP1 139C 82 DUP3 139D 01 ADD 139E 90 SWAP1 139F 91 SWAP2 13A0 52 MSTORE 13A1 60 PUSH1 0x01 13A3 81 DUP2 13A4 52 MSTORE 13A5 60 PUSH1 0x03 13A7 60 PUSH1 0xfc 13A9 1B SHL 13AA 60 PUSH1 0x20 13AC 82 DUP3 13AD 01 ADD 13AE 52 MSTORE 13AF 90 SWAP1 13B0 56 *JUMP 13B1 5B JUMPDEST 13B2 81 DUP2 13B3 60 PUSH1 0x00 13B5 5B JUMPDEST 13B6 81 DUP2 13B7 15 ISZERO 13B8 61 PUSH2 0x13db 13BB 57 *JUMPI 13BC 80 DUP1 13BD 61 PUSH2 0x13c5 13C0 81 DUP2 13C1 61 PUSH2 0x24e8 13C4 56 *JUMP 13C5 5B JUMPDEST 13C6 91 SWAP2 13C7 50 POP 13C8 61 PUSH2 0x13d4 13CB 90 SWAP1 13CC 50 POP 13CD 60 PUSH1 0x0a 13CF 83 DUP4 13D0 61 PUSH2 0x2077 13D3 56 *JUMP 13D4 5B JUMPDEST 13D5 91 SWAP2 13D6 50 POP 13D7 61 PUSH2 0x13b5 13DA 56 *JUMP 13DB 5B JUMPDEST 13DC 60 PUSH1 0x00 13DE 81 DUP2 13DF 67 PUSH8 0xffffffffffffffff 13E8 81 DUP2 13E9 11 GT 13EA 15 ISZERO 13EB 61 PUSH2 0x13f6 13EE 57 *JUMPI 13EF 61 PUSH2 0x13f6 13F2 61 PUSH2 0x1b5b 13F5 56 *JUMP 13F6 5B JUMPDEST 13F7 60 PUSH1 0x40 13F9 51 MLOAD 13FA 90 SWAP1 13FB 80 DUP1 13FC 82 DUP3 13FD 52 MSTORE 13FE 80 DUP1 13FF 60 PUSH1 0x1f 1401 01 ADD 1402 60 PUSH1 0x1f 1404 19 NOT 1405 16 AND 1406 60 PUSH1 0x20 1408 01 ADD 1409 82 DUP3 140A 01 ADD 140B 60 PUSH1 0x40 140D 52 MSTORE 140E 80 DUP1 140F 15 ISZERO 1410 61 PUSH2 0x1420 1413 57 *JUMPI 1414 60 PUSH1 0x20 1416 82 DUP3 1417 01 ADD 1418 81 DUP2 1419 80 DUP1 141A 36 CALLDATASIZE 141B 83 DUP4 141C 37 CALLDATACOPY 141D 01 ADD 141E 90 SWAP1 141F 50 POP 1420 5B JUMPDEST 1421 50 POP 1422 90 SWAP1 1423 50 POP 1424 5B JUMPDEST 1425 84 DUP5 1426 15 ISZERO 1427 61 PUSH2 0x103f 142A 57 *JUMPI 142B 61 PUSH2 0x1435 142E 60 PUSH1 0x01 1430 83 DUP4 1431 61 PUSH2 0x21d0 1434 56 *JUMP 1435 5B JUMPDEST 1436 91 SWAP2 1437 50 POP 1438 61 PUSH2 0x1442 143B 60 PUSH1 0x0a 143D 86 DUP7 143E 61 PUSH2 0x25ea 1441 56 *JUMP 1442 5B JUMPDEST 1443 61 PUSH2 0x144d 1446 90 SWAP1 1447 60 PUSH1 0x30 1449 61 PUSH2 0x22a3 144C 56 *JUMP 144D 5B JUMPDEST 144E 60 PUSH1 0xf8 1450 1B SHL 1451 81 DUP2 1452 83 DUP4 1453 81 DUP2 1454 51 MLOAD 1455 81 DUP2 1456 10 LT 1457 61 PUSH2 0x1462 145A 57 *JUMPI 145B 61 PUSH2 0x1462 145E 61 PUSH2 0x25fe 1461 56 *JUMP 1462 5B JUMPDEST 1463 60 PUSH1 0x20 1465 01 ADD 1466 01 ADD 1467 90 SWAP1 1468 60 PUSH1 0x01 146A 60 PUSH1 0x01 146C 60 PUSH1 0xf8 146E 1B SHL 146F 03 SUB 1470 19 NOT 1471 16 AND 1472 90 SWAP1 1473 81 DUP2 1474 60 PUSH1 0x00 1476 1A BYTE 1477 90 SWAP1 1478 53 MSTORE8 1479 50 POP 147A 61 PUSH2 0x1484 147D 60 PUSH1 0x0a 147F 86 DUP7 1480 61 PUSH2 0x2077 1483 56 *JUMP 1484 5B JUMPDEST 1485 94 SWAP5 1486 50 POP 1487 61 PUSH2 0x1424 148A 56 *JUMP 148B 5B JUMPDEST 148C 61 PUSH2 0x0a22 148F 82 DUP3 1490 82 DUP3 1491 60 PUSH1 0x40 1493 51 MLOAD 1494 80 DUP1 1495 60 PUSH1 0x20 1497 01 ADD 1498 60 PUSH1 0x40 149A 52 MSTORE 149B 80 DUP1 149C 60 PUSH1 0x00 149E 81 DUP2 149F 52 MSTORE 14A0 50 POP 14A1 61 PUSH2 0x15c5 14A4 56 *JUMP 14A5 5B JUMPDEST 14A6 60 PUSH1 0x00 14A8 82 DUP3 14A9 61 PUSH2 0x14b2 14AC 85 DUP6 14AD 84 DUP5 14AE 61 PUSH2 0x15f8 14B1 56 *JUMP 14B2 5B JUMPDEST 14B3 14 EQ 14B4 94 SWAP5 14B5 93 SWAP4 14B6 50 POP 14B7 50 POP 14B8 50 POP 14B9 50 POP 14BA 56 *JUMP 14BB 5B JUMPDEST 14BC 60 PUSH1 0x00 14BE 60 PUSH1 0x01 14C0 60 PUSH1 0x01 14C2 60 PUSH1 0xa0 14C4 1B SHL 14C5 03 SUB 14C6 84 DUP5 14C7 16 AND 14C8 3B EXTCODESIZE 14C9 15 ISZERO 14CA 61 PUSH2 0x15bd 14CD 57 *JUMPI 14CE 60 PUSH1 0x40 14D0 51 MLOAD 14D1 63 PUSH4 0x0a85bd01 14D6 60 PUSH1 0xe1 14D8 1B SHL 14D9 81 DUP2 14DA 52 MSTORE 14DB 60 PUSH1 0x01 14DD 60 PUSH1 0x01 14DF 60 PUSH1 0xa0 14E1 1B SHL 14E2 03 SUB 14E3 85 DUP6 14E4 16 AND 14E5 90 SWAP1 14E6 63 PUSH4 0x150b7a02 14EB 90 SWAP1 14EC 61 PUSH2 0x14ff 14EF 90 SWAP1 14F0 33 CALLER 14F1 90 SWAP1 14F2 89 DUP10 14F3 90 SWAP1 14F4 88 DUP9 14F5 90 SWAP1 14F6 88 DUP9 14F7 90 SWAP1 14F8 60 PUSH1 0x04 14FA 01 ADD 14FB 61 PUSH2 0x2614 14FE 56 *JUMP 14FF 5B JUMPDEST 1500 60 PUSH1 0x20 1502 60 PUSH1 0x40 1504 51 MLOAD 1505 80 DUP1 1506 83 DUP4 1507 03 SUB 1508 81 DUP2 1509 60 PUSH1 0x00 150B 87 DUP8 150C 80 DUP1 150D 3B EXTCODESIZE 150E 15 ISZERO 150F 80 DUP1 1510 15 ISZERO 1511 61 PUSH2 0x1519 1514 57 *JUMPI 1515 60 PUSH1 0x00 1517 80 DUP1 1518 FD *REVERT 1519 5B JUMPDEST 151A 50 POP 151B 5A GAS 151C F1 CALL 151D 92 SWAP3 151E 50 POP 151F 50 POP 1520 50 POP 1521 80 DUP1 1522 15 ISZERO 1523 61 PUSH2 0x1549 1526 57 *JUMPI 1527 50 POP 1528 60 PUSH1 0x40 152A 80 DUP1 152B 51 MLOAD 152C 60 PUSH1 0x1f 152E 3D RETURNDATASIZE 152F 90 SWAP1 1530 81 DUP2 1531 01 ADD 1532 60 PUSH1 0x1f 1534 19 NOT 1535 16 AND 1536 82 DUP3 1537 01 ADD 1538 90 SWAP1 1539 92 SWAP3 153A 52 MSTORE 153B 61 PUSH2 0x1546 153E 91 SWAP2 153F 81 DUP2 1540 01 ADD 1541 90 SWAP1 1542 61 PUSH2 0x2659 1545 56 *JUMP 1546 5B JUMPDEST 1547 60 PUSH1 0x01 1549 5B JUMPDEST 154A 61 PUSH2 0x15a3 154D 57 *JUMPI 154E 3D RETURNDATASIZE 154F 80 DUP1 1550 80 DUP1 1551 15 ISZERO 1552 61 PUSH2 0x1577 1555 57 *JUMPI 1556 60 PUSH1 0x40 1558 51 MLOAD 1559 91 SWAP2 155A 50 POP 155B 60 PUSH1 0x1f 155D 19 NOT 155E 60 PUSH1 0x3f 1560 3D RETURNDATASIZE 1561 01 ADD 1562 16 AND 1563 82 DUP3 1564 01 ADD 1565 60 PUSH1 0x40 1567 52 MSTORE 1568 3D RETURNDATASIZE 1569 82 DUP3 156A 52 MSTORE 156B 3D RETURNDATASIZE 156C 60 PUSH1 0x00 156E 60 PUSH1 0x20 1570 84 DUP5 1571 01 ADD 1572 3E RETURNDATACOPY 1573 61 PUSH2 0x157c 1576 56 *JUMP 1577 5B JUMPDEST 1578 60 PUSH1 0x60 157A 91 SWAP2 157B 50 POP 157C 5B JUMPDEST 157D 50 POP 157E 80 DUP1 157F 51 MLOAD 1580 61 PUSH2 0x159b 1583 57 *JUMPI 1584 60 PUSH1 0x40 1586 51 MLOAD 1587 62 PUSH3 0x461bcd 158B 60 PUSH1 0xe5 158D 1B SHL 158E 81 DUP2 158F 52 MSTORE 1590 60 PUSH1 0x04 1592 01 ADD 1593 61 PUSH2 0x0792 1596 90 SWAP1 1597 61 PUSH2 0x25da 159A 56 *JUMP 159B 5B JUMPDEST 159C 80 DUP1 159D 51 MLOAD 159E 81 DUP2 159F 60 PUSH1 0x20 15A1 01 ADD 15A2 FD *REVERT 15A3 5B JUMPDEST 15A4 60 PUSH1 0x01 15A6 60 PUSH1 0x01 15A8 60 PUSH1 0xe0 15AA 1B SHL 15AB 03 SUB 15AC 19 NOT 15AD 16 AND 15AE 63 PUSH4 0x0a85bd01 15B3 60 PUSH1 0xe1 15B5 1B SHL 15B6 14 EQ 15B7 90 SWAP1 15B8 50 POP 15B9 61 PUSH2 0x103f 15BC 56 *JUMP 15BD 5B JUMPDEST 15BE 50 POP 15BF 60 PUSH1 0x01 15C1 61 PUSH2 0x103f 15C4 56 *JUMP 15C5 5B JUMPDEST 15C6 61 PUSH2 0x15cf 15C9 83 DUP4 15CA 83 DUP4 15CB 61 PUSH2 0x16a2 15CE 56 *JUMP 15CF 5B JUMPDEST 15D0 61 PUSH2 0x15dc 15D3 60 PUSH1 0x00 15D5 84 DUP5 15D6 84 DUP5 15D7 84 DUP5 15D8 61 PUSH2 0x14bb 15DB 56 *JUMP 15DC 5B JUMPDEST 15DD 61 PUSH2 0x0838 15E0 57 *JUMPI 15E1 60 PUSH1 0x40 15E3 51 MLOAD 15E4 62 PUSH3 0x461bcd 15E8 60 PUSH1 0xe5 15EA 1B SHL 15EB 81 DUP2 15EC 52 MSTORE 15ED 60 PUSH1 0x04 15EF 01 ADD 15F0 61 PUSH2 0x0792 15F3 90 SWAP1 15F4 61 PUSH2 0x25da 15F7 56 *JUMP 15F8 5B JUMPDEST 15F9 60 PUSH1 0x00 15FB 81 DUP2 15FC 81 DUP2 15FD 5B JUMPDEST 15FE 84 DUP5 15FF 51 MLOAD 1600 81 DUP2 1601 10 LT 1602 15 ISZERO 1603 61 PUSH2 0x169a 1606 57 *JUMPI 1607 60 PUSH1 0x00 1609 85 DUP6 160A 82 DUP3 160B 81 DUP2 160C 51 MLOAD 160D 81 DUP2 160E 10 LT 160F 61 PUSH2 0x161a 1612 57 *JUMPI 1613 61 PUSH2 0x161a 1616 61 PUSH2 0x25fe 1619 56 *JUMP 161A 5B JUMPDEST 161B 60 PUSH1 0x20 161D 02 MUL 161E 60 PUSH1 0x20 1620 01 ADD 1621 01 ADD 1622 51 MLOAD 1623 90 SWAP1 1624 50 POP 1625 80 DUP1 1626 83 DUP4 1627 11 GT 1628 61 PUSH2 0x165b 162B 57 *JUMPI 162C 82 DUP3 162D 81 DUP2 162E 60 PUSH1 0x40 1630 51 MLOAD 1631 60 PUSH1 0x20 1633 01 ADD 1634 61 PUSH2 0x163e 1637 92 SWAP3 1638 91 SWAP2 1639 90 SWAP1 163A 61 PUSH2 0x267a 163D 56 *JUMP 163E 5B JUMPDEST 163F 60 PUSH1 0x40 1641 51 MLOAD 1642 60 PUSH1 0x20 1644 81 DUP2 1645 83 DUP4 1646 03 SUB 1647 03 SUB 1648 81 DUP2 1649 52 MSTORE 164A 90 SWAP1 164B 60 PUSH1 0x40 164D 52 MSTORE 164E 80 DUP1 164F 51 MLOAD 1650 90 SWAP1 1651 60 PUSH1 0x20 1653 01 ADD 1654 20 SHA3 1655 92 SWAP3 1656 50 POP 1657 61 PUSH2 0x1687 165A 56 *JUMP 165B 5B JUMPDEST 165C 80 DUP1 165D 83 DUP4 165E 60 PUSH1 0x40 1660 51 MLOAD 1661 60 PUSH1 0x20 1663 01 ADD 1664 61 PUSH2 0x166e 1667 92 SWAP3 1668 91 SWAP2 1669 90 SWAP1 166A 61 PUSH2 0x267a 166D 56 *JUMP 166E 5B JUMPDEST 166F 60 PUSH1 0x40 1671 51 MLOAD 1672 60 PUSH1 0x20 1674 81 DUP2 1675 83 DUP4 1676 03 SUB 1677 03 SUB 1678 81 DUP2 1679 52 MSTORE 167A 90 SWAP1 167B 60 PUSH1 0x40 167D 52 MSTORE 167E 80 DUP1 167F 51 MLOAD 1680 90 SWAP1 1681 60 PUSH1 0x20 1683 01 ADD 1684 20 SHA3 1685 92 SWAP3 1686 50 POP 1687 5B JUMPDEST 1688 50 POP 1689 80 DUP1 168A 61 PUSH2 0x1692 168D 81 DUP2 168E 61 PUSH2 0x24e8 1691 56 *JUMP 1692 5B JUMPDEST 1693 91 SWAP2 1694 50 POP 1695 50 POP 1696 61 PUSH2 0x15fd 1699 56 *JUMP label_169A: // Incoming return from call to 0x1BE5 at 0x1C29 // Inputs[3] // { // @169C stack[-2] // @169C stack[-6] // @169D stack[-5] // } 169A 5B JUMPDEST 169B 50 POP 169C 93 SWAP4 169D 92 SWAP3 169E 50 POP 169F 50 POP 16A0 50 POP 16A1 56 *JUMP // Stack delta = -5 // Outputs[1] { @169C stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] 16A2 5B JUMPDEST 16A3 60 PUSH1 0x01 16A5 60 PUSH1 0x01 16A7 60 PUSH1 0xa0 16A9 1B SHL 16AA 03 SUB 16AB 82 DUP3 16AC 16 AND 16AD 61 PUSH2 0x16c8 16B0 57 *JUMPI 16B1 60 PUSH1 0x40 16B3 51 MLOAD 16B4 62 PUSH3 0x461bcd 16B8 60 PUSH1 0xe5 16BA 1B SHL 16BB 81 DUP2 16BC 52 MSTORE 16BD 60 PUSH1 0x04 16BF 01 ADD 16C0 61 PUSH2 0x0792 16C3 90 SWAP1 16C4 61 PUSH2 0x26d2 16C7 56 *JUMP 16C8 5B JUMPDEST 16C9 60 PUSH1 0x00 16CB 81 DUP2 16CC 81 DUP2 16CD 52 MSTORE 16CE 60 PUSH1 0x02 16D0 60 PUSH1 0x20 16D2 52 MSTORE 16D3 60 PUSH1 0x40 16D5 90 SWAP1 16D6 20 SHA3 16D7 54 SLOAD 16D8 60 PUSH1 0x01 16DA 60 PUSH1 0x01 16DC 60 PUSH1 0xa0 16DE 1B SHL 16DF 03 SUB 16E0 16 AND 16E1 15 ISZERO 16E2 61 PUSH2 0x16fd 16E5 57 *JUMPI 16E6 60 PUSH1 0x40 16E8 51 MLOAD 16E9 62 PUSH3 0x461bcd 16ED 60 PUSH1 0xe5 16EF 1B SHL 16F0 81 DUP2 16F1 52 MSTORE 16F2 60 PUSH1 0x04 16F4 01 ADD 16F5 61 PUSH2 0x0792 16F8 90 SWAP1 16F9 61 PUSH2 0x2716 16FC 56 *JUMP 16FD 5B JUMPDEST 16FE 60 PUSH1 0x01 1700 60 PUSH1 0x01 1702 60 PUSH1 0xa0 1704 1B SHL 1705 03 SUB 1706 82 DUP3 1707 16 AND 1708 60 PUSH1 0x00 170A 90 SWAP1 170B 81 DUP2 170C 52 MSTORE 170D 60 PUSH1 0x03 170F 60 PUSH1 0x20 1711 52 MSTORE 1712 60 PUSH1 0x40 1714 81 DUP2 1715 20 SHA3 1716 80 DUP1 1717 54 SLOAD 1718 60 PUSH1 0x01 171A 92 SWAP3 171B 90 SWAP1 171C 61 PUSH2 0x1726 171F 90 SWAP1 1720 84 DUP5 1721 90 SWAP1 1722 61 PUSH2 0x22a3 1725 56 *JUMP 1726 5B JUMPDEST 1727 90 SWAP1 1728 91 SWAP2 1729 55 SSTORE 172A 50 POP 172B 50 POP 172C 60 PUSH1 0x00 172E 81 DUP2 172F 81 DUP2 1730 52 MSTORE 1731 60 PUSH1 0x02 1733 60 PUSH1 0x20 1735 52 MSTORE 1736 60 PUSH1 0x40 1738 80 DUP1 1739 82 DUP3 173A 20 SHA3 173B 80 DUP1 173C 54 SLOAD 173D 60 PUSH1 0x01 173F 60 PUSH1 0x01 1741 60 PUSH1 0xa0 1743 1B SHL 1744 03 SUB 1745 19 NOT 1746 16 AND 1747 60 PUSH1 0x01 1749 60 PUSH1 0x01 174B 60 PUSH1 0xa0 174D 1B SHL 174E 03 SUB 174F 86 DUP7 1750 16 AND 1751 90 SWAP1 1752 81 DUP2 1753 17 OR 1754 90 SWAP1 1755 91 SWAP2 1756 55 SSTORE 1757 90 SWAP1 1758 51 MLOAD 1759 83 DUP4 175A 92 SWAP3 175B 90 SWAP1 175C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 177D 90 SWAP1 177E 82 DUP3 177F 90 SWAP1 1780 A4 LOG4 1781 50 POP 1782 50 POP 1783 56 *JUMP label_1784: // Incoming jump from 0x0872 // Inputs[2] // { // @1785 stack[-3] // @1787 storage[stack[-3]] // } 1784 5B JUMPDEST 1785 82 DUP3 1786 80 DUP1 1787 54 SLOAD 1788 61 PUSH2 0x1790 178B 90 SWAP1 178C 61 PUSH2 0x1e67 178F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1785 stack[0] = stack[-3] // @178B stack[1] = 0x1790 // @178B stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1e67, returns to 0x1790 label_1790: // Incoming return from call to 0x1E67 at 0x178F // Inputs[5] // { // @1791 stack[-1] // @1791 stack[-2] // @1799 memory[0x00:0x20] // @17A4 stack[-4] // @17A5 stack[-3] // } 1790 5B JUMPDEST 1791 90 SWAP1 1792 60 PUSH1 0x00 1794 52 MSTORE 1795 60 PUSH1 0x20 1797 60 PUSH1 0x00 1799 20 SHA3 179A 90 SWAP1 179B 60 PUSH1 0x1f 179D 01 ADD 179E 60 PUSH1 0x20 17A0 90 SWAP1 17A1 04 DIV 17A2 81 DUP2 17A3 01 ADD 17A4 92 SWAP3 17A5 82 DUP3 17A6 61 PUSH2 0x17b2 17A9 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1794 memory[0x00:0x20] = stack[-2] // @179A stack[-2] = keccak256(memory[0x00:0x20]) // @17A4 stack[-1] = stack[-4] // @17A4 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x17b2, if stack[-3] label_17AA: // Incoming jump from 0x17A9, if not stack[-3] // Inputs[1] { @17AC stack[-5] } 17AA 60 PUSH1 0x00 17AC 85 DUP6 17AD 55 SSTORE 17AE 61 PUSH2 0x17f8 17B1 56 *JUMP // Stack delta = +0 // Outputs[1] { @17AD storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x17f8 label_17B2: // Incoming jump from 0x17A9, if stack[-3] // Inputs[1] { @17B3 stack[-3] } 17B2 5B JUMPDEST 17B3 82 DUP3 17B4 60 PUSH1 0x1f 17B6 10 LT 17B7 61 PUSH2 0x17cb 17BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17cb, if 0x1f < stack[-3] label_17BB: // Incoming jump from 0x17BA, if not 0x1f < stack[-3] // Inputs[4] // { // @17BB stack[-3] // @17C1 stack[-1] // @17C2 msg.data[stack[-1]:stack[-1] + 0x20] // @17C5 stack[-5] // } 17BB 82 DUP3 17BC 80 DUP1 17BD 01 ADD 17BE 60 PUSH1 0xff 17C0 19 NOT 17C1 82 DUP3 17C2 35 CALLDATALOAD 17C3 16 AND 17C4 17 OR 17C5 85 DUP6 17C6 55 SSTORE 17C7 61 PUSH2 0x17f8 17CA 56 *JUMP // Stack delta = +0 // Outputs[1] { @17C6 storage[stack[-5]] = (msg.data[stack[-1]:stack[-1] + 0x20] & ~0xff) | stack[-3] + stack[-3] } // Block ends with unconditional jump to 0x17f8 label_17CB: // Incoming jump from 0x17BA, if 0x1f < stack[-3] // Inputs[2] // { // @17CC stack[-3] // @17D2 stack[-5] // } 17CB 5B JUMPDEST 17CC 82 DUP3 17CD 80 DUP1 17CE 01 ADD 17CF 60 PUSH1 0x01 17D1 01 ADD 17D2 85 DUP6 17D3 55 SSTORE 17D4 82 DUP3 17D5 15 ISZERO 17D6 61 PUSH2 0x17f8 17D9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @17D3 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x17f8, if !stack[-3] label_17DA: // Incoming jump from 0x17D9, if not !stack[-3] // Inputs[2] // { // @17DA stack[-3] // @17DA stack[-1] // } 17DA 91 SWAP2 17DB 82 DUP3 17DC 01 ADD 17DD 5B JUMPDEST 17DE 82 DUP3 17DF 81 DUP2 17E0 11 GT 17E1 15 ISZERO 17E2 61 PUSH2 0x17f8 17E5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @17DA stack[-3] = stack[-1] // @17DC stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x17f8, if !(stack[-1] + stack[-3] > stack[-1]) label_17E6: // Incoming jump from 0x17E5, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x17E5, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @17E6 stack[-3] // @17E7 msg.data[stack[-3]:stack[-3] + 0x20] // @17E8 stack[-2] // @17EA stack[-1] // } 17E6 82 DUP3 17E7 35 CALLDATALOAD 17E8 82 DUP3 17E9 55 SSTORE 17EA 91 SWAP2 17EB 60 PUSH1 0x20 17ED 01 ADD 17EE 91 SWAP2 17EF 90 SWAP1 17F0 60 PUSH1 0x01 17F2 01 ADD 17F3 90 SWAP1 17F4 61 PUSH2 0x17dd 17F7 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @17E9 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @17EE stack[-3] = 0x20 + stack[-3] // @17F3 stack[-2] = 0x01 + stack[-2] // @17F3 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x17dd label_17F8: // Incoming jump from 0x17E5, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x17B1 // Incoming jump from 0x17D9, if !stack[-3] // Incoming jump from 0x17CA // Incoming jump from 0x17E5, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @17FD stack[-4] // @17FE stack[-3] // } 17F8 5B JUMPDEST 17F9 50 POP 17FA 61 PUSH2 0x1804 17FD 92 SWAP3 17FE 91 SWAP2 17FF 50 POP 1800 61 PUSH2 0x187c 1803 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @17FD stack[-4] = 0x1804 // @17FE stack[-3] = stack[-4] // } // Block ends with call to 0x187c, returns to 0x1804 label_1804: // Incoming jump from 0x1885, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x187C at 0x1803 // Incoming jump from 0x1885, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1806 stack[-2] // @1806 stack[-3] // } 1804 5B JUMPDEST 1805 50 POP 1806 90 SWAP1 1807 56 *JUMP // Stack delta = -2 // Outputs[1] { @1806 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] 1808 5B JUMPDEST 1809 82 DUP3 180A 80 DUP1 180B 54 SLOAD 180C 61 PUSH2 0x1814 180F 90 SWAP1 1810 61 PUSH2 0x1e67 1813 56 *JUMP 1814 5B JUMPDEST 1815 90 SWAP1 1816 60 PUSH1 0x00 1818 52 MSTORE 1819 60 PUSH1 0x20 181B 60 PUSH1 0x00 181D 20 SHA3 181E 90 SWAP1 181F 60 PUSH1 0x1f 1821 01 ADD 1822 60 PUSH1 0x20 1824 90 SWAP1 1825 04 DIV 1826 81 DUP2 1827 01 ADD 1828 92 SWAP3 1829 82 DUP3 182A 61 PUSH2 0x1836 182D 57 *JUMPI 182E 60 PUSH1 0x00 1830 85 DUP6 1831 55 SSTORE 1832 61 PUSH2 0x17f8 1835 56 *JUMP 1836 5B JUMPDEST 1837 82 DUP3 1838 60 PUSH1 0x1f 183A 10 LT 183B 61 PUSH2 0x184f 183E 57 *JUMPI 183F 80 DUP1 1840 51 MLOAD 1841 60 PUSH1 0xff 1843 19 NOT 1844 16 AND 1845 83 DUP4 1846 80 DUP1 1847 01 ADD 1848 17 OR 1849 85 DUP6 184A 55 SSTORE 184B 61 PUSH2 0x17f8 184E 56 *JUMP 184F 5B JUMPDEST 1850 82 DUP3 1851 80 DUP1 1852 01 ADD 1853 60 PUSH1 0x01 1855 01 ADD 1856 85 DUP6 1857 55 SSTORE 1858 82 DUP3 1859 15 ISZERO 185A 61 PUSH2 0x17f8 185D 57 *JUMPI 185E 91 SWAP2 185F 82 DUP3 1860 01 ADD 1861 5B JUMPDEST 1862 82 DUP3 1863 81 DUP2 1864 11 GT 1865 15 ISZERO 1866 61 PUSH2 0x17f8 1869 57 *JUMPI 186A 82 DUP3 186B 51 MLOAD 186C 82 DUP3 186D 55 SSTORE 186E 91 SWAP2 186F 60 PUSH1 0x20 1871 01 ADD 1872 91 SWAP2 1873 90 SWAP1 1874 60 PUSH1 0x01 1876 01 ADD 1877 90 SWAP1 1878 61 PUSH2 0x1861 187B 56 *JUMP label_187C: // Incoming call from 0x1803, returns to 0x1804 // Inputs[2] // { // @187E stack[-1] // @187F stack[-2] // } 187C 5B JUMPDEST 187D 5B JUMPDEST 187E 80 DUP1 187F 82 DUP3 1880 11 GT 1881 15 ISZERO 1882 61 PUSH2 0x1804 1885 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1804, if !(stack[-2] > stack[-1]) label_1886: // Incoming jump from 0x1885, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1885, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1888 stack[-1] } 1886 60 PUSH1 0x00 1888 81 DUP2 1889 55 SSTORE 188A 60 PUSH1 0x01 188C 01 ADD 188D 61 PUSH2 0x187d 1890 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1889 storage[stack[-1]] = 0x00 // @188C stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x187d label_1891: // Incoming call from 0x18B2, returns to 0x06C6 // Inputs[1] { @189B stack[-1] } 1891 5B JUMPDEST 1892 60 PUSH1 0x01 1894 60 PUSH1 0x01 1896 60 PUSH1 0xe0 1898 1B SHL 1899 03 SUB 189A 19 NOT 189B 81 DUP2 189C 16 AND 189D 5B JUMPDEST 189E 81 DUP2 189F 14 EQ 18A0 61 PUSH2 0x09d0 18A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09d0, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_18A4: // Incoming jump from 0x18A3, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x18A3, if not stack[-2] == stack[-1] // Inputs[1] { @18A7 memory[0x00:0x00] } 18A4 60 PUSH1 0x00 18A6 80 DUP1 18A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @18A7 revert(memory[0x00:0x00]); } // Block terminates label_18A8: // Incoming jump from 0x18D3 // Inputs[2] // { // @18A9 stack[-1] // @18AA msg.data[stack[-1]:stack[-1] + 0x20] // } 18A8 5B JUMPDEST 18A9 80 DUP1 18AA 35 CALLDATALOAD 18AB 61 PUSH2 0x06c6 18AE 81 DUP2 18AF 61 PUSH2 0x1891 18B2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18AA stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @18AB stack[1] = 0x06c6 // @18AE stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1891, returns to 0x06C6 label_18B3: // Incoming jump from 0x0239 // Inputs[2] // { // @18B8 stack[-1] // @18B9 stack[-2] // } 18B3 5B JUMPDEST 18B4 60 PUSH1 0x00 18B6 60 PUSH1 0x20 18B8 82 DUP3 18B9 84 DUP5 18BA 03 SUB 18BB 12 SLT 18BC 15 ISZERO 18BD 61 PUSH2 0x18c8 18C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18B4 stack[0] = 0x00 } // Block ends with conditional jump to 0x18c8, if !(stack[-2] - stack[-1] i< 0x20) label_18C1: // Incoming jump from 0x18C0, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @18C7 memory[0x00:0x00] } 18C1 61 PUSH2 0x18c8 18C4 60 PUSH1 0x00 18C6 80 DUP1 18C7 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @18C1 stack[0] = 0x18c8 // @18C7 revert(memory[0x00:0x00]); // } // Block terminates label_18C8: // Incoming jump from 0x18C0, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @18CE stack[-3] // @18CF stack[-2] // } 18C8 5B JUMPDEST 18C9 60 PUSH1 0x00 18CB 61 PUSH2 0x103f 18CE 84 DUP5 18CF 84 DUP5 18D0 61 PUSH2 0x18a8 18D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18C9 stack[0] = 0x00 // @18CB stack[1] = 0x103f // @18CE stack[2] = stack[-3] // @18CF stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x18a8 label_18D4: // Incoming call from 0x18EB, returns to 0x06C6 // Inputs[1] { @18D5 stack[-1] } 18D4 5B JUMPDEST 18D5 80 DUP1 18D6 15 ISZERO 18D7 15 ISZERO // Stack delta = +1 // Outputs[1] { @18D7 stack[0] = !!stack[-1] } // Block continues label_18D8: // Incoming return from call to 0x198D at 0x19A6 // Incoming jump from 0x1A2C // Incoming jump from 0x18D7 // Inputs[3] // { // @18D9 stack[-3] // @18DA stack[-1] // @18DD stack[-4] // } 18D8 5B JUMPDEST 18D9 82 DUP3 18DA 52 MSTORE 18DB 50 POP 18DC 50 POP 18DD 56 *JUMP // Stack delta = -4 // Outputs[1] { @18DA memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_18DE: // Incoming jump from 0x024B // Inputs[2] // { // @18E1 stack[-1] // @18E7 stack[-2] // } 18DE 5B JUMPDEST 18DF 60 PUSH1 0x20 18E1 81 DUP2 18E2 01 ADD 18E3 61 PUSH2 0x06c6 18E6 82 DUP3 18E7 84 DUP5 18E8 61 PUSH2 0x18d4 18EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18E2 stack[0] = stack[-1] + 0x20 // @18E3 stack[1] = 0x06c6 // @18E6 stack[2] = stack[-1] // @18E7 stack[3] = stack[-2] // } // Block ends with call to 0x18d4, returns to 0x06C6 label_18EC: // Incoming call from 0x1938, returns to 0x1939 // Inputs[1] { @18F0 stack[-3] } 18EC 5B JUMPDEST 18ED 60 PUSH1 0x00 18EF 5B JUMPDEST 18F0 83 DUP4 18F1 81 DUP2 18F2 10 LT 18F3 15 ISZERO 18F4 61 PUSH2 0x1907 18F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18ED stack[0] = 0x00 } // Block ends with conditional jump to 0x1907, if !(0x00 < stack[-3]) label_18F8: // Incoming jump from 0x18F7, if not !(0x00 < stack[-3]) // Incoming jump from 0x18F7, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @18F8 stack[-2] // @18F9 stack[-1] // @18FB memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @18FC stack[-3] // } 18F8 81 DUP2 18F9 81 DUP2 18FA 01 ADD 18FB 51 MLOAD 18FC 83 DUP4 18FD 82 DUP3 18FE 01 ADD 18FF 52 MSTORE 1900 60 PUSH1 0x20 1902 01 ADD 1903 61 PUSH2 0x18ef 1906 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18FF memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1902 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x18ef label_1907: // Incoming jump from 0x18F7, if !(0x00 < stack[-3]) // Incoming jump from 0x18F7, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1908 stack[-4] // @1909 stack[-1] // } 1907 5B JUMPDEST 1908 83 DUP4 1909 81 DUP2 190A 11 GT 190B 15 ISZERO 190C 61 PUSH2 0x0dbb 190F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dbb, if !(stack[-1] > stack[-4]) label_1910: // Incoming jump from 0x190F, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1914 stack[-4] // @1915 stack[-3] // @1917 stack[-5] // } 1910 50 POP 1911 50 POP 1912 60 PUSH1 0x00 1914 91 SWAP2 1915 01 ADD 1916 52 MSTORE 1917 56 *JUMP // Stack delta = -5 // Outputs[1] { @1916 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1918: // Incoming call from 0x195A, returns to 0x0E4D // Inputs[2] // { // @191E stack[-1] // @191F memory[stack[-1]:stack[-1] + 0x20] // } 1918 5B JUMPDEST 1919 60 PUSH1 0x00 191B 61 PUSH2 0x1922 191E 82 DUP3 191F 51 MLOAD 1920 90 SWAP1 1921 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1919 stack[0] = 0x00 // @1920 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1922 label_1922: // Incoming jump from 0x1921 // Inputs[3] // { // @1923 stack[-1] // @1924 stack[-4] // @1933 stack[-3] // } 1922 5B JUMPDEST 1923 80 DUP1 1924 84 DUP5 1925 52 MSTORE 1926 60 PUSH1 0x20 1928 84 DUP5 1929 01 ADD 192A 93 SWAP4 192B 50 POP 192C 61 PUSH2 0x1939 192F 81 DUP2 1930 85 DUP6 1931 60 PUSH1 0x20 1933 86 DUP7 1934 01 ADD 1935 61 PUSH2 0x18ec 1938 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1925 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @192A stack[-4] = stack[-4] + 0x20 // @192C stack[0] = 0x1939 // @192F stack[1] = stack[-1] // @1930 stack[2] = stack[-4] + 0x20 // @1934 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x18ec, returns to 0x1939 label_1939: // Incoming return from call to 0x18EC at 0x1938 // Inputs[4] // { // @193C stack[-1] // @1941 stack[-4] // @1942 stack[-2] // @1945 stack[-5] // } 1939 5B JUMPDEST 193A 60 PUSH1 0x1f 193C 01 ADD 193D 60 PUSH1 0x1f 193F 19 NOT 1940 16 AND 1941 92 SWAP3 1942 90 SWAP1 1943 92 SWAP3 1944 01 ADD 1945 92 SWAP3 1946 91 SWAP2 1947 50 POP 1948 50 POP 1949 56 *JUMP // Stack delta = -4 // Outputs[1] { @1945 stack[-5] = (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_194A: // Incoming call from 0x0276, returns to 0x024C // Inputs[2] // { // @194E stack[-1] // @1956 stack[-2] // } 194A 5B JUMPDEST 194B 60 PUSH1 0x20 194D 80 DUP1 194E 82 DUP3 194F 52 MSTORE 1950 81 DUP2 1951 01 ADD 1952 61 PUSH2 0x0e4d 1955 81 DUP2 1956 84 DUP5 1957 61 PUSH2 0x1918 195A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @194F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1951 stack[0] = stack[-1] + 0x20 // @1952 stack[1] = 0x0e4d // @1955 stack[2] = stack[-1] + 0x20 // @1956 stack[3] = stack[-2] // } // Block ends with call to 0x1918, returns to 0x0E4D label_195B: // Incoming call from 0x196B, returns to 0x06C6 // Inputs[1] { @195C stack[-1] } 195B 5B JUMPDEST 195C 80 DUP1 195D 61 PUSH2 0x189d 1960 56 *JUMP // Stack delta = +1 // Outputs[1] { @195C stack[0] = stack[-1] } // Block ends with unconditional jump to 0x189d label_1961: // Incoming jump from 0x1B3F // Incoming jump from 0x198C // Incoming jump from 0x1CF8 // Inputs[2] // { // @1962 stack[-1] // @1963 msg.data[stack[-1]:stack[-1] + 0x20] // } 1961 5B JUMPDEST 1962 80 DUP1 1963 35 CALLDATALOAD 1964 61 PUSH2 0x06c6 1967 81 DUP2 1968 61 PUSH2 0x195b 196B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1963 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1964 stack[1] = 0x06c6 // @1967 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x195b, returns to 0x06C6 label_196C: // Incoming jump from 0x0515 // Incoming jump from 0x0291 // Incoming jump from 0x0611 // Incoming jump from 0x04AB // Inputs[2] // { // @1971 stack[-1] // @1972 stack[-2] // } 196C 5B JUMPDEST 196D 60 PUSH1 0x00 196F 60 PUSH1 0x20 1971 82 DUP3 1972 84 DUP5 1973 03 SUB 1974 12 SLT 1975 15 ISZERO 1976 61 PUSH2 0x1981 1979 57 *JUMPI // Stack delta = +1 // Outputs[1] { @196D stack[0] = 0x00 } // Block ends with conditional jump to 0x1981, if !(stack[-2] - stack[-1] i< 0x20) label_197A: // Incoming jump from 0x1979, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1980 memory[0x00:0x00] } 197A 61 PUSH2 0x1981 197D 60 PUSH1 0x00 197F 80 DUP1 1980 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @197A stack[0] = 0x1981 // @1980 revert(memory[0x00:0x00]); // } // Block terminates label_1981: // Incoming jump from 0x1979, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1987 stack[-3] // @1988 stack[-2] // } 1981 5B JUMPDEST 1982 60 PUSH1 0x00 1984 61 PUSH2 0x103f 1987 84 DUP5 1988 84 DUP5 1989 61 PUSH2 0x1961 198C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1982 stack[0] = 0x00 // @1984 stack[1] = 0x103f // @1987 stack[2] = stack[-3] // @1988 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1961 label_198D: // Incoming call from 0x19BD, returns to 0x189D // Incoming call from 0x19A6, returns to 0x18D8 // Inputs[1] { @1998 stack[-1] } 198D 5B JUMPDEST 198E 60 PUSH1 0x00 1990 60 PUSH1 0x01 1992 60 PUSH1 0x01 1994 60 PUSH1 0xa0 1996 1B SHL 1997 03 SUB 1998 82 DUP3 1999 16 AND 199A 61 PUSH2 0x06c6 199D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @198E stack[0] = 0x00 // @1999 stack[1] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x06c6 label_199E: // Incoming jump from 0x19B4 // Inputs[1] { @19A2 stack[-1] } 199E 5B JUMPDEST 199F 61 PUSH2 0x18d8 19A2 81 DUP2 19A3 61 PUSH2 0x198d 19A6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @199F stack[0] = 0x18d8 // @19A2 stack[1] = stack[-1] // } // Block ends with call to 0x198d, returns to 0x18D8 label_19A7: // Incoming jump from 0x02A3 // Inputs[2] // { // @19AA stack[-1] // @19B0 stack[-2] // } 19A7 5B JUMPDEST 19A8 60 PUSH1 0x20 19AA 81 DUP2 19AB 01 ADD 19AC 61 PUSH2 0x06c6 19AF 82 DUP3 19B0 84 DUP5 19B1 61 PUSH2 0x199e 19B4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19AB stack[0] = stack[-1] + 0x20 // @19AC stack[1] = 0x06c6 // @19AF stack[2] = stack[-1] // @19B0 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x199e label_19B5: // Incoming jump from 0x19C8 // Inputs[1] { @19B9 stack[-1] } 19B5 5B JUMPDEST 19B6 61 PUSH2 0x189d 19B9 81 DUP2 19BA 61 PUSH2 0x198d 19BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19B6 stack[0] = 0x189d // @19B9 stack[1] = stack[-1] // } // Block ends with call to 0x198d, returns to 0x189D label_19BE: // Incoming jump from 0x1E3F // Incoming jump from 0x1D78 // Incoming jump from 0x19EA // Incoming jump from 0x1A26 // Incoming jump from 0x1DCF // Incoming jump from 0x1AF1 // Inputs[2] // { // @19BF stack[-1] // @19C0 msg.data[stack[-1]:stack[-1] + 0x20] // } 19BE 5B JUMPDEST 19BF 80 DUP1 19C0 35 CALLDATALOAD 19C1 61 PUSH2 0x06c6 19C4 81 DUP2 19C5 61 PUSH2 0x19b5 19C8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19C0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @19C1 stack[1] = 0x06c6 // @19C4 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x19b5 label_19C9: // Incoming jump from 0x02BE // Incoming jump from 0x046B // Inputs[2] // { // @19CF stack[-1] // @19D0 stack[-2] // } 19C9 5B JUMPDEST 19CA 60 PUSH1 0x00 19CC 80 DUP1 19CD 60 PUSH1 0x40 19CF 83 DUP4 19D0 85 DUP6 19D1 03 SUB 19D2 12 SLT 19D3 15 ISZERO 19D4 61 PUSH2 0x19df 19D7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19CA stack[0] = 0x00 // @19CC stack[1] = 0x00 // } // Block ends with conditional jump to 0x19df, if !(stack[-2] - stack[-1] i< 0x40) label_19D8: // Incoming jump from 0x19D7, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @19DE memory[0x00:0x00] } 19D8 61 PUSH2 0x19df 19DB 60 PUSH1 0x00 19DD 80 DUP1 19DE FD *REVERT // Stack delta = +1 // Outputs[2] // { // @19D8 stack[0] = 0x19df // @19DE revert(memory[0x00:0x00]); // } // Block terminates label_19DF: // Incoming jump from 0x19D7, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @19E5 stack[-4] // @19E6 stack[-3] // } 19DF 5B JUMPDEST 19E0 60 PUSH1 0x00 19E2 61 PUSH2 0x19eb 19E5 85 DUP6 19E6 85 DUP6 19E7 61 PUSH2 0x19be 19EA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19E0 stack[0] = 0x00 // @19E2 stack[1] = 0x19eb // @19E5 stack[2] = stack[-4] // @19E6 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x19be 19EB 5B JUMPDEST 19EC 92 SWAP3 19ED 50 POP 19EE 50 POP 19EF 60 PUSH1 0x20 19F1 61 PUSH2 0x19fc 19F4 85 DUP6 19F5 82 DUP3 19F6 86 DUP7 19F7 01 ADD 19F8 61 PUSH2 0x1961 19FB 56 *JUMP 19FC 5B JUMPDEST 19FD 91 SWAP2 19FE 50 POP 19FF 50 POP 1A00 92 SWAP3 1A01 50 POP 1A02 92 SWAP3 1A03 90 SWAP1 1A04 50 POP 1A05 56 *JUMP label_1A06: // Incoming jump from 0x03E0 // Incoming jump from 0x0686 // Incoming jump from 0x04E0 // Incoming jump from 0x02E0 // Incoming jump from 0x0358 // Inputs[2] // { // @1A0B stack[-1] // @1A0C stack[-2] // } 1A06 5B JUMPDEST 1A07 60 PUSH1 0x00 1A09 60 PUSH1 0x20 1A0B 82 DUP3 1A0C 84 DUP5 1A0D 03 SUB 1A0E 12 SLT 1A0F 15 ISZERO 1A10 61 PUSH2 0x1a1b 1A13 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A07 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a1b, if !(stack[-2] - stack[-1] i< 0x20) label_1A14: // Incoming jump from 0x1A13, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A1A memory[0x00:0x00] } 1A14 61 PUSH2 0x1a1b 1A17 60 PUSH1 0x00 1A19 80 DUP1 1A1A FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A14 stack[0] = 0x1a1b // @1A1A revert(memory[0x00:0x00]); // } // Block terminates label_1A1B: // Incoming jump from 0x1A13, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1A21 stack[-3] // @1A22 stack[-2] // } 1A1B 5B JUMPDEST 1A1C 60 PUSH1 0x00 1A1E 61 PUSH2 0x103f 1A21 84 DUP5 1A22 84 DUP5 1A23 61 PUSH2 0x19be 1A26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A1C stack[0] = 0x00 // @1A1E stack[1] = 0x103f // @1A21 stack[2] = stack[-3] // @1A22 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x19be label_1A27: // Incoming call from 0x1A3A, returns to 0x06C6 // Inputs[1] { @1A28 stack[-1] } 1A27 5B JUMPDEST 1A28 80 DUP1 1A29 61 PUSH2 0x18d8 1A2C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A28 stack[0] = stack[-1] } // Block ends with unconditional jump to 0x18d8 label_1A2D: // Incoming jump from 0x0308 // Inputs[2] // { // @1A30 stack[-1] // @1A36 stack[-2] // } 1A2D 5B JUMPDEST 1A2E 60 PUSH1 0x20 1A30 81 DUP2 1A31 01 ADD 1A32 61 PUSH2 0x06c6 1A35 82 DUP3 1A36 84 DUP5 1A37 61 PUSH2 0x1a27 1A3A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A31 stack[0] = stack[-1] + 0x20 // @1A32 stack[1] = 0x06c6 // @1A35 stack[2] = stack[-1] // @1A36 stack[3] = stack[-2] // } // Block ends with call to 0x1a27, returns to 0x06C6 label_1A3B: // Incoming call from 0x1AC1, returns to 0x1AC2 // Inputs[2] // { // @1A3F stack[-2] // @1A42 stack[-1] // } 1A3B 5B JUMPDEST 1A3C 60 PUSH1 0x00 1A3E 80 DUP1 1A3F 83 DUP4 1A40 60 PUSH1 0x1f 1A42 84 DUP5 1A43 01 ADD 1A44 12 SLT 1A45 61 PUSH2 0x1a50 1A48 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A3C stack[0] = 0x00 // @1A3E stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a50, if stack[-1] + 0x1f i< stack[-2] label_1A49: // Incoming jump from 0x1A48, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1A4F memory[0x00:0x00] } 1A49 61 PUSH2 0x1a50 1A4C 60 PUSH1 0x00 1A4E 80 DUP1 1A4F FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A49 stack[0] = 0x1a50 // @1A4F revert(memory[0x00:0x00]); // } // Block terminates label_1A50: // Incoming jump from 0x1A48, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1A52 stack[-3] // @1A53 msg.data[stack[-3]:stack[-3] + 0x20] // } 1A50 5B JUMPDEST 1A51 50 POP 1A52 81 DUP2 1A53 35 CALLDATALOAD 1A54 67 PUSH8 0xffffffffffffffff 1A5D 81 DUP2 1A5E 11 GT 1A5F 15 ISZERO 1A60 61 PUSH2 0x1a6b 1A63 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A53 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1a6b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1A64: // Incoming jump from 0x1A63, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1A6A memory[0x00:0x00] } 1A64 61 PUSH2 0x1a6b 1A67 60 PUSH1 0x00 1A69 80 DUP1 1A6A FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A64 stack[0] = 0x1a6b // @1A6A revert(memory[0x00:0x00]); // } // Block terminates label_1A6B: // Incoming jump from 0x1A63, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @1A6E stack[-3] // @1A70 stack[-2] // @1A72 stack[-4] // @1A75 stack[-1] // } 1A6B 5B JUMPDEST 1A6C 60 PUSH1 0x20 1A6E 83 DUP4 1A6F 01 ADD 1A70 91 SWAP2 1A71 50 POP 1A72 83 DUP4 1A73 60 PUSH1 0x01 1A75 82 DUP3 1A76 02 MUL 1A77 83 DUP4 1A78 01 ADD 1A79 11 GT 1A7A 15 ISZERO 1A7B 61 PUSH2 0x091a 1A7E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A70 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x091a, if !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) label_1A7F: // Incoming jump from 0x1A7E, if not !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) // Inputs[1] { @1A85 memory[0x00:0x00] } 1A7F 61 PUSH2 0x091a 1A82 60 PUSH1 0x00 1A84 80 DUP1 1A85 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A7F stack[0] = 0x091a // @1A85 revert(memory[0x00:0x00]); // } // Block terminates label_1A86: // Incoming call from 0x0323, returns to 0x0324 // Inputs[2] // { // @1A8C stack[-1] // @1A8D stack[-2] // } 1A86 5B JUMPDEST 1A87 60 PUSH1 0x00 1A89 80 DUP1 1A8A 60 PUSH1 0x20 1A8C 83 DUP4 1A8D 85 DUP6 1A8E 03 SUB 1A8F 12 SLT 1A90 15 ISZERO 1A91 61 PUSH2 0x1a9c 1A94 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A87 stack[0] = 0x00 // @1A89 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a9c, if !(stack[-2] - stack[-1] i< 0x20) label_1A95: // Incoming jump from 0x1A94, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A9B memory[0x00:0x00] } 1A95 61 PUSH2 0x1a9c 1A98 60 PUSH1 0x00 1A9A 80 DUP1 1A9B FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1A95 stack[0] = 0x1a9c // @1A9B revert(memory[0x00:0x00]); // } // Block terminates label_1A9C: // Incoming jump from 0x1A94, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1A9D stack[-3] // @1A9E msg.data[stack[-3]:stack[-3] + 0x20] // } 1A9C 5B JUMPDEST 1A9D 82 DUP3 1A9E 35 CALLDATALOAD 1A9F 67 PUSH8 0xffffffffffffffff 1AA8 81 DUP2 1AA9 11 GT 1AAA 15 ISZERO 1AAB 61 PUSH2 0x1ab6 1AAE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A9E stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1ab6, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1AAF: // Incoming jump from 0x1AAE, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1AB5 memory[0x00:0x00] } 1AAF 61 PUSH2 0x1ab6 1AB2 60 PUSH1 0x00 1AB4 80 DUP1 1AB5 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1AAF stack[0] = 0x1ab6 // @1AB5 revert(memory[0x00:0x00]); // } // Block terminates label_1AB6: // Incoming jump from 0x1AAE, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1ABA stack[-5] // @1ABB stack[-1] // @1ABC stack[-4] // } 1AB6 5B JUMPDEST 1AB7 61 PUSH2 0x1ac2 1ABA 85 DUP6 1ABB 82 DUP3 1ABC 86 DUP7 1ABD 01 ADD 1ABE 61 PUSH2 0x1a3b 1AC1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AB7 stack[0] = 0x1ac2 // @1ABA stack[1] = stack[-5] // @1ABD stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1a3b, returns to 0x1AC2 label_1AC2: // Incoming return from call to 0x1A3B at 0x1AC1 // Inputs[7] // { // @1AC3 stack[-4] // @1AC3 stack[-1] // @1AC5 stack[-2] // @1AC5 stack[-5] // @1AC8 stack[-7] // @1ACA stack[-8] // @1ACB stack[-6] // } 1AC2 5B JUMPDEST 1AC3 92 SWAP3 1AC4 50 POP 1AC5 92 SWAP3 1AC6 50 POP 1AC7 50 POP 1AC8 92 SWAP3 1AC9 50 POP 1ACA 92 SWAP3 1ACB 90 SWAP1 1ACC 50 POP 1ACD 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1AC8 stack[-7] = stack[-1] // @1ACA stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-8] label_1ACE: // Incoming jump from 0x0392 // Incoming jump from 0x044B // Inputs[2] // { // @1AD6 stack[-1] // @1AD7 stack[-2] // } 1ACE 5B JUMPDEST 1ACF 60 PUSH1 0x00 1AD1 80 DUP1 1AD2 60 PUSH1 0x00 1AD4 60 PUSH1 0x60 1AD6 84 DUP5 1AD7 86 DUP7 1AD8 03 SUB 1AD9 12 SLT 1ADA 15 ISZERO 1ADB 61 PUSH2 0x1ae6 1ADE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1ACF stack[0] = 0x00 // @1AD1 stack[1] = 0x00 // @1AD2 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ae6, if !(stack[-2] - stack[-1] i< 0x60) label_1ADF: // Incoming jump from 0x1ADE, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1AE5 memory[0x00:0x00] } 1ADF 61 PUSH2 0x1ae6 1AE2 60 PUSH1 0x00 1AE4 80 DUP1 1AE5 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1ADF stack[0] = 0x1ae6 // @1AE5 revert(memory[0x00:0x00]); // } // Block terminates label_1AE6: // Incoming jump from 0x1ADE, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1AEC stack[-5] // @1AED stack[-4] // } 1AE6 5B JUMPDEST 1AE7 60 PUSH1 0x00 1AE9 61 PUSH2 0x1af2 1AEC 86 DUP7 1AED 86 DUP7 1AEE 61 PUSH2 0x19be 1AF1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AE7 stack[0] = 0x00 // @1AE9 stack[1] = 0x1af2 // @1AEC stack[2] = stack[-5] // @1AED stack[3] = stack[-4] // } // Block ends with unconditional jump to 0x19be 1AF2 5B JUMPDEST 1AF3 93 SWAP4 1AF4 50 POP 1AF5 50 POP 1AF6 60 PUSH1 0x20 1AF8 61 PUSH2 0x1b03 1AFB 86 DUP7 1AFC 82 DUP3 1AFD 87 DUP8 1AFE 01 ADD 1AFF 61 PUSH2 0x19be 1B02 56 *JUMP 1B03 5B JUMPDEST 1B04 92 SWAP3 1B05 50 POP 1B06 50 POP 1B07 60 PUSH1 0x40 1B09 61 PUSH2 0x1b14 1B0C 86 DUP7 1B0D 82 DUP3 1B0E 87 DUP8 1B0F 01 ADD 1B10 61 PUSH2 0x1961 1B13 56 *JUMP 1B14 5B JUMPDEST 1B15 91 SWAP2 1B16 50 POP 1B17 50 POP 1B18 92 SWAP3 1B19 50 POP 1B1A 92 SWAP3 1B1B 50 POP 1B1C 92 SWAP3 1B1D 56 *JUMP label_1B1E: // Incoming jump from 0x03B2 // Inputs[2] // { // @1B24 stack[-1] // @1B25 stack[-2] // } 1B1E 5B JUMPDEST 1B1F 60 PUSH1 0x00 1B21 80 DUP1 1B22 60 PUSH1 0x40 1B24 83 DUP4 1B25 85 DUP6 1B26 03 SUB 1B27 12 SLT 1B28 15 ISZERO 1B29 61 PUSH2 0x1b34 1B2C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B1F stack[0] = 0x00 // @1B21 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b34, if !(stack[-2] - stack[-1] i< 0x40) label_1B2D: // Incoming jump from 0x1B2C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1B33 memory[0x00:0x00] } 1B2D 61 PUSH2 0x1b34 1B30 60 PUSH1 0x00 1B32 80 DUP1 1B33 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1B2D stack[0] = 0x1b34 // @1B33 revert(memory[0x00:0x00]); // } // Block terminates label_1B34: // Incoming jump from 0x1B2C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B3A stack[-4] // @1B3B stack[-3] // } 1B34 5B JUMPDEST 1B35 60 PUSH1 0x00 1B37 61 PUSH2 0x19eb 1B3A 85 DUP6 1B3B 85 DUP6 1B3C 61 PUSH2 0x1961 1B3F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B35 stack[0] = 0x00 // @1B37 stack[1] = 0x19eb // @1B3A stack[2] = stack[-4] // @1B3B stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x1961 1B40 5B JUMPDEST 1B41 60 PUSH1 0x40 1B43 81 DUP2 1B44 01 ADD 1B45 61 PUSH2 0x1b4e 1B48 82 DUP3 1B49 85 DUP6 1B4A 61 PUSH2 0x199e 1B4D 56 *JUMP 1B4E 5B JUMPDEST 1B4F 61 PUSH2 0x0e4d 1B52 60 PUSH1 0x20 1B54 83 DUP4 1B55 01 ADD 1B56 84 DUP5 1B57 61 PUSH2 0x1a27 1B5A 56 *JUMP label_1B5B: // Incoming jump from 0x1BD3 // Incoming jump from 0x1B96 // Inputs[1] { @1B70 memory[0x00:0x24] } 1B5B 5B JUMPDEST 1B5C 63 PUSH4 0x4e487b71 1B61 60 PUSH1 0xe0 1B63 1B SHL 1B64 60 PUSH1 0x00 1B66 52 MSTORE 1B67 60 PUSH1 0x41 1B69 60 PUSH1 0x04 1B6B 52 MSTORE 1B6C 60 PUSH1 0x24 1B6E 60 PUSH1 0x00 1B70 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1B66 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1B6B memory[0x04:0x24] = 0x41 // @1B70 revert(memory[0x00:0x24]); // } // Block terminates label_1B71: // Incoming call from 0x1BB4, returns to 0x1BB5 // Inputs[2] // { // @1B77 stack[-2] // @1B7A stack[-1] // } 1B71 5B JUMPDEST 1B72 60 PUSH1 0x1f 1B74 19 NOT 1B75 60 PUSH1 0x1f 1B77 83 DUP4 1B78 01 ADD 1B79 16 AND 1B7A 81 DUP2 1B7B 01 ADD 1B7C 81 DUP2 1B7D 81 DUP2 1B7E 10 LT 1B7F 67 PUSH8 0xffffffffffffffff 1B88 82 DUP3 1B89 11 GT 1B8A 17 OR 1B8B 15 ISZERO 1B8C 61 PUSH2 0x1b97 1B8F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B7B stack[0] = stack[-1] + (stack[-2] + 0x1f & ~0x1f) } // Block ends with conditional jump to 0x1b97, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) label_1B90: // Incoming jump from 0x1B8F, if not !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) 1B90 61 PUSH2 0x1b97 1B93 61 PUSH2 0x1b5b 1B96 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B90 stack[0] = 0x1b97 } // Block ends with unconditional jump to 0x1b5b label_1B97: // Incoming jump from 0x1B8F, if !((stack[-1] + (stack[-2] + 0x1f & ~0x1f) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & ~0x1f) < stack[-1])) // Inputs[2] // { // @1B9A stack[-1] // @1B9D stack[-4] // } 1B97 5B JUMPDEST 1B98 60 PUSH1 0x40 1B9A 52 MSTORE 1B9B 50 POP 1B9C 50 POP 1B9D 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B9A memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1B9E: // Incoming jump from 0x1C03 // Inputs[1] { @1BA6 memory[0x40:0x60] } 1B9E 5B JUMPDEST 1B9F 60 PUSH1 0x00 1BA1 61 PUSH2 0x1ba9 1BA4 60 PUSH1 0x40 1BA6 51 MLOAD 1BA7 90 SWAP1 1BA8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B9F stack[0] = 0x00 // @1BA7 stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1ba9 label_1BA9: // Incoming jump from 0x1BA8 // Inputs[3] // { // @1BAA stack[-2] // @1BAA stack[-1] // @1BAF stack[-3] // } 1BA9 5B JUMPDEST 1BAA 90 SWAP1 1BAB 50 POP 1BAC 61 PUSH2 0x1bb5 1BAF 82 DUP3 1BB0 82 DUP3 1BB1 61 PUSH2 0x1b71 1BB4 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1BAA stack[-2] = stack[-1] // @1BAC stack[-1] = 0x1bb5 // @1BAF stack[0] = stack[-3] // @1BB0 stack[1] = stack[-1] // } // Block ends with call to 0x1b71, returns to 0x1BB5 label_1BB5: // Incoming return from call to 0x1B71 at 0x1BB4 // Inputs[3] // { // @1BB6 stack[-1] // @1BB6 stack[-3] // @1BB7 stack[-2] // } 1BB5 5B JUMPDEST 1BB6 91 SWAP2 1BB7 90 SWAP1 1BB8 50 POP 1BB9 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BB6 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1BBA: // Incoming call from 0x1BFE, returns to 0x1BFF // Inputs[1] { @1BC6 stack[-1] } 1BBA 5B JUMPDEST 1BBB 60 PUSH1 0x00 1BBD 67 PUSH8 0xffffffffffffffff 1BC6 82 DUP3 1BC7 11 GT 1BC8 15 ISZERO 1BC9 61 PUSH2 0x1bd4 1BCC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BBB stack[0] = 0x00 } // Block ends with conditional jump to 0x1bd4, if !(stack[-1] > 0xffffffffffffffff) label_1BCD: // Incoming jump from 0x1BCC, if not !(stack[-1] > 0xffffffffffffffff) 1BCD 61 PUSH2 0x1bd4 1BD0 61 PUSH2 0x1b5b 1BD3 56 *JUMP // Stack delta = +1 // Outputs[1] { @1BCD stack[0] = 0x1bd4 } // Block ends with unconditional jump to 0x1b5b label_1BD4: // Incoming jump from 0x1BCC, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1BDA stack[-2] // @1BE0 stack[-3] // } 1BD4 5B JUMPDEST 1BD5 60 PUSH1 0x1f 1BD7 19 NOT 1BD8 60 PUSH1 0x1f 1BDA 83 DUP4 1BDB 01 ADD 1BDC 16 AND 1BDD 60 PUSH1 0x20 1BDF 01 ADD 1BE0 92 SWAP3 1BE1 91 SWAP2 1BE2 50 POP 1BE3 50 POP 1BE4 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BE0 stack[-3] = 0x20 + (stack[-2] + 0x1f & ~0x1f) } // Block ends with unconditional jump to stack[-3] label_1BE5: // Incoming call from 0x1C29, returns to 0x169A // Inputs[5] // { // @1BE6 stack[-3] // @1BE7 stack[-1] // @1BE8 stack[-2] // @1BE9 msg.data[stack[-1]:stack[-1] + stack[-3]] // @1BF0 stack[-4] // } 1BE5 5B JUMPDEST 1BE6 82 DUP3 1BE7 81 DUP2 1BE8 83 DUP4 1BE9 37 CALLDATACOPY 1BEA 50 POP 1BEB 60 PUSH1 0x00 1BED 91 SWAP2 1BEE 01 ADD 1BEF 52 MSTORE 1BF0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1BE9 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @1BEF memory[stack[-3] + stack[-2]:stack[-3] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_1BF1: // Incoming call from 0x1C4D, returns to 0x103F // Inputs[1] { @1BFA stack[-2] } 1BF1 5B JUMPDEST 1BF2 60 PUSH1 0x00 1BF4 61 PUSH2 0x1c04 1BF7 61 PUSH2 0x1bff 1BFA 84 DUP5 1BFB 61 PUSH2 0x1bba 1BFE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BF2 stack[0] = 0x00 // @1BF4 stack[1] = 0x1c04 // @1BF7 stack[2] = 0x1bff // @1BFA stack[3] = stack[-2] // } // Block ends with call to 0x1bba, returns to 0x1BFF label_1BFF: // Incoming return from call to 0x1BBA at 0x1BFE 1BFF 5B JUMPDEST 1C00 61 PUSH2 0x1b9e 1C03 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b9e label_1C04: // Incoming return from call to 0x1BFF at 0x1BFE // Inputs[5] // { // @1C05 stack[-2] // @1C05 stack[-1] // @1C07 stack[-4] // @1C0E stack[-5] // @1C10 stack[-3] // } 1C04 5B JUMPDEST 1C05 90 SWAP1 1C06 50 POP 1C07 82 DUP3 1C08 81 DUP2 1C09 52 MSTORE 1C0A 60 PUSH1 0x20 1C0C 81 DUP2 1C0D 01 ADD 1C0E 84 DUP5 1C0F 84 DUP5 1C10 84 DUP5 1C11 01 ADD 1C12 11 GT 1C13 15 ISZERO 1C14 61 PUSH2 0x1c1f 1C17 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1C05 stack[-2] = stack[-1] // @1C09 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1C0D stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1c1f, if !(stack[-3] + stack[-4] > stack[-5]) label_1C18: // Incoming jump from 0x1C17, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @1C1E memory[0x00:0x00] } 1C18 61 PUSH2 0x1c1f 1C1B 60 PUSH1 0x00 1C1D 80 DUP1 1C1E FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C18 stack[0] = 0x1c1f // @1C1E revert(memory[0x00:0x00]); // } // Block terminates label_1C1F: // Incoming jump from 0x1C17, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @1C23 stack[-4] // @1C24 stack[-1] // @1C25 stack[-3] // } 1C1F 5B JUMPDEST 1C20 61 PUSH2 0x169a 1C23 84 DUP5 1C24 82 DUP3 1C25 85 DUP6 1C26 61 PUSH2 0x1be5 1C29 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C20 stack[0] = 0x169a // @1C23 stack[1] = stack[-4] // @1C24 stack[2] = stack[-1] // @1C25 stack[3] = stack[-3] // } // Block ends with call to 0x1be5, returns to 0x169A label_1C2A: // Incoming call from 0x1C88, returns to 0x103F // Inputs[2] // { // @1C2D stack[-2] // @1C30 stack[-1] // } 1C2A 5B JUMPDEST 1C2B 60 PUSH1 0x00 1C2D 82 DUP3 1C2E 60 PUSH1 0x1f 1C30 83 DUP4 1C31 01 ADD 1C32 12 SLT 1C33 61 PUSH2 0x1c3e 1C36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C2B stack[0] = 0x00 } // Block ends with conditional jump to 0x1c3e, if stack[-1] + 0x1f i< stack[-2] label_1C37: // Incoming jump from 0x1C36, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1C3D memory[0x00:0x00] } 1C37 61 PUSH2 0x1c3e 1C3A 60 PUSH1 0x00 1C3C 80 DUP1 1C3D FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C37 stack[0] = 0x1c3e // @1C3D revert(memory[0x00:0x00]); // } // Block terminates label_1C3E: // Incoming jump from 0x1C36, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1C3F stack[-2] // @1C40 msg.data[stack[-2]:stack[-2] + 0x20] // @1C44 stack[-3] // } 1C3E 5B JUMPDEST 1C3F 81 DUP2 1C40 35 CALLDATALOAD 1C41 61 PUSH2 0x103f 1C44 84 DUP5 1C45 82 DUP3 1C46 60 PUSH1 0x20 1C48 86 DUP7 1C49 01 ADD 1C4A 61 PUSH2 0x1bf1 1C4D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C40 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C41 stack[1] = 0x103f // @1C44 stack[2] = stack[-3] // @1C45 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C49 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x1bf1, returns to 0x103F label_1C4E: // Incoming jump from 0x0566 // Incoming jump from 0x048B // Inputs[2] // { // @1C53 stack[-1] // @1C54 stack[-2] // } 1C4E 5B JUMPDEST 1C4F 60 PUSH1 0x00 1C51 60 PUSH1 0x20 1C53 82 DUP3 1C54 84 DUP5 1C55 03 SUB 1C56 12 SLT 1C57 15 ISZERO 1C58 61 PUSH2 0x1c63 1C5B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C4F stack[0] = 0x00 } // Block ends with conditional jump to 0x1c63, if !(stack[-2] - stack[-1] i< 0x20) label_1C5C: // Incoming jump from 0x1C5B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1C62 memory[0x00:0x00] } 1C5C 61 PUSH2 0x1c63 1C5F 60 PUSH1 0x00 1C61 80 DUP1 1C62 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C5C stack[0] = 0x1c63 // @1C62 revert(memory[0x00:0x00]); // } // Block terminates label_1C63: // Incoming jump from 0x1C5B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1C64 stack[-2] // @1C65 msg.data[stack[-2]:stack[-2] + 0x20] // } 1C63 5B JUMPDEST 1C64 81 DUP2 1C65 35 CALLDATALOAD 1C66 67 PUSH8 0xffffffffffffffff 1C6F 81 DUP2 1C70 11 GT 1C71 15 ISZERO 1C72 61 PUSH2 0x1c7d 1C75 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C65 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1c7d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1C76: // Incoming jump from 0x1C75, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1C7C memory[0x00:0x00] } 1C76 61 PUSH2 0x1c7d 1C79 60 PUSH1 0x00 1C7B 80 DUP1 1C7C FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C76 stack[0] = 0x1c7d // @1C7C revert(memory[0x00:0x00]); // } // Block terminates label_1C7D: // Incoming jump from 0x1C75, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C81 stack[-4] // @1C82 stack[-1] // @1C83 stack[-3] // } 1C7D 5B JUMPDEST 1C7E 61 PUSH2 0x103f 1C81 84 DUP5 1C82 82 DUP3 1C83 85 DUP6 1C84 01 ADD 1C85 61 PUSH2 0x1c2a 1C88 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C7E stack[0] = 0x103f // @1C81 stack[1] = stack[-4] // @1C84 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1c2a, returns to 0x103F 1C89 5B JUMPDEST 1C8A 60 PUSH1 0x00 1C8C 80 DUP1 1C8D 83 DUP4 1C8E 60 PUSH1 0x1f 1C90 84 DUP5 1C91 01 ADD 1C92 12 SLT 1C93 61 PUSH2 0x1c9e 1C96 57 *JUMPI 1C97 61 PUSH2 0x1c9e 1C9A 60 PUSH1 0x00 1C9C 80 DUP1 1C9D FD *REVERT 1C9E 5B JUMPDEST 1C9F 50 POP 1CA0 81 DUP2 1CA1 35 CALLDATALOAD 1CA2 67 PUSH8 0xffffffffffffffff 1CAB 81 DUP2 1CAC 11 GT 1CAD 15 ISZERO 1CAE 61 PUSH2 0x1cb9 1CB1 57 *JUMPI 1CB2 61 PUSH2 0x1cb9 1CB5 60 PUSH1 0x00 1CB7 80 DUP1 1CB8 FD *REVERT 1CB9 5B JUMPDEST 1CBA 60 PUSH1 0x20 1CBC 83 DUP4 1CBD 01 ADD 1CBE 91 SWAP2 1CBF 50 POP 1CC0 83 DUP4 1CC1 60 PUSH1 0x20 1CC3 82 DUP3 1CC4 02 MUL 1CC5 83 DUP4 1CC6 01 ADD 1CC7 11 GT 1CC8 15 ISZERO 1CC9 61 PUSH2 0x091a 1CCC 57 *JUMPI 1CCD 61 PUSH2 0x091a 1CD0 60 PUSH1 0x00 1CD2 80 DUP1 1CD3 FD *REVERT label_1CD4: // Incoming jump from 0x0528 // Inputs[2] // { // @1CDD stack[-1] // @1CDE stack[-2] // } 1CD4 5B JUMPDEST 1CD5 60 PUSH1 0x00 1CD7 80 DUP1 1CD8 60 PUSH1 0x00 1CDA 80 DUP1 1CDB 60 PUSH1 0x60 1CDD 85 DUP6 1CDE 87 DUP8 1CDF 03 SUB 1CE0 12 SLT 1CE1 15 ISZERO 1CE2 61 PUSH2 0x1ced 1CE5 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1CD5 stack[0] = 0x00 // @1CD7 stack[1] = 0x00 // @1CD8 stack[2] = 0x00 // @1CDA stack[3] = 0x00 // } // Block ends with conditional jump to 0x1ced, if !(stack[-2] - stack[-1] i< 0x60) label_1CE6: // Incoming jump from 0x1CE5, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1CEC memory[0x00:0x00] } 1CE6 61 PUSH2 0x1ced 1CE9 60 PUSH1 0x00 1CEB 80 DUP1 1CEC FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1CE6 stack[0] = 0x1ced // @1CEC revert(memory[0x00:0x00]); // } // Block terminates label_1CED: // Incoming jump from 0x1CE5, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1CF3 stack[-6] // @1CF4 stack[-5] // } 1CED 5B JUMPDEST 1CEE 60 PUSH1 0x00 1CF0 61 PUSH2 0x1cf9 1CF3 87 DUP8 1CF4 87 DUP8 1CF5 61 PUSH2 0x1961 1CF8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CEE stack[0] = 0x00 // @1CF0 stack[1] = 0x1cf9 // @1CF3 stack[2] = stack[-6] // @1CF4 stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1961 1CF9 5B JUMPDEST 1CFA 94 SWAP5 1CFB 50 POP 1CFC 50 POP 1CFD 60 PUSH1 0x20 1CFF 85 DUP6 1D00 01 ADD 1D01 35 CALLDATALOAD 1D02 67 PUSH8 0xffffffffffffffff 1D0B 81 DUP2 1D0C 11 GT 1D0D 15 ISZERO 1D0E 61 PUSH2 0x1d19 1D11 57 *JUMPI 1D12 61 PUSH2 0x1d19 1D15 60 PUSH1 0x00 1D17 80 DUP1 1D18 FD *REVERT 1D19 5B JUMPDEST 1D1A 61 PUSH2 0x1d25 1D1D 87 DUP8 1D1E 82 DUP3 1D1F 88 DUP9 1D20 01 ADD 1D21 61 PUSH2 0x1c89 1D24 56 *JUMP 1D25 5B JUMPDEST 1D26 93 SWAP4 1D27 50 POP 1D28 93 SWAP4 1D29 50 POP 1D2A 50 POP 1D2B 60 PUSH1 0x40 1D2D 61 PUSH2 0x1d38 1D30 87 DUP8 1D31 82 DUP3 1D32 88 DUP9 1D33 01 ADD 1D34 61 PUSH2 0x1961 1D37 56 *JUMP 1D38 5B JUMPDEST 1D39 91 SWAP2 1D3A 50 POP 1D3B 50 POP 1D3C 92 SWAP3 1D3D 95 SWAP6 1D3E 91 SWAP2 1D3F 94 SWAP5 1D40 50 POP 1D41 92 SWAP3 1D42 50 POP 1D43 56 *JUMP label_1D44: // Incoming call from 0x1D56, returns to 0x06C6 // Inputs[1] { @1D45 stack[-1] } 1D44 5B JUMPDEST 1D45 80 DUP1 1D46 15 ISZERO 1D47 15 ISZERO 1D48 61 PUSH2 0x189d 1D4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D47 stack[0] = !!stack[-1] } // Block ends with unconditional jump to 0x189d label_1D4C: // Incoming jump from 0x1DAA // Inputs[2] // { // @1D4D stack[-1] // @1D4E msg.data[stack[-1]:stack[-1] + 0x20] // } 1D4C 5B JUMPDEST 1D4D 80 DUP1 1D4E 35 CALLDATALOAD 1D4F 61 PUSH2 0x06c6 1D52 81 DUP2 1D53 61 PUSH2 0x1d44 1D56 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D4E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1D4F stack[1] = 0x06c6 // @1D52 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1d44, returns to 0x06C6 label_1D57: // Incoming jump from 0x05B1 // Inputs[2] // { // @1D5D stack[-1] // @1D5E stack[-2] // } 1D57 5B JUMPDEST 1D58 60 PUSH1 0x00 1D5A 80 DUP1 1D5B 60 PUSH1 0x40 1D5D 83 DUP4 1D5E 85 DUP6 1D5F 03 SUB 1D60 12 SLT 1D61 15 ISZERO 1D62 61 PUSH2 0x1d6d 1D65 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D58 stack[0] = 0x00 // @1D5A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d6d, if !(stack[-2] - stack[-1] i< 0x40) label_1D66: // Incoming jump from 0x1D65, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D6C memory[0x00:0x00] } 1D66 61 PUSH2 0x1d6d 1D69 60 PUSH1 0x00 1D6B 80 DUP1 1D6C FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1D66 stack[0] = 0x1d6d // @1D6C revert(memory[0x00:0x00]); // } // Block terminates label_1D6D: // Incoming jump from 0x1D65, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D73 stack[-4] // @1D74 stack[-3] // } 1D6D 5B JUMPDEST 1D6E 60 PUSH1 0x00 1D70 61 PUSH2 0x1d79 1D73 85 DUP6 1D74 85 DUP6 1D75 61 PUSH2 0x19be 1D78 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D6E stack[0] = 0x00 // @1D70 stack[1] = 0x1d79 // @1D73 stack[2] = stack[-4] // @1D74 stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x19be 1D79 5B JUMPDEST 1D7A 92 SWAP3 1D7B 50 POP 1D7C 50 POP 1D7D 60 PUSH1 0x20 1D7F 61 PUSH2 0x19fc 1D82 85 DUP6 1D83 82 DUP3 1D84 86 DUP7 1D85 01 ADD 1D86 61 PUSH2 0x1d4c 1D89 56 *JUMP label_1D8A: // Incoming jump from 0x05D1 // Inputs[2] // { // @1D8F stack[-1] // @1D90 stack[-2] // } 1D8A 5B JUMPDEST 1D8B 60 PUSH1 0x00 1D8D 60 PUSH1 0x20 1D8F 82 DUP3 1D90 84 DUP5 1D91 03 SUB 1D92 12 SLT 1D93 15 ISZERO 1D94 61 PUSH2 0x1d9f 1D97 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D8B stack[0] = 0x00 } // Block ends with conditional jump to 0x1d9f, if !(stack[-2] - stack[-1] i< 0x20) label_1D98: // Incoming jump from 0x1D97, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D9E memory[0x00:0x00] } 1D98 61 PUSH2 0x1d9f 1D9B 60 PUSH1 0x00 1D9D 80 DUP1 1D9E FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1D98 stack[0] = 0x1d9f // @1D9E revert(memory[0x00:0x00]); // } // Block terminates label_1D9F: // Incoming jump from 0x1D97, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DA5 stack[-3] // @1DA6 stack[-2] // } 1D9F 5B JUMPDEST 1DA0 60 PUSH1 0x00 1DA2 61 PUSH2 0x103f 1DA5 84 DUP5 1DA6 84 DUP5 1DA7 61 PUSH2 0x1d4c 1DAA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DA0 stack[0] = 0x00 // @1DA2 stack[1] = 0x103f // @1DA5 stack[2] = stack[-3] // @1DA6 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1d4c label_1DAB: // Incoming jump from 0x05F1 // Inputs[2] // { // @1DB4 stack[-1] // @1DB5 stack[-2] // } 1DAB 5B JUMPDEST 1DAC 60 PUSH1 0x00 1DAE 80 DUP1 1DAF 60 PUSH1 0x00 1DB1 80 DUP1 1DB2 60 PUSH1 0x80 1DB4 85 DUP6 1DB5 87 DUP8 1DB6 03 SUB 1DB7 12 SLT 1DB8 15 ISZERO 1DB9 61 PUSH2 0x1dc4 1DBC 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1DAC stack[0] = 0x00 // @1DAE stack[1] = 0x00 // @1DAF stack[2] = 0x00 // @1DB1 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1dc4, if !(stack[-2] - stack[-1] i< 0x80) label_1DBD: // Incoming jump from 0x1DBC, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1DC3 memory[0x00:0x00] } 1DBD 61 PUSH2 0x1dc4 1DC0 60 PUSH1 0x00 1DC2 80 DUP1 1DC3 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1DBD stack[0] = 0x1dc4 // @1DC3 revert(memory[0x00:0x00]); // } // Block terminates label_1DC4: // Incoming jump from 0x1DBC, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1DCA stack[-6] // @1DCB stack[-5] // } 1DC4 5B JUMPDEST 1DC5 60 PUSH1 0x00 1DC7 61 PUSH2 0x1dd0 1DCA 87 DUP8 1DCB 87 DUP8 1DCC 61 PUSH2 0x19be 1DCF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DC5 stack[0] = 0x00 // @1DC7 stack[1] = 0x1dd0 // @1DCA stack[2] = stack[-6] // @1DCB stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x19be 1DD0 5B JUMPDEST 1DD1 94 SWAP5 1DD2 50 POP 1DD3 50 POP 1DD4 60 PUSH1 0x20 1DD6 61 PUSH2 0x1de1 1DD9 87 DUP8 1DDA 82 DUP3 1DDB 88 DUP9 1DDC 01 ADD 1DDD 61 PUSH2 0x19be 1DE0 56 *JUMP 1DE1 5B JUMPDEST 1DE2 93 SWAP4 1DE3 50 POP 1DE4 50 POP 1DE5 60 PUSH1 0x40 1DE7 61 PUSH2 0x1df2 1DEA 87 DUP8 1DEB 82 DUP3 1DEC 88 DUP9 1DED 01 ADD 1DEE 61 PUSH2 0x1961 1DF1 56 *JUMP 1DF2 5B JUMPDEST 1DF3 92 SWAP3 1DF4 50 POP 1DF5 50 POP 1DF6 60 PUSH1 0x60 1DF8 85 DUP6 1DF9 01 ADD 1DFA 35 CALLDATALOAD 1DFB 67 PUSH8 0xffffffffffffffff 1E04 81 DUP2 1E05 11 GT 1E06 15 ISZERO 1E07 61 PUSH2 0x1e12 1E0A 57 *JUMPI 1E0B 61 PUSH2 0x1e12 1E0E 60 PUSH1 0x00 1E10 80 DUP1 1E11 FD *REVERT 1E12 5B JUMPDEST 1E13 61 PUSH2 0x1d38 1E16 87 DUP8 1E17 82 DUP3 1E18 88 DUP9 1E19 01 ADD 1E1A 61 PUSH2 0x1c2a 1E1D 56 *JUMP label_1E1E: // Incoming jump from 0x0646 // Inputs[2] // { // @1E24 stack[-1] // @1E25 stack[-2] // } 1E1E 5B JUMPDEST 1E1F 60 PUSH1 0x00 1E21 80 DUP1 1E22 60 PUSH1 0x40 1E24 83 DUP4 1E25 85 DUP6 1E26 03 SUB 1E27 12 SLT 1E28 15 ISZERO 1E29 61 PUSH2 0x1e34 1E2C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E1F stack[0] = 0x00 // @1E21 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e34, if !(stack[-2] - stack[-1] i< 0x40) label_1E2D: // Incoming jump from 0x1E2C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E33 memory[0x00:0x00] } 1E2D 61 PUSH2 0x1e34 1E30 60 PUSH1 0x00 1E32 80 DUP1 1E33 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1E2D stack[0] = 0x1e34 // @1E33 revert(memory[0x00:0x00]); // } // Block terminates label_1E34: // Incoming jump from 0x1E2C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E3A stack[-4] // @1E3B stack[-3] // } 1E34 5B JUMPDEST 1E35 60 PUSH1 0x00 1E37 61 PUSH2 0x1e40 1E3A 85 DUP6 1E3B 85 DUP6 1E3C 61 PUSH2 0x19be 1E3F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E35 stack[0] = 0x00 // @1E37 stack[1] = 0x1e40 // @1E3A stack[2] = stack[-4] // @1E3B stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x19be 1E40 5B JUMPDEST 1E41 92 SWAP3 1E42 50 POP 1E43 50 POP 1E44 60 PUSH1 0x20 1E46 61 PUSH2 0x19fc 1E49 85 DUP6 1E4A 82 DUP3 1E4B 86 DUP7 1E4C 01 ADD 1E4D 61 PUSH2 0x19be 1E50 56 *JUMP label_1E51: // Incoming jump from 0x1E8D // Inputs[1] { @1E66 memory[0x00:0x24] } 1E51 5B JUMPDEST 1E52 63 PUSH4 0x4e487b71 1E57 60 PUSH1 0xe0 1E59 1B SHL 1E5A 60 PUSH1 0x00 1E5C 52 MSTORE 1E5D 60 PUSH1 0x22 1E5F 60 PUSH1 0x04 1E61 52 MSTORE 1E62 60 PUSH1 0x24 1E64 60 PUSH1 0x00 1E66 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E5C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1E61 memory[0x04:0x24] = 0x22 // @1E66 revert(memory[0x00:0x24]); // } // Block terminates label_1E67: // Incoming call from 0x0706, returns to 0x0707 // Incoming call from 0x0AA4, returns to 0x0AA5 // Incoming call from 0x178F, returns to 0x1790 // Incoming call from 0x0AD0, returns to 0x0AD1 // Incoming call from 0x06DA, returns to 0x06DB // Incoming call from 0x0E62, returns to 0x06DB // Incoming call from 0x0EF6, returns to 0x0AA5 // Incoming call from 0x0D40, returns to 0x06DB // Inputs[1] { @1E6A stack[-1] } 1E67 5B JUMPDEST 1E68 60 PUSH1 0x02 1E6A 81 DUP2 1E6B 04 DIV 1E6C 60 PUSH1 0x01 1E6E 82 DUP3 1E6F 16 AND 1E70 80 DUP1 1E71 61 PUSH2 0x1e7b 1E74 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E6B stack[0] = stack[-1] / 0x02 // @1E6F stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1e7b, if stack[-1] & 0x01 label_1E75: // Incoming jump from 0x1E74, if not stack[-1] & 0x01 // Inputs[2] // { // @1E77 stack[-2] // @1E80 stack[-1] // } 1E75 60 PUSH1 0x7f 1E77 82 DUP3 1E78 16 AND 1E79 91 SWAP2 1E7A 50 POP 1E7B 5B JUMPDEST 1E7C 60 PUSH1 0x20 1E7E 82 DUP3 1E7F 10 LT 1E80 81 DUP2 1E81 14 EQ 1E82 15 ISZERO 1E83 61 PUSH2 0x1e8e 1E86 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E79 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1e8e, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1E87: // Incoming jump from 0x1E86, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1E86, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) 1E87 61 PUSH2 0x1e8e 1E8A 61 PUSH2 0x1e51 1E8D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E87 stack[0] = 0x1e8e } // Block ends with unconditional jump to 0x1e51 label_1E8E: // Incoming jump from 0x1E86, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1E86, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @1E90 stack[-4] // @1E90 stack[-2] // @1E91 stack[-3] // } 1E8E 5B JUMPDEST 1E8F 50 POP 1E90 91 SWAP2 1E91 90 SWAP1 1E92 50 POP 1E93 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E90 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] 1E94 5B JUMPDEST 1E95 60 PUSH1 0x2c 1E97 81 DUP2 1E98 52 MSTORE 1E99 60 PUSH1 0x00 1E9B 60 PUSH1 0x20 1E9D 82 DUP3 1E9E 01 ADD 1E9F 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 1EC0 81 DUP2 1EC1 52 MSTORE 1EC2 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 1ECF 60 PUSH1 0xa1 1ED1 1B SHL 1ED2 60 PUSH1 0x20 1ED4 82 DUP3 1ED5 01 ADD 1ED6 52 MSTORE 1ED7 91 SWAP2 1ED8 50 POP 1ED9 5B JUMPDEST 1EDA 50 POP 1EDB 60 PUSH1 0x40 1EDD 01 ADD 1EDE 90 SWAP1 1EDF 56 *JUMP 1EE0 5B JUMPDEST 1EE1 60 PUSH1 0x20 1EE3 80 DUP1 1EE4 82 DUP3 1EE5 52 MSTORE 1EE6 81 DUP2 1EE7 01 ADD 1EE8 61 PUSH2 0x06c6 1EEB 81 DUP2 1EEC 61 PUSH2 0x1e94 1EEF 56 *JUMP 1EF0 5B JUMPDEST 1EF1 60 PUSH1 0x21 1EF3 81 DUP2 1EF4 52 MSTORE 1EF5 60 PUSH1 0x00 1EF7 60 PUSH1 0x20 1EF9 82 DUP3 1EFA 01 ADD 1EFB 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 1F1C 81 DUP2 1F1D 52 MSTORE 1F1E 60 PUSH1 0x39 1F20 60 PUSH1 0xf9 1F22 1B SHL 1F23 60 PUSH1 0x20 1F25 82 DUP3 1F26 01 ADD 1F27 52 MSTORE 1F28 91 SWAP2 1F29 50 POP 1F2A 61 PUSH2 0x1ed9 1F2D 56 *JUMP 1F2E 5B JUMPDEST 1F2F 60 PUSH1 0x20 1F31 80 DUP1 1F32 82 DUP3 1F33 52 MSTORE 1F34 81 DUP2 1F35 01 ADD 1F36 61 PUSH2 0x06c6 1F39 81 DUP2 1F3A 61 PUSH2 0x1ef0 1F3D 56 *JUMP 1F3E 5B JUMPDEST 1F3F 60 PUSH1 0x38 1F41 81 DUP2 1F42 52 MSTORE 1F43 60 PUSH1 0x00 1F45 60 PUSH1 0x20 1F47 82 DUP3 1F48 01 ADD 1F49 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 1F6A 81 DUP2 1F6B 52 MSTORE 1F6C 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 1F8D 60 PUSH1 0x20 1F8F 82 DUP3 1F90 01 ADD 1F91 52 MSTORE 1F92 91 SWAP2 1F93 50 POP 1F94 61 PUSH2 0x1ed9 1F97 56 *JUMP 1F98 5B JUMPDEST 1F99 60 PUSH1 0x20 1F9B 80 DUP1 1F9C 82 DUP3 1F9D 52 MSTORE 1F9E 81 DUP2 1F9F 01 ADD 1FA0 61 PUSH2 0x06c6 1FA3 81 DUP2 1FA4 61 PUSH2 0x1f3e 1FA7 56 *JUMP label_1FA8: // Incoming call from 0x1FEC, returns to 0x06C6 // Inputs[2] // { // @1FAC stack[-1] // @1FDB stack[-2] // } 1FA8 5B JUMPDEST 1FA9 60 PUSH1 0x20 1FAB 80 DUP1 1FAC 82 DUP3 1FAD 52 MSTORE 1FAE 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1FCF 91 SWAP2 1FD0 01 ADD 1FD1 90 SWAP1 1FD2 81 DUP2 1FD3 52 MSTORE 1FD4 60 PUSH1 0x00 1FD6 5B JUMPDEST 1FD7 50 POP 1FD8 60 PUSH1 0x20 1FDA 01 ADD 1FDB 90 SWAP1 1FDC 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1FAD memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1FD3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1FDB stack[-2] = 0x20 + stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-2] label_1FDD: // Incoming jump from 0x0996 // Incoming jump from 0x0B93 // Incoming jump from 0x0866 // Inputs[1] { @1FE1 stack[-1] } 1FDD 5B JUMPDEST 1FDE 60 PUSH1 0x20 1FE0 80 DUP1 1FE1 82 DUP3 1FE2 52 MSTORE 1FE3 81 DUP2 1FE4 01 ADD 1FE5 61 PUSH2 0x06c6 1FE8 81 DUP2 1FE9 61 PUSH2 0x1fa8 1FEC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1FE2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1FE4 stack[0] = stack[-1] + 0x20 // @1FE5 stack[1] = 0x06c6 // @1FE8 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1fa8, returns to 0x06C6 1FED 5B JUMPDEST 1FEE 60 PUSH1 0x31 1FF0 81 DUP2 1FF1 52 MSTORE 1FF2 60 PUSH1 0x00 1FF4 60 PUSH1 0x20 1FF6 82 DUP3 1FF7 01 ADD 1FF8 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2019 81 DUP2 201A 52 MSTORE 201B 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 202D 60 PUSH1 0x7a 202F 1B SHL 2030 60 PUSH1 0x20 2032 82 DUP3 2033 01 ADD 2034 52 MSTORE 2035 91 SWAP2 2036 50 POP 2037 61 PUSH2 0x1ed9 203A 56 *JUMP 203B 5B JUMPDEST 203C 60 PUSH1 0x20 203E 80 DUP1 203F 82 DUP3 2040 52 MSTORE 2041 81 DUP2 2042 01 ADD 2043 61 PUSH2 0x06c6 2046 81 DUP2 2047 61 PUSH2 0x1fed 204A 56 *JUMP 204B 5B JUMPDEST 204C 63 PUSH4 0x4e487b71 2051 60 PUSH1 0xe0 2053 1B SHL 2054 60 PUSH1 0x00 2056 52 MSTORE 2057 60 PUSH1 0x12 2059 60 PUSH1 0x04 205B 52 MSTORE 205C 60 PUSH1 0x24 205E 60 PUSH1 0x00 2060 FD *REVERT 2061 5B JUMPDEST 2062 63 PUSH4 0x4e487b71 2067 60 PUSH1 0xe0 2069 1B SHL 206A 60 PUSH1 0x00 206C 52 MSTORE 206D 60 PUSH1 0x11 206F 60 PUSH1 0x04 2071 52 MSTORE 2072 60 PUSH1 0x24 2074 60 PUSH1 0x00 2076 FD *REVERT 2077 5B JUMPDEST 2078 60 PUSH1 0x00 207A 82 DUP3 207B 61 PUSH2 0x2086 207E 57 *JUMPI 207F 61 PUSH2 0x2086 2082 61 PUSH2 0x204b 2085 56 *JUMP 2086 5B JUMPDEST 2087 50 POP 2088 04 DIV 2089 90 SWAP1 208A 56 *JUMP 208B 5B JUMPDEST 208C 60 PUSH1 0x00 208E 81 DUP2 208F 60 PUSH1 0x00 2091 19 NOT 2092 04 DIV 2093 83 DUP4 2094 11 GT 2095 82 DUP3 2096 15 ISZERO 2097 15 ISZERO 2098 16 AND 2099 15 ISZERO 209A 61 PUSH2 0x20a5 209D 57 *JUMPI 209E 61 PUSH2 0x20a5 20A1 61 PUSH2 0x2061 20A4 56 *JUMP 20A5 5B JUMPDEST 20A6 50 POP 20A7 02 MUL 20A8 90 SWAP1 20A9 56 *JUMP 20AA 5B JUMPDEST 20AB 60 PUSH1 0x29 20AD 81 DUP2 20AE 52 MSTORE 20AF 60 PUSH1 0x00 20B1 60 PUSH1 0x20 20B3 82 DUP3 20B4 01 ADD 20B5 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 20D6 81 DUP2 20D7 52 MSTORE 20D8 68 PUSH9 0x32b73a103a37b5b2b7 20E2 60 PUSH1 0xb9 20E4 1B SHL 20E5 60 PUSH1 0x20 20E7 82 DUP3 20E8 01 ADD 20E9 52 MSTORE 20EA 91 SWAP2 20EB 50 POP 20EC 61 PUSH2 0x1ed9 20EF 56 *JUMP 20F0 5B JUMPDEST 20F1 60 PUSH1 0x20 20F3 80 DUP1 20F4 82 DUP3 20F5 52 MSTORE 20F6 81 DUP2 20F7 01 ADD 20F8 61 PUSH2 0x06c6 20FB 81 DUP2 20FC 61 PUSH2 0x20aa 20FF 56 *JUMP 2100 5B JUMPDEST 2101 60 PUSH1 0x2a 2103 81 DUP2 2104 52 MSTORE 2105 60 PUSH1 0x00 2107 60 PUSH1 0x20 2109 82 DUP3 210A 01 ADD 210B 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 212C 81 DUP2 212D 52 MSTORE 212E 69 PUSH10 0x726f2061646472657373 2139 60 PUSH1 0xb0 213B 1B SHL 213C 60 PUSH1 0x20 213E 82 DUP3 213F 01 ADD 2140 52 MSTORE 2141 91 SWAP2 2142 50 POP 2143 61 PUSH2 0x1ed9 2146 56 *JUMP 2147 5B JUMPDEST 2148 60 PUSH1 0x20 214A 80 DUP1 214B 82 DUP3 214C 52 MSTORE 214D 81 DUP2 214E 01 ADD 214F 61 PUSH2 0x06c6 2152 81 DUP2 2153 61 PUSH2 0x2100 2156 56 *JUMP 2157 5B JUMPDEST 2158 60 PUSH1 0x1f 215A 81 DUP2 215B 52 MSTORE 215C 60 PUSH1 0x00 215E 60 PUSH1 0x20 2160 82 DUP3 2161 01 ADD 2162 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 2183 81 DUP2 2184 52 MSTORE 2185 91 SWAP2 2186 50 POP 2187 61 PUSH2 0x1fd6 218A 56 *JUMP 218B 5B JUMPDEST 218C 60 PUSH1 0x20 218E 80 DUP1 218F 82 DUP3 2190 52 MSTORE 2191 81 DUP2 2192 01 ADD 2193 61 PUSH2 0x06c6 2196 81 DUP2 2197 61 PUSH2 0x2157 219A 56 *JUMP 219B 5B JUMPDEST 219C 60 PUSH1 0x0e 219E 81 DUP2 219F 52 MSTORE 21A0 60 PUSH1 0x00 21A2 60 PUSH1 0x20 21A4 82 DUP3 21A5 01 ADD 21A6 6D PUSH14 0x14d85b19481a5cc818db1bdcd959 21B5 60 PUSH1 0x92 21B7 1B SHL 21B8 81 DUP2 21B9 52 MSTORE 21BA 91 SWAP2 21BB 50 POP 21BC 61 PUSH2 0x1fd6 21BF 56 *JUMP 21C0 5B JUMPDEST 21C1 60 PUSH1 0x20 21C3 80 DUP1 21C4 82 DUP3 21C5 52 MSTORE 21C6 81 DUP2 21C7 01 ADD 21C8 61 PUSH2 0x06c6 21CB 81 DUP2 21CC 61 PUSH2 0x219b 21CF 56 *JUMP 21D0 5B JUMPDEST 21D1 60 PUSH1 0x00 21D3 82 DUP3 21D4 82 DUP3 21D5 10 LT 21D6 15 ISZERO 21D7 61 PUSH2 0x21e2 21DA 57 *JUMPI 21DB 61 PUSH2 0x21e2 21DE 61 PUSH2 0x2061 21E1 56 *JUMP 21E2 5B JUMPDEST 21E3 50 POP 21E4 03 SUB 21E5 90 SWAP1 21E6 56 *JUMP 21E7 5B JUMPDEST 21E8 60 PUSH1 0x17 21EA 81 DUP2 21EB 52 MSTORE 21EC 60 PUSH1 0x00 21EE 60 PUSH1 0x20 21F0 82 DUP3 21F1 01 ADD 21F2 7F PUSH32 0x496e73756666696369656e74206d696e7473206c656674000000000000000000 2213 81 DUP2 2214 52 MSTORE 2215 91 SWAP2 2216 50 POP 2217 61 PUSH2 0x1fd6 221A 56 *JUMP 221B 5B JUMPDEST 221C 60 PUSH1 0x20 221E 80 DUP1 221F 82 DUP3 2220 52 MSTORE 2221 81 DUP2 2222 01 ADD 2223 61 PUSH2 0x06c6 2226 81 DUP2 2227 61 PUSH2 0x21e7 222A 56 *JUMP 222B 5B JUMPDEST 222C 60 PUSH1 0x0d 222E 81 DUP2 222F 52 MSTORE 2230 60 PUSH1 0x00 2232 60 PUSH1 0x20 2234 82 DUP3 2235 01 ADD 2236 6C PUSH13 0x24b73b30b634b210383937b7b3 2244 60 PUSH1 0x99 2246 1B SHL 2247 81 DUP2 2248 52 MSTORE 2249 91 SWAP2 224A 50 POP 224B 61 PUSH2 0x1fd6 224E 56 *JUMP 224F 5B JUMPDEST 2250 60 PUSH1 0x20 2252 80 DUP1 2253 82 DUP3 2254 52 MSTORE 2255 81 DUP2 2256 01 ADD 2257 61 PUSH2 0x06c6 225A 81 DUP2 225B 61 PUSH2 0x222b 225E 56 *JUMP 225F 5B JUMPDEST 2260 60 PUSH1 0x18 2262 81 DUP2 2263 52 MSTORE 2264 60 PUSH1 0x00 2266 60 PUSH1 0x20 2268 82 DUP3 2269 01 ADD 226A 7F PUSH32 0x496e636f72726563742070617961626c6520616d6f756e740000000000000000 228B 81 DUP2 228C 52 MSTORE 228D 91 SWAP2 228E 50 POP 228F 61 PUSH2 0x1fd6 2292 56 *JUMP 2293 5B JUMPDEST 2294 60 PUSH1 0x20 2296 80 DUP1 2297 82 DUP3 2298 52 MSTORE 2299 81 DUP2 229A 01 ADD 229B 61 PUSH2 0x06c6 229E 81 DUP2 229F 61 PUSH2 0x225f 22A2 56 *JUMP 22A3 5B JUMPDEST 22A4 60 PUSH1 0x00 22A6 82 DUP3 22A7 19 NOT 22A8 82 DUP3 22A9 11 GT 22AA 15 ISZERO 22AB 61 PUSH2 0x22b6 22AE 57 *JUMPI 22AF 61 PUSH2 0x22b6 22B2 61 PUSH2 0x2061 22B5 56 *JUMP 22B6 5B JUMPDEST 22B7 50 POP 22B8 01 ADD 22B9 90 SWAP1 22BA 56 *JUMP 22BB 5B JUMPDEST 22BC 60 PUSH1 0x2f 22BE 81 DUP2 22BF 52 MSTORE 22C0 60 PUSH1 0x00 22C2 60 PUSH1 0x20 22C4 82 DUP3 22C5 01 ADD 22C6 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 22E7 81 DUP2 22E8 52 MSTORE 22E9 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 22F9 60 PUSH1 0x89 22FB 1B SHL 22FC 60 PUSH1 0x20 22FE 82 DUP3 22FF 01 ADD 2300 52 MSTORE 2301 91 SWAP2 2302 50 POP 2303 61 PUSH2 0x1ed9 2306 56 *JUMP 2307 5B JUMPDEST 2308 60 PUSH1 0x20 230A 80 DUP1 230B 82 DUP3 230C 52 MSTORE 230D 81 DUP2 230E 01 ADD 230F 61 PUSH2 0x06c6 2312 81 DUP2 2313 61 PUSH2 0x22bb 2316 56 *JUMP 2317 5B JUMPDEST 2318 60 PUSH1 0x00 231A 61 PUSH2 0x2321 231D 82 DUP3 231E 51 MLOAD 231F 90 SWAP1 2320 56 *JUMP 2321 5B JUMPDEST 2322 61 PUSH2 0x232f 2325 81 DUP2 2326 85 DUP6 2327 60 PUSH1 0x20 2329 86 DUP7 232A 01 ADD 232B 61 PUSH2 0x18ec 232E 56 *JUMP 232F 5B JUMPDEST 2330 92 SWAP3 2331 90 SWAP1 2332 92 SWAP3 2333 01 ADD 2334 92 SWAP3 2335 91 SWAP2 2336 50 POP 2337 50 POP 2338 56 *JUMP 2339 5B JUMPDEST 233A 60 PUSH1 0x00 233C 61 PUSH2 0x2345 233F 82 DUP3 2340 85 DUP6 2341 61 PUSH2 0x2317 2344 56 *JUMP 2345 5B JUMPDEST 2346 91 SWAP2 2347 50 POP 2348 61 PUSH2 0x103f 234B 82 DUP3 234C 84 DUP5 234D 61 PUSH2 0x2317 2350 56 *JUMP 2351 5B JUMPDEST 2352 60 PUSH1 0x26 2354 81 DUP2 2355 52 MSTORE 2356 60 PUSH1 0x00 2358 60 PUSH1 0x20 235A 82 DUP3 235B 01 ADD 235C 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 237D 81 DUP2 237E 52 MSTORE 237F 65 PUSH6 0x646472657373 2386 60 PUSH1 0xd0 2388 1B SHL 2389 60 PUSH1 0x20 238B 82 DUP3 238C 01 ADD 238D 52 MSTORE 238E 91 SWAP2 238F 50 POP 2390 61 PUSH2 0x1ed9 2393 56 *JUMP 2394 5B JUMPDEST 2395 60 PUSH1 0x20 2397 80 DUP1 2398 82 DUP3 2399 52 MSTORE 239A 81 DUP2 239B 01 ADD 239C 61 PUSH2 0x06c6 239F 81 DUP2 23A0 61 PUSH2 0x2351 23A3 56 *JUMP 23A4 5B JUMPDEST 23A5 60 PUSH1 0x2c 23A7 81 DUP2 23A8 52 MSTORE 23A9 60 PUSH1 0x00 23AB 60 PUSH1 0x20 23AD 82 DUP3 23AE 01 ADD 23AF 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 23D0 81 DUP2 23D1 52 MSTORE 23D2 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 23DF 60 PUSH1 0xa1 23E1 1B SHL 23E2 60 PUSH1 0x20 23E4 82 DUP3 23E5 01 ADD 23E6 52 MSTORE 23E7 91 SWAP2 23E8 50 POP 23E9 61 PUSH2 0x1ed9 23EC 56 *JUMP 23ED 5B JUMPDEST 23EE 60 PUSH1 0x20 23F0 80 DUP1 23F1 82 DUP3 23F2 52 MSTORE 23F3 81 DUP2 23F4 01 ADD 23F5 61 PUSH2 0x06c6 23F8 81 DUP2 23F9 61 PUSH2 0x23a4 23FC 56 *JUMP 23FD 5B JUMPDEST 23FE 60 PUSH1 0x29 2400 81 DUP2 2401 52 MSTORE 2402 60 PUSH1 0x00 2404 60 PUSH1 0x20 2406 82 DUP3 2407 01 ADD 2408 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 2429 81 DUP2 242A 52 MSTORE 242B 68 PUSH9 0x39903737ba1037bbb7 2435 60 PUSH1 0xb9 2437 1B SHL 2438 60 PUSH1 0x20 243A 82 DUP3 243B 01 ADD 243C 52 MSTORE 243D 91 SWAP2 243E 50 POP 243F 61 PUSH2 0x1ed9 2442 56 *JUMP 2443 5B JUMPDEST 2444 60 PUSH1 0x20 2446 80 DUP1 2447 82 DUP3 2448 52 MSTORE 2449 81 DUP2 244A 01 ADD 244B 61 PUSH2 0x06c6 244E 81 DUP2 244F 61 PUSH2 0x23fd 2452 56 *JUMP 2453 5B JUMPDEST 2454 60 PUSH1 0x24 2456 81 DUP2 2457 52 MSTORE 2458 60 PUSH1 0x00 245A 60 PUSH1 0x20 245C 82 DUP3 245D 01 ADD 245E 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 247F 81 DUP2 2480 52 MSTORE 2481 63 PUSH4 0x72657373 2486 60 PUSH1 0xe0 2488 1B SHL 2489 60 PUSH1 0x20 248B 82 DUP3 248C 01 ADD 248D 52 MSTORE 248E 91 SWAP2 248F 50 POP 2490 61 PUSH2 0x1ed9 2493 56 *JUMP 2494 5B JUMPDEST 2495 60 PUSH1 0x20 2497 80 DUP1 2498 82 DUP3 2499 52 MSTORE 249A 81 DUP2 249B 01 ADD 249C 61 PUSH2 0x06c6 249F 81 DUP2 24A0 61 PUSH2 0x2453 24A3 56 *JUMP 24A4 5B JUMPDEST 24A5 60 PUSH1 0x1a 24A7 81 DUP2 24A8 52 MSTORE 24A9 60 PUSH1 0x00 24AB 60 PUSH1 0x20 24AD 82 DUP3 24AE 01 ADD 24AF 7F PUSH32 0x57696c6c20657863656564206d6178696d756d20737570706c79000000000000 24D0 81 DUP2 24D1 52 MSTORE 24D2 91 SWAP2 24D3 50 POP 24D4 61 PUSH2 0x1fd6 24D7 56 *JUMP 24D8 5B JUMPDEST 24D9 60 PUSH1 0x20 24DB 80 DUP1 24DC 82 DUP3 24DD 52 MSTORE 24DE 81 DUP2 24DF 01 ADD 24E0 61 PUSH2 0x06c6 24E3 81 DUP2 24E4 61 PUSH2 0x24a4 24E7 56 *JUMP 24E8 5B JUMPDEST 24E9 60 PUSH1 0x00 24EB 60 PUSH1 0x00 24ED 19 NOT 24EE 82 DUP3 24EF 14 EQ 24F0 15 ISZERO 24F1 61 PUSH2 0x24fc 24F4 57 *JUMPI 24F5 61 PUSH2 0x24fc 24F8 61 PUSH2 0x2061 24FB 56 *JUMP 24FC 5B JUMPDEST 24FD 50 POP 24FE 60 PUSH1 0x01 2500 01 ADD 2501 90 SWAP1 2502 56 *JUMP 2503 5B JUMPDEST 2504 60 PUSH1 0x00 2506 61 PUSH2 0x06c6 2509 82 DUP3 250A 60 PUSH1 0x60 250C 1B SHL 250D 90 SWAP1 250E 56 *JUMP 250F 5B JUMPDEST 2510 60 PUSH1 0x00 2512 61 PUSH2 0x06c6 2515 82 DUP3 2516 61 PUSH2 0x2503 2519 56 *JUMP 251A 5B JUMPDEST 251B 61 PUSH2 0x18d8 251E 61 PUSH2 0x2526 2521 82 DUP3 2522 61 PUSH2 0x198d 2525 56 *JUMP 2526 5B JUMPDEST 2527 61 PUSH2 0x250f 252A 56 *JUMP 252B 5B JUMPDEST 252C 60 PUSH1 0x00 252E 61 PUSH2 0x2537 2531 82 DUP3 2532 85 DUP6 2533 61 PUSH2 0x251a 2536 56 *JUMP 2537 5B JUMPDEST 2538 60 PUSH1 0x14 253A 82 DUP3 253B 01 ADD 253C 91 SWAP2 253D 50 POP 253E 61 PUSH2 0x103f 2541 82 DUP3 2542 84 DUP5 2543 61 PUSH2 0x2317 2546 56 *JUMP 2547 5B JUMPDEST 2548 60 PUSH1 0x19 254A 81 DUP2 254B 52 MSTORE 254C 60 PUSH1 0x00 254E 60 PUSH1 0x20 2550 82 DUP3 2551 01 ADD 2552 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 2573 81 DUP2 2574 52 MSTORE 2575 91 SWAP2 2576 50 POP 2577 61 PUSH2 0x1fd6 257A 56 *JUMP 257B 5B JUMPDEST 257C 60 PUSH1 0x20 257E 80 DUP1 257F 82 DUP3 2580 52 MSTORE 2581 81 DUP2 2582 01 ADD 2583 61 PUSH2 0x06c6 2586 81 DUP2 2587 61 PUSH2 0x2547 258A 56 *JUMP 258B 5B JUMPDEST 258C 60 PUSH1 0x32 258E 81 DUP2 258F 52 MSTORE 2590 60 PUSH1 0x00 2592 60 PUSH1 0x20 2594 82 DUP3 2595 01 ADD 2596 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 25B7 81 DUP2 25B8 52 MSTORE 25B9 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 25CC 60 PUSH1 0x71 25CE 1B SHL 25CF 60 PUSH1 0x20 25D1 82 DUP3 25D2 01 ADD 25D3 52 MSTORE 25D4 91 SWAP2 25D5 50 POP 25D6 61 PUSH2 0x1ed9 25D9 56 *JUMP 25DA 5B JUMPDEST 25DB 60 PUSH1 0x20 25DD 80 DUP1 25DE 82 DUP3 25DF 52 MSTORE 25E0 81 DUP2 25E1 01 ADD 25E2 61 PUSH2 0x06c6 25E5 81 DUP2 25E6 61 PUSH2 0x258b 25E9 56 *JUMP 25EA 5B JUMPDEST 25EB 60 PUSH1 0x00 25ED 82 DUP3 25EE 61 PUSH2 0x25f9 25F1 57 *JUMPI 25F2 61 PUSH2 0x25f9 25F5 61 PUSH2 0x204b 25F8 56 *JUMP 25F9 5B JUMPDEST 25FA 50 POP 25FB 06 MOD 25FC 90 SWAP1 25FD 56 *JUMP 25FE 5B JUMPDEST 25FF 63 PUSH4 0x4e487b71 2604 60 PUSH1 0xe0 2606 1B SHL 2607 60 PUSH1 0x00 2609 52 MSTORE 260A 60 PUSH1 0x32 260C 60 PUSH1 0x04 260E 52 MSTORE 260F 60 PUSH1 0x24 2611 60 PUSH1 0x00 2613 FD *REVERT 2614 5B JUMPDEST 2615 60 PUSH1 0x80 2617 81 DUP2 2618 01 ADD 2619 61 PUSH2 0x2622 261C 82 DUP3 261D 87 DUP8 261E 61 PUSH2 0x199e 2621 56 *JUMP 2622 5B JUMPDEST 2623 61 PUSH2 0x262f 2626 60 PUSH1 0x20 2628 83 DUP4 2629 01 ADD 262A 86 DUP7 262B 61 PUSH2 0x199e 262E 56 *JUMP 262F 5B JUMPDEST 2630 61 PUSH2 0x263c 2633 60 PUSH1 0x40 2635 83 DUP4 2636 01 ADD 2637 85 DUP6 2638 61 PUSH2 0x1a27 263B 56 *JUMP 263C 5B JUMPDEST 263D 81 DUP2 263E 81 DUP2 263F 03 SUB 2640 60 PUSH1 0x60 2642 83 DUP4 2643 01 ADD 2644 52 MSTORE 2645 61 PUSH2 0x129e 2648 81 DUP2 2649 84 DUP5 264A 61 PUSH2 0x1918 264D 56 *JUMP 264E 5B JUMPDEST 264F 80 DUP1 2650 51 MLOAD 2651 61 PUSH2 0x06c6 2654 81 DUP2 2655 61 PUSH2 0x1891 2658 56 *JUMP 2659 5B JUMPDEST 265A 60 PUSH1 0x00 265C 60 PUSH1 0x20 265E 82 DUP3 265F 84 DUP5 2660 03 SUB 2661 12 SLT 2662 15 ISZERO 2663 61 PUSH2 0x266e 2666 57 *JUMPI 2667 61 PUSH2 0x266e 266A 60 PUSH1 0x00 266C 80 DUP1 266D FD *REVERT 266E 5B JUMPDEST 266F 60 PUSH1 0x00 2671 61 PUSH2 0x103f 2674 84 DUP5 2675 84 DUP5 2676 61 PUSH2 0x264e 2679 56 *JUMP 267A 5B JUMPDEST 267B 60 PUSH1 0x00 267D 61 PUSH2 0x2686 2680 82 DUP3 2681 85 DUP6 2682 61 PUSH2 0x1a27 2685 56 *JUMP 2686 5B JUMPDEST 2687 60 PUSH1 0x20 2689 82 DUP3 268A 01 ADD 268B 91 SWAP2 268C 50 POP 268D 61 PUSH2 0x2696 2690 82 DUP3 2691 84 DUP5 2692 61 PUSH2 0x1a27 2695 56 *JUMP 2696 5B JUMPDEST 2697 50 POP 2698 60 PUSH1 0x20 269A 01 ADD 269B 92 SWAP3 269C 91 SWAP2 269D 50 POP 269E 50 POP 269F 56 *JUMP 26A0 5B JUMPDEST 26A1 60 PUSH1 0x20 26A3 80 DUP1 26A4 82 DUP3 26A5 52 MSTORE 26A6 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 26C7 91 SWAP2 26C8 01 ADD 26C9 90 SWAP1 26CA 81 DUP2 26CB 52 MSTORE 26CC 60 PUSH1 0x00 26CE 61 PUSH2 0x1fd6 26D1 56 *JUMP 26D2 5B JUMPDEST 26D3 60 PUSH1 0x20 26D5 80 DUP1 26D6 82 DUP3 26D7 52 MSTORE 26D8 81 DUP2 26D9 01 ADD 26DA 61 PUSH2 0x06c6 26DD 81 DUP2 26DE 61 PUSH2 0x26a0 26E1 56 *JUMP 26E2 5B JUMPDEST 26E3 60 PUSH1 0x1c 26E5 81 DUP2 26E6 52 MSTORE 26E7 60 PUSH1 0x00 26E9 60 PUSH1 0x20 26EB 82 DUP3 26EC 01 ADD 26ED 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 270E 81 DUP2 270F 52 MSTORE 2710 91 SWAP2 2711 50 POP 2712 61 PUSH2 0x1fd6 2715 56 *JUMP 2716 5B JUMPDEST 2717 60 PUSH1 0x20 2719 80 DUP1 271A 82 DUP3 271B 52 MSTORE 271C 81 DUP2 271D 01 ADD 271E 61 PUSH2 0x06c6 2721 81 DUP2 2722 61 PUSH2 0x26e2 2725 56 *JUMP 2726 FE *ASSERT 2727 A2 LOG2 2728 64 PUSH5 0x6970667358 272E 22 22 272F 12 SLT 2730 20 SHA3 2731 B5 B5 2732 D2 D2 2733 DA DA 2734 43 NUMBER 2735 EE EE 2736 38 CODESIZE 2737 34 CALLVALUE 2738 28 28 2739 9E SWAP15 273A 83 DUP4 273B 17 OR 273C 78 PUSH25 0xcf13e0246045f99cb6a053627744d65f7e520ccd64736f6c63 2756 43 NUMBER 2757 00 *STOP 2758 08 ADDMOD 2759 09 MULMOD 275A 00 *STOP 275B 33 CALLER