Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x02d6 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x02d6, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x70a08231 0026 11 GT 0027 61 PUSH2 0x0182 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0182, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb4b5b48f 0031 11 GT 0032 61 PUSH2 0x00e9 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e9, if 0xb4b5b48f > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb4b5b48f > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xdde2c6c8 003C 11 GT 003D 61 PUSH2 0x00a2 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a2, if 0xdde2c6c8 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xdde2c6c8 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe8a3d485 0047 11 GT 0048 61 PUSH2 0x007c 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xe8a3d485 > stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe8a3d485 > stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe8a3d485 0052 14 EQ 0053 61 PUSH2 0x0687 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0687, if 0xe8a3d485 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe8a3d485 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x068f 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068f, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x06cb 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06cb, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xfe73d374 0073 14 EQ 0074 61 PUSH2 0x06de 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06de, if 0xfe73d374 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xfe73d374 == stack[-1] // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x004B, if 0xe8a3d485 > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xdde2c6c8 0083 14 EQ 0084 61 PUSH2 0x064e 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064e, if 0xdde2c6c8 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xdde2c6c8 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xde9d629e 008E 14 EQ 008F 61 PUSH2 0x0661 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0661, if 0xde9d629e == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xde9d629e == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xe023c6d9 0099 14 EQ 009A 61 PUSH2 0x0674 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0674, if 0xe023c6d9 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xe023c6d9 == stack[-1] // Inputs[1] { @00A1 memory[0x00:0x00] } 009E 60 PUSH1 0x00 00A0 80 DUP1 00A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A1 revert(memory[0x00:0x00]); } // Block terminates label_00A2: // Incoming jump from 0x0040, if 0xdde2c6c8 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0xb4b5b48f 00A9 14 EQ 00AA 61 PUSH2 0x05d7 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d7, if 0xb4b5b48f == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0xb4b5b48f == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xb88d4fde 00B4 14 EQ 00B5 61 PUSH2 0x05f8 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f8, if 0xb88d4fde == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xc0e72740 00BF 14 EQ 00C0 61 PUSH2 0x060b 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060b, if 0xc0e72740 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xc0e72740 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xc87b56dd 00CA 14 EQ 00CB 61 PUSH2 0x0613 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0613, if 0xc87b56dd == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xd2070cf6 00D5 14 EQ 00D6 61 PUSH2 0x0626 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0626, if 0xd2070cf6 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xd2070cf6 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0xd547741f 00E0 14 EQ 00E1 61 PUSH2 0x063b 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063b, if 0xd547741f == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0xd547741f == stack[-1] // Inputs[1] { @00E8 memory[0x00:0x00] } 00E5 60 PUSH1 0x00 00E7 80 DUP1 00E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E8 revert(memory[0x00:0x00]); } // Block terminates label_00E9: // Incoming jump from 0x0035, if 0xb4b5b48f > stack[-1] // Inputs[1] { @00EA stack[-1] } 00E9 5B JUMPDEST 00EA 80 DUP1 00EB 63 PUSH4 0x9315f9e6 00F0 11 GT 00F1 61 PUSH2 0x013b 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013b, if 0x9315f9e6 > stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x9315f9e6 > stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x9315f9e6 00FB 14 EQ 00FC 61 PUSH2 0x057b 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x057b, if 0x9315f9e6 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x9315f9e6 == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x938e3d7b 0106 14 EQ 0107 61 PUSH2 0x058e 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058e, if 0x938e3d7b == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x938e3d7b == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x95d89b41 0111 14 EQ 0112 61 PUSH2 0x05a1 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a1, if 0x95d89b41 == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0xa217fddf 011C 14 EQ 011D 61 PUSH2 0x05a9 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a9, if 0xa217fddf == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0xa217fddf == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0xa22cb465 0127 14 EQ 0128 61 PUSH2 0x05b1 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b1, if 0xa22cb465 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0xa22cb465 == stack[-1] // Inputs[1] { @012C stack[-1] } 012C 80 DUP1 012D 63 PUSH4 0xaea90239 0132 14 EQ 0133 61 PUSH2 0x05c4 0136 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c4, if 0xaea90239 == stack[-1] label_0137: // Incoming jump from 0x0136, if not 0xaea90239 == stack[-1] // Inputs[1] { @013A memory[0x00:0x00] } 0137 60 PUSH1 0x00 0139 80 DUP1 013A FD *REVERT // Stack delta = +0 // Outputs[1] { @013A revert(memory[0x00:0x00]); } // Block terminates label_013B: // Incoming jump from 0x00F4, if 0x9315f9e6 > stack[-1] // Inputs[1] { @013C stack[-1] } 013B 5B JUMPDEST 013C 80 DUP1 013D 63 PUSH4 0x70a08231 0142 14 EQ 0143 61 PUSH2 0x051c 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051c, if 0x70a08231 == stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x70a08231 == stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x715018a6 014D 14 EQ 014E 61 PUSH2 0x052f 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052f, if 0x715018a6 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x715018a6 == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x8456cb59 0158 14 EQ 0159 61 PUSH2 0x0537 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0537, if 0x8456cb59 == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x8456cb59 == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x85c54bc5 0163 14 EQ 0164 61 PUSH2 0x053f 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053f, if 0x85c54bc5 == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x85c54bc5 == stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x8da5cb5b 016E 14 EQ 016F 61 PUSH2 0x0552 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0552, if 0x8da5cb5b == stack[-1] label_0173: // Incoming jump from 0x0172, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0173 stack[-1] } 0173 80 DUP1 0174 63 PUSH4 0x91d14854 0179 14 EQ 017A 61 PUSH2 0x0568 017D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0568, if 0x91d14854 == stack[-1] label_017E: // Incoming jump from 0x017D, if not 0x91d14854 == stack[-1] // Inputs[1] { @0181 memory[0x00:0x00] } 017E 60 PUSH1 0x00 0180 80 DUP1 0181 FD *REVERT // Stack delta = +0 // Outputs[1] { @0181 revert(memory[0x00:0x00]); } // Block terminates label_0182: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0183 stack[-1] } 0182 5B JUMPDEST 0183 80 DUP1 0184 63 PUSH4 0x31690734 0189 11 GT 018A 61 PUSH2 0x0241 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0241, if 0x31690734 > stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x31690734 > stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0x3f4ba83a 0194 11 GT 0195 61 PUSH2 0x01fa 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fa, if 0x3f4ba83a > stack[-1] label_0199: // Incoming jump from 0x0198, if not 0x3f4ba83a > stack[-1] // Inputs[1] { @0199 stack[-1] } 0199 80 DUP1 019A 63 PUSH4 0x4f6ccce7 019F 11 GT 01A0 61 PUSH2 0x01d4 01A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d4, if 0x4f6ccce7 > stack[-1] label_01A4: // Incoming jump from 0x01A3, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @01A4 stack[-1] } 01A4 80 DUP1 01A5 63 PUSH4 0x4f6ccce7 01AA 14 EQ 01AB 61 PUSH2 0x04d8 01AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d8, if 0x4f6ccce7 == stack[-1] label_01AF: // Incoming jump from 0x01AE, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @01AF stack[-1] } 01AF 80 DUP1 01B0 63 PUSH4 0x55f804b3 01B5 14 EQ 01B6 61 PUSH2 0x04eb 01B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04eb, if 0x55f804b3 == stack[-1] label_01BA: // Incoming jump from 0x01B9, if not 0x55f804b3 == stack[-1] // Inputs[1] { @01BA stack[-1] } 01BA 80 DUP1 01BB 63 PUSH4 0x5c975abb 01C0 14 EQ 01C1 61 PUSH2 0x04fe 01C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fe, if 0x5c975abb == stack[-1] label_01C5: // Incoming jump from 0x01C4, if not 0x5c975abb == stack[-1] // Inputs[1] { @01C5 stack[-1] } 01C5 80 DUP1 01C6 63 PUSH4 0x6352211e 01CB 14 EQ 01CC 61 PUSH2 0x0509 01CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0509, if 0x6352211e == stack[-1] label_01D0: // Incoming jump from 0x01CF, if not 0x6352211e == stack[-1] // Inputs[1] { @01D3 memory[0x00:0x00] } 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D3 revert(memory[0x00:0x00]); } // Block terminates label_01D4: // Incoming jump from 0x01A3, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @01D5 stack[-1] } 01D4 5B JUMPDEST 01D5 80 DUP1 01D6 63 PUSH4 0x3f4ba83a 01DB 14 EQ 01DC 61 PUSH2 0x04aa 01DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04aa, if 0x3f4ba83a == stack[-1] label_01E0: // Incoming jump from 0x01DF, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @01E0 stack[-1] } 01E0 80 DUP1 01E1 63 PUSH4 0x42842e0e 01E6 14 EQ 01E7 61 PUSH2 0x04b2 01EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b2, if 0x42842e0e == stack[-1] label_01EB: // Incoming jump from 0x01EA, if not 0x42842e0e == stack[-1] // Inputs[1] { @01EB stack[-1] } 01EB 80 DUP1 01EC 63 PUSH4 0x42966c68 01F1 14 EQ 01F2 61 PUSH2 0x04c5 01F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c5, if 0x42966c68 == stack[-1] label_01F6: // Incoming jump from 0x01F5, if not 0x42966c68 == stack[-1] // Inputs[1] { @01F9 memory[0x00:0x00] } 01F6 60 PUSH1 0x00 01F8 80 DUP1 01F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F9 revert(memory[0x00:0x00]); } // Block terminates label_01FA: // Incoming jump from 0x0198, if 0x3f4ba83a > stack[-1] // Inputs[1] { @01FB stack[-1] } 01FA 5B JUMPDEST 01FB 80 DUP1 01FC 63 PUSH4 0x31690734 0201 14 EQ 0202 61 PUSH2 0x03ff 0205 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ff, if 0x31690734 == stack[-1] label_0206: // Incoming jump from 0x0205, if not 0x31690734 == stack[-1] // Inputs[1] { @0206 stack[-1] } 0206 80 DUP1 0207 63 PUSH4 0x342a37bc 020C 14 EQ 020D 61 PUSH2 0x0412 0210 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0412, if 0x342a37bc == stack[-1] label_0211: // Incoming jump from 0x0210, if not 0x342a37bc == stack[-1] // Inputs[1] { @0211 stack[-1] } 0211 80 DUP1 0212 63 PUSH4 0x36568abe 0217 14 EQ 0218 61 PUSH2 0x0425 021B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0425, if 0x36568abe == stack[-1] label_021C: // Incoming jump from 0x021B, if not 0x36568abe == stack[-1] // Inputs[1] { @021C stack[-1] } 021C 80 DUP1 021D 63 PUSH4 0x390b04f3 0222 14 EQ 0223 61 PUSH2 0x0438 0226 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0438, if 0x390b04f3 == stack[-1] label_0227: // Incoming jump from 0x0226, if not 0x390b04f3 == stack[-1] // Inputs[1] { @0227 stack[-1] } 0227 80 DUP1 0228 63 PUSH4 0x39ef8e72 022D 14 EQ 022E 61 PUSH2 0x0482 0231 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0482, if 0x39ef8e72 == stack[-1] label_0232: // Incoming jump from 0x0231, if not 0x39ef8e72 == stack[-1] // Inputs[1] { @0232 stack[-1] } 0232 80 DUP1 0233 63 PUSH4 0x3b7b0754 0238 14 EQ 0239 61 PUSH2 0x0495 023C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0495, if 0x3b7b0754 == stack[-1] label_023D: // Incoming jump from 0x023C, if not 0x3b7b0754 == stack[-1] // Inputs[1] { @0240 memory[0x00:0x00] } 023D 60 PUSH1 0x00 023F 80 DUP1 0240 FD *REVERT // Stack delta = +0 // Outputs[1] { @0240 revert(memory[0x00:0x00]); } // Block terminates label_0241: // Incoming jump from 0x018D, if 0x31690734 > stack[-1] // Inputs[1] { @0242 stack[-1] } 0241 5B JUMPDEST 0242 80 DUP1 0243 63 PUSH4 0x23b872dd 0248 11 GT 0249 61 PUSH2 0x0293 024C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0293, if 0x23b872dd > stack[-1] label_024D: // Incoming jump from 0x024C, if not 0x23b872dd > stack[-1] // Inputs[1] { @024D stack[-1] } 024D 80 DUP1 024E 63 PUSH4 0x23b872dd 0253 14 EQ 0254 61 PUSH2 0x037d 0257 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037d, if 0x23b872dd == stack[-1] label_0258: // Incoming jump from 0x0257, if not 0x23b872dd == stack[-1] // Inputs[1] { @0258 stack[-1] } 0258 80 DUP1 0259 63 PUSH4 0x248a9ca3 025E 14 EQ 025F 61 PUSH2 0x0390 0262 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0390, if 0x248a9ca3 == stack[-1] label_0263: // Incoming jump from 0x0262, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @0263 stack[-1] } 0263 80 DUP1 0264 63 PUSH4 0x27190e5f 0269 14 EQ 026A 61 PUSH2 0x03b3 026D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b3, if 0x27190e5f == stack[-1] label_026E: // Incoming jump from 0x026D, if not 0x27190e5f == stack[-1] // Inputs[1] { @026E stack[-1] } 026E 80 DUP1 026F 63 PUSH4 0x2ca51e22 0274 14 EQ 0275 61 PUSH2 0x03c6 0278 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c6, if 0x2ca51e22 == stack[-1] label_0279: // Incoming jump from 0x0278, if not 0x2ca51e22 == stack[-1] // Inputs[1] { @0279 stack[-1] } 0279 80 DUP1 027A 63 PUSH4 0x2f2ff15d 027F 14 EQ 0280 61 PUSH2 0x03d9 0283 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d9, if 0x2f2ff15d == stack[-1] label_0284: // Incoming jump from 0x0283, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @0284 stack[-1] } 0284 80 DUP1 0285 63 PUSH4 0x2f745c59 028A 14 EQ 028B 61 PUSH2 0x03ec 028E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ec, if 0x2f745c59 == stack[-1] label_028F: // Incoming jump from 0x028E, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0292 memory[0x00:0x00] } 028F 60 PUSH1 0x00 0291 80 DUP1 0292 FD *REVERT // Stack delta = +0 // Outputs[1] { @0292 revert(memory[0x00:0x00]); } // Block terminates label_0293: // Incoming jump from 0x024C, if 0x23b872dd > stack[-1] // Inputs[1] { @0294 stack[-1] } 0293 5B JUMPDEST 0294 80 DUP1 0295 63 PUSH4 0x01ffc9a7 029A 14 EQ 029B 61 PUSH2 0x02db 029E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02db, if 0x01ffc9a7 == stack[-1] label_029F: // Incoming jump from 0x029E, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @029F stack[-1] } 029F 80 DUP1 02A0 63 PUSH4 0x06fdde03 02A5 14 EQ 02A6 61 PUSH2 0x0303 02A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0303, if 0x06fdde03 == stack[-1] label_02AA: // Incoming jump from 0x02A9, if not 0x06fdde03 == stack[-1] // Inputs[1] { @02AA stack[-1] } 02AA 80 DUP1 02AB 63 PUSH4 0x081812fc 02B0 14 EQ 02B1 61 PUSH2 0x0318 02B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0318, if 0x081812fc == stack[-1] label_02B5: // Incoming jump from 0x02B4, if not 0x081812fc == stack[-1] // Inputs[1] { @02B5 stack[-1] } 02B5 80 DUP1 02B6 63 PUSH4 0x095ea7b3 02BB 14 EQ 02BC 61 PUSH2 0x0343 02BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0343, if 0x095ea7b3 == stack[-1] label_02C0: // Incoming jump from 0x02BF, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @02C0 stack[-1] } 02C0 80 DUP1 02C1 63 PUSH4 0x18160ddd 02C6 14 EQ 02C7 61 PUSH2 0x0358 02CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0358, if 0x18160ddd == stack[-1] label_02CB: // Incoming jump from 0x02CA, if not 0x18160ddd == stack[-1] // Inputs[1] { @02CB stack[-1] } 02CB 80 DUP1 02CC 63 PUSH4 0x1ee6a15c 02D1 14 EQ 02D2 61 PUSH2 0x036a 02D5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036a, if 0x1ee6a15c == stack[-1] label_02D6: // Incoming jump from 0x02D5, if not 0x1ee6a15c == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @02DA memory[0x00:0x00] } 02D6 5B JUMPDEST 02D7 60 PUSH1 0x00 02D9 80 DUP1 02DA FD *REVERT // Stack delta = +0 // Outputs[1] { @02DA revert(memory[0x00:0x00]); } // Block terminates label_02DB: // Incoming jump from 0x029E, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @02E2 msg.data.length } 02DB 5B JUMPDEST 02DC 61 PUSH2 0x02ee 02DF 61 PUSH2 0x02e9 02E2 36 CALLDATASIZE 02E3 60 PUSH1 0x04 02E5 61 PUSH2 0x333f 02E8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DC stack[0] = 0x02ee // @02DF stack[1] = 0x02e9 // @02E2 stack[2] = msg.data.length // @02E3 stack[3] = 0x04 // } // Block ends with call to 0x333f, returns to 0x02E9 label_02E9: // Incoming return from call to 0x333F at 0x02E8 02E9 5B JUMPDEST 02EA 61 PUSH2 0x06f1 02ED 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06f1 label_02EE: // Incoming return from call to 0x0576 at 0x0575 // Incoming jump from 0x0508 // Incoming return from call to 0x066F at 0x066E // Incoming return from call to 0x0589 at 0x0588 // Incoming return from call to 0x0589 at 0x0588 // Incoming return from call to 0x02E9 at 0x02E8 // Inputs[2] // { // @02F1 memory[0x40:0x60] // @02F2 stack[-1] // } 02EE 5B JUMPDEST 02EF 60 PUSH1 0x40 02F1 51 MLOAD 02F2 90 SWAP1 02F3 15 ISZERO 02F4 15 ISZERO 02F5 81 DUP2 02F6 52 MSTORE 02F7 60 PUSH1 0x20 02F9 01 ADD // Stack delta = +0 // Outputs[2] // { // @02F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02F9 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_02FA: // Incoming jump from 0x0342 // Incoming jump from 0x0369 // Incoming jump from 0x0369 // Incoming jump from 0x0481 // Incoming return from call to 0x3583 at 0x05F7 // Incoming jump from 0x02F9 // Incoming return from call to 0x3570 at 0x0317 // Inputs[3] // { // @02FD memory[0x40:0x60] // @02FF stack[-1] // @0302 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02FA 5B JUMPDEST 02FB 60 PUSH1 0x40 02FD 51 MLOAD 02FE 80 DUP1 02FF 91 SWAP2 0300 03 SUB 0301 90 SWAP1 0302 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0302 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0303: // Incoming jump from 0x02A9, if 0x06fdde03 == stack[-1] 0303 5B JUMPDEST 0304 61 PUSH2 0x030b 0307 61 PUSH2 0x0702 030A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0304 stack[0] = 0x030b } // Block ends with call to 0x0702, returns to 0x030B label_030B: // Incoming return from call to 0x18D6 at 0x05A8 // Incoming return from call to 0x1DC6 at 0x068E // Incoming return from call to 0x1ACE at 0x0612 // Incoming return from call to 0x0702 at 0x030A // Incoming return from call to 0x0621 at 0x0620 // Incoming return from call to 0x0621 at 0x0620 // Inputs[2] // { // @030E memory[0x40:0x60] // @0312 stack[-1] // } 030B 5B JUMPDEST 030C 60 PUSH1 0x40 030E 51 MLOAD 030F 61 PUSH2 0x02fa 0312 91 SWAP2 0313 90 SWAP1 0314 61 PUSH2 0x3570 0317 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0312 stack[-1] = 0x02fa // @0313 stack[1] = memory[0x40:0x60] // @0313 stack[0] = stack[-1] // } // Block ends with call to 0x3570, returns to 0x02FA label_0318: // Incoming jump from 0x02B4, if 0x081812fc == stack[-1] // Inputs[1] { @031F msg.data.length } 0318 5B JUMPDEST 0319 61 PUSH2 0x032b 031C 61 PUSH2 0x0326 031F 36 CALLDATASIZE 0320 60 PUSH1 0x04 0322 61 PUSH2 0x3305 0325 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0319 stack[0] = 0x032b // @031C stack[1] = 0x0326 // @031F stack[2] = msg.data.length // @0320 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x0326 label_0326: // Incoming return from call to 0x3305 at 0x0325 0326 5B JUMPDEST 0327 61 PUSH2 0x0794 032A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0794 label_032B: // Incoming return from call to 0x0517 at 0x0516 // Incoming jump from 0x0424 // Incoming return from call to 0x0326 at 0x0325 // Incoming jump from 0x0567 // Inputs[2] // { // @032E memory[0x40:0x60] // @0338 stack[-1] // } 032B 5B JUMPDEST 032C 60 PUSH1 0x40 032E 51 MLOAD 032F 60 PUSH1 0x01 0331 60 PUSH1 0x01 0333 60 PUSH1 0xa0 0335 1B SHL 0336 03 SUB 0337 90 SWAP1 0338 91 SWAP2 0339 16 AND 033A 81 DUP2 033B 52 MSTORE 033C 60 PUSH1 0x20 033E 01 ADD 033F 61 PUSH2 0x02fa 0342 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @033B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @033E stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02fa label_0343: // Incoming jump from 0x02BF, if 0x095ea7b3 == stack[-1] // Inputs[1] { @034A msg.data.length } 0343 5B JUMPDEST 0344 61 PUSH2 0x0356 0347 61 PUSH2 0x0351 034A 36 CALLDATASIZE 034B 60 PUSH1 0x04 034D 61 PUSH2 0x3273 0350 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0344 stack[0] = 0x0356 // @0347 stack[1] = 0x0351 // @034A stack[2] = msg.data.length // @034B stack[3] = 0x04 // } // Block ends with call to 0x3273, returns to 0x0351 label_0351: // Incoming return from call to 0x3273 at 0x0350 0351 5B JUMPDEST 0352 61 PUSH2 0x082e 0355 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x082e label_0356: // Incoming return from call to 0x05BF at 0x05BE // Incoming return from call to 0x0433 at 0x0432 // Incoming return from call to 0x05D2 at 0x05D1 // Incoming return from call to 0x0682 at 0x0681 // Incoming return from call to 0x1780 at 0x0536 // Incoming return from call to 0x06EC at 0x06EB // Incoming return from call to 0x0351 at 0x0350 // Incoming return from call to 0x17BA at 0x053E // Incoming return from call to 0x0649 at 0x0648 // Incoming return from call to 0x0490 at 0x048F // Incoming return from call to 0x03C1 at 0x03C0 // Incoming return from call to 0x054D at 0x054C // Incoming return from call to 0x14CF at 0x04B1 // Incoming return from call to 0x065C at 0x065B 0356 5B JUMPDEST 0357 00 *STOP // Stack delta = +0 // Outputs[1] { @0357 stop(); } // Block terminates label_0358: // Incoming jump from 0x02CA, if 0x18160ddd == stack[-1] // Inputs[2] // { // @035B storage[0x09] // @035F memory[0x40:0x60] // } 0358 5B JUMPDEST 0359 60 PUSH1 0x09 035B 54 SLOAD 035C 5B JUMPDEST 035D 60 PUSH1 0x40 035F 51 MLOAD 0360 90 SWAP1 0361 81 DUP2 0362 52 MSTORE 0363 60 PUSH1 0x20 0365 01 ADD 0366 61 PUSH2 0x02fa 0369 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0362 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] // @0365 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02fa label_036A: // Incoming jump from 0x02D5, if 0x1ee6a15c == stack[-1] // Inputs[1] { @0371 msg.data.length } 036A 5B JUMPDEST 036B 61 PUSH2 0x0356 036E 61 PUSH2 0x0378 0371 36 CALLDATASIZE 0372 60 PUSH1 0x04 0374 61 PUSH2 0x33c2 0377 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036B stack[0] = 0x0356 // @036E stack[1] = 0x0378 // @0371 stack[2] = msg.data.length // @0372 stack[3] = 0x04 // } // Block ends with call to 0x33c2, returns to 0x0378 label_0378: // Incoming return from call to 0x33C2 at 0x0377 0378 5B JUMPDEST 0379 61 PUSH2 0x0944 037C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0944 label_037D: // Incoming jump from 0x0257, if 0x23b872dd == stack[-1] // Inputs[1] { @0384 msg.data.length } 037D 5B JUMPDEST 037E 61 PUSH2 0x0356 0381 61 PUSH2 0x038b 0384 36 CALLDATASIZE 0385 60 PUSH1 0x04 0387 61 PUSH2 0x3185 038A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @037E stack[0] = 0x0356 // @0381 stack[1] = 0x038b // @0384 stack[2] = msg.data.length // @0385 stack[3] = 0x04 // } // Block ends with call to 0x3185, returns to 0x038B label_038B: // Incoming return from call to 0x3185 at 0x038A 038B 5B JUMPDEST 038C 61 PUSH2 0x0a65 038F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a65 label_0390: // Incoming jump from 0x0262, if 0x248a9ca3 == stack[-1] // Inputs[1] { @0397 msg.data.length } 0390 5B JUMPDEST 0391 61 PUSH2 0x035c 0394 61 PUSH2 0x039e 0397 36 CALLDATASIZE 0398 60 PUSH1 0x04 039A 61 PUSH2 0x3305 039D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0391 stack[0] = 0x035c // @0394 stack[1] = 0x039e // @0397 stack[2] = msg.data.length // @0398 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x039E label_039E: // Incoming return from call to 0x3305 at 0x039D // Inputs[4] // { // @03A1 stack[-1] // @03AC memory[0x00:0x40] // @03B0 storage[0x01 + keccak256(memory[0x00:0x40])] // @03B1 stack[-2] // } 039E 5B JUMPDEST 039F 60 PUSH1 0x00 03A1 90 SWAP1 03A2 81 DUP2 03A3 52 MSTORE 03A4 60 PUSH1 0x06 03A6 60 PUSH1 0x20 03A8 52 MSTORE 03A9 60 PUSH1 0x40 03AB 90 SWAP1 03AC 20 SHA3 03AD 60 PUSH1 0x01 03AF 01 ADD 03B0 54 SLOAD 03B1 90 SWAP1 03B2 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @03A3 memory[0x00:0x20] = stack[-1] // @03A8 memory[0x20:0x40] = 0x06 // @03B1 stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_03B3: // Incoming jump from 0x026D, if 0x27190e5f == stack[-1] // Inputs[1] { @03BA msg.data.length } 03B3 5B JUMPDEST 03B4 61 PUSH2 0x0356 03B7 61 PUSH2 0x03c1 03BA 36 CALLDATASIZE 03BB 60 PUSH1 0x04 03BD 61 PUSH2 0x3139 03C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B4 stack[0] = 0x0356 // @03B7 stack[1] = 0x03c1 // @03BA stack[2] = msg.data.length // @03BB stack[3] = 0x04 // } // Block ends with call to 0x3139, returns to 0x03C1 label_03C1: // Incoming return from call to 0x3139 at 0x03C0 03C1 5B JUMPDEST 03C2 61 PUSH2 0x0a97 03C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a97 label_03C6: // Incoming jump from 0x0278, if 0x2ca51e22 == stack[-1] // Inputs[1] { @03CD msg.data.length } 03C6 5B JUMPDEST 03C7 61 PUSH2 0x0356 03CA 61 PUSH2 0x03d4 03CD 36 CALLDATASIZE 03CE 60 PUSH1 0x04 03D0 61 PUSH2 0x329c 03D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C7 stack[0] = 0x0356 // @03CA stack[1] = 0x03d4 // @03CD stack[2] = msg.data.length // @03CE stack[3] = 0x04 // } // Block ends with call to 0x329c, returns to 0x03D4 label_03D4: // Incoming return from call to 0x329C at 0x03D3 03D4 5B JUMPDEST 03D5 61 PUSH2 0x0ae9 03D8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ae9 label_03D9: // Incoming jump from 0x0283, if 0x2f2ff15d == stack[-1] // Inputs[1] { @03E0 msg.data.length } 03D9 5B JUMPDEST 03DA 61 PUSH2 0x0356 03DD 61 PUSH2 0x03e7 03E0 36 CALLDATASIZE 03E1 60 PUSH1 0x04 03E3 61 PUSH2 0x331d 03E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03DA stack[0] = 0x0356 // @03DD stack[1] = 0x03e7 // @03E0 stack[2] = msg.data.length // @03E1 stack[3] = 0x04 // } // Block ends with call to 0x331d, returns to 0x03E7 label_03E7: // Incoming return from call to 0x331D at 0x03E6 03E7 5B JUMPDEST 03E8 61 PUSH2 0x1314 03EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1314 label_03EC: // Incoming jump from 0x028E, if 0x2f745c59 == stack[-1] // Inputs[1] { @03F3 msg.data.length } 03EC 5B JUMPDEST 03ED 61 PUSH2 0x035c 03F0 61 PUSH2 0x03fa 03F3 36 CALLDATASIZE 03F4 60 PUSH1 0x04 03F6 61 PUSH2 0x3273 03F9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03ED stack[0] = 0x035c // @03F0 stack[1] = 0x03fa // @03F3 stack[2] = msg.data.length // @03F4 stack[3] = 0x04 // } // Block ends with call to 0x3273, returns to 0x03FA label_03FA: // Incoming return from call to 0x3273 at 0x03F9 03FA 5B JUMPDEST 03FB 61 PUSH2 0x133a 03FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x133a label_03FF: // Incoming jump from 0x0205, if 0x31690734 == stack[-1] // Inputs[1] { @0406 msg.data.length } 03FF 5B JUMPDEST 0400 61 PUSH2 0x0356 0403 61 PUSH2 0x040d 0406 36 CALLDATASIZE 0407 60 PUSH1 0x04 0409 61 PUSH2 0x3377 040C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0400 stack[0] = 0x0356 // @0403 stack[1] = 0x040d // @0406 stack[2] = msg.data.length // @0407 stack[3] = 0x04 // } // Block ends with call to 0x3377, returns to 0x040D label_040D: // Incoming return from call to 0x3377 at 0x040C 040D 5B JUMPDEST 040E 61 PUSH2 0x13d0 0411 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13d0 label_0412: // Incoming jump from 0x0210, if 0x342a37bc == stack[-1] // Inputs[1] { @0415 storage[0x14] } 0412 5B JUMPDEST 0413 60 PUSH1 0x14 0415 54 SLOAD 0416 61 PUSH2 0x032b 0419 90 SWAP1 041A 60 PUSH1 0x01 041C 60 PUSH1 0x01 041E 60 PUSH1 0xa0 0420 1B SHL 0421 03 SUB 0422 16 AND 0423 81 DUP2 0424 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0419 stack[0] = 0x032b // @0422 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x14] // } // Block ends with unconditional jump to 0x032b label_0425: // Incoming jump from 0x021B, if 0x36568abe == stack[-1] // Inputs[1] { @042C msg.data.length } 0425 5B JUMPDEST 0426 61 PUSH2 0x0356 0429 61 PUSH2 0x0433 042C 36 CALLDATASIZE 042D 60 PUSH1 0x04 042F 61 PUSH2 0x331d 0432 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0426 stack[0] = 0x0356 // @0429 stack[1] = 0x0433 // @042C stack[2] = msg.data.length // @042D stack[3] = 0x04 // } // Block ends with call to 0x331d, returns to 0x0433 label_0433: // Incoming return from call to 0x331D at 0x0432 0433 5B JUMPDEST 0434 61 PUSH2 0x1417 0437 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1417 label_0438: // Incoming jump from 0x0226, if 0x390b04f3 == stack[-1] // Inputs[1] { @043F msg.data.length } 0438 5B JUMPDEST 0439 61 PUSH2 0x0467 043C 61 PUSH2 0x0446 043F 36 CALLDATASIZE 0440 60 PUSH1 0x04 0442 61 PUSH2 0x3305 0445 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0439 stack[0] = 0x0467 // @043C stack[1] = 0x0446 // @043F stack[2] = msg.data.length // @0440 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x0446 label_0446: // Incoming return from call to 0x3305 at 0x0445 // Inputs[6] // { // @044E stack[-1] // @0454 memory[0x00:0x40] // @0456 storage[keccak256(memory[0x00:0x40])] // @045B storage[keccak256(memory[0x00:0x40]) + 0x01] // @0461 storage[keccak256(memory[0x00:0x40]) + 0x02] // @0465 stack[-2] // } 0446 5B JUMPDEST 0447 60 PUSH1 0x0f 0449 60 PUSH1 0x20 044B 52 MSTORE 044C 60 PUSH1 0x00 044E 90 SWAP1 044F 81 DUP2 0450 52 MSTORE 0451 60 PUSH1 0x40 0453 90 SWAP1 0454 20 SHA3 0455 80 DUP1 0456 54 SLOAD 0457 60 PUSH1 0x01 0459 82 DUP3 045A 01 ADD 045B 54 SLOAD 045C 60 PUSH1 0x02 045E 90 SWAP1 045F 92 SWAP3 0460 01 ADD 0461 54 SLOAD 0462 90 SWAP1 0463 91 SWAP2 0464 90 SWAP1 0465 83 DUP4 0466 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @044B memory[0x20:0x40] = 0x0f // @0450 memory[0x00:0x20] = stack[-1] // @0463 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @0464 stack[1] = storage[keccak256(memory[0x00:0x40]) + 0x02] // @0464 stack[0] = storage[keccak256(memory[0x00:0x40]) + 0x01] // } // Block ends with unconditional jump to stack[-2] label_0467: // Incoming return from call to 0x0446 at 0x0445 // Inputs[4] // { // @046B memory[0x40:0x60] // @046C stack[-3] // @0473 stack[-2] // @0477 stack[-1] // } 0467 5B JUMPDEST 0468 60 PUSH1 0x40 046A 80 DUP1 046B 51 MLOAD 046C 93 SWAP4 046D 84 DUP5 046E 52 MSTORE 046F 60 PUSH1 0x20 0471 84 DUP5 0472 01 ADD 0473 92 SWAP3 0474 90 SWAP1 0475 92 SWAP3 0476 52 MSTORE 0477 90 SWAP1 0478 82 DUP3 0479 01 ADD 047A 52 MSTORE 047B 60 PUSH1 0x60 047D 01 ADD 047E 61 PUSH2 0x02fa 0481 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @046E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0476 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @047A memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-1] // @047D stack[-3] = 0x60 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02fa label_0482: // Incoming jump from 0x0231, if 0x39ef8e72 == stack[-1] // Inputs[1] { @0489 msg.data.length } 0482 5B JUMPDEST 0483 61 PUSH2 0x0356 0486 61 PUSH2 0x0490 0489 36 CALLDATASIZE 048A 60 PUSH1 0x04 048C 61 PUSH2 0x3273 048F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0483 stack[0] = 0x0356 // @0486 stack[1] = 0x0490 // @0489 stack[2] = msg.data.length // @048A stack[3] = 0x04 // } // Block ends with call to 0x3273, returns to 0x0490 label_0490: // Incoming return from call to 0x3273 at 0x048F 0490 5B JUMPDEST 0491 61 PUSH2 0x1491 0494 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1491 label_0495: // Incoming jump from 0x023C, if 0x3b7b0754 == stack[-1] // Inputs[2] // { // @049C memory[0x00:0x20] // @04A5 memory[0x00:0x20] // } 0495 5B JUMPDEST 0496 61 PUSH2 0x035c 0499 60 PUSH1 0x00 049B 80 DUP1 049C 51 MLOAD 049D 60 PUSH1 0x20 049F 61 PUSH2 0x3837 04A2 83 DUP4 04A3 39 CODECOPY 04A4 81 DUP2 04A5 51 MLOAD 04A6 91 SWAP2 04A7 52 MSTORE 04A8 81 DUP2 04A9 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0496 stack[0] = 0x035c // @04A3 memory[0x00:0x20] = code[0x3837:0x3857] // @04A6 stack[1] = memory[0x00:0x20] // @04A7 memory[0x00:0x20] = memory[0x00:0x20] // } // Block ends with unconditional jump to 0x035c label_04AA: // Incoming jump from 0x01DF, if 0x3f4ba83a == stack[-1] 04AA 5B JUMPDEST 04AB 61 PUSH2 0x0356 04AE 61 PUSH2 0x14cf 04B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @04AB stack[0] = 0x0356 } // Block ends with call to 0x14cf, returns to 0x0356 label_04B2: // Incoming jump from 0x01EA, if 0x42842e0e == stack[-1] // Inputs[1] { @04B9 msg.data.length } 04B2 5B JUMPDEST 04B3 61 PUSH2 0x0356 04B6 61 PUSH2 0x04c0 04B9 36 CALLDATASIZE 04BA 60 PUSH1 0x04 04BC 61 PUSH2 0x3185 04BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04B3 stack[0] = 0x0356 // @04B6 stack[1] = 0x04c0 // @04B9 stack[2] = msg.data.length // @04BA stack[3] = 0x04 // } // Block ends with call to 0x3185, returns to 0x04C0 label_04C0: // Incoming return from call to 0x3185 at 0x04BF 04C0 5B JUMPDEST 04C1 61 PUSH2 0x1509 04C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1509 label_04C5: // Incoming jump from 0x01F5, if 0x42966c68 == stack[-1] // Inputs[1] { @04CC msg.data.length } 04C5 5B JUMPDEST 04C6 61 PUSH2 0x0356 04C9 61 PUSH2 0x04d3 04CC 36 CALLDATASIZE 04CD 60 PUSH1 0x04 04CF 61 PUSH2 0x3305 04D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04C6 stack[0] = 0x0356 // @04C9 stack[1] = 0x04d3 // @04CC stack[2] = msg.data.length // @04CD stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x04D3 label_04D3: // Incoming return from call to 0x3305 at 0x04D2 04D3 5B JUMPDEST 04D4 61 PUSH2 0x1524 04D7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1524 label_04D8: // Incoming jump from 0x01AE, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @04DF msg.data.length } 04D8 5B JUMPDEST 04D9 61 PUSH2 0x035c 04DC 61 PUSH2 0x04e6 04DF 36 CALLDATASIZE 04E0 60 PUSH1 0x04 04E2 61 PUSH2 0x3305 04E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04D9 stack[0] = 0x035c // @04DC stack[1] = 0x04e6 // @04DF stack[2] = msg.data.length // @04E0 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x04E6 label_04E6: // Incoming return from call to 0x3305 at 0x04E5 04E6 5B JUMPDEST 04E7 61 PUSH2 0x159e 04EA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x159e label_04EB: // Incoming jump from 0x01B9, if 0x55f804b3 == stack[-1] // Inputs[1] { @04F2 msg.data.length } 04EB 5B JUMPDEST 04EC 61 PUSH2 0x0356 04EF 61 PUSH2 0x04f9 04F2 36 CALLDATASIZE 04F3 60 PUSH1 0x04 04F5 61 PUSH2 0x3377 04F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04EC stack[0] = 0x0356 // @04EF stack[1] = 0x04f9 // @04F2 stack[2] = msg.data.length // @04F3 stack[3] = 0x04 // } // Block ends with call to 0x3377, returns to 0x04F9 label_04F9: // Incoming return from call to 0x3377 at 0x04F8 04F9 5B JUMPDEST 04FA 61 PUSH2 0x163f 04FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x163f label_04FE: // Incoming jump from 0x01C4, if 0x5c975abb == stack[-1] // Inputs[1] { @0501 storage[0x0b] } 04FE 5B JUMPDEST 04FF 60 PUSH1 0x0b 0501 54 SLOAD 0502 60 PUSH1 0xff 0504 16 AND 0505 61 PUSH2 0x02ee 0508 56 *JUMP // Stack delta = +1 // Outputs[1] { @0504 stack[0] = 0xff & storage[0x0b] } // Block ends with unconditional jump to 0x02ee label_0509: // Incoming jump from 0x01CF, if 0x6352211e == stack[-1] // Inputs[1] { @0510 msg.data.length } 0509 5B JUMPDEST 050A 61 PUSH2 0x032b 050D 61 PUSH2 0x0517 0510 36 CALLDATASIZE 0511 60 PUSH1 0x04 0513 61 PUSH2 0x3305 0516 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @050A stack[0] = 0x032b // @050D stack[1] = 0x0517 // @0510 stack[2] = msg.data.length // @0511 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x0517 label_0517: // Incoming return from call to 0x3305 at 0x0516 0517 5B JUMPDEST 0518 61 PUSH2 0x1682 051B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1682 label_051C: // Incoming jump from 0x0146, if 0x70a08231 == stack[-1] // Inputs[1] { @0523 msg.data.length } 051C 5B JUMPDEST 051D 61 PUSH2 0x035c 0520 61 PUSH2 0x052a 0523 36 CALLDATASIZE 0524 60 PUSH1 0x04 0526 61 PUSH2 0x3139 0529 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @051D stack[0] = 0x035c // @0520 stack[1] = 0x052a // @0523 stack[2] = msg.data.length // @0524 stack[3] = 0x04 // } // Block ends with call to 0x3139, returns to 0x052A label_052A: // Incoming return from call to 0x3139 at 0x0529 052A 5B JUMPDEST 052B 61 PUSH2 0x16f9 052E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16f9 label_052F: // Incoming jump from 0x0151, if 0x715018a6 == stack[-1] 052F 5B JUMPDEST 0530 61 PUSH2 0x0356 0533 61 PUSH2 0x1780 0536 56 *JUMP // Stack delta = +1 // Outputs[1] { @0530 stack[0] = 0x0356 } // Block ends with call to 0x1780, returns to 0x0356 label_0537: // Incoming jump from 0x015C, if 0x8456cb59 == stack[-1] 0537 5B JUMPDEST 0538 61 PUSH2 0x0356 053B 61 PUSH2 0x17ba 053E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0538 stack[0] = 0x0356 } // Block ends with call to 0x17ba, returns to 0x0356 label_053F: // Incoming jump from 0x0167, if 0x85c54bc5 == stack[-1] // Inputs[1] { @0546 msg.data.length } 053F 5B JUMPDEST 0540 61 PUSH2 0x0356 0543 61 PUSH2 0x054d 0546 36 CALLDATASIZE 0547 60 PUSH1 0x04 0549 61 PUSH2 0x3305 054C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0540 stack[0] = 0x0356 // @0543 stack[1] = 0x054d // @0546 stack[2] = msg.data.length // @0547 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x054D label_054D: // Incoming return from call to 0x3305 at 0x054C 054D 5B JUMPDEST 054E 61 PUSH2 0x17f2 0551 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x17f2 label_0552: // Incoming jump from 0x0172, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0555 storage[0x0b] } 0552 5B JUMPDEST 0553 60 PUSH1 0x0b 0555 54 SLOAD 0556 61 PUSH2 0x0100 0559 90 SWAP1 055A 04 DIV 055B 60 PUSH1 0x01 055D 60 PUSH1 0x01 055F 60 PUSH1 0xa0 0561 1B SHL 0562 03 SUB 0563 16 AND 0564 61 PUSH2 0x032b 0567 56 *JUMP // Stack delta = +1 // Outputs[1] { @0563 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0b] / 0x0100 } // Block ends with unconditional jump to 0x032b label_0568: // Incoming jump from 0x017D, if 0x91d14854 == stack[-1] // Inputs[1] { @056F msg.data.length } 0568 5B JUMPDEST 0569 61 PUSH2 0x02ee 056C 61 PUSH2 0x0576 056F 36 CALLDATASIZE 0570 60 PUSH1 0x04 0572 61 PUSH2 0x331d 0575 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0569 stack[0] = 0x02ee // @056C stack[1] = 0x0576 // @056F stack[2] = msg.data.length // @0570 stack[3] = 0x04 // } // Block ends with call to 0x331d, returns to 0x0576 label_0576: // Incoming return from call to 0x331D at 0x0575 0576 5B JUMPDEST 0577 61 PUSH2 0x1827 057A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1827 label_057B: // Incoming jump from 0x00FF, if 0x9315f9e6 == stack[-1] // Inputs[1] { @0582 msg.data.length } 057B 5B JUMPDEST 057C 61 PUSH2 0x02ee 057F 61 PUSH2 0x0589 0582 36 CALLDATASIZE 0583 60 PUSH1 0x04 0585 61 PUSH2 0x3273 0588 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @057C stack[0] = 0x02ee // @057F stack[1] = 0x0589 // @0582 stack[2] = msg.data.length // @0583 stack[3] = 0x04 // } // Block ends with call to 0x3273, returns to 0x0589 label_0589: // Incoming return from call to 0x3273 at 0x0588 0589 5B JUMPDEST 058A 61 PUSH2 0x1852 058D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1852 label_058E: // Incoming jump from 0x010A, if 0x938e3d7b == stack[-1] // Inputs[1] { @0595 msg.data.length } 058E 5B JUMPDEST 058F 61 PUSH2 0x0356 0592 61 PUSH2 0x059c 0595 36 CALLDATASIZE 0596 60 PUSH1 0x04 0598 61 PUSH2 0x3377 059B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @058F stack[0] = 0x0356 // @0592 stack[1] = 0x059c // @0595 stack[2] = msg.data.length // @0596 stack[3] = 0x04 // } // Block ends with call to 0x3377, returns to 0x059C label_059C: // Incoming return from call to 0x3377 at 0x059B 059C 5B JUMPDEST 059D 61 PUSH2 0x18a2 05A0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x18a2 label_05A1: // Incoming jump from 0x0115, if 0x95d89b41 == stack[-1] 05A1 5B JUMPDEST 05A2 61 PUSH2 0x030b 05A5 61 PUSH2 0x18d6 05A8 56 *JUMP // Stack delta = +1 // Outputs[1] { @05A2 stack[0] = 0x030b } // Block ends with call to 0x18d6, returns to 0x030B label_05A9: // Incoming jump from 0x0120, if 0xa217fddf == stack[-1] 05A9 5B JUMPDEST 05AA 61 PUSH2 0x035c 05AD 60 PUSH1 0x00 05AF 81 DUP2 05B0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05AA stack[0] = 0x035c // @05AD stack[1] = 0x00 // } // Block ends with unconditional jump to 0x035c label_05B1: // Incoming jump from 0x012B, if 0xa22cb465 == stack[-1] // Inputs[1] { @05B8 msg.data.length } 05B1 5B JUMPDEST 05B2 61 PUSH2 0x0356 05B5 61 PUSH2 0x05bf 05B8 36 CALLDATASIZE 05B9 60 PUSH1 0x04 05BB 61 PUSH2 0x3239 05BE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05B2 stack[0] = 0x0356 // @05B5 stack[1] = 0x05bf // @05B8 stack[2] = msg.data.length // @05B9 stack[3] = 0x04 // } // Block ends with call to 0x3239, returns to 0x05BF label_05BF: // Incoming return from call to 0x3239 at 0x05BE 05BF 5B JUMPDEST 05C0 61 PUSH2 0x18e5 05C3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x18e5 label_05C4: // Incoming jump from 0x0136, if 0xaea90239 == stack[-1] // Inputs[1] { @05CB msg.data.length } 05C4 5B JUMPDEST 05C5 61 PUSH2 0x0356 05C8 61 PUSH2 0x05d2 05CB 36 CALLDATASIZE 05CC 60 PUSH1 0x04 05CE 61 PUSH2 0x3407 05D1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05C5 stack[0] = 0x0356 // @05C8 stack[1] = 0x05d2 // @05CB stack[2] = msg.data.length // @05CC stack[3] = 0x04 // } // Block ends with call to 0x3407, returns to 0x05D2 label_05D2: // Incoming return from call to 0x3407 at 0x05D1 05D2 5B JUMPDEST 05D3 61 PUSH2 0x19aa 05D6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x19aa label_05D7: // Incoming jump from 0x00AD, if 0xb4b5b48f == stack[-1] // Inputs[1] { @05DE msg.data.length } 05D7 5B JUMPDEST 05D8 61 PUSH2 0x05ea 05DB 61 PUSH2 0x05e5 05DE 36 CALLDATASIZE 05DF 60 PUSH1 0x04 05E1 61 PUSH2 0x3305 05E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05D8 stack[0] = 0x05ea // @05DB stack[1] = 0x05e5 // @05DE stack[2] = msg.data.length // @05DF stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x05E5 label_05E5: // Incoming return from call to 0x3305 at 0x05E4 05E5 5B JUMPDEST 05E6 61 PUSH2 0x19ef 05E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x19ef label_05EA: // Incoming return from call to 0x05E5 at 0x05E4 // Inputs[3] // { // @05ED memory[0x40:0x60] // @05F1 stack[-2] // @05F2 stack[-1] // } 05EA 5B JUMPDEST 05EB 60 PUSH1 0x40 05ED 51 MLOAD 05EE 61 PUSH2 0x02fa 05F1 92 SWAP3 05F2 91 SWAP2 05F3 90 SWAP1 05F4 61 PUSH2 0x3583 05F7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @05F1 stack[-2] = 0x02fa // @05F2 stack[-1] = stack[-2] // @05F3 stack[1] = memory[0x40:0x60] // @05F3 stack[0] = stack[-1] // } // Block ends with call to 0x3583, returns to 0x02FA label_05F8: // Incoming jump from 0x00B8, if 0xb88d4fde == stack[-1] // Inputs[1] { @05FF msg.data.length } 05F8 5B JUMPDEST 05F9 61 PUSH2 0x0356 05FC 61 PUSH2 0x0606 05FF 36 CALLDATASIZE 0600 60 PUSH1 0x04 0602 61 PUSH2 0x31c0 0605 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05F9 stack[0] = 0x0356 // @05FC stack[1] = 0x0606 // @05FF stack[2] = msg.data.length // @0600 stack[3] = 0x04 // } // Block ends with call to 0x31c0, returns to 0x0606 label_0606: // Incoming return from call to 0x31C0 at 0x0605 0606 5B JUMPDEST 0607 61 PUSH2 0x1a96 060A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a96 label_060B: // Incoming jump from 0x00C3, if 0xc0e72740 == stack[-1] 060B 5B JUMPDEST 060C 61 PUSH2 0x030b 060F 61 PUSH2 0x1ace 0612 56 *JUMP // Stack delta = +1 // Outputs[1] { @060C stack[0] = 0x030b } // Block ends with call to 0x1ace, returns to 0x030B label_0613: // Incoming jump from 0x00CE, if 0xc87b56dd == stack[-1] // Inputs[1] { @061A msg.data.length } 0613 5B JUMPDEST 0614 61 PUSH2 0x030b 0617 61 PUSH2 0x0621 061A 36 CALLDATASIZE 061B 60 PUSH1 0x04 061D 61 PUSH2 0x3305 0620 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0614 stack[0] = 0x030b // @0617 stack[1] = 0x0621 // @061A stack[2] = msg.data.length // @061B stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x0621 label_0621: // Incoming return from call to 0x3305 at 0x0620 0621 5B JUMPDEST 0622 61 PUSH2 0x1b5c 0625 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b5c label_0626: // Incoming jump from 0x00D9, if 0xd2070cf6 == stack[-1] // Inputs[2] // { // @062D memory[0x00:0x20] // @0636 memory[0x00:0x20] // } 0626 5B JUMPDEST 0627 61 PUSH2 0x035c 062A 60 PUSH1 0x00 062C 80 DUP1 062D 51 MLOAD 062E 60 PUSH1 0x20 0630 61 PUSH2 0x3857 0633 83 DUP4 0634 39 CODECOPY 0635 81 DUP2 0636 51 MLOAD 0637 91 SWAP2 0638 52 MSTORE 0639 81 DUP2 063A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0627 stack[0] = 0x035c // @0634 memory[0x00:0x20] = code[0x3857:0x3877] // @0637 stack[1] = memory[0x00:0x20] // @0638 memory[0x00:0x20] = memory[0x00:0x20] // } // Block ends with unconditional jump to 0x035c label_063B: // Incoming jump from 0x00E4, if 0xd547741f == stack[-1] // Inputs[1] { @0642 msg.data.length } 063B 5B JUMPDEST 063C 61 PUSH2 0x0356 063F 61 PUSH2 0x0649 0642 36 CALLDATASIZE 0643 60 PUSH1 0x04 0645 61 PUSH2 0x331d 0648 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @063C stack[0] = 0x0356 // @063F stack[1] = 0x0649 // @0642 stack[2] = msg.data.length // @0643 stack[3] = 0x04 // } // Block ends with call to 0x331d, returns to 0x0649 label_0649: // Incoming return from call to 0x331D at 0x0648 0649 5B JUMPDEST 064A 61 PUSH2 0x1cf0 064D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1cf0 label_064E: // Incoming jump from 0x0087, if 0xdde2c6c8 == stack[-1] // Inputs[1] { @0655 msg.data.length } 064E 5B JUMPDEST 064F 61 PUSH2 0x0356 0652 61 PUSH2 0x065c 0655 36 CALLDATASIZE 0656 60 PUSH1 0x04 0658 61 PUSH2 0x3273 065B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @064F stack[0] = 0x0356 // @0652 stack[1] = 0x065c // @0655 stack[2] = msg.data.length // @0656 stack[3] = 0x04 // } // Block ends with call to 0x3273, returns to 0x065C label_065C: // Incoming return from call to 0x3273 at 0x065B 065C 5B JUMPDEST 065D 61 PUSH2 0x1d16 0660 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d16 label_0661: // Incoming jump from 0x0092, if 0xde9d629e == stack[-1] // Inputs[1] { @0668 msg.data.length } 0661 5B JUMPDEST 0662 61 PUSH2 0x02ee 0665 61 PUSH2 0x066f 0668 36 CALLDATASIZE 0669 60 PUSH1 0x04 066B 61 PUSH2 0x3305 066E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0662 stack[0] = 0x02ee // @0665 stack[1] = 0x066f // @0668 stack[2] = msg.data.length // @0669 stack[3] = 0x04 // } // Block ends with call to 0x3305, returns to 0x066F label_066F: // Incoming return from call to 0x3305 at 0x066E 066F 5B JUMPDEST 0670 61 PUSH2 0x1d54 0673 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d54 label_0674: // Incoming jump from 0x009D, if 0xe023c6d9 == stack[-1] // Inputs[1] { @067B msg.data.length } 0674 5B JUMPDEST 0675 61 PUSH2 0x0356 0678 61 PUSH2 0x0682 067B 36 CALLDATASIZE 067C 60 PUSH1 0x04 067E 61 PUSH2 0x3407 0681 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0675 stack[0] = 0x0356 // @0678 stack[1] = 0x0682 // @067B stack[2] = msg.data.length // @067C stack[3] = 0x04 // } // Block ends with call to 0x3407, returns to 0x0682 label_0682: // Incoming return from call to 0x3407 at 0x0681 0682 5B JUMPDEST 0683 61 PUSH2 0x1d84 0686 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d84 label_0687: // Incoming jump from 0x0056, if 0xe8a3d485 == stack[-1] 0687 5B JUMPDEST 0688 61 PUSH2 0x030b 068B 61 PUSH2 0x1dc6 068E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0688 stack[0] = 0x030b } // Block ends with call to 0x1dc6, returns to 0x030B label_068F: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0696 msg.data.length } 068F 5B JUMPDEST 0690 61 PUSH2 0x02ee 0693 61 PUSH2 0x069d 0696 36 CALLDATASIZE 0697 60 PUSH1 0x04 0699 61 PUSH2 0x3153 069C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0690 stack[0] = 0x02ee // @0693 stack[1] = 0x069d // @0696 stack[2] = msg.data.length // @0697 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x3153 label_069D: // Incoming call from 0x08C2, returns to 0x08C3 // Inputs[6] // { // @06A6 stack[-2] // @06B9 memory[0x00:0x40] // @06BA stack[-1] // @06C4 memory[0x00:0x40] // @06C5 storage[keccak256(memory[0x00:0x40])] // @06C9 stack[-3] // } 069D 5B JUMPDEST 069E 60 PUSH1 0x01 06A0 60 PUSH1 0x01 06A2 60 PUSH1 0xa0 06A4 1B SHL 06A5 03 SUB 06A6 91 SWAP2 06A7 82 DUP3 06A8 16 AND 06A9 60 PUSH1 0x00 06AB 90 SWAP1 06AC 81 DUP2 06AD 52 MSTORE 06AE 60 PUSH1 0x05 06B0 60 PUSH1 0x20 06B2 90 SWAP1 06B3 81 DUP2 06B4 52 MSTORE 06B5 60 PUSH1 0x40 06B7 80 DUP1 06B8 83 DUP4 06B9 20 SHA3 06BA 93 SWAP4 06BB 90 SWAP1 06BC 94 SWAP5 06BD 16 AND 06BE 82 DUP3 06BF 52 MSTORE 06C0 91 SWAP2 06C1 90 SWAP1 06C2 91 SWAP2 06C3 52 MSTORE 06C4 20 SHA3 06C5 54 SLOAD 06C6 60 PUSH1 0xff 06C8 16 AND 06C9 90 SWAP1 06CA 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @06AD memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @06B4 memory[0x20:0x40] = 0x05 // @06BF memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @06C3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06C9 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06CB: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @06D2 msg.data.length } 06CB 5B JUMPDEST 06CC 61 PUSH2 0x0356 06CF 61 PUSH2 0x06d9 06D2 36 CALLDATASIZE 06D3 60 PUSH1 0x04 06D5 61 PUSH2 0x3139 06D8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06CC stack[0] = 0x0356 // @06CF stack[1] = 0x06d9 // @06D2 stack[2] = msg.data.length // @06D3 stack[3] = 0x04 // } // Block ends with call to 0x3139, returns to 0x06D9 label_06D9: // Incoming return from call to 0x3139 at 0x06D8 06D9 5B JUMPDEST 06DA 61 PUSH2 0x1dd5 06DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1dd5 label_06DE: // Incoming jump from 0x0077, if 0xfe73d374 == stack[-1] // Inputs[1] { @06E5 msg.data.length } 06DE 5B JUMPDEST 06DF 61 PUSH2 0x0356 06E2 61 PUSH2 0x06ec 06E5 36 CALLDATASIZE 06E6 60 PUSH1 0x04 06E8 61 PUSH2 0x3407 06EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06DF stack[0] = 0x0356 // @06E2 stack[1] = 0x06ec // @06E5 stack[2] = msg.data.length // @06E6 stack[3] = 0x04 // } // Block ends with call to 0x3407, returns to 0x06EC label_06EC: // Incoming return from call to 0x3407 at 0x06EB 06EC 5B JUMPDEST 06ED 61 PUSH2 0x1e73 06F0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1e73 label_06F1: // Incoming jump from 0x02ED // Inputs[1] { @06F7 stack[-1] } 06F1 5B JUMPDEST 06F2 60 PUSH1 0x00 06F4 61 PUSH2 0x06fc 06F7 82 DUP3 06F8 61 PUSH2 0x20a3 06FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06F2 stack[0] = 0x00 // @06F4 stack[1] = 0x06fc // @06F7 stack[2] = stack[-1] // } // Block ends with call to 0x20a3, returns to 0x06FC label_06FC: // Incoming jump from 0x169F, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x2B5E, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x29B2, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1D6B, if !(block.timestamp > storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x2B77 // Incoming return from call to 0x20A3 at 0x06FB // Incoming jump from 0x2B5E, if stack[-1] // Incoming return from call to 0x2997 at 0x20C7 // Incoming jump from 0x20BE, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1877 // Incoming return from call to 0x2B28 at 0x29BB // Inputs[3] // { // @06FD stack[-1] // @06FD stack[-4] // @06FE stack[-3] // } 06FC 5B JUMPDEST 06FD 92 SWAP3 06FE 91 SWAP2 06FF 50 POP 0700 50 POP 0701 56 *JUMP // Stack delta = -3 // Outputs[1] { @06FD stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0702: // Incoming call from 0x030A, returns to 0x030B // Inputs[1] { @0708 storage[0x00] } 0702 5B JUMPDEST 0703 60 PUSH1 0x60 0705 60 PUSH1 0x00 0707 80 DUP1 0708 54 SLOAD 0709 61 PUSH2 0x0711 070C 90 SWAP1 070D 61 PUSH2 0x3774 0710 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0703 stack[0] = 0x60 // @0705 stack[1] = 0x00 // @070C stack[2] = 0x0711 // @070C stack[3] = storage[0x00] // } // Block ends with call to 0x3774, returns to 0x0711 label_0711: // Incoming return from call to 0x3774 at 0x1DD4 // Incoming return from call to 0x3774 at 0x0710 // Incoming return from call to 0x3774 at 0x18E4 // Inputs[4] // { // @0712 stack[-1] // @0721 memory[0x40:0x60] // @0729 stack[-2] // @0734 storage[stack[-2]] // } 0711 5B JUMPDEST 0712 80 DUP1 0713 60 PUSH1 0x1f 0715 01 ADD 0716 60 PUSH1 0x20 0718 80 DUP1 0719 91 SWAP2 071A 04 DIV 071B 02 MUL 071C 60 PUSH1 0x20 071E 01 ADD 071F 60 PUSH1 0x40 0721 51 MLOAD 0722 90 SWAP1 0723 81 DUP2 0724 01 ADD 0725 60 PUSH1 0x40 0727 52 MSTORE 0728 80 DUP1 0729 92 SWAP3 072A 91 SWAP2 072B 90 SWAP1 072C 81 DUP2 072D 81 DUP2 072E 52 MSTORE 072F 60 PUSH1 0x20 0731 01 ADD 0732 82 DUP3 0733 80 DUP1 0734 54 SLOAD 0735 61 PUSH2 0x073d 0738 90 SWAP1 0739 61 PUSH2 0x3774 073C 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0727 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0729 stack[-2] = memory[0x40:0x60] // @072A stack[-1] = stack[-2] // @072B stack[0] = stack[-1] // @072E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0731 stack[1] = 0x20 + memory[0x40:0x60] // @0732 stack[2] = stack[-2] // @0738 stack[4] = storage[stack[-2]] // @0738 stack[3] = 0x073d // } // Block ends with call to 0x3774, returns to 0x073D label_073D: // Incoming return from call to 0x3774 at 0x073C // Inputs[1] { @073E stack[-1] } 073D 5B JUMPDEST 073E 80 DUP1 073F 15 ISZERO 0740 61 PUSH2 0x078a 0743 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x078a, if !stack[-1] label_0744: // Incoming jump from 0x0743, if not !stack[-1] // Inputs[1] { @0744 stack[-1] } 0744 80 DUP1 0745 60 PUSH1 0x1f 0747 10 LT 0748 61 PUSH2 0x075f 074B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x075f, if 0x1f < stack[-1] label_074C: // Incoming jump from 0x074B, if not 0x1f < stack[-1] // Inputs[4] // { // @0750 stack[-2] // @0751 storage[stack[-2]] // @0754 stack[-3] // @0756 stack[-1] // } 074C 61 PUSH2 0x0100 074F 80 DUP1 0750 83 DUP4 0751 54 SLOAD 0752 04 DIV 0753 02 MUL 0754 83 DUP4 0755 52 MSTORE 0756 91 SWAP2 0757 60 PUSH1 0x20 0759 01 ADD 075A 91 SWAP2 075B 61 PUSH2 0x078a 075E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0755 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @075A stack[-1] = stack[-1] // @075A stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x078a label_075F: // Incoming jump from 0x074B, if 0x1f < stack[-1] // Inputs[5] // { // @0760 stack[-3] // @0761 stack[-1] // @0763 stack[-2] // @076B memory[0x00:0x20] // @076F storage[keccak256(memory[0x00:0x20])] // } 075F 5B JUMPDEST 0760 82 DUP3 0761 01 ADD 0762 91 SWAP2 0763 90 SWAP1 0764 60 PUSH1 0x00 0766 52 MSTORE 0767 60 PUSH1 0x20 0769 60 PUSH1 0x00 076B 20 SHA3 076C 90 SWAP1 076D 5B JUMPDEST 076E 81 DUP2 076F 54 SLOAD 0770 81 DUP2 0771 52 MSTORE 0772 90 SWAP1 0773 60 PUSH1 0x01 0775 01 ADD 0776 90 SWAP1 0777 60 PUSH1 0x20 0779 01 ADD 077A 80 DUP1 077B 83 DUP4 077C 11 GT 077D 61 PUSH2 0x076d 0780 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0762 stack[-3] = stack[-3] + stack[-1] // @0766 memory[0x00:0x20] = stack[-2] // @0771 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0776 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0779 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x076d, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0781: // Incoming jump from 0x0780, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0780, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0781 stack[-3] // @0782 stack[-1] // } 0781 82 DUP3 0782 90 SWAP1 0783 03 SUB 0784 60 PUSH1 0x1f 0786 16 AND 0787 82 DUP3 0788 01 ADD 0789 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0789 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0789 stack[-1] = stack[-3] // } // Block continues label_078A: // Incoming jump from 0x0789 // Incoming jump from 0x075E // Incoming jump from 0x0743, if !stack[-1] // Inputs[3] // { // @0790 stack[-6] // @0790 stack[-7] // @0792 stack[-8] // } 078A 5B JUMPDEST 078B 50 POP 078C 50 POP 078D 50 POP 078E 50 POP 078F 50 POP 0790 90 SWAP1 0791 50 POP 0792 90 SWAP1 0793 56 *JUMP // Stack delta = -7 // Outputs[1] { @0792 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0794: // Incoming jump from 0x032A // Incoming call from 0x21E9, returns to 0x21EA // Inputs[3] // { // @0797 stack[-1] // @07A2 memory[0x00:0x40] // @07A3 storage[keccak256(memory[0x00:0x40])] // } 0794 5B JUMPDEST 0795 60 PUSH1 0x00 0797 81 DUP2 0798 81 DUP2 0799 52 MSTORE 079A 60 PUSH1 0x02 079C 60 PUSH1 0x20 079E 52 MSTORE 079F 60 PUSH1 0x40 07A1 81 DUP2 07A2 20 SHA3 07A3 54 SLOAD 07A4 60 PUSH1 0x01 07A6 60 PUSH1 0x01 07A8 60 PUSH1 0xa0 07AA 1B SHL 07AB 03 SUB 07AC 16 AND 07AD 61 PUSH2 0x0812 07B0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0795 stack[0] = 0x00 // @0799 memory[0x00:0x20] = stack[-1] // @079E memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0812, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_07B1: // Incoming jump from 0x07B0, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @07B3 memory[0x40:0x60] } 07B1 60 PUSH1 0x40 07B3 51 MLOAD 07B4 62 PUSH3 0x461bcd 07B8 60 PUSH1 0xe5 07BA 1B SHL 07BB 81 DUP2 07BC 52 MSTORE 07BD 60 PUSH1 0x20 07BF 60 PUSH1 0x04 07C1 82 DUP3 07C2 01 ADD 07C3 52 MSTORE 07C4 60 PUSH1 0x2c 07C6 60 PUSH1 0x24 07C8 82 DUP3 07C9 01 ADD 07CA 52 MSTORE 07CB 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 07EC 60 PUSH1 0x44 07EE 82 DUP3 07EF 01 ADD 07F0 52 MSTORE 07F1 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 07FE 60 PUSH1 0xa1 0800 1B SHL 0801 60 PUSH1 0x64 0803 82 DUP3 0804 01 ADD 0805 52 MSTORE 0806 60 PUSH1 0x84 0808 01 ADD // Stack delta = +1 // Outputs[6] // { // @07BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @07F0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @0805 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @0808 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0809: // Incoming return from call to 0x3649 at 0x166E // Incoming return from call to 0x3649 at 0x0AC6 // Incoming jump from 0x2309 // Incoming jump from 0x1763 // Incoming jump from 0x193D // Incoming jump from 0x22A7 // Incoming return from call to 0x3649 at 0x1821 // Incoming return from call to 0x3570 at 0x263C // Incoming jump from 0x0A23 // Incoming jump from 0x1486 // Incoming jump from 0x1BDA // Incoming return from call to 0x3649 at 0x19D9 // Incoming jump from 0x2772 // Incoming jump from 0x1E69 // Incoming return from call to 0x3649 at 0x13FF // Incoming jump from 0x20A2 // Incoming return from call to 0x3649 at 0x14FE // Incoming jump from 0x21AE // Incoming jump from 0x16F8 // Incoming jump from 0x2BE9 // Incoming return from call to 0x3649 at 0x1DB3 // Incoming return from call to 0x367E at 0x1ABB // Incoming jump from 0x0934 // Incoming jump from 0x08A6 // Incoming jump from 0x1591 // Incoming jump from 0x160B // Incoming jump from 0x2903 // Incoming return from call to 0x3649 at 0x17AF // Incoming return from call to 0x3649 at 0x17E9 // Incoming jump from 0x0808 // Incoming return from call to 0x3649 at 0x1E04 // Incoming jump from 0x09B3 // Incoming return from call to 0x3649 at 0x1EA2 // Incoming jump from 0x13A6 // Inputs[3] // { // @080C memory[0x40:0x60] // @080E stack[-1] // @0811 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0809 5B JUMPDEST 080A 60 PUSH1 0x40 080C 51 MLOAD 080D 80 DUP1 080E 91 SWAP2 080F 03 SUB 0810 90 SWAP1 0811 FD *REVERT // Stack delta = -1 // Outputs[1] { @0811 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0812: // Incoming jump from 0x07B0, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0816 stack[-2] // @0821 memory[0x00:0x40] // @0822 storage[keccak256(memory[0x00:0x40])] // @082C stack[-3] // } 0812 5B JUMPDEST 0813 50 POP 0814 60 PUSH1 0x00 0816 90 SWAP1 0817 81 DUP2 0818 52 MSTORE 0819 60 PUSH1 0x04 081B 60 PUSH1 0x20 081D 52 MSTORE 081E 60 PUSH1 0x40 0820 90 SWAP1 0821 20 SHA3 0822 54 SLOAD 0823 60 PUSH1 0x01 0825 60 PUSH1 0x01 0827 60 PUSH1 0xa0 0829 1B SHL 082A 03 SUB 082B 16 AND 082C 90 SWAP1 082D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0818 memory[0x00:0x20] = stack[-2] // @081D memory[0x20:0x40] = 0x04 // @082C stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_082E: // Incoming jump from 0x0355 // Inputs[1] { @0834 stack[-1] } 082E 5B JUMPDEST 082F 60 PUSH1 0x00 0831 61 PUSH2 0x0839 0834 82 DUP3 0835 61 PUSH2 0x1682 0838 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @082F stack[0] = 0x00 // @0831 stack[1] = 0x0839 // @0834 stack[2] = stack[-1] // } // Block ends with call to 0x1682, returns to 0x0839 label_0839: // Incoming return from call to 0x1682 at 0x0838 // Inputs[3] // { // @083A stack[-2] // @083A stack[-1] // @0846 stack[-4] // } 0839 5B JUMPDEST 083A 90 SWAP1 083B 50 POP 083C 80 DUP1 083D 60 PUSH1 0x01 083F 60 PUSH1 0x01 0841 60 PUSH1 0xa0 0843 1B SHL 0844 03 SUB 0845 16 AND 0846 83 DUP4 0847 60 PUSH1 0x01 0849 60 PUSH1 0x01 084B 60 PUSH1 0xa0 084D 1B SHL 084E 03 SUB 084F 16 AND 0850 14 EQ 0851 15 ISZERO 0852 61 PUSH2 0x08a7 0855 57 *JUMPI // Stack delta = -1 // Outputs[1] { @083A stack[-2] = stack[-1] } // Block ends with conditional jump to 0x08a7, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0856: // Incoming jump from 0x0855, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0858 memory[0x40:0x60] } 0856 60 PUSH1 0x40 0858 51 MLOAD 0859 62 PUSH3 0x461bcd 085D 60 PUSH1 0xe5 085F 1B SHL 0860 81 DUP2 0861 52 MSTORE 0862 60 PUSH1 0x20 0864 60 PUSH1 0x04 0866 82 DUP3 0867 01 ADD 0868 52 MSTORE 0869 60 PUSH1 0x21 086B 60 PUSH1 0x24 086D 82 DUP3 086E 01 ADD 086F 52 MSTORE 0870 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 0891 60 PUSH1 0x44 0893 82 DUP3 0894 01 ADD 0895 52 MSTORE 0896 60 PUSH1 0x39 0898 60 PUSH1 0xf9 089A 1B SHL 089B 60 PUSH1 0x64 089D 82 DUP3 089E 01 ADD 089F 52 MSTORE 08A0 60 PUSH1 0x84 08A2 01 ADD 08A3 61 PUSH2 0x0809 08A6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0861 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0868 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @086F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @0895 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @089F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39 << 0xf9 // @08A2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_08A7: // Incoming jump from 0x0855, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @08A8 msg.sender // @08B1 stack[-1] // } 08A7 5B JUMPDEST 08A8 33 CALLER 08A9 60 PUSH1 0x01 08AB 60 PUSH1 0x01 08AD 60 PUSH1 0xa0 08AF 1B SHL 08B0 03 SUB 08B1 82 DUP3 08B2 16 AND 08B3 14 EQ 08B4 80 DUP1 08B5 61 PUSH2 0x08c3 08B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08B3 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x08c3, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_08B9: // Incoming jump from 0x08B8, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @08BD stack[-2] // @08BE msg.sender // } 08B9 50 POP 08BA 61 PUSH2 0x08c3 08BD 81 DUP2 08BE 33 CALLER 08BF 61 PUSH2 0x069d 08C2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08BA stack[-1] = 0x08c3 // @08BD stack[0] = stack[-2] // @08BE stack[1] = msg.sender // } // Block ends with call to 0x069d, returns to 0x08C3 label_08C3: // Incoming return from call to 0x069D at 0x08C2 // Incoming jump from 0x08B8, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @08C7 stack[-1] } 08C3 5B JUMPDEST 08C4 61 PUSH2 0x0935 08C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0935, if stack[-1] label_08C8: // Incoming jump from 0x08C7, if not stack[-1] // Inputs[1] { @08CA memory[0x40:0x60] } 08C8 60 PUSH1 0x40 08CA 51 MLOAD 08CB 62 PUSH3 0x461bcd 08CF 60 PUSH1 0xe5 08D1 1B SHL 08D2 81 DUP2 08D3 52 MSTORE 08D4 60 PUSH1 0x20 08D6 60 PUSH1 0x04 08D8 82 DUP3 08D9 01 ADD 08DA 52 MSTORE 08DB 60 PUSH1 0x38 08DD 60 PUSH1 0x24 08DF 82 DUP3 08E0 01 ADD 08E1 52 MSTORE 08E2 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 0903 60 PUSH1 0x44 0905 82 DUP3 0906 01 ADD 0907 52 MSTORE 0908 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 0929 60 PUSH1 0x64 092B 82 DUP3 092C 01 ADD 092D 52 MSTORE 092E 60 PUSH1 0x84 0930 01 ADD 0931 61 PUSH2 0x0809 0934 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08DA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08E1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @0907 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @092D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @0930 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_0935: // Incoming jump from 0x08C7, if stack[-1] // Inputs[2] // { // @0939 stack[-3] // @093A stack[-2] // } 0935 5B JUMPDEST 0936 61 PUSH2 0x093f 0939 83 DUP4 093A 83 DUP4 093B 61 PUSH2 0x20c8 093E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0936 stack[0] = 0x093f // @0939 stack[1] = stack[-3] // @093A stack[2] = stack[-2] // } // Block ends with call to 0x20c8, returns to 0x093F label_093F: // Incoming return from call to 0x2B78 at 0x29C6 // Incoming jump from 0x2DE6, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming return from call to 0x2E8D at 0x2DCC // Incoming return from call to 0x20C8 at 0x093E // Incoming return from call to 0x2F66 at 0x2DEF // Incoming return from call to 0x263D at 0x1339 // Incoming return from call to 0x26C3 at 0x1D15 // Incoming jump from 0x2B8E, if !(0xff & storage[0x0b]) // Inputs[1] { @0943 stack[-4] } 093F 5B JUMPDEST 0940 50 POP 0941 50 POP 0942 50 POP 0943 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0944: // Incoming jump from 0x037C // Inputs[3] // { // @094B memory[0x00:0x20] // @0954 memory[0x00:0x20] // @0957 msg.sender // } 0944 5B JUMPDEST 0945 61 PUSH2 0x095c 0948 60 PUSH1 0x00 094A 80 DUP1 094B 51 MLOAD 094C 60 PUSH1 0x20 094E 61 PUSH2 0x3857 0951 83 DUP4 0952 39 CODECOPY 0953 81 DUP2 0954 51 MLOAD 0955 91 SWAP2 0956 52 MSTORE 0957 33 CALLER 0958 61 PUSH2 0x1827 095B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0945 stack[0] = 0x095c // @0952 memory[0x00:0x20] = code[0x3857:0x3877] // @0955 stack[1] = memory[0x00:0x20] // @0956 memory[0x00:0x20] = memory[0x00:0x20] // @0957 stack[2] = msg.sender // } // Block ends with call to 0x1827, returns to 0x095C label_095C: // Incoming return from call to 0x1827 at 0x095B // Inputs[1] { @0960 stack[-1] } 095C 5B JUMPDEST 095D 61 PUSH2 0x09b4 0960 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09b4, if stack[-1] label_0961: // Incoming jump from 0x0960, if not stack[-1] // Inputs[1] { @0963 memory[0x40:0x60] } 0961 60 PUSH1 0x40 0963 51 MLOAD 0964 62 PUSH3 0x461bcd 0968 60 PUSH1 0xe5 096A 1B SHL 096B 81 DUP2 096C 52 MSTORE 096D 60 PUSH1 0x20 096F 60 PUSH1 0x04 0971 82 DUP3 0972 01 ADD 0973 52 MSTORE 0974 60 PUSH1 0x23 0976 60 PUSH1 0x24 0978 82 DUP3 0979 01 ADD 097A 52 MSTORE 097B 7F PUSH32 0x4163636573733a2073656e64657220646f6573206e6f74206861766520616363 099C 60 PUSH1 0x44 099E 82 DUP3 099F 01 ADD 09A0 52 MSTORE 09A1 62 PUSH3 0x657373 09A5 60 PUSH1 0xe8 09A7 1B SHL 09A8 60 PUSH1 0x64 09AA 82 DUP3 09AB 01 ADD 09AC 52 MSTORE 09AD 60 PUSH1 0x84 09AF 01 ADD 09B0 61 PUSH2 0x0809 09B3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @096C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0973 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @097A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @09A0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4163636573733a2073656e64657220646f6573206e6f74206861766520616363 // @09AC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @09AF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_09B4: // Incoming jump from 0x0960, if stack[-1] // Inputs[3] // { // @09B7 stack[-2] // @09C2 memory[0x00:0x40] // @09C3 storage[keccak256(memory[0x00:0x40])] // } 09B4 5B JUMPDEST 09B5 60 PUSH1 0x00 09B7 82 DUP3 09B8 81 DUP2 09B9 52 MSTORE 09BA 60 PUSH1 0x02 09BC 60 PUSH1 0x20 09BE 52 MSTORE 09BF 60 PUSH1 0x40 09C1 90 SWAP1 09C2 20 SHA3 09C3 54 SLOAD 09C4 60 PUSH1 0x01 09C6 60 PUSH1 0x01 09C8 60 PUSH1 0xa0 09CA 1B SHL 09CB 03 SUB 09CC 16 AND 09CD 61 PUSH2 0x0a24 09D0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @09B9 memory[0x00:0x20] = stack[-2] // @09BE memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0a24, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_09D1: // Incoming jump from 0x09D0, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @09D3 memory[0x40:0x60] } 09D1 60 PUSH1 0x40 09D3 51 MLOAD 09D4 62 PUSH3 0x461bcd 09D8 60 PUSH1 0xe5 09DA 1B SHL 09DB 81 DUP2 09DC 52 MSTORE 09DD 60 PUSH1 0x20 09DF 60 PUSH1 0x04 09E1 82 DUP3 09E2 01 ADD 09E3 52 MSTORE 09E4 60 PUSH1 0x24 09E6 80 DUP1 09E7 82 DUP3 09E8 01 ADD 09E9 52 MSTORE 09EA 7F PUSH32 0x4552433732314d657461646174613a20546f6b656e20646f6573206e6f742065 0A0B 60 PUSH1 0x44 0A0D 82 DUP3 0A0E 01 ADD 0A0F 52 MSTORE 0A10 63 PUSH4 0x1e1a5cdd 0A15 60 PUSH1 0xe2 0A17 1B SHL 0A18 60 PUSH1 0x64 0A1A 82 DUP3 0A1B 01 ADD 0A1C 52 MSTORE 0A1D 60 PUSH1 0x84 0A1F 01 ADD 0A20 61 PUSH2 0x0809 0A23 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @09DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09E3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09E9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @0A0F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a20546f6b656e20646f6573206e6f742065 // @0A1C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1e1a5cdd << 0xe2 // @0A1F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_0A24: // Incoming jump from 0x09D0, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0A27 stack[-2] // @0A35 memory[0x00:0x40] // @0A36 stack[-1] // @0A37 memory[stack[-1]:stack[-1] + 0x20] // } 0A24 5B JUMPDEST 0A25 60 PUSH1 0x00 0A27 82 DUP3 0A28 81 DUP2 0A29 52 MSTORE 0A2A 60 PUSH1 0x0e 0A2C 60 PUSH1 0x20 0A2E 90 SWAP1 0A2F 81 DUP2 0A30 52 MSTORE 0A31 60 PUSH1 0x40 0A33 90 SWAP1 0A34 91 SWAP2 0A35 20 SHA3 0A36 82 DUP3 0A37 51 MLOAD 0A38 61 PUSH2 0x0a43 0A3B 92 SWAP3 0A3C 84 DUP5 0A3D 01 ADD 0A3E 90 SWAP1 0A3F 61 PUSH2 0x2faa 0A42 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0A29 memory[0x00:0x20] = stack[-2] // @0A30 memory[0x20:0x40] = 0x0e // @0A35 stack[1] = keccak256(memory[0x00:0x40]) // @0A3B stack[0] = 0x0a43 // @0A3E stack[2] = stack[-1] + 0x20 // @0A3E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2faa 0A43 5B JUMPDEST 0A44 50 POP 0A45 50 POP 0A46 60 PUSH1 0x00 0A48 90 SWAP1 0A49 81 DUP2 0A4A 52 MSTORE 0A4B 60 PUSH1 0x0e 0A4D 60 PUSH1 0x20 0A4F 52 MSTORE 0A50 60 PUSH1 0x40 0A52 90 SWAP1 0A53 20 SHA3 0A54 60 PUSH1 0x01 0A56 90 SWAP1 0A57 81 DUP2 0A58 01 ADD 0A59 80 DUP1 0A5A 54 SLOAD 0A5B 60 PUSH1 0xff 0A5D 19 NOT 0A5E 16 AND 0A5F 90 SWAP1 0A60 91 SWAP2 0A61 17 OR 0A62 90 SWAP1 0A63 55 SSTORE 0A64 56 *JUMP label_0A65: // Incoming jump from 0x038F // Inputs[1] { @0A69 msg.sender } 0A65 5B JUMPDEST 0A66 61 PUSH2 0x0a70 0A69 33 CALLER // Stack delta = +2 // Outputs[2] // { // @0A66 stack[0] = 0x0a70 // @0A69 stack[1] = msg.sender // } // Block continues label_0A6A: // Incoming call from 0x152C, returns to 0x152D // Incoming jump from 0x0A69 // Inputs[1] { @0A6B stack[-3] } 0A6A 5B JUMPDEST 0A6B 82 DUP3 0A6C 61 PUSH2 0x2136 0A6F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A6B stack[0] = stack[-3] } // Block ends with unconditional jump to 0x2136 0A70 5B JUMPDEST 0A71 61 PUSH2 0x0a8c 0A74 57 *JUMPI 0A75 60 PUSH1 0x40 0A77 51 MLOAD 0A78 62 PUSH3 0x461bcd 0A7C 60 PUSH1 0xe5 0A7E 1B SHL 0A7F 81 DUP2 0A80 52 MSTORE 0A81 60 PUSH1 0x04 0A83 01 ADD 0A84 61 PUSH2 0x0809 0A87 90 SWAP1 0A88 61 PUSH2 0x367e 0A8B 56 *JUMP 0A8C 5B JUMPDEST 0A8D 61 PUSH2 0x093f 0A90 83 DUP4 0A91 83 DUP4 0A92 83 DUP4 0A93 61 PUSH2 0x222d 0A96 56 *JUMP label_0A97: // Incoming jump from 0x03C5 // Inputs[2] // { // @0A9A storage[0x0b] // @0AAA msg.sender // } 0A97 5B JUMPDEST 0A98 60 PUSH1 0x0b 0A9A 54 SLOAD 0A9B 60 PUSH1 0x01 0A9D 60 PUSH1 0x01 0A9F 60 PUSH1 0xa0 0AA1 1B SHL 0AA2 03 SUB 0AA3 61 PUSH2 0x0100 0AA6 90 SWAP1 0AA7 91 SWAP2 0AA8 04 DIV 0AA9 16 AND 0AAA 33 CALLER 0AAB 14 EQ 0AAC 61 PUSH2 0x0ac7 0AAF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ac7, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0AB0: // Incoming jump from 0x0AAF, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0AB2 memory[0x40:0x60] } 0AB0 60 PUSH1 0x40 0AB2 51 MLOAD 0AB3 62 PUSH3 0x461bcd 0AB7 60 PUSH1 0xe5 0AB9 1B SHL 0ABA 81 DUP2 0ABB 52 MSTORE 0ABC 60 PUSH1 0x04 0ABE 01 ADD 0ABF 61 PUSH2 0x0809 0AC2 90 SWAP1 0AC3 61 PUSH2 0x3649 0AC6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0ABB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AC2 stack[0] = 0x0809 // @0AC2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_0AC7: // Incoming jump from 0x0AAF, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0ACB storage[0x14] // @0ADE stack[-1] // @0AE8 stack[-2] // } 0AC7 5B JUMPDEST 0AC8 60 PUSH1 0x14 0ACA 80 DUP1 0ACB 54 SLOAD 0ACC 60 PUSH1 0x01 0ACE 60 PUSH1 0x01 0AD0 60 PUSH1 0xa0 0AD2 1B SHL 0AD3 03 SUB 0AD4 19 NOT 0AD5 16 AND 0AD6 60 PUSH1 0x01 0AD8 60 PUSH1 0x01 0ADA 60 PUSH1 0xa0 0ADC 1B SHL 0ADD 03 SUB 0ADE 92 SWAP3 0ADF 90 SWAP1 0AE0 92 SWAP3 0AE1 16 AND 0AE2 91 SWAP2 0AE3 90 SWAP1 0AE4 91 SWAP2 0AE5 17 OR 0AE6 90 SWAP1 0AE7 55 SSTORE 0AE8 56 *JUMP // Stack delta = -2 // Outputs[1] { @0AE7 storage[0x14] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x14]) } // Block ends with unconditional jump to stack[-2] label_0AE9: // Incoming jump from 0x03D8 // Inputs[1] { @0AEF memory[0x40:0x60] } 0AE9 5B JUMPDEST 0AEA 61 PUSH2 0x0b16 0AED 60 PUSH1 0x40 0AEF 51 MLOAD 0AF0 80 DUP1 0AF1 60 PUSH1 0x40 0AF3 01 ADD 0AF4 60 PUSH1 0x40 0AF6 52 MSTORE 0AF7 80 DUP1 0AF8 60 PUSH1 0x0c 0AFA 81 DUP2 0AFB 52 MSTORE 0AFC 60 PUSH1 0x20 0AFE 01 ADD 0AFF 6B PUSH12 0x3932b232b2b6b4b733971717 0B0C 60 PUSH1 0xa1 0B0E 1B SHL 0B0F 81 DUP2 0B10 52 MSTORE 0B11 50 POP 0B12 61 PUSH2 0x23d8 0B15 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0AEA stack[0] = 0x0b16 // @0AEF stack[1] = memory[0x40:0x60] // @0AF6 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0AFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0c // @0B10 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3932b232b2b6b4b733971717 << 0xa1 // } // Block ends with unconditional jump to 0x23d8 0B16 5B JUMPDEST 0B17 33 CALLER 0B18 32 ORIGIN 0B19 14 EQ 0B1A 61 PUSH2 0x0b6f 0B1D 57 *JUMPI 0B1E 60 PUSH1 0x40 0B20 51 MLOAD 0B21 62 PUSH3 0x461bcd 0B25 60 PUSH1 0xe5 0B27 1B SHL 0B28 81 DUP2 0B29 52 MSTORE 0B2A 60 PUSH1 0x20 0B2C 60 PUSH1 0x04 0B2E 82 DUP3 0B2F 01 ADD 0B30 52 MSTORE 0B31 60 PUSH1 0x21 0B33 60 PUSH1 0x24 0B35 82 DUP3 0B36 01 ADD 0B37 52 MSTORE 0B38 7F PUSH32 0x52656465656d3a206e6f7420616c6c6f7765642066726f6d20636f6e74726163 0B59 60 PUSH1 0x44 0B5B 82 DUP3 0B5C 01 ADD 0B5D 52 MSTORE 0B5E 60 PUSH1 0x1d 0B60 60 PUSH1 0xfa 0B62 1B SHL 0B63 60 PUSH1 0x64 0B65 82 DUP3 0B66 01 ADD 0B67 52 MSTORE 0B68 60 PUSH1 0x84 0B6A 01 ADD 0B6B 61 PUSH2 0x0809 0B6E 56 *JUMP 0B6F 5B JUMPDEST 0B70 60 PUSH1 0x0b 0B72 54 SLOAD 0B73 60 PUSH1 0xff 0B75 16 AND 0B76 15 ISZERO 0B77 61 PUSH2 0x0bb3 0B7A 57 *JUMPI 0B7B 60 PUSH1 0x40 0B7D 51 MLOAD 0B7E 62 PUSH3 0x461bcd 0B82 60 PUSH1 0xe5 0B84 1B SHL 0B85 81 DUP2 0B86 52 MSTORE 0B87 60 PUSH1 0x20 0B89 60 PUSH1 0x04 0B8B 82 DUP3 0B8C 01 ADD 0B8D 52 MSTORE 0B8E 60 PUSH1 0x0e 0B90 60 PUSH1 0x24 0B92 82 DUP3 0B93 01 ADD 0B94 52 MSTORE 0B95 6D PUSH14 0x14995919595b4e881c185d5cd959 0BA4 60 PUSH1 0x92 0BA6 1B SHL 0BA7 60 PUSH1 0x44 0BA9 82 DUP3 0BAA 01 ADD 0BAB 52 MSTORE 0BAC 60 PUSH1 0x64 0BAE 01 ADD 0BAF 61 PUSH2 0x0809 0BB2 56 *JUMP 0BB3 5B JUMPDEST 0BB4 60 PUSH1 0x00 0BB6 5B JUMPDEST 0BB7 83 DUP4 0BB8 81 DUP2 0BB9 10 LT 0BBA 15 ISZERO 0BBB 61 PUSH2 0x1050 0BBE 57 *JUMPI 0BBF 61 PUSH2 0x0c15 0BC2 60 PUSH1 0x40 0BC4 51 MLOAD 0BC5 80 DUP1 0BC6 60 PUSH1 0x40 0BC8 01 ADD 0BC9 60 PUSH1 0x40 0BCB 52 MSTORE 0BCC 80 DUP1 0BCD 60 PUSH1 0x0f 0BCF 81 DUP2 0BD0 52 MSTORE 0BD1 60 PUSH1 0x20 0BD3 01 ADD 0BD4 6E PUSH15 0x031b432b1b5b4b733903a37b5b2b71 0BE4 60 PUSH1 0x8d 0BE6 1B SHL 0BE7 81 DUP2 0BE8 52 MSTORE 0BE9 50 POP 0BEA 86 DUP7 0BEB 86 DUP7 0BEC 84 DUP5 0BED 81 DUP2 0BEE 81 DUP2 0BEF 10 LT 0BF0 61 PUSH2 0x0c09 0BF3 57 *JUMPI 0BF4 63 PUSH4 0x4e487b71 0BF9 60 PUSH1 0xe0 0BFB 1B SHL 0BFC 60 PUSH1 0x00 0BFE 52 MSTORE 0BFF 60 PUSH1 0x32 0C01 60 PUSH1 0x04 0C03 52 MSTORE 0C04 60 PUSH1 0x24 0C06 60 PUSH1 0x00 0C08 FD *REVERT 0C09 5B JUMPDEST 0C0A 90 SWAP1 0C0B 50 POP 0C0C 60 PUSH1 0x20 0C0E 02 MUL 0C0F 01 ADD 0C10 35 CALLDATALOAD 0C11 61 PUSH2 0x241b 0C14 56 *JUMP 0C15 5B JUMPDEST 0C16 61 PUSH2 0x0c5a 0C19 60 PUSH1 0x40 0C1B 51 MLOAD 0C1C 80 DUP1 0C1D 60 PUSH1 0x40 0C1F 01 ADD 0C20 60 PUSH1 0x40 0C22 52 MSTORE 0C23 80 DUP1 0C24 60 PUSH1 0x09 0C26 81 DUP2 0C27 52 MSTORE 0C28 60 PUSH1 0x20 0C2A 01 ADD 0C2B 68 PUSH9 0x038bab0b73a34ba3c9 0C35 60 PUSH1 0xbd 0C37 1B SHL 0C38 81 DUP2 0C39 52 MSTORE 0C3A 50 POP 0C3B 84 DUP5 0C3C 84 DUP5 0C3D 84 DUP5 0C3E 81 DUP2 0C3F 81 DUP2 0C40 10 LT 0C41 61 PUSH2 0x0c09 0C44 57 *JUMPI 0C45 63 PUSH4 0x4e487b71 0C4A 60 PUSH1 0xe0 0C4C 1B SHL 0C4D 60 PUSH1 0x00 0C4F 52 MSTORE 0C50 60 PUSH1 0x32 0C52 60 PUSH1 0x04 0C54 52 MSTORE 0C55 60 PUSH1 0x24 0C57 60 PUSH1 0x00 0C59 FD *REVERT 0C5A 5B JUMPDEST 0C5B 60 PUSH1 0x00 0C5D 83 DUP4 0C5E 83 DUP4 0C5F 83 DUP4 0C60 81 DUP2 0C61 81 DUP2 0C62 10 LT 0C63 61 PUSH2 0x0c7c 0C66 57 *JUMPI 0C67 63 PUSH4 0x4e487b71 0C6C 60 PUSH1 0xe0 0C6E 1B SHL 0C6F 60 PUSH1 0x00 0C71 52 MSTORE 0C72 60 PUSH1 0x32 0C74 60 PUSH1 0x04 0C76 52 MSTORE 0C77 60 PUSH1 0x24 0C79 60 PUSH1 0x00 0C7B FD *REVERT 0C7C 5B JUMPDEST 0C7D 90 SWAP1 0C7E 50 POP 0C7F 60 PUSH1 0x20 0C81 02 MUL 0C82 01 ADD 0C83 35 CALLDATALOAD 0C84 11 GT 0C85 61 PUSH2 0x0cd0 0C88 57 *JUMPI 0C89 60 PUSH1 0x40 0C8B 51 MLOAD 0C8C 62 PUSH3 0x461bcd 0C90 60 PUSH1 0xe5 0C92 1B SHL 0C93 81 DUP2 0C94 52 MSTORE 0C95 60 PUSH1 0x20 0C97 60 PUSH1 0x04 0C99 82 DUP3 0C9A 01 ADD 0C9B 52 MSTORE 0C9C 60 PUSH1 0x1d 0C9E 60 PUSH1 0x24 0CA0 82 DUP3 0CA1 01 ADD 0CA2 52 MSTORE 0CA3 7F PUSH32 0x52656465656d3a20616d6f756e742063616e6e6f74206265207a65726f000000 0CC4 60 PUSH1 0x44 0CC6 82 DUP3 0CC7 01 ADD 0CC8 52 MSTORE 0CC9 60 PUSH1 0x64 0CCB 01 ADD 0CCC 61 PUSH2 0x0809 0CCF 56 *JUMP 0CD0 5B JUMPDEST 0CD1 60 PUSH1 0x0f 0CD3 60 PUSH1 0x00 0CD5 86 DUP7 0CD6 86 DUP7 0CD7 84 DUP5 0CD8 81 DUP2 0CD9 81 DUP2 0CDA 10 LT 0CDB 61 PUSH2 0x0cf4 0CDE 57 *JUMPI 0CDF 63 PUSH4 0x4e487b71 0CE4 60 PUSH1 0xe0 0CE6 1B SHL 0CE7 60 PUSH1 0x00 0CE9 52 MSTORE 0CEA 60 PUSH1 0x32 0CEC 60 PUSH1 0x04 0CEE 52 MSTORE 0CEF 60 PUSH1 0x24 0CF1 60 PUSH1 0x00 0CF3 FD *REVERT 0CF4 5B JUMPDEST 0CF5 90 SWAP1 0CF6 50 POP 0CF7 60 PUSH1 0x20 0CF9 02 MUL 0CFA 01 ADD 0CFB 35 CALLDATALOAD 0CFC 81 DUP2 0CFD 52 MSTORE 0CFE 60 PUSH1 0x20 0D00 01 ADD 0D01 90 SWAP1 0D02 81 DUP2 0D03 52 MSTORE 0D04 60 PUSH1 0x20 0D06 01 ADD 0D07 60 PUSH1 0x00 0D09 20 SHA3 0D0A 60 PUSH1 0x02 0D0C 01 ADD 0D0D 54 SLOAD 0D0E 83 DUP4 0D0F 83 DUP4 0D10 83 DUP4 0D11 81 DUP2 0D12 81 DUP2 0D13 10 LT 0D14 61 PUSH2 0x0d2d 0D17 57 *JUMPI 0D18 63 PUSH4 0x4e487b71 0D1D 60 PUSH1 0xe0 0D1F 1B SHL 0D20 60 PUSH1 0x00 0D22 52 MSTORE 0D23 60 PUSH1 0x32 0D25 60 PUSH1 0x04 0D27 52 MSTORE 0D28 60 PUSH1 0x24 0D2A 60 PUSH1 0x00 0D2C FD *REVERT 0D2D 5B JUMPDEST 0D2E 90 SWAP1 0D2F 50 POP 0D30 60 PUSH1 0x20 0D32 02 MUL 0D33 01 ADD 0D34 35 CALLDATALOAD 0D35 11 GT 0D36 15 ISZERO 0D37 61 PUSH2 0x0d95 0D3A 57 *JUMPI 0D3B 60 PUSH1 0x40 0D3D 51 MLOAD 0D3E 62 PUSH3 0x461bcd 0D42 60 PUSH1 0xe5 0D44 1B SHL 0D45 81 DUP2 0D46 52 MSTORE 0D47 60 PUSH1 0x20 0D49 60 PUSH1 0x04 0D4B 82 DUP3 0D4C 01 ADD 0D4D 52 MSTORE 0D4E 60 PUSH1 0x2a 0D50 60 PUSH1 0x24 0D52 82 DUP3 0D53 01 ADD 0D54 52 MSTORE 0D55 7F PUSH32 0x52656465656d3a206d61782072656465656d20706572207472616e7361637469 0D76 60 PUSH1 0x44 0D78 82 DUP3 0D79 01 ADD 0D7A 52 MSTORE 0D7B 69 PUSH10 0x1bdb881c995858da1959 0D86 60 PUSH1 0xb2 0D88 1B SHL 0D89 60 PUSH1 0x64 0D8B 82 DUP3 0D8C 01 ADD 0D8D 52 MSTORE 0D8E 60 PUSH1 0x84 0D90 01 ADD 0D91 61 PUSH2 0x0809 0D94 56 *JUMP 0D95 5B JUMPDEST 0D96 82 DUP3 0D97 82 DUP3 0D98 82 DUP3 0D99 81 DUP2 0D9A 81 DUP2 0D9B 10 LT 0D9C 61 PUSH2 0x0db5 0D9F 57 *JUMPI 0DA0 63 PUSH4 0x4e487b71 0DA5 60 PUSH1 0xe0 0DA7 1B SHL 0DA8 60 PUSH1 0x00 0DAA 52 MSTORE 0DAB 60 PUSH1 0x32 0DAD 60 PUSH1 0x04 0DAF 52 MSTORE 0DB0 60 PUSH1 0x24 0DB2 60 PUSH1 0x00 0DB4 FD *REVERT 0DB5 5B JUMPDEST 0DB6 60 PUSH1 0x14 0DB8 54 SLOAD 0DB9 60 PUSH1 0x20 0DBB 90 SWAP1 0DBC 91 SWAP2 0DBD 02 MUL 0DBE 92 SWAP3 0DBF 90 SWAP1 0DC0 92 SWAP3 0DC1 01 ADD 0DC2 35 CALLDATALOAD 0DC3 91 SWAP2 0DC4 60 PUSH1 0x01 0DC6 60 PUSH1 0x01 0DC8 60 PUSH1 0xa0 0DCA 1B SHL 0DCB 03 SUB 0DCC 16 AND 0DCD 90 SWAP1 0DCE 50 POP 0DCF 62 PUSH3 0xfdd58e 0DD3 33 CALLER 0DD4 88 DUP9 0DD5 88 DUP9 0DD6 86 DUP7 0DD7 81 DUP2 0DD8 81 DUP2 0DD9 10 LT 0DDA 61 PUSH2 0x0df3 0DDD 57 *JUMPI 0DDE 63 PUSH4 0x4e487b71 0DE3 60 PUSH1 0xe0 0DE5 1B SHL 0DE6 60 PUSH1 0x00 0DE8 52 MSTORE 0DE9 60 PUSH1 0x32 0DEB 60 PUSH1 0x04 0DED 52 MSTORE 0DEE 60 PUSH1 0x24 0DF0 60 PUSH1 0x00 0DF2 FD *REVERT 0DF3 5B JUMPDEST 0DF4 60 PUSH1 0x40 0DF6 51 MLOAD 0DF7 60 PUSH1 0x01 0DF9 60 PUSH1 0x01 0DFB 60 PUSH1 0xe0 0DFD 1B SHL 0DFE 03 SUB 0DFF 19 NOT 0E00 60 PUSH1 0xe0 0E02 87 DUP8 0E03 90 SWAP1 0E04 1B SHL 0E05 16 AND 0E06 81 DUP2 0E07 52 MSTORE 0E08 60 PUSH1 0x01 0E0A 60 PUSH1 0x01 0E0C 60 PUSH1 0xa0 0E0E 1B SHL 0E0F 03 SUB 0E10 90 SWAP1 0E11 94 SWAP5 0E12 16 AND 0E13 60 PUSH1 0x04 0E15 85 DUP6 0E16 01 ADD 0E17 52 MSTORE 0E18 60 PUSH1 0x20 0E1A 02 MUL 0E1B 91 SWAP2 0E1C 90 SWAP1 0E1D 91 SWAP2 0E1E 01 ADD 0E1F 35 CALLDATALOAD 0E20 60 PUSH1 0x24 0E22 83 DUP4 0E23 01 ADD 0E24 52 MSTORE 0E25 50 POP 0E26 60 PUSH1 0x44 0E28 01 ADD 0E29 60 PUSH1 0x20 0E2B 60 PUSH1 0x40 0E2D 51 MLOAD 0E2E 80 DUP1 0E2F 83 DUP4 0E30 03 SUB 0E31 81 DUP2 0E32 86 DUP7 0E33 80 DUP1 0E34 3B EXTCODESIZE 0E35 15 ISZERO 0E36 80 DUP1 0E37 15 ISZERO 0E38 61 PUSH2 0x0e40 0E3B 57 *JUMPI 0E3C 60 PUSH1 0x00 0E3E 80 DUP1 0E3F FD *REVERT 0E40 5B JUMPDEST 0E41 50 POP 0E42 5A GAS 0E43 FA STATICCALL 0E44 15 ISZERO 0E45 80 DUP1 0E46 15 ISZERO 0E47 61 PUSH2 0x0e54 0E4A 57 *JUMPI 0E4B 3D RETURNDATASIZE 0E4C 60 PUSH1 0x00 0E4E 80 DUP1 0E4F 3E RETURNDATACOPY 0E50 3D RETURNDATASIZE 0E51 60 PUSH1 0x00 0E53 FD *REVERT 0E54 5B JUMPDEST 0E55 50 POP 0E56 50 POP 0E57 50 POP 0E58 50 POP 0E59 60 PUSH1 0x40 0E5B 51 MLOAD 0E5C 3D RETURNDATASIZE 0E5D 60 PUSH1 0x1f 0E5F 19 NOT 0E60 60 PUSH1 0x1f 0E62 82 DUP3 0E63 01 ADD 0E64 16 AND 0E65 82 DUP3 0E66 01 ADD 0E67 80 DUP1 0E68 60 PUSH1 0x40 0E6A 52 MSTORE 0E6B 50 POP 0E6C 81 DUP2 0E6D 01 ADD 0E6E 90 SWAP1 0E6F 61 PUSH2 0x0e78 0E72 91 SWAP2 0E73 90 SWAP1 0E74 61 PUSH2 0x33aa 0E77 56 *JUMP 0E78 5B JUMPDEST 0E79 10 LT 0E7A 15 ISZERO 0E7B 61 PUSH2 0x0edc 0E7E 57 *JUMPI 0E7F 60 PUSH1 0x40 0E81 51 MLOAD 0E82 62 PUSH3 0x461bcd 0E86 60 PUSH1 0xe5 0E88 1B SHL 0E89 81 DUP2 0E8A 52 MSTORE 0E8B 60 PUSH1 0x20 0E8D 60 PUSH1 0x04 0E8F 82 DUP3 0E90 01 ADD 0E91 52 MSTORE 0E92 60 PUSH1 0x2d 0E94 60 PUSH1 0x24 0E96 82 DUP3 0E97 01 ADD 0E98 52 MSTORE 0E99 7F PUSH32 0x52656465656d3a20696e73756666696369656e7420616d6f756e74206f66204d 0EBA 60 PUSH1 0x44 0EBC 82 DUP3 0EBD 01 ADD 0EBE 52 MSTORE 0EBF 6C PUSH13 0x696e742050617373706f727473 0ECD 60 PUSH1 0x98 0ECF 1B SHL 0ED0 60 PUSH1 0x64 0ED2 82 DUP3 0ED3 01 ADD 0ED4 52 MSTORE 0ED5 60 PUSH1 0x84 0ED7 01 ADD 0ED8 61 PUSH2 0x0809 0EDB 56 *JUMP 0EDC 5B JUMPDEST 0EDD 60 PUSH1 0x0f 0EDF 60 PUSH1 0x00 0EE1 86 DUP7 0EE2 86 DUP7 0EE3 84 DUP5 0EE4 81 DUP2 0EE5 81 DUP2 0EE6 10 LT 0EE7 61 PUSH2 0x0f00 0EEA 57 *JUMPI 0EEB 63 PUSH4 0x4e487b71 0EF0 60 PUSH1 0xe0 0EF2 1B SHL 0EF3 60 PUSH1 0x00 0EF5 52 MSTORE 0EF6 60 PUSH1 0x32 0EF8 60 PUSH1 0x04 0EFA 52 MSTORE 0EFB 60 PUSH1 0x24 0EFD 60 PUSH1 0x00 0EFF FD *REVERT 0F00 5B JUMPDEST 0F01 90 SWAP1 0F02 50 POP 0F03 60 PUSH1 0x20 0F05 02 MUL 0F06 01 ADD 0F07 35 CALLDATALOAD 0F08 81 DUP2 0F09 52 MSTORE 0F0A 60 PUSH1 0x20 0F0C 01 ADD 0F0D 90 SWAP1 0F0E 81 DUP2 0F0F 52 MSTORE 0F10 60 PUSH1 0x20 0F12 01 ADD 0F13 60 PUSH1 0x00 0F15 20 SHA3 0F16 60 PUSH1 0x00 0F18 01 ADD 0F19 54 SLOAD 0F1A 42 TIMESTAMP 0F1B 11 GT 0F1C 61 PUSH2 0x0f8d 0F1F 57 *JUMPI 0F20 60 PUSH1 0x40 0F22 51 MLOAD 0F23 62 PUSH3 0x461bcd 0F27 60 PUSH1 0xe5 0F29 1B SHL 0F2A 81 DUP2 0F2B 52 MSTORE 0F2C 60 PUSH1 0x20 0F2E 60 PUSH1 0x04 0F30 82 DUP3 0F31 01 ADD 0F32 52 MSTORE 0F33 60 PUSH1 0x38 0F35 60 PUSH1 0x24 0F37 82 DUP3 0F38 01 ADD 0F39 52 MSTORE 0F3A 7F PUSH32 0x52656465656d3a20726564657074696f6e2077696e646f77206e6f74206f7065 0F5B 60 PUSH1 0x44 0F5D 82 DUP3 0F5E 01 ADD 0F5F 52 MSTORE 0F60 7F PUSH32 0x6e20666f722074686973204d696e742050617373706f72740000000000000000 0F81 60 PUSH1 0x64 0F83 82 DUP3 0F84 01 ADD 0F85 52 MSTORE 0F86 60 PUSH1 0x84 0F88 01 ADD 0F89 61 PUSH2 0x0809 0F8C 56 *JUMP 0F8D 5B JUMPDEST 0F8E 60 PUSH1 0x0f 0F90 60 PUSH1 0x00 0F92 86 DUP7 0F93 86 DUP7 0F94 84 DUP5 0F95 81 DUP2 0F96 81 DUP2 0F97 10 LT 0F98 61 PUSH2 0x0fb1 0F9B 57 *JUMPI 0F9C 63 PUSH4 0x4e487b71 0FA1 60 PUSH1 0xe0 0FA3 1B SHL 0FA4 60 PUSH1 0x00 0FA6 52 MSTORE 0FA7 60 PUSH1 0x32 0FA9 60 PUSH1 0x04 0FAB 52 MSTORE 0FAC 60 PUSH1 0x24 0FAE 60 PUSH1 0x00 0FB0 FD *REVERT 0FB1 5B JUMPDEST 0FB2 90 SWAP1 0FB3 50 POP 0FB4 60 PUSH1 0x20 0FB6 02 MUL 0FB7 01 ADD 0FB8 35 CALLDATALOAD 0FB9 81 DUP2 0FBA 52 MSTORE 0FBB 60 PUSH1 0x20 0FBD 01 ADD 0FBE 90 SWAP1 0FBF 81 DUP2 0FC0 52 MSTORE 0FC1 60 PUSH1 0x20 0FC3 01 ADD 0FC4 60 PUSH1 0x00 0FC6 20 SHA3 0FC7 60 PUSH1 0x01 0FC9 01 ADD 0FCA 54 SLOAD 0FCB 42 TIMESTAMP 0FCC 10 LT 0FCD 61 PUSH2 0x103e 0FD0 57 *JUMPI 0FD1 60 PUSH1 0x40 0FD3 51 MLOAD 0FD4 62 PUSH3 0x461bcd 0FD8 60 PUSH1 0xe5 0FDA 1B SHL 0FDB 81 DUP2 0FDC 52 MSTORE 0FDD 60 PUSH1 0x20 0FDF 60 PUSH1 0x04 0FE1 82 DUP3 0FE2 01 ADD 0FE3 52 MSTORE 0FE4 60 PUSH1 0x39 0FE6 60 PUSH1 0x24 0FE8 82 DUP3 0FE9 01 ADD 0FEA 52 MSTORE 0FEB 7F PUSH32 0x52656465656d3a20726564657074696f6e2077696e646f7720697320636c6f73 100C 60 PUSH1 0x44 100E 82 DUP3 100F 01 ADD 1010 52 MSTORE 1011 7F PUSH32 0x656420666f722074686973204d696e742050617373706f727400000000000000 1032 60 PUSH1 0x64 1034 82 DUP3 1035 01 ADD 1036 52 MSTORE 1037 60 PUSH1 0x84 1039 01 ADD 103A 61 PUSH2 0x0809 103D 56 *JUMP 103E 5B JUMPDEST 103F 80 DUP1 1040 61 PUSH2 0x1048 1043 81 DUP2 1044 61 PUSH2 0x37af 1047 56 *JUMP 1048 5B JUMPDEST 1049 91 SWAP2 104A 50 POP 104B 50 POP 104C 61 PUSH2 0x0bb6 104F 56 *JUMP 1050 5B JUMPDEST 1051 50 POP 1052 60 PUSH1 0x40 1054 80 DUP1 1055 51 MLOAD 1056 60 PUSH1 0x20 1058 81 DUP2 1059 01 ADD 105A 90 SWAP1 105B 91 SWAP2 105C 52 MSTORE 105D 60 PUSH1 0x00 105F 80 DUP1 1060 82 DUP3 1061 52 MSTORE 1062 5B JUMPDEST 1063 84 DUP5 1064 81 DUP2 1065 10 LT 1066 15 ISZERO 1067 61 PUSH2 0x12cb 106A 57 *JUMPI 106B 60 PUSH1 0x14 106D 54 SLOAD 106E 60 PUSH1 0x01 1070 60 PUSH1 0x01 1072 60 PUSH1 0xa0 1074 1B SHL 1075 03 SUB 1076 16 AND 1077 63 PUSH4 0x3aeca210 107C 33 CALLER 107D 88 DUP9 107E 88 DUP9 107F 85 DUP6 1080 81 DUP2 1081 81 DUP2 1082 10 LT 1083 61 PUSH2 0x109c 1086 57 *JUMPI 1087 63 PUSH4 0x4e487b71 108C 60 PUSH1 0xe0 108E 1B SHL 108F 60 PUSH1 0x00 1091 52 MSTORE 1092 60 PUSH1 0x32 1094 60 PUSH1 0x04 1096 52 MSTORE 1097 60 PUSH1 0x24 1099 60 PUSH1 0x00 109B FD *REVERT 109C 5B JUMPDEST 109D 90 SWAP1 109E 50 POP 109F 60 PUSH1 0x20 10A1 02 MUL 10A2 01 ADD 10A3 35 CALLDATALOAD 10A4 87 DUP8 10A5 87 DUP8 10A6 86 DUP7 10A7 81 DUP2 10A8 81 DUP2 10A9 10 LT 10AA 61 PUSH2 0x10c3 10AD 57 *JUMPI 10AE 63 PUSH4 0x4e487b71 10B3 60 PUSH1 0xe0 10B5 1B SHL 10B6 60 PUSH1 0x00 10B8 52 MSTORE 10B9 60 PUSH1 0x32 10BB 60 PUSH1 0x04 10BD 52 MSTORE 10BE 60 PUSH1 0x24 10C0 60 PUSH1 0x00 10C2 FD *REVERT 10C3 5B JUMPDEST 10C4 60 PUSH1 0x40 10C6 51 MLOAD 10C7 60 PUSH1 0x01 10C9 60 PUSH1 0x01 10CB 60 PUSH1 0xe0 10CD 1B SHL 10CE 03 SUB 10CF 19 NOT 10D0 60 PUSH1 0xe0 10D2 88 DUP9 10D3 90 SWAP1 10D4 1B SHL 10D5 16 AND 10D6 81 DUP2 10D7 52 MSTORE 10D8 60 PUSH1 0x01 10DA 60 PUSH1 0x01 10DC 60 PUSH1 0xa0 10DE 1B SHL 10DF 03 SUB 10E0 90 SWAP1 10E1 95 SWAP6 10E2 16 AND 10E3 60 PUSH1 0x04 10E5 86 DUP7 10E6 01 ADD 10E7 52 MSTORE 10E8 60 PUSH1 0x24 10EA 85 DUP6 10EB 01 ADD 10EC 93 SWAP4 10ED 90 SWAP1 10EE 93 SWAP4 10EF 52 MSTORE 10F0 50 POP 10F1 60 PUSH1 0x20 10F3 90 SWAP1 10F4 91 SWAP2 10F5 02 MUL 10F6 01 ADD 10F7 35 CALLDATALOAD 10F8 60 PUSH1 0x44 10FA 82 DUP3 10FB 01 ADD 10FC 52 MSTORE 10FD 60 PUSH1 0x64 10FF 01 ADD 1100 60 PUSH1 0x00 1102 60 PUSH1 0x40 1104 51 MLOAD 1105 80 DUP1 1106 83 DUP4 1107 03 SUB 1108 81 DUP2 1109 60 PUSH1 0x00 110B 87 DUP8 110C 80 DUP1 110D 3B EXTCODESIZE 110E 15 ISZERO 110F 80 DUP1 1110 15 ISZERO 1111 61 PUSH2 0x1119 1114 57 *JUMPI 1115 60 PUSH1 0x00 1117 80 DUP1 1118 FD *REVERT 1119 5B JUMPDEST 111A 50 POP 111B 5A GAS 111C F1 CALL 111D 15 ISZERO 111E 80 DUP1 111F 15 ISZERO 1120 61 PUSH2 0x112d 1123 57 *JUMPI 1124 3D RETURNDATASIZE 1125 60 PUSH1 0x00 1127 80 DUP1 1128 3E RETURNDATACOPY 1129 3D RETURNDATASIZE 112A 60 PUSH1 0x00 112C FD *REVERT 112D 5B JUMPDEST 112E 50 POP 112F 50 POP 1130 50 POP 1131 50 POP 1132 60 PUSH1 0x00 1134 5B JUMPDEST 1135 84 DUP5 1136 84 DUP5 1137 83 DUP4 1138 81 DUP2 1139 81 DUP2 113A 10 LT 113B 61 PUSH2 0x1154 113E 57 *JUMPI 113F 63 PUSH4 0x4e487b71 1144 60 PUSH1 0xe0 1146 1B SHL 1147 60 PUSH1 0x00 1149 52 MSTORE 114A 60 PUSH1 0x32 114C 60 PUSH1 0x04 114E 52 MSTORE 114F 60 PUSH1 0x24 1151 60 PUSH1 0x00 1153 FD *REVERT 1154 5B JUMPDEST 1155 90 SWAP1 1156 50 POP 1157 60 PUSH1 0x20 1159 02 MUL 115A 01 ADD 115B 35 CALLDATALOAD 115C 81 DUP2 115D 10 LT 115E 15 ISZERO 115F 61 PUSH2 0x1279 1162 57 *JUMPI 1163 61 PUSH2 0x11a4 1166 33 CALLER 1167 88 DUP9 1168 88 DUP9 1169 85 DUP6 116A 81 DUP2 116B 81 DUP2 116C 10 LT 116D 61 PUSH2 0x1186 1170 57 *JUMPI 1171 63 PUSH4 0x4e487b71 1176 60 PUSH1 0xe0 1178 1B SHL 1179 60 PUSH1 0x00 117B 52 MSTORE 117C 60 PUSH1 0x32 117E 60 PUSH1 0x04 1180 52 MSTORE 1181 60 PUSH1 0x24 1183 60 PUSH1 0x00 1185 FD *REVERT 1186 5B JUMPDEST 1187 90 SWAP1 1188 50 POP 1189 60 PUSH1 0x20 118B 02 MUL 118C 01 ADD 118D 35 CALLDATALOAD 118E 60 PUSH1 0x00 1190 14 EQ 1191 61 PUSH2 0x119c 1194 57 *JUMPI 1195 60 PUSH1 0x0d 1197 54 SLOAD 1198 61 PUSH2 0x2460 119B 56 *JUMP 119C 5B JUMPDEST 119D 60 PUSH1 0x0c 119F 54 SLOAD 11A0 61 PUSH2 0x2460 11A3 56 *JUMP 11A4 5B JUMPDEST 11A5 82 DUP3 11A6 87 DUP8 11A7 87 DUP8 11A8 84 DUP5 11A9 81 DUP2 11AA 81 DUP2 11AB 10 LT 11AC 61 PUSH2 0x11c5 11AF 57 *JUMPI 11B0 63 PUSH4 0x4e487b71 11B5 60 PUSH1 0xe0 11B7 1B SHL 11B8 60 PUSH1 0x00 11BA 52 MSTORE 11BB 60 PUSH1 0x32 11BD 60 PUSH1 0x04 11BF 52 MSTORE 11C0 60 PUSH1 0x24 11C2 60 PUSH1 0x00 11C4 FD *REVERT 11C5 5B JUMPDEST 11C6 90 SWAP1 11C7 50 POP 11C8 60 PUSH1 0x20 11CA 02 MUL 11CB 01 ADD 11CC 35 CALLDATALOAD 11CD 60 PUSH1 0x00 11CF 14 EQ 11D0 61 PUSH2 0x11e9 11D3 57 *JUMPI 11D4 61 PUSH2 0x11e4 11D7 61 PUSH2 0x11df 11DA 60 PUSH1 0x0d 11DC 54 SLOAD 11DD 90 SWAP1 11DE 56 *JUMP 11DF 5B JUMPDEST 11E0 61 PUSH2 0x247a 11E3 56 *JUMP 11E4 5B JUMPDEST 11E5 61 PUSH2 0x11f5 11E8 56 *JUMP 11E9 5B JUMPDEST 11EA 61 PUSH2 0x11f5 11ED 61 PUSH2 0x11df 11F0 60 PUSH1 0x0c 11F2 54 SLOAD 11F3 90 SWAP1 11F4 56 *JUMP 11F5 5B JUMPDEST 11F6 60 PUSH1 0x40 11F8 51 MLOAD 11F9 60 PUSH1 0x20 11FB 01 ADD 11FC 61 PUSH2 0x1206 11FF 92 SWAP3 1200 91 SWAP2 1201 90 SWAP1 1202 61 PUSH2 0x3483 1205 56 *JUMP 1206 5B JUMPDEST 1207 60 PUSH1 0x40 1209 51 MLOAD 120A 60 PUSH1 0x20 120C 81 DUP2 120D 83 DUP4 120E 03 SUB 120F 03 SUB 1210 81 DUP2 1211 52 MSTORE 1212 90 SWAP1 1213 60 PUSH1 0x40 1215 52 MSTORE 1216 92 SWAP3 1217 50 POP 1218 86 DUP7 1219 86 DUP7 121A 83 DUP4 121B 81 DUP2 121C 81 DUP2 121D 10 LT 121E 61 PUSH2 0x1237 1221 57 *JUMPI 1222 63 PUSH4 0x4e487b71 1227 60 PUSH1 0xe0 1229 1B SHL 122A 60 PUSH1 0x00 122C 52 MSTORE 122D 60 PUSH1 0x32 122F 60 PUSH1 0x04 1231 52 MSTORE 1232 60 PUSH1 0x24 1234 60 PUSH1 0x00 1236 FD *REVERT 1237 5B JUMPDEST 1238 90 SWAP1 1239 50 POP 123A 60 PUSH1 0x20 123C 02 MUL 123D 01 ADD 123E 35 CALLDATALOAD 123F 60 PUSH1 0x00 1241 14 EQ 1242 15 ISZERO 1243 61 PUSH2 0x1259 1246 57 *JUMPI 1247 61 PUSH2 0x1254 124A 60 PUSH1 0x0c 124C 80 DUP1 124D 54 SLOAD 124E 60 PUSH1 0x01 1250 01 ADD 1251 90 SWAP1 1252 55 SSTORE 1253 56 *JUMP 1254 5B JUMPDEST 1255 61 PUSH2 0x1267 1258 56 *JUMP 1259 5B JUMPDEST 125A 61 PUSH2 0x1267 125D 60 PUSH1 0x0d 125F 80 DUP1 1260 54 SLOAD 1261 60 PUSH1 0x01 1263 01 ADD 1264 90 SWAP1 1265 55 SSTORE 1266 56 *JUMP 1267 5B JUMPDEST 1268 80 DUP1 1269 61 PUSH2 0x1271 126C 81 DUP2 126D 61 PUSH2 0x37af 1270 56 *JUMP 1271 5B JUMPDEST 1272 91 SWAP2 1273 50 POP 1274 50 POP 1275 61 PUSH2 0x1134 1278 56 *JUMP 1279 5B JUMPDEST 127A 50 POP 127B 61 PUSH2 0x12b9 127E 60 PUSH1 0x40 1280 51 MLOAD 1281 80 DUP1 1282 60 PUSH1 0x40 1284 01 ADD 1285 60 PUSH1 0x40 1287 52 MSTORE 1288 80 DUP1 1289 60 PUSH1 0x17 128B 81 DUP2 128C 52 MSTORE 128D 60 PUSH1 0x20 128F 01 ADD 1290 7F PUSH32 0x6e657720746f6b656e204944732072656465656d65643a000000000000000000 12B1 81 DUP2 12B2 52 MSTORE 12B3 50 POP 12B4 83 DUP4 12B5 61 PUSH2 0x2594 12B8 56 *JUMP 12B9 5B JUMPDEST 12BA 80 DUP1 12BB 61 PUSH2 0x12c3 12BE 81 DUP2 12BF 61 PUSH2 0x37af 12C2 56 *JUMP 12C3 5B JUMPDEST 12C4 91 SWAP2 12C5 50 POP 12C6 50 POP 12C7 61 PUSH2 0x1062 12CA 56 *JUMP 12CB 5B JUMPDEST 12CC 50 POP 12CD 33 CALLER 12CE 60 PUSH1 0x01 12D0 60 PUSH1 0x01 12D2 60 PUSH1 0xa0 12D4 1B SHL 12D5 03 SUB 12D6 16 AND 12D7 7F PUSH32 0xb2dcce7cfa3c79295325596a77d05aea7f6a0e73cc5fdebec4138151f90117a1 12F8 82 DUP3 12F9 60 PUSH1 0x40 12FB 51 MLOAD 12FC 61 PUSH2 0x1305 12FF 91 SWAP2 1300 90 SWAP1 1301 61 PUSH2 0x3570 1304 56 *JUMP 1305 5B JUMPDEST 1306 60 PUSH1 0x40 1308 51 MLOAD 1309 80 DUP1 130A 91 SWAP2 130B 03 SUB 130C 90 SWAP1 130D A2 LOG2 130E 50 POP 130F 50 POP 1310 50 POP 1311 50 POP 1312 50 POP 1313 56 *JUMP label_1314: // Incoming jump from 0x1D53 // Incoming jump from 0x03EB // Incoming jump from 0x1D32 // Inputs[4] // { // @1317 stack[-2] // @1322 memory[0x00:0x40] // @1326 storage[0x01 + keccak256(memory[0x00:0x40])] // @132B msg.sender // } 1314 5B JUMPDEST 1315 60 PUSH1 0x00 1317 82 DUP3 1318 81 DUP2 1319 52 MSTORE 131A 60 PUSH1 0x06 131C 60 PUSH1 0x20 131E 52 MSTORE 131F 60 PUSH1 0x40 1321 90 SWAP1 1322 20 SHA3 1323 60 PUSH1 0x01 1325 01 ADD 1326 54 SLOAD 1327 61 PUSH2 0x1330 132A 81 DUP2 132B 33 CALLER 132C 61 PUSH2 0x25d9 132F 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1319 memory[0x00:0x20] = stack[-2] // @131E memory[0x20:0x40] = 0x06 // @1326 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1327 stack[1] = 0x1330 // @132A stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // @132B stack[3] = msg.sender // } // Block ends with call to 0x25d9, returns to 0x1330 label_1330: // Incoming return from call to 0x25D9 at 0x132F // Inputs[2] // { // @1334 stack[-3] // @1335 stack[-2] // } 1330 5B JUMPDEST 1331 61 PUSH2 0x093f 1334 83 DUP4 1335 83 DUP4 1336 61 PUSH2 0x263d 1339 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1331 stack[0] = 0x093f // @1334 stack[1] = stack[-3] // @1335 stack[2] = stack[-2] // } // Block ends with call to 0x263d, returns to 0x093F label_133A: // Incoming jump from 0x03FE // Inputs[1] { @1340 stack[-2] } 133A 5B JUMPDEST 133B 60 PUSH1 0x00 133D 61 PUSH2 0x1345 1340 83 DUP4 1341 61 PUSH2 0x16f9 1344 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @133B stack[0] = 0x00 // @133D stack[1] = 0x1345 // @1340 stack[2] = stack[-2] // } // Block ends with call to 0x16f9, returns to 0x1345 label_1345: // Incoming return from call to 0x16F9 at 0x1344 // Inputs[2] // { // @1346 stack[-3] // @1347 stack[-1] // } 1345 5B JUMPDEST 1346 82 DUP3 1347 10 LT 1348 61 PUSH2 0x13a7 134B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13a7, if stack[-3] < stack[-1] label_134C: // Incoming jump from 0x134B, if not stack[-3] < stack[-1] // Inputs[1] { @134E memory[0x40:0x60] } 134C 60 PUSH1 0x40 134E 51 MLOAD 134F 62 PUSH3 0x461bcd 1353 60 PUSH1 0xe5 1355 1B SHL 1356 81 DUP2 1357 52 MSTORE 1358 60 PUSH1 0x20 135A 60 PUSH1 0x04 135C 82 DUP3 135D 01 ADD 135E 52 MSTORE 135F 60 PUSH1 0x2b 1361 60 PUSH1 0x24 1363 82 DUP3 1364 01 ADD 1365 52 MSTORE 1366 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 1387 60 PUSH1 0x44 1389 82 DUP3 138A 01 ADD 138B 52 MSTORE 138C 6A PUSH11 0x74206f6620626f756e6473 1398 60 PUSH1 0xa8 139A 1B SHL 139B 60 PUSH1 0x64 139D 82 DUP3 139E 01 ADD 139F 52 MSTORE 13A0 60 PUSH1 0x84 13A2 01 ADD 13A3 61 PUSH2 0x0809 13A6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1357 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @135E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1365 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @138B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @139F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x74206f6620626f756e6473 << 0xa8 // @13A2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_13A7: // Incoming jump from 0x134B, if stack[-3] < stack[-1] // Inputs[6] // { // @13B1 stack[-3] // @13B2 stack[-2] // @13C5 memory[0x00:0x40] // @13CC memory[0x00:0x40] // @13CD storage[keccak256(memory[0x00:0x40])] // @13CE stack[-4] // } 13A7 5B JUMPDEST 13A8 50 POP 13A9 60 PUSH1 0x01 13AB 60 PUSH1 0x01 13AD 60 PUSH1 0xa0 13AF 1B SHL 13B0 03 SUB 13B1 91 SWAP2 13B2 90 SWAP1 13B3 91 SWAP2 13B4 16 AND 13B5 60 PUSH1 0x00 13B7 90 SWAP1 13B8 81 DUP2 13B9 52 MSTORE 13BA 60 PUSH1 0x07 13BC 60 PUSH1 0x20 13BE 90 SWAP1 13BF 81 DUP2 13C0 52 MSTORE 13C1 60 PUSH1 0x40 13C3 80 DUP1 13C4 83 DUP4 13C5 20 SHA3 13C6 93 SWAP4 13C7 83 DUP4 13C8 52 MSTORE 13C9 92 SWAP3 13CA 90 SWAP1 13CB 52 MSTORE 13CC 20 SHA3 13CD 54 SLOAD 13CE 90 SWAP1 13CF 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @13B9 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @13C0 memory[0x20:0x40] = 0x07 // @13C8 memory[0x00:0x20] = stack[-2] // @13CB memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13CE stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_13D0: // Incoming jump from 0x0411 // Inputs[2] // { // @13D3 storage[0x0b] // @13E3 msg.sender // } 13D0 5B JUMPDEST 13D1 60 PUSH1 0x0b 13D3 54 SLOAD 13D4 60 PUSH1 0x01 13D6 60 PUSH1 0x01 13D8 60 PUSH1 0xa0 13DA 1B SHL 13DB 03 SUB 13DC 61 PUSH2 0x0100 13DF 90 SWAP1 13E0 91 SWAP2 13E1 04 DIV 13E2 16 AND 13E3 33 CALLER 13E4 14 EQ 13E5 61 PUSH2 0x1400 13E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1400, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_13E9: // Incoming jump from 0x13E8, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @13EB memory[0x40:0x60] } 13E9 60 PUSH1 0x40 13EB 51 MLOAD 13EC 62 PUSH3 0x461bcd 13F0 60 PUSH1 0xe5 13F2 1B SHL 13F3 81 DUP2 13F4 52 MSTORE 13F5 60 PUSH1 0x04 13F7 01 ADD 13F8 61 PUSH2 0x0809 13FB 90 SWAP1 13FC 61 PUSH2 0x3649 13FF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13FB stack[0] = 0x0809 // @13FB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_1400: // Incoming jump from 0x13E8, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1401 stack[-1] // @1402 memory[stack[-1]:stack[-1] + 0x20] // } 1400 5B JUMPDEST 1401 80 DUP1 1402 51 MLOAD 1403 61 PUSH2 0x1413 1406 90 SWAP1 1407 60 PUSH1 0x11 1409 90 SWAP1 140A 60 PUSH1 0x20 140C 84 DUP5 140D 01 ADD 140E 90 SWAP1 140F 61 PUSH2 0x2faa 1412 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1406 stack[0] = 0x1413 // @1409 stack[1] = 0x11 // @140E stack[2] = stack[-1] + 0x20 // @140E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2faa label_1413: // Incoming jump from 0x1D3C, if !(0x01 == stack[-1]) // Incoming return from call to 0x1CF0 at 0x14AD // Incoming jump from 0x264B, if stack[-1] // Incoming jump from 0x25E7, if stack[-1] // Incoming jump from 0x26D2, if !stack[-1] // Incoming jump from 0x14B7, if !(0x01 == stack[-1]) // Incoming return from call to 0x1CF0 at 0x14CE // Incoming return from call to 0x26C3 at 0x1490 // Inputs[1] { @1416 stack[-3] } 1413 5B JUMPDEST 1414 50 POP 1415 50 POP 1416 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1417: // Incoming jump from 0x0437 // Inputs[2] // { // @1420 stack[-1] // @1422 msg.sender // } 1417 5B JUMPDEST 1418 60 PUSH1 0x01 141A 60 PUSH1 0x01 141C 60 PUSH1 0xa0 141E 1B SHL 141F 03 SUB 1420 81 DUP2 1421 16 AND 1422 33 CALLER 1423 14 EQ 1424 61 PUSH2 0x1487 1427 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1487, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 label_1428: // Incoming jump from 0x1427, if not msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @142A memory[0x40:0x60] } 1428 60 PUSH1 0x40 142A 51 MLOAD 142B 62 PUSH3 0x461bcd 142F 60 PUSH1 0xe5 1431 1B SHL 1432 81 DUP2 1433 52 MSTORE 1434 60 PUSH1 0x20 1436 60 PUSH1 0x04 1438 82 DUP3 1439 01 ADD 143A 52 MSTORE 143B 60 PUSH1 0x2f 143D 60 PUSH1 0x24 143F 82 DUP3 1440 01 ADD 1441 52 MSTORE 1442 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 1463 60 PUSH1 0x44 1465 82 DUP3 1466 01 ADD 1467 52 MSTORE 1468 6E PUSH15 0x103937b632b9903337b91039b2b633 1478 60 PUSH1 0x89 147A 1B SHL 147B 60 PUSH1 0x64 147D 82 DUP3 147E 01 ADD 147F 52 MSTORE 1480 60 PUSH1 0x84 1482 01 ADD 1483 61 PUSH2 0x0809 1486 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1433 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @143A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1441 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @1467 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @147F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103937b632b9903337b91039b2b633 << 0x89 // @1482 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_1487: // Incoming jump from 0x1427, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @148B stack[-2] // @148C stack[-1] // } 1487 5B JUMPDEST 1488 61 PUSH2 0x1413 148B 82 DUP3 148C 82 DUP3 148D 61 PUSH2 0x26c3 1490 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1488 stack[0] = 0x1413 // @148B stack[1] = stack[-2] // @148C stack[2] = stack[-1] // } // Block ends with call to 0x26c3, returns to 0x1413 label_1491: // Incoming jump from 0x0494 // Inputs[1] { @1492 stack[-1] } 1491 5B JUMPDEST 1492 80 DUP1 1493 61 PUSH2 0x14ae 1496 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ae, if stack[-1] label_1497: // Incoming jump from 0x1496, if not stack[-1] // Inputs[3] // { // @149D memory[0x00:0x20] // @14A6 memory[0x00:0x20] // @14A9 stack[-2] // } 1497 61 PUSH2 0x1413 149A 60 PUSH1 0x00 149C 80 DUP1 149D 51 MLOAD 149E 60 PUSH1 0x20 14A0 61 PUSH2 0x3837 14A3 83 DUP4 14A4 39 CODECOPY 14A5 81 DUP2 14A6 51 MLOAD 14A7 91 SWAP2 14A8 52 MSTORE 14A9 83 DUP4 14AA 61 PUSH2 0x1cf0 14AD 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1497 stack[0] = 0x1413 // @14A4 memory[0x00:0x20] = code[0x3837:0x3857] // @14A7 stack[1] = memory[0x00:0x20] // @14A8 memory[0x00:0x20] = memory[0x00:0x20] // @14A9 stack[2] = stack[-2] // } // Block ends with call to 0x1cf0, returns to 0x1413 label_14AE: // Incoming jump from 0x1496, if stack[-1] // Inputs[1] { @14AF stack[-1] } 14AE 5B JUMPDEST 14AF 80 DUP1 14B0 60 PUSH1 0x01 14B2 14 EQ 14B3 15 ISZERO 14B4 61 PUSH2 0x1413 14B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1413, if !(0x01 == stack[-1]) label_14B8: // Incoming jump from 0x14B7, if not !(0x01 == stack[-1]) // Inputs[3] // { // @14BE memory[0x00:0x20] // @14C7 memory[0x00:0x20] // @14CA stack[-2] // } 14B8 61 PUSH2 0x1413 14BB 60 PUSH1 0x00 14BD 80 DUP1 14BE 51 MLOAD 14BF 60 PUSH1 0x20 14C1 61 PUSH2 0x3857 14C4 83 DUP4 14C5 39 CODECOPY 14C6 81 DUP2 14C7 51 MLOAD 14C8 91 SWAP2 14C9 52 MSTORE 14CA 83 DUP4 14CB 61 PUSH2 0x1cf0 14CE 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @14B8 stack[0] = 0x1413 // @14C5 memory[0x00:0x20] = code[0x3857:0x3877] // @14C8 stack[1] = memory[0x00:0x20] // @14C9 memory[0x00:0x20] = memory[0x00:0x20] // @14CA stack[2] = stack[-2] // } // Block ends with call to 0x1cf0, returns to 0x1413 label_14CF: // Incoming call from 0x04B1, returns to 0x0356 // Inputs[2] // { // @14D2 storage[0x0b] // @14E2 msg.sender // } 14CF 5B JUMPDEST 14D0 60 PUSH1 0x0b 14D2 54 SLOAD 14D3 60 PUSH1 0x01 14D5 60 PUSH1 0x01 14D7 60 PUSH1 0xa0 14D9 1B SHL 14DA 03 SUB 14DB 61 PUSH2 0x0100 14DE 90 SWAP1 14DF 91 SWAP2 14E0 04 DIV 14E1 16 AND 14E2 33 CALLER 14E3 14 EQ 14E4 61 PUSH2 0x14ff 14E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ff, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_14E8: // Incoming jump from 0x14E7, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14EA memory[0x40:0x60] } 14E8 60 PUSH1 0x40 14EA 51 MLOAD 14EB 62 PUSH3 0x461bcd 14EF 60 PUSH1 0xe5 14F1 1B SHL 14F2 81 DUP2 14F3 52 MSTORE 14F4 60 PUSH1 0x04 14F6 01 ADD 14F7 61 PUSH2 0x0809 14FA 90 SWAP1 14FB 61 PUSH2 0x3649 14FE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14FA stack[0] = 0x0809 // @14FA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_14FF: // Incoming jump from 0x14E7, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 14FF 5B JUMPDEST 1500 61 PUSH2 0x1507 1503 61 PUSH2 0x272a 1506 56 *JUMP // Stack delta = +1 // Outputs[1] { @1500 stack[0] = 0x1507 } // Block ends with call to 0x272a, returns to 0x1507 label_1507: // Incoming return from call to 0x2864 at 0x17B9 // Incoming return from call to 0x272A at 0x1506 // Incoming return from call to 0x28BE at 0x17F1 // Inputs[1] { @1508 stack[-1] } 1507 5B JUMPDEST 1508 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1509: // Incoming jump from 0x04C4 // Inputs[4] // { // @150D stack[-3] // @150E stack[-2] // @150F stack[-1] // @1512 memory[0x40:0x60] // } 1509 5B JUMPDEST 150A 61 PUSH2 0x093f 150D 83 DUP4 150E 83 DUP4 150F 83 DUP4 1510 60 PUSH1 0x40 1512 51 MLOAD 1513 80 DUP1 1514 60 PUSH1 0x20 1516 01 ADD 1517 60 PUSH1 0x40 1519 52 MSTORE 151A 80 DUP1 151B 60 PUSH1 0x00 151D 81 DUP2 151E 52 MSTORE 151F 50 POP 1520 61 PUSH2 0x1a96 1523 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @150A stack[0] = 0x093f // @150D stack[1] = stack[-3] // @150E stack[2] = stack[-2] // @150F stack[3] = stack[-1] // @1512 stack[4] = memory[0x40:0x60] // @1519 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @151E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1a96 label_1524: // Incoming jump from 0x04D7 // Inputs[1] { @1528 msg.sender } 1524 5B JUMPDEST 1525 61 PUSH2 0x152d 1528 33 CALLER 1529 61 PUSH2 0x0a6a 152C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1525 stack[0] = 0x152d // @1528 stack[1] = msg.sender // } // Block ends with call to 0x0a6a, returns to 0x152D label_152D: // Incoming return from call to 0x0A6A at 0x152C // Inputs[1] { @1531 stack[-1] } 152D 5B JUMPDEST 152E 61 PUSH2 0x1592 1531 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1592, if stack[-1] label_1532: // Incoming jump from 0x1531, if not stack[-1] // Inputs[1] { @1534 memory[0x40:0x60] } 1532 60 PUSH1 0x40 1534 51 MLOAD 1535 62 PUSH3 0x461bcd 1539 60 PUSH1 0xe5 153B 1B SHL 153C 81 DUP2 153D 52 MSTORE 153E 60 PUSH1 0x20 1540 60 PUSH1 0x04 1542 82 DUP3 1543 01 ADD 1544 52 MSTORE 1545 60 PUSH1 0x30 1547 60 PUSH1 0x24 1549 82 DUP3 154A 01 ADD 154B 52 MSTORE 154C 7F PUSH32 0x4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f77 156D 60 PUSH1 0x44 156F 82 DUP3 1570 01 ADD 1571 52 MSTORE 1572 6F PUSH16 0x1b995c881b9bdc88185c1c1c9bdd9959 1583 60 PUSH1 0x82 1585 1B SHL 1586 60 PUSH1 0x64 1588 82 DUP3 1589 01 ADD 158A 52 MSTORE 158B 60 PUSH1 0x84 158D 01 ADD 158E 61 PUSH2 0x0809 1591 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @153D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1544 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @154B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x30 // @1571 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f77 // @158A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1b995c881b9bdc88185c1c1c9bdd9959 << 0x82 // @158D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_1592: // Incoming jump from 0x1531, if stack[-1] // Inputs[1] { @1596 stack[-1] } 1592 5B JUMPDEST 1593 61 PUSH2 0x159b 1596 81 DUP2 1597 61 PUSH2 0x27bd 159A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1593 stack[0] = 0x159b // @1596 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x27bd label_159B: // Incoming return from call to 0x2864 at 0x1E72 // Incoming jump from 0x3831, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x23EC at 0x23EB // Inputs[1] { @159D stack[-2] } 159B 5B JUMPDEST 159C 50 POP 159D 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_159E: // Incoming jump from 0x04EA // Inputs[1] { @15A6 storage[0x09] } 159E 5B JUMPDEST 159F 60 PUSH1 0x00 15A1 61 PUSH2 0x15a9 15A4 60 PUSH1 0x09 15A6 54 SLOAD 15A7 90 SWAP1 15A8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @159F stack[0] = 0x00 // @15A7 stack[1] = storage[0x09] // } // Block ends with unconditional jump to 0x15a9 label_15A9: // Incoming jump from 0x15A8 // Inputs[2] // { // @15AA stack[-3] // @15AB stack[-1] // } 15A9 5B JUMPDEST 15AA 82 DUP3 15AB 10 LT 15AC 61 PUSH2 0x160c 15AF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x160c, if stack[-3] < stack[-1] label_15B0: // Incoming jump from 0x15AF, if not stack[-3] < stack[-1] // Inputs[1] { @15B2 memory[0x40:0x60] } 15B0 60 PUSH1 0x40 15B2 51 MLOAD 15B3 62 PUSH3 0x461bcd 15B7 60 PUSH1 0xe5 15B9 1B SHL 15BA 81 DUP2 15BB 52 MSTORE 15BC 60 PUSH1 0x20 15BE 60 PUSH1 0x04 15C0 82 DUP3 15C1 01 ADD 15C2 52 MSTORE 15C3 60 PUSH1 0x2c 15C5 60 PUSH1 0x24 15C7 82 DUP3 15C8 01 ADD 15C9 52 MSTORE 15CA 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 15EB 60 PUSH1 0x44 15ED 82 DUP3 15EE 01 ADD 15EF 52 MSTORE 15F0 6B PUSH12 0x7574206f6620626f756e6473 15FD 60 PUSH1 0xa0 15FF 1B SHL 1600 60 PUSH1 0x64 1602 82 DUP3 1603 01 ADD 1604 52 MSTORE 1605 60 PUSH1 0x84 1607 01 ADD 1608 61 PUSH2 0x0809 160B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @15BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15C2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15C9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @15EF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @1604 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7574206f6620626f756e6473 << 0xa0 // @1607 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_160C: // Incoming jump from 0x15AF, if stack[-3] < stack[-1] // Inputs[2] // { // @160F stack[-2] // @1611 storage[0x09] // } 160C 5B JUMPDEST 160D 60 PUSH1 0x09 160F 82 DUP3 1610 81 DUP2 1611 54 SLOAD 1612 81 DUP2 1613 10 LT 1614 61 PUSH2 0x162d 1617 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @160D stack[0] = 0x09 // @160F stack[1] = stack[-2] // } // Block ends with conditional jump to 0x162d, if stack[-2] < storage[0x09] label_1618: // Incoming jump from 0x1617, if not stack[-2] < storage[0x09] // Inputs[1] { @162C memory[0x00:0x24] } 1618 63 PUSH4 0x4e487b71 161D 60 PUSH1 0xe0 161F 1B SHL 1620 60 PUSH1 0x00 1622 52 MSTORE 1623 60 PUSH1 0x32 1625 60 PUSH1 0x04 1627 52 MSTORE 1628 60 PUSH1 0x24 162A 60 PUSH1 0x00 162C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1622 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1627 memory[0x04:0x24] = 0x32 // @162C revert(memory[0x00:0x24]); // } // Block terminates label_162D: // Incoming jump from 0x1617, if stack[-2] < storage[0x09] // Inputs[7] // { // @162E stack[-2] // @162E stack[-1] // @1636 memory[0x00:0x20] // @1638 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @1639 stack[-3] // @163B stack[-5] // @163C stack[-4] // } 162D 5B JUMPDEST 162E 90 SWAP1 162F 60 PUSH1 0x00 1631 52 MSTORE 1632 60 PUSH1 0x20 1634 60 PUSH1 0x00 1636 20 SHA3 1637 01 ADD 1638 54 SLOAD 1639 90 SWAP1 163A 50 POP 163B 91 SWAP2 163C 90 SWAP1 163D 50 POP 163E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1631 memory[0x00:0x20] = stack[-2] // @163B stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_163F: // Incoming jump from 0x04FD // Inputs[2] // { // @1642 storage[0x0b] // @1652 msg.sender // } 163F 5B JUMPDEST 1640 60 PUSH1 0x0b 1642 54 SLOAD 1643 60 PUSH1 0x01 1645 60 PUSH1 0x01 1647 60 PUSH1 0xa0 1649 1B SHL 164A 03 SUB 164B 61 PUSH2 0x0100 164E 90 SWAP1 164F 91 SWAP2 1650 04 DIV 1651 16 AND 1652 33 CALLER 1653 14 EQ 1654 61 PUSH2 0x166f 1657 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x166f, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1658: // Incoming jump from 0x1657, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @165A memory[0x40:0x60] } 1658 60 PUSH1 0x40 165A 51 MLOAD 165B 62 PUSH3 0x461bcd 165F 60 PUSH1 0xe5 1661 1B SHL 1662 81 DUP2 1663 52 MSTORE 1664 60 PUSH1 0x04 1666 01 ADD 1667 61 PUSH2 0x0809 166A 90 SWAP1 166B 61 PUSH2 0x3649 166E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1663 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @166A stack[0] = 0x0809 // @166A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_166F: // Incoming jump from 0x1657, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1670 stack[-1] // @1671 memory[stack[-1]:stack[-1] + 0x20] // } 166F 5B JUMPDEST 1670 80 DUP1 1671 51 MLOAD 1672 61 PUSH2 0x1413 1675 90 SWAP1 1676 60 PUSH1 0x10 1678 90 SWAP1 1679 60 PUSH1 0x20 167B 84 DUP5 167C 01 ADD 167D 90 SWAP1 167E 61 PUSH2 0x2faa 1681 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1675 stack[0] = 0x1413 // @1678 stack[1] = 0x10 // @167D stack[2] = stack[-1] + 0x20 // @167D stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2faa label_1682: // Incoming call from 0x20FC, returns to 0x20FD // Incoming call from 0x223F, returns to 0x2240 // Incoming call from 0x27C7, returns to 0x27C8 // Incoming jump from 0x051B // Incoming call from 0x0838, returns to 0x0839 // Incoming call from 0x21B9, returns to 0x21BA // Inputs[3] // { // @1685 stack[-1] // @1690 memory[0x00:0x40] // @1691 storage[keccak256(memory[0x00:0x40])] // } 1682 5B JUMPDEST 1683 60 PUSH1 0x00 1685 81 DUP2 1686 81 DUP2 1687 52 MSTORE 1688 60 PUSH1 0x02 168A 60 PUSH1 0x20 168C 52 MSTORE 168D 60 PUSH1 0x40 168F 81 DUP2 1690 20 SHA3 1691 54 SLOAD 1692 60 PUSH1 0x01 1694 60 PUSH1 0x01 1696 60 PUSH1 0xa0 1698 1B SHL 1699 03 SUB 169A 16 AND 169B 80 DUP1 169C 61 PUSH2 0x06fc 169F 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1683 stack[0] = 0x00 // @1687 memory[0x00:0x20] = stack[-1] // @168C memory[0x20:0x40] = 0x02 // @169A stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x06fc, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_16A0: // Incoming jump from 0x169F, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @16A2 memory[0x40:0x60] } 16A0 60 PUSH1 0x40 16A2 51 MLOAD 16A3 62 PUSH3 0x461bcd 16A7 60 PUSH1 0xe5 16A9 1B SHL 16AA 81 DUP2 16AB 52 MSTORE 16AC 60 PUSH1 0x20 16AE 60 PUSH1 0x04 16B0 82 DUP3 16B1 01 ADD 16B2 52 MSTORE 16B3 60 PUSH1 0x29 16B5 60 PUSH1 0x24 16B7 82 DUP3 16B8 01 ADD 16B9 52 MSTORE 16BA 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 16DB 60 PUSH1 0x44 16DD 82 DUP3 16DE 01 ADD 16DF 52 MSTORE 16E0 68 PUSH9 0x32b73a103a37b5b2b7 16EA 60 PUSH1 0xb9 16EC 1B SHL 16ED 60 PUSH1 0x64 16EF 82 DUP3 16F0 01 ADD 16F1 52 MSTORE 16F2 60 PUSH1 0x84 16F4 01 ADD 16F5 61 PUSH2 0x0809 16F8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @16AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16B2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @16DF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @16F1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @16F4 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_16F9: // Incoming call from 0x2F70, returns to 0x2F71 // Incoming jump from 0x052E // Incoming call from 0x2DFC, returns to 0x2DFD // Incoming call from 0x1344, returns to 0x1345 // Inputs[1] { @1704 stack[-1] } 16F9 5B JUMPDEST 16FA 60 PUSH1 0x00 16FC 60 PUSH1 0x01 16FE 60 PUSH1 0x01 1700 60 PUSH1 0xa0 1702 1B SHL 1703 03 SUB 1704 82 DUP3 1705 16 AND 1706 61 PUSH2 0x1764 1709 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16FA stack[0] = 0x00 } // Block ends with conditional jump to 0x1764, if stack[-1] & (0x01 << 0xa0) - 0x01 label_170A: // Incoming jump from 0x1709, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @170C memory[0x40:0x60] } 170A 60 PUSH1 0x40 170C 51 MLOAD 170D 62 PUSH3 0x461bcd 1711 60 PUSH1 0xe5 1713 1B SHL 1714 81 DUP2 1715 52 MSTORE 1716 60 PUSH1 0x20 1718 60 PUSH1 0x04 171A 82 DUP3 171B 01 ADD 171C 52 MSTORE 171D 60 PUSH1 0x2a 171F 60 PUSH1 0x24 1721 82 DUP3 1722 01 ADD 1723 52 MSTORE 1724 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 1745 60 PUSH1 0x44 1747 82 DUP3 1748 01 ADD 1749 52 MSTORE 174A 69 PUSH10 0x726f2061646472657373 1755 60 PUSH1 0xb0 1757 1B SHL 1758 60 PUSH1 0x64 175A 82 DUP3 175B 01 ADD 175C 52 MSTORE 175D 60 PUSH1 0x84 175F 01 ADD 1760 61 PUSH2 0x0809 1763 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1715 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @171C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1723 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1749 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @175C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f2061646472657373 << 0xb0 // @175F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_1764: // Incoming jump from 0x1709, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @176E stack[-2] // @177C memory[0x00:0x40] // @177D storage[keccak256(memory[0x00:0x40])] // @177E stack[-3] // } 1764 5B JUMPDEST 1765 50 POP 1766 60 PUSH1 0x01 1768 60 PUSH1 0x01 176A 60 PUSH1 0xa0 176C 1B SHL 176D 03 SUB 176E 16 AND 176F 60 PUSH1 0x00 1771 90 SWAP1 1772 81 DUP2 1773 52 MSTORE 1774 60 PUSH1 0x03 1776 60 PUSH1 0x20 1778 52 MSTORE 1779 60 PUSH1 0x40 177B 90 SWAP1 177C 20 SHA3 177D 54 SLOAD 177E 90 SWAP1 177F 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1773 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1778 memory[0x20:0x40] = 0x03 // @177E stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1780: // Incoming call from 0x0536, returns to 0x0356 // Inputs[2] // { // @1783 storage[0x0b] // @1793 msg.sender // } 1780 5B JUMPDEST 1781 60 PUSH1 0x0b 1783 54 SLOAD 1784 60 PUSH1 0x01 1786 60 PUSH1 0x01 1788 60 PUSH1 0xa0 178A 1B SHL 178B 03 SUB 178C 61 PUSH2 0x0100 178F 90 SWAP1 1790 91 SWAP2 1791 04 DIV 1792 16 AND 1793 33 CALLER 1794 14 EQ 1795 61 PUSH2 0x17b0 1798 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17b0, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1799: // Incoming jump from 0x1798, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @179B memory[0x40:0x60] } 1799 60 PUSH1 0x40 179B 51 MLOAD 179C 62 PUSH3 0x461bcd 17A0 60 PUSH1 0xe5 17A2 1B SHL 17A3 81 DUP2 17A4 52 MSTORE 17A5 60 PUSH1 0x04 17A7 01 ADD 17A8 61 PUSH2 0x0809 17AB 90 SWAP1 17AC 61 PUSH2 0x3649 17AF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17AB stack[0] = 0x0809 // @17AB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_17B0: // Incoming jump from 0x1798, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 17B0 5B JUMPDEST 17B1 61 PUSH2 0x1507 17B4 60 PUSH1 0x00 17B6 61 PUSH2 0x2864 17B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @17B1 stack[0] = 0x1507 // @17B4 stack[1] = 0x00 // } // Block ends with call to 0x2864, returns to 0x1507 label_17BA: // Incoming call from 0x053E, returns to 0x0356 // Inputs[2] // { // @17BD storage[0x0b] // @17CD msg.sender // } 17BA 5B JUMPDEST 17BB 60 PUSH1 0x0b 17BD 54 SLOAD 17BE 60 PUSH1 0x01 17C0 60 PUSH1 0x01 17C2 60 PUSH1 0xa0 17C4 1B SHL 17C5 03 SUB 17C6 61 PUSH2 0x0100 17C9 90 SWAP1 17CA 91 SWAP2 17CB 04 DIV 17CC 16 AND 17CD 33 CALLER 17CE 14 EQ 17CF 61 PUSH2 0x17ea 17D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17ea, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_17D3: // Incoming jump from 0x17D2, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @17D5 memory[0x40:0x60] } 17D3 60 PUSH1 0x40 17D5 51 MLOAD 17D6 62 PUSH3 0x461bcd 17DA 60 PUSH1 0xe5 17DC 1B SHL 17DD 81 DUP2 17DE 52 MSTORE 17DF 60 PUSH1 0x04 17E1 01 ADD 17E2 61 PUSH2 0x0809 17E5 90 SWAP1 17E6 61 PUSH2 0x3649 17E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17E5 stack[0] = 0x0809 // @17E5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_17EA: // Incoming jump from 0x17D2, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 17EA 5B JUMPDEST 17EB 61 PUSH2 0x1507 17EE 61 PUSH2 0x28be 17F1 56 *JUMP // Stack delta = +1 // Outputs[1] { @17EB stack[0] = 0x1507 } // Block ends with call to 0x28be, returns to 0x1507 label_17F2: // Incoming jump from 0x0551 // Inputs[2] // { // @17F5 storage[0x0b] // @1805 msg.sender // } 17F2 5B JUMPDEST 17F3 60 PUSH1 0x0b 17F5 54 SLOAD 17F6 60 PUSH1 0x01 17F8 60 PUSH1 0x01 17FA 60 PUSH1 0xa0 17FC 1B SHL 17FD 03 SUB 17FE 61 PUSH2 0x0100 1801 90 SWAP1 1802 91 SWAP2 1803 04 DIV 1804 16 AND 1805 33 CALLER 1806 14 EQ 1807 61 PUSH2 0x1822 180A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1822, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_180B: // Incoming jump from 0x180A, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @180D memory[0x40:0x60] } 180B 60 PUSH1 0x40 180D 51 MLOAD 180E 62 PUSH3 0x461bcd 1812 60 PUSH1 0xe5 1814 1B SHL 1815 81 DUP2 1816 52 MSTORE 1817 60 PUSH1 0x04 1819 01 ADD 181A 61 PUSH2 0x0809 181D 90 SWAP1 181E 61 PUSH2 0x3649 1821 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1816 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @181D stack[0] = 0x0809 // @181D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_1822: // Incoming jump from 0x180A, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1825 stack[-1] // @1826 stack[-2] // } 1822 5B JUMPDEST 1823 60 PUSH1 0x13 1825 55 SSTORE 1826 56 *JUMP // Stack delta = -2 // Outputs[1] { @1825 storage[0x13] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1827: // Incoming call from 0x2646, returns to 0x2647 // Incoming call from 0x26CC, returns to 0x26CD // Incoming jump from 0x057A // Incoming call from 0x1870, returns to 0x1871 // Incoming call from 0x095B, returns to 0x095C // Incoming call from 0x18B9, returns to 0x18BA // Incoming call from 0x1898, returns to 0x1871 // Incoming call from 0x25E2, returns to 0x25E3 // Inputs[6] // { // @182A stack[-2] // @1838 memory[0x00:0x40] // @1841 stack[-1] // @184B memory[0x00:0x40] // @184C storage[keccak256(memory[0x00:0x40])] // @1850 stack[-3] // } 1827 5B JUMPDEST 1828 60 PUSH1 0x00 182A 91 SWAP2 182B 82 DUP3 182C 52 MSTORE 182D 60 PUSH1 0x06 182F 60 PUSH1 0x20 1831 90 SWAP1 1832 81 DUP2 1833 52 MSTORE 1834 60 PUSH1 0x40 1836 80 DUP1 1837 84 DUP5 1838 20 SHA3 1839 60 PUSH1 0x01 183B 60 PUSH1 0x01 183D 60 PUSH1 0xa0 183F 1B SHL 1840 03 SUB 1841 93 SWAP4 1842 90 SWAP1 1843 93 SWAP4 1844 16 AND 1845 84 DUP5 1846 52 MSTORE 1847 91 SWAP2 1848 90 SWAP1 1849 52 MSTORE 184A 90 SWAP1 184B 20 SHA3 184C 54 SLOAD 184D 60 PUSH1 0xff 184F 16 AND 1850 90 SWAP1 1851 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @182C memory[0x00:0x20] = stack[-2] // @1833 memory[0x20:0x40] = 0x06 // @1846 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1849 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1850 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1852: // Incoming jump from 0x058D // Inputs[1] { @1855 stack[-1] } 1852 5B JUMPDEST 1853 60 PUSH1 0x00 1855 81 DUP2 1856 61 PUSH2 0x1878 1859 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1853 stack[0] = 0x00 } // Block ends with conditional jump to 0x1878, if stack[-1] label_185A: // Incoming jump from 0x1859, if not stack[-1] // Inputs[3] // { // @1860 memory[0x00:0x20] // @1869 memory[0x00:0x20] // @186C stack[-3] // } 185A 61 PUSH2 0x1871 185D 60 PUSH1 0x00 185F 80 DUP1 1860 51 MLOAD 1861 60 PUSH1 0x20 1863 61 PUSH2 0x3837 1866 83 DUP4 1867 39 CODECOPY 1868 81 DUP2 1869 51 MLOAD 186A 91 SWAP2 186B 52 MSTORE 186C 84 DUP5 186D 61 PUSH2 0x1827 1870 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @185A stack[0] = 0x1871 // @1867 memory[0x00:0x20] = code[0x3837:0x3857] // @186A stack[1] = memory[0x00:0x20] // @186B memory[0x00:0x20] = memory[0x00:0x20] // @186C stack[2] = stack[-3] // } // Block ends with call to 0x1827, returns to 0x1871 label_1871: // Incoming return from call to 0x1827 at 0x1898 // Incoming return from call to 0x1827 at 0x1870 // Inputs[2] // { // @1872 stack[-2] // @1872 stack[-1] // } 1871 5B JUMPDEST 1872 90 SWAP1 1873 50 POP 1874 61 PUSH2 0x06fc 1877 56 *JUMP // Stack delta = -1 // Outputs[1] { @1872 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x06fc label_1878: // Incoming jump from 0x1859, if stack[-1] // Inputs[1] { @1879 stack[-2] } 1878 5B JUMPDEST 1879 81 DUP2 187A 60 PUSH1 0x01 187C 14 EQ 187D 15 ISZERO 187E 61 PUSH2 0x1899 1881 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1899, if !(0x01 == stack[-2]) label_1882: // Incoming jump from 0x1881, if not !(0x01 == stack[-2]) // Inputs[3] // { // @1888 memory[0x00:0x20] // @1891 memory[0x00:0x20] // @1894 stack[-3] // } 1882 61 PUSH2 0x1871 1885 60 PUSH1 0x00 1887 80 DUP1 1888 51 MLOAD 1889 60 PUSH1 0x20 188B 61 PUSH2 0x3857 188E 83 DUP4 188F 39 CODECOPY 1890 81 DUP2 1891 51 MLOAD 1892 91 SWAP2 1893 52 MSTORE 1894 84 DUP5 1895 61 PUSH2 0x1827 1898 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1882 stack[0] = 0x1871 // @188F memory[0x00:0x20] = code[0x3857:0x3877] // @1892 stack[1] = memory[0x00:0x20] // @1893 memory[0x00:0x20] = memory[0x00:0x20] // @1894 stack[2] = stack[-3] // } // Block ends with call to 0x1827, returns to 0x1871 label_1899: // Incoming jump from 0x1881, if !(0x01 == stack[-2]) // Inputs[2] // { // @189D stack[-4] // @189E stack[-3] // } 1899 5B JUMPDEST 189A 50 POP 189B 60 PUSH1 0x00 189D 92 SWAP3 189E 91 SWAP2 189F 50 POP 18A0 50 POP 18A1 56 *JUMP // Stack delta = -3 // Outputs[1] { @189D stack[-4] = 0x00 } // Block ends with unconditional jump to stack[-4] label_18A2: // Incoming jump from 0x05A0 // Inputs[3] // { // @18A9 memory[0x00:0x20] // @18B2 memory[0x00:0x20] // @18B5 msg.sender // } 18A2 5B JUMPDEST 18A3 61 PUSH2 0x18ba 18A6 60 PUSH1 0x00 18A8 80 DUP1 18A9 51 MLOAD 18AA 60 PUSH1 0x20 18AC 61 PUSH2 0x3857 18AF 83 DUP4 18B0 39 CODECOPY 18B1 81 DUP2 18B2 51 MLOAD 18B3 91 SWAP2 18B4 52 MSTORE 18B5 33 CALLER 18B6 61 PUSH2 0x1827 18B9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @18A3 stack[0] = 0x18ba // @18B0 memory[0x00:0x20] = code[0x3857:0x3877] // @18B3 stack[1] = memory[0x00:0x20] // @18B4 memory[0x00:0x20] = memory[0x00:0x20] // @18B5 stack[2] = msg.sender // } // Block ends with call to 0x1827, returns to 0x18BA label_18BA: // Incoming return from call to 0x1827 at 0x18B9 // Inputs[1] { @18BE stack[-1] } 18BA 5B JUMPDEST 18BB 61 PUSH2 0x18c3 18BE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18c3, if stack[-1] label_18BF: // Incoming jump from 0x18BE, if not stack[-1] // Inputs[1] { @18C2 memory[0x00:0x00] } 18BF 60 PUSH1 0x00 18C1 80 DUP1 18C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @18C2 revert(memory[0x00:0x00]); } // Block terminates label_18C3: // Incoming jump from 0x18BE, if stack[-1] // Inputs[2] // { // @18C4 stack[-1] // @18C5 memory[stack[-1]:stack[-1] + 0x20] // } 18C3 5B JUMPDEST 18C4 80 DUP1 18C5 51 MLOAD 18C6 61 PUSH2 0x1413 18C9 90 SWAP1 18CA 60 PUSH1 0x12 18CC 90 SWAP1 18CD 60 PUSH1 0x20 18CF 84 DUP5 18D0 01 ADD 18D1 90 SWAP1 18D2 61 PUSH2 0x2faa 18D5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18C9 stack[0] = 0x1413 // @18CC stack[1] = 0x12 // @18D1 stack[2] = stack[-1] + 0x20 // @18D1 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2faa label_18D6: // Incoming call from 0x05A8, returns to 0x030B // Inputs[1] { @18DC storage[0x01] } 18D6 5B JUMPDEST 18D7 60 PUSH1 0x60 18D9 60 PUSH1 0x01 18DB 80 DUP1 18DC 54 SLOAD 18DD 61 PUSH2 0x0711 18E0 90 SWAP1 18E1 61 PUSH2 0x3774 18E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18D7 stack[0] = 0x60 // @18D9 stack[1] = 0x01 // @18E0 stack[2] = 0x0711 // @18E0 stack[3] = storage[0x01] // } // Block ends with call to 0x3774, returns to 0x0711 label_18E5: // Incoming jump from 0x05C3 // Inputs[2] // { // @18EE stack[-2] // @18F0 msg.sender // } 18E5 5B JUMPDEST 18E6 60 PUSH1 0x01 18E8 60 PUSH1 0x01 18EA 60 PUSH1 0xa0 18EC 1B SHL 18ED 03 SUB 18EE 82 DUP3 18EF 16 AND 18F0 33 CALLER 18F1 14 EQ 18F2 15 ISZERO 18F3 61 PUSH2 0x193e 18F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x193e, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_18F7: // Incoming jump from 0x18F6, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @18F9 memory[0x40:0x60] } 18F7 60 PUSH1 0x40 18F9 51 MLOAD 18FA 62 PUSH3 0x461bcd 18FE 60 PUSH1 0xe5 1900 1B SHL 1901 81 DUP2 1902 52 MSTORE 1903 60 PUSH1 0x20 1905 60 PUSH1 0x04 1907 82 DUP3 1908 01 ADD 1909 52 MSTORE 190A 60 PUSH1 0x19 190C 60 PUSH1 0x24 190E 82 DUP3 190F 01 ADD 1910 52 MSTORE 1911 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 1932 60 PUSH1 0x44 1934 82 DUP3 1935 01 ADD 1936 52 MSTORE 1937 60 PUSH1 0x64 1939 01 ADD 193A 61 PUSH2 0x0809 193D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1902 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1909 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1910 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1936 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @1939 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_193E: // Incoming jump from 0x18F6, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @193F msg.sender // @1950 memory[0x00:0x40] // @1959 stack[-2] // @1964 memory[0x00:0x40] // @1966 storage[keccak256(memory[0x00:0x40])] // @196B stack[-1] // @1975 memory[0x40:0x60] // @19A1 memory[0x40:0x60] // @19A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @19A9 stack[-3] // } 193E 5B JUMPDEST 193F 33 CALLER 1940 60 PUSH1 0x00 1942 81 DUP2 1943 81 DUP2 1944 52 MSTORE 1945 60 PUSH1 0x05 1947 60 PUSH1 0x20 1949 90 SWAP1 194A 81 DUP2 194B 52 MSTORE 194C 60 PUSH1 0x40 194E 80 DUP1 194F 83 DUP4 1950 20 SHA3 1951 60 PUSH1 0x01 1953 60 PUSH1 0x01 1955 60 PUSH1 0xa0 1957 1B SHL 1958 03 SUB 1959 87 DUP8 195A 16 AND 195B 80 DUP1 195C 85 DUP6 195D 52 MSTORE 195E 90 SWAP1 195F 83 DUP4 1960 52 MSTORE 1961 92 SWAP3 1962 81 DUP2 1963 90 SWAP1 1964 20 SHA3 1965 80 DUP1 1966 54 SLOAD 1967 60 PUSH1 0xff 1969 19 NOT 196A 16 AND 196B 86 DUP7 196C 15 ISZERO 196D 15 ISZERO 196E 90 SWAP1 196F 81 DUP2 1970 17 OR 1971 90 SWAP1 1972 91 SWAP2 1973 55 SSTORE 1974 90 SWAP1 1975 51 MLOAD 1976 90 SWAP1 1977 81 DUP2 1978 52 MSTORE 1979 91 SWAP2 197A 92 SWAP3 197B 91 SWAP2 197C 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 199D 91 SWAP2 199E 01 ADD 199F 60 PUSH1 0x40 19A1 51 MLOAD 19A2 80 DUP1 19A3 91 SWAP2 19A4 03 SUB 19A5 90 SWAP1 19A6 A3 LOG3 19A7 50 POP 19A8 50 POP 19A9 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1944 memory[0x00:0x20] = msg.sender // @194B memory[0x20:0x40] = 0x05 // @195D memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1960 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1973 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1978 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @19A6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_19AA: // Incoming jump from 0x05D6 // Inputs[2] // { // @19AD storage[0x0b] // @19BD msg.sender // } 19AA 5B JUMPDEST 19AB 60 PUSH1 0x0b 19AD 54 SLOAD 19AE 60 PUSH1 0x01 19B0 60 PUSH1 0x01 19B2 60 PUSH1 0xa0 19B4 1B SHL 19B5 03 SUB 19B6 61 PUSH2 0x0100 19B9 90 SWAP1 19BA 91 SWAP2 19BB 04 DIV 19BC 16 AND 19BD 33 CALLER 19BE 14 EQ 19BF 61 PUSH2 0x19da 19C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19da, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_19C3: // Incoming jump from 0x19C2, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @19C5 memory[0x40:0x60] } 19C3 60 PUSH1 0x40 19C5 51 MLOAD 19C6 62 PUSH3 0x461bcd 19CA 60 PUSH1 0xe5 19CC 1B SHL 19CD 81 DUP2 19CE 52 MSTORE 19CF 60 PUSH1 0x04 19D1 01 ADD 19D2 61 PUSH2 0x0809 19D5 90 SWAP1 19D6 61 PUSH2 0x3649 19D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19D5 stack[0] = 0x0809 // @19D5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_19DA: // Incoming jump from 0x19C2, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @19DD stack[-2] // @19E7 stack[-1] // @19E9 memory[0x00:0x40] // @19EE stack[-3] // } 19DA 5B JUMPDEST 19DB 60 PUSH1 0x00 19DD 91 SWAP2 19DE 82 DUP3 19DF 52 MSTORE 19E0 60 PUSH1 0x0f 19E2 60 PUSH1 0x20 19E4 52 MSTORE 19E5 60 PUSH1 0x40 19E7 90 SWAP1 19E8 91 SWAP2 19E9 20 SHA3 19EA 60 PUSH1 0x02 19EC 01 ADD 19ED 55 SSTORE 19EE 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @19DF memory[0x00:0x20] = stack[-2] // @19E4 memory[0x20:0x40] = 0x0f // @19ED storage[0x02 + keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_19EF: // Incoming jump from 0x05E9 // Inputs[3] // { // @19F7 stack[-1] // @19FD memory[0x00:0x40] // @19FF storage[keccak256(memory[0x00:0x40])] // } 19EF 5B JUMPDEST 19F0 60 PUSH1 0x0e 19F2 60 PUSH1 0x20 19F4 52 MSTORE 19F5 60 PUSH1 0x00 19F7 90 SWAP1 19F8 81 DUP2 19F9 52 MSTORE 19FA 60 PUSH1 0x40 19FC 90 SWAP1 19FD 20 SHA3 19FE 80 DUP1 19FF 54 SLOAD 1A00 81 DUP2 1A01 90 SWAP1 1A02 61 PUSH2 0x1a0a 1A05 90 SWAP1 1A06 61 PUSH2 0x3774 1A09 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @19F4 memory[0x20:0x40] = 0x0e // @19F9 memory[0x00:0x20] = stack[-1] // @19FD stack[-1] = keccak256(memory[0x00:0x40]) // @1A01 stack[0] = keccak256(memory[0x00:0x40]) // @1A05 stack[2] = storage[keccak256(memory[0x00:0x40])] // @1A05 stack[1] = 0x1a0a // } // Block ends with call to 0x3774, returns to 0x1A0A label_1A0A: // Incoming return from call to 0x3774 at 0x1A09 // Inputs[4] // { // @1A0B stack[-1] // @1A1A memory[0x40:0x60] // @1A22 stack[-2] // @1A2D storage[stack[-2]] // } 1A0A 5B JUMPDEST 1A0B 80 DUP1 1A0C 60 PUSH1 0x1f 1A0E 01 ADD 1A0F 60 PUSH1 0x20 1A11 80 DUP1 1A12 91 SWAP2 1A13 04 DIV 1A14 02 MUL 1A15 60 PUSH1 0x20 1A17 01 ADD 1A18 60 PUSH1 0x40 1A1A 51 MLOAD 1A1B 90 SWAP1 1A1C 81 DUP2 1A1D 01 ADD 1A1E 60 PUSH1 0x40 1A20 52 MSTORE 1A21 80 DUP1 1A22 92 SWAP3 1A23 91 SWAP2 1A24 90 SWAP1 1A25 81 DUP2 1A26 81 DUP2 1A27 52 MSTORE 1A28 60 PUSH1 0x20 1A2A 01 ADD 1A2B 82 DUP3 1A2C 80 DUP1 1A2D 54 SLOAD 1A2E 61 PUSH2 0x1a36 1A31 90 SWAP1 1A32 61 PUSH2 0x3774 1A35 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1A20 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1A22 stack[-2] = memory[0x40:0x60] // @1A23 stack[-1] = stack[-2] // @1A24 stack[0] = stack[-1] // @1A27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1A2A stack[1] = 0x20 + memory[0x40:0x60] // @1A2B stack[2] = stack[-2] // @1A31 stack[4] = storage[stack[-2]] // @1A31 stack[3] = 0x1a36 // } // Block ends with call to 0x3774, returns to 0x1A36 label_1A36: // Incoming return from call to 0x3774 at 0x1A35 // Inputs[1] { @1A37 stack[-1] } 1A36 5B JUMPDEST 1A37 80 DUP1 1A38 15 ISZERO 1A39 61 PUSH2 0x1a83 1A3C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a83, if !stack[-1] label_1A3D: // Incoming jump from 0x1A3C, if not !stack[-1] // Inputs[1] { @1A3D stack[-1] } 1A3D 80 DUP1 1A3E 60 PUSH1 0x1f 1A40 10 LT 1A41 61 PUSH2 0x1a58 1A44 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a58, if 0x1f < stack[-1] label_1A45: // Incoming jump from 0x1A44, if not 0x1f < stack[-1] // Inputs[4] // { // @1A49 stack[-2] // @1A4A storage[stack[-2]] // @1A4D stack[-3] // @1A4F stack[-1] // } 1A45 61 PUSH2 0x0100 1A48 80 DUP1 1A49 83 DUP4 1A4A 54 SLOAD 1A4B 04 DIV 1A4C 02 MUL 1A4D 83 DUP4 1A4E 52 MSTORE 1A4F 91 SWAP2 1A50 60 PUSH1 0x20 1A52 01 ADD 1A53 91 SWAP2 1A54 61 PUSH2 0x1a83 1A57 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1A4E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1A53 stack[-1] = stack[-1] // @1A53 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1a83 label_1A58: // Incoming jump from 0x1A44, if 0x1f < stack[-1] // Inputs[5] // { // @1A59 stack[-3] // @1A5A stack[-1] // @1A5C stack[-2] // @1A64 memory[0x00:0x20] // @1A68 storage[keccak256(memory[0x00:0x20])] // } 1A58 5B JUMPDEST 1A59 82 DUP3 1A5A 01 ADD 1A5B 91 SWAP2 1A5C 90 SWAP1 1A5D 60 PUSH1 0x00 1A5F 52 MSTORE 1A60 60 PUSH1 0x20 1A62 60 PUSH1 0x00 1A64 20 SHA3 1A65 90 SWAP1 1A66 5B JUMPDEST 1A67 81 DUP2 1A68 54 SLOAD 1A69 81 DUP2 1A6A 52 MSTORE 1A6B 90 SWAP1 1A6C 60 PUSH1 0x01 1A6E 01 ADD 1A6F 90 SWAP1 1A70 60 PUSH1 0x20 1A72 01 ADD 1A73 80 DUP1 1A74 83 DUP4 1A75 11 GT 1A76 61 PUSH2 0x1a66 1A79 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1A5B stack[-3] = stack[-3] + stack[-1] // @1A5F memory[0x00:0x20] = stack[-2] // @1A6A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1A6F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1A72 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1a66, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1A7A: // Incoming jump from 0x1A79, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1A79, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1A7A stack[-3] // @1A7B stack[-1] // } 1A7A 82 DUP3 1A7B 90 SWAP1 1A7C 03 SUB 1A7D 60 PUSH1 0x1f 1A7F 16 AND 1A80 82 DUP3 1A81 01 ADD 1A82 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1A82 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1A82 stack[-1] = stack[-3] // } // Block continues label_1A83: // Incoming jump from 0x1A57 // Incoming jump from 0x1A82 // Incoming jump from 0x1A3C, if !stack[-1] // Inputs[5] // { // @1A89 stack[-4] // @1A8A stack[-7] // @1A8C storage[stack[-7] + 0x01] // @1A8D stack[-6] // @1A94 stack[-8] // } 1A83 5B JUMPDEST 1A84 50 POP 1A85 50 POP 1A86 50 POP 1A87 60 PUSH1 0x01 1A89 90 SWAP1 1A8A 93 SWAP4 1A8B 01 ADD 1A8C 54 SLOAD 1A8D 91 SWAP2 1A8E 92 SWAP3 1A8F 50 POP 1A90 50 POP 1A91 60 PUSH1 0xff 1A93 16 AND 1A94 82 DUP3 1A95 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1A8E stack[-7] = stack[-6] // @1A93 stack[-6] = 0xff & storage[stack[-7] + 0x01] // } // Block ends with unconditional jump to stack[-8] label_1A96: // Incoming jump from 0x060A // Incoming jump from 0x1523 // Inputs[2] // { // @1A9A msg.sender // @1A9B stack[-2] // } 1A96 5B JUMPDEST 1A97 61 PUSH2 0x1aa0 1A9A 33 CALLER 1A9B 83 DUP4 1A9C 61 PUSH2 0x2136 1A9F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A97 stack[0] = 0x1aa0 // @1A9A stack[1] = msg.sender // @1A9B stack[2] = stack[-2] // } // Block ends with call to 0x2136, returns to 0x1AA0 label_1AA0: // Incoming return from call to 0x2136 at 0x1A9F // Inputs[1] { @1AA4 stack[-1] } 1AA0 5B JUMPDEST 1AA1 61 PUSH2 0x1abc 1AA4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1abc, if stack[-1] label_1AA5: // Incoming jump from 0x1AA4, if not stack[-1] // Inputs[1] { @1AA7 memory[0x40:0x60] } 1AA5 60 PUSH1 0x40 1AA7 51 MLOAD 1AA8 62 PUSH3 0x461bcd 1AAC 60 PUSH1 0xe5 1AAE 1B SHL 1AAF 81 DUP2 1AB0 52 MSTORE 1AB1 60 PUSH1 0x04 1AB3 01 ADD 1AB4 61 PUSH2 0x0809 1AB7 90 SWAP1 1AB8 61 PUSH2 0x367e 1ABB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1AB0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1AB7 stack[0] = 0x0809 // @1AB7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x367e, returns to 0x0809 label_1ABC: // Incoming jump from 0x1AA4, if stack[-1] // Inputs[4] // { // @1AC0 stack[-4] // @1AC1 stack[-3] // @1AC2 stack[-2] // @1AC3 stack[-1] // } 1ABC 5B JUMPDEST 1ABD 61 PUSH2 0x1ac8 1AC0 84 DUP5 1AC1 84 DUP5 1AC2 84 DUP5 1AC3 84 DUP5 1AC4 61 PUSH2 0x2939 1AC7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1ABD stack[0] = 0x1ac8 // @1AC0 stack[1] = stack[-4] // @1AC1 stack[2] = stack[-3] // @1AC2 stack[3] = stack[-2] // @1AC3 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x2939 label_1AC8: // Incoming jump from 0x3754, if !(stack[-1] > stack[-4]) // Inputs[1] { @1ACD stack[-5] } 1AC8 5B JUMPDEST 1AC9 50 POP 1ACA 50 POP 1ACB 50 POP 1ACC 50 POP 1ACD 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1ACE: // Incoming call from 0x0612, returns to 0x030B // Inputs[1] { @1AD2 storage[0x12] } 1ACE 5B JUMPDEST 1ACF 60 PUSH1 0x12 1AD1 80 DUP1 1AD2 54 SLOAD 1AD3 61 PUSH2 0x1adb 1AD6 90 SWAP1 1AD7 61 PUSH2 0x3774 1ADA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1ACF stack[0] = 0x12 // @1AD6 stack[1] = 0x1adb // @1AD6 stack[2] = storage[0x12] // } // Block ends with call to 0x3774, returns to 0x1ADB label_1ADB: // Incoming return from call to 0x3774 at 0x1ADA // Inputs[4] // { // @1ADC stack[-1] // @1AEB memory[0x40:0x60] // @1AF3 stack[-2] // @1AFE storage[stack[-2]] // } 1ADB 5B JUMPDEST 1ADC 80 DUP1 1ADD 60 PUSH1 0x1f 1ADF 01 ADD 1AE0 60 PUSH1 0x20 1AE2 80 DUP1 1AE3 91 SWAP2 1AE4 04 DIV 1AE5 02 MUL 1AE6 60 PUSH1 0x20 1AE8 01 ADD 1AE9 60 PUSH1 0x40 1AEB 51 MLOAD 1AEC 90 SWAP1 1AED 81 DUP2 1AEE 01 ADD 1AEF 60 PUSH1 0x40 1AF1 52 MSTORE 1AF2 80 DUP1 1AF3 92 SWAP3 1AF4 91 SWAP2 1AF5 90 SWAP1 1AF6 81 DUP2 1AF7 81 DUP2 1AF8 52 MSTORE 1AF9 60 PUSH1 0x20 1AFB 01 ADD 1AFC 82 DUP3 1AFD 80 DUP1 1AFE 54 SLOAD 1AFF 61 PUSH2 0x1b07 1B02 90 SWAP1 1B03 61 PUSH2 0x3774 1B06 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1AF1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1AF3 stack[-2] = memory[0x40:0x60] // @1AF4 stack[-1] = stack[-2] // @1AF5 stack[0] = stack[-1] // @1AF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1AFB stack[1] = 0x20 + memory[0x40:0x60] // @1AFC stack[2] = stack[-2] // @1B02 stack[4] = storage[stack[-2]] // @1B02 stack[3] = 0x1b07 // } // Block ends with call to 0x3774, returns to 0x1B07 label_1B07: // Incoming return from call to 0x3774 at 0x1B06 // Inputs[1] { @1B08 stack[-1] } 1B07 5B JUMPDEST 1B08 80 DUP1 1B09 15 ISZERO 1B0A 61 PUSH2 0x1b54 1B0D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b54, if !stack[-1] label_1B0E: // Incoming jump from 0x1B0D, if not !stack[-1] // Inputs[1] { @1B0E stack[-1] } 1B0E 80 DUP1 1B0F 60 PUSH1 0x1f 1B11 10 LT 1B12 61 PUSH2 0x1b29 1B15 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b29, if 0x1f < stack[-1] label_1B16: // Incoming jump from 0x1B15, if not 0x1f < stack[-1] // Inputs[4] // { // @1B1A stack[-2] // @1B1B storage[stack[-2]] // @1B1E stack[-3] // @1B20 stack[-1] // } 1B16 61 PUSH2 0x0100 1B19 80 DUP1 1B1A 83 DUP4 1B1B 54 SLOAD 1B1C 04 DIV 1B1D 02 MUL 1B1E 83 DUP4 1B1F 52 MSTORE 1B20 91 SWAP2 1B21 60 PUSH1 0x20 1B23 01 ADD 1B24 91 SWAP2 1B25 61 PUSH2 0x1b54 1B28 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1B1F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1B24 stack[-1] = stack[-1] // @1B24 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1b54 label_1B29: // Incoming jump from 0x1B15, if 0x1f < stack[-1] // Inputs[5] // { // @1B2A stack[-3] // @1B2B stack[-1] // @1B2D stack[-2] // @1B35 memory[0x00:0x20] // @1B39 storage[keccak256(memory[0x00:0x20])] // } 1B29 5B JUMPDEST 1B2A 82 DUP3 1B2B 01 ADD 1B2C 91 SWAP2 1B2D 90 SWAP1 1B2E 60 PUSH1 0x00 1B30 52 MSTORE 1B31 60 PUSH1 0x20 1B33 60 PUSH1 0x00 1B35 20 SHA3 1B36 90 SWAP1 1B37 5B JUMPDEST 1B38 81 DUP2 1B39 54 SLOAD 1B3A 81 DUP2 1B3B 52 MSTORE 1B3C 90 SWAP1 1B3D 60 PUSH1 0x01 1B3F 01 ADD 1B40 90 SWAP1 1B41 60 PUSH1 0x20 1B43 01 ADD 1B44 80 DUP1 1B45 83 DUP4 1B46 11 GT 1B47 61 PUSH2 0x1b37 1B4A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1B2C stack[-3] = stack[-3] + stack[-1] // @1B30 memory[0x00:0x20] = stack[-2] // @1B3B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1B40 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1B43 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1b37, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1B4B: // Incoming jump from 0x1B4A, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1B4A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1B4B stack[-3] // @1B4C stack[-1] // } 1B4B 82 DUP3 1B4C 90 SWAP1 1B4D 03 SUB 1B4E 60 PUSH1 0x1f 1B50 16 AND 1B51 82 DUP3 1B52 01 ADD 1B53 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1B53 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1B53 stack[-1] = stack[-3] // } // Block continues label_1B54: // Incoming jump from 0x1B53 // Incoming jump from 0x1B0D, if !stack[-1] // Incoming jump from 0x1B28 // Inputs[1] { @1B5A stack[-7] } 1B54 5B JUMPDEST 1B55 50 POP 1B56 50 POP 1B57 50 POP 1B58 50 POP 1B59 50 POP 1B5A 81 DUP2 1B5B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1B5C: // Incoming jump from 0x0625 // Inputs[3] // { // @1B5F stack[-1] // @1B6A memory[0x00:0x40] // @1B6B storage[keccak256(memory[0x00:0x40])] // } 1B5C 5B JUMPDEST 1B5D 60 PUSH1 0x00 1B5F 81 DUP2 1B60 81 DUP2 1B61 52 MSTORE 1B62 60 PUSH1 0x02 1B64 60 PUSH1 0x20 1B66 52 MSTORE 1B67 60 PUSH1 0x40 1B69 90 SWAP1 1B6A 20 SHA3 1B6B 54 SLOAD 1B6C 60 PUSH1 0x60 1B6E 90 SWAP1 1B6F 60 PUSH1 0x01 1B71 60 PUSH1 0x01 1B73 60 PUSH1 0xa0 1B75 1B SHL 1B76 03 SUB 1B77 16 AND 1B78 61 PUSH2 0x1bdb 1B7B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1B61 memory[0x00:0x20] = stack[-1] // @1B66 memory[0x20:0x40] = 0x02 // @1B6E stack[0] = 0x60 // } // Block ends with conditional jump to 0x1bdb, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1B7C: // Incoming jump from 0x1B7B, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1B7E memory[0x40:0x60] } 1B7C 60 PUSH1 0x40 1B7E 51 MLOAD 1B7F 62 PUSH3 0x461bcd 1B83 60 PUSH1 0xe5 1B85 1B SHL 1B86 81 DUP2 1B87 52 MSTORE 1B88 60 PUSH1 0x20 1B8A 60 PUSH1 0x04 1B8C 82 DUP3 1B8D 01 ADD 1B8E 52 MSTORE 1B8F 60 PUSH1 0x2f 1B91 60 PUSH1 0x24 1B93 82 DUP3 1B94 01 ADD 1B95 52 MSTORE 1B96 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 1BB7 60 PUSH1 0x44 1BB9 82 DUP3 1BBA 01 ADD 1BBB 52 MSTORE 1BBC 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 1BCC 60 PUSH1 0x89 1BCE 1B SHL 1BCF 60 PUSH1 0x64 1BD1 82 DUP3 1BD2 01 ADD 1BD3 52 MSTORE 1BD4 60 PUSH1 0x84 1BD6 01 ADD 1BD7 61 PUSH2 0x0809 1BDA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1B87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B8E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B95 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @1BBB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @1BD3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @1BD6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_1BDB: // Incoming jump from 0x1B7B, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @1BDE stack[-2] // @1BE9 memory[0x00:0x40] // @1BED storage[0x01 + keccak256(memory[0x00:0x40])] // } 1BDB 5B JUMPDEST 1BDC 60 PUSH1 0x00 1BDE 82 DUP3 1BDF 81 DUP2 1BE0 52 MSTORE 1BE1 60 PUSH1 0x0e 1BE3 60 PUSH1 0x20 1BE5 52 MSTORE 1BE6 60 PUSH1 0x40 1BE8 90 SWAP1 1BE9 20 SHA3 1BEA 60 PUSH1 0x01 1BEC 01 ADD 1BED 54 SLOAD 1BEE 60 PUSH1 0xff 1BF0 16 AND 1BF1 15 ISZERO 1BF2 61 PUSH2 0x1c93 1BF5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BE0 memory[0x00:0x20] = stack[-2] // @1BE5 memory[0x20:0x40] = 0x0e // } // Block ends with conditional jump to 0x1c93, if !(0xff & storage[0x01 + keccak256(memory[0x00:0x40])]) label_1BF6: // Incoming jump from 0x1BF5, if not !(0xff & storage[0x01 + keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @1BF8 stack[-2] // @1C03 memory[0x00:0x40] // @1C05 storage[keccak256(memory[0x00:0x40])] // } 1BF6 60 PUSH1 0x00 1BF8 82 DUP3 1BF9 81 DUP2 1BFA 52 MSTORE 1BFB 60 PUSH1 0x0e 1BFD 60 PUSH1 0x20 1BFF 52 MSTORE 1C00 60 PUSH1 0x40 1C02 90 SWAP1 1C03 20 SHA3 1C04 80 DUP1 1C05 54 SLOAD 1C06 61 PUSH2 0x1c0e 1C09 90 SWAP1 1C0A 61 PUSH2 0x3774 1C0D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1BFA memory[0x00:0x20] = stack[-2] // @1BFF memory[0x20:0x40] = 0x0e // @1C03 stack[0] = keccak256(memory[0x00:0x40]) // @1C09 stack[1] = 0x1c0e // @1C09 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3774, returns to 0x1C0E label_1C0E: // Incoming return from call to 0x3774 at 0x2991 // Incoming return from call to 0x3774 at 0x2984 // Incoming return from call to 0x3774 at 0x1C0D // Inputs[4] // { // @1C0F stack[-1] // @1C1E memory[0x40:0x60] // @1C26 stack[-2] // @1C31 storage[stack[-2]] // } 1C0E 5B JUMPDEST 1C0F 80 DUP1 1C10 60 PUSH1 0x1f 1C12 01 ADD 1C13 60 PUSH1 0x20 1C15 80 DUP1 1C16 91 SWAP2 1C17 04 DIV 1C18 02 MUL 1C19 60 PUSH1 0x20 1C1B 01 ADD 1C1C 60 PUSH1 0x40 1C1E 51 MLOAD 1C1F 90 SWAP1 1C20 81 DUP2 1C21 01 ADD 1C22 60 PUSH1 0x40 1C24 52 MSTORE 1C25 80 DUP1 1C26 92 SWAP3 1C27 91 SWAP2 1C28 90 SWAP1 1C29 81 DUP2 1C2A 81 DUP2 1C2B 52 MSTORE 1C2C 60 PUSH1 0x20 1C2E 01 ADD 1C2F 82 DUP3 1C30 80 DUP1 1C31 54 SLOAD 1C32 61 PUSH2 0x1c3a 1C35 90 SWAP1 1C36 61 PUSH2 0x3774 1C39 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1C24 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1C26 stack[-2] = memory[0x40:0x60] // @1C27 stack[-1] = stack[-2] // @1C28 stack[0] = stack[-1] // @1C2B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1C2E stack[1] = 0x20 + memory[0x40:0x60] // @1C2F stack[2] = stack[-2] // @1C35 stack[4] = storage[stack[-2]] // @1C35 stack[3] = 0x1c3a // } // Block ends with call to 0x3774, returns to 0x1C3A label_1C3A: // Incoming return from call to 0x3774 at 0x1C39 // Inputs[1] { @1C3B stack[-1] } 1C3A 5B JUMPDEST 1C3B 80 DUP1 1C3C 15 ISZERO 1C3D 61 PUSH2 0x1c87 1C40 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c87, if !stack[-1] label_1C41: // Incoming jump from 0x1C40, if not !stack[-1] // Inputs[1] { @1C41 stack[-1] } 1C41 80 DUP1 1C42 60 PUSH1 0x1f 1C44 10 LT 1C45 61 PUSH2 0x1c5c 1C48 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c5c, if 0x1f < stack[-1] label_1C49: // Incoming jump from 0x1C48, if not 0x1f < stack[-1] // Inputs[4] // { // @1C4D stack[-2] // @1C4E storage[stack[-2]] // @1C51 stack[-3] // @1C53 stack[-1] // } 1C49 61 PUSH2 0x0100 1C4C 80 DUP1 1C4D 83 DUP4 1C4E 54 SLOAD 1C4F 04 DIV 1C50 02 MUL 1C51 83 DUP4 1C52 52 MSTORE 1C53 91 SWAP2 1C54 60 PUSH1 0x20 1C56 01 ADD 1C57 91 SWAP2 1C58 61 PUSH2 0x1c87 1C5B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1C52 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1C57 stack[-1] = stack[-1] // @1C57 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1c87 label_1C5C: // Incoming jump from 0x1C48, if 0x1f < stack[-1] // Inputs[5] // { // @1C5D stack[-3] // @1C5E stack[-1] // @1C60 stack[-2] // @1C68 memory[0x00:0x20] // @1C6C storage[keccak256(memory[0x00:0x20])] // } 1C5C 5B JUMPDEST 1C5D 82 DUP3 1C5E 01 ADD 1C5F 91 SWAP2 1C60 90 SWAP1 1C61 60 PUSH1 0x00 1C63 52 MSTORE 1C64 60 PUSH1 0x20 1C66 60 PUSH1 0x00 1C68 20 SHA3 1C69 90 SWAP1 1C6A 5B JUMPDEST 1C6B 81 DUP2 1C6C 54 SLOAD 1C6D 81 DUP2 1C6E 52 MSTORE 1C6F 90 SWAP1 1C70 60 PUSH1 0x01 1C72 01 ADD 1C73 90 SWAP1 1C74 60 PUSH1 0x20 1C76 01 ADD 1C77 80 DUP1 1C78 83 DUP4 1C79 11 GT 1C7A 61 PUSH2 0x1c6a 1C7D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1C5F stack[-3] = stack[-3] + stack[-1] // @1C63 memory[0x00:0x20] = stack[-2] // @1C6E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1C73 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1C76 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1c6a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1C7E: // Incoming jump from 0x1C7D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1C7D, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1C7E stack[-3] // @1C7F stack[-1] // } 1C7E 82 DUP3 1C7F 90 SWAP1 1C80 03 SUB 1C81 60 PUSH1 0x1f 1C83 16 AND 1C84 82 DUP3 1C85 01 ADD 1C86 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1C86 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1C86 stack[-1] = stack[-3] // } // Block continues label_1C87: // Incoming jump from 0x1C5B // Incoming jump from 0x1C86 // Incoming jump from 0x1C40, if !stack[-1] // Inputs[4] // { // @1C8D stack[-7] // @1C8D stack[-6] // @1C8F stack[-9] // @1C90 stack[-8] // } 1C87 5B JUMPDEST 1C88 50 POP 1C89 50 POP 1C8A 50 POP 1C8B 50 POP 1C8C 50 POP 1C8D 90 SWAP1 1C8E 50 POP 1C8F 91 SWAP2 1C90 90 SWAP1 1C91 50 POP 1C92 56 *JUMP // Stack delta = -8 // Outputs[1] { @1C8F stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_1C93: // Incoming jump from 0x1BF5, if !(0xff & storage[0x01 + keccak256(memory[0x00:0x40])]) // Inputs[1] { @1C99 stack[-2] } 1C93 5B JUMPDEST 1C94 60 PUSH1 0x00 1C96 61 PUSH2 0x1c9e 1C99 83 DUP4 1C9A 61 PUSH2 0x296c 1C9D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C94 stack[0] = 0x00 // @1C96 stack[1] = 0x1c9e // @1C99 stack[2] = stack[-2] // } // Block ends with call to 0x296c, returns to 0x1C9E label_1C9E: // Incoming return from call to 0x296C at 0x1C9D // Inputs[3] // { // @1C9F stack[-2] // @1C9F stack[-1] // @1CA4 memory[stack[-1]:stack[-1] + 0x20] // } 1C9E 5B JUMPDEST 1C9F 90 SWAP1 1CA0 50 POP 1CA1 60 PUSH1 0x00 1CA3 81 DUP2 1CA4 51 MLOAD 1CA5 11 GT 1CA6 61 PUSH2 0x1cbe 1CA9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1C9F stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1cbe, if memory[stack[-1]:stack[-1] + 0x20] > 0x00 label_1CAA: // Incoming jump from 0x1CA9, if not memory[stack[-1]:stack[-1] + 0x20] > 0x00 // Inputs[1] { @1CAC memory[0x40:0x60] } 1CAA 60 PUSH1 0x40 1CAC 51 MLOAD 1CAD 80 DUP1 1CAE 60 PUSH1 0x20 1CB0 01 ADD 1CB1 60 PUSH1 0x40 1CB3 52 MSTORE 1CB4 80 DUP1 1CB5 60 PUSH1 0x00 1CB7 81 DUP2 1CB8 52 MSTORE 1CB9 50 POP 1CBA 61 PUSH2 0x1ce9 1CBD 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1CAC stack[0] = memory[0x40:0x60] // @1CB3 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1CB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1ce9 label_1CBE: // Incoming jump from 0x1CA9, if memory[stack[-1]:stack[-1] + 0x20] > 0x00 // Inputs[2] // { // @1CBF stack[-1] // @1CC3 stack[-3] // } 1CBE 5B JUMPDEST 1CBF 80 DUP1 1CC0 61 PUSH2 0x1cc8 1CC3 84 DUP5 1CC4 61 PUSH2 0x247a 1CC7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CBF stack[0] = stack[-1] // @1CC0 stack[1] = 0x1cc8 // @1CC3 stack[2] = stack[-3] // } // Block ends with call to 0x247a, returns to 0x1CC8 label_1CC8: // Incoming return from call to 0x247A at 0x1CC7 // Inputs[3] // { // @1CCB memory[0x40:0x60] // @1CD2 stack[-2] // @1CD3 stack[-1] // } 1CC8 5B JUMPDEST 1CC9 60 PUSH1 0x40 1CCB 51 MLOAD 1CCC 60 PUSH1 0x20 1CCE 01 ADD 1CCF 61 PUSH2 0x1cd9 1CD2 92 SWAP3 1CD3 91 SWAP2 1CD4 90 SWAP1 1CD5 61 PUSH2 0x3454 1CD8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1CD2 stack[-2] = 0x1cd9 // @1CD3 stack[-1] = stack[-2] // @1CD4 stack[1] = 0x20 + memory[0x40:0x60] // @1CD4 stack[0] = stack[-1] // } // Block ends with call to 0x3454, returns to 0x1CD9 label_1CD9: // Incoming return from call to 0x3454 at 0x1CD8 // Inputs[2] // { // @1CDC memory[0x40:0x60] // @1CE0 stack[-1] // } 1CD9 5B JUMPDEST 1CDA 60 PUSH1 0x40 1CDC 51 MLOAD 1CDD 60 PUSH1 0x20 1CDF 81 DUP2 1CE0 83 DUP4 1CE1 03 SUB 1CE2 03 SUB 1CE3 81 DUP2 1CE4 52 MSTORE 1CE5 90 SWAP1 1CE6 60 PUSH1 0x40 1CE8 52 MSTORE // Stack delta = +0 // Outputs[3] // { // @1CE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1CE5 stack[-1] = memory[0x40:0x60] // @1CE8 memory[0x40:0x60] = stack[-1] // } // Block continues label_1CE9: // Incoming return from call to 0x3043 at 0x3138 // Incoming return from call to 0x30B9 at 0x3152 // Incoming return from call to 0x3820 at 0x335A // Incoming jump from 0x1CE8 // Incoming jump from 0x1CBD // Incoming return from call to 0x3428 at 0x3582 // Incoming jump from 0x205B, if !stack[-5] // Inputs[3] // { // @1CEA stack[-5] // @1CEA stack[-1] // @1CEB stack[-4] // } 1CE9 5B JUMPDEST 1CEA 93 SWAP4 1CEB 92 SWAP3 1CEC 50 POP 1CED 50 POP 1CEE 50 POP 1CEF 56 *JUMP // Stack delta = -4 // Outputs[1] { @1CEA stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1CF0: // Incoming call from 0x14AD, returns to 0x1413 // Incoming call from 0x14CE, returns to 0x1413 // Incoming jump from 0x064D // Inputs[4] // { // @1CF3 stack[-2] // @1CFE memory[0x00:0x40] // @1D02 storage[0x01 + keccak256(memory[0x00:0x40])] // @1D07 msg.sender // } 1CF0 5B JUMPDEST 1CF1 60 PUSH1 0x00 1CF3 82 DUP3 1CF4 81 DUP2 1CF5 52 MSTORE 1CF6 60 PUSH1 0x06 1CF8 60 PUSH1 0x20 1CFA 52 MSTORE 1CFB 60 PUSH1 0x40 1CFD 90 SWAP1 1CFE 20 SHA3 1CFF 60 PUSH1 0x01 1D01 01 ADD 1D02 54 SLOAD 1D03 61 PUSH2 0x1d0c 1D06 81 DUP2 1D07 33 CALLER 1D08 61 PUSH2 0x25d9 1D0B 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1CF5 memory[0x00:0x20] = stack[-2] // @1CFA memory[0x20:0x40] = 0x06 // @1D02 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1D03 stack[1] = 0x1d0c // @1D06 stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1D07 stack[3] = msg.sender // } // Block ends with call to 0x25d9, returns to 0x1D0C label_1D0C: // Incoming return from call to 0x25D9 at 0x1D0B // Inputs[2] // { // @1D10 stack[-3] // @1D11 stack[-2] // } 1D0C 5B JUMPDEST 1D0D 61 PUSH2 0x093f 1D10 83 DUP4 1D11 83 DUP4 1D12 61 PUSH2 0x26c3 1D15 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D0D stack[0] = 0x093f // @1D10 stack[1] = stack[-3] // @1D11 stack[2] = stack[-2] // } // Block ends with call to 0x26c3, returns to 0x093F label_1D16: // Incoming jump from 0x0660 // Inputs[1] { @1D17 stack[-1] } 1D16 5B JUMPDEST 1D17 80 DUP1 1D18 61 PUSH2 0x1d33 1D1B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d33, if stack[-1] label_1D1C: // Incoming jump from 0x1D1B, if not stack[-1] // Inputs[3] // { // @1D22 memory[0x00:0x20] // @1D2B memory[0x00:0x20] // @1D2E stack[-2] // } 1D1C 61 PUSH2 0x1413 1D1F 60 PUSH1 0x00 1D21 80 DUP1 1D22 51 MLOAD 1D23 60 PUSH1 0x20 1D25 61 PUSH2 0x3837 1D28 83 DUP4 1D29 39 CODECOPY 1D2A 81 DUP2 1D2B 51 MLOAD 1D2C 91 SWAP2 1D2D 52 MSTORE 1D2E 83 DUP4 1D2F 61 PUSH2 0x1314 1D32 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1D1C stack[0] = 0x1413 // @1D29 memory[0x00:0x20] = code[0x3837:0x3857] // @1D2C stack[1] = memory[0x00:0x20] // @1D2D memory[0x00:0x20] = memory[0x00:0x20] // @1D2E stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1314 label_1D33: // Incoming jump from 0x1D1B, if stack[-1] // Inputs[1] { @1D34 stack[-1] } 1D33 5B JUMPDEST 1D34 80 DUP1 1D35 60 PUSH1 0x01 1D37 14 EQ 1D38 15 ISZERO 1D39 61 PUSH2 0x1413 1D3C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1413, if !(0x01 == stack[-1]) label_1D3D: // Incoming jump from 0x1D3C, if not !(0x01 == stack[-1]) // Inputs[3] // { // @1D43 memory[0x00:0x20] // @1D4C memory[0x00:0x20] // @1D4F stack[-2] // } 1D3D 61 PUSH2 0x1413 1D40 60 PUSH1 0x00 1D42 80 DUP1 1D43 51 MLOAD 1D44 60 PUSH1 0x20 1D46 61 PUSH2 0x3857 1D49 83 DUP4 1D4A 39 CODECOPY 1D4B 81 DUP2 1D4C 51 MLOAD 1D4D 91 SWAP2 1D4E 52 MSTORE 1D4F 83 DUP4 1D50 61 PUSH2 0x1314 1D53 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1D3D stack[0] = 0x1413 // @1D4A memory[0x00:0x20] = code[0x3857:0x3877] // @1D4D stack[1] = memory[0x00:0x20] // @1D4E memory[0x00:0x20] = memory[0x00:0x20] // @1D4F stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1314 label_1D54: // Incoming jump from 0x0673 // Inputs[4] // { // @1D57 stack[-1] // @1D62 memory[0x00:0x40] // @1D63 storage[keccak256(memory[0x00:0x40])] // @1D64 block.timestamp // } 1D54 5B JUMPDEST 1D55 60 PUSH1 0x00 1D57 81 DUP2 1D58 81 DUP2 1D59 52 MSTORE 1D5A 60 PUSH1 0x0f 1D5C 60 PUSH1 0x20 1D5E 52 MSTORE 1D5F 60 PUSH1 0x40 1D61 81 DUP2 1D62 20 SHA3 1D63 54 SLOAD 1D64 42 TIMESTAMP 1D65 11 GT 1D66 80 DUP1 1D67 15 ISZERO 1D68 61 PUSH2 0x06fc 1D6B 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1D55 stack[0] = 0x00 // @1D59 memory[0x00:0x20] = stack[-1] // @1D5E memory[0x20:0x40] = 0x0f // @1D65 stack[1] = block.timestamp > storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x06fc, if !(block.timestamp > storage[keccak256(memory[0x00:0x40])]) label_1D6C: // Incoming jump from 0x1D6B, if not !(block.timestamp > storage[keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @1D70 stack[-3] // @1D7B memory[0x00:0x40] // @1D7F storage[0x01 + keccak256(memory[0x00:0x40])] // @1D80 block.timestamp // @1D82 stack[-4] // } 1D6C 50 POP 1D6D 50 POP 1D6E 60 PUSH1 0x00 1D70 90 SWAP1 1D71 81 DUP2 1D72 52 MSTORE 1D73 60 PUSH1 0x0f 1D75 60 PUSH1 0x20 1D77 52 MSTORE 1D78 60 PUSH1 0x40 1D7A 90 SWAP1 1D7B 20 SHA3 1D7C 60 PUSH1 0x01 1D7E 01 ADD 1D7F 54 SLOAD 1D80 42 TIMESTAMP 1D81 10 LT 1D82 90 SWAP1 1D83 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1D72 memory[0x00:0x20] = stack[-3] // @1D77 memory[0x20:0x40] = 0x0f // @1D82 stack[-4] = block.timestamp < storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_1D84: // Incoming jump from 0x0686 // Inputs[2] // { // @1D87 storage[0x0b] // @1D97 msg.sender // } 1D84 5B JUMPDEST 1D85 60 PUSH1 0x0b 1D87 54 SLOAD 1D88 60 PUSH1 0x01 1D8A 60 PUSH1 0x01 1D8C 60 PUSH1 0xa0 1D8E 1B SHL 1D8F 03 SUB 1D90 61 PUSH2 0x0100 1D93 90 SWAP1 1D94 91 SWAP2 1D95 04 DIV 1D96 16 AND 1D97 33 CALLER 1D98 14 EQ 1D99 61 PUSH2 0x1db4 1D9C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1db4, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1D9D: // Incoming jump from 0x1D9C, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1D9F memory[0x40:0x60] } 1D9D 60 PUSH1 0x40 1D9F 51 MLOAD 1DA0 62 PUSH3 0x461bcd 1DA4 60 PUSH1 0xe5 1DA6 1B SHL 1DA7 81 DUP2 1DA8 52 MSTORE 1DA9 60 PUSH1 0x04 1DAB 01 ADD 1DAC 61 PUSH2 0x0809 1DAF 90 SWAP1 1DB0 61 PUSH2 0x3649 1DB3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DAF stack[0] = 0x0809 // @1DAF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_1DB4: // Incoming jump from 0x1D9C, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1DB7 stack[-2] // @1DC1 stack[-1] // @1DC3 memory[0x00:0x40] // @1DC5 stack[-3] // } 1DB4 5B JUMPDEST 1DB5 60 PUSH1 0x00 1DB7 91 SWAP2 1DB8 82 DUP3 1DB9 52 MSTORE 1DBA 60 PUSH1 0x0f 1DBC 60 PUSH1 0x20 1DBE 52 MSTORE 1DBF 60 PUSH1 0x40 1DC1 90 SWAP1 1DC2 91 SWAP2 1DC3 20 SHA3 1DC4 55 SSTORE 1DC5 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1DB9 memory[0x00:0x20] = stack[-2] // @1DBE memory[0x20:0x40] = 0x0f // @1DC4 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1DC6: // Incoming call from 0x068E, returns to 0x030B // Inputs[1] { @1DCC storage[0x12] } 1DC6 5B JUMPDEST 1DC7 60 PUSH1 0x60 1DC9 60 PUSH1 0x12 1DCB 80 DUP1 1DCC 54 SLOAD 1DCD 61 PUSH2 0x0711 1DD0 90 SWAP1 1DD1 61 PUSH2 0x3774 1DD4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DC7 stack[0] = 0x60 // @1DC9 stack[1] = 0x12 // @1DD0 stack[2] = 0x0711 // @1DD0 stack[3] = storage[0x12] // } // Block ends with call to 0x3774, returns to 0x0711 label_1DD5: // Incoming jump from 0x06DD // Inputs[2] // { // @1DD8 storage[0x0b] // @1DE8 msg.sender // } 1DD5 5B JUMPDEST 1DD6 60 PUSH1 0x0b 1DD8 54 SLOAD 1DD9 60 PUSH1 0x01 1DDB 60 PUSH1 0x01 1DDD 60 PUSH1 0xa0 1DDF 1B SHL 1DE0 03 SUB 1DE1 61 PUSH2 0x0100 1DE4 90 SWAP1 1DE5 91 SWAP2 1DE6 04 DIV 1DE7 16 AND 1DE8 33 CALLER 1DE9 14 EQ 1DEA 61 PUSH2 0x1e05 1DED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e05, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1DEE: // Incoming jump from 0x1DED, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DF0 memory[0x40:0x60] } 1DEE 60 PUSH1 0x40 1DF0 51 MLOAD 1DF1 62 PUSH3 0x461bcd 1DF5 60 PUSH1 0xe5 1DF7 1B SHL 1DF8 81 DUP2 1DF9 52 MSTORE 1DFA 60 PUSH1 0x04 1DFC 01 ADD 1DFD 61 PUSH2 0x0809 1E00 90 SWAP1 1E01 61 PUSH2 0x3649 1E04 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E00 stack[0] = 0x0809 // @1E00 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_1E05: // Incoming jump from 0x1DED, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E0E stack[-1] } 1E05 5B JUMPDEST 1E06 60 PUSH1 0x01 1E08 60 PUSH1 0x01 1E0A 60 PUSH1 0xa0 1E0C 1B SHL 1E0D 03 SUB 1E0E 81 DUP2 1E0F 16 AND 1E10 61 PUSH2 0x1e6a 1E13 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e6a, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1E14: // Incoming jump from 0x1E13, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E16 memory[0x40:0x60] } 1E14 60 PUSH1 0x40 1E16 51 MLOAD 1E17 62 PUSH3 0x461bcd 1E1B 60 PUSH1 0xe5 1E1D 1B SHL 1E1E 81 DUP2 1E1F 52 MSTORE 1E20 60 PUSH1 0x20 1E22 60 PUSH1 0x04 1E24 82 DUP3 1E25 01 ADD 1E26 52 MSTORE 1E27 60 PUSH1 0x26 1E29 60 PUSH1 0x24 1E2B 82 DUP3 1E2C 01 ADD 1E2D 52 MSTORE 1E2E 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1E4F 60 PUSH1 0x44 1E51 82 DUP3 1E52 01 ADD 1E53 52 MSTORE 1E54 65 PUSH6 0x646472657373 1E5B 60 PUSH1 0xd0 1E5D 1B SHL 1E5E 60 PUSH1 0x64 1E60 82 DUP3 1E61 01 ADD 1E62 52 MSTORE 1E63 60 PUSH1 0x84 1E65 01 ADD 1E66 61 PUSH2 0x0809 1E69 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1E1F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E26 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E2D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1E53 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1E62 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1E65 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_1E6A: // Incoming jump from 0x1E13, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E6E stack[-1] } 1E6A 5B JUMPDEST 1E6B 61 PUSH2 0x159b 1E6E 81 DUP2 1E6F 61 PUSH2 0x2864 1E72 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E6B stack[0] = 0x159b // @1E6E stack[1] = stack[-1] // } // Block ends with call to 0x2864, returns to 0x159B label_1E73: // Incoming jump from 0x06F0 // Inputs[2] // { // @1E76 storage[0x0b] // @1E86 msg.sender // } 1E73 5B JUMPDEST 1E74 60 PUSH1 0x0b 1E76 54 SLOAD 1E77 60 PUSH1 0x01 1E79 60 PUSH1 0x01 1E7B 60 PUSH1 0xa0 1E7D 1B SHL 1E7E 03 SUB 1E7F 61 PUSH2 0x0100 1E82 90 SWAP1 1E83 91 SWAP2 1E84 04 DIV 1E85 16 AND 1E86 33 CALLER 1E87 14 EQ 1E88 61 PUSH2 0x1ea3 1E8B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ea3, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1E8C: // Incoming jump from 0x1E8B, if not msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E8E memory[0x40:0x60] } 1E8C 60 PUSH1 0x40 1E8E 51 MLOAD 1E8F 62 PUSH3 0x461bcd 1E93 60 PUSH1 0xe5 1E95 1B SHL 1E96 81 DUP2 1E97 52 MSTORE 1E98 60 PUSH1 0x04 1E9A 01 ADD 1E9B 61 PUSH2 0x0809 1E9E 90 SWAP1 1E9F 61 PUSH2 0x3649 1EA2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E9E stack[0] = 0x0809 // @1E9E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3649, returns to 0x0809 label_1EA3: // Incoming jump from 0x1E8B, if msg.sender == storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1EA6 stack[-2] // @1EB0 stack[-1] // @1EB2 memory[0x00:0x40] // @1EB7 stack[-3] // } 1EA3 5B JUMPDEST 1EA4 60 PUSH1 0x00 1EA6 91 SWAP2 1EA7 82 DUP3 1EA8 52 MSTORE 1EA9 60 PUSH1 0x0f 1EAB 60 PUSH1 0x20 1EAD 52 MSTORE 1EAE 60 PUSH1 0x40 1EB0 90 SWAP1 1EB1 91 SWAP2 1EB2 20 SHA3 1EB3 60 PUSH1 0x01 1EB5 01 ADD 1EB6 55 SSTORE 1EB7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1EA8 memory[0x00:0x20] = stack[-2] // @1EAD memory[0x20:0x40] = 0x0f // @1EB6 storage[0x01 + keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-3] 1EB8 5B JUMPDEST 1EB9 80 DUP1 1EBA 54 SLOAD 1EBB 60 PUSH1 0x01 1EBD 01 ADD 1EBE 90 SWAP1 1EBF 55 SSTORE 1EC0 56 *JUMP label_1EC1: // Incoming call from 0x25FA, returns to 0x25FB // Incoming call from 0x2605, returns to 0x2606 // Inputs[1] { @1EC9 stack[-1] } 1EC1 5B JUMPDEST 1EC2 60 PUSH1 0x60 1EC4 60 PUSH1 0x00 1EC6 61 PUSH2 0x1ed0 1EC9 83 DUP4 1ECA 60 PUSH1 0x02 1ECC 61 PUSH2 0x36fb 1ECF 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1EC2 stack[0] = 0x60 // @1EC4 stack[1] = 0x00 // @1EC6 stack[2] = 0x1ed0 // @1EC9 stack[3] = stack[-1] // @1ECA stack[4] = 0x02 // } // Block ends with call to 0x36fb, returns to 0x1ED0 label_1ED0: // Incoming return from call to 0x36FB at 0x1ECF // Inputs[1] { @1ED4 stack[-1] } 1ED0 5B JUMPDEST 1ED1 61 PUSH2 0x1edb 1ED4 90 SWAP1 1ED5 60 PUSH1 0x02 1ED7 61 PUSH2 0x36cf 1EDA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1ED4 stack[0] = stack[-1] // @1ED4 stack[-1] = 0x1edb // @1ED5 stack[1] = 0x02 // } // Block ends with call to 0x36cf, returns to 0x1EDB label_1EDB: // Incoming return from call to 0x36CF at 0x1EDA // Inputs[1] { @1EE5 stack[-1] } 1EDB 5B JUMPDEST 1EDC 67 PUSH8 0xffffffffffffffff 1EE5 81 DUP2 1EE6 11 GT 1EE7 15 ISZERO 1EE8 61 PUSH2 0x1f01 1EEB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f01, if !(stack[-1] > 0xffffffffffffffff) label_1EEC: // Incoming jump from 0x1EEB, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1F00 memory[0x00:0x24] } 1EEC 63 PUSH4 0x4e487b71 1EF1 60 PUSH1 0xe0 1EF3 1B SHL 1EF4 60 PUSH1 0x00 1EF6 52 MSTORE 1EF7 60 PUSH1 0x41 1EF9 60 PUSH1 0x04 1EFB 52 MSTORE 1EFC 60 PUSH1 0x24 1EFE 60 PUSH1 0x00 1F00 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1EF6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1EFB memory[0x04:0x24] = 0x41 // @1F00 revert(memory[0x00:0x24]); // } // Block terminates label_1F01: // Incoming jump from 0x1EEB, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1F04 memory[0x40:0x60] // @1F05 stack[-1] // } 1F01 5B JUMPDEST 1F02 60 PUSH1 0x40 1F04 51 MLOAD 1F05 90 SWAP1 1F06 80 DUP1 1F07 82 DUP3 1F08 52 MSTORE 1F09 80 DUP1 1F0A 60 PUSH1 0x1f 1F0C 01 ADD 1F0D 60 PUSH1 0x1f 1F0F 19 NOT 1F10 16 AND 1F11 60 PUSH1 0x20 1F13 01 ADD 1F14 82 DUP3 1F15 01 ADD 1F16 60 PUSH1 0x40 1F18 52 MSTORE 1F19 80 DUP1 1F1A 15 ISZERO 1F1B 61 PUSH2 0x1f2b 1F1E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1F05 stack[-1] = memory[0x40:0x60] // @1F05 stack[0] = stack[-1] // @1F08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1F18 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1f2b, if !stack[-1] label_1F1F: // Incoming jump from 0x1F1E, if not !stack[-1] // Inputs[6] // { // @1F21 stack[-2] // @1F23 stack[-1] // @1F25 msg.data.length // @1F27 msg.data[msg.data.length:msg.data.length + stack[-1]] // @1F2D stack[-3] // @1F38 memory[stack[-2]:stack[-2] + 0x20] // } 1F1F 60 PUSH1 0x20 1F21 82 DUP3 1F22 01 ADD 1F23 81 DUP2 1F24 80 DUP1 1F25 36 CALLDATASIZE 1F26 83 DUP4 1F27 37 CALLDATACOPY 1F28 01 ADD 1F29 90 SWAP1 1F2A 50 POP 1F2B 5B JUMPDEST 1F2C 50 POP 1F2D 90 SWAP1 1F2E 50 POP 1F2F 60 PUSH1 0x03 1F31 60 PUSH1 0xfc 1F33 1B SHL 1F34 81 DUP2 1F35 60 PUSH1 0x00 1F37 81 DUP2 1F38 51 MLOAD 1F39 81 DUP2 1F3A 10 LT 1F3B 61 PUSH2 0x1f54 1F3E 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @1F27 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1F2D stack[-3] = stack[-2] // @1F33 stack[-2] = 0x03 << 0xfc // @1F34 stack[-1] = stack[-2] // @1F35 stack[0] = 0x00 // } // Block ends with conditional jump to 0x1f54, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_1F3F: // Incoming jump from 0x1F3E, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1F3E, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1F53 memory[0x00:0x24] } 1F3F 63 PUSH4 0x4e487b71 1F44 60 PUSH1 0xe0 1F46 1B SHL 1F47 60 PUSH1 0x00 1F49 52 MSTORE 1F4A 60 PUSH1 0x32 1F4C 60 PUSH1 0x04 1F4E 52 MSTORE 1F4F 60 PUSH1 0x24 1F51 60 PUSH1 0x00 1F53 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1F49 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1F4E memory[0x04:0x24] = 0x32 // @1F53 revert(memory[0x00:0x24]); // } // Block terminates label_1F54: // Incoming jump from 0x1F3E, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1F3E, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @1F57 stack[-1] // @1F58 stack[-2] // @1F59 stack[-3] // @1F71 stack[-4] // @1F75 memory[stack[-4]:stack[-4] + 0x20] // } 1F54 5B JUMPDEST 1F55 60 PUSH1 0x20 1F57 01 ADD 1F58 01 ADD 1F59 90 SWAP1 1F5A 60 PUSH1 0x01 1F5C 60 PUSH1 0x01 1F5E 60 PUSH1 0xf8 1F60 1B SHL 1F61 03 SUB 1F62 19 NOT 1F63 16 AND 1F64 90 SWAP1 1F65 81 DUP2 1F66 60 PUSH1 0x00 1F68 1A BYTE 1F69 90 SWAP1 1F6A 53 MSTORE8 1F6B 50 POP 1F6C 60 PUSH1 0x0f 1F6E 60 PUSH1 0xfb 1F70 1B SHL 1F71 81 DUP2 1F72 60 PUSH1 0x01 1F74 81 DUP2 1F75 51 MLOAD 1F76 81 DUP2 1F77 10 LT 1F78 61 PUSH2 0x1f91 1F7B 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1F6A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1F70 stack[-3] = 0x0f << 0xfb // @1F71 stack[-2] = stack[-4] // @1F72 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x1f91, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_1F7C: // Incoming jump from 0x1F7B, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[1] { @1F90 memory[0x00:0x24] } 1F7C 63 PUSH4 0x4e487b71 1F81 60 PUSH1 0xe0 1F83 1B SHL 1F84 60 PUSH1 0x00 1F86 52 MSTORE 1F87 60 PUSH1 0x32 1F89 60 PUSH1 0x04 1F8B 52 MSTORE 1F8C 60 PUSH1 0x24 1F8E 60 PUSH1 0x00 1F90 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1F86 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1F8B memory[0x04:0x24] = 0x32 // @1F90 revert(memory[0x00:0x24]); // } // Block terminates label_1F91: // Incoming jump from 0x1F7B, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @1F94 stack[-1] // @1F95 stack[-2] // @1F96 stack[-3] // @1FAE stack[-6] // } 1F91 5B JUMPDEST 1F92 60 PUSH1 0x20 1F94 01 ADD 1F95 01 ADD 1F96 90 SWAP1 1F97 60 PUSH1 0x01 1F99 60 PUSH1 0x01 1F9B 60 PUSH1 0xf8 1F9D 1B SHL 1F9E 03 SUB 1F9F 19 NOT 1FA0 16 AND 1FA1 90 SWAP1 1FA2 81 DUP2 1FA3 60 PUSH1 0x00 1FA5 1A BYTE 1FA6 90 SWAP1 1FA7 53 MSTORE8 1FA8 50 POP 1FA9 60 PUSH1 0x00 1FAB 61 PUSH2 0x1fb5 1FAE 84 DUP5 1FAF 60 PUSH1 0x02 1FB1 61 PUSH2 0x36fb 1FB4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1FA7 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1FA9 stack[-3] = 0x00 // @1FAB stack[-2] = 0x1fb5 // @1FAE stack[-1] = stack[-6] // @1FAF stack[0] = 0x02 // } // Block ends with call to 0x36fb, returns to 0x1FB5 label_1FB5: // Incoming return from call to 0x36FB at 0x1FB4 // Inputs[1] { @1FB9 stack[-1] } 1FB5 5B JUMPDEST 1FB6 61 PUSH2 0x1fc0 1FB9 90 SWAP1 1FBA 60 PUSH1 0x01 1FBC 61 PUSH2 0x36cf 1FBF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FB9 stack[0] = stack[-1] // @1FB9 stack[-1] = 0x1fc0 // @1FBA stack[1] = 0x01 // } // Block ends with call to 0x36cf, returns to 0x1FC0 label_1FC0: // Incoming return from call to 0x36CF at 0x1FBF // Inputs[2] // { // @1FC1 stack[-2] // @1FC1 stack[-1] // } 1FC0 5B JUMPDEST 1FC1 90 SWAP1 1FC2 50 POP 1FC3 5B JUMPDEST 1FC4 60 PUSH1 0x01 1FC6 81 DUP2 1FC7 11 GT 1FC8 15 ISZERO 1FC9 61 PUSH2 0x2054 1FCC 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1FC1 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2054, if !(stack[-1] > 0x01) label_1FCD: // Incoming jump from 0x1FCC, if not !(stack[-1] > 0x01) // Incoming jump from 0x1FCC, if not !(stack[-1] > 0x01) // Inputs[1] { @1FE1 stack[-5] } 1FCD 6F PUSH16 0x181899199a1a9b1b9c1cb0b131b232b3 1FDE 60 PUSH1 0x81 1FE0 1B SHL 1FE1 85 DUP6 1FE2 60 PUSH1 0x0f 1FE4 16 AND 1FE5 60 PUSH1 0x10 1FE7 81 DUP2 1FE8 10 LT 1FE9 61 PUSH2 0x2002 1FEC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FE0 stack[0] = 0x181899199a1a9b1b9c1cb0b131b232b3 << 0x81 // @1FE4 stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x2002, if 0x0f & stack[-5] < 0x10 label_1FED: // Incoming jump from 0x1FEC, if not 0x0f & stack[-5] < 0x10 // Inputs[1] { @2001 memory[0x00:0x24] } 1FED 63 PUSH4 0x4e487b71 1FF2 60 PUSH1 0xe0 1FF4 1B SHL 1FF5 60 PUSH1 0x00 1FF7 52 MSTORE 1FF8 60 PUSH1 0x32 1FFA 60 PUSH1 0x04 1FFC 52 MSTORE 1FFD 60 PUSH1 0x24 1FFF 60 PUSH1 0x00 2001 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1FF7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1FFC memory[0x04:0x24] = 0x32 // @2001 revert(memory[0x00:0x24]); // } // Block terminates label_2002: // Incoming jump from 0x1FEC, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @2003 stack[-2] // @2003 stack[-1] // @2007 stack[-4] // @2008 stack[-3] // @200A memory[stack[-4]:stack[-4] + 0x20] // } 2002 5B JUMPDEST 2003 1A BYTE 2004 60 PUSH1 0xf8 2006 1B SHL 2007 82 DUP3 2008 82 DUP3 2009 81 DUP2 200A 51 MLOAD 200B 81 DUP2 200C 10 LT 200D 61 PUSH2 0x2026 2010 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2006 stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @2007 stack[-1] = stack[-4] // @2008 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x2026, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_2011: // Incoming jump from 0x2010, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[1] { @2025 memory[0x00:0x24] } 2011 63 PUSH4 0x4e487b71 2016 60 PUSH1 0xe0 2018 1B SHL 2019 60 PUSH1 0x00 201B 52 MSTORE 201C 60 PUSH1 0x32 201E 60 PUSH1 0x04 2020 52 MSTORE 2021 60 PUSH1 0x24 2023 60 PUSH1 0x00 2025 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @201B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2020 memory[0x04:0x24] = 0x32 // @2025 revert(memory[0x00:0x24]); // } // Block terminates label_2026: // Incoming jump from 0x2010, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @2029 stack[-1] // @202A stack[-2] // @202B stack[-3] // @2040 stack[-8] // @2041 stack[-4] // } 2026 5B JUMPDEST 2027 60 PUSH1 0x20 2029 01 ADD 202A 01 ADD 202B 90 SWAP1 202C 60 PUSH1 0x01 202E 60 PUSH1 0x01 2030 60 PUSH1 0xf8 2032 1B SHL 2033 03 SUB 2034 19 NOT 2035 16 AND 2036 90 SWAP1 2037 81 DUP2 2038 60 PUSH1 0x00 203A 1A BYTE 203B 90 SWAP1 203C 53 MSTORE8 203D 50 POP 203E 60 PUSH1 0x04 2040 94 SWAP5 2041 90 SWAP1 2042 94 SWAP5 2043 1C SHR 2044 93 SWAP4 2045 61 PUSH2 0x204d 2048 81 DUP2 2049 61 PUSH2 0x375d 204C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @203C memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2044 stack[-4] = stack[-4] // @2044 stack[-8] = stack[-8] >> 0x04 // @2045 stack[-3] = 0x204d // @2048 stack[-2] = stack[-4] // } // Block ends with call to 0x375d, returns to 0x204D label_204D: // Incoming return from call to 0x375D at 0x204C // Inputs[2] // { // @204E stack[-2] // @204E stack[-1] // } 204D 5B JUMPDEST 204E 90 SWAP1 204F 50 POP 2050 61 PUSH2 0x1fc3 2053 56 *JUMP // Stack delta = -1 // Outputs[1] { @204E stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x1fc3 label_2054: // Incoming jump from 0x1FCC, if !(stack[-1] > 0x01) // Incoming jump from 0x1FCC, if !(stack[-1] > 0x01) // Inputs[1] { @2056 stack[-5] } 2054 5B JUMPDEST 2055 50 POP 2056 83 DUP4 2057 15 ISZERO 2058 61 PUSH2 0x1ce9 205B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ce9, if !stack[-5] label_205C: // Incoming jump from 0x205B, if not !stack[-5] // Inputs[1] { @205E memory[0x40:0x60] } 205C 60 PUSH1 0x40 205E 51 MLOAD 205F 62 PUSH3 0x461bcd 2063 60 PUSH1 0xe5 2065 1B SHL 2066 81 DUP2 2067 52 MSTORE 2068 60 PUSH1 0x20 206A 60 PUSH1 0x04 206C 82 DUP3 206D 01 ADD 206E 81 DUP2 206F 90 SWAP1 2070 52 MSTORE 2071 60 PUSH1 0x24 2073 82 DUP3 2074 01 ADD 2075 52 MSTORE 2076 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 2097 60 PUSH1 0x44 2099 82 DUP3 209A 01 ADD 209B 52 MSTORE 209C 60 PUSH1 0x64 209E 01 ADD 209F 61 PUSH2 0x0809 20A2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2067 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2070 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2075 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @209B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @209E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_20A3: // Incoming call from 0x06FB, returns to 0x06FC // Inputs[1] { @20AF stack[-1] } 20A3 5B JUMPDEST 20A4 60 PUSH1 0x00 20A6 60 PUSH1 0x01 20A8 60 PUSH1 0x01 20AA 60 PUSH1 0xe0 20AC 1B SHL 20AD 03 SUB 20AE 19 NOT 20AF 82 DUP3 20B0 16 AND 20B1 63 PUSH4 0x780e9d63 20B6 60 PUSH1 0xe0 20B8 1B SHL 20B9 14 EQ 20BA 80 DUP1 20BB 61 PUSH2 0x06fc 20BE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20A4 stack[0] = 0x00 // @20B9 stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x06fc, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_20BF: // Incoming jump from 0x20BE, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @20C3 stack[-3] } 20BF 50 POP 20C0 61 PUSH2 0x06fc 20C3 82 DUP3 20C4 61 PUSH2 0x2997 20C7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @20C0 stack[-1] = 0x06fc // @20C3 stack[0] = stack[-3] // } // Block ends with call to 0x2997, returns to 0x06FC label_20C8: // Incoming call from 0x093E, returns to 0x093F // Inputs[4] // { // @20CB stack[-1] // @20D6 memory[0x00:0x40] // @20D8 storage[keccak256(memory[0x00:0x40])] // @20EB stack[-2] // } 20C8 5B JUMPDEST 20C9 60 PUSH1 0x00 20CB 81 DUP2 20CC 81 DUP2 20CD 52 MSTORE 20CE 60 PUSH1 0x04 20D0 60 PUSH1 0x20 20D2 52 MSTORE 20D3 60 PUSH1 0x40 20D5 90 SWAP1 20D6 20 SHA3 20D7 80 DUP1 20D8 54 SLOAD 20D9 60 PUSH1 0x01 20DB 60 PUSH1 0x01 20DD 60 PUSH1 0xa0 20DF 1B SHL 20E0 03 SUB 20E1 19 NOT 20E2 16 AND 20E3 60 PUSH1 0x01 20E5 60 PUSH1 0x01 20E7 60 PUSH1 0xa0 20E9 1B SHL 20EA 03 SUB 20EB 84 DUP5 20EC 16 AND 20ED 90 SWAP1 20EE 81 DUP2 20EF 17 OR 20F0 90 SWAP1 20F1 91 SWAP2 20F2 55 SSTORE 20F3 81 DUP2 20F4 90 SWAP1 20F5 61 PUSH2 0x20fd 20F8 82 DUP3 20F9 61 PUSH2 0x1682 20FC 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @20CD memory[0x00:0x20] = stack[-1] // @20D2 memory[0x20:0x40] = 0x04 // @20F2 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @20F4 stack[0] = stack[-1] // @20F4 stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @20F5 stack[2] = 0x20fd // @20F8 stack[3] = stack[-1] // } // Block ends with call to 0x1682, returns to 0x20FD label_20FD: // Incoming return from call to 0x1682 at 0x20FC // Inputs[7] // { // @2106 stack[-1] // @212A memory[0x40:0x60] // @212D memory[0x40:0x60] // @2132 stack[-3] // @2132 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2132 stack[-2] // @2135 stack[-6] // } 20FD 5B JUMPDEST 20FE 60 PUSH1 0x01 2100 60 PUSH1 0x01 2102 60 PUSH1 0xa0 2104 1B SHL 2105 03 SUB 2106 16 AND 2107 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 2128 60 PUSH1 0x40 212A 51 MLOAD 212B 60 PUSH1 0x40 212D 51 MLOAD 212E 80 DUP1 212F 91 SWAP2 2130 03 SUB 2131 90 SWAP1 2132 A4 LOG4 2133 50 POP 2134 50 POP 2135 56 *JUMP // Stack delta = -6 // Outputs[1] { @2132 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_2136: // Incoming call from 0x1A9F, returns to 0x1AA0 // Incoming jump from 0x0A6F // Inputs[3] // { // @2139 stack[-1] // @2144 memory[0x00:0x40] // @2145 storage[keccak256(memory[0x00:0x40])] // } 2136 5B JUMPDEST 2137 60 PUSH1 0x00 2139 81 DUP2 213A 81 DUP2 213B 52 MSTORE 213C 60 PUSH1 0x02 213E 60 PUSH1 0x20 2140 52 MSTORE 2141 60 PUSH1 0x40 2143 81 DUP2 2144 20 SHA3 2145 54 SLOAD 2146 60 PUSH1 0x01 2148 60 PUSH1 0x01 214A 60 PUSH1 0xa0 214C 1B SHL 214D 03 SUB 214E 16 AND 214F 61 PUSH2 0x21af 2152 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2137 stack[0] = 0x00 // @213B memory[0x00:0x20] = stack[-1] // @2140 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x21af, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_2153: // Incoming jump from 0x2152, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @2155 memory[0x40:0x60] } 2153 60 PUSH1 0x40 2155 51 MLOAD 2156 62 PUSH3 0x461bcd 215A 60 PUSH1 0xe5 215C 1B SHL 215D 81 DUP2 215E 52 MSTORE 215F 60 PUSH1 0x20 2161 60 PUSH1 0x04 2163 82 DUP3 2164 01 ADD 2165 52 MSTORE 2166 60 PUSH1 0x2c 2168 60 PUSH1 0x24 216A 82 DUP3 216B 01 ADD 216C 52 MSTORE 216D 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 218E 60 PUSH1 0x44 2190 82 DUP3 2191 01 ADD 2192 52 MSTORE 2193 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 21A0 60 PUSH1 0xa1 21A2 1B SHL 21A3 60 PUSH1 0x64 21A5 82 DUP3 21A6 01 ADD 21A7 52 MSTORE 21A8 60 PUSH1 0x84 21AA 01 ADD 21AB 61 PUSH2 0x0809 21AE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @215E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2165 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @216C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @2192 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @21A7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @21AA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_21AF: // Incoming jump from 0x2152, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @21B5 stack[-2] } 21AF 5B JUMPDEST 21B0 60 PUSH1 0x00 21B2 61 PUSH2 0x21ba 21B5 83 DUP4 21B6 61 PUSH2 0x1682 21B9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21B0 stack[0] = 0x00 // @21B2 stack[1] = 0x21ba // @21B5 stack[2] = stack[-2] // } // Block ends with call to 0x1682, returns to 0x21BA label_21BA: // Incoming return from call to 0x1682 at 0x21B9 // Inputs[3] // { // @21BB stack[-2] // @21BB stack[-1] // @21C7 stack[-5] // } 21BA 5B JUMPDEST 21BB 90 SWAP1 21BC 50 POP 21BD 80 DUP1 21BE 60 PUSH1 0x01 21C0 60 PUSH1 0x01 21C2 60 PUSH1 0xa0 21C4 1B SHL 21C5 03 SUB 21C6 16 AND 21C7 84 DUP5 21C8 60 PUSH1 0x01 21CA 60 PUSH1 0x01 21CC 60 PUSH1 0xa0 21CE 1B SHL 21CF 03 SUB 21D0 16 AND 21D1 14 EQ 21D2 80 DUP1 21D3 61 PUSH2 0x21f5 21D6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21BB stack[-2] = stack[-1] // @21D1 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x21f5, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_21D7: // Incoming jump from 0x21D6, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @21D8 stack[-5] // @21E5 stack[-4] // } 21D7 50 POP 21D8 83 DUP4 21D9 60 PUSH1 0x01 21DB 60 PUSH1 0x01 21DD 60 PUSH1 0xa0 21DF 1B SHL 21E0 03 SUB 21E1 16 AND 21E2 61 PUSH2 0x21ea 21E5 84 DUP5 21E6 61 PUSH2 0x0794 21E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @21E1 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @21E2 stack[0] = 0x21ea // @21E5 stack[1] = stack[-4] // } // Block ends with call to 0x0794, returns to 0x21EA label_21EA: // Incoming return from call to 0x0794 at 0x21E9 // Inputs[2] // { // @21F3 stack[-1] // @21F4 stack[-2] // } 21EA 5B JUMPDEST 21EB 60 PUSH1 0x01 21ED 60 PUSH1 0x01 21EF 60 PUSH1 0xa0 21F1 1B SHL 21F2 03 SUB 21F3 16 AND 21F4 14 EQ // Stack delta = -1 // Outputs[1] { @21F4 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_21F5: // Incoming jump from 0x21F4 // Incoming jump from 0x21D6, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @21F6 stack[-1] } 21F5 5B JUMPDEST 21F6 80 DUP1 21F7 61 PUSH2 0x2225 21FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2225, if stack[-1] label_21FB: // Incoming jump from 0x21FA, if not stack[-1] // Inputs[5] // { // @2205 stack[-2] // @2217 memory[0x00:0x40] // @2219 stack[-5] // @2220 memory[0x00:0x40] // @2221 storage[keccak256(memory[0x00:0x40])] // } 21FB 50 POP 21FC 60 PUSH1 0x01 21FE 60 PUSH1 0x01 2200 60 PUSH1 0xa0 2202 1B SHL 2203 03 SUB 2204 80 DUP1 2205 82 DUP3 2206 16 AND 2207 60 PUSH1 0x00 2209 90 SWAP1 220A 81 DUP2 220B 52 MSTORE 220C 60 PUSH1 0x05 220E 60 PUSH1 0x20 2210 90 SWAP1 2211 81 DUP2 2212 52 MSTORE 2213 60 PUSH1 0x40 2215 80 DUP1 2216 83 DUP4 2217 20 SHA3 2218 93 SWAP4 2219 88 DUP9 221A 16 AND 221B 83 DUP4 221C 52 MSTORE 221D 92 SWAP3 221E 90 SWAP1 221F 52 MSTORE 2220 20 SHA3 2221 54 SLOAD 2222 60 PUSH1 0xff 2224 16 AND // Stack delta = +0 // Outputs[5] // { // @220B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @2212 memory[0x20:0x40] = 0x05 // @221C memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @221F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2224 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_2225: // Incoming return from call to 0x311A at 0x33A9 // Incoming jump from 0x2525, if !stack[-5] // Incoming jump from 0x2224 // Incoming jump from 0x21FA, if stack[-1] // Incoming jump from 0x2525, if !stack[-7] // Incoming jump from 0x2525, if !stack[-7] // Inputs[3] // { // @2226 stack[-6] // @2226 stack[-1] // @2227 stack[-5] // } 2225 5B JUMPDEST 2226 94 SWAP5 2227 93 SWAP4 2228 50 POP 2229 50 POP 222A 50 POP 222B 50 POP 222C 56 *JUMP // Stack delta = -5 // Outputs[1] { @2226 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_222D: // Incoming jump from 0x2943 // Inputs[2] // { // @222E stack[-3] // @223B stack[-1] // } 222D 5B JUMPDEST 222E 82 DUP3 222F 60 PUSH1 0x01 2231 60 PUSH1 0x01 2233 60 PUSH1 0xa0 2235 1B SHL 2236 03 SUB 2237 16 AND 2238 61 PUSH2 0x2240 223B 82 DUP3 223C 61 PUSH2 0x1682 223F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2237 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @2238 stack[1] = 0x2240 // @223B stack[2] = stack[-1] // } // Block ends with call to 0x1682, returns to 0x2240 label_2240: // Incoming return from call to 0x1682 at 0x223F // Inputs[2] // { // @2249 stack[-1] // @224A stack[-2] // } 2240 5B JUMPDEST 2241 60 PUSH1 0x01 2243 60 PUSH1 0x01 2245 60 PUSH1 0xa0 2247 1B SHL 2248 03 SUB 2249 16 AND 224A 14 EQ 224B 61 PUSH2 0x22a8 224E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x22a8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_224F: // Incoming jump from 0x224E, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @2251 memory[0x40:0x60] } 224F 60 PUSH1 0x40 2251 51 MLOAD 2252 62 PUSH3 0x461bcd 2256 60 PUSH1 0xe5 2258 1B SHL 2259 81 DUP2 225A 52 MSTORE 225B 60 PUSH1 0x20 225D 60 PUSH1 0x04 225F 82 DUP3 2260 01 ADD 2261 52 MSTORE 2262 60 PUSH1 0x29 2264 60 PUSH1 0x24 2266 82 DUP3 2267 01 ADD 2268 52 MSTORE 2269 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 228A 60 PUSH1 0x44 228C 82 DUP3 228D 01 ADD 228E 52 MSTORE 228F 68 PUSH9 0x39903737ba1037bbb7 2299 60 PUSH1 0xb9 229B 1B SHL 229C 60 PUSH1 0x64 229E 82 DUP3 229F 01 ADD 22A0 52 MSTORE 22A1 60 PUSH1 0x84 22A3 01 ADD 22A4 61 PUSH2 0x0809 22A7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @225A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2261 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2268 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @228E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @22A0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39903737ba1037bbb7 << 0xb9 // @22A3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_22A8: // Incoming jump from 0x224E, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @22B1 stack[-2] } 22A8 5B JUMPDEST 22A9 60 PUSH1 0x01 22AB 60 PUSH1 0x01 22AD 60 PUSH1 0xa0 22AF 1B SHL 22B0 03 SUB 22B1 82 DUP3 22B2 16 AND 22B3 61 PUSH2 0x230a 22B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x230a, if stack[-2] & (0x01 << 0xa0) - 0x01 label_22B7: // Incoming jump from 0x22B6, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @22B9 memory[0x40:0x60] } 22B7 60 PUSH1 0x40 22B9 51 MLOAD 22BA 62 PUSH3 0x461bcd 22BE 60 PUSH1 0xe5 22C0 1B SHL 22C1 81 DUP2 22C2 52 MSTORE 22C3 60 PUSH1 0x20 22C5 60 PUSH1 0x04 22C7 82 DUP3 22C8 01 ADD 22C9 52 MSTORE 22CA 60 PUSH1 0x24 22CC 80 DUP1 22CD 82 DUP3 22CE 01 ADD 22CF 52 MSTORE 22D0 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 22F1 60 PUSH1 0x44 22F3 82 DUP3 22F4 01 ADD 22F5 52 MSTORE 22F6 63 PUSH4 0x72657373 22FB 60 PUSH1 0xe0 22FD 1B SHL 22FE 60 PUSH1 0x64 2300 82 DUP3 2301 01 ADD 2302 52 MSTORE 2303 60 PUSH1 0x84 2305 01 ADD 2306 61 PUSH2 0x0809 2309 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @22C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @22C9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @22CF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @22F5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @2302 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @2305 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_230A: // Incoming jump from 0x22B6, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @230E stack[-3] // @230F stack[-2] // @2310 stack[-1] // } 230A 5B JUMPDEST 230B 61 PUSH2 0x2315 230E 83 DUP4 230F 83 DUP4 2310 83 DUP4 2311 61 PUSH2 0x29bc 2314 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @230B stack[0] = 0x2315 // @230E stack[1] = stack[-3] // @230F stack[2] = stack[-2] // @2310 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x29bc 2315 5B JUMPDEST 2316 61 PUSH2 0x2320 2319 60 PUSH1 0x00 231B 82 DUP3 231C 61 PUSH2 0x20c8 231F 56 *JUMP 2320 5B JUMPDEST 2321 60 PUSH1 0x01 2323 60 PUSH1 0x01 2325 60 PUSH1 0xa0 2327 1B SHL 2328 03 SUB 2329 83 DUP4 232A 16 AND 232B 60 PUSH1 0x00 232D 90 SWAP1 232E 81 DUP2 232F 52 MSTORE 2330 60 PUSH1 0x03 2332 60 PUSH1 0x20 2334 52 MSTORE 2335 60 PUSH1 0x40 2337 81 DUP2 2338 20 SHA3 2339 80 DUP1 233A 54 SLOAD 233B 60 PUSH1 0x01 233D 92 SWAP3 233E 90 SWAP1 233F 61 PUSH2 0x2349 2342 90 SWAP1 2343 84 DUP5 2344 90 SWAP1 2345 61 PUSH2 0x371a 2348 56 *JUMP 2349 5B JUMPDEST 234A 90 SWAP1 234B 91 SWAP2 234C 55 SSTORE 234D 50 POP 234E 50 POP 234F 60 PUSH1 0x01 2351 60 PUSH1 0x01 2353 60 PUSH1 0xa0 2355 1B SHL 2356 03 SUB 2357 82 DUP3 2358 16 AND 2359 60 PUSH1 0x00 235B 90 SWAP1 235C 81 DUP2 235D 52 MSTORE 235E 60 PUSH1 0x03 2360 60 PUSH1 0x20 2362 52 MSTORE 2363 60 PUSH1 0x40 2365 81 DUP2 2366 20 SHA3 2367 80 DUP1 2368 54 SLOAD 2369 60 PUSH1 0x01 236B 92 SWAP3 236C 90 SWAP1 236D 61 PUSH2 0x2377 2370 90 SWAP1 2371 84 DUP5 2372 90 SWAP1 2373 61 PUSH2 0x36cf 2376 56 *JUMP 2377 5B JUMPDEST 2378 90 SWAP1 2379 91 SWAP2 237A 55 SSTORE 237B 50 POP 237C 50 POP 237D 60 PUSH1 0x00 237F 81 DUP2 2380 81 DUP2 2381 52 MSTORE 2382 60 PUSH1 0x02 2384 60 PUSH1 0x20 2386 52 MSTORE 2387 60 PUSH1 0x40 2389 80 DUP1 238A 82 DUP3 238B 20 SHA3 238C 80 DUP1 238D 54 SLOAD 238E 60 PUSH1 0x01 2390 60 PUSH1 0x01 2392 60 PUSH1 0xa0 2394 1B SHL 2395 03 SUB 2396 19 NOT 2397 16 AND 2398 60 PUSH1 0x01 239A 60 PUSH1 0x01 239C 60 PUSH1 0xa0 239E 1B SHL 239F 03 SUB 23A0 86 DUP7 23A1 81 DUP2 23A2 16 AND 23A3 91 SWAP2 23A4 82 DUP3 23A5 17 OR 23A6 90 SWAP1 23A7 92 SWAP3 23A8 55 SSTORE 23A9 91 SWAP2 23AA 51 MLOAD 23AB 84 DUP5 23AC 93 SWAP4 23AD 91 SWAP2 23AE 87 DUP8 23AF 16 AND 23B0 91 SWAP2 23B1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 23D2 91 SWAP2 23D3 A4 LOG4 23D4 50 POP 23D5 50 POP 23D6 50 POP 23D7 56 *JUMP label_23D8: // Incoming jump from 0x0B15 // Inputs[2] // { // @23DC stack[-1] // @23DF memory[0x40:0x60] // } 23D8 5B JUMPDEST 23D9 61 PUSH2 0x159b 23DC 81 DUP2 23DD 60 PUSH1 0x40 23DF 51 MLOAD 23E0 60 PUSH1 0x24 23E2 01 ADD 23E3 61 PUSH2 0x23ec 23E6 91 SWAP2 23E7 90 SWAP1 23E8 61 PUSH2 0x3570 23EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23D9 stack[0] = 0x159b // @23E6 stack[1] = 0x23ec // @23E7 stack[2] = stack[-1] // @23E7 stack[3] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x3570, returns to 0x23EC label_23EC: // Incoming return from call to 0x3570 at 0x23EB // Inputs[3] // { // @23F0 memory[0x40:0x60] // @23F5 stack[-1] // @2402 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // } 23EC 5B JUMPDEST 23ED 60 PUSH1 0x40 23EF 80 DUP1 23F0 51 MLOAD 23F1 60 PUSH1 0x1f 23F3 19 NOT 23F4 81 DUP2 23F5 84 DUP5 23F6 03 SUB 23F7 01 ADD 23F8 81 DUP2 23F9 52 MSTORE 23FA 91 SWAP2 23FB 90 SWAP1 23FC 52 MSTORE 23FD 60 PUSH1 0x20 23FF 81 DUP2 2400 01 ADD 2401 80 DUP1 2402 51 MLOAD 2403 60 PUSH1 0x01 2405 60 PUSH1 0x01 2407 60 PUSH1 0xe0 2409 1B SHL 240A 03 SUB 240B 16 AND 240C 63 PUSH4 0x104c13eb 2411 60 PUSH1 0xe2 2413 1B SHL 2414 17 OR 2415 90 SWAP1 2416 52 MSTORE 2417 61 PUSH2 0x29c7 241A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @23F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @23FA stack[-1] = memory[0x40:0x60] // @23FC memory[0x40:0x60] = stack[-1] // @2416 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x104c13eb << 0xe2) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // } // Block ends with unconditional jump to 0x29c7 241B 5B JUMPDEST 241C 61 PUSH2 0x1413 241F 82 DUP3 2420 82 DUP3 2421 60 PUSH1 0x40 2423 51 MLOAD 2424 60 PUSH1 0x24 2426 01 ADD 2427 61 PUSH2 0x2431 242A 92 SWAP3 242B 91 SWAP2 242C 90 SWAP1 242D 61 PUSH2 0x35d5 2430 56 *JUMP 2431 5B JUMPDEST 2432 60 PUSH1 0x40 2434 80 DUP1 2435 51 MLOAD 2436 60 PUSH1 0x1f 2438 19 NOT 2439 81 DUP2 243A 84 DUP5 243B 03 SUB 243C 01 ADD 243D 81 DUP2 243E 52 MSTORE 243F 91 SWAP2 2440 90 SWAP1 2441 52 MSTORE 2442 60 PUSH1 0x20 2444 81 DUP2 2445 01 ADD 2446 80 DUP1 2447 51 MLOAD 2448 60 PUSH1 0x01 244A 60 PUSH1 0x01 244C 60 PUSH1 0xe0 244E 1B SHL 244F 03 SUB 2450 16 AND 2451 63 PUSH4 0x09710a9d 2456 60 PUSH1 0xe4 2458 1B SHL 2459 17 OR 245A 90 SWAP1 245B 52 MSTORE 245C 61 PUSH2 0x29c7 245F 56 *JUMP 2460 5B JUMPDEST 2461 61 PUSH2 0x1413 2464 82 DUP3 2465 82 DUP3 2466 60 PUSH1 0x40 2468 51 MLOAD 2469 80 DUP1 246A 60 PUSH1 0x20 246C 01 ADD 246D 60 PUSH1 0x40 246F 52 MSTORE 2470 80 DUP1 2471 60 PUSH1 0x00 2473 81 DUP2 2474 52 MSTORE 2475 50 POP 2476 61 PUSH2 0x29e8 2479 56 *JUMP label_247A: // Incoming call from 0x1CC7, returns to 0x1CC8 // Inputs[1] { @247D stack[-1] } 247A 5B JUMPDEST 247B 60 PUSH1 0x60 247D 81 DUP2 247E 61 PUSH2 0x249e 2481 57 *JUMPI // Stack delta = +1 // Outputs[1] { @247B stack[0] = 0x60 } // Block ends with conditional jump to 0x249e, if stack[-1] label_2482: // Incoming jump from 0x2481, if not stack[-1] // Inputs[2] // { // @2487 memory[0x40:0x60] // @249C stack[-3] // } 2482 50 POP 2483 50 POP 2484 60 PUSH1 0x40 2486 80 DUP1 2487 51 MLOAD 2488 80 DUP1 2489 82 DUP3 248A 01 ADD 248B 90 SWAP1 248C 91 SWAP2 248D 52 MSTORE 248E 60 PUSH1 0x01 2490 81 DUP2 2491 52 MSTORE 2492 60 PUSH1 0x03 2494 60 PUSH1 0xfc 2496 1B SHL 2497 60 PUSH1 0x20 2499 82 DUP3 249A 01 ADD 249B 52 MSTORE 249C 90 SWAP1 249D 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @248D memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2491 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @249B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @249C stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_249E: // Incoming jump from 0x2481, if stack[-1] // Inputs[1] { @249F stack[-2] } 249E 5B JUMPDEST 249F 81 DUP2 24A0 60 PUSH1 0x00 24A2 5B JUMPDEST 24A3 81 DUP2 24A4 15 ISZERO 24A5 61 PUSH2 0x24c8 24A8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @249F stack[0] = stack[-2] // @24A0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x24c8, if !stack[-2] label_24A9: // Incoming jump from 0x24A8, if not !stack[-2] // Incoming jump from 0x24A8, if not !stack[-2] // Inputs[1] { @24A9 stack[-1] } 24A9 80 DUP1 24AA 61 PUSH2 0x24b2 24AD 81 DUP2 24AE 61 PUSH2 0x37af 24B1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24A9 stack[0] = stack[-1] // @24AA stack[1] = 0x24b2 // @24AD stack[2] = stack[-1] // } // Block ends with call to 0x37af, returns to 0x24B2 label_24B2: // Incoming return from call to 0x37AF at 0x24B1 // Inputs[4] // { // @24B3 stack[-1] // @24B3 stack[-3] // @24B8 stack[-2] // @24BC stack[-4] // } 24B2 5B JUMPDEST 24B3 91 SWAP2 24B4 50 POP 24B5 61 PUSH2 0x24c1 24B8 90 SWAP1 24B9 50 POP 24BA 60 PUSH1 0x0a 24BC 83 DUP4 24BD 61 PUSH2 0x36e7 24C0 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @24B3 stack[-3] = stack[-1] // @24B8 stack[-2] = 0x24c1 // @24BA stack[-1] = 0x0a // @24BC stack[0] = stack[-4] // } // Block ends with call to 0x36e7, returns to 0x24C1 label_24C1: // Incoming return from call to 0x36E7 at 0x24C0 // Inputs[2] // { // @24C2 stack[-3] // @24C2 stack[-1] // } 24C1 5B JUMPDEST 24C2 91 SWAP2 24C3 50 POP 24C4 61 PUSH2 0x24a2 24C7 56 *JUMP // Stack delta = -1 // Outputs[1] { @24C2 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x24a2 label_24C8: // Incoming jump from 0x24A8, if !stack[-2] // Incoming jump from 0x24A8, if !stack[-2] // Inputs[1] { @24CB stack[-1] } 24C8 5B JUMPDEST 24C9 60 PUSH1 0x00 24CB 81 DUP2 24CC 67 PUSH8 0xffffffffffffffff 24D5 81 DUP2 24D6 11 GT 24D7 15 ISZERO 24D8 61 PUSH2 0x24f1 24DB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @24C9 stack[0] = 0x00 // @24CB stack[1] = stack[-1] // } // Block ends with conditional jump to 0x24f1, if !(stack[-1] > 0xffffffffffffffff) label_24DC: // Incoming jump from 0x24DB, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @24F0 memory[0x00:0x24] } 24DC 63 PUSH4 0x4e487b71 24E1 60 PUSH1 0xe0 24E3 1B SHL 24E4 60 PUSH1 0x00 24E6 52 MSTORE 24E7 60 PUSH1 0x41 24E9 60 PUSH1 0x04 24EB 52 MSTORE 24EC 60 PUSH1 0x24 24EE 60 PUSH1 0x00 24F0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @24E6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @24EB memory[0x04:0x24] = 0x41 // @24F0 revert(memory[0x00:0x24]); // } // Block terminates label_24F1: // Incoming jump from 0x24DB, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @24F4 memory[0x40:0x60] // @24F5 stack[-1] // } 24F1 5B JUMPDEST 24F2 60 PUSH1 0x40 24F4 51 MLOAD 24F5 90 SWAP1 24F6 80 DUP1 24F7 82 DUP3 24F8 52 MSTORE 24F9 80 DUP1 24FA 60 PUSH1 0x1f 24FC 01 ADD 24FD 60 PUSH1 0x1f 24FF 19 NOT 2500 16 AND 2501 60 PUSH1 0x20 2503 01 ADD 2504 82 DUP3 2505 01 ADD 2506 60 PUSH1 0x40 2508 52 MSTORE 2509 80 DUP1 250A 15 ISZERO 250B 61 PUSH2 0x251b 250E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @24F5 stack[-1] = memory[0x40:0x60] // @24F5 stack[0] = stack[-1] // @24F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2508 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x251b, if !stack[-1] label_250F: // Incoming jump from 0x250E, if not !stack[-1] // Inputs[6] // { // @2511 stack[-2] // @2513 stack[-1] // @2515 msg.data.length // @2517 msg.data[msg.data.length:msg.data.length + stack[-1]] // @251D stack[-3] // @2520 stack[-7] // } 250F 60 PUSH1 0x20 2511 82 DUP3 2512 01 ADD 2513 81 DUP2 2514 80 DUP1 2515 36 CALLDATASIZE 2516 83 DUP4 2517 37 CALLDATACOPY 2518 01 ADD 2519 90 SWAP1 251A 50 POP 251B 5B JUMPDEST 251C 50 POP 251D 90 SWAP1 251E 50 POP 251F 5B JUMPDEST 2520 84 DUP5 2521 15 ISZERO 2522 61 PUSH2 0x2225 2525 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2517 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @251D stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x2225, if !stack[-7] label_2526: // Incoming jump from 0x2525, if not !stack[-7] // Incoming jump from 0x2525, if not !stack[-5] // Incoming jump from 0x2525, if not !stack[-7] // Inputs[1] { @252B stack[-2] } 2526 61 PUSH2 0x2530 2529 60 PUSH1 0x01 252B 83 DUP4 252C 61 PUSH2 0x371a 252F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2526 stack[0] = 0x2530 // @2529 stack[1] = 0x01 // @252B stack[2] = stack[-2] // } // Block ends with call to 0x371a, returns to 0x2530 label_2530: // Incoming return from call to 0x371A at 0x252F // Inputs[3] // { // @2531 stack[-3] // @2531 stack[-1] // @2538 stack[-6] // } 2530 5B JUMPDEST 2531 91 SWAP2 2532 50 POP 2533 61 PUSH2 0x253d 2536 60 PUSH1 0x0a 2538 86 DUP7 2539 61 PUSH2 0x37ca 253C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2531 stack[-3] = stack[-1] // @2533 stack[-1] = 0x253d // @2536 stack[0] = 0x0a // @2538 stack[1] = stack[-6] // } // Block ends with call to 0x37ca, returns to 0x253D label_253D: // Incoming return from call to 0x37CA at 0x253C // Inputs[1] { @2541 stack[-1] } 253D 5B JUMPDEST 253E 61 PUSH2 0x2548 2541 90 SWAP1 2542 60 PUSH1 0x30 2544 61 PUSH2 0x36cf 2547 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2541 stack[0] = stack[-1] // @2541 stack[-1] = 0x2548 // @2542 stack[1] = 0x30 // } // Block ends with call to 0x36cf, returns to 0x2548 label_2548: // Incoming return from call to 0x36CF at 0x2547 // Inputs[4] // { // @254B stack[-1] // @254C stack[-2] // @254D stack[-3] // @254F memory[stack[-2]:stack[-2] + 0x20] // } 2548 5B JUMPDEST 2549 60 PUSH1 0xf8 254B 1B SHL 254C 81 DUP2 254D 83 DUP4 254E 81 DUP2 254F 51 MLOAD 2550 81 DUP2 2551 10 LT 2552 61 PUSH2 0x256b 2555 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @254B stack[-1] = stack[-1] << 0xf8 // @254C stack[0] = stack[-2] // @254D stack[1] = stack[-3] // } // Block ends with conditional jump to 0x256b, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_2556: // Incoming jump from 0x2555, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @256A memory[0x00:0x24] } 2556 63 PUSH4 0x4e487b71 255B 60 PUSH1 0xe0 255D 1B SHL 255E 60 PUSH1 0x00 2560 52 MSTORE 2561 60 PUSH1 0x32 2563 60 PUSH1 0x04 2565 52 MSTORE 2566 60 PUSH1 0x24 2568 60 PUSH1 0x00 256A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2560 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2565 memory[0x04:0x24] = 0x32 // @256A revert(memory[0x00:0x24]); // } // Block terminates label_256B: // Incoming jump from 0x2555, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @256E stack[-1] // @256F stack[-2] // @2570 stack[-3] // @2588 stack[-8] // } 256B 5B JUMPDEST 256C 60 PUSH1 0x20 256E 01 ADD 256F 01 ADD 2570 90 SWAP1 2571 60 PUSH1 0x01 2573 60 PUSH1 0x01 2575 60 PUSH1 0xf8 2577 1B SHL 2578 03 SUB 2579 19 NOT 257A 16 AND 257B 90 SWAP1 257C 81 DUP2 257D 60 PUSH1 0x00 257F 1A BYTE 2580 90 SWAP1 2581 53 MSTORE8 2582 50 POP 2583 61 PUSH2 0x258d 2586 60 PUSH1 0x0a 2588 86 DUP7 2589 61 PUSH2 0x36e7 258C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2581 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2583 stack[-3] = 0x258d // @2586 stack[-2] = 0x0a // @2588 stack[-1] = stack[-8] // } // Block ends with call to 0x36e7, returns to 0x258D label_258D: // Incoming return from call to 0x36E7 at 0x258C // Inputs[2] // { // @258E stack[-1] // @258E stack[-6] // } 258D 5B JUMPDEST 258E 94 SWAP5 258F 50 POP 2590 61 PUSH2 0x251f 2593 56 *JUMP // Stack delta = -1 // Outputs[1] { @258E stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x251f 2594 5B JUMPDEST 2595 61 PUSH2 0x1413 2598 82 DUP3 2599 82 DUP3 259A 60 PUSH1 0x40 259C 51 MLOAD 259D 60 PUSH1 0x24 259F 01 ADD 25A0 61 PUSH2 0x25aa 25A3 92 SWAP3 25A4 91 SWAP2 25A5 90 SWAP1 25A6 61 PUSH2 0x35a7 25A9 56 *JUMP 25AA 5B JUMPDEST 25AB 60 PUSH1 0x40 25AD 80 DUP1 25AE 51 MLOAD 25AF 60 PUSH1 0x1f 25B1 19 NOT 25B2 81 DUP2 25B3 84 DUP5 25B4 03 SUB 25B5 01 ADD 25B6 81 DUP2 25B7 52 MSTORE 25B8 91 SWAP2 25B9 90 SWAP1 25BA 52 MSTORE 25BB 60 PUSH1 0x20 25BD 81 DUP2 25BE 01 ADD 25BF 80 DUP1 25C0 51 MLOAD 25C1 60 PUSH1 0x01 25C3 60 PUSH1 0x01 25C5 60 PUSH1 0xe0 25C7 1B SHL 25C8 03 SUB 25C9 16 AND 25CA 63 PUSH4 0x4b5c4277 25CF 60 PUSH1 0xe0 25D1 1B SHL 25D2 17 OR 25D3 90 SWAP1 25D4 52 MSTORE 25D5 61 PUSH2 0x29c7 25D8 56 *JUMP label_25D9: // Incoming call from 0x1D0B, returns to 0x1D0C // Incoming call from 0x132F, returns to 0x1330 // Inputs[2] // { // @25DD stack[-2] // @25DE stack[-1] // } 25D9 5B JUMPDEST 25DA 61 PUSH2 0x25e3 25DD 82 DUP3 25DE 82 DUP3 25DF 61 PUSH2 0x1827 25E2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25DA stack[0] = 0x25e3 // @25DD stack[1] = stack[-2] // @25DE stack[2] = stack[-1] // } // Block ends with call to 0x1827, returns to 0x25E3 label_25E3: // Incoming return from call to 0x1827 at 0x25E2 // Inputs[1] { @25E7 stack[-1] } 25E3 5B JUMPDEST 25E4 61 PUSH2 0x1413 25E7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1413, if stack[-1] label_25E8: // Incoming jump from 0x25E7, if not stack[-1] // Inputs[1] { @25EB stack[-1] } 25E8 61 PUSH2 0x25fb 25EB 81 DUP2 25EC 60 PUSH1 0x01 25EE 60 PUSH1 0x01 25F0 60 PUSH1 0xa0 25F2 1B SHL 25F3 03 SUB 25F4 16 AND 25F5 60 PUSH1 0x14 25F7 61 PUSH2 0x1ec1 25FA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25E8 stack[0] = 0x25fb // @25F4 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @25F5 stack[2] = 0x14 // } // Block ends with call to 0x1ec1, returns to 0x25FB label_25FB: // Incoming return from call to 0x1EC1 at 0x25FA // Inputs[1] { @25FF stack[-3] } 25FB 5B JUMPDEST 25FC 61 PUSH2 0x2606 25FF 83 DUP4 2600 60 PUSH1 0x20 2602 61 PUSH2 0x1ec1 2605 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25FC stack[0] = 0x2606 // @25FF stack[1] = stack[-3] // @2600 stack[2] = 0x20 // } // Block ends with call to 0x1ec1, returns to 0x2606 label_2606: // Incoming return from call to 0x1EC1 at 0x2605 // Inputs[3] // { // @2609 memory[0x40:0x60] // @2610 stack[-2] // @2611 stack[-1] // } 2606 5B JUMPDEST 2607 60 PUSH1 0x40 2609 51 MLOAD 260A 60 PUSH1 0x20 260C 01 ADD 260D 61 PUSH2 0x2617 2610 92 SWAP3 2611 91 SWAP2 2612 90 SWAP1 2613 61 PUSH2 0x34be 2616 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2610 stack[-2] = 0x2617 // @2611 stack[-1] = stack[-2] // @2612 stack[1] = 0x20 + memory[0x40:0x60] // @2612 stack[0] = stack[-1] // } // Block ends with call to 0x34be, returns to 0x2617 label_2617: // Incoming return from call to 0x34BE at 0x2616 // Inputs[2] // { // @261B memory[0x40:0x60] // @2620 stack[-1] // } 2617 5B JUMPDEST 2618 60 PUSH1 0x40 261A 80 DUP1 261B 51 MLOAD 261C 60 PUSH1 0x1f 261E 19 NOT 261F 81 DUP2 2620 84 DUP5 2621 03 SUB 2622 01 ADD 2623 81 DUP2 2624 52 MSTORE 2625 90 SWAP1 2626 82 DUP3 2627 90 SWAP1 2628 52 MSTORE 2629 62 PUSH3 0x461bcd 262D 60 PUSH1 0xe5 262F 1B SHL 2630 82 DUP3 2631 52 MSTORE 2632 61 PUSH2 0x0809 2635 91 SWAP2 2636 60 PUSH1 0x04 2638 01 ADD 2639 61 PUSH2 0x3570 263C 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @2624 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @2625 stack[0] = memory[0x40:0x60] // @2628 memory[0x40:0x60] = stack[-1] // @2631 memory[stack[-1]:stack[-1] + 0x20] = 0x461bcd << 0xe5 // @2635 stack[-1] = 0x0809 // @2638 stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x3570, returns to 0x0809 label_263D: // Incoming call from 0x1339, returns to 0x093F // Inputs[2] // { // @2641 stack[-2] // @2642 stack[-1] // } 263D 5B JUMPDEST 263E 61 PUSH2 0x2647 2641 82 DUP3 2642 82 DUP3 2643 61 PUSH2 0x1827 2646 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @263E stack[0] = 0x2647 // @2641 stack[1] = stack[-2] // @2642 stack[2] = stack[-1] // } // Block ends with call to 0x1827, returns to 0x2647 label_2647: // Incoming return from call to 0x1827 at 0x2646 // Inputs[1] { @264B stack[-1] } 2647 5B JUMPDEST 2648 61 PUSH2 0x1413 264B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1413, if stack[-1] label_264C: // Incoming jump from 0x264B, if not stack[-1] // Inputs[6] // { // @264E stack[-2] // @265C memory[0x00:0x40] // @2665 stack[-1] // @266D memory[0x00:0x40] // @266F storage[keccak256(memory[0x00:0x40])] // @267C msg.sender // } 264C 60 PUSH1 0x00 264E 82 DUP3 264F 81 DUP2 2650 52 MSTORE 2651 60 PUSH1 0x06 2653 60 PUSH1 0x20 2655 90 SWAP1 2656 81 DUP2 2657 52 MSTORE 2658 60 PUSH1 0x40 265A 80 DUP1 265B 83 DUP4 265C 20 SHA3 265D 60 PUSH1 0x01 265F 60 PUSH1 0x01 2661 60 PUSH1 0xa0 2663 1B SHL 2664 03 SUB 2665 85 DUP6 2666 16 AND 2667 84 DUP5 2668 52 MSTORE 2669 90 SWAP1 266A 91 SWAP2 266B 52 MSTORE 266C 90 SWAP1 266D 20 SHA3 266E 80 DUP1 266F 54 SLOAD 2670 60 PUSH1 0xff 2672 19 NOT 2673 16 AND 2674 60 PUSH1 0x01 2676 17 OR 2677 90 SWAP1 2678 55 SSTORE 2679 61 PUSH2 0x267f 267C 33 CALLER 267D 90 SWAP1 267E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2650 memory[0x00:0x20] = stack[-2] // @2657 memory[0x20:0x40] = 0x06 // @2668 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @266B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2678 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @267D stack[0] = msg.sender // } // Block ends with unconditional jump to 0x267f label_267F: // Incoming jump from 0x267E // Inputs[7] // { // @2688 stack[-1] // @2689 stack[-2] // @2693 stack[-3] // @26B7 memory[0x40:0x60] // @26BA memory[0x40:0x60] // @26BF memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @26C2 stack[-4] // } 267F 5B JUMPDEST 2680 60 PUSH1 0x01 2682 60 PUSH1 0x01 2684 60 PUSH1 0xa0 2686 1B SHL 2687 03 SUB 2688 16 AND 2689 81 DUP2 268A 60 PUSH1 0x01 268C 60 PUSH1 0x01 268E 60 PUSH1 0xa0 2690 1B SHL 2691 03 SUB 2692 16 AND 2693 83 DUP4 2694 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 26B5 60 PUSH1 0x40 26B7 51 MLOAD 26B8 60 PUSH1 0x40 26BA 51 MLOAD 26BB 80 DUP1 26BC 91 SWAP2 26BD 03 SUB 26BE 90 SWAP1 26BF A4 LOG4 26C0 50 POP 26C1 50 POP 26C2 56 *JUMP // Stack delta = -4 // Outputs[1] { @26BF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d, stack[-3], stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-4] label_26C3: // Incoming call from 0x1490, returns to 0x1413 // Incoming call from 0x1D15, returns to 0x093F // Inputs[2] // { // @26C7 stack[-2] // @26C8 stack[-1] // } 26C3 5B JUMPDEST 26C4 61 PUSH2 0x26cd 26C7 82 DUP3 26C8 82 DUP3 26C9 61 PUSH2 0x1827 26CC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @26C4 stack[0] = 0x26cd // @26C7 stack[1] = stack[-2] // @26C8 stack[2] = stack[-1] // } // Block ends with call to 0x1827, returns to 0x26CD label_26CD: // Incoming return from call to 0x1827 at 0x26CC // Inputs[1] { @26CE stack[-1] } 26CD 5B JUMPDEST 26CE 15 ISZERO 26CF 61 PUSH2 0x1413 26D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1413, if !stack[-1] label_26D3: // Incoming jump from 0x26D2, if not !stack[-1] // Inputs[9] // { // @26D5 stack[-2] // @26E3 memory[0x00:0x40] // @26EC stack[-1] // @26F5 memory[0x00:0x40] // @26F7 storage[keccak256(memory[0x00:0x40])] // @26FE memory[0x40:0x60] // @26FF msg.sender // @2726 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2729 stack[-3] // } 26D3 60 PUSH1 0x00 26D5 82 DUP3 26D6 81 DUP2 26D7 52 MSTORE 26D8 60 PUSH1 0x06 26DA 60 PUSH1 0x20 26DC 90 SWAP1 26DD 81 DUP2 26DE 52 MSTORE 26DF 60 PUSH1 0x40 26E1 80 DUP1 26E2 83 DUP4 26E3 20 SHA3 26E4 60 PUSH1 0x01 26E6 60 PUSH1 0x01 26E8 60 PUSH1 0xa0 26EA 1B SHL 26EB 03 SUB 26EC 85 DUP6 26ED 16 AND 26EE 80 DUP1 26EF 85 DUP6 26F0 52 MSTORE 26F1 92 SWAP3 26F2 52 MSTORE 26F3 80 DUP1 26F4 83 DUP4 26F5 20 SHA3 26F6 80 DUP1 26F7 54 SLOAD 26F8 60 PUSH1 0xff 26FA 19 NOT 26FB 16 AND 26FC 90 SWAP1 26FD 55 SSTORE 26FE 51 MLOAD 26FF 33 CALLER 2700 92 SWAP3 2701 85 DUP6 2702 91 SWAP2 2703 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 2724 91 SWAP2 2725 90 SWAP1 2726 A4 LOG4 2727 50 POP 2728 50 POP 2729 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @26D7 memory[0x00:0x20] = stack[-2] // @26DE memory[0x20:0x40] = 0x06 // @26F0 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @26F2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @26FD storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @2726 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b, stack[-2], stack[-1] & (0x01 << 0xa0) - 0x01, msg.sender]); // } // Block ends with unconditional jump to stack[-3] label_272A: // Incoming call from 0x1506, returns to 0x1507 // Inputs[1] { @272D storage[0x0b] } 272A 5B JUMPDEST 272B 60 PUSH1 0x0b 272D 54 SLOAD 272E 60 PUSH1 0xff 2730 16 AND 2731 61 PUSH2 0x2773 2734 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2773, if 0xff & storage[0x0b] label_2735: // Incoming jump from 0x2734, if not 0xff & storage[0x0b] // Inputs[1] { @2737 memory[0x40:0x60] } 2735 60 PUSH1 0x40 2737 51 MLOAD 2738 62 PUSH3 0x461bcd 273C 60 PUSH1 0xe5 273E 1B SHL 273F 81 DUP2 2740 52 MSTORE 2741 60 PUSH1 0x20 2743 60 PUSH1 0x04 2745 82 DUP3 2746 01 ADD 2747 52 MSTORE 2748 60 PUSH1 0x14 274A 60 PUSH1 0x24 274C 82 DUP3 274D 01 ADD 274E 52 MSTORE 274F 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 2764 60 PUSH1 0x62 2766 1B SHL 2767 60 PUSH1 0x44 2769 82 DUP3 276A 01 ADD 276B 52 MSTORE 276C 60 PUSH1 0x64 276E 01 ADD 276F 61 PUSH2 0x0809 2772 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2740 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2747 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @274E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @276B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @276E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_2773: // Incoming jump from 0x2734, if 0xff & storage[0x0b] // Inputs[2] // { // @2777 storage[0x0b] // @279F msg.sender // } 2773 5B JUMPDEST 2774 60 PUSH1 0x0b 2776 80 DUP1 2777 54 SLOAD 2778 60 PUSH1 0xff 277A 19 NOT 277B 16 AND 277C 90 SWAP1 277D 55 SSTORE 277E 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 279F 33 CALLER // Stack delta = +2 // Outputs[3] // { // @277D storage[0x0b] = ~0xff & storage[0x0b] // @277E stack[0] = 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa // @279F stack[1] = msg.sender // } // Block continues label_27A0: // Incoming jump from 0x279F // Incoming jump from 0x2938 // Inputs[6] // { // @27A3 memory[0x40:0x60] // @27AD stack[-1] // @27B6 memory[0x40:0x60] // @27BB stack[-2] // @27BB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @27BC stack[-3] // } 27A0 5B JUMPDEST 27A1 60 PUSH1 0x40 27A3 51 MLOAD 27A4 60 PUSH1 0x01 27A6 60 PUSH1 0x01 27A8 60 PUSH1 0xa0 27AA 1B SHL 27AB 03 SUB 27AC 90 SWAP1 27AD 91 SWAP2 27AE 16 AND 27AF 81 DUP2 27B0 52 MSTORE 27B1 60 PUSH1 0x20 27B3 01 ADD 27B4 60 PUSH1 0x40 27B6 51 MLOAD 27B7 80 DUP1 27B8 91 SWAP2 27B9 03 SUB 27BA 90 SWAP1 27BB A1 LOG1 27BC 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @27B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @27BB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // } // Block ends with unconditional jump to stack[-3] label_27BD: // Incoming jump from 0x159A // Inputs[1] { @27C3 stack[-1] } 27BD 5B JUMPDEST 27BE 60 PUSH1 0x00 27C0 61 PUSH2 0x27c8 27C3 82 DUP3 27C4 61 PUSH2 0x1682 27C7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27BE stack[0] = 0x00 // @27C0 stack[1] = 0x27c8 // @27C3 stack[2] = stack[-1] // } // Block ends with call to 0x1682, returns to 0x27C8 label_27C8: // Incoming return from call to 0x1682 at 0x27C7 // Inputs[3] // { // @27C9 stack[-2] // @27C9 stack[-1] // @27D1 stack[-3] // } 27C8 5B JUMPDEST 27C9 90 SWAP1 27CA 50 POP 27CB 61 PUSH2 0x27d6 27CE 81 DUP2 27CF 60 PUSH1 0x00 27D1 84 DUP5 27D2 61 PUSH2 0x29bc 27D5 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @27C9 stack[-2] = stack[-1] // @27CB stack[-1] = 0x27d6 // @27CE stack[0] = stack[-1] // @27CF stack[1] = 0x00 // @27D1 stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x29bc 27D6 5B JUMPDEST 27D7 61 PUSH2 0x27e1 27DA 60 PUSH1 0x00 27DC 83 DUP4 27DD 61 PUSH2 0x20c8 27E0 56 *JUMP 27E1 5B JUMPDEST 27E2 60 PUSH1 0x01 27E4 60 PUSH1 0x01 27E6 60 PUSH1 0xa0 27E8 1B SHL 27E9 03 SUB 27EA 81 DUP2 27EB 16 AND 27EC 60 PUSH1 0x00 27EE 90 SWAP1 27EF 81 DUP2 27F0 52 MSTORE 27F1 60 PUSH1 0x03 27F3 60 PUSH1 0x20 27F5 52 MSTORE 27F6 60 PUSH1 0x40 27F8 81 DUP2 27F9 20 SHA3 27FA 80 DUP1 27FB 54 SLOAD 27FC 60 PUSH1 0x01 27FE 92 SWAP3 27FF 90 SWAP1 2800 61 PUSH2 0x280a 2803 90 SWAP1 2804 84 DUP5 2805 90 SWAP1 2806 61 PUSH2 0x371a 2809 56 *JUMP 280A 5B JUMPDEST 280B 90 SWAP1 280C 91 SWAP2 280D 55 SSTORE 280E 50 POP 280F 50 POP 2810 60 PUSH1 0x00 2812 82 DUP3 2813 81 DUP2 2814 52 MSTORE 2815 60 PUSH1 0x02 2817 60 PUSH1 0x20 2819 52 MSTORE 281A 60 PUSH1 0x40 281C 80 DUP1 281D 82 DUP3 281E 20 SHA3 281F 80 DUP1 2820 54 SLOAD 2821 60 PUSH1 0x01 2823 60 PUSH1 0x01 2825 60 PUSH1 0xa0 2827 1B SHL 2828 03 SUB 2829 19 NOT 282A 16 AND 282B 90 SWAP1 282C 55 SSTORE 282D 51 MLOAD 282E 83 DUP4 282F 91 SWAP2 2830 90 SWAP1 2831 60 PUSH1 0x01 2833 60 PUSH1 0x01 2835 60 PUSH1 0xa0 2837 1B SHL 2838 03 SUB 2839 84 DUP5 283A 16 AND 283B 90 SWAP1 283C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 285D 90 SWAP1 285E 83 DUP4 285F 90 SWAP1 2860 A4 LOG4 2861 50 POP 2862 50 POP 2863 56 *JUMP label_2864: // Incoming call from 0x17B9, returns to 0x1507 // Incoming call from 0x1E72, returns to 0x159B // Inputs[5] // { // @2868 storage[0x0b] // @2871 stack[-1] // @288C memory[0x40:0x60] // @28BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @28BD stack[-2] // } 2864 5B JUMPDEST 2865 60 PUSH1 0x0b 2867 80 DUP1 2868 54 SLOAD 2869 60 PUSH1 0x01 286B 60 PUSH1 0x01 286D 60 PUSH1 0xa0 286F 1B SHL 2870 03 SUB 2871 83 DUP4 2872 81 DUP2 2873 16 AND 2874 61 PUSH2 0x0100 2877 81 DUP2 2878 81 DUP2 2879 02 MUL 287A 61 PUSH2 0x0100 287D 60 PUSH1 0x01 287F 60 PUSH1 0xa8 2881 1B SHL 2882 03 SUB 2883 19 NOT 2884 85 DUP6 2885 16 AND 2886 17 OR 2887 90 SWAP1 2888 94 SWAP5 2889 55 SSTORE 288A 60 PUSH1 0x40 288C 51 MLOAD 288D 93 SWAP4 288E 90 SWAP1 288F 92 SWAP3 2890 04 DIV 2891 16 AND 2892 91 SWAP2 2893 82 DUP3 2894 90 SWAP1 2895 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 28B6 90 SWAP1 28B7 60 PUSH1 0x00 28B9 90 SWAP1 28BA A3 LOG3 28BB 50 POP 28BC 50 POP 28BD 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2889 storage[0x0b] = (storage[0x0b] & ~((0x01 << 0xa8) - 0x0100)) | 0x0100 * (stack[-1] & (0x01 << 0xa0) - 0x01) // @28BA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0b] / 0x0100 & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_28BE: // Incoming call from 0x17F1, returns to 0x1507 // Inputs[1] { @28C1 storage[0x0b] } 28BE 5B JUMPDEST 28BF 60 PUSH1 0x0b 28C1 54 SLOAD 28C2 60 PUSH1 0xff 28C4 16 AND 28C5 15 ISZERO 28C6 61 PUSH2 0x2904 28C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2904, if !(0xff & storage[0x0b]) label_28CA: // Incoming jump from 0x28C9, if not !(0xff & storage[0x0b]) // Inputs[1] { @28CC memory[0x40:0x60] } 28CA 60 PUSH1 0x40 28CC 51 MLOAD 28CD 62 PUSH3 0x461bcd 28D1 60 PUSH1 0xe5 28D3 1B SHL 28D4 81 DUP2 28D5 52 MSTORE 28D6 60 PUSH1 0x20 28D8 60 PUSH1 0x04 28DA 82 DUP3 28DB 01 ADD 28DC 52 MSTORE 28DD 60 PUSH1 0x10 28DF 60 PUSH1 0x24 28E1 82 DUP3 28E2 01 ADD 28E3 52 MSTORE 28E4 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 28F5 60 PUSH1 0x82 28F7 1B SHL 28F8 60 PUSH1 0x44 28FA 82 DUP3 28FB 01 ADD 28FC 52 MSTORE 28FD 60 PUSH1 0x64 28FF 01 ADD 2900 61 PUSH2 0x0809 2903 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @28D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @28DC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @28E3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @28FC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @28FF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 label_2904: // Incoming jump from 0x28C9, if !(0xff & storage[0x0b]) // Inputs[2] // { // @2908 storage[0x0b] // @2936 msg.sender // } 2904 5B JUMPDEST 2905 60 PUSH1 0x0b 2907 80 DUP1 2908 54 SLOAD 2909 60 PUSH1 0xff 290B 19 NOT 290C 16 AND 290D 60 PUSH1 0x01 290F 17 OR 2910 90 SWAP1 2911 55 SSTORE 2912 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 2933 61 PUSH2 0x27a0 2936 33 CALLER 2937 90 SWAP1 2938 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2911 storage[0x0b] = 0x01 | (~0xff & storage[0x0b]) // @2912 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @2937 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x27a0 label_2939: // Incoming jump from 0x1AC7 // Inputs[3] // { // @293D stack[-4] // @293E stack[-3] // @293F stack[-2] // } 2939 5B JUMPDEST 293A 61 PUSH2 0x2944 293D 84 DUP5 293E 84 DUP5 293F 84 DUP5 2940 61 PUSH2 0x222d 2943 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @293A stack[0] = 0x2944 // @293D stack[1] = stack[-4] // @293E stack[2] = stack[-3] // @293F stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x222d 2944 5B JUMPDEST 2945 61 PUSH2 0x2950 2948 84 DUP5 2949 84 DUP5 294A 84 DUP5 294B 84 DUP5 294C 61 PUSH2 0x2a1b 294F 56 *JUMP 2950 5B JUMPDEST 2951 61 PUSH2 0x1ac8 2954 57 *JUMPI 2955 60 PUSH1 0x40 2957 51 MLOAD 2958 62 PUSH3 0x461bcd 295C 60 PUSH1 0xe5 295E 1B SHL 295F 81 DUP2 2960 52 MSTORE 2961 60 PUSH1 0x04 2963 01 ADD 2964 61 PUSH2 0x0809 2967 90 SWAP1 2968 61 PUSH2 0x35f7 296B 56 *JUMP label_296C: // Incoming call from 0x1C9D, returns to 0x1C9E // Inputs[2] // { // @2971 storage[0x13] // @2972 stack[-1] // } 296C 5B JUMPDEST 296D 60 PUSH1 0x60 296F 60 PUSH1 0x13 2971 54 SLOAD 2972 82 DUP3 2973 11 GT 2974 15 ISZERO 2975 61 PUSH2 0x2985 2978 57 *JUMPI // Stack delta = +1 // Outputs[1] { @296D stack[0] = 0x60 } // Block ends with conditional jump to 0x2985, if !(stack[-1] > storage[0x13]) label_2979: // Incoming jump from 0x2978, if not !(stack[-1] > storage[0x13]) // Inputs[1] { @297C storage[0x10] } 2979 60 PUSH1 0x10 297B 80 DUP1 297C 54 SLOAD 297D 61 PUSH2 0x1c0e 2980 90 SWAP1 2981 61 PUSH2 0x3774 2984 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2979 stack[0] = 0x10 // @2980 stack[1] = 0x1c0e // @2980 stack[2] = storage[0x10] // } // Block ends with call to 0x3774, returns to 0x1C0E label_2985: // Incoming jump from 0x2978, if !(stack[-1] > storage[0x13]) // Inputs[1] { @2989 storage[0x11] } 2985 5B JUMPDEST 2986 60 PUSH1 0x11 2988 80 DUP1 2989 54 SLOAD 298A 61 PUSH2 0x1c0e 298D 90 SWAP1 298E 61 PUSH2 0x3774 2991 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2986 stack[0] = 0x11 // @298D stack[1] = 0x1c0e // @298D stack[2] = storage[0x11] // } // Block ends with call to 0x3774, returns to 0x1C0E label_2992: // Incoming jump from 0x30CB, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2993 stack[-1] // @2993 stack[-3] // @2994 stack[-2] // } 2992 5B JUMPDEST 2993 91 SWAP2 2994 90 SWAP1 2995 50 POP 2996 56 *JUMP // Stack delta = -2 // Outputs[1] { @2993 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2997: // Incoming call from 0x20C7, returns to 0x06FC // Inputs[1] { @29A3 stack[-1] } 2997 5B JUMPDEST 2998 60 PUSH1 0x00 299A 60 PUSH1 0x01 299C 60 PUSH1 0x01 299E 60 PUSH1 0xe0 29A0 1B SHL 29A1 03 SUB 29A2 19 NOT 29A3 82 DUP3 29A4 16 AND 29A5 63 PUSH4 0x7965db0b 29AA 60 PUSH1 0xe0 29AC 1B SHL 29AD 14 EQ 29AE 80 DUP1 29AF 61 PUSH2 0x06fc 29B2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2998 stack[0] = 0x00 // @29AD stack[1] = 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x06fc, if 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_29B3: // Incoming jump from 0x29B2, if not 0x7965db0b << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @29B7 stack[-3] } 29B3 50 POP 29B4 61 PUSH2 0x06fc 29B7 82 DUP3 29B8 61 PUSH2 0x2b28 29BB 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @29B4 stack[-1] = 0x06fc // @29B7 stack[0] = stack[-3] // } // Block ends with call to 0x2b28, returns to 0x06FC label_29BC: // Incoming jump from 0x2314 // Incoming jump from 0x27D5 // Inputs[3] // { // @29C0 stack[-3] // @29C1 stack[-2] // @29C2 stack[-1] // } 29BC 5B JUMPDEST 29BD 61 PUSH2 0x093f 29C0 83 DUP4 29C1 83 DUP4 29C2 83 DUP4 29C3 61 PUSH2 0x2b78 29C6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @29BD stack[0] = 0x093f // @29C0 stack[1] = stack[-3] // @29C1 stack[2] = stack[-2] // @29C2 stack[3] = stack[-1] // } // Block ends with call to 0x2b78, returns to 0x093F label_29C7: // Incoming jump from 0x241A // Inputs[6] // { // @29C8 stack[-1] // @29C9 memory[stack[-1]:stack[-1] + 0x20] // @29E0 msg.gas // @29E1 address(0x636f6e736f6c652e6c6f67).staticcall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // @29E1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]] // @29E7 stack[-2] // } 29C7 5B JUMPDEST 29C8 80 DUP1 29C9 51 MLOAD 29CA 6A PUSH11 0x636f6e736f6c652e6c6f67 29D6 60 PUSH1 0x20 29D8 83 DUP4 29D9 01 ADD 29DA 60 PUSH1 0x00 29DC 80 DUP1 29DD 84 DUP5 29DE 83 DUP4 29DF 85 DUP6 29E0 5A GAS 29E1 FA STATICCALL 29E2 50 POP 29E3 50 POP 29E4 50 POP 29E5 50 POP 29E6 50 POP 29E7 56 *JUMP // Stack delta = -2 // Outputs[1] { @29E1 memory[0x00:0x00] = address(0x636f6e736f6c652e6c6f67).staticcall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) } // Block ends with unconditional jump to stack[-2] 29E8 5B JUMPDEST 29E9 61 PUSH2 0x29f2 29EC 83 DUP4 29ED 83 DUP4 29EE 61 PUSH2 0x2bea 29F1 56 *JUMP 29F2 5B JUMPDEST 29F3 61 PUSH2 0x29ff 29F6 60 PUSH1 0x00 29F8 84 DUP5 29F9 84 DUP5 29FA 84 DUP5 29FB 61 PUSH2 0x2a1b 29FE 56 *JUMP 29FF 5B JUMPDEST 2A00 61 PUSH2 0x093f 2A03 57 *JUMPI 2A04 60 PUSH1 0x40 2A06 51 MLOAD 2A07 62 PUSH3 0x461bcd 2A0B 60 PUSH1 0xe5 2A0D 1B SHL 2A0E 81 DUP2 2A0F 52 MSTORE 2A10 60 PUSH1 0x04 2A12 01 ADD 2A13 61 PUSH2 0x0809 2A16 90 SWAP1 2A17 61 PUSH2 0x35f7 2A1A 56 *JUMP 2A1B 5B JUMPDEST 2A1C 60 PUSH1 0x00 2A1E 60 PUSH1 0x01 2A20 60 PUSH1 0x01 2A22 60 PUSH1 0xa0 2A24 1B SHL 2A25 03 SUB 2A26 84 DUP5 2A27 16 AND 2A28 3B EXTCODESIZE 2A29 15 ISZERO 2A2A 61 PUSH2 0x2b1d 2A2D 57 *JUMPI 2A2E 60 PUSH1 0x40 2A30 51 MLOAD 2A31 63 PUSH4 0x0a85bd01 2A36 60 PUSH1 0xe1 2A38 1B SHL 2A39 81 DUP2 2A3A 52 MSTORE 2A3B 60 PUSH1 0x01 2A3D 60 PUSH1 0x01 2A3F 60 PUSH1 0xa0 2A41 1B SHL 2A42 03 SUB 2A43 85 DUP6 2A44 16 AND 2A45 90 SWAP1 2A46 63 PUSH4 0x150b7a02 2A4B 90 SWAP1 2A4C 61 PUSH2 0x2a5f 2A4F 90 SWAP1 2A50 33 CALLER 2A51 90 SWAP1 2A52 89 DUP10 2A53 90 SWAP1 2A54 88 DUP9 2A55 90 SWAP1 2A56 88 DUP9 2A57 90 SWAP1 2A58 60 PUSH1 0x04 2A5A 01 ADD 2A5B 61 PUSH2 0x3533 2A5E 56 *JUMP 2A5F 5B JUMPDEST 2A60 60 PUSH1 0x20 2A62 60 PUSH1 0x40 2A64 51 MLOAD 2A65 80 DUP1 2A66 83 DUP4 2A67 03 SUB 2A68 81 DUP2 2A69 60 PUSH1 0x00 2A6B 87 DUP8 2A6C 80 DUP1 2A6D 3B EXTCODESIZE 2A6E 15 ISZERO 2A6F 80 DUP1 2A70 15 ISZERO 2A71 61 PUSH2 0x2a79 2A74 57 *JUMPI 2A75 60 PUSH1 0x00 2A77 80 DUP1 2A78 FD *REVERT 2A79 5B JUMPDEST 2A7A 50 POP 2A7B 5A GAS 2A7C F1 CALL 2A7D 92 SWAP3 2A7E 50 POP 2A7F 50 POP 2A80 50 POP 2A81 80 DUP1 2A82 15 ISZERO 2A83 61 PUSH2 0x2aa9 2A86 57 *JUMPI 2A87 50 POP 2A88 60 PUSH1 0x40 2A8A 80 DUP1 2A8B 51 MLOAD 2A8C 60 PUSH1 0x1f 2A8E 3D RETURNDATASIZE 2A8F 90 SWAP1 2A90 81 DUP2 2A91 01 ADD 2A92 60 PUSH1 0x1f 2A94 19 NOT 2A95 16 AND 2A96 82 DUP3 2A97 01 ADD 2A98 90 SWAP1 2A99 92 SWAP3 2A9A 52 MSTORE 2A9B 61 PUSH2 0x2aa6 2A9E 91 SWAP2 2A9F 81 DUP2 2AA0 01 ADD 2AA1 90 SWAP1 2AA2 61 PUSH2 0x335b 2AA5 56 *JUMP 2AA6 5B JUMPDEST 2AA7 60 PUSH1 0x01 2AA9 5B JUMPDEST 2AAA 61 PUSH2 0x2b03 2AAD 57 *JUMPI 2AAE 3D RETURNDATASIZE 2AAF 80 DUP1 2AB0 80 DUP1 2AB1 15 ISZERO 2AB2 61 PUSH2 0x2ad7 2AB5 57 *JUMPI 2AB6 60 PUSH1 0x40 2AB8 51 MLOAD 2AB9 91 SWAP2 2ABA 50 POP 2ABB 60 PUSH1 0x1f 2ABD 19 NOT 2ABE 60 PUSH1 0x3f 2AC0 3D RETURNDATASIZE 2AC1 01 ADD 2AC2 16 AND 2AC3 82 DUP3 2AC4 01 ADD 2AC5 60 PUSH1 0x40 2AC7 52 MSTORE 2AC8 3D RETURNDATASIZE 2AC9 82 DUP3 2ACA 52 MSTORE 2ACB 3D RETURNDATASIZE 2ACC 60 PUSH1 0x00 2ACE 60 PUSH1 0x20 2AD0 84 DUP5 2AD1 01 ADD 2AD2 3E RETURNDATACOPY 2AD3 61 PUSH2 0x2adc 2AD6 56 *JUMP 2AD7 5B JUMPDEST 2AD8 60 PUSH1 0x60 2ADA 91 SWAP2 2ADB 50 POP 2ADC 5B JUMPDEST 2ADD 50 POP 2ADE 80 DUP1 2ADF 51 MLOAD 2AE0 61 PUSH2 0x2afb 2AE3 57 *JUMPI 2AE4 60 PUSH1 0x40 2AE6 51 MLOAD 2AE7 62 PUSH3 0x461bcd 2AEB 60 PUSH1 0xe5 2AED 1B SHL 2AEE 81 DUP2 2AEF 52 MSTORE 2AF0 60 PUSH1 0x04 2AF2 01 ADD 2AF3 61 PUSH2 0x0809 2AF6 90 SWAP1 2AF7 61 PUSH2 0x35f7 2AFA 56 *JUMP 2AFB 5B JUMPDEST 2AFC 80 DUP1 2AFD 51 MLOAD 2AFE 81 DUP2 2AFF 60 PUSH1 0x20 2B01 01 ADD 2B02 FD *REVERT 2B03 5B JUMPDEST 2B04 60 PUSH1 0x01 2B06 60 PUSH1 0x01 2B08 60 PUSH1 0xe0 2B0A 1B SHL 2B0B 03 SUB 2B0C 19 NOT 2B0D 16 AND 2B0E 63 PUSH4 0x0a85bd01 2B13 60 PUSH1 0xe1 2B15 1B SHL 2B16 14 EQ 2B17 90 SWAP1 2B18 50 POP 2B19 61 PUSH2 0x2225 2B1C 56 *JUMP 2B1D 5B JUMPDEST 2B1E 50 POP 2B1F 60 PUSH1 0x01 2B21 94 SWAP5 2B22 93 SWAP4 2B23 50 POP 2B24 50 POP 2B25 50 POP 2B26 50 POP 2B27 56 *JUMP label_2B28: // Incoming call from 0x29BB, returns to 0x06FC // Inputs[1] { @2B34 stack[-1] } 2B28 5B JUMPDEST 2B29 60 PUSH1 0x00 2B2B 60 PUSH1 0x01 2B2D 60 PUSH1 0x01 2B2F 60 PUSH1 0xe0 2B31 1B SHL 2B32 03 SUB 2B33 19 NOT 2B34 82 DUP3 2B35 16 AND 2B36 63 PUSH4 0x80ac58cd 2B3B 60 PUSH1 0xe0 2B3D 1B SHL 2B3E 14 EQ 2B3F 80 DUP1 2B40 61 PUSH2 0x2b59 2B43 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B29 stack[0] = 0x00 // @2B3E stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x2b59, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2B44: // Incoming jump from 0x2B43, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2B4E stack[-3] } 2B44 50 POP 2B45 60 PUSH1 0x01 2B47 60 PUSH1 0x01 2B49 60 PUSH1 0xe0 2B4B 1B SHL 2B4C 03 SUB 2B4D 19 NOT 2B4E 82 DUP3 2B4F 16 AND 2B50 63 PUSH4 0x5b5e139f 2B55 60 PUSH1 0xe0 2B57 1B SHL 2B58 14 EQ 2B59 5B JUMPDEST 2B5A 80 DUP1 2B5B 61 PUSH2 0x06fc 2B5E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2B58 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x06fc, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_2B5F: // Incoming jump from 0x2B5E, if not stack[-1] // Incoming jump from 0x2B5E, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2B71 stack[-3] } 2B5F 50 POP 2B60 63 PUSH4 0x01ffc9a7 2B65 60 PUSH1 0xe0 2B67 1B SHL 2B68 60 PUSH1 0x01 2B6A 60 PUSH1 0x01 2B6C 60 PUSH1 0xe0 2B6E 1B SHL 2B6F 03 SUB 2B70 19 NOT 2B71 83 DUP4 2B72 16 AND 2B73 14 EQ 2B74 61 PUSH2 0x06fc 2B77 56 *JUMP // Stack delta = +0 // Outputs[1] { @2B73 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x06fc label_2B78: // Incoming call from 0x29C6, returns to 0x093F // Inputs[3] // { // @2B7C stack[-3] // @2B7D stack[-2] // @2B7E stack[-1] // } 2B78 5B JUMPDEST 2B79 61 PUSH2 0x2b83 2B7C 83 DUP4 2B7D 83 DUP4 2B7E 83 DUP4 2B7F 61 PUSH2 0x2d38 2B82 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2B79 stack[0] = 0x2b83 // @2B7C stack[1] = stack[-3] // @2B7D stack[2] = stack[-2] // @2B7E stack[3] = stack[-1] // } // Block ends with call to 0x2d38, returns to 0x2B83 label_2B83: // Incoming return from call to 0x2D38 at 0x2B82 // Inputs[1] { @2B86 storage[0x0b] } 2B83 5B JUMPDEST 2B84 60 PUSH1 0x0b 2B86 54 SLOAD 2B87 60 PUSH1 0xff 2B89 16 AND 2B8A 15 ISZERO 2B8B 61 PUSH2 0x093f 2B8E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x093f, if !(0xff & storage[0x0b]) label_2B8F: // Incoming jump from 0x2B8E, if not !(0xff & storage[0x0b]) // Inputs[1] { @2B91 memory[0x40:0x60] } 2B8F 60 PUSH1 0x40 2B91 51 MLOAD 2B92 62 PUSH3 0x461bcd 2B96 60 PUSH1 0xe5 2B98 1B SHL 2B99 81 DUP2 2B9A 52 MSTORE 2B9B 60 PUSH1 0x20 2B9D 60 PUSH1 0x04 2B9F 82 DUP3 2BA0 01 ADD 2BA1 52 MSTORE 2BA2 60 PUSH1 0x2b 2BA4 60 PUSH1 0x24 2BA6 82 DUP3 2BA7 01 ADD 2BA8 52 MSTORE 2BA9 7F PUSH32 0x4552433732315061757361626c653a20746f6b656e207472616e736665722077 2BCA 60 PUSH1 0x44 2BCC 82 DUP3 2BCD 01 ADD 2BCE 52 MSTORE 2BCF 6A PUSH11 0x1a1a5b19481c185d5cd959 2BDB 60 PUSH1 0xaa 2BDD 1B SHL 2BDE 60 PUSH1 0x64 2BE0 82 DUP3 2BE1 01 ADD 2BE2 52 MSTORE 2BE3 60 PUSH1 0x84 2BE5 01 ADD 2BE6 61 PUSH2 0x0809 2BE9 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2B9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2BA1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2BA8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @2BCE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315061757361626c653a20746f6b656e207472616e736665722077 // @2BE2 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1a1a5b19481c185d5cd959 << 0xaa // @2BE5 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0809 2BEA 5B JUMPDEST 2BEB 60 PUSH1 0x01 2BED 60 PUSH1 0x01 2BEF 60 PUSH1 0xa0 2BF1 1B SHL 2BF2 03 SUB 2BF3 82 DUP3 2BF4 16 AND 2BF5 61 PUSH2 0x2c40 2BF8 57 *JUMPI 2BF9 60 PUSH1 0x40 2BFB 51 MLOAD 2BFC 62 PUSH3 0x461bcd 2C00 60 PUSH1 0xe5 2C02 1B SHL 2C03 81 DUP2 2C04 52 MSTORE 2C05 60 PUSH1 0x20 2C07 60 PUSH1 0x04 2C09 82 DUP3 2C0A 01 ADD 2C0B 81 DUP2 2C0C 90 SWAP1 2C0D 52 MSTORE 2C0E 60 PUSH1 0x24 2C10 82 DUP3 2C11 01 ADD 2C12 52 MSTORE 2C13 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 2C34 60 PUSH1 0x44 2C36 82 DUP3 2C37 01 ADD 2C38 52 MSTORE 2C39 60 PUSH1 0x64 2C3B 01 ADD 2C3C 61 PUSH2 0x0809 2C3F 56 *JUMP 2C40 5B JUMPDEST 2C41 60 PUSH1 0x00 2C43 81 DUP2 2C44 81 DUP2 2C45 52 MSTORE 2C46 60 PUSH1 0x02 2C48 60 PUSH1 0x20 2C4A 52 MSTORE 2C4B 60 PUSH1 0x40 2C4D 90 SWAP1 2C4E 20 SHA3 2C4F 54 SLOAD 2C50 60 PUSH1 0x01 2C52 60 PUSH1 0x01 2C54 60 PUSH1 0xa0 2C56 1B SHL 2C57 03 SUB 2C58 16 AND 2C59 15 ISZERO 2C5A 61 PUSH2 0x2ca5 2C5D 57 *JUMPI 2C5E 60 PUSH1 0x40 2C60 51 MLOAD 2C61 62 PUSH3 0x461bcd 2C65 60 PUSH1 0xe5 2C67 1B SHL 2C68 81 DUP2 2C69 52 MSTORE 2C6A 60 PUSH1 0x20 2C6C 60 PUSH1 0x04 2C6E 82 DUP3 2C6F 01 ADD 2C70 52 MSTORE 2C71 60 PUSH1 0x1c 2C73 60 PUSH1 0x24 2C75 82 DUP3 2C76 01 ADD 2C77 52 MSTORE 2C78 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2C99 60 PUSH1 0x44 2C9B 82 DUP3 2C9C 01 ADD 2C9D 52 MSTORE 2C9E 60 PUSH1 0x64 2CA0 01 ADD 2CA1 61 PUSH2 0x0809 2CA4 56 *JUMP 2CA5 5B JUMPDEST 2CA6 61 PUSH2 0x2cb1 2CA9 60 PUSH1 0x00 2CAB 83 DUP4 2CAC 83 DUP4 2CAD 61 PUSH2 0x29bc 2CB0 56 *JUMP 2CB1 5B JUMPDEST 2CB2 60 PUSH1 0x01 2CB4 60 PUSH1 0x01 2CB6 60 PUSH1 0xa0 2CB8 1B SHL 2CB9 03 SUB 2CBA 82 DUP3 2CBB 16 AND 2CBC 60 PUSH1 0x00 2CBE 90 SWAP1 2CBF 81 DUP2 2CC0 52 MSTORE 2CC1 60 PUSH1 0x03 2CC3 60 PUSH1 0x20 2CC5 52 MSTORE 2CC6 60 PUSH1 0x40 2CC8 81 DUP2 2CC9 20 SHA3 2CCA 80 DUP1 2CCB 54 SLOAD 2CCC 60 PUSH1 0x01 2CCE 92 SWAP3 2CCF 90 SWAP1 2CD0 61 PUSH2 0x2cda 2CD3 90 SWAP1 2CD4 84 DUP5 2CD5 90 SWAP1 2CD6 61 PUSH2 0x36cf 2CD9 56 *JUMP 2CDA 5B JUMPDEST 2CDB 90 SWAP1 2CDC 91 SWAP2 2CDD 55 SSTORE 2CDE 50 POP 2CDF 50 POP 2CE0 60 PUSH1 0x00 2CE2 81 DUP2 2CE3 81 DUP2 2CE4 52 MSTORE 2CE5 60 PUSH1 0x02 2CE7 60 PUSH1 0x20 2CE9 52 MSTORE 2CEA 60 PUSH1 0x40 2CEC 80 DUP1 2CED 82 DUP3 2CEE 20 SHA3 2CEF 80 DUP1 2CF0 54 SLOAD 2CF1 60 PUSH1 0x01 2CF3 60 PUSH1 0x01 2CF5 60 PUSH1 0xa0 2CF7 1B SHL 2CF8 03 SUB 2CF9 19 NOT 2CFA 16 AND 2CFB 60 PUSH1 0x01 2CFD 60 PUSH1 0x01 2CFF 60 PUSH1 0xa0 2D01 1B SHL 2D02 03 SUB 2D03 86 DUP7 2D04 16 AND 2D05 90 SWAP1 2D06 81 DUP2 2D07 17 OR 2D08 90 SWAP1 2D09 91 SWAP2 2D0A 55 SSTORE 2D0B 90 SWAP1 2D0C 51 MLOAD 2D0D 83 DUP4 2D0E 92 SWAP3 2D0F 90 SWAP1 2D10 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2D31 90 SWAP1 2D32 82 DUP3 2D33 90 SWAP1 2D34 A4 LOG4 2D35 50 POP 2D36 50 POP 2D37 56 *JUMP label_2D38: // Incoming call from 0x2B82, returns to 0x2B83 // Inputs[1] { @2D41 stack[-3] } 2D38 5B JUMPDEST 2D39 60 PUSH1 0x01 2D3B 60 PUSH1 0x01 2D3D 60 PUSH1 0xa0 2D3F 1B SHL 2D40 03 SUB 2D41 83 DUP4 2D42 16 AND 2D43 61 PUSH2 0x2d93 2D46 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d93, if stack[-3] & (0x01 << 0xa0) - 0x01 label_2D47: // Incoming jump from 0x2D46, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2D4A stack[-1] // @2D4E storage[0x09] // @2D5C memory[0x00:0x40] // } 2D47 61 PUSH2 0x2d8e 2D4A 81 DUP2 2D4B 60 PUSH1 0x09 2D4D 80 DUP1 2D4E 54 SLOAD 2D4F 60 PUSH1 0x00 2D51 83 DUP4 2D52 81 DUP2 2D53 52 MSTORE 2D54 60 PUSH1 0x0a 2D56 60 PUSH1 0x20 2D58 52 MSTORE 2D59 60 PUSH1 0x40 2D5B 81 DUP2 2D5C 20 SHA3 2D5D 82 DUP3 2D5E 90 SWAP1 2D5F 55 SSTORE 2D60 60 PUSH1 0x01 2D62 82 DUP3 2D63 01 ADD 2D64 83 DUP4 2D65 55 SSTORE 2D66 91 SWAP2 2D67 90 SWAP1 2D68 91 SWAP2 2D69 52 MSTORE 2D6A 7F PUSH32 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af 2D8B 01 ADD 2D8C 55 SSTORE 2D8D 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @2D53 memory[0x00:0x20] = stack[-1] // @2D58 memory[0x20:0x40] = 0x0a // @2D5F storage[keccak256(memory[0x00:0x40])] = storage[0x09] // @2D65 storage[0x09] = storage[0x09] + 0x01 // @2D69 memory[0x00:0x20] = 0x09 // @2D8C storage[0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af + storage[0x09]] = stack[-1] // } // Block ends with unconditional jump to 0x2d8e label_2D8E: // Incoming jump from 0x2D8D 2D8E 5B JUMPDEST 2D8F 61 PUSH2 0x2db6 2D92 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2db6 label_2D93: // Incoming jump from 0x2D46, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2D94 stack[-2] // @2D9E stack[-3] // } 2D93 5B JUMPDEST 2D94 81 DUP2 2D95 60 PUSH1 0x01 2D97 60 PUSH1 0x01 2D99 60 PUSH1 0xa0 2D9B 1B SHL 2D9C 03 SUB 2D9D 16 AND 2D9E 83 DUP4 2D9F 60 PUSH1 0x01 2DA1 60 PUSH1 0x01 2DA3 60 PUSH1 0xa0 2DA5 1B SHL 2DA6 03 SUB 2DA7 16 AND 2DA8 14 EQ 2DA9 61 PUSH2 0x2db6 2DAC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2db6, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_2DAD: // Incoming jump from 0x2DAC, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @2DB0 stack[-3] // @2DB1 stack[-1] // } 2DAD 61 PUSH2 0x2db6 2DB0 83 DUP4 2DB1 82 DUP3 2DB2 61 PUSH2 0x2df0 2DB5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DAD stack[0] = 0x2db6 // @2DB0 stack[1] = stack[-3] // @2DB1 stack[2] = stack[-1] // } // Block ends with call to 0x2df0, returns to 0x2DB6 label_2DB6: // Incoming jump from 0x2D92 // Incoming return from call to 0x2DF0 at 0x2DB5 // Incoming jump from 0x2DAC, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[1] { @2DBF stack[-2] } 2DB6 5B JUMPDEST 2DB7 60 PUSH1 0x01 2DB9 60 PUSH1 0x01 2DBB 60 PUSH1 0xa0 2DBD 1B SHL 2DBE 03 SUB 2DBF 82 DUP3 2DC0 16 AND 2DC1 61 PUSH2 0x2dcd 2DC4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2dcd, if stack[-2] & (0x01 << 0xa0) - 0x01 label_2DC5: // Incoming jump from 0x2DC4, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2DC8 stack[-1] } 2DC5 61 PUSH2 0x093f 2DC8 81 DUP2 2DC9 61 PUSH2 0x2e8d 2DCC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2DC5 stack[0] = 0x093f // @2DC8 stack[1] = stack[-1] // } // Block ends with call to 0x2e8d, returns to 0x093F label_2DCD: // Incoming jump from 0x2DC4, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2DCE stack[-3] // @2DD8 stack[-2] // } 2DCD 5B JUMPDEST 2DCE 82 DUP3 2DCF 60 PUSH1 0x01 2DD1 60 PUSH1 0x01 2DD3 60 PUSH1 0xa0 2DD5 1B SHL 2DD6 03 SUB 2DD7 16 AND 2DD8 82 DUP3 2DD9 60 PUSH1 0x01 2DDB 60 PUSH1 0x01 2DDD 60 PUSH1 0xa0 2DDF 1B SHL 2DE0 03 SUB 2DE1 16 AND 2DE2 14 EQ 2DE3 61 PUSH2 0x093f 2DE6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x093f, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_2DE7: // Incoming jump from 0x2DE6, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @2DEA stack[-2] // @2DEB stack[-1] // } 2DE7 61 PUSH2 0x093f 2DEA 82 DUP3 2DEB 82 DUP3 2DEC 61 PUSH2 0x2f66 2DEF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DE7 stack[0] = 0x093f // @2DEA stack[1] = stack[-2] // @2DEB stack[2] = stack[-1] // } // Block ends with call to 0x2f66, returns to 0x093F label_2DF0: // Incoming call from 0x2DB5, returns to 0x2DB6 // Inputs[1] { @2DF8 stack[-2] } 2DF0 5B JUMPDEST 2DF1 60 PUSH1 0x00 2DF3 60 PUSH1 0x01 2DF5 61 PUSH2 0x2dfd 2DF8 84 DUP5 2DF9 61 PUSH2 0x16f9 2DFC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2DF1 stack[0] = 0x00 // @2DF3 stack[1] = 0x01 // @2DF5 stack[2] = 0x2dfd // @2DF8 stack[3] = stack[-2] // } // Block ends with call to 0x16f9, returns to 0x2DFD label_2DFD: // Incoming return from call to 0x16F9 at 0x2DFC // Inputs[2] // { // @2E01 stack[-2] // @2E02 stack[-1] // } 2DFD 5B JUMPDEST 2DFE 61 PUSH2 0x2e07 2E01 91 SWAP2 2E02 90 SWAP1 2E03 61 PUSH2 0x371a 2E06 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2E01 stack[-2] = 0x2e07 // @2E02 stack[-1] = stack[-2] // @2E02 stack[0] = stack[-1] // } // Block ends with call to 0x371a, returns to 0x2E07 label_2E07: // Incoming return from call to 0x371A at 0x2E06 // Inputs[5] // { // @2E0A stack[-3] // @2E15 memory[0x00:0x40] // @2E16 storage[keccak256(memory[0x00:0x40])] // @2E17 stack[-1] // @2E18 stack[-2] // } 2E07 5B JUMPDEST 2E08 60 PUSH1 0x00 2E0A 83 DUP4 2E0B 81 DUP2 2E0C 52 MSTORE 2E0D 60 PUSH1 0x08 2E0F 60 PUSH1 0x20 2E11 52 MSTORE 2E12 60 PUSH1 0x40 2E14 90 SWAP1 2E15 20 SHA3 2E16 54 SLOAD 2E17 90 SWAP1 2E18 91 SWAP2 2E19 50 POP 2E1A 80 DUP1 2E1B 82 DUP3 2E1C 14 EQ 2E1D 61 PUSH2 0x2e5a 2E20 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2E0C memory[0x00:0x20] = stack[-3] // @2E11 memory[0x20:0x40] = 0x08 // @2E17 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2E18 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x2e5a, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_2E21: // Incoming jump from 0x2E20, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @2E29 stack[-4] // @2E3B memory[0x00:0x40] // @2E3C stack[-2] // @2E43 memory[0x00:0x40] // @2E44 storage[keccak256(memory[0x00:0x40])] // @2E45 stack[-1] // @2E4A memory[0x00:0x40] // @2E56 memory[0x00:0x40] // @2E5E stack[-3] // @2E6C memory[0x00:0x40] // @2E83 memory[0x00:0x40] // @2E8A memory[0x00:0x40] // @2E8C stack[-5] // } 2E21 60 PUSH1 0x01 2E23 60 PUSH1 0x01 2E25 60 PUSH1 0xa0 2E27 1B SHL 2E28 03 SUB 2E29 84 DUP5 2E2A 16 AND 2E2B 60 PUSH1 0x00 2E2D 90 SWAP1 2E2E 81 DUP2 2E2F 52 MSTORE 2E30 60 PUSH1 0x07 2E32 60 PUSH1 0x20 2E34 90 SWAP1 2E35 81 DUP2 2E36 52 MSTORE 2E37 60 PUSH1 0x40 2E39 80 DUP1 2E3A 83 DUP4 2E3B 20 SHA3 2E3C 85 DUP6 2E3D 84 DUP5 2E3E 52 MSTORE 2E3F 82 DUP3 2E40 52 MSTORE 2E41 80 DUP1 2E42 83 DUP4 2E43 20 SHA3 2E44 54 SLOAD 2E45 84 DUP5 2E46 84 DUP5 2E47 52 MSTORE 2E48 81 DUP2 2E49 84 DUP5 2E4A 20 SHA3 2E4B 81 DUP2 2E4C 90 SWAP1 2E4D 55 SSTORE 2E4E 83 DUP4 2E4F 52 MSTORE 2E50 60 PUSH1 0x08 2E52 90 SWAP1 2E53 91 SWAP2 2E54 52 MSTORE 2E55 90 SWAP1 2E56 20 SHA3 2E57 81 DUP2 2E58 90 SWAP1 2E59 55 SSTORE 2E5A 5B JUMPDEST 2E5B 50 POP 2E5C 60 PUSH1 0x00 2E5E 91 SWAP2 2E5F 82 DUP3 2E60 52 MSTORE 2E61 60 PUSH1 0x08 2E63 60 PUSH1 0x20 2E65 90 SWAP1 2E66 81 DUP2 2E67 52 MSTORE 2E68 60 PUSH1 0x40 2E6A 80 DUP1 2E6B 84 DUP5 2E6C 20 SHA3 2E6D 84 DUP5 2E6E 90 SWAP1 2E6F 55 SSTORE 2E70 60 PUSH1 0x01 2E72 60 PUSH1 0x01 2E74 60 PUSH1 0xa0 2E76 1B SHL 2E77 03 SUB 2E78 90 SWAP1 2E79 94 SWAP5 2E7A 16 AND 2E7B 83 DUP4 2E7C 52 MSTORE 2E7D 60 PUSH1 0x07 2E7F 81 DUP2 2E80 52 MSTORE 2E81 83 DUP4 2E82 83 DUP4 2E83 20 SHA3 2E84 91 SWAP2 2E85 83 DUP4 2E86 52 MSTORE 2E87 52 MSTORE 2E88 90 SWAP1 2E89 81 DUP2 2E8A 20 SHA3 2E8B 55 SSTORE 2E8C 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @2E2F memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2E36 memory[0x20:0x40] = 0x07 // @2E3E memory[0x00:0x20] = stack[-2] // @2E40 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2E47 memory[0x00:0x20] = stack[-1] // @2E4D storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @2E4F memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @2E54 memory[0x20:0x40] = 0x08 // @2E59 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2E60 memory[0x00:0x20] = stack[-3] // @2E67 memory[0x20:0x40] = 0x08 // @2E6F storage[keccak256(memory[0x00:0x40])] = 0x00 // @2E7C memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2E80 memory[0x20:0x40] = 0x07 // @2E86 memory[0x00:0x20] = stack[-2] // @2E87 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2E8B storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_2E8D: // Incoming call from 0x2DCC, returns to 0x093F // Inputs[1] { @2E90 storage[0x09] } 2E8D 5B JUMPDEST 2E8E 60 PUSH1 0x09 2E90 54 SLOAD 2E91 60 PUSH1 0x00 2E93 90 SWAP1 2E94 61 PUSH2 0x2e9f 2E97 90 SWAP1 2E98 60 PUSH1 0x01 2E9A 90 SWAP1 2E9B 61 PUSH2 0x371a 2E9E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2E93 stack[0] = 0x00 // @2E97 stack[1] = 0x2e9f // @2E9A stack[2] = 0x01 // @2E9A stack[3] = storage[0x09] // } // Block ends with call to 0x371a, returns to 0x2E9F label_2E9F: // Incoming return from call to 0x371A at 0x2E9E // Inputs[6] // { // @2EA2 stack[-3] // @2EAD memory[0x00:0x40] // @2EAE storage[keccak256(memory[0x00:0x40])] // @2EB2 storage[0x09] // @2EB3 stack[-1] // @2EB4 stack[-2] // } 2E9F 5B JUMPDEST 2EA0 60 PUSH1 0x00 2EA2 83 DUP4 2EA3 81 DUP2 2EA4 52 MSTORE 2EA5 60 PUSH1 0x0a 2EA7 60 PUSH1 0x20 2EA9 52 MSTORE 2EAA 60 PUSH1 0x40 2EAC 81 DUP2 2EAD 20 SHA3 2EAE 54 SLOAD 2EAF 60 PUSH1 0x09 2EB1 80 DUP1 2EB2 54 SLOAD 2EB3 93 SWAP4 2EB4 94 SWAP5 2EB5 50 POP 2EB6 90 SWAP1 2EB7 92 SWAP3 2EB8 84 DUP5 2EB9 90 SWAP1 2EBA 81 DUP2 2EBB 10 LT 2EBC 61 PUSH2 0x2ed5 2EBF 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @2EA0 stack[0] = 0x00 // @2EA4 memory[0x00:0x20] = stack[-3] // @2EA9 memory[0x20:0x40] = 0x0a // @2EB4 stack[-2] = stack[-1] // @2EB6 stack[1] = 0x09 // @2EB7 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2EB9 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2ed5, if stack[-1] < storage[0x09] label_2EC0: // Incoming jump from 0x2EBF, if not stack[-1] < storage[0x09] // Inputs[1] { @2ED4 memory[0x00:0x24] } 2EC0 63 PUSH4 0x4e487b71 2EC5 60 PUSH1 0xe0 2EC7 1B SHL 2EC8 60 PUSH1 0x00 2ECA 52 MSTORE 2ECB 60 PUSH1 0x32 2ECD 60 PUSH1 0x04 2ECF 52 MSTORE 2ED0 60 PUSH1 0x24 2ED2 60 PUSH1 0x00 2ED4 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2ECA memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2ECF memory[0x04:0x24] = 0x32 // @2ED4 revert(memory[0x00:0x24]); // } // Block terminates label_2ED5: // Incoming jump from 0x2EBF, if stack[-1] < storage[0x09] // Inputs[7] // { // @2ED6 stack[-2] // @2ED6 stack[-1] // @2EDE memory[0x00:0x20] // @2EE0 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2EE1 stack[-3] // @2EE6 stack[-4] // @2EE8 storage[0x09] // } 2ED5 5B JUMPDEST 2ED6 90 SWAP1 2ED7 60 PUSH1 0x00 2ED9 52 MSTORE 2EDA 60 PUSH1 0x20 2EDC 60 PUSH1 0x00 2EDE 20 SHA3 2EDF 01 ADD 2EE0 54 SLOAD 2EE1 90 SWAP1 2EE2 50 POP 2EE3 80 DUP1 2EE4 60 PUSH1 0x09 2EE6 83 DUP4 2EE7 81 DUP2 2EE8 54 SLOAD 2EE9 81 DUP2 2EEA 10 LT 2EEB 61 PUSH2 0x2f04 2EEE 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2ED9 memory[0x00:0x20] = stack[-2] // @2EE1 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2EE3 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2EE4 stack[-1] = 0x09 // @2EE6 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x2f04, if stack[-4] < storage[0x09] label_2EEF: // Incoming jump from 0x2EEE, if not stack[-4] < storage[0x09] // Inputs[1] { @2F03 memory[0x00:0x24] } 2EEF 63 PUSH4 0x4e487b71 2EF4 60 PUSH1 0xe0 2EF6 1B SHL 2EF7 60 PUSH1 0x00 2EF9 52 MSTORE 2EFA 60 PUSH1 0x32 2EFC 60 PUSH1 0x04 2EFE 52 MSTORE 2EFF 60 PUSH1 0x24 2F01 60 PUSH1 0x00 2F03 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2EF9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2EFE memory[0x04:0x24] = 0x32 // @2F03 revert(memory[0x00:0x24]); // } // Block terminates label_2F04: // Incoming jump from 0x2EEE, if stack[-4] < storage[0x09] // Inputs[10] // { // @2F07 stack[-2] // @2F0E memory[0x00:0x20] // @2F10 stack[-1] // @2F12 stack[-3] // @2F16 stack[-4] // @2F22 memory[0x00:0x40] // @2F23 stack[-5] // @2F26 stack[-7] // @2F2A memory[0x00:0x40] // @2F2F storage[0x09] // } 2F04 5B JUMPDEST 2F05 60 PUSH1 0x00 2F07 91 SWAP2 2F08 82 DUP3 2F09 52 MSTORE 2F0A 60 PUSH1 0x20 2F0C 80 DUP1 2F0D 83 DUP4 2F0E 20 SHA3 2F0F 90 SWAP1 2F10 91 SWAP2 2F11 01 ADD 2F12 92 SWAP3 2F13 90 SWAP1 2F14 92 SWAP3 2F15 55 SSTORE 2F16 82 DUP3 2F17 81 DUP2 2F18 52 MSTORE 2F19 60 PUSH1 0x0a 2F1B 90 SWAP1 2F1C 91 SWAP2 2F1D 52 MSTORE 2F1E 60 PUSH1 0x40 2F20 80 DUP1 2F21 82 DUP3 2F22 20 SHA3 2F23 84 DUP5 2F24 90 SWAP1 2F25 55 SSTORE 2F26 85 DUP6 2F27 82 DUP3 2F28 52 MSTORE 2F29 81 DUP2 2F2A 20 SHA3 2F2B 55 SSTORE 2F2C 60 PUSH1 0x09 2F2E 80 DUP1 2F2F 54 SLOAD 2F30 80 DUP1 2F31 61 PUSH2 0x2f4a 2F34 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @2F09 memory[0x00:0x20] = stack[-2] // @2F15 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @2F18 memory[0x00:0x20] = stack[-4] // @2F1D memory[0x20:0x40] = 0x0a // @2F25 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @2F28 memory[0x00:0x20] = stack[-7] // @2F2B storage[keccak256(memory[0x00:0x40])] = 0x00 // @2F2C stack[-3] = 0x09 // @2F2F stack[-2] = storage[0x09] // } // Block ends with conditional jump to 0x2f4a, if storage[0x09] label_2F35: // Incoming jump from 0x2F34, if not storage[0x09] // Inputs[1] { @2F49 memory[0x00:0x24] } 2F35 63 PUSH4 0x4e487b71 2F3A 60 PUSH1 0xe0 2F3C 1B SHL 2F3D 60 PUSH1 0x00 2F3F 52 MSTORE 2F40 60 PUSH1 0x31 2F42 60 PUSH1 0x04 2F44 52 MSTORE 2F45 60 PUSH1 0x24 2F47 60 PUSH1 0x00 2F49 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2F3F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2F44 memory[0x04:0x24] = 0x31 // @2F49 revert(memory[0x00:0x24]); // } // Block terminates label_2F4A: // Incoming jump from 0x2F34, if storage[0x09] // Inputs[4] // { // @2F4D stack[-1] // @2F4F stack[-2] // @2F59 memory[0x00:0x20] // @2F65 stack[-7] // } 2F4A 5B JUMPDEST 2F4B 60 PUSH1 0x01 2F4D 90 SWAP1 2F4E 03 SUB 2F4F 81 DUP2 2F50 81 DUP2 2F51 90 SWAP1 2F52 60 PUSH1 0x00 2F54 52 MSTORE 2F55 60 PUSH1 0x20 2F57 60 PUSH1 0x00 2F59 20 SHA3 2F5A 01 ADD 2F5B 60 PUSH1 0x00 2F5D 90 SWAP1 2F5E 55 SSTORE 2F5F 90 SWAP1 2F60 55 SSTORE 2F61 50 POP 2F62 50 POP 2F63 50 POP 2F64 50 POP 2F65 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2F54 memory[0x00:0x20] = stack[-2] // @2F5E storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @2F60 storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_2F66: // Incoming call from 0x2DEF, returns to 0x093F // Inputs[1] { @2F6C stack[-2] } 2F66 5B JUMPDEST 2F67 60 PUSH1 0x00 2F69 61 PUSH2 0x2f71 2F6C 83 DUP4 2F6D 61 PUSH2 0x16f9 2F70 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2F67 stack[0] = 0x00 // @2F69 stack[1] = 0x2f71 // @2F6C stack[2] = stack[-2] // } // Block ends with call to 0x16f9, returns to 0x2F71 label_2F71: // Incoming return from call to 0x16F9 at 0x2F70 // Inputs[8] // { // @2F7A stack[-1] // @2F7B stack[-4] // @2F8D memory[0x00:0x40] // @2F95 memory[0x00:0x40] // @2F96 stack[-3] // @2FA1 stack[-2] // @2FA3 memory[0x00:0x40] // @2FA9 stack[-5] // } 2F71 5B JUMPDEST 2F72 60 PUSH1 0x01 2F74 60 PUSH1 0x01 2F76 60 PUSH1 0xa0 2F78 1B SHL 2F79 03 SUB 2F7A 90 SWAP1 2F7B 93 SWAP4 2F7C 16 AND 2F7D 60 PUSH1 0x00 2F7F 90 SWAP1 2F80 81 DUP2 2F81 52 MSTORE 2F82 60 PUSH1 0x07 2F84 60 PUSH1 0x20 2F86 90 SWAP1 2F87 81 DUP2 2F88 52 MSTORE 2F89 60 PUSH1 0x40 2F8B 80 DUP1 2F8C 83 DUP4 2F8D 20 SHA3 2F8E 86 DUP7 2F8F 84 DUP5 2F90 52 MSTORE 2F91 82 DUP3 2F92 52 MSTORE 2F93 80 DUP1 2F94 83 DUP4 2F95 20 SHA3 2F96 85 DUP6 2F97 90 SWAP1 2F98 55 SSTORE 2F99 93 SWAP4 2F9A 82 DUP3 2F9B 52 MSTORE 2F9C 60 PUSH1 0x08 2F9E 90 SWAP1 2F9F 52 MSTORE 2FA0 91 SWAP2 2FA1 90 SWAP1 2FA2 91 SWAP2 2FA3 20 SHA3 2FA4 91 SWAP2 2FA5 90 SWAP1 2FA6 91 SWAP2 2FA7 55 SSTORE 2FA8 50 POP 2FA9 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @2F81 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2F88 memory[0x20:0x40] = 0x07 // @2F90 memory[0x00:0x20] = stack[-1] // @2F92 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2F98 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @2F9B memory[0x00:0x20] = stack[-3] // @2F9F memory[0x20:0x40] = 0x08 // @2FA7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_2FAA: // Incoming jump from 0x0A42 // Incoming jump from 0x1412 // Incoming jump from 0x1681 // Incoming jump from 0x18D5 // Inputs[2] // { // @2FAB stack[-3] // @2FAD storage[stack[-3]] // } 2FAA 5B JUMPDEST 2FAB 82 DUP3 2FAC 80 DUP1 2FAD 54 SLOAD 2FAE 61 PUSH2 0x2fb6 2FB1 90 SWAP1 2FB2 61 PUSH2 0x3774 2FB5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2FAB stack[0] = stack[-3] // @2FB1 stack[1] = 0x2fb6 // @2FB1 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x3774, returns to 0x2FB6 label_2FB6: // Incoming return from call to 0x3774 at 0x2FB5 // Inputs[5] // { // @2FB7 stack[-2] // @2FB7 stack[-1] // @2FBF memory[0x00:0x20] // @2FCA stack[-4] // @2FCB stack[-3] // } 2FB6 5B JUMPDEST 2FB7 90 SWAP1 2FB8 60 PUSH1 0x00 2FBA 52 MSTORE 2FBB 60 PUSH1 0x20 2FBD 60 PUSH1 0x00 2FBF 20 SHA3 2FC0 90 SWAP1 2FC1 60 PUSH1 0x1f 2FC3 01 ADD 2FC4 60 PUSH1 0x20 2FC6 90 SWAP1 2FC7 04 DIV 2FC8 81 DUP2 2FC9 01 ADD 2FCA 92 SWAP3 2FCB 82 DUP3 2FCC 61 PUSH2 0x2fd8 2FCF 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2FBA memory[0x00:0x20] = stack[-2] // @2FC0 stack[-2] = keccak256(memory[0x00:0x20]) // @2FCA stack[-1] = stack[-4] // @2FCA stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x2fd8, if stack[-3] label_2FD0: // Incoming jump from 0x2FCF, if not stack[-3] // Inputs[1] { @2FD2 stack[-5] } 2FD0 60 PUSH1 0x00 2FD2 85 DUP6 2FD3 55 SSTORE 2FD4 61 PUSH2 0x301e 2FD7 56 *JUMP // Stack delta = +0 // Outputs[1] { @2FD3 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x301e label_2FD8: // Incoming jump from 0x2FCF, if stack[-3] // Inputs[1] { @2FD9 stack[-3] } 2FD8 5B JUMPDEST 2FD9 82 DUP3 2FDA 60 PUSH1 0x1f 2FDC 10 LT 2FDD 61 PUSH2 0x2ff1 2FE0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2ff1, if 0x1f < stack[-3] label_2FE1: // Incoming jump from 0x2FE0, if not 0x1f < stack[-3] // Inputs[4] // { // @2FE1 stack[-1] // @2FE2 memory[stack[-1]:stack[-1] + 0x20] // @2FE7 stack[-3] // @2FEB stack[-5] // } 2FE1 80 DUP1 2FE2 51 MLOAD 2FE3 60 PUSH1 0xff 2FE5 19 NOT 2FE6 16 AND 2FE7 83 DUP4 2FE8 80 DUP1 2FE9 01 ADD 2FEA 17 OR 2FEB 85 DUP6 2FEC 55 SSTORE 2FED 61 PUSH2 0x301e 2FF0 56 *JUMP // Stack delta = +0 // Outputs[1] { @2FEC storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x301e label_2FF1: // Incoming jump from 0x2FE0, if 0x1f < stack[-3] // Inputs[2] // { // @2FF2 stack[-3] // @2FF8 stack[-5] // } 2FF1 5B JUMPDEST 2FF2 82 DUP3 2FF3 80 DUP1 2FF4 01 ADD 2FF5 60 PUSH1 0x01 2FF7 01 ADD 2FF8 85 DUP6 2FF9 55 SSTORE 2FFA 82 DUP3 2FFB 15 ISZERO 2FFC 61 PUSH2 0x301e 2FFF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2FF9 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x301e, if !stack[-3] label_3000: // Incoming jump from 0x2FFF, if not !stack[-3] // Inputs[2] // { // @3000 stack[-3] // @3000 stack[-1] // } 3000 91 SWAP2 3001 82 DUP3 3002 01 ADD 3003 5B JUMPDEST 3004 82 DUP3 3005 81 DUP2 3006 11 GT 3007 15 ISZERO 3008 61 PUSH2 0x301e 300B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3000 stack[-3] = stack[-1] // @3002 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x301e, if !(stack[-1] + stack[-3] > stack[-1]) label_300C: // Incoming jump from 0x300B, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x300B, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @300C stack[-3] // @300D memory[stack[-3]:stack[-3] + 0x20] // @300E stack[-2] // @3010 stack[-1] // } 300C 82 DUP3 300D 51 MLOAD 300E 82 DUP3 300F 55 SSTORE 3010 91 SWAP2 3011 60 PUSH1 0x20 3013 01 ADD 3014 91 SWAP2 3015 90 SWAP1 3016 60 PUSH1 0x01 3018 01 ADD 3019 90 SWAP1 301A 61 PUSH2 0x3003 301D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @300F storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @3014 stack[-3] = 0x20 + stack[-3] // @3019 stack[-2] = 0x01 + stack[-2] // @3019 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x3003 label_301E: // Incoming jump from 0x2FD7 // Incoming jump from 0x300B, if !(stack[-1] > stack[-3]) // Incoming jump from 0x2FFF, if !stack[-3] // Incoming jump from 0x2FF0 // Incoming jump from 0x300B, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @3023 stack[-4] // @3024 stack[-3] // } 301E 5B JUMPDEST 301F 50 POP 3020 61 PUSH2 0x302a 3023 92 SWAP3 3024 91 SWAP2 3025 50 POP 3026 61 PUSH2 0x302e 3029 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @3023 stack[-4] = 0x302a // @3024 stack[-3] = stack[-4] // } // Block ends with call to 0x302e, returns to 0x302A label_302A: // Incoming jump from 0x3037, if !(stack[-2] > stack[-1]) // Incoming jump from 0x3037, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x302E at 0x3029 // Inputs[2] // { // @302C stack[-3] // @302C stack[-2] // } 302A 5B JUMPDEST 302B 50 POP 302C 90 SWAP1 302D 56 *JUMP // Stack delta = -2 // Outputs[1] { @302C stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_302E: // Incoming call from 0x3029, returns to 0x302A // Inputs[2] // { // @3030 stack[-1] // @3031 stack[-2] // } 302E 5B JUMPDEST 302F 5B JUMPDEST 3030 80 DUP1 3031 82 DUP3 3032 11 GT 3033 15 ISZERO 3034 61 PUSH2 0x302a 3037 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x302a, if !(stack[-2] > stack[-1]) label_3038: // Incoming jump from 0x3037, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x3037, if not !(stack[-2] > stack[-1]) // Inputs[1] { @303A stack[-1] } 3038 60 PUSH1 0x00 303A 81 DUP2 303B 55 SSTORE 303C 60 PUSH1 0x01 303E 01 ADD 303F 61 PUSH2 0x302f 3042 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @303B storage[stack[-1]] = 0x00 // @303E stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x302f label_3043: // Incoming call from 0x322C, returns to 0x322D // Incoming call from 0x3138, returns to 0x1CE9 // Inputs[1] { @3050 stack[-2] } 3043 5B JUMPDEST 3044 60 PUSH1 0x00 3046 67 PUSH8 0xffffffffffffffff 304F 80 DUP1 3050 84 DUP5 3051 11 GT 3052 15 ISZERO 3053 61 PUSH2 0x305e 3056 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3044 stack[0] = 0x00 // @3046 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x305e, if !(stack[-2] > 0xffffffffffffffff) label_3057: // Incoming jump from 0x3056, if not !(stack[-2] > 0xffffffffffffffff) 3057 61 PUSH2 0x305e 305A 61 PUSH2 0x380a 305D 56 *JUMP // Stack delta = +1 // Outputs[1] { @3057 stack[0] = 0x305e } // Block ends with unconditional jump to 0x380a label_305E: // Incoming jump from 0x3056, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @3061 memory[0x40:0x60] // @3064 stack[-4] // @3073 stack[-1] // } 305E 5B JUMPDEST 305F 60 PUSH1 0x40 3061 51 MLOAD 3062 60 PUSH1 0x1f 3064 85 DUP6 3065 01 ADD 3066 60 PUSH1 0x1f 3068 19 NOT 3069 90 SWAP1 306A 81 DUP2 306B 16 AND 306C 60 PUSH1 0x3f 306E 01 ADD 306F 16 AND 3070 81 DUP2 3071 01 ADD 3072 90 SWAP1 3073 82 DUP3 3074 82 DUP3 3075 11 GT 3076 81 DUP2 3077 83 DUP4 3078 10 LT 3079 17 OR 307A 15 ISZERO 307B 61 PUSH2 0x3086 307E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3072 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @3072 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x3086, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_307F: // Incoming jump from 0x307E, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 307F 61 PUSH2 0x3086 3082 61 PUSH2 0x380a 3085 56 *JUMP // Stack delta = +1 // Outputs[1] { @307F stack[0] = 0x3086 } // Block ends with unconditional jump to 0x380a label_3086: // Incoming jump from 0x307E, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @3087 stack[-2] // @308B stack[-1] // @308C stack[-4] // @308E stack[-6] // @3091 stack[-7] // @3093 stack[-5] // } 3086 5B JUMPDEST 3087 81 DUP2 3088 60 PUSH1 0x40 308A 52 MSTORE 308B 80 DUP1 308C 93 SWAP4 308D 50 POP 308E 85 DUP6 308F 81 DUP2 3090 52 MSTORE 3091 86 DUP7 3092 86 DUP7 3093 86 DUP7 3094 01 ADD 3095 11 GT 3096 15 ISZERO 3097 61 PUSH2 0x309f 309A 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @308A memory[0x40:0x60] = stack[-2] // @308C stack[-4] = stack[-1] // @3090 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x309f, if !(stack[-5] + stack[-6] > stack[-7]) label_309B: // Incoming jump from 0x309A, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @309E memory[0x00:0x00] } 309B 60 PUSH1 0x00 309D 80 DUP1 309E FD *REVERT // Stack delta = +0 // Outputs[1] { @309E revert(memory[0x00:0x00]); } // Block terminates label_309F: // Incoming jump from 0x309A, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @30A0 stack[-6] // @30A1 stack[-5] // @30A4 stack[-1] // @30A6 msg.data[stack[-5]:stack[-5] + stack[-6]] // @30B3 stack[-8] // @30B3 stack[-4] // @30B4 stack[-7] // } 309F 5B JUMPDEST 30A0 85 DUP6 30A1 85 DUP6 30A2 60 PUSH1 0x20 30A4 83 DUP4 30A5 01 ADD 30A6 37 CALLDATACOPY 30A7 60 PUSH1 0x00 30A9 60 PUSH1 0x20 30AB 87 DUP8 30AC 83 DUP4 30AD 01 ADD 30AE 01 ADD 30AF 52 MSTORE 30B0 50 POP 30B1 50 POP 30B2 50 POP 30B3 93 SWAP4 30B4 92 SWAP3 30B5 50 POP 30B6 50 POP 30B7 50 POP 30B8 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @30A6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @30AF memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @30B3 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_30B9: // Incoming call from 0x31A1, returns to 0x31A2 // Incoming call from 0x3253, returns to 0x3254 // Incoming call from 0x328D, returns to 0x328E // Incoming call from 0x31DD, returns to 0x31DE // Incoming call from 0x3152, returns to 0x1CE9 // Incoming call from 0x317B, returns to 0x317C // Incoming call from 0x31AF, returns to 0x31B0 // Incoming call from 0x31EB, returns to 0x31EC // Incoming call from 0x316D, returns to 0x316E // Incoming call from 0x333E, returns to 0x317C // Inputs[2] // { // @30BA stack[-1] // @30BB msg.data[stack[-1]:stack[-1] + 0x20] // } 30B9 5B JUMPDEST 30BA 80 DUP1 30BB 35 CALLDATALOAD 30BC 60 PUSH1 0x01 30BE 60 PUSH1 0x01 30C0 60 PUSH1 0xa0 30C2 1B SHL 30C3 03 SUB 30C4 81 DUP2 30C5 16 AND 30C6 81 DUP2 30C7 14 EQ 30C8 61 PUSH2 0x2992 30CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @30BB stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2992, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_30CC: // Incoming jump from 0x30CB, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @30CF memory[0x00:0x00] } 30CC 60 PUSH1 0x00 30CE 80 DUP1 30CF FD *REVERT // Stack delta = +0 // Outputs[1] { @30CF revert(memory[0x00:0x00]); } // Block terminates label_30D0: // Incoming call from 0x32D3, returns to 0x32D4 // Incoming call from 0x32F8, returns to 0x32F9 // Inputs[2] // { // @30D4 stack[-2] // @30D7 stack[-1] // } 30D0 5B JUMPDEST 30D1 60 PUSH1 0x00 30D3 80 DUP1 30D4 83 DUP4 30D5 60 PUSH1 0x1f 30D7 84 DUP5 30D8 01 ADD 30D9 12 SLT 30DA 61 PUSH2 0x30e1 30DD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @30D1 stack[0] = 0x00 // @30D3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x30e1, if stack[-1] + 0x1f i< stack[-2] label_30DE: // Incoming jump from 0x30DD, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @30DE stack[-1] // @30E0 memory[stack[-1]:stack[-1] + stack[-1]] // } 30DE 80 DUP1 30DF 81 DUP2 30E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @30E0 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_30E1: // Incoming jump from 0x30DD, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @30E3 stack[-3] // @30E4 msg.data[stack[-3]:stack[-3] + 0x20] // } 30E1 5B JUMPDEST 30E2 50 POP 30E3 81 DUP2 30E4 35 CALLDATALOAD 30E5 67 PUSH8 0xffffffffffffffff 30EE 81 DUP2 30EF 11 GT 30F0 15 ISZERO 30F1 61 PUSH2 0x30f8 30F4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @30E4 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x30f8, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_30F5: // Incoming jump from 0x30F4, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @30F5 stack[-2] // @30F7 memory[stack[-2]:stack[-2] + stack[-2]] // } 30F5 81 DUP2 30F6 82 DUP3 30F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @30F7 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_30F8: // Incoming jump from 0x30F4, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @30FB stack[-3] // @30FD stack[-2] // @30FF stack[-4] // @3102 stack[-1] // } 30F8 5B JUMPDEST 30F9 60 PUSH1 0x20 30FB 83 DUP4 30FC 01 ADD 30FD 91 SWAP2 30FE 50 POP 30FF 83 DUP4 3100 60 PUSH1 0x20 3102 82 DUP3 3103 60 PUSH1 0x05 3105 1B SHL 3106 85 DUP6 3107 01 ADD 3108 01 ADD 3109 11 GT 310A 15 ISZERO 310B 61 PUSH2 0x3113 310E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @30FD stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x3113, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_310F: // Incoming jump from 0x310E, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @3112 memory[0x00:0x00] } 310F 60 PUSH1 0x00 3111 80 DUP1 3112 FD *REVERT // Stack delta = +0 // Outputs[1] { @3112 revert(memory[0x00:0x00]); } // Block terminates label_3113: // Incoming jump from 0x310E, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @3114 stack[-1] // @3114 stack[-4] // @3116 stack[-2] // @3116 stack[-5] // @3117 stack[-3] // } 3113 5B JUMPDEST 3114 92 SWAP3 3115 50 POP 3116 92 SWAP3 3117 90 SWAP1 3118 50 POP 3119 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3114 stack[-4] = stack[-1] // @3116 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_311A: // Incoming call from 0x33FC, returns to 0x33FD // Incoming call from 0x33A9, returns to 0x2225 // Inputs[2] // { // @311D stack[-2] // @3120 stack[-1] // } 311A 5B JUMPDEST 311B 60 PUSH1 0x00 311D 82 DUP3 311E 60 PUSH1 0x1f 3120 83 DUP4 3121 01 ADD 3122 12 SLT 3123 61 PUSH2 0x312a 3126 57 *JUMPI // Stack delta = +1 // Outputs[1] { @311B stack[0] = 0x00 } // Block ends with conditional jump to 0x312a, if stack[-1] + 0x1f i< stack[-2] label_3127: // Incoming jump from 0x3126, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @3127 stack[-1] // @3129 memory[stack[-1]:stack[-1] + stack[-1]] // } 3127 80 DUP1 3128 81 DUP2 3129 FD *REVERT // Stack delta = +0 // Outputs[1] { @3129 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_312A: // Incoming jump from 0x3126, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @312E stack[-3] // @312F stack[-2] // @3130 msg.data[stack[-2]:stack[-2] + 0x20] // } 312A 5B JUMPDEST 312B 61 PUSH2 0x1ce9 312E 83 DUP4 312F 83 DUP4 3130 35 CALLDATALOAD 3131 60 PUSH1 0x20 3133 85 DUP6 3134 01 ADD 3135 61 PUSH2 0x3043 3138 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @312B stack[0] = 0x1ce9 // @312E stack[1] = stack[-3] // @3130 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @3134 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x3043, returns to 0x1CE9 label_3139: // Incoming call from 0x06D8, returns to 0x06D9 // Incoming call from 0x03C0, returns to 0x03C1 // Incoming call from 0x0529, returns to 0x052A // Inputs[2] // { // @313E stack[-1] // @313F stack[-2] // } 3139 5B JUMPDEST 313A 60 PUSH1 0x00 313C 60 PUSH1 0x20 313E 82 DUP3 313F 84 DUP5 3140 03 SUB 3141 12 SLT 3142 15 ISZERO 3143 61 PUSH2 0x314a 3146 57 *JUMPI // Stack delta = +1 // Outputs[1] { @313A stack[0] = 0x00 } // Block ends with conditional jump to 0x314a, if !(stack[-2] - stack[-1] i< 0x20) label_3147: // Incoming jump from 0x3146, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3147 stack[-1] // @3149 memory[stack[-1]:stack[-1] + stack[-1]] // } 3147 80 DUP1 3148 81 DUP2 3149 FD *REVERT // Stack delta = +0 // Outputs[1] { @3149 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_314A: // Incoming jump from 0x3146, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @314E stack[-2] } 314A 5B JUMPDEST 314B 61 PUSH2 0x1ce9 314E 82 DUP3 314F 61 PUSH2 0x30b9 3152 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @314B stack[0] = 0x1ce9 // @314E stack[1] = stack[-2] // } // Block ends with call to 0x30b9, returns to 0x1CE9 label_3153: // Incoming jump from 0x069C // Inputs[2] // { // @3159 stack[-1] // @315A stack[-2] // } 3153 5B JUMPDEST 3154 60 PUSH1 0x00 3156 80 DUP1 3157 60 PUSH1 0x40 3159 83 DUP4 315A 85 DUP6 315B 03 SUB 315C 12 SLT 315D 15 ISZERO 315E 61 PUSH2 0x3165 3161 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3154 stack[0] = 0x00 // @3156 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3165, if !(stack[-2] - stack[-1] i< 0x40) label_3162: // Incoming jump from 0x3161, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3162 stack[-1] // @3164 memory[stack[-1]:stack[-1] + stack[-1]] // } 3162 80 DUP1 3163 81 DUP2 3164 FD *REVERT // Stack delta = +0 // Outputs[1] { @3164 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3165: // Incoming jump from 0x3161, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3169 stack[-3] } 3165 5B JUMPDEST 3166 61 PUSH2 0x316e 3169 83 DUP4 316A 61 PUSH2 0x30b9 316D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3166 stack[0] = 0x316e // @3169 stack[1] = stack[-3] // } // Block ends with call to 0x30b9, returns to 0x316E label_316E: // Incoming return from call to 0x30B9 at 0x316D // Inputs[3] // { // @316F stack[-3] // @316F stack[-1] // @3176 stack[-4] // } 316E 5B JUMPDEST 316F 91 SWAP2 3170 50 POP 3171 61 PUSH2 0x317c 3174 60 PUSH1 0x20 3176 84 DUP5 3177 01 ADD 3178 61 PUSH2 0x30b9 317B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @316F stack[-3] = stack[-1] // @3171 stack[-1] = 0x317c // @3177 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x30b9, returns to 0x317C label_317C: // Incoming return from call to 0x30B9 at 0x317B // Incoming return from call to 0x30B9 at 0x333E // Inputs[6] // { // @317D stack[-1] // @317D stack[-2] // @317F stack[-5] // @3181 stack[-3] // @3181 stack[-6] // @3182 stack[-4] // } 317C 5B JUMPDEST 317D 90 SWAP1 317E 50 POP 317F 92 SWAP3 3180 50 POP 3181 92 SWAP3 3182 90 SWAP1 3183 50 POP 3184 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @317F stack[-5] = stack[-1] // @3181 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_3185: // Incoming call from 0x038A, returns to 0x038B // Incoming call from 0x04BF, returns to 0x04C0 // Inputs[2] // { // @318D stack[-1] // @318E stack[-2] // } 3185 5B JUMPDEST 3186 60 PUSH1 0x00 3188 80 DUP1 3189 60 PUSH1 0x00 318B 60 PUSH1 0x60 318D 84 DUP5 318E 86 DUP7 318F 03 SUB 3190 12 SLT 3191 15 ISZERO 3192 61 PUSH2 0x3199 3195 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3186 stack[0] = 0x00 // @3188 stack[1] = 0x00 // @3189 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3199, if !(stack[-2] - stack[-1] i< 0x60) label_3196: // Incoming jump from 0x3195, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3196 stack[-1] // @3198 memory[stack[-1]:stack[-1] + stack[-1]] // } 3196 80 DUP1 3197 81 DUP2 3198 FD *REVERT // Stack delta = +0 // Outputs[1] { @3198 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3199: // Incoming jump from 0x3195, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @319D stack[-4] } 3199 5B JUMPDEST 319A 61 PUSH2 0x31a2 319D 84 DUP5 319E 61 PUSH2 0x30b9 31A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @319A stack[0] = 0x31a2 // @319D stack[1] = stack[-4] // } // Block ends with call to 0x30b9, returns to 0x31A2 label_31A2: // Incoming return from call to 0x30B9 at 0x31A1 // Inputs[3] // { // @31A3 stack[-4] // @31A3 stack[-1] // @31AA stack[-5] // } 31A2 5B JUMPDEST 31A3 92 SWAP3 31A4 50 POP 31A5 61 PUSH2 0x31b0 31A8 60 PUSH1 0x20 31AA 85 DUP6 31AB 01 ADD 31AC 61 PUSH2 0x30b9 31AF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @31A3 stack[-4] = stack[-1] // @31A5 stack[-1] = 0x31b0 // @31AB stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x30b9, returns to 0x31B0 label_31B0: // Incoming return from call to 0x30B9 at 0x31AF // Inputs[8] // { // @31B1 stack[-3] // @31B1 stack[-1] // @31B5 stack[-5] // @31B7 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @31B8 stack[-2] // @31BC stack[-6] // @31BE stack[-4] // @31BE stack[-7] // } 31B0 5B JUMPDEST 31B1 91 SWAP2 31B2 50 POP 31B3 60 PUSH1 0x40 31B5 84 DUP5 31B6 01 ADD 31B7 35 CALLDATALOAD 31B8 90 SWAP1 31B9 50 POP 31BA 92 SWAP3 31BB 50 POP 31BC 92 SWAP3 31BD 50 POP 31BE 92 SWAP3 31BF 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @31BA stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @31BC stack[-6] = stack[-1] // @31BE stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_31C0: // Incoming call from 0x0605, returns to 0x0606 // Inputs[2] // { // @31C9 stack[-1] // @31CA stack[-2] // } 31C0 5B JUMPDEST 31C1 60 PUSH1 0x00 31C3 80 DUP1 31C4 60 PUSH1 0x00 31C6 80 DUP1 31C7 60 PUSH1 0x80 31C9 85 DUP6 31CA 87 DUP8 31CB 03 SUB 31CC 12 SLT 31CD 15 ISZERO 31CE 61 PUSH2 0x31d5 31D1 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @31C1 stack[0] = 0x00 // @31C3 stack[1] = 0x00 // @31C4 stack[2] = 0x00 // @31C6 stack[3] = 0x00 // } // Block ends with conditional jump to 0x31d5, if !(stack[-2] - stack[-1] i< 0x80) label_31D2: // Incoming jump from 0x31D1, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @31D2 stack[-1] // @31D4 memory[stack[-1]:stack[-1] + stack[-1]] // } 31D2 80 DUP1 31D3 81 DUP2 31D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @31D4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_31D5: // Incoming jump from 0x31D1, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @31D9 stack[-5] } 31D5 5B JUMPDEST 31D6 61 PUSH2 0x31de 31D9 85 DUP6 31DA 61 PUSH2 0x30b9 31DD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @31D6 stack[0] = 0x31de // @31D9 stack[1] = stack[-5] // } // Block ends with call to 0x30b9, returns to 0x31DE label_31DE: // Incoming return from call to 0x30B9 at 0x31DD // Inputs[3] // { // @31DF stack[-1] // @31DF stack[-5] // @31E6 stack[-6] // } 31DE 5B JUMPDEST 31DF 93 SWAP4 31E0 50 POP 31E1 61 PUSH2 0x31ec 31E4 60 PUSH1 0x20 31E6 86 DUP7 31E7 01 ADD 31E8 61 PUSH2 0x30b9 31EB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @31DF stack[-5] = stack[-1] // @31E1 stack[-1] = 0x31ec // @31E7 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x30b9, returns to 0x31EC label_31EC: // Incoming return from call to 0x30B9 at 0x31EB // Inputs[6] // { // @31ED stack[-4] // @31ED stack[-1] // @31F1 stack[-6] // @31F3 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @31F4 stack[-3] // @31FA msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 31EC 5B JUMPDEST 31ED 92 SWAP3 31EE 50 POP 31EF 60 PUSH1 0x40 31F1 85 DUP6 31F2 01 ADD 31F3 35 CALLDATALOAD 31F4 91 SWAP2 31F5 50 POP 31F6 60 PUSH1 0x60 31F8 85 DUP6 31F9 01 ADD 31FA 35 CALLDATALOAD 31FB 67 PUSH8 0xffffffffffffffff 3204 81 DUP2 3205 11 GT 3206 15 ISZERO 3207 61 PUSH2 0x320e 320A 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @31ED stack[-4] = stack[-1] // @31F4 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @31FA stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x320e, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_320B: // Incoming jump from 0x320A, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @320B stack[-2] // @320D memory[stack[-2]:stack[-2] + stack[-2]] // } 320B 81 DUP2 320C 82 DUP3 320D FD *REVERT // Stack delta = +0 // Outputs[1] { @320D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_320E: // Incoming jump from 0x320A, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @320F stack[-6] // @3210 stack[-1] // @3215 stack[-7] // } 320E 5B JUMPDEST 320F 85 DUP6 3210 01 ADD 3211 60 PUSH1 0x1f 3213 81 DUP2 3214 01 ADD 3215 87 DUP8 3216 13 SGT 3217 61 PUSH2 0x321e 321A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3210 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x321e, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_321B: // Incoming jump from 0x321A, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @321B stack[-2] // @321D memory[stack[-2]:stack[-2] + stack[-2]] // } 321B 81 DUP2 321C 82 DUP3 321D FD *REVERT // Stack delta = +0 // Outputs[1] { @321D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_321E: // Incoming jump from 0x321A, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @3222 stack[-7] // @3223 stack[-1] // @3224 msg.data[stack[-1]:stack[-1] + 0x20] // } 321E 5B JUMPDEST 321F 61 PUSH2 0x322d 3222 87 DUP8 3223 82 DUP3 3224 35 CALLDATALOAD 3225 60 PUSH1 0x20 3227 84 DUP5 3228 01 ADD 3229 61 PUSH2 0x3043 322C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @321F stack[0] = 0x322d // @3222 stack[1] = stack[-7] // @3224 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @3228 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x3043, returns to 0x322D label_322D: // Incoming return from call to 0x3043 at 0x322C // Inputs[8] // { // @322E stack[-1] // @322E stack[-3] // @3231 stack[-6] // @3232 stack[-9] // @3233 stack[-5] // @3234 stack[-8] // @3236 stack[-4] // @3236 stack[-7] // } 322D 5B JUMPDEST 322E 91 SWAP2 322F 50 POP 3230 50 POP 3231 92 SWAP3 3232 95 SWAP6 3233 91 SWAP2 3234 94 SWAP5 3235 50 POP 3236 92 SWAP3 3237 50 POP 3238 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @3231 stack[-6] = stack[-1] // @3232 stack[-9] = stack[-6] // @3234 stack[-8] = stack[-5] // @3236 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_3239: // Incoming call from 0x05BE, returns to 0x05BF // Inputs[2] // { // @323F stack[-1] // @3240 stack[-2] // } 3239 5B JUMPDEST 323A 60 PUSH1 0x00 323C 80 DUP1 323D 60 PUSH1 0x40 323F 83 DUP4 3240 85 DUP6 3241 03 SUB 3242 12 SLT 3243 15 ISZERO 3244 61 PUSH2 0x324b 3247 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @323A stack[0] = 0x00 // @323C stack[1] = 0x00 // } // Block ends with conditional jump to 0x324b, if !(stack[-2] - stack[-1] i< 0x40) label_3248: // Incoming jump from 0x3247, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3248 stack[-2] // @324A memory[stack[-2]:stack[-2] + stack[-2]] // } 3248 81 DUP2 3249 82 DUP3 324A FD *REVERT // Stack delta = +0 // Outputs[1] { @324A revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_324B: // Incoming jump from 0x3247, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @324F stack[-3] } 324B 5B JUMPDEST 324C 61 PUSH2 0x3254 324F 83 DUP4 3250 61 PUSH2 0x30b9 3253 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @324C stack[0] = 0x3254 // @324F stack[1] = stack[-3] // } // Block ends with call to 0x30b9, returns to 0x3254 label_3254: // Incoming return from call to 0x30B9 at 0x3253 // Inputs[4] // { // @3255 stack[-1] // @3255 stack[-3] // @3259 stack[-4] // @325B msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 3254 5B JUMPDEST 3255 91 SWAP2 3256 50 POP 3257 60 PUSH1 0x20 3259 83 DUP4 325A 01 ADD 325B 35 CALLDATALOAD 325C 80 DUP1 325D 15 ISZERO 325E 15 ISZERO 325F 81 DUP2 3260 14 EQ 3261 61 PUSH2 0x3268 3264 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3255 stack[-3] = stack[-1] // @325B stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x3268, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_3265: // Incoming jump from 0x3264, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @3265 stack[-2] // @3267 memory[stack[-2]:stack[-2] + stack[-2]] // } 3265 81 DUP2 3266 82 DUP3 3267 FD *REVERT // Stack delta = +0 // Outputs[1] { @3267 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3268: // Incoming jump from 0x3264, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @3269 stack[-1] // @326A stack[-2] // @326D stack[-5] // @326F stack[-6] // @326F stack[-3] // @3270 stack[-4] // } 3268 5B JUMPDEST 3269 80 DUP1 326A 91 SWAP2 326B 50 POP 326C 50 POP 326D 92 SWAP3 326E 50 POP 326F 92 SWAP3 3270 90 SWAP1 3271 50 POP 3272 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @326D stack[-5] = stack[-1] // @326F stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_3273: // Incoming call from 0x03F9, returns to 0x03FA // Incoming call from 0x048F, returns to 0x0490 // Incoming call from 0x0588, returns to 0x0589 // Incoming call from 0x0350, returns to 0x0351 // Incoming call from 0x065B, returns to 0x065C // Inputs[2] // { // @3279 stack[-1] // @327A stack[-2] // } 3273 5B JUMPDEST 3274 60 PUSH1 0x00 3276 80 DUP1 3277 60 PUSH1 0x40 3279 83 DUP4 327A 85 DUP6 327B 03 SUB 327C 12 SLT 327D 15 ISZERO 327E 61 PUSH2 0x3285 3281 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3274 stack[0] = 0x00 // @3276 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3285, if !(stack[-2] - stack[-1] i< 0x40) label_3282: // Incoming jump from 0x3281, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3282 stack[-2] // @3284 memory[stack[-2]:stack[-2] + stack[-2]] // } 3282 81 DUP2 3283 82 DUP3 3284 FD *REVERT // Stack delta = +0 // Outputs[1] { @3284 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3285: // Incoming jump from 0x3281, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3289 stack[-3] } 3285 5B JUMPDEST 3286 61 PUSH2 0x328e 3289 83 DUP4 328A 61 PUSH2 0x30b9 328D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3286 stack[0] = 0x328e // @3289 stack[1] = stack[-3] // } // Block ends with call to 0x30b9, returns to 0x328E label_328E: // Incoming return from call to 0x30B9 at 0x328D // Inputs[5] // { // @328F stack[-6] // @328F stack[-1] // @3292 stack[-4] // @3296 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @3297 stack[-5] // } 328E 5B JUMPDEST 328F 94 SWAP5 3290 60 PUSH1 0x20 3292 93 SWAP4 3293 90 SWAP1 3294 93 SWAP4 3295 01 ADD 3296 35 CALLDATALOAD 3297 93 SWAP4 3298 50 POP 3299 50 POP 329A 50 POP 329B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @328F stack[-6] = stack[-1] // @3297 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_329C: // Incoming call from 0x03D3, returns to 0x03D4 // Inputs[2] // { // @32A5 stack[-1] // @32A6 stack[-2] // } 329C 5B JUMPDEST 329D 60 PUSH1 0x00 329F 80 DUP1 32A0 60 PUSH1 0x00 32A2 80 DUP1 32A3 60 PUSH1 0x40 32A5 85 DUP6 32A6 87 DUP8 32A7 03 SUB 32A8 12 SLT 32A9 15 ISZERO 32AA 61 PUSH2 0x32b1 32AD 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @329D stack[0] = 0x00 // @329F stack[1] = 0x00 // @32A0 stack[2] = 0x00 // @32A2 stack[3] = 0x00 // } // Block ends with conditional jump to 0x32b1, if !(stack[-2] - stack[-1] i< 0x40) label_32AE: // Incoming jump from 0x32AD, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @32AE stack[-4] // @32B0 memory[stack[-4]:stack[-4] + stack[-4]] // } 32AE 83 DUP4 32AF 84 DUP5 32B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @32B0 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_32B1: // Incoming jump from 0x32AD, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @32B2 stack[-5] // @32B3 msg.data[stack[-5]:stack[-5] + 0x20] // } 32B1 5B JUMPDEST 32B2 84 DUP5 32B3 35 CALLDATALOAD 32B4 67 PUSH8 0xffffffffffffffff 32BD 80 DUP1 32BE 82 DUP3 32BF 11 GT 32C0 15 ISZERO 32C1 61 PUSH2 0x32c8 32C4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @32B3 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @32B4 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x32c8, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) label_32C5: // Incoming jump from 0x32C4, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @32C5 stack[-6] // @32C7 memory[stack[-6]:stack[-6] + stack[-6]] // } 32C5 85 DUP6 32C6 86 DUP7 32C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @32C7 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_32C8: // Incoming jump from 0x32C4, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @32CC stack[-8] // @32CD stack[-2] // @32CE stack[-7] // } 32C8 5B JUMPDEST 32C9 61 PUSH2 0x32d4 32CC 88 DUP9 32CD 83 DUP4 32CE 89 DUP10 32CF 01 ADD 32D0 61 PUSH2 0x30d0 32D3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @32C9 stack[0] = 0x32d4 // @32CC stack[1] = stack[-8] // @32CF stack[2] = stack[-7] + stack[-2] // } // Block ends with call to 0x30d0, returns to 0x32D4 label_32D4: // Incoming return from call to 0x30D0 at 0x32D3 // Inputs[8] // { // @32D5 stack[-2] // @32D5 stack[-1] // @32D6 stack[-8] // @32D8 stack[-7] // @32DC stack[-9] // @32DE msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @32DF stack[-4] // @32E1 stack[-3] // } 32D4 5B JUMPDEST 32D5 90 SWAP1 32D6 96 SWAP7 32D7 50 POP 32D8 94 SWAP5 32D9 50 POP 32DA 60 PUSH1 0x20 32DC 87 DUP8 32DD 01 ADD 32DE 35 CALLDATALOAD 32DF 91 SWAP2 32E0 50 POP 32E1 80 DUP1 32E2 82 DUP3 32E3 11 GT 32E4 15 ISZERO 32E5 61 PUSH2 0x32ec 32E8 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @32D6 stack[-8] = stack[-2] // @32D8 stack[-7] = stack[-1] // @32DF stack[-4] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x32ec, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) label_32E9: // Incoming jump from 0x32E8, if not !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) // Inputs[2] // { // @32E9 stack[-4] // @32EB memory[stack[-4]:stack[-4] + stack[-4]] // } 32E9 83 DUP4 32EA 84 DUP5 32EB FD *REVERT // Stack delta = +0 // Outputs[1] { @32EB revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_32EC: // Incoming jump from 0x32E8, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) // Inputs[3] // { // @32F1 stack[-8] // @32F2 stack[-2] // @32F3 stack[-7] // } 32EC 5B JUMPDEST 32ED 50 POP 32EE 61 PUSH2 0x32f9 32F1 87 DUP8 32F2 82 DUP3 32F3 88 DUP9 32F4 01 ADD 32F5 61 PUSH2 0x30d0 32F8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @32EE stack[-1] = 0x32f9 // @32F1 stack[0] = stack[-8] // @32F4 stack[1] = stack[-7] + stack[-2] // } // Block ends with call to 0x30d0, returns to 0x32F9 label_32F9: // Incoming return from call to 0x30D0 at 0x32F8 // Inputs[7] // { // @32FA stack[-7] // @32FA stack[-1] // @32FB stack[-10] // @32FC stack[-6] // @32FD stack[-9] // @32FF stack[-8] // @32FF stack[-2] // } 32F9 5B JUMPDEST 32FA 95 SWAP6 32FB 98 SWAP9 32FC 94 SWAP5 32FD 97 SWAP8 32FE 50 POP 32FF 95 SWAP6 3300 50 POP 3301 50 POP 3302 50 POP 3303 50 POP 3304 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @32FA stack[-7] = stack[-1] // @32FB stack[-10] = stack[-7] // @32FD stack[-9] = stack[-6] // @32FF stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_3305: // Incoming call from 0x04E5, returns to 0x04E6 // Incoming call from 0x04D2, returns to 0x04D3 // Incoming call from 0x066E, returns to 0x066F // Incoming call from 0x054C, returns to 0x054D // Incoming call from 0x0620, returns to 0x0621 // Incoming call from 0x039D, returns to 0x039E // Incoming call from 0x0516, returns to 0x0517 // Incoming call from 0x05E4, returns to 0x05E5 // Incoming call from 0x0325, returns to 0x0326 // Incoming call from 0x0445, returns to 0x0446 // Inputs[2] // { // @330A stack[-1] // @330B stack[-2] // } 3305 5B JUMPDEST 3306 60 PUSH1 0x00 3308 60 PUSH1 0x20 330A 82 DUP3 330B 84 DUP5 330C 03 SUB 330D 12 SLT 330E 15 ISZERO 330F 61 PUSH2 0x3316 3312 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3306 stack[0] = 0x00 } // Block ends with conditional jump to 0x3316, if !(stack[-2] - stack[-1] i< 0x20) label_3313: // Incoming jump from 0x3312, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3313 stack[-1] // @3315 memory[stack[-1]:stack[-1] + stack[-1]] // } 3313 80 DUP1 3314 81 DUP2 3315 FD *REVERT // Stack delta = +0 // Outputs[1] { @3315 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3316: // Incoming jump from 0x3312, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @3318 msg.data[stack[-2]:stack[-2] + 0x20] // @3318 stack[-2] // @3319 stack[-4] // @331A stack[-3] // } 3316 5B JUMPDEST 3317 50 POP 3318 35 CALLDATALOAD 3319 91 SWAP2 331A 90 SWAP1 331B 50 POP 331C 56 *JUMP // Stack delta = -3 // Outputs[1] { @3319 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_331D: // Incoming call from 0x03E6, returns to 0x03E7 // Incoming call from 0x0432, returns to 0x0433 // Incoming call from 0x0648, returns to 0x0649 // Incoming call from 0x0575, returns to 0x0576 // Inputs[2] // { // @3323 stack[-1] // @3324 stack[-2] // } 331D 5B JUMPDEST 331E 60 PUSH1 0x00 3320 80 DUP1 3321 60 PUSH1 0x40 3323 83 DUP4 3324 85 DUP6 3325 03 SUB 3326 12 SLT 3327 15 ISZERO 3328 61 PUSH2 0x332f 332B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @331E stack[0] = 0x00 // @3320 stack[1] = 0x00 // } // Block ends with conditional jump to 0x332f, if !(stack[-2] - stack[-1] i< 0x40) label_332C: // Incoming jump from 0x332B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @332C stack[-2] // @332E memory[stack[-2]:stack[-2] + stack[-2]] // } 332C 81 DUP2 332D 82 DUP3 332E FD *REVERT // Stack delta = +0 // Outputs[1] { @332E revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_332F: // Incoming jump from 0x332B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @3330 stack[-3] // @3331 msg.data[stack[-3]:stack[-3] + 0x20] // @3332 stack[-2] // } 332F 5B JUMPDEST 3330 82 DUP3 3331 35 CALLDATALOAD 3332 91 SWAP2 3333 50 POP 3334 61 PUSH2 0x317c 3337 60 PUSH1 0x20 3339 84 DUP5 333A 01 ADD 333B 61 PUSH2 0x30b9 333E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3332 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @3334 stack[0] = 0x317c // @333A stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x30b9, returns to 0x317C label_333F: // Incoming call from 0x02E8, returns to 0x02E9 // Inputs[2] // { // @3344 stack[-1] // @3345 stack[-2] // } 333F 5B JUMPDEST 3340 60 PUSH1 0x00 3342 60 PUSH1 0x20 3344 82 DUP3 3345 84 DUP5 3346 03 SUB 3347 12 SLT 3348 15 ISZERO 3349 61 PUSH2 0x3350 334C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3340 stack[0] = 0x00 } // Block ends with conditional jump to 0x3350, if !(stack[-2] - stack[-1] i< 0x20) label_334D: // Incoming jump from 0x334C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @334D stack[-1] // @334F memory[stack[-1]:stack[-1] + stack[-1]] // } 334D 80 DUP1 334E 81 DUP2 334F FD *REVERT // Stack delta = +0 // Outputs[1] { @334F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3350: // Incoming jump from 0x334C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3351 stack[-2] // @3352 msg.data[stack[-2]:stack[-2] + 0x20] // } 3350 5B JUMPDEST 3351 81 DUP2 3352 35 CALLDATALOAD 3353 61 PUSH2 0x1ce9 3356 81 DUP2 3357 61 PUSH2 0x3820 335A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3352 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @3353 stack[1] = 0x1ce9 // @3356 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3820, returns to 0x1CE9 335B 5B JUMPDEST 335C 60 PUSH1 0x00 335E 60 PUSH1 0x20 3360 82 DUP3 3361 84 DUP5 3362 03 SUB 3363 12 SLT 3364 15 ISZERO 3365 61 PUSH2 0x336c 3368 57 *JUMPI 3369 80 DUP1 336A 81 DUP2 336B FD *REVERT 336C 5B JUMPDEST 336D 81 DUP2 336E 51 MLOAD 336F 61 PUSH2 0x1ce9 3372 81 DUP2 3373 61 PUSH2 0x3820 3376 56 *JUMP label_3377: // Incoming call from 0x040C, returns to 0x040D // Incoming call from 0x04F8, returns to 0x04F9 // Incoming call from 0x059B, returns to 0x059C // Inputs[2] // { // @337C stack[-1] // @337D stack[-2] // } 3377 5B JUMPDEST 3378 60 PUSH1 0x00 337A 60 PUSH1 0x20 337C 82 DUP3 337D 84 DUP5 337E 03 SUB 337F 12 SLT 3380 15 ISZERO 3381 61 PUSH2 0x3388 3384 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3378 stack[0] = 0x00 } // Block ends with conditional jump to 0x3388, if !(stack[-2] - stack[-1] i< 0x20) label_3385: // Incoming jump from 0x3384, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3385 stack[-1] // @3387 memory[stack[-1]:stack[-1] + stack[-1]] // } 3385 80 DUP1 3386 81 DUP2 3387 FD *REVERT // Stack delta = +0 // Outputs[1] { @3387 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3388: // Incoming jump from 0x3384, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3389 stack[-2] // @338A msg.data[stack[-2]:stack[-2] + 0x20] // } 3388 5B JUMPDEST 3389 81 DUP2 338A 35 CALLDATALOAD 338B 67 PUSH8 0xffffffffffffffff 3394 81 DUP2 3395 11 GT 3396 15 ISZERO 3397 61 PUSH2 0x339e 339A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @338A stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x339e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_339B: // Incoming jump from 0x339A, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @339B stack[-2] // @339D memory[stack[-2]:stack[-2] + stack[-2]] // } 339B 81 DUP2 339C 82 DUP3 339D FD *REVERT // Stack delta = +0 // Outputs[1] { @339D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_339E: // Incoming jump from 0x339A, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @33A2 stack[-4] // @33A3 stack[-1] // @33A4 stack[-3] // } 339E 5B JUMPDEST 339F 61 PUSH2 0x2225 33A2 84 DUP5 33A3 82 DUP3 33A4 85 DUP6 33A5 01 ADD 33A6 61 PUSH2 0x311a 33A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @339F stack[0] = 0x2225 // @33A2 stack[1] = stack[-4] // @33A5 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x311a, returns to 0x2225 33AA 5B JUMPDEST 33AB 60 PUSH1 0x00 33AD 60 PUSH1 0x20 33AF 82 DUP3 33B0 84 DUP5 33B1 03 SUB 33B2 12 SLT 33B3 15 ISZERO 33B4 61 PUSH2 0x33bb 33B7 57 *JUMPI 33B8 80 DUP1 33B9 81 DUP2 33BA FD *REVERT 33BB 5B JUMPDEST 33BC 50 POP 33BD 51 MLOAD 33BE 91 SWAP2 33BF 90 SWAP1 33C0 50 POP 33C1 56 *JUMP label_33C2: // Incoming call from 0x0377, returns to 0x0378 // Inputs[2] // { // @33C8 stack[-1] // @33C9 stack[-2] // } 33C2 5B JUMPDEST 33C3 60 PUSH1 0x00 33C5 80 DUP1 33C6 60 PUSH1 0x40 33C8 83 DUP4 33C9 85 DUP6 33CA 03 SUB 33CB 12 SLT 33CC 15 ISZERO 33CD 61 PUSH2 0x33d4 33D0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @33C3 stack[0] = 0x00 // @33C5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x33d4, if !(stack[-2] - stack[-1] i< 0x40) label_33D1: // Incoming jump from 0x33D0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @33D1 stack[-2] // @33D3 memory[stack[-2]:stack[-2] + stack[-2]] // } 33D1 81 DUP2 33D2 82 DUP3 33D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @33D3 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_33D4: // Incoming jump from 0x33D0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @33D5 stack[-3] // @33D6 msg.data[stack[-3]:stack[-3] + 0x20] // @33D7 stack[-2] // @33DD msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 33D4 5B JUMPDEST 33D5 82 DUP3 33D6 35 CALLDATALOAD 33D7 91 SWAP2 33D8 50 POP 33D9 60 PUSH1 0x20 33DB 83 DUP4 33DC 01 ADD 33DD 35 CALLDATALOAD 33DE 67 PUSH8 0xffffffffffffffff 33E7 81 DUP2 33E8 11 GT 33E9 15 ISZERO 33EA 61 PUSH2 0x33f1 33ED 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @33D7 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @33DD stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x33f1, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_33EE: // Incoming jump from 0x33ED, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @33EE stack[-2] // @33F0 memory[stack[-2]:stack[-2] + stack[-2]] // } 33EE 81 DUP2 33EF 82 DUP3 33F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @33F0 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_33F1: // Incoming jump from 0x33ED, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @33F5 stack[-5] // @33F6 stack[-1] // @33F7 stack[-4] // } 33F1 5B JUMPDEST 33F2 61 PUSH2 0x33fd 33F5 85 DUP6 33F6 82 DUP3 33F7 86 DUP7 33F8 01 ADD 33F9 61 PUSH2 0x311a 33FC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @33F2 stack[0] = 0x33fd // @33F5 stack[1] = stack[-5] // @33F8 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x311a, returns to 0x33FD label_33FD: // Incoming return from call to 0x311A at 0x33FC // Inputs[6] // { // @33FE stack[-1] // @33FE stack[-3] // @3401 stack[-6] // @3403 stack[-4] // @3403 stack[-7] // @3404 stack[-5] // } 33FD 5B JUMPDEST 33FE 91 SWAP2 33FF 50 POP 3400 50 POP 3401 92 SWAP3 3402 50 POP 3403 92 SWAP3 3404 90 SWAP1 3405 50 POP 3406 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @3401 stack[-6] = stack[-1] // @3403 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_3407: // Incoming call from 0x05D1, returns to 0x05D2 // Incoming call from 0x0681, returns to 0x0682 // Incoming call from 0x06EB, returns to 0x06EC // Inputs[2] // { // @340D stack[-1] // @340E stack[-2] // } 3407 5B JUMPDEST 3408 60 PUSH1 0x00 340A 80 DUP1 340B 60 PUSH1 0x40 340D 83 DUP4 340E 85 DUP6 340F 03 SUB 3410 12 SLT 3411 15 ISZERO 3412 61 PUSH2 0x3419 3415 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3408 stack[0] = 0x00 // @340A stack[1] = 0x00 // } // Block ends with conditional jump to 0x3419, if !(stack[-2] - stack[-1] i< 0x40) label_3416: // Incoming jump from 0x3415, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3416 stack[-2] // @3418 memory[stack[-2]:stack[-2] + stack[-2]] // } 3416 81 DUP2 3417 82 DUP3 3418 FD *REVERT // Stack delta = +0 // Outputs[1] { @3418 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3419: // Incoming jump from 0x3415, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @341C stack[-3] // @341D msg.data[stack[-3]:stack[-3] + 0x20] // @341E stack[-5] // @3424 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3425 stack[-4] // } 3419 5B JUMPDEST 341A 50 POP 341B 50 POP 341C 80 DUP1 341D 35 CALLDATALOAD 341E 92 SWAP3 341F 60 PUSH1 0x20 3421 90 SWAP1 3422 91 SWAP2 3423 01 ADD 3424 35 CALLDATALOAD 3425 91 SWAP2 3426 50 POP 3427 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @341E stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @3425 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_3428: // Incoming call from 0x3582, returns to 0x1CE9 // Incoming call from 0x3595, returns to 0x3596 // Inputs[3] // { // @342B stack[-1] // @342C memory[stack[-1]:stack[-1] + 0x20] // @342E stack[-2] // } 3428 5B JUMPDEST 3429 60 PUSH1 0x00 342B 81 DUP2 342C 51 MLOAD 342D 80 DUP1 342E 84 DUP5 342F 52 MSTORE 3430 61 PUSH2 0x3440 3433 81 DUP2 3434 60 PUSH1 0x20 3436 86 DUP7 3437 01 ADD 3438 60 PUSH1 0x20 343A 86 DUP7 343B 01 ADD 343C 61 PUSH2 0x3731 343F 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @3429 stack[0] = 0x00 // @342C stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @342F memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @3430 stack[2] = 0x3440 // @3433 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @3437 stack[4] = stack[-2] + 0x20 // @343B stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x3731, returns to 0x3440 label_3440: // Incoming return from call to 0x3731 at 0x343F // Inputs[4] // { // @3443 stack[-1] // @3448 stack[-4] // @3449 stack[-2] // @344F stack[-5] // } 3440 5B JUMPDEST 3441 60 PUSH1 0x1f 3443 01 ADD 3444 60 PUSH1 0x1f 3446 19 NOT 3447 16 AND 3448 92 SWAP3 3449 90 SWAP1 344A 92 SWAP3 344B 01 ADD 344C 60 PUSH1 0x20 344E 01 ADD 344F 92 SWAP3 3450 91 SWAP2 3451 50 POP 3452 50 POP 3453 56 *JUMP // Stack delta = -4 // Outputs[1] { @344F stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_3454: // Incoming call from 0x1CD8, returns to 0x1CD9 // Inputs[3] // { // @3457 stack[-3] // @3458 memory[stack[-3]:stack[-3] + 0x20] // @345D stack[-1] // } 3454 5B JUMPDEST 3455 60 PUSH1 0x00 3457 83 DUP4 3458 51 MLOAD 3459 61 PUSH2 0x3466 345C 81 DUP2 345D 84 DUP5 345E 60 PUSH1 0x20 3460 88 DUP9 3461 01 ADD 3462 61 PUSH2 0x3731 3465 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3455 stack[0] = 0x00 // @3458 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @3459 stack[2] = 0x3466 // @345C stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @345D stack[4] = stack[-1] // @3461 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x3731, returns to 0x3466 label_3466: // Incoming return from call to 0x3731 at 0x3465 // Inputs[4] // { // @3467 stack[-4] // @3468 memory[stack[-4]:stack[-4] + 0x20] // @3469 stack[-1] // @346A stack[-3] // } 3466 5B JUMPDEST 3467 83 DUP4 3468 51 MLOAD 3469 90 SWAP1 346A 83 DUP4 346B 01 ADD 346C 90 SWAP1 346D 61 PUSH2 0x347a 3470 81 DUP2 3471 83 DUP4 3472 60 PUSH1 0x20 3474 88 DUP9 3475 01 ADD 3476 61 PUSH2 0x3731 3479 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @346C stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @346C stack[-1] = stack[-3] + stack[-1] // @346D stack[1] = 0x347a // @3470 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @3471 stack[3] = stack[-3] + stack[-1] // @3475 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x3731, returns to 0x347A label_347A: // Incoming return from call to 0x3731 at 0x3479 // Inputs[4] // { // @347B stack[-1] // @347B stack[-2] // @347C stack[-7] // @347D stack[-6] // } 347A 5B JUMPDEST 347B 01 ADD 347C 94 SWAP5 347D 93 SWAP4 347E 50 POP 347F 50 POP 3480 50 POP 3481 50 POP 3482 56 *JUMP // Stack delta = -6 // Outputs[1] { @347C stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 3483 5B JUMPDEST 3484 60 PUSH1 0x00 3486 83 DUP4 3487 51 MLOAD 3488 61 PUSH2 0x3495 348B 81 DUP2 348C 84 DUP5 348D 60 PUSH1 0x20 348F 88 DUP9 3490 01 ADD 3491 61 PUSH2 0x3731 3494 56 *JUMP 3495 5B JUMPDEST 3496 83 DUP4 3497 51 MLOAD 3498 90 SWAP1 3499 83 DUP4 349A 01 ADD 349B 90 SWAP1 349C 61 PUSH2 0x34a9 349F 81 DUP2 34A0 83 DUP4 34A1 60 PUSH1 0x20 34A3 88 DUP9 34A4 01 ADD 34A5 61 PUSH2 0x3731 34A8 56 *JUMP 34A9 5B JUMPDEST 34AA 60 PUSH1 0x0b 34AC 60 PUSH1 0xfa 34AE 1B SHL 34AF 91 SWAP2 34B0 01 ADD 34B1 90 SWAP1 34B2 81 DUP2 34B3 52 MSTORE 34B4 60 PUSH1 0x01 34B6 01 ADD 34B7 94 SWAP5 34B8 93 SWAP4 34B9 50 POP 34BA 50 POP 34BB 50 POP 34BC 50 POP 34BD 56 *JUMP label_34BE: // Incoming call from 0x2616, returns to 0x2617 // Inputs[3] // { // @34E0 stack[-1] // @34E4 stack[-3] // @34E5 memory[stack[-3]:stack[-3] + 0x20] // } 34BE 5B JUMPDEST 34BF 7F PUSH32 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 34E0 81 DUP2 34E1 52 MSTORE 34E2 60 PUSH1 0x00 34E4 83 DUP4 34E5 51 MLOAD 34E6 61 PUSH2 0x34f6 34E9 81 DUP2 34EA 60 PUSH1 0x17 34EC 85 DUP6 34ED 01 ADD 34EE 60 PUSH1 0x20 34F0 88 DUP9 34F1 01 ADD 34F2 61 PUSH2 0x3731 34F5 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @34E1 memory[stack[-1]:stack[-1] + 0x20] = 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 // @34E2 stack[0] = 0x00 // @34E5 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @34E6 stack[2] = 0x34f6 // @34E9 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @34ED stack[4] = stack[-1] + 0x17 // @34F1 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x3731, returns to 0x34F6 label_34F6: // Incoming return from call to 0x3731 at 0x34F5 // Inputs[4] // { // @350E stack[-1] // @350F stack[-3] // @3515 stack[-4] // @3516 memory[stack[-4]:stack[-4] + 0x20] // } 34F6 5B JUMPDEST 34F7 70 PUSH17 0x01034b99036b4b9b9b4b733903937b6329 3509 60 PUSH1 0x7d 350B 1B SHL 350C 60 PUSH1 0x17 350E 91 SWAP2 350F 84 DUP5 3510 01 ADD 3511 91 SWAP2 3512 82 DUP3 3513 01 ADD 3514 52 MSTORE 3515 83 DUP4 3516 51 MLOAD 3517 61 PUSH2 0x3527 351A 81 DUP2 351B 60 PUSH1 0x28 351D 84 DUP5 351E 01 ADD 351F 60 PUSH1 0x20 3521 88 DUP9 3522 01 ADD 3523 61 PUSH2 0x3731 3526 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @3511 stack[-1] = stack[-3] + stack[-1] // @3514 memory[stack[-3] + stack[-1] + 0x17:stack[-3] + stack[-1] + 0x17 + 0x20] = 0x01034b99036b4b9b9b4b733903937b6329 << 0x7d // @3516 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @3517 stack[1] = 0x3527 // @351A stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @351E stack[3] = stack[-3] + stack[-1] + 0x28 // @3522 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x3731, returns to 0x3527 label_3527: // Incoming return from call to 0x3731 at 0x3526 // Inputs[4] // { // @3528 stack[-2] // @3528 stack[-1] // @352C stack[-7] // @352D stack[-6] // } 3527 5B JUMPDEST 3528 01 ADD 3529 60 PUSH1 0x28 352B 01 ADD 352C 94 SWAP5 352D 93 SWAP4 352E 50 POP 352F 50 POP 3530 50 POP 3531 50 POP 3532 56 *JUMP // Stack delta = -6 // Outputs[1] { @352C stack[-7] = 0x28 + stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 3533 5B JUMPDEST 3534 60 PUSH1 0x01 3536 60 PUSH1 0x01 3538 60 PUSH1 0xa0 353A 1B SHL 353B 03 SUB 353C 85 DUP6 353D 81 DUP2 353E 16 AND 353F 82 DUP3 3540 52 MSTORE 3541 84 DUP5 3542 16 AND 3543 60 PUSH1 0x20 3545 82 DUP3 3546 01 ADD 3547 52 MSTORE 3548 60 PUSH1 0x40 354A 81 DUP2 354B 01 ADD 354C 83 DUP4 354D 90 SWAP1 354E 52 MSTORE 354F 60 PUSH1 0x80 3551 60 PUSH1 0x60 3553 82 DUP3 3554 01 ADD 3555 81 DUP2 3556 90 SWAP1 3557 52 MSTORE 3558 60 PUSH1 0x00 355A 90 SWAP1 355B 61 PUSH2 0x3566 355E 90 SWAP1 355F 83 DUP4 3560 01 ADD 3561 84 DUP5 3562 61 PUSH2 0x3428 3565 56 *JUMP 3566 5B JUMPDEST 3567 96 SWAP7 3568 95 SWAP6 3569 50 POP 356A 50 POP 356B 50 POP 356C 50 POP 356D 50 POP 356E 50 POP 356F 56 *JUMP label_3570: // Incoming call from 0x0317, returns to 0x02FA // Incoming call from 0x263C, returns to 0x0809 // Incoming call from 0x23EB, returns to 0x23EC // Inputs[2] // { // @3573 stack[-1] // @357E stack[-2] // } 3570 5B JUMPDEST 3571 60 PUSH1 0x20 3573 81 DUP2 3574 52 MSTORE 3575 60 PUSH1 0x00 3577 61 PUSH2 0x1ce9 357A 60 PUSH1 0x20 357C 83 DUP4 357D 01 ADD 357E 84 DUP5 357F 61 PUSH2 0x3428 3582 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @3574 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3575 stack[0] = 0x00 // @3577 stack[1] = 0x1ce9 // @357D stack[2] = stack[-1] + 0x20 // @357E stack[3] = stack[-2] // } // Block ends with call to 0x3428, returns to 0x1CE9 label_3583: // Incoming call from 0x05F7, returns to 0x02FA // Inputs[2] // { // @3586 stack[-1] // @3591 stack[-3] // } 3583 5B JUMPDEST 3584 60 PUSH1 0x40 3586 81 DUP2 3587 52 MSTORE 3588 60 PUSH1 0x00 358A 61 PUSH2 0x3596 358D 60 PUSH1 0x40 358F 83 DUP4 3590 01 ADD 3591 85 DUP6 3592 61 PUSH2 0x3428 3595 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @3587 memory[stack[-1]:stack[-1] + 0x20] = 0x40 // @3588 stack[0] = 0x00 // @358A stack[1] = 0x3596 // @3590 stack[2] = stack[-1] + 0x40 // @3591 stack[3] = stack[-3] // } // Block ends with call to 0x3428, returns to 0x3596 label_3596: // Incoming return from call to 0x3428 at 0x3595 // Inputs[6] // { // @3597 stack[-1] // @3597 stack[-2] // @3599 stack[-4] // @359E stack[-3] // @35A1 stack[-6] // @35A2 stack[-5] // } 3596 5B JUMPDEST 3597 90 SWAP1 3598 50 POP 3599 82 DUP3 359A 15 ISZERO 359B 15 ISZERO 359C 60 PUSH1 0x20 359E 83 DUP4 359F 01 ADD 35A0 52 MSTORE 35A1 93 SWAP4 35A2 92 SWAP3 35A3 50 POP 35A4 50 POP 35A5 50 POP 35A6 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @35A0 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = !!stack[-4] // @35A1 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] 35A7 5B JUMPDEST 35A8 60 PUSH1 0x40 35AA 81 DUP2 35AB 52 MSTORE 35AC 60 PUSH1 0x00 35AE 61 PUSH2 0x35ba 35B1 60 PUSH1 0x40 35B3 83 DUP4 35B4 01 ADD 35B5 85 DUP6 35B6 61 PUSH2 0x3428 35B9 56 *JUMP 35BA 5B JUMPDEST 35BB 82 DUP3 35BC 81 DUP2 35BD 03 SUB 35BE 60 PUSH1 0x20 35C0 84 DUP5 35C1 01 ADD 35C2 52 MSTORE 35C3 61 PUSH2 0x35cc 35C6 81 DUP2 35C7 85 DUP6 35C8 61 PUSH2 0x3428 35CB 56 *JUMP 35CC 5B JUMPDEST 35CD 95 SWAP6 35CE 94 SWAP5 35CF 50 POP 35D0 50 POP 35D1 50 POP 35D2 50 POP 35D3 50 POP 35D4 56 *JUMP 35D5 5B JUMPDEST 35D6 60 PUSH1 0x40 35D8 81 DUP2 35D9 52 MSTORE 35DA 60 PUSH1 0x00 35DC 61 PUSH2 0x35e8 35DF 60 PUSH1 0x40 35E1 83 DUP4 35E2 01 ADD 35E3 85 DUP6 35E4 61 PUSH2 0x3428 35E7 56 *JUMP 35E8 5B JUMPDEST 35E9 90 SWAP1 35EA 50 POP 35EB 82 DUP3 35EC 60 PUSH1 0x20 35EE 83 DUP4 35EF 01 ADD 35F0 52 MSTORE 35F1 93 SWAP4 35F2 92 SWAP3 35F3 50 POP 35F4 50 POP 35F5 50 POP 35F6 56 *JUMP 35F7 5B JUMPDEST 35F8 60 PUSH1 0x20 35FA 80 DUP1 35FB 82 DUP3 35FC 52 MSTORE 35FD 60 PUSH1 0x32 35FF 90 SWAP1 3600 82 DUP3 3601 01 ADD 3602 52 MSTORE 3603 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 3624 60 PUSH1 0x40 3626 82 DUP3 3627 01 ADD 3628 52 MSTORE 3629 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 363C 60 PUSH1 0x71 363E 1B SHL 363F 60 PUSH1 0x60 3641 82 DUP3 3642 01 ADD 3643 52 MSTORE 3644 60 PUSH1 0x80 3646 01 ADD 3647 90 SWAP1 3648 56 *JUMP label_3649: // Incoming call from 0x14FE, returns to 0x0809 // Incoming call from 0x166E, returns to 0x0809 // Incoming call from 0x17AF, returns to 0x0809 // Incoming call from 0x0AC6, returns to 0x0809 // Incoming call from 0x19D9, returns to 0x0809 // Incoming call from 0x17E9, returns to 0x0809 // Incoming call from 0x13FF, returns to 0x0809 // Incoming call from 0x1DB3, returns to 0x0809 // Incoming call from 0x1821, returns to 0x0809 // Incoming call from 0x1EA2, returns to 0x0809 // Incoming call from 0x1E04, returns to 0x0809 // Inputs[2] // { // @364D stack[-1] // @367C stack[-2] // } 3649 5B JUMPDEST 364A 60 PUSH1 0x20 364C 80 DUP1 364D 82 DUP3 364E 52 MSTORE 364F 81 DUP2 3650 81 DUP2 3651 01 ADD 3652 52 MSTORE 3653 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 3674 60 PUSH1 0x40 3676 82 DUP3 3677 01 ADD 3678 52 MSTORE 3679 60 PUSH1 0x60 367B 01 ADD 367C 90 SWAP1 367D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @364E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3652 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @3678 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @367C stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_367E: // Incoming call from 0x1ABB, returns to 0x0809 // Inputs[2] // { // @3682 stack[-1] // @36CD stack[-2] // } 367E 5B JUMPDEST 367F 60 PUSH1 0x20 3681 80 DUP1 3682 82 DUP3 3683 52 MSTORE 3684 60 PUSH1 0x31 3686 90 SWAP1 3687 82 DUP3 3688 01 ADD 3689 52 MSTORE 368A 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 36AB 60 PUSH1 0x40 36AD 82 DUP3 36AE 01 ADD 36AF 52 MSTORE 36B0 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 36C2 60 PUSH1 0x7a 36C4 1B SHL 36C5 60 PUSH1 0x60 36C7 82 DUP3 36C8 01 ADD 36C9 52 MSTORE 36CA 60 PUSH1 0x80 36CC 01 ADD 36CD 90 SWAP1 36CE 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3683 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3689 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x31 // @36AF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @36C9 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1ddb995c881b9bdc88185c1c1c9bdd9959 << 0x7a // @36CD stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_36CF: // Incoming call from 0x2547, returns to 0x2548 // Incoming call from 0x1EDA, returns to 0x1EDB // Incoming call from 0x1FBF, returns to 0x1FC0 // Inputs[2] // { // @36D2 stack[-2] // @36D4 stack[-1] // } 36CF 5B JUMPDEST 36D0 60 PUSH1 0x00 36D2 82 DUP3 36D3 19 NOT 36D4 82 DUP3 36D5 11 GT 36D6 15 ISZERO 36D7 61 PUSH2 0x36e2 36DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @36D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x36e2, if !(stack[-1] > ~stack[-2]) label_36DB: // Incoming jump from 0x36DA, if not !(stack[-1] > ~stack[-2]) 36DB 61 PUSH2 0x36e2 36DE 61 PUSH2 0x37de 36E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @36DB stack[0] = 0x36e2 } // Block ends with unconditional jump to 0x37de label_36E2: // Incoming jump from 0x36DA, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @36E4 stack[-3] // @36E4 stack[-2] // @36E5 stack[-4] // } 36E2 5B JUMPDEST 36E3 50 POP 36E4 01 ADD 36E5 90 SWAP1 36E6 56 *JUMP // Stack delta = -3 // Outputs[1] { @36E5 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_36E7: // Incoming call from 0x258C, returns to 0x258D // Incoming call from 0x24C0, returns to 0x24C1 // Inputs[1] { @36EA stack[-2] } 36E7 5B JUMPDEST 36E8 60 PUSH1 0x00 36EA 82 DUP3 36EB 61 PUSH2 0x36f6 36EE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @36E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x36f6, if stack[-2] label_36EF: // Incoming jump from 0x36EE, if not stack[-2] 36EF 61 PUSH2 0x36f6 36F2 61 PUSH2 0x37f4 36F5 56 *JUMP // Stack delta = +1 // Outputs[1] { @36EF stack[0] = 0x36f6 } // Block ends with unconditional jump to 0x37f4 label_36F6: // Incoming jump from 0x36EE, if stack[-2] // Inputs[3] // { // @36F8 stack[-2] // @36F8 stack[-3] // @36F9 stack[-4] // } 36F6 5B JUMPDEST 36F7 50 POP 36F8 04 DIV 36F9 90 SWAP1 36FA 56 *JUMP // Stack delta = -3 // Outputs[1] { @36F9 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_36FB: // Incoming call from 0x1FB4, returns to 0x1FB5 // Incoming call from 0x1ECF, returns to 0x1ED0 // Inputs[2] // { // @36FE stack[-1] // @3703 stack[-2] // } 36FB 5B JUMPDEST 36FC 60 PUSH1 0x00 36FE 81 DUP2 36FF 60 PUSH1 0x00 3701 19 NOT 3702 04 DIV 3703 83 DUP4 3704 11 GT 3705 82 DUP3 3706 15 ISZERO 3707 15 ISZERO 3708 16 AND 3709 15 ISZERO 370A 61 PUSH2 0x3715 370D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @36FC stack[0] = 0x00 } // Block ends with conditional jump to 0x3715, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_370E: // Incoming jump from 0x370D, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 370E 61 PUSH2 0x3715 3711 61 PUSH2 0x37de 3714 56 *JUMP // Stack delta = +1 // Outputs[1] { @370E stack[0] = 0x3715 } // Block ends with unconditional jump to 0x37de label_3715: // Incoming jump from 0x370D, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @3717 stack[-3] // @3717 stack[-2] // @3718 stack[-4] // } 3715 5B JUMPDEST 3716 50 POP 3717 02 MUL 3718 90 SWAP1 3719 56 *JUMP // Stack delta = -3 // Outputs[1] { @3718 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_371A: // Incoming call from 0x2E9E, returns to 0x2E9F // Incoming call from 0x252F, returns to 0x2530 // Incoming call from 0x2E06, returns to 0x2E07 // Inputs[2] // { // @371D stack[-2] // @371E stack[-1] // } 371A 5B JUMPDEST 371B 60 PUSH1 0x00 371D 82 DUP3 371E 82 DUP3 371F 10 LT 3720 15 ISZERO 3721 61 PUSH2 0x372c 3724 57 *JUMPI // Stack delta = +1 // Outputs[1] { @371B stack[0] = 0x00 } // Block ends with conditional jump to 0x372c, if !(stack[-1] < stack[-2]) label_3725: // Incoming jump from 0x3724, if not !(stack[-1] < stack[-2]) 3725 61 PUSH2 0x372c 3728 61 PUSH2 0x37de 372B 56 *JUMP // Stack delta = +1 // Outputs[1] { @3725 stack[0] = 0x372c } // Block ends with unconditional jump to 0x37de label_372C: // Incoming jump from 0x3724, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @372E stack[-3] // @372E stack[-2] // @372F stack[-4] // } 372C 5B JUMPDEST 372D 50 POP 372E 03 SUB 372F 90 SWAP1 3730 56 *JUMP // Stack delta = -3 // Outputs[1] { @372F stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_3731: // Incoming call from 0x34F5, returns to 0x34F6 // Incoming call from 0x3479, returns to 0x347A // Incoming call from 0x343F, returns to 0x3440 // Incoming call from 0x3526, returns to 0x3527 // Incoming call from 0x3465, returns to 0x3466 // Inputs[1] { @3735 stack[-3] } 3731 5B JUMPDEST 3732 60 PUSH1 0x00 3734 5B JUMPDEST 3735 83 DUP4 3736 81 DUP2 3737 10 LT 3738 15 ISZERO 3739 61 PUSH2 0x374c 373C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3732 stack[0] = 0x00 } // Block ends with conditional jump to 0x374c, if !(0x00 < stack[-3]) label_373D: // Incoming jump from 0x373C, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x373C, if not !(0x00 < stack[-3]) // Inputs[4] // { // @373D stack[-2] // @373E stack[-1] // @3740 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3741 stack[-3] // } 373D 81 DUP2 373E 81 DUP2 373F 01 ADD 3740 51 MLOAD 3741 83 DUP4 3742 82 DUP3 3743 01 ADD 3744 52 MSTORE 3745 60 PUSH1 0x20 3747 01 ADD 3748 61 PUSH2 0x3734 374B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3744 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3747 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x3734 label_374C: // Incoming jump from 0x373C, if !(stack[-1] < stack[-4]) // Incoming jump from 0x373C, if !(0x00 < stack[-3]) // Inputs[2] // { // @374D stack[-4] // @374E stack[-1] // } 374C 5B JUMPDEST 374D 83 DUP4 374E 81 DUP2 374F 11 GT 3750 15 ISZERO 3751 61 PUSH2 0x1ac8 3754 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ac8, if !(stack[-1] > stack[-4]) label_3755: // Incoming jump from 0x3754, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @3759 stack[-4] // @375A stack[-3] // @375C stack[-5] // } 3755 50 POP 3756 50 POP 3757 60 PUSH1 0x00 3759 91 SWAP2 375A 01 ADD 375B 52 MSTORE 375C 56 *JUMP // Stack delta = -5 // Outputs[1] { @375B memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_375D: // Incoming call from 0x204C, returns to 0x204D // Inputs[1] { @3760 stack[-1] } 375D 5B JUMPDEST 375E 60 PUSH1 0x00 3760 81 DUP2 3761 61 PUSH2 0x376c 3764 57 *JUMPI // Stack delta = +1 // Outputs[1] { @375E stack[0] = 0x00 } // Block ends with conditional jump to 0x376c, if stack[-1] label_3765: // Incoming jump from 0x3764, if not stack[-1] 3765 61 PUSH2 0x376c 3768 61 PUSH2 0x37de 376B 56 *JUMP // Stack delta = +1 // Outputs[1] { @3765 stack[0] = 0x376c } // Block ends with unconditional jump to 0x37de label_376C: // Incoming jump from 0x3764, if stack[-1] // Inputs[2] // { // @3771 stack[-2] // @3772 stack[-3] // } 376C 5B JUMPDEST 376D 50 POP 376E 60 PUSH1 0x00 3770 19 NOT 3771 01 ADD 3772 90 SWAP1 3773 56 *JUMP // Stack delta = -2 // Outputs[1] { @3772 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_3774: // Incoming call from 0x073C, returns to 0x073D // Incoming call from 0x1A09, returns to 0x1A0A // Incoming call from 0x2FB5, returns to 0x2FB6 // Incoming call from 0x1ADA, returns to 0x1ADB // Incoming call from 0x1C39, returns to 0x1C3A // Incoming call from 0x1A35, returns to 0x1A36 // Incoming call from 0x0710, returns to 0x0711 // Incoming call from 0x2991, returns to 0x1C0E // Incoming call from 0x1C0D, returns to 0x1C0E // Incoming call from 0x1DD4, returns to 0x0711 // Incoming call from 0x1B06, returns to 0x1B07 // Incoming call from 0x18E4, returns to 0x0711 // Incoming call from 0x2984, returns to 0x1C0E // Inputs[1] { @3777 stack[-1] } 3774 5B JUMPDEST 3775 60 PUSH1 0x01 3777 81 DUP2 3778 81 DUP2 3779 1C SHR 377A 90 SWAP1 377B 82 DUP3 377C 16 AND 377D 80 DUP1 377E 61 PUSH2 0x3788 3781 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @377A stack[0] = stack[-1] >> 0x01 // @377C stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x3788, if stack[-1] & 0x01 label_3782: // Incoming jump from 0x3781, if not stack[-1] & 0x01 // Inputs[2] // { // @3784 stack[-2] // @378D stack[-1] // } 3782 60 PUSH1 0x7f 3784 82 DUP3 3785 16 AND 3786 91 SWAP2 3787 50 POP 3788 5B JUMPDEST 3789 60 PUSH1 0x20 378B 82 DUP3 378C 10 LT 378D 81 DUP2 378E 14 EQ 378F 15 ISZERO 3790 61 PUSH2 0x37a9 3793 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3786 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x37a9, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_3794: // Incoming jump from 0x3793, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x3793, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @37A8 memory[0x00:0x24] } 3794 63 PUSH4 0x4e487b71 3799 60 PUSH1 0xe0 379B 1B SHL 379C 60 PUSH1 0x00 379E 52 MSTORE 379F 60 PUSH1 0x22 37A1 60 PUSH1 0x04 37A3 52 MSTORE 37A4 60 PUSH1 0x24 37A6 60 PUSH1 0x00 37A8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @379E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @37A3 memory[0x04:0x24] = 0x22 // @37A8 revert(memory[0x00:0x24]); // } // Block terminates label_37A9: // Incoming jump from 0x3793, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x3793, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @37AB stack[-4] // @37AB stack[-2] // @37AC stack[-3] // } 37A9 5B JUMPDEST 37AA 50 POP 37AB 91 SWAP2 37AC 90 SWAP1 37AD 50 POP 37AE 56 *JUMP // Stack delta = -3 // Outputs[1] { @37AB stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_37AF: // Incoming call from 0x24B1, returns to 0x24B2 // Inputs[1] { @37B5 stack[-1] } 37AF 5B JUMPDEST 37B0 60 PUSH1 0x00 37B2 60 PUSH1 0x00 37B4 19 NOT 37B5 82 DUP3 37B6 14 EQ 37B7 15 ISZERO 37B8 61 PUSH2 0x37c3 37BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @37B0 stack[0] = 0x00 } // Block ends with conditional jump to 0x37c3, if !(stack[-1] == ~0x00) label_37BC: // Incoming jump from 0x37BB, if not !(stack[-1] == ~0x00) 37BC 61 PUSH2 0x37c3 37BF 61 PUSH2 0x37de 37C2 56 *JUMP // Stack delta = +1 // Outputs[1] { @37BC stack[0] = 0x37c3 } // Block ends with unconditional jump to 0x37de label_37C3: // Incoming jump from 0x37BB, if !(stack[-1] == ~0x00) // Inputs[2] // { // @37C7 stack[-2] // @37C8 stack[-3] // } 37C3 5B JUMPDEST 37C4 50 POP 37C5 60 PUSH1 0x01 37C7 01 ADD 37C8 90 SWAP1 37C9 56 *JUMP // Stack delta = -2 // Outputs[1] { @37C8 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_37CA: // Incoming call from 0x253C, returns to 0x253D // Inputs[1] { @37CD stack[-2] } 37CA 5B JUMPDEST 37CB 60 PUSH1 0x00 37CD 82 DUP3 37CE 61 PUSH2 0x37d9 37D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @37CB stack[0] = 0x00 } // Block ends with conditional jump to 0x37d9, if stack[-2] label_37D2: // Incoming jump from 0x37D1, if not stack[-2] 37D2 61 PUSH2 0x37d9 37D5 61 PUSH2 0x37f4 37D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @37D2 stack[0] = 0x37d9 } // Block ends with unconditional jump to 0x37f4 label_37D9: // Incoming jump from 0x37D1, if stack[-2] // Inputs[3] // { // @37DB stack[-3] // @37DB stack[-2] // @37DC stack[-4] // } 37D9 5B JUMPDEST 37DA 50 POP 37DB 06 MOD 37DC 90 SWAP1 37DD 56 *JUMP // Stack delta = -3 // Outputs[1] { @37DC stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_37DE: // Incoming jump from 0x37C2 // Incoming jump from 0x3714 // Incoming jump from 0x36E1 // Incoming jump from 0x376B // Incoming jump from 0x372B // Inputs[1] { @37F3 memory[0x00:0x24] } 37DE 5B JUMPDEST 37DF 63 PUSH4 0x4e487b71 37E4 60 PUSH1 0xe0 37E6 1B SHL 37E7 60 PUSH1 0x00 37E9 52 MSTORE 37EA 60 PUSH1 0x11 37EC 60 PUSH1 0x04 37EE 52 MSTORE 37EF 60 PUSH1 0x24 37F1 60 PUSH1 0x00 37F3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @37E9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @37EE memory[0x04:0x24] = 0x11 // @37F3 revert(memory[0x00:0x24]); // } // Block terminates label_37F4: // Incoming jump from 0x36F5 // Incoming jump from 0x37D8 // Inputs[1] { @3809 memory[0x00:0x24] } 37F4 5B JUMPDEST 37F5 63 PUSH4 0x4e487b71 37FA 60 PUSH1 0xe0 37FC 1B SHL 37FD 60 PUSH1 0x00 37FF 52 MSTORE 3800 60 PUSH1 0x12 3802 60 PUSH1 0x04 3804 52 MSTORE 3805 60 PUSH1 0x24 3807 60 PUSH1 0x00 3809 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @37FF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3804 memory[0x04:0x24] = 0x12 // @3809 revert(memory[0x00:0x24]); // } // Block terminates label_380A: // Incoming jump from 0x305D // Incoming jump from 0x3085 // Inputs[1] { @381F memory[0x00:0x24] } 380A 5B JUMPDEST 380B 63 PUSH4 0x4e487b71 3810 60 PUSH1 0xe0 3812 1B SHL 3813 60 PUSH1 0x00 3815 52 MSTORE 3816 60 PUSH1 0x41 3818 60 PUSH1 0x04 381A 52 MSTORE 381B 60 PUSH1 0x24 381D 60 PUSH1 0x00 381F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3815 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @381A memory[0x04:0x24] = 0x41 // @381F revert(memory[0x00:0x24]); // } // Block terminates label_3820: // Incoming call from 0x335A, returns to 0x1CE9 // Inputs[1] { @382A stack[-1] } 3820 5B JUMPDEST 3821 60 PUSH1 0x01 3823 60 PUSH1 0x01 3825 60 PUSH1 0xe0 3827 1B SHL 3828 03 SUB 3829 19 NOT 382A 81 DUP2 382B 16 AND 382C 81 DUP2 382D 14 EQ 382E 61 PUSH2 0x159b 3831 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x159b, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_3832: // Incoming jump from 0x3831, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @3835 memory[0x00:0x00] } 3832 60 PUSH1 0x00 3834 80 DUP1 3835 FD *REVERT // Stack delta = +0 // Outputs[1] { @3835 revert(memory[0x00:0x00]); } // Block terminates 3836 FE *ASSERT 3837 97 SWAP8 3838 2D 2D 3839 20 SHA3 383A E7 E7 383B 11 GT 383C 34 CALLVALUE 383D C6 C6 383E 30 ADDRESS 383F 3C EXTCODECOPY 3840 02 MUL 3841 35 CALLDATALOAD 3842 34 CALLVALUE 3843 76 PUSH23 0x83d57743077e54181dd68b7758f8734e3e629d50a8be3f 385B 62 PUSH3 0x47733c 385F 59 MSIZE 3860 3C EXTCODECOPY 3861 BA BA 3862 B2 SWAP 3863 1A BYTE 3864 93 SWAP4 3865 01 ADD 3866 5B JUMPDEST 3867 82 DUP3 3868 8C DUP13 3869 2F 2F 386A 88 DUP9 386B AD AD 386C CD CD 386D 12 SLT 386E 9B SWAP12 386F 29 29 3870 7A PUSH27 0x2a036e0296e5a2646970667358221220030d588a8ee141ecb51928 388C E9 E9 388D 28 28 388E 6A PUSH11 0x1d1ae120b137a1445f8be0 389A B9 B9 389B 92 SWAP3 389C 2F 2F 389D 3C EXTCODECOPY 389E 26 26 389F C1 C1 38A0 D2 D2 38A1 64 PUSH5 0x736f6c6343 38A7 00 *STOP 38A8 08 ADDMOD 38A9 04 DIV 38AA 00 *STOP 38AB 33 CALLER