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 0x0227 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0227, 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 0x767bbd5b 0026 11 GT 0027 61 PUSH2 0x0130 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0130, if 0x767bbd5b > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x767bbd5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb0467deb 0031 11 GT 0032 61 PUSH2 0x00b8 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b8, if 0xb0467deb > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb0467deb > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe4b50cb8 003C 11 GT 003D 61 PUSH2 0x007c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xe4b50cb8 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe4b50cb8 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe4b50cb8 0047 14 EQ 0048 61 PUSH2 0x051a 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051a, if 0xe4b50cb8 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe4b50cb8 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x053d 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053d, if 0xe985e9c5 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf0063795 005D 14 EQ 005E 61 PUSH2 0x057a 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x057a, if 0xf0063795 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf0063795 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf3cb8385 0068 14 EQ 0069 61 PUSH2 0x059f 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x059f, if 0xf3cb8385 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf3cb8385 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf5fe58b8 0073 14 EQ 0074 61 PUSH2 0x05b2 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b2, if 0xf5fe58b8 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf5fe58b8 == 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 0x0040, if 0xe4b50cb8 > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xb0467deb 0083 14 EQ 0084 61 PUSH2 0x04bb 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bb, if 0xb0467deb == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xb0467deb == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb3a7eb59 008E 14 EQ 008F 61 PUSH2 0x04ce 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ce, if 0xb3a7eb59 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb3a7eb59 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xb88d4fde 0099 14 EQ 009A 61 PUSH2 0x04e1 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e1, if 0xb88d4fde == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xb88d4fde == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x04f4 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f4, if 0xc87b56dd == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0xdfe6e512 00AF 14 EQ 00B0 61 PUSH2 0x0507 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0507, if 0xdfe6e512 == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xdfe6e512 == stack[-1] // Inputs[1] { @00B7 memory[0x00:0x00] } 00B4 60 PUSH1 0x00 00B6 80 DUP1 00B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B7 revert(memory[0x00:0x00]); } // Block terminates label_00B8: // Incoming jump from 0x0035, if 0xb0467deb > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B8 5B JUMPDEST 00B9 80 DUP1 00BA 63 PUSH4 0xa22cb465 00BF 11 GT 00C0 61 PUSH2 0x00ff 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ff, if 0xa22cb465 > stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xa22cb465 > stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa22cb465 00CA 14 EQ 00CB 61 PUSH2 0x044f 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044f, if 0xa22cb465 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0xa3739f71 00D5 14 EQ 00D6 61 PUSH2 0x0462 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0462, if 0xa3739f71 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xa3739f71 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0xa46a932f 00E0 14 EQ 00E1 61 PUSH2 0x0475 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0475, if 0xa46a932f == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0xa46a932f == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0xa9e566c0 00EB 14 EQ 00EC 61 PUSH2 0x0488 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0488, if 0xa9e566c0 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0xa9e566c0 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0xab2a1941 00F6 14 EQ 00F7 61 PUSH2 0x04a8 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a8, if 0xab2a1941 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0xab2a1941 == stack[-1] // Inputs[1] { @00FE memory[0x00:0x00] } 00FB 60 PUSH1 0x00 00FD 80 DUP1 00FE FD *REVERT // Stack delta = +0 // Outputs[1] { @00FE revert(memory[0x00:0x00]); } // Block terminates label_00FF: // Incoming jump from 0x00C3, if 0xa22cb465 > stack[-1] // Inputs[1] { @0100 stack[-1] } 00FF 5B JUMPDEST 0100 80 DUP1 0101 63 PUSH4 0x767bbd5b 0106 14 EQ 0107 61 PUSH2 0x0410 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0410, if 0x767bbd5b == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x767bbd5b == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x773c02d4 0111 14 EQ 0112 61 PUSH2 0x0423 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0423, if 0x773c02d4 == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x773c02d4 == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x8da5cb5b 011C 14 EQ 011D 61 PUSH2 0x0436 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0436, if 0x8da5cb5b == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x95d89b41 0127 14 EQ 0128 61 PUSH2 0x0447 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0447, if 0x95d89b41 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x95d89b41 == stack[-1] // Inputs[1] { @012F memory[0x00:0x00] } 012C 60 PUSH1 0x00 012E 80 DUP1 012F FD *REVERT // Stack delta = +0 // Outputs[1] { @012F revert(memory[0x00:0x00]); } // Block terminates label_0130: // Incoming jump from 0x002A, if 0x767bbd5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0131 stack[-1] } 0130 5B JUMPDEST 0131 80 DUP1 0132 63 PUSH4 0x32ba0a1e 0137 11 GT 0138 61 PUSH2 0x01b3 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b3, if 0x32ba0a1e > stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x32ba0a1e > stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x6352211e 0142 11 GT 0143 61 PUSH2 0x0182 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0182, if 0x6352211e > stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x6352211e > stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x6352211e 014D 14 EQ 014E 61 PUSH2 0x038c 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038c, if 0x6352211e == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x6352211e == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x6bd5ff2f 0158 14 EQ 0159 61 PUSH2 0x039f 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039f, if 0x6bd5ff2f == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x6bd5ff2f == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x6eb3500d 0163 14 EQ 0164 61 PUSH2 0x03c5 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c5, if 0x6eb3500d == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x6eb3500d == stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x6ff92f50 016E 14 EQ 016F 61 PUSH2 0x03d6 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d6, if 0x6ff92f50 == stack[-1] label_0173: // Incoming jump from 0x0172, if not 0x6ff92f50 == stack[-1] // Inputs[1] { @0173 stack[-1] } 0173 80 DUP1 0174 63 PUSH4 0x70a08231 0179 14 EQ 017A 61 PUSH2 0x03e7 017D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e7, if 0x70a08231 == stack[-1] label_017E: // Incoming jump from 0x017D, if not 0x70a08231 == 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 0x0146, if 0x6352211e > stack[-1] // Inputs[1] { @0183 stack[-1] } 0182 5B JUMPDEST 0183 80 DUP1 0184 63 PUSH4 0x32ba0a1e 0189 14 EQ 018A 61 PUSH2 0x031b 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031b, if 0x32ba0a1e == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x32ba0a1e == stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0x42842e0e 0194 14 EQ 0195 61 PUSH2 0x033e 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033e, if 0x42842e0e == stack[-1] label_0199: // Incoming jump from 0x0198, if not 0x42842e0e == stack[-1] // Inputs[1] { @0199 stack[-1] } 0199 80 DUP1 019A 63 PUSH4 0x4f6ccce7 019F 14 EQ 01A0 61 PUSH2 0x0351 01A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0351, 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 0x57f6b812 01AA 14 EQ 01AB 61 PUSH2 0x0364 01AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0364, if 0x57f6b812 == stack[-1] label_01AF: // Incoming jump from 0x01AE, if not 0x57f6b812 == stack[-1] // Inputs[1] { @01B2 memory[0x00:0x00] } 01AF 60 PUSH1 0x00 01B1 80 DUP1 01B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B2 revert(memory[0x00:0x00]); } // Block terminates label_01B3: // Incoming jump from 0x013B, if 0x32ba0a1e > stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B3 5B JUMPDEST 01B4 80 DUP1 01B5 63 PUSH4 0x113f2d9e 01BA 11 GT 01BB 61 PUSH2 0x01fa 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fa, if 0x113f2d9e > stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x113f2d9e > stack[-1] // Inputs[1] { @01BF stack[-1] } 01BF 80 DUP1 01C0 63 PUSH4 0x113f2d9e 01C5 14 EQ 01C6 61 PUSH2 0x02b9 01C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b9, if 0x113f2d9e == stack[-1] label_01CA: // Incoming jump from 0x01C9, if not 0x113f2d9e == stack[-1] // Inputs[1] { @01CA stack[-1] } 01CA 80 DUP1 01CB 63 PUSH4 0x13af4035 01D0 14 EQ 01D1 61 PUSH2 0x02da 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02da, if 0x13af4035 == stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x13af4035 == stack[-1] // Inputs[1] { @01D5 stack[-1] } 01D5 80 DUP1 01D6 63 PUSH4 0x18160ddd 01DB 14 EQ 01DC 61 PUSH2 0x02ed 01DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ed, if 0x18160ddd == stack[-1] label_01E0: // Incoming jump from 0x01DF, if not 0x18160ddd == stack[-1] // Inputs[1] { @01E0 stack[-1] } 01E0 80 DUP1 01E1 63 PUSH4 0x23b872dd 01E6 14 EQ 01E7 61 PUSH2 0x02f5 01EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f5, if 0x23b872dd == stack[-1] label_01EB: // Incoming jump from 0x01EA, if not 0x23b872dd == stack[-1] // Inputs[1] { @01EB stack[-1] } 01EB 80 DUP1 01EC 63 PUSH4 0x2f745c59 01F1 14 EQ 01F2 61 PUSH2 0x0308 01F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0308, if 0x2f745c59 == stack[-1] label_01F6: // Incoming jump from 0x01F5, if not 0x2f745c59 == 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 0x01BE, if 0x113f2d9e > stack[-1] // Inputs[1] { @01FB stack[-1] } 01FA 5B JUMPDEST 01FB 80 DUP1 01FC 63 PUSH4 0x01ffc9a7 0201 14 EQ 0202 61 PUSH2 0x022c 0205 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022c, if 0x01ffc9a7 == stack[-1] label_0206: // Incoming jump from 0x0205, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0206 stack[-1] } 0206 80 DUP1 0207 63 PUSH4 0x06fdde03 020C 14 EQ 020D 61 PUSH2 0x0264 0210 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0264, if 0x06fdde03 == stack[-1] label_0211: // Incoming jump from 0x0210, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0211 stack[-1] } 0211 80 DUP1 0212 63 PUSH4 0x081812fc 0217 14 EQ 0218 61 PUSH2 0x0279 021B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0279, if 0x081812fc == stack[-1] label_021C: // Incoming jump from 0x021B, if not 0x081812fc == stack[-1] // Inputs[1] { @021C stack[-1] } 021C 80 DUP1 021D 63 PUSH4 0x095ea7b3 0222 14 EQ 0223 61 PUSH2 0x02a4 0226 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a4, if 0x095ea7b3 == stack[-1] label_0227: // Incoming jump from 0x0226, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @022B memory[0x00:0x00] } 0227 5B JUMPDEST 0228 60 PUSH1 0x00 022A 80 DUP1 022B FD *REVERT // Stack delta = +0 // Outputs[1] { @022B revert(memory[0x00:0x00]); } // Block terminates label_022C: // Incoming jump from 0x0205, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0233 msg.data.length } 022C 5B JUMPDEST 022D 61 PUSH2 0x024f 0230 61 PUSH2 0x023a 0233 36 CALLDATASIZE 0234 60 PUSH1 0x04 0236 61 PUSH2 0x17ca 0239 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @022D stack[0] = 0x024f // @0230 stack[1] = 0x023a // @0233 stack[2] = msg.data.length // @0234 stack[3] = 0x04 // } // Block ends with call to 0x17ca, returns to 0x023A label_023A: // Incoming return from call to 0x17CA at 0x0239 // Inputs[4] // { // @0242 stack[-1] // @0248 memory[0x00:0x40] // @0249 storage[keccak256(memory[0x00:0x40])] // @024D stack[-2] // } 023A 5B JUMPDEST 023B 60 PUSH1 0x06 023D 60 PUSH1 0x20 023F 52 MSTORE 0240 60 PUSH1 0x00 0242 90 SWAP1 0243 81 DUP2 0244 52 MSTORE 0245 60 PUSH1 0x40 0247 90 SWAP1 0248 20 SHA3 0249 54 SLOAD 024A 60 PUSH1 0xff 024C 16 AND 024D 81 DUP2 024E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @023F memory[0x20:0x40] = 0x06 // @0244 memory[0x00:0x20] = stack[-1] // @024C stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_024F: // Incoming return from call to 0x054B at 0x054A // Incoming return from call to 0x023A at 0x0239 // Inputs[2] // { // @0252 memory[0x40:0x60] // @0253 stack[-1] // } 024F 5B JUMPDEST 0250 60 PUSH1 0x40 0252 51 MLOAD 0253 90 SWAP1 0254 15 ISZERO 0255 15 ISZERO 0256 81 DUP2 0257 52 MSTORE 0258 60 PUSH1 0x20 025A 01 ADD // Stack delta = +0 // Outputs[2] // { // @0257 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @025A stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_025B: // Incoming jump from 0x02A3 // Incoming jump from 0x038B // Incoming return from call to 0x1A9A at 0x033D // Incoming jump from 0x02D9 // Incoming return from call to 0x1B6C at 0x03C4 // Incoming return from call to 0x1E12 at 0x059E // Incoming jump from 0x025A // Inputs[3] // { // @025E memory[0x40:0x60] // @0260 stack[-1] // @0263 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 025B 5B JUMPDEST 025C 60 PUSH1 0x40 025E 51 MLOAD 025F 80 DUP1 0260 91 SWAP2 0261 03 SUB 0262 90 SWAP1 0263 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0263 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0264: // Incoming jump from 0x0210, if 0x06fdde03 == stack[-1] 0264 5B JUMPDEST 0265 61 PUSH2 0x026c 0268 61 PUSH2 0x05c5 026B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0265 stack[0] = 0x026c } // Block ends with call to 0x05c5, returns to 0x026C label_026C: // Incoming return from call to 0x0502 at 0x0501 // Incoming return from call to 0x0C38 at 0x044E // Incoming return from call to 0x05C5 at 0x026B // Inputs[2] // { // @026F memory[0x40:0x60] // @0273 stack[-1] // } 026C 5B JUMPDEST 026D 60 PUSH1 0x40 026F 51 MLOAD 0270 61 PUSH2 0x025b 0273 91 SWAP2 0274 90 SWAP1 0275 61 PUSH2 0x1843 0278 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0273 stack[-1] = 0x025b // @0274 stack[1] = memory[0x40:0x60] // @0274 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1843 label_0279: // Incoming jump from 0x021B, if 0x081812fc == stack[-1] // Inputs[1] { @0280 msg.data.length } 0279 5B JUMPDEST 027A 61 PUSH2 0x028c 027D 61 PUSH2 0x0287 0280 36 CALLDATASIZE 0281 60 PUSH1 0x04 0283 61 PUSH2 0x1856 0286 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027A stack[0] = 0x028c // @027D stack[1] = 0x0287 // @0280 stack[2] = msg.data.length // @0281 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x0287 label_0287: // Incoming return from call to 0x1856 at 0x0286 0287 5B JUMPDEST 0288 61 PUSH2 0x063c 028B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x063c label_028C: // Incoming return from call to 0x0287 at 0x0286 // Incoming return from call to 0x04C9 at 0x04C8 // Incoming jump from 0x03D5 // Incoming return from call to 0x039A at 0x0399 // Incoming jump from 0x0446 // Incoming jump from 0x03E6 // Inputs[2] // { // @028F memory[0x40:0x60] // @0299 stack[-1] // } 028C 5B JUMPDEST 028D 60 PUSH1 0x40 028F 51 MLOAD 0290 60 PUSH1 0x01 0292 60 PUSH1 0x01 0294 60 PUSH1 0xa0 0296 1B SHL 0297 03 SUB 0298 90 SWAP1 0299 91 SWAP2 029A 16 AND 029B 81 DUP2 029C 52 MSTORE 029D 60 PUSH1 0x20 029F 01 ADD 02A0 61 PUSH2 0x025b 02A3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @029C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @029F stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x025b label_02A4: // Incoming jump from 0x0226, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02AB msg.data.length } 02A4 5B JUMPDEST 02A5 61 PUSH2 0x02b7 02A8 61 PUSH2 0x02b2 02AB 36 CALLDATASIZE 02AC 60 PUSH1 0x04 02AE 61 PUSH2 0x1884 02B1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A5 stack[0] = 0x02b7 // @02A8 stack[1] = 0x02b2 // @02AB stack[2] = msg.data.length // @02AC stack[3] = 0x04 // } // Block ends with call to 0x1884, returns to 0x02B2 label_02B2: // Incoming return from call to 0x1884 at 0x02B1 02B2 5B JUMPDEST 02B3 61 PUSH2 0x066a 02B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x066a label_02B7: // Incoming return from call to 0x045D at 0x045C // Incoming return from call to 0x05AD at 0x05AC // Incoming return from call to 0x02E8 at 0x02E7 // Incoming return from call to 0x0303 at 0x0302 // Incoming return from call to 0x0483 at 0x0482 // Incoming return from call to 0x02B2 at 0x02B1 // Incoming return from call to 0x04EF at 0x04EE 02B7 5B JUMPDEST 02B8 00 *STOP // Stack delta = +0 // Outputs[1] { @02B8 stop(); } // Block terminates label_02B9: // Incoming jump from 0x01C9, if 0x113f2d9e == stack[-1] // Inputs[1] { @02C0 msg.data.length } 02B9 5B JUMPDEST 02BA 61 PUSH2 0x02cc 02BD 61 PUSH2 0x02c7 02C0 36 CALLDATASIZE 02C1 60 PUSH1 0x04 02C3 61 PUSH2 0x1856 02C6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BA stack[0] = 0x02cc // @02BD stack[1] = 0x02c7 // @02C0 stack[2] = msg.data.length // @02C1 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x02C7 label_02C7: // Incoming return from call to 0x1856 at 0x02C6 02C7 5B JUMPDEST 02C8 61 PUSH2 0x06ec 02CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ec label_02CC: // Incoming return from call to 0x05C0 at 0x05BF // Incoming return from call to 0x03F5 at 0x03F4 // Incoming return from call to 0x0316 at 0x0315 // Incoming jump from 0x02F4 // Incoming return from call to 0x0515 at 0x0514 // Incoming return from call to 0x041E at 0x041D // Incoming return from call to 0x02C7 at 0x02C6 // Incoming return from call to 0x04DC at 0x04DB // Incoming return from call to 0x0470 at 0x046F // Incoming return from call to 0x04B6 at 0x04B5 // Incoming return from call to 0x035F at 0x035E // Inputs[2] // { // @02CF memory[0x40:0x60] // @02D0 stack[-1] // } 02CC 5B JUMPDEST 02CD 60 PUSH1 0x40 02CF 51 MLOAD 02D0 90 SWAP1 02D1 81 DUP2 02D2 52 MSTORE 02D3 60 PUSH1 0x20 02D5 01 ADD 02D6 61 PUSH2 0x025b 02D9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02D5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x025b label_02DA: // Incoming jump from 0x01D4, if 0x13af4035 == stack[-1] // Inputs[1] { @02E1 msg.data.length } 02DA 5B JUMPDEST 02DB 61 PUSH2 0x02b7 02DE 61 PUSH2 0x02e8 02E1 36 CALLDATASIZE 02E2 60 PUSH1 0x04 02E4 61 PUSH2 0x18b0 02E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DB stack[0] = 0x02b7 // @02DE stack[1] = 0x02e8 // @02E1 stack[2] = msg.data.length // @02E2 stack[3] = 0x04 // } // Block ends with call to 0x18b0, returns to 0x02E8 label_02E8: // Incoming return from call to 0x18B0 at 0x02E7 02E8 5B JUMPDEST 02E9 61 PUSH2 0x0721 02EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0721 label_02ED: // Incoming jump from 0x01DF, if 0x18160ddd == stack[-1] // Inputs[1] { @02F0 storage[0x00] } 02ED 5B JUMPDEST 02EE 60 PUSH1 0x00 02F0 54 SLOAD 02F1 61 PUSH2 0x02cc 02F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F0 stack[0] = storage[0x00] } // Block ends with unconditional jump to 0x02cc label_02F5: // Incoming jump from 0x01EA, if 0x23b872dd == stack[-1] // Inputs[1] { @02FC msg.data.length } 02F5 5B JUMPDEST 02F6 61 PUSH2 0x02b7 02F9 61 PUSH2 0x0303 02FC 36 CALLDATASIZE 02FD 60 PUSH1 0x04 02FF 61 PUSH2 0x18cd 0302 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F6 stack[0] = 0x02b7 // @02F9 stack[1] = 0x0303 // @02FC stack[2] = msg.data.length // @02FD stack[3] = 0x04 // } // Block ends with call to 0x18cd, returns to 0x0303 label_0303: // Incoming return from call to 0x18CD at 0x0302 0303 5B JUMPDEST 0304 61 PUSH2 0x075a 0307 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x075a label_0308: // Incoming jump from 0x01F5, if 0x2f745c59 == stack[-1] // Inputs[1] { @030F msg.data.length } 0308 5B JUMPDEST 0309 61 PUSH2 0x02cc 030C 61 PUSH2 0x0316 030F 36 CALLDATASIZE 0310 60 PUSH1 0x04 0312 61 PUSH2 0x1884 0315 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0309 stack[0] = 0x02cc // @030C stack[1] = 0x0316 // @030F stack[2] = msg.data.length // @0310 stack[3] = 0x04 // } // Block ends with call to 0x1884, returns to 0x0316 label_0316: // Incoming return from call to 0x1884 at 0x0315 // Incoming return from call to 0x1F9E at 0x13F5 // Incoming return from call to 0x1F67 at 0x13FF 0316 5B JUMPDEST 0317 61 PUSH2 0x076a 031A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x076a label_031B: // Incoming jump from 0x018D, if 0x32ba0a1e == stack[-1] // Inputs[1] { @0322 msg.data.length } 031B 5B JUMPDEST 031C 61 PUSH2 0x032e 031F 61 PUSH2 0x0329 0322 36 CALLDATASIZE 0323 60 PUSH1 0x04 0325 61 PUSH2 0x1954 0328 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031C stack[0] = 0x032e // @031F stack[1] = 0x0329 // @0322 stack[2] = msg.data.length // @0323 stack[3] = 0x04 // } // Block ends with call to 0x1954, returns to 0x0329 label_0329: // Incoming return from call to 0x1954 at 0x0328 0329 5B JUMPDEST 032A 61 PUSH2 0x07bd 032D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07bd label_032E: // Incoming return from call to 0x0329 at 0x0328 // Inputs[5] // { // @0331 memory[0x40:0x60] // @0335 stack[-4] // @0336 stack[-3] // @0337 stack[-2] // @0338 stack[-1] // } 032E 5B JUMPDEST 032F 60 PUSH1 0x40 0331 51 MLOAD 0332 61 PUSH2 0x025b 0335 94 SWAP5 0336 93 SWAP4 0337 92 SWAP3 0338 91 SWAP2 0339 90 SWAP1 033A 61 PUSH2 0x1a9a 033D 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0335 stack[-4] = 0x025b // @0336 stack[-3] = stack[-4] // @0337 stack[-2] = stack[-3] // @0338 stack[-1] = stack[-2] // @0339 stack[1] = memory[0x40:0x60] // @0339 stack[0] = stack[-1] // } // Block ends with call to 0x1a9a, returns to 0x025B label_033E: // Incoming jump from 0x0198, if 0x42842e0e == stack[-1] // Inputs[1] { @0345 msg.data.length } 033E 5B JUMPDEST 033F 61 PUSH2 0x02b7 0342 61 PUSH2 0x034c 0345 36 CALLDATASIZE 0346 60 PUSH1 0x04 0348 61 PUSH2 0x18cd 034B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033F stack[0] = 0x02b7 // @0342 stack[1] = 0x034c // @0345 stack[2] = msg.data.length // @0346 stack[3] = 0x04 // } // Block ends with call to 0x18cd, returns to 0x034C label_034C: // Incoming return from call to 0x18CD at 0x034B 034C 5B JUMPDEST 034D 61 PUSH2 0x09b5 0350 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09b5 label_0351: // Incoming jump from 0x01A3, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0358 msg.data.length } 0351 5B JUMPDEST 0352 61 PUSH2 0x02cc 0355 61 PUSH2 0x035f 0358 36 CALLDATASIZE 0359 60 PUSH1 0x04 035B 61 PUSH2 0x1856 035E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0352 stack[0] = 0x02cc // @0355 stack[1] = 0x035f // @0358 stack[2] = msg.data.length // @0359 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x035F label_035F: // Incoming return from call to 0x1F9E at 0x0B59 // Incoming return from call to 0x1F67 at 0x0B63 // Incoming return from call to 0x1856 at 0x035E 035F 5B JUMPDEST 0360 61 PUSH2 0x09d0 0363 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09d0 label_0364: // Incoming jump from 0x01AE, if 0x57f6b812 == stack[-1] // Inputs[1] { @036B msg.data.length } 0364 5B JUMPDEST 0365 61 PUSH2 0x0377 0368 61 PUSH2 0x0372 036B 36 CALLDATASIZE 036C 60 PUSH1 0x04 036E 61 PUSH2 0x18b0 0371 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0365 stack[0] = 0x0377 // @0368 stack[1] = 0x0372 // @036B stack[2] = msg.data.length // @036C stack[3] = 0x04 // } // Block ends with call to 0x18b0, returns to 0x0372 label_0372: // Incoming return from call to 0x18B0 at 0x0371 0372 5B JUMPDEST 0373 61 PUSH2 0x09e3 0376 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09e3 label_0377: // Incoming return from call to 0x0372 at 0x0371 // Inputs[3] // { // @037B memory[0x40:0x60] // @037C stack[-2] // @0383 stack[-1] // } 0377 5B JUMPDEST 0378 60 PUSH1 0x40 037A 80 DUP1 037B 51 MLOAD 037C 92 SWAP3 037D 83 DUP4 037E 52 MSTORE 037F 60 PUSH1 0x20 0381 83 DUP4 0382 01 ADD 0383 91 SWAP2 0384 90 SWAP1 0385 91 SWAP2 0386 52 MSTORE 0387 01 ADD 0388 61 PUSH2 0x025b 038B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @037E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0386 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0387 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x025b label_038C: // Incoming jump from 0x0151, if 0x6352211e == stack[-1] // Inputs[1] { @0393 msg.data.length } 038C 5B JUMPDEST 038D 61 PUSH2 0x028c 0390 61 PUSH2 0x039a 0393 36 CALLDATASIZE 0394 60 PUSH1 0x04 0396 61 PUSH2 0x1856 0399 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038D stack[0] = 0x028c // @0390 stack[1] = 0x039a // @0393 stack[2] = msg.data.length // @0394 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x039A label_039A: // Incoming return from call to 0x1856 at 0x0399 039A 5B JUMPDEST 039B 61 PUSH2 0x0a11 039E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a11 label_039F: // Incoming jump from 0x015C, if 0x6bd5ff2f == stack[-1] // Inputs[1] { @03A6 msg.data.length } 039F 5B JUMPDEST 03A0 61 PUSH2 0x03b2 03A3 61 PUSH2 0x03ad 03A6 36 CALLDATASIZE 03A7 60 PUSH1 0x04 03A9 61 PUSH2 0x1b07 03AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A0 stack[0] = 0x03b2 // @03A3 stack[1] = 0x03ad // @03A6 stack[2] = msg.data.length // @03A7 stack[3] = 0x04 // } // Block ends with call to 0x1b07, returns to 0x03AD label_03AD: // Incoming return from call to 0x1B07 at 0x03AC 03AD 5B JUMPDEST 03AE 61 PUSH2 0x0a40 03B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a40 label_03B2: // Incoming return from call to 0x03AD at 0x03AC // Inputs[8] // { // @03B5 memory[0x40:0x60] // @03B9 stack[-7] // @03BA stack[-6] // @03BB stack[-5] // @03BC stack[-4] // @03BD stack[-3] // @03BE stack[-2] // @03BF stack[-1] // } 03B2 5B JUMPDEST 03B3 60 PUSH1 0x40 03B5 51 MLOAD 03B6 61 PUSH2 0x025b 03B9 97 SWAP8 03BA 96 SWAP7 03BB 95 SWAP6 03BC 94 SWAP5 03BD 93 SWAP4 03BE 92 SWAP3 03BF 91 SWAP2 03C0 90 SWAP1 03C1 61 PUSH2 0x1b6c 03C4 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @03B9 stack[-7] = 0x025b // @03BA stack[-6] = stack[-7] // @03BB stack[-5] = stack[-6] // @03BC stack[-4] = stack[-5] // @03BD stack[-3] = stack[-4] // @03BE stack[-2] = stack[-3] // @03BF stack[-1] = stack[-2] // @03C0 stack[1] = memory[0x40:0x60] // @03C0 stack[0] = stack[-1] // } // Block ends with call to 0x1b6c, returns to 0x025B label_03C5: // Incoming jump from 0x0167, if 0x6eb3500d == stack[-1] // Inputs[1] { @03C8 storage[0x03] } 03C5 5B JUMPDEST 03C6 60 PUSH1 0x03 03C8 54 SLOAD 03C9 60 PUSH1 0x01 03CB 60 PUSH1 0x01 03CD 60 PUSH1 0xa0 03CF 1B SHL 03D0 03 SUB 03D1 16 AND 03D2 61 PUSH2 0x028c 03D5 56 *JUMP // Stack delta = +1 // Outputs[1] { @03D1 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x03] } // Block ends with unconditional jump to 0x028c label_03D6: // Incoming jump from 0x0172, if 0x6ff92f50 == stack[-1] // Inputs[1] { @03D9 storage[0x04] } 03D6 5B JUMPDEST 03D7 60 PUSH1 0x04 03D9 54 SLOAD 03DA 60 PUSH1 0x01 03DC 60 PUSH1 0x01 03DE 60 PUSH1 0xa0 03E0 1B SHL 03E1 03 SUB 03E2 16 AND 03E3 61 PUSH2 0x028c 03E6 56 *JUMP // Stack delta = +1 // Outputs[1] { @03E2 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x04] } // Block ends with unconditional jump to 0x028c label_03E7: // Incoming jump from 0x017D, if 0x70a08231 == stack[-1] // Inputs[1] { @03EE msg.data.length } 03E7 5B JUMPDEST 03E8 61 PUSH2 0x02cc 03EB 61 PUSH2 0x03f5 03EE 36 CALLDATASIZE 03EF 60 PUSH1 0x04 03F1 61 PUSH2 0x18b0 03F4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03E8 stack[0] = 0x02cc // @03EB stack[1] = 0x03f5 // @03EE stack[2] = msg.data.length // @03EF stack[3] = 0x04 // } // Block ends with call to 0x18b0, returns to 0x03F5 label_03F5: // Incoming return from call to 0x18B0 at 0x03F4 // Inputs[4] // { // @03FE stack[-1] // @040C memory[0x00:0x40] // @040D storage[keccak256(memory[0x00:0x40])] // @040E stack[-2] // } 03F5 5B JUMPDEST 03F6 60 PUSH1 0x01 03F8 60 PUSH1 0x01 03FA 60 PUSH1 0xa0 03FC 1B SHL 03FD 03 SUB 03FE 16 AND 03FF 60 PUSH1 0x00 0401 90 SWAP1 0402 81 DUP2 0403 52 MSTORE 0404 60 PUSH1 0x02 0406 60 PUSH1 0x20 0408 52 MSTORE 0409 60 PUSH1 0x40 040B 90 SWAP1 040C 20 SHA3 040D 54 SLOAD 040E 90 SWAP1 040F 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0403 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0408 memory[0x20:0x40] = 0x02 // @040E stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0410: // Incoming jump from 0x010A, if 0x767bbd5b == stack[-1] // Inputs[1] { @0417 msg.data.length } 0410 5B JUMPDEST 0411 61 PUSH2 0x02cc 0414 61 PUSH2 0x041e 0417 36 CALLDATASIZE 0418 60 PUSH1 0x04 041A 61 PUSH2 0x1856 041D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0411 stack[0] = 0x02cc // @0414 stack[1] = 0x041e // @0417 stack[2] = msg.data.length // @0418 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x041E label_041E: // Incoming return from call to 0x1856 at 0x041D 041E 5B JUMPDEST 041F 61 PUSH2 0x0bcb 0422 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bcb label_0423: // Incoming jump from 0x0115, if 0x773c02d4 == stack[-1] // Inputs[1] { @042A msg.data.length } 0423 5B JUMPDEST 0424 61 PUSH2 0x02cc 0427 61 PUSH2 0x0431 042A 36 CALLDATASIZE 042B 60 PUSH1 0x04 042D 61 PUSH2 0x18b0 0430 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0424 stack[0] = 0x02cc // @0427 stack[1] = 0x0431 // @042A stack[2] = msg.data.length // @042B stack[3] = 0x04 // } // Block ends with call to 0x18b0, returns to 0x0431 label_0431: // Incoming return from call to 0x18B0 at 0x0430 0431 5B JUMPDEST 0432 61 PUSH2 0x0c00 0435 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c00 label_0436: // Incoming jump from 0x0120, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0439 storage[0x05] } 0436 5B JUMPDEST 0437 60 PUSH1 0x05 0439 54 SLOAD 043A 60 PUSH1 0x01 043C 60 PUSH1 0x01 043E 60 PUSH1 0xa0 0440 1B SHL 0441 03 SUB 0442 16 AND 0443 61 PUSH2 0x028c 0446 56 *JUMP // Stack delta = +1 // Outputs[1] { @0442 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x05] } // Block ends with unconditional jump to 0x028c label_0447: // Incoming jump from 0x012B, if 0x95d89b41 == stack[-1] 0447 5B JUMPDEST 0448 61 PUSH2 0x026c 044B 61 PUSH2 0x0c38 044E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0448 stack[0] = 0x026c } // Block ends with call to 0x0c38, returns to 0x026C label_044F: // Incoming jump from 0x00CE, if 0xa22cb465 == stack[-1] // Inputs[1] { @0456 msg.data.length } 044F 5B JUMPDEST 0450 61 PUSH2 0x02b7 0453 61 PUSH2 0x045d 0456 36 CALLDATASIZE 0457 60 PUSH1 0x04 0459 61 PUSH2 0x1be4 045C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0450 stack[0] = 0x02b7 // @0453 stack[1] = 0x045d // @0456 stack[2] = msg.data.length // @0457 stack[3] = 0x04 // } // Block ends with call to 0x1be4, returns to 0x045D label_045D: // Incoming return from call to 0x1BE4 at 0x045C 045D 5B JUMPDEST 045E 61 PUSH2 0x0c82 0461 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c82 label_0462: // Incoming jump from 0x00D9, if 0xa3739f71 == stack[-1] // Inputs[1] { @0469 msg.data.length } 0462 5B JUMPDEST 0463 61 PUSH2 0x02cc 0466 61 PUSH2 0x0470 0469 36 CALLDATASIZE 046A 60 PUSH1 0x04 046C 61 PUSH2 0x1856 046F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0463 stack[0] = 0x02cc // @0466 stack[1] = 0x0470 // @0469 stack[2] = msg.data.length // @046A stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x0470 label_0470: // Incoming return from call to 0x1856 at 0x046F 0470 5B JUMPDEST 0471 61 PUSH2 0x0cef 0474 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cef label_0475: // Incoming jump from 0x00E4, if 0xa46a932f == stack[-1] // Inputs[1] { @047C msg.data.length } 0475 5B JUMPDEST 0476 61 PUSH2 0x02b7 0479 61 PUSH2 0x0483 047C 36 CALLDATASIZE 047D 60 PUSH1 0x04 047F 61 PUSH2 0x1c19 0482 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0476 stack[0] = 0x02b7 // @0479 stack[1] = 0x0483 // @047C stack[2] = msg.data.length // @047D stack[3] = 0x04 // } // Block ends with call to 0x1c19, returns to 0x0483 label_0483: // Incoming return from call to 0x1C19 at 0x0482 0483 5B JUMPDEST 0484 61 PUSH2 0x0d1d 0487 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d1d label_0488: // Incoming jump from 0x00EF, if 0xa9e566c0 == stack[-1] // Inputs[1] { @048F msg.data.length } 0488 5B JUMPDEST 0489 61 PUSH2 0x049b 048C 61 PUSH2 0x0496 048F 36 CALLDATASIZE 0490 60 PUSH1 0x04 0492 61 PUSH2 0x1856 0495 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0489 stack[0] = 0x049b // @048C stack[1] = 0x0496 // @048F stack[2] = msg.data.length // @0490 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x0496 label_0496: // Incoming return from call to 0x1856 at 0x0495 0496 5B JUMPDEST 0497 61 PUSH2 0x1035 049A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1035 label_049B: // Incoming return from call to 0x0496 at 0x0495 // Inputs[2] // { // @049E memory[0x40:0x60] // @04A2 stack[-1] // } 049B 5B JUMPDEST 049C 60 PUSH1 0x40 049E 51 MLOAD 049F 61 PUSH2 0x025b 04A2 91 SWAP2 04A3 90 SWAP1 04A4 61 PUSH2 0x1c77 04A7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04A2 stack[-1] = 0x025b // @04A3 stack[1] = memory[0x40:0x60] // @04A3 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1c77 label_04A8: // Incoming jump from 0x00FA, if 0xab2a1941 == stack[-1] // Inputs[1] { @04AF msg.data.length } 04A8 5B JUMPDEST 04A9 61 PUSH2 0x02cc 04AC 61 PUSH2 0x04b6 04AF 36 CALLDATASIZE 04B0 60 PUSH1 0x04 04B2 61 PUSH2 0x1856 04B5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04A9 stack[0] = 0x02cc // @04AC stack[1] = 0x04b6 // @04AF stack[2] = msg.data.length // @04B0 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x04B6 label_04B6: // Incoming return from call to 0x1856 at 0x04B5 04B6 5B JUMPDEST 04B7 61 PUSH2 0x10a1 04BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10a1 label_04BB: // Incoming jump from 0x0087, if 0xb0467deb == stack[-1] // Inputs[1] { @04C2 msg.data.length } 04BB 5B JUMPDEST 04BC 61 PUSH2 0x028c 04BF 61 PUSH2 0x04c9 04C2 36 CALLDATASIZE 04C3 60 PUSH1 0x04 04C5 61 PUSH2 0x1856 04C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04BC stack[0] = 0x028c // @04BF stack[1] = 0x04c9 // @04C2 stack[2] = msg.data.length // @04C3 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x04C9 label_04C9: // Incoming return from call to 0x1856 at 0x04C8 04C9 5B JUMPDEST 04CA 61 PUSH2 0x10d6 04CD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10d6 label_04CE: // Incoming jump from 0x0092, if 0xb3a7eb59 == stack[-1] // Inputs[1] { @04D5 msg.data.length } 04CE 5B JUMPDEST 04CF 61 PUSH2 0x02cc 04D2 61 PUSH2 0x04dc 04D5 36 CALLDATASIZE 04D6 60 PUSH1 0x04 04D8 61 PUSH2 0x1856 04DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04CF stack[0] = 0x02cc // @04D2 stack[1] = 0x04dc // @04D5 stack[2] = msg.data.length // @04D6 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x04DC label_04DC: // Incoming return from call to 0x1856 at 0x04DB 04DC 5B JUMPDEST 04DD 61 PUSH2 0x1101 04E0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1101 label_04E1: // Incoming jump from 0x009D, if 0xb88d4fde == stack[-1] // Inputs[1] { @04E8 msg.data.length } 04E1 5B JUMPDEST 04E2 61 PUSH2 0x02b7 04E5 61 PUSH2 0x04ef 04E8 36 CALLDATASIZE 04E9 60 PUSH1 0x04 04EB 61 PUSH2 0x1cac 04EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04E2 stack[0] = 0x02b7 // @04E5 stack[1] = 0x04ef // @04E8 stack[2] = msg.data.length // @04E9 stack[3] = 0x04 // } // Block ends with call to 0x1cac, returns to 0x04EF label_04EF: // Incoming return from call to 0x1CAC at 0x04EE 04EF 5B JUMPDEST 04F0 61 PUSH2 0x1136 04F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1136 label_04F4: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @04FB msg.data.length } 04F4 5B JUMPDEST 04F5 61 PUSH2 0x026c 04F8 61 PUSH2 0x0502 04FB 36 CALLDATASIZE 04FC 60 PUSH1 0x04 04FE 61 PUSH2 0x1856 0501 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04F5 stack[0] = 0x026c // @04F8 stack[1] = 0x0502 // @04FB stack[2] = msg.data.length // @04FC stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x0502 label_0502: // Incoming return from call to 0x1856 at 0x0501 0502 5B JUMPDEST 0503 61 PUSH2 0x11e7 0506 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11e7 label_0507: // Incoming jump from 0x00B3, if 0xdfe6e512 == stack[-1] // Inputs[1] { @050E msg.data.length } 0507 5B JUMPDEST 0508 61 PUSH2 0x02cc 050B 61 PUSH2 0x0515 050E 36 CALLDATASIZE 050F 60 PUSH1 0x04 0511 61 PUSH2 0x1856 0514 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0508 stack[0] = 0x02cc // @050B stack[1] = 0x0515 // @050E stack[2] = msg.data.length // @050F stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x0515 label_0515: // Incoming return from call to 0x1856 at 0x0514 0515 5B JUMPDEST 0516 61 PUSH2 0x1259 0519 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1259 label_051A: // Incoming jump from 0x004B, if 0xe4b50cb8 == stack[-1] // Inputs[1] { @0521 msg.data.length } 051A 5B JUMPDEST 051B 61 PUSH2 0x052d 051E 61 PUSH2 0x0528 0521 36 CALLDATASIZE 0522 60 PUSH1 0x04 0524 61 PUSH2 0x1856 0527 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @051B stack[0] = 0x052d // @051E stack[1] = 0x0528 // @0521 stack[2] = msg.data.length // @0522 stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x0528 label_0528: // Incoming return from call to 0x1856 at 0x0527 0528 5B JUMPDEST 0529 61 PUSH2 0x1287 052C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1287 label_052D: // Incoming return from call to 0x0528 at 0x0527 // Inputs[5] // { // @0530 memory[0x40:0x60] // @0534 stack[-4] // @0535 stack[-3] // @0536 stack[-2] // @0537 stack[-1] // } 052D 5B JUMPDEST 052E 60 PUSH1 0x40 0530 51 MLOAD 0531 61 PUSH2 0x025b 0534 94 SWAP5 0535 93 SWAP4 0536 92 SWAP3 0537 91 SWAP2 0538 90 SWAP1 0539 61 PUSH2 0x1d5a 053C 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0534 stack[-4] = 0x025b // @0535 stack[-3] = stack[-4] // @0536 stack[-2] = stack[-3] // @0537 stack[-1] = stack[-2] // @0538 stack[1] = memory[0x40:0x60] // @0538 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1d5a label_053D: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0544 msg.data.length } 053D 5B JUMPDEST 053E 61 PUSH2 0x024f 0541 61 PUSH2 0x054b 0544 36 CALLDATASIZE 0545 60 PUSH1 0x04 0547 61 PUSH2 0x1d91 054A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @053E stack[0] = 0x024f // @0541 stack[1] = 0x054b // @0544 stack[2] = msg.data.length // @0545 stack[3] = 0x04 // } // Block ends with call to 0x1d91, returns to 0x054B label_054B: // Incoming return from call to 0x1D91 at 0x054A // Inputs[6] // { // @0554 stack[-2] // @0567 memory[0x00:0x40] // @0568 stack[-1] // @0573 memory[0x00:0x40] // @0574 storage[keccak256(memory[0x00:0x40])] // @0578 stack[-3] // } 054B 5B JUMPDEST 054C 60 PUSH1 0x01 054E 60 PUSH1 0x01 0550 60 PUSH1 0xa0 0552 1B SHL 0553 03 SUB 0554 91 SWAP2 0555 82 DUP3 0556 16 AND 0557 60 PUSH1 0x00 0559 90 SWAP1 055A 81 DUP2 055B 52 MSTORE 055C 60 PUSH1 0x02 055E 60 PUSH1 0x20 0560 81 DUP2 0561 81 DUP2 0562 52 MSTORE 0563 60 PUSH1 0x40 0565 80 DUP1 0566 84 DUP5 0567 20 SHA3 0568 94 SWAP5 0569 90 SWAP1 056A 95 SWAP6 056B 16 AND 056C 83 DUP4 056D 52 MSTORE 056E 92 SWAP3 056F 01 ADD 0570 90 SWAP1 0571 91 SWAP2 0572 52 MSTORE 0573 20 SHA3 0574 54 SLOAD 0575 60 PUSH1 0xff 0577 16 AND 0578 90 SWAP1 0579 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @055B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0562 memory[0x20:0x40] = 0x02 // @056D memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0572 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x02 // @0578 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_057A: // Incoming jump from 0x0061, if 0xf0063795 == stack[-1] // Inputs[1] { @0581 msg.data.length } 057A 5B JUMPDEST 057B 61 PUSH2 0x058d 057E 61 PUSH2 0x0588 0581 36 CALLDATASIZE 0582 60 PUSH1 0x04 0584 61 PUSH2 0x1dca 0587 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @057B stack[0] = 0x058d // @057E stack[1] = 0x0588 // @0581 stack[2] = msg.data.length // @0582 stack[3] = 0x04 // } // Block ends with call to 0x1dca, returns to 0x0588 label_0588: // Incoming return from call to 0x1DCA at 0x0587 0588 5B JUMPDEST 0589 61 PUSH2 0x12c7 058C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12c7 label_058D: // Incoming return from call to 0x0588 at 0x0587 // Inputs[7] // { // @0590 memory[0x40:0x60] // @0594 stack[-6] // @0595 stack[-5] // @0596 stack[-4] // @0597 stack[-3] // @0598 stack[-2] // @0599 stack[-1] // } 058D 5B JUMPDEST 058E 60 PUSH1 0x40 0590 51 MLOAD 0591 61 PUSH2 0x025b 0594 96 SWAP7 0595 95 SWAP6 0596 94 SWAP5 0597 93 SWAP4 0598 92 SWAP3 0599 91 SWAP2 059A 90 SWAP1 059B 61 PUSH2 0x1e12 059E 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0594 stack[-6] = 0x025b // @0595 stack[-5] = stack[-6] // @0596 stack[-4] = stack[-5] // @0597 stack[-3] = stack[-4] // @0598 stack[-2] = stack[-3] // @0599 stack[-1] = stack[-2] // @059A stack[1] = memory[0x40:0x60] // @059A stack[0] = stack[-1] // } // Block ends with call to 0x1e12, returns to 0x025B label_059F: // Incoming jump from 0x006C, if 0xf3cb8385 == stack[-1] // Inputs[1] { @05A6 msg.data.length } 059F 5B JUMPDEST 05A0 61 PUSH2 0x02b7 05A3 61 PUSH2 0x05ad 05A6 36 CALLDATASIZE 05A7 60 PUSH1 0x04 05A9 61 PUSH2 0x18b0 05AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05A0 stack[0] = 0x02b7 // @05A3 stack[1] = 0x05ad // @05A6 stack[2] = msg.data.length // @05A7 stack[3] = 0x04 // } // Block ends with call to 0x18b0, returns to 0x05AD label_05AD: // Incoming return from call to 0x18B0 at 0x05AC 05AD 5B JUMPDEST 05AE 61 PUSH2 0x1468 05B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1468 label_05B2: // Incoming jump from 0x0077, if 0xf5fe58b8 == stack[-1] // Inputs[1] { @05B9 msg.data.length } 05B2 5B JUMPDEST 05B3 61 PUSH2 0x02cc 05B6 61 PUSH2 0x05c0 05B9 36 CALLDATASIZE 05BA 60 PUSH1 0x04 05BC 61 PUSH2 0x1856 05BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05B3 stack[0] = 0x02cc // @05B6 stack[1] = 0x05c0 // @05B9 stack[2] = msg.data.length // @05BA stack[3] = 0x04 // } // Block ends with call to 0x1856, returns to 0x05C0 label_05C0: // Incoming return from call to 0x1856 at 0x05BF 05C0 5B JUMPDEST 05C1 61 PUSH2 0x14a1 05C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14a1 label_05C5: // Incoming call from 0x026B, returns to 0x026C // Inputs[6] // { // @05C8 storage[0x03] // @05CC memory[0x40:0x60] // @05D8 memory[0x40:0x60] // @05FD msg.gas // @05FE memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04] // @05FE address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // } 05C5 5B JUMPDEST 05C6 60 PUSH1 0x03 05C8 54 SLOAD 05C9 60 PUSH1 0x40 05CB 80 DUP1 05CC 51 MLOAD 05CD 63 PUSH4 0x06fdde03 05D2 60 PUSH1 0xe0 05D4 1B SHL 05D5 81 DUP2 05D6 52 MSTORE 05D7 90 SWAP1 05D8 51 MLOAD 05D9 60 PUSH1 0x60 05DB 92 SWAP3 05DC 60 PUSH1 0x01 05DE 60 PUSH1 0x01 05E0 60 PUSH1 0xa0 05E2 1B SHL 05E3 03 SUB 05E4 16 AND 05E5 91 SWAP2 05E6 63 PUSH4 0x06fdde03 05EB 91 SWAP2 05EC 60 PUSH1 0x04 05EE 80 DUP1 05EF 83 DUP4 05F0 01 ADD 05F1 92 SWAP3 05F2 60 PUSH1 0x00 05F4 92 SWAP3 05F5 91 SWAP2 05F6 90 SWAP1 05F7 82 DUP3 05F8 90 SWAP1 05F9 03 SUB 05FA 01 ADD 05FB 81 DUP2 05FC 86 DUP7 05FD 5A GAS 05FE FA STATICCALL 05FF 15 ISZERO 0600 80 DUP1 0601 15 ISZERO 0602 61 PUSH2 0x060f 0605 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @05D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x06fdde03 << 0xe0 // @05DB stack[0] = 0x60 // @05E5 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @05EB stack[2] = 0x06fdde03 // @05F1 stack[3] = memory[0x40:0x60] + 0x04 // @05FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // @05FF stack[4] = !address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // } // Block ends with conditional jump to 0x060f, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) label_0606: // Incoming jump from 0x0605, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // Inputs[4] // { // @0606 returndata.length // @060A returndata[0x00:0x00 + returndata.length] // @060B returndata.length // @060E memory[0x00:0x00 + returndata.length] // } 0606 3D RETURNDATASIZE 0607 60 PUSH1 0x00 0609 80 DUP1 060A 3E RETURNDATACOPY 060B 3D RETURNDATASIZE 060C 60 PUSH1 0x00 060E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @060A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @060E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_060F: // Incoming jump from 0x0605, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // Incoming jump from 0x0C78, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // Inputs[4] // { // @0616 memory[0x40:0x60] // @0617 returndata.length // @061B returndata[0x00:0x00 + returndata.length] // @061E returndata.length // } 060F 5B JUMPDEST 0610 50 POP 0611 50 POP 0612 50 POP 0613 50 POP 0614 60 PUSH1 0x40 0616 51 MLOAD 0617 3D RETURNDATASIZE 0618 60 PUSH1 0x00 061A 82 DUP3 061B 3E RETURNDATACOPY 061C 60 PUSH1 0x1f 061E 3D RETURNDATASIZE 061F 90 SWAP1 0620 81 DUP2 0621 01 ADD 0622 60 PUSH1 0x1f 0624 19 NOT 0625 16 AND 0626 82 DUP3 0627 01 ADD 0628 60 PUSH1 0x40 062A 52 MSTORE 062B 61 PUSH2 0x0637 062E 91 SWAP2 062F 90 SWAP1 0630 81 DUP2 0631 01 ADD 0632 90 SWAP1 0633 61 PUSH2 0x1e75 0636 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @061B memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @062A memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @062E stack[-4] = 0x0637 // @0632 stack[-2] = memory[0x40:0x60] // @0632 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1e75, returns to 0x0637 label_0637: // Incoming return from call to 0x1E75 at 0x0636 // Inputs[3] // { // @0638 stack[-1] // @0638 stack[-2] // @063A stack[-3] // } 0637 5B JUMPDEST 0638 90 SWAP1 0639 50 POP 063A 90 SWAP1 063B 56 *JUMP // Stack delta = -2 // Outputs[1] { @063A stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_063C: // Incoming call from 0x12A5, returns to 0x12A6 // Incoming jump from 0x028B // Incoming call from 0x14E6, returns to 0x14E7 // Inputs[2] // { // @0640 storage[0x00] // @0641 stack[-1] // } 063C 5B JUMPDEST 063D 60 PUSH1 0x00 063F 80 DUP1 0640 54 SLOAD 0641 82 DUP3 0642 10 LT 0643 61 PUSH2 0x064b 0646 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063D stack[0] = 0x00 } // Block ends with conditional jump to 0x064b, if stack[-1] < storage[0x00] label_0647: // Incoming jump from 0x0646, if not stack[-1] < storage[0x00] // Inputs[1] { @064A memory[0x00:0x00] } 0647 60 PUSH1 0x00 0649 80 DUP1 064A FD *REVERT // Stack delta = +0 // Outputs[1] { @064A revert(memory[0x00:0x00]); } // Block terminates label_064B: // Incoming jump from 0x0646, if stack[-1] < storage[0x00] // Inputs[4] // { // @064F stack[-2] // @065A memory[0x00:0x40] // @065E storage[0x02 + keccak256(memory[0x00:0x40])] // @0668 stack[-3] // } 064B 5B JUMPDEST 064C 50 POP 064D 60 PUSH1 0x00 064F 90 SWAP1 0650 81 DUP2 0651 52 MSTORE 0652 60 PUSH1 0x01 0654 60 PUSH1 0x20 0656 52 MSTORE 0657 60 PUSH1 0x40 0659 90 SWAP1 065A 20 SHA3 065B 60 PUSH1 0x02 065D 01 ADD 065E 54 SLOAD 065F 60 PUSH1 0x01 0661 60 PUSH1 0x01 0663 60 PUSH1 0xa0 0665 1B SHL 0666 03 SUB 0667 16 AND 0668 90 SWAP1 0669 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0651 memory[0x00:0x20] = stack[-2] // @0656 memory[0x20:0x40] = 0x01 // @0668 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_066A: // Incoming jump from 0x02B6 // Inputs[1] { @066E stack[-1] } 066A 5B JUMPDEST 066B 61 PUSH2 0x0673 066E 81 DUP2 066F 61 PUSH2 0x0a11 0672 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @066B stack[0] = 0x0673 // @066E stack[1] = stack[-1] // } // Block ends with call to 0x0a11, returns to 0x0673 label_0673: // Incoming return from call to 0x0A11 at 0x0672 // Inputs[2] // { // @067C stack[-1] // @067D msg.sender // } 0673 5B JUMPDEST 0674 60 PUSH1 0x01 0676 60 PUSH1 0x01 0678 60 PUSH1 0xa0 067A 1B SHL 067B 03 SUB 067C 16 AND 067D 33 CALLER 067E 60 PUSH1 0x01 0680 60 PUSH1 0x01 0682 60 PUSH1 0xa0 0684 1B SHL 0685 03 SUB 0686 16 AND 0687 14 EQ 0688 61 PUSH2 0x0690 068B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0690, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] label_068C: // Incoming jump from 0x068B, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @068F memory[0x00:0x00] } 068C 60 PUSH1 0x00 068E 80 DUP1 068F FD *REVERT // Stack delta = +0 // Outputs[1] { @068F revert(memory[0x00:0x00]); } // Block terminates label_0690: // Incoming jump from 0x068B, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[8] // { // @0693 stack[-1] // @069F memory[0x00:0x40] // @06A4 storage[0x02 + keccak256(memory[0x00:0x40])] // @06B7 stack[-2] // @06C0 memory[0x40:0x60] // @06C3 msg.sender // @06E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @06EB stack[-3] // } 0690 5B JUMPDEST 0691 60 PUSH1 0x00 0693 81 DUP2 0694 81 DUP2 0695 52 MSTORE 0696 60 PUSH1 0x01 0698 60 PUSH1 0x20 069A 52 MSTORE 069B 60 PUSH1 0x40 069D 80 DUP1 069E 82 DUP3 069F 20 SHA3 06A0 60 PUSH1 0x02 06A2 01 ADD 06A3 80 DUP1 06A4 54 SLOAD 06A5 60 PUSH1 0x01 06A7 60 PUSH1 0x01 06A9 60 PUSH1 0xa0 06AB 1B SHL 06AC 03 SUB 06AD 19 NOT 06AE 16 AND 06AF 60 PUSH1 0x01 06B1 60 PUSH1 0x01 06B3 60 PUSH1 0xa0 06B5 1B SHL 06B6 03 SUB 06B7 86 DUP7 06B8 16 AND 06B9 90 SWAP1 06BA 81 DUP2 06BB 17 OR 06BC 90 SWAP1 06BD 91 SWAP2 06BE 55 SSTORE 06BF 90 SWAP1 06C0 51 MLOAD 06C1 83 DUP4 06C2 92 SWAP3 06C3 33 CALLER 06C4 91 SWAP2 06C5 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 06E6 91 SWAP2 06E7 90 SWAP1 06E8 A4 LOG4 06E9 50 POP 06EA 50 POP 06EB 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @0695 memory[0x00:0x20] = stack[-1] // @069A memory[0x20:0x40] = 0x01 // @06BE storage[0x02 + keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x02 + keccak256(memory[0x00:0x40])]) // @06E8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-3] label_06EC: // Incoming call from 0x1096, returns to 0x1097 // Incoming jump from 0x02CB // Inputs[2] // { // @06F0 storage[0x00] // @06F1 stack[-1] // } 06EC 5B JUMPDEST 06ED 60 PUSH1 0x00 06EF 80 DUP1 06F0 54 SLOAD 06F1 82 DUP3 06F2 10 LT 06F3 61 PUSH2 0x06fb 06F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06ED stack[0] = 0x00 } // Block ends with conditional jump to 0x06fb, if stack[-1] < storage[0x00] label_06F7: // Incoming jump from 0x06F6, if not stack[-1] < storage[0x00] // Inputs[1] { @06FA memory[0x00:0x00] } 06F7 60 PUSH1 0x00 06F9 80 DUP1 06FA FD *REVERT // Stack delta = +0 // Outputs[1] { @06FA revert(memory[0x00:0x00]); } // Block terminates label_06FB: // Incoming jump from 0x06F6, if stack[-1] < storage[0x00] // Inputs[4] // { // @06FF stack[-2] // @070A memory[0x00:0x40] // @070E storage[0x05 + keccak256(memory[0x00:0x40])] // @071F stack[-3] // } 06FB 5B JUMPDEST 06FC 50 POP 06FD 60 PUSH1 0x00 06FF 90 SWAP1 0700 81 DUP2 0701 52 MSTORE 0702 60 PUSH1 0x01 0704 60 PUSH1 0x20 0706 52 MSTORE 0707 60 PUSH1 0x40 0709 90 SWAP1 070A 20 SHA3 070B 60 PUSH1 0x05 070D 01 ADD 070E 54 SLOAD 070F 60 PUSH1 0x01 0711 60 PUSH1 0xc0 0713 1B SHL 0714 90 SWAP1 0715 04 DIV 0716 60 PUSH1 0x01 0718 60 PUSH1 0x01 071A 60 PUSH1 0x40 071C 1B SHL 071D 03 SUB 071E 16 AND 071F 90 SWAP1 0720 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0701 memory[0x00:0x20] = stack[-2] // @0706 memory[0x20:0x40] = 0x01 // @071F stack[-3] = (0x01 << 0x40) - 0x01 & storage[0x05 + keccak256(memory[0x00:0x40])] / (0x01 << 0xc0) // } // Block ends with unconditional jump to stack[-3] label_0721: // Incoming jump from 0x02EC // Inputs[2] // { // @0724 storage[0x05] // @072E msg.sender // } 0721 5B JUMPDEST 0722 60 PUSH1 0x05 0724 54 SLOAD 0725 60 PUSH1 0x01 0727 60 PUSH1 0x01 0729 60 PUSH1 0xa0 072B 1B SHL 072C 03 SUB 072D 16 AND 072E 33 CALLER 072F 14 EQ 0730 61 PUSH2 0x0738 0733 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0738, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_0734: // Incoming jump from 0x0733, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @0737 memory[0x00:0x00] } 0734 60 PUSH1 0x00 0736 80 DUP1 0737 FD *REVERT // Stack delta = +0 // Outputs[1] { @0737 revert(memory[0x00:0x00]); } // Block terminates label_0738: // Incoming jump from 0x0733, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[3] // { // @073C storage[0x05] // @074F stack[-1] // @0759 stack[-2] // } 0738 5B JUMPDEST 0739 60 PUSH1 0x05 073B 80 DUP1 073C 54 SLOAD 073D 60 PUSH1 0x01 073F 60 PUSH1 0x01 0741 60 PUSH1 0xa0 0743 1B SHL 0744 03 SUB 0745 19 NOT 0746 16 AND 0747 60 PUSH1 0x01 0749 60 PUSH1 0x01 074B 60 PUSH1 0xa0 074D 1B SHL 074E 03 SUB 074F 92 SWAP3 0750 90 SWAP1 0751 92 SWAP3 0752 16 AND 0753 91 SWAP2 0754 90 SWAP1 0755 91 SWAP2 0756 17 OR 0757 90 SWAP1 0758 55 SSTORE 0759 56 *JUMP // Stack delta = -2 // Outputs[1] { @0758 storage[0x05] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x05]) } // Block ends with unconditional jump to stack[-2] label_075A: // Incoming jump from 0x0307 // Inputs[3] // { // @075E stack[-3] // @075F stack[-2] // @0760 stack[-1] // } 075A 5B JUMPDEST 075B 61 PUSH2 0x0765 075E 83 DUP4 075F 83 DUP4 0760 83 DUP4 0761 61 PUSH2 0x14cf 0764 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @075B stack[0] = 0x0765 // @075E stack[1] = stack[-3] // @075F stack[2] = stack[-2] // @0760 stack[3] = stack[-1] // } // Block ends with call to 0x14cf, returns to 0x0765 label_0765: // Incoming return from call to 0x1136 at 0x09CF // Incoming return from call to 0x14CF at 0x0764 // Inputs[1] { @0769 stack[-4] } 0765 5B JUMPDEST 0766 50 POP 0767 50 POP 0768 50 POP 0769 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_076A: // Incoming jump from 0x031A // Inputs[4] // { // @0773 stack[-2] // @0782 memory[0x00:0x40] // @0783 storage[keccak256(memory[0x00:0x40])] // @0784 stack[-1] // } 076A 5B JUMPDEST 076B 60 PUSH1 0x01 076D 60 PUSH1 0x01 076F 60 PUSH1 0xa0 0771 1B SHL 0772 03 SUB 0773 82 DUP3 0774 16 AND 0775 60 PUSH1 0x00 0777 90 SWAP1 0778 81 DUP2 0779 52 MSTORE 077A 60 PUSH1 0x02 077C 60 PUSH1 0x20 077E 52 MSTORE 077F 60 PUSH1 0x40 0781 81 DUP2 0782 20 SHA3 0783 54 SLOAD 0784 82 DUP3 0785 10 LT 0786 61 PUSH2 0x078e 0789 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0777 stack[0] = 0x00 // @0779 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @077E memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x078e, if stack[-1] < storage[keccak256(memory[0x00:0x40])] label_078A: // Incoming jump from 0x0789, if not stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @078D memory[0x00:0x00] } 078A 60 PUSH1 0x00 078C 80 DUP1 078D FD *REVERT // Stack delta = +0 // Outputs[1] { @078D revert(memory[0x00:0x00]); } // Block terminates label_078E: // Incoming jump from 0x0789, if stack[-1] < storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @0798 stack[-3] // @07AA memory[0x00:0x40] // @07AB stack[-2] // @07B5 memory[0x00:0x40] // @07B6 storage[keccak256(memory[0x00:0x40])] // @07B8 stack[-4] // } 078E 5B JUMPDEST 078F 50 POP 0790 60 PUSH1 0x01 0792 60 PUSH1 0x01 0794 60 PUSH1 0xa0 0796 1B SHL 0797 03 SUB 0798 82 DUP3 0799 16 AND 079A 60 PUSH1 0x00 079C 90 SWAP1 079D 81 DUP2 079E 52 MSTORE 079F 60 PUSH1 0x02 07A1 60 PUSH1 0x20 07A3 90 SWAP1 07A4 81 DUP2 07A5 52 MSTORE 07A6 60 PUSH1 0x40 07A8 80 DUP1 07A9 83 DUP4 07AA 20 SHA3 07AB 84 DUP5 07AC 84 DUP5 07AD 52 MSTORE 07AE 60 PUSH1 0x01 07B0 01 ADD 07B1 90 SWAP1 07B2 91 SWAP2 07B3 52 MSTORE 07B4 90 SWAP1 07B5 20 SHA3 07B6 54 SLOAD 07B7 5B JUMPDEST 07B8 92 SWAP3 07B9 91 SWAP2 07BA 50 POP 07BB 50 POP 07BC 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @079E memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @07A5 memory[0x20:0x40] = 0x02 // @07AD memory[0x00:0x20] = stack[-2] // @07B3 memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @07B8 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_07BD: // Incoming jump from 0x032D // Incoming call from 0x1452, returns to 0x1453 // Incoming call from 0x0BB6, returns to 0x0BB7 // Incoming call from 0x1452, returns to 0x1453 // Incoming call from 0x0BB6, returns to 0x0BB7 // Inputs[2] // { // @07C6 stack[-1] // @07C7 memory[stack[-1]:stack[-1] + 0x20] // } 07BD 5B JUMPDEST 07BE 60 PUSH1 0x60 07C0 80 DUP1 07C1 60 PUSH1 0x60 07C3 80 DUP1 07C4 60 PUSH1 0x00 07C6 85 DUP6 07C7 51 MLOAD 07C8 90 SWAP1 07C9 50 POP 07CA 80 DUP1 07CB 60 PUSH1 0x01 07CD 60 PUSH1 0x01 07CF 60 PUSH1 0x40 07D1 1B SHL 07D2 03 SUB 07D3 81 DUP2 07D4 11 GT 07D5 15 ISZERO 07D6 61 PUSH2 0x07e1 07D9 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @07BE stack[0] = 0x60 // @07C0 stack[1] = 0x60 // @07C1 stack[2] = 0x60 // @07C3 stack[3] = 0x60 // @07C8 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @07CA stack[5] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x07e1, if !(memory[stack[-1]:stack[-1] + 0x20] > (0x01 << 0x40) - 0x01) label_07DA: // Incoming jump from 0x07D9, if not !(memory[stack[-1]:stack[-1] + 0x20] > (0x01 << 0x40) - 0x01) 07DA 61 PUSH2 0x07e1 07DD 61 PUSH2 0x190e 07E0 56 *JUMP // Stack delta = +1 // Outputs[1] { @07DA stack[0] = 0x07e1 } // Block ends with unconditional jump to 0x190e label_07E1: // Incoming jump from 0x07D9, if !(memory[stack[-1]:stack[-1] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @07E4 memory[0x40:0x60] // @07E5 stack[-1] // } 07E1 5B JUMPDEST 07E2 60 PUSH1 0x40 07E4 51 MLOAD 07E5 90 SWAP1 07E6 80 DUP1 07E7 82 DUP3 07E8 52 MSTORE 07E9 80 DUP1 07EA 60 PUSH1 0x20 07EC 02 MUL 07ED 60 PUSH1 0x20 07EF 01 ADD 07F0 82 DUP3 07F1 01 ADD 07F2 60 PUSH1 0x40 07F4 52 MSTORE 07F5 80 DUP1 07F6 15 ISZERO 07F7 61 PUSH2 0x080a 07FA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @07E5 stack[-1] = memory[0x40:0x60] // @07E5 stack[0] = stack[-1] // @07E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @07F4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x080a, if !stack[-1] label_07FB: // Incoming jump from 0x07FA, if not !stack[-1] // Inputs[6] // { // @07FB stack[-2] // @0801 stack[-1] // @0804 msg.data.length // @0806 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @080C stack[-7] // @080E stack[-3] // } 07FB 81 DUP2 07FC 60 PUSH1 0x20 07FE 01 ADD 07FF 60 PUSH1 0x20 0801 82 DUP3 0802 02 MUL 0803 80 DUP1 0804 36 CALLDATASIZE 0805 83 DUP4 0806 37 CALLDATACOPY 0807 01 ADD 0808 90 SWAP1 0809 50 POP 080A 5B JUMPDEST 080B 50 POP 080C 94 SWAP5 080D 50 POP 080E 80 DUP1 080F 60 PUSH1 0x01 0811 60 PUSH1 0x01 0813 60 PUSH1 0x40 0815 1B SHL 0816 03 SUB 0817 81 DUP2 0818 11 GT 0819 15 ISZERO 081A 61 PUSH2 0x0825 081D 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0806 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @080C stack[-7] = stack[-2] // @080E stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x0825, if !(stack[-3] > (0x01 << 0x40) - 0x01) label_081E: // Incoming jump from 0x081D, if not !(stack[-3] > (0x01 << 0x40) - 0x01) // Incoming jump from 0x081D, if not !(stack[-3] > (0x01 << 0x40) - 0x01) 081E 61 PUSH2 0x0825 0821 61 PUSH2 0x190e 0824 56 *JUMP // Stack delta = +1 // Outputs[1] { @081E stack[0] = 0x0825 } // Block ends with unconditional jump to 0x190e label_0825: // Incoming jump from 0x081D, if !(stack[-3] > (0x01 << 0x40) - 0x01) // Incoming jump from 0x081D, if !(stack[-3] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0828 memory[0x40:0x60] // @0829 stack[-1] // } 0825 5B JUMPDEST 0826 60 PUSH1 0x40 0828 51 MLOAD 0829 90 SWAP1 082A 80 DUP1 082B 82 DUP3 082C 52 MSTORE 082D 80 DUP1 082E 60 PUSH1 0x20 0830 02 MUL 0831 60 PUSH1 0x20 0833 01 ADD 0834 82 DUP3 0835 01 ADD 0836 60 PUSH1 0x40 0838 52 MSTORE 0839 80 DUP1 083A 15 ISZERO 083B 61 PUSH2 0x084e 083E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0829 stack[-1] = memory[0x40:0x60] // @0829 stack[0] = stack[-1] // @082C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0838 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x084e, if !stack[-1] label_083F: // Incoming jump from 0x083E, if not !stack[-1] // Inputs[6] // { // @083F stack[-2] // @0845 stack[-1] // @0848 msg.data.length // @084A msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0850 stack[-6] // @0852 stack[-3] // } 083F 81 DUP2 0840 60 PUSH1 0x20 0842 01 ADD 0843 60 PUSH1 0x20 0845 82 DUP3 0846 02 MUL 0847 80 DUP1 0848 36 CALLDATASIZE 0849 83 DUP4 084A 37 CALLDATACOPY 084B 01 ADD 084C 90 SWAP1 084D 50 POP 084E 5B JUMPDEST 084F 50 POP 0850 93 SWAP4 0851 50 POP 0852 80 DUP1 0853 60 PUSH1 0x01 0855 60 PUSH1 0x01 0857 60 PUSH1 0x40 0859 1B SHL 085A 03 SUB 085B 81 DUP2 085C 11 GT 085D 15 ISZERO 085E 61 PUSH2 0x0869 0861 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @084A memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0850 stack[-6] = stack[-2] // @0852 stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x0869, if !(stack[-3] > (0x01 << 0x40) - 0x01) label_0862: // Incoming jump from 0x0861, if not !(stack[-3] > (0x01 << 0x40) - 0x01) // Incoming jump from 0x0861, if not !(stack[-3] > (0x01 << 0x40) - 0x01) 0862 61 PUSH2 0x0869 0865 61 PUSH2 0x190e 0868 56 *JUMP // Stack delta = +1 // Outputs[1] { @0862 stack[0] = 0x0869 } // Block ends with unconditional jump to 0x190e label_0869: // Incoming jump from 0x0861, if !(stack[-3] > (0x01 << 0x40) - 0x01) // Incoming jump from 0x0861, if !(stack[-3] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @086C memory[0x40:0x60] // @086D stack[-1] // } 0869 5B JUMPDEST 086A 60 PUSH1 0x40 086C 51 MLOAD 086D 90 SWAP1 086E 80 DUP1 086F 82 DUP3 0870 52 MSTORE 0871 80 DUP1 0872 60 PUSH1 0x20 0874 02 MUL 0875 60 PUSH1 0x20 0877 01 ADD 0878 82 DUP3 0879 01 ADD 087A 60 PUSH1 0x40 087C 52 MSTORE 087D 80 DUP1 087E 15 ISZERO 087F 61 PUSH2 0x0892 0882 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @086D stack[-1] = memory[0x40:0x60] // @086D stack[0] = stack[-1] // @0870 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @087C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0892, if !stack[-1] label_0883: // Incoming jump from 0x0882, if not !stack[-1] // Inputs[6] // { // @0883 stack[-2] // @0889 stack[-1] // @088C msg.data.length // @088E msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0894 stack[-5] // @0896 stack[-3] // } 0883 81 DUP2 0884 60 PUSH1 0x20 0886 01 ADD 0887 60 PUSH1 0x20 0889 82 DUP3 088A 02 MUL 088B 80 DUP1 088C 36 CALLDATASIZE 088D 83 DUP4 088E 37 CALLDATACOPY 088F 01 ADD 0890 90 SWAP1 0891 50 POP 0892 5B JUMPDEST 0893 50 POP 0894 92 SWAP3 0895 50 POP 0896 80 DUP1 0897 60 PUSH1 0x01 0899 60 PUSH1 0x01 089B 60 PUSH1 0x40 089D 1B SHL 089E 03 SUB 089F 81 DUP2 08A0 11 GT 08A1 15 ISZERO 08A2 61 PUSH2 0x08ad 08A5 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @088E memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0894 stack[-5] = stack[-2] // @0896 stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x08ad, if !(stack[-3] > (0x01 << 0x40) - 0x01) label_08A6: // Incoming jump from 0x08A5, if not !(stack[-3] > (0x01 << 0x40) - 0x01) // Incoming jump from 0x08A5, if not !(stack[-3] > (0x01 << 0x40) - 0x01) 08A6 61 PUSH2 0x08ad 08A9 61 PUSH2 0x190e 08AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @08A6 stack[0] = 0x08ad } // Block ends with unconditional jump to 0x190e label_08AD: // Incoming jump from 0x08A5, if !(stack[-3] > (0x01 << 0x40) - 0x01) // Incoming jump from 0x08A5, if !(stack[-3] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @08B0 memory[0x40:0x60] // @08B1 stack[-1] // } 08AD 5B JUMPDEST 08AE 60 PUSH1 0x40 08B0 51 MLOAD 08B1 90 SWAP1 08B2 80 DUP1 08B3 82 DUP3 08B4 52 MSTORE 08B5 80 DUP1 08B6 60 PUSH1 0x20 08B8 02 MUL 08B9 60 PUSH1 0x20 08BB 01 ADD 08BC 82 DUP3 08BD 01 ADD 08BE 60 PUSH1 0x40 08C0 52 MSTORE 08C1 80 DUP1 08C2 15 ISZERO 08C3 61 PUSH2 0x08e6 08C6 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @08B1 stack[-1] = memory[0x40:0x60] // @08B1 stack[0] = stack[-1] // @08B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @08C0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x08e6, if !stack[-1] label_08C7: // Incoming jump from 0x08C6, if not !stack[-1] // Inputs[1] { @08C7 stack[-2] } 08C7 81 DUP2 08C8 60 PUSH1 0x20 08CA 01 ADD 08CB 5B JUMPDEST 08CC 61 PUSH2 0x08d3 08CF 61 PUSH2 0x1793 08D2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08CA stack[0] = 0x20 + stack[-2] // @08CC stack[1] = 0x08d3 // } // Block ends with call to 0x1793, returns to 0x08D3 label_08D3: // Incoming return from call to 0x1793 at 0x08D2 // Incoming return from call to 0x1793 at 0x08D2 // Inputs[3] // { // @08D4 stack[-2] // @08D5 stack[-1] // @08D9 stack[-3] // } 08D3 5B JUMPDEST 08D4 81 DUP2 08D5 52 MSTORE 08D6 60 PUSH1 0x20 08D8 01 ADD 08D9 90 SWAP1 08DA 60 PUSH1 0x01 08DC 90 SWAP1 08DD 03 SUB 08DE 90 SWAP1 08DF 81 DUP2 08E0 61 PUSH2 0x08cb 08E3 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @08D5 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @08DE stack[-2] = 0x20 + stack[-2] // @08DE stack[-3] = stack[-3] - 0x01 // } // Block ends with conditional jump to 0x08cb, if stack[-3] - 0x01 label_08E4: // Incoming jump from 0x08E3, if not stack[-3] - 0x01 // Inputs[2] // { // @08E4 stack[-2] // @08E4 stack[-1] // } 08E4 90 SWAP1 08E5 50 POP // Stack delta = -1 // Outputs[1] { @08E4 stack[-2] = stack[-1] } // Block continues label_08E6: // Incoming jump from 0x08E5 // Incoming jump from 0x08C6, if !stack[-1] // Inputs[3] // { // @08E8 stack[-4] // @08E8 stack[-2] // @08ED stack[-3] // } 08E6 5B JUMPDEST 08E7 50 POP 08E8 91 SWAP2 08E9 50 POP 08EA 60 PUSH1 0x00 08EC 5B JUMPDEST 08ED 81 DUP2 08EE 81 DUP2 08EF 10 LT 08F0 15 ISZERO 08F1 61 PUSH2 0x09ac 08F4 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @08E8 stack[-4] = stack[-2] // @08EA stack[-2] = 0x00 // } // Block ends with conditional jump to 0x09ac, if !(0x00 < stack[-3]) label_08F5: // Incoming jump from 0x08F4, if not !(0x00 < stack[-3]) // Incoming jump from 0x08F4, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @08F8 stack[-7] // @08F9 stack[-1] // @08FB memory[stack[-7]:stack[-7] + 0x20] // } 08F5 61 PUSH2 0x0916 08F8 87 DUP8 08F9 82 DUP3 08FA 81 DUP2 08FB 51 MLOAD 08FC 81 DUP2 08FD 10 LT 08FE 61 PUSH2 0x0909 0901 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08F5 stack[0] = 0x0916 // @08F8 stack[1] = stack[-7] // @08F9 stack[2] = stack[-1] // } // Block ends with conditional call to 0x0909, returns to 0x0916, if stack[-1] < memory[stack[-7]:stack[-7] + 0x20] label_0902: // Incoming jump from 0x0901, if not stack[-1] < memory[stack[-7]:stack[-7] + 0x20] 0902 61 PUSH2 0x0909 0905 61 PUSH2 0x1ee2 0908 56 *JUMP // Stack delta = +1 // Outputs[1] { @0902 stack[0] = 0x0909 } // Block ends with unconditional jump to 0x1ee2 label_0909: // Incoming call from 0x0901, returns to 0x0916, if stack[-1] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @090C stack[-1] // @0910 stack[-2] // @0911 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0909 5B JUMPDEST 090A 60 PUSH1 0x20 090C 02 MUL 090D 60 PUSH1 0x20 090F 01 ADD 0910 01 ADD 0911 51 MLOAD 0912 61 PUSH2 0x1287 0915 56 *JUMP // Stack delta = -1 // Outputs[1] { @0911 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1287 label_0916: // Incoming return from call to 0x0909 at 0x0901 // Inputs[3] // { // @0917 stack[-10] // @0918 stack[-5] // @091A memory[stack[-10]:stack[-10] + 0x20] // } 0916 5B JUMPDEST 0917 89 DUP10 0918 85 DUP6 0919 81 DUP2 091A 51 MLOAD 091B 81 DUP2 091C 10 LT 091D 61 PUSH2 0x0928 0920 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0917 stack[0] = stack[-10] // @0918 stack[1] = stack[-5] // } // Block ends with conditional jump to 0x0928, if stack[-5] < memory[stack[-10]:stack[-10] + 0x20] label_0921: // Incoming jump from 0x0920, if not stack[-5] < memory[stack[-10]:stack[-10] + 0x20] 0921 61 PUSH2 0x0928 0924 61 PUSH2 0x1ee2 0927 56 *JUMP // Stack delta = +1 // Outputs[1] { @0921 stack[0] = 0x0928 } // Block ends with unconditional jump to 0x1ee2 label_0928: // Incoming jump from 0x0920, if stack[-5] < memory[stack[-10]:stack[-10] + 0x20] // Inputs[5] // { // @092B stack[-1] // @092F stack[-2] // @0930 stack[-11] // @0931 stack[-7] // @0933 memory[stack[-11]:stack[-11] + 0x20] // } 0928 5B JUMPDEST 0929 60 PUSH1 0x20 092B 02 MUL 092C 60 PUSH1 0x20 092E 01 ADD 092F 01 ADD 0930 89 DUP10 0931 86 DUP7 0932 81 DUP2 0933 51 MLOAD 0934 81 DUP2 0935 10 LT 0936 61 PUSH2 0x0941 0939 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @092F stack[-2] = 0x20 + 0x20 * stack[-1] + stack[-2] // @0930 stack[-1] = stack[-11] // @0931 stack[0] = stack[-7] // } // Block ends with conditional jump to 0x0941, if stack[-7] < memory[stack[-11]:stack[-11] + 0x20] label_093A: // Incoming jump from 0x0939, if not stack[-7] < memory[stack[-11]:stack[-11] + 0x20] 093A 61 PUSH2 0x0941 093D 61 PUSH2 0x1ee2 0940 56 *JUMP // Stack delta = +1 // Outputs[1] { @093A stack[0] = 0x0941 } // Block ends with unconditional jump to 0x1ee2 label_0941: // Incoming jump from 0x0939, if stack[-7] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[5] // { // @0944 stack[-1] // @0948 stack[-2] // @0949 stack[-11] // @094A stack[-8] // @094C memory[stack[-11]:stack[-11] + 0x20] // } 0941 5B JUMPDEST 0942 60 PUSH1 0x20 0944 02 MUL 0945 60 PUSH1 0x20 0947 01 ADD 0948 01 ADD 0949 89 DUP10 094A 87 DUP8 094B 81 DUP2 094C 51 MLOAD 094D 81 DUP2 094E 10 LT 094F 61 PUSH2 0x095a 0952 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0948 stack[-2] = 0x20 + 0x20 * stack[-1] + stack[-2] // @0949 stack[-1] = stack[-11] // @094A stack[0] = stack[-8] // } // Block ends with conditional jump to 0x095a, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20] label_0953: // Incoming jump from 0x0952, if not stack[-8] < memory[stack[-11]:stack[-11] + 0x20] 0953 61 PUSH2 0x095a 0956 61 PUSH2 0x1ee2 0959 56 *JUMP // Stack delta = +1 // Outputs[1] { @0953 stack[0] = 0x095a } // Block ends with unconditional jump to 0x1ee2 label_095A: // Incoming jump from 0x0952, if stack[-8] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[5] // { // @095D stack[-1] // @0961 stack[-2] // @0962 stack[-11] // @0963 stack[-9] // @0965 memory[stack[-11]:stack[-11] + 0x20] // } 095A 5B JUMPDEST 095B 60 PUSH1 0x20 095D 02 MUL 095E 60 PUSH1 0x20 0960 01 ADD 0961 01 ADD 0962 89 DUP10 0963 88 DUP9 0964 81 DUP2 0965 51 MLOAD 0966 81 DUP2 0967 10 LT 0968 61 PUSH2 0x0973 096B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0961 stack[-2] = 0x20 + 0x20 * stack[-1] + stack[-2] // @0962 stack[-1] = stack[-11] // @0963 stack[0] = stack[-9] // } // Block ends with conditional jump to 0x0973, if stack[-9] < memory[stack[-11]:stack[-11] + 0x20] label_096C: // Incoming jump from 0x096B, if not stack[-9] < memory[stack[-11]:stack[-11] + 0x20] 096C 61 PUSH2 0x0973 096F 61 PUSH2 0x1ee2 0972 56 *JUMP // Stack delta = +1 // Outputs[1] { @096C stack[0] = 0x0973 } // Block ends with unconditional jump to 0x1ee2 label_0973: // Incoming jump from 0x096B, if stack[-9] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[10] // { // @0976 stack[-1] // @0979 stack[-2] // @097E stack[-6] // @097F stack[-3] // @098A stack[-7] // @098D stack[-4] // @0990 stack[-8] // @0990 stack[-5] // @0995 stack[-9] // @099B stack[-10] // } 0973 5B JUMPDEST 0974 60 PUSH1 0x20 0976 90 SWAP1 0977 81 DUP2 0978 02 MUL 0979 91 SWAP2 097A 90 SWAP1 097B 91 SWAP2 097C 01 ADD 097D 01 ADD 097E 93 SWAP4 097F 90 SWAP1 0980 93 SWAP4 0981 52 MSTORE 0982 60 PUSH1 0x01 0984 60 PUSH1 0x01 0986 60 PUSH1 0xa0 0988 1B SHL 0989 03 SUB 098A 93 SWAP4 098B 84 DUP5 098C 16 AND 098D 90 SWAP1 098E 92 SWAP3 098F 52 MSTORE 0990 92 SWAP3 0991 82 DUP3 0992 16 AND 0993 90 SWAP1 0994 52 MSTORE 0995 91 SWAP2 0996 90 SWAP1 0997 91 SWAP2 0998 16 AND 0999 90 SWAP1 099A 52 MSTORE 099B 80 DUP1 099C 61 PUSH2 0x09a4 099F 81 DUP2 09A0 61 PUSH2 0x1f0e 09A3 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @0981 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-6] // @098F memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @0994 memory[stack[-4]:stack[-4] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-8] // @099A memory[stack[-5]:stack[-5] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-9] // @099B stack[-9] = stack[-10] // @099C stack[-8] = 0x09a4 // @099F stack[-7] = stack[-10] // } // Block ends with call to 0x1f0e, returns to 0x09A4 label_09A4: // Incoming return from call to 0x1F0E at 0x09A3 // Inputs[2] // { // @09A5 stack[-1] // @09A5 stack[-3] // } 09A4 5B JUMPDEST 09A5 91 SWAP2 09A6 50 POP 09A7 50 POP 09A8 61 PUSH2 0x08ec 09AB 56 *JUMP // Stack delta = -2 // Outputs[1] { @09A5 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x08ec label_09AC: // Incoming jump from 0x08F4, if !(0x00 < stack[-3]) // Incoming jump from 0x08F4, if !(stack[-1] < stack[-2]) // Inputs[6] // { // @09AF stack[-3] // @09AF stack[-5] // @09B0 stack[-7] // @09B2 stack[-4] // @09B2 stack[-6] // @09B3 stack[-8] // } 09AC 5B JUMPDEST 09AD 50 POP 09AE 50 POP 09AF 91 SWAP2 09B0 93 SWAP4 09B1 50 POP 09B2 91 SWAP2 09B3 93 SWAP4 09B4 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @09AF stack[-5] = stack[-3] // @09B0 stack[-7] = stack[-5] // @09B2 stack[-6] = stack[-4] // @09B3 stack[-8] = stack[-6] // } // Block ends with unconditional jump to stack[-8] label_09B5: // Incoming jump from 0x0350 // Inputs[4] // { // @09B9 stack[-3] // @09BA stack[-2] // @09BB stack[-1] // @09BE memory[0x40:0x60] // } 09B5 5B JUMPDEST 09B6 61 PUSH2 0x0765 09B9 83 DUP4 09BA 83 DUP4 09BB 83 DUP4 09BC 60 PUSH1 0x40 09BE 51 MLOAD 09BF 80 DUP1 09C0 60 PUSH1 0x20 09C2 01 ADD 09C3 60 PUSH1 0x40 09C5 52 MSTORE 09C6 80 DUP1 09C7 60 PUSH1 0x00 09C9 81 DUP2 09CA 52 MSTORE 09CB 50 POP 09CC 61 PUSH2 0x1136 09CF 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @09B6 stack[0] = 0x0765 // @09B9 stack[1] = stack[-3] // @09BA stack[2] = stack[-2] // @09BB stack[3] = stack[-1] // @09BE stack[4] = memory[0x40:0x60] // @09C5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @09CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1136, returns to 0x0765 label_09D0: // Incoming jump from 0x0363 // Inputs[2] // { // @09D4 storage[0x00] // @09D5 stack[-1] // } 09D0 5B JUMPDEST 09D1 60 PUSH1 0x00 09D3 80 DUP1 09D4 54 SLOAD 09D5 82 DUP3 09D6 10 LT 09D7 61 PUSH2 0x09df 09DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09D1 stack[0] = 0x00 } // Block ends with conditional jump to 0x09df, if stack[-1] < storage[0x00] label_09DB: // Incoming jump from 0x09DA, if not stack[-1] < storage[0x00] // Inputs[1] { @09DE memory[0x00:0x00] } 09DB 60 PUSH1 0x00 09DD 80 DUP1 09DE FD *REVERT // Stack delta = +0 // Outputs[1] { @09DE revert(memory[0x00:0x00]); } // Block terminates label_09DF: // Incoming jump from 0x09DA, if stack[-1] < storage[0x00] // Inputs[2] // { // @09E1 stack[-3] // @09E1 stack[-2] // } 09DF 5B JUMPDEST 09E0 50 POP 09E1 90 SWAP1 09E2 56 *JUMP // Stack delta = -2 // Outputs[1] { @09E1 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_09E3: // Incoming jump from 0x0376 // Inputs[1] { @09EC storage[0x00] } 09E3 5B JUMPDEST 09E4 60 PUSH1 0x00 09E6 80 DUP1 09E7 61 PUSH2 0x09ef 09EA 60 PUSH1 0x00 09EC 54 SLOAD 09ED 90 SWAP1 09EE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09E4 stack[0] = 0x00 // @09E6 stack[1] = 0x00 // @09ED stack[2] = storage[0x00] // } // Block ends with unconditional jump to 0x09ef label_09EF: // Incoming jump from 0x09EE // Inputs[7] // { // @09F8 stack[-4] // @0A07 memory[0x00:0x40] // @0A08 storage[keccak256(memory[0x00:0x40])] // @0A09 stack[-2] // @0A0B stack[-3] // @0A0B stack[-1] // @0A0F stack[-5] // } 09EF 5B JUMPDEST 09F0 60 PUSH1 0x01 09F2 60 PUSH1 0x01 09F4 60 PUSH1 0xa0 09F6 1B SHL 09F7 03 SUB 09F8 84 DUP5 09F9 16 AND 09FA 60 PUSH1 0x00 09FC 90 SWAP1 09FD 81 DUP2 09FE 52 MSTORE 09FF 60 PUSH1 0x02 0A01 60 PUSH1 0x20 0A03 52 MSTORE 0A04 60 PUSH1 0x40 0A06 90 SWAP1 0A07 20 SHA3 0A08 54 SLOAD 0A09 91 SWAP2 0A0A 50 POP 0A0B 91 SWAP2 0A0C 50 POP 0A0D 91 SWAP2 0A0E 50 POP 0A0F 91 SWAP2 0A10 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @09FE memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0A03 memory[0x20:0x40] = 0x02 // @0A0D stack[-4] = storage[keccak256(memory[0x00:0x40])] // @0A0F stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_0A11: // Incoming call from 0x14D9, returns to 0x14DA // Incoming call from 0x0672, returns to 0x0673 // Incoming call from 0x129C, returns to 0x129D // Incoming jump from 0x039E // Inputs[2] // { // @0A15 storage[0x00] // @0A16 stack[-1] // } 0A11 5B JUMPDEST 0A12 60 PUSH1 0x00 0A14 80 DUP1 0A15 54 SLOAD 0A16 82 DUP3 0A17 10 LT 0A18 61 PUSH2 0x0a20 0A1B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A12 stack[0] = 0x00 } // Block ends with conditional jump to 0x0a20, if stack[-1] < storage[0x00] label_0A1C: // Incoming jump from 0x0A1B, if not stack[-1] < storage[0x00] // Inputs[1] { @0A1F memory[0x00:0x00] } 0A1C 60 PUSH1 0x00 0A1E 80 DUP1 0A1F FD *REVERT // Stack delta = +0 // Outputs[1] { @0A1F revert(memory[0x00:0x00]); } // Block terminates label_0A20: // Incoming jump from 0x0A1B, if stack[-1] < storage[0x00] // Inputs[4] // { // @0A24 stack[-2] // @0A32 memory[0x00:0x40] // @0A34 storage[keccak256(memory[0x00:0x40]) + 0x01] // @0A3E stack[-3] // } 0A20 5B JUMPDEST 0A21 50 POP 0A22 60 PUSH1 0x00 0A24 90 SWAP1 0A25 81 DUP2 0A26 52 MSTORE 0A27 60 PUSH1 0x01 0A29 60 PUSH1 0x20 0A2B 81 DUP2 0A2C 90 SWAP1 0A2D 52 MSTORE 0A2E 60 PUSH1 0x40 0A30 90 SWAP1 0A31 91 SWAP2 0A32 20 SHA3 0A33 01 ADD 0A34 54 SLOAD 0A35 60 PUSH1 0x01 0A37 60 PUSH1 0x01 0A39 60 PUSH1 0xa0 0A3B 1B SHL 0A3C 03 SUB 0A3D 16 AND 0A3E 90 SWAP1 0A3F 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A26 memory[0x00:0x20] = stack[-2] // @0A2D memory[0x20:0x40] = 0x01 // @0A3E stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x01] // } // Block ends with unconditional jump to stack[-3] label_0A40: // Incoming jump from 0x03B1 // Inputs[1] { @0A4E stack[-3] } 0A40 5B JUMPDEST 0A41 60 PUSH1 0x60 0A43 80 DUP1 0A44 60 PUSH1 0x60 0A46 80 DUP1 0A47 60 PUSH1 0x60 0A49 60 PUSH1 0x00 0A4B 80 DUP1 0A4C 60 PUSH1 0x00 0A4E 8A DUP11 0A4F 11 GT 0A50 61 PUSH2 0x0a58 0A53 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0A41 stack[0] = 0x60 // @0A43 stack[1] = 0x60 // @0A44 stack[2] = 0x60 // @0A46 stack[3] = 0x60 // @0A47 stack[4] = 0x60 // @0A49 stack[5] = 0x00 // @0A4B stack[6] = 0x00 // } // Block ends with conditional jump to 0x0a58, if stack[-3] > 0x00 label_0A54: // Incoming jump from 0x0A53, if not stack[-3] > 0x00 // Inputs[1] { @0A57 memory[0x00:0x00] } 0A54 60 PUSH1 0x00 0A56 80 DUP1 0A57 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A57 revert(memory[0x00:0x00]); } // Block terminates label_0A58: // Incoming jump from 0x0A53, if stack[-3] > 0x00 // Inputs[2] // { // @0A5B storage[0x00] // @0A5C stack[-2] // } 0A58 5B JUMPDEST 0A59 60 PUSH1 0x00 0A5B 54 SLOAD 0A5C 91 SWAP2 0A5D 50 POP 0A5E 81 DUP2 0A5F 15 ISZERO 0A60 61 PUSH2 0x0b9a 0A63 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A5C stack[-2] = storage[0x00] } // Block ends with conditional jump to 0x0b9a, if !storage[0x00] label_0A64: // Incoming jump from 0x0A63, if not !storage[0x00] // Inputs[2] // { // @0A67 stack[-10] // @0A68 stack[-2] // } 0A64 61 PUSH2 0x0a6d 0A67 8A DUP11 0A68 83 DUP4 0A69 61 PUSH2 0x1f3f 0A6C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A64 stack[0] = 0x0a6d // @0A67 stack[1] = stack[-10] // @0A68 stack[2] = stack[-2] // } // Block ends with call to 0x1f3f, returns to 0x0A6D label_0A6D: // Incoming return from call to 0x1F3F at 0x0A6C // Inputs[1] { @0A6E stack[-1] } 0A6D 5B JUMPDEST 0A6E 15 ISZERO 0A6F 61 PUSH2 0x0a79 0A72 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a79, if !stack[-1] label_0A73: // Incoming jump from 0x0A72, if not !stack[-1] 0A73 60 PUSH1 0x01 0A75 61 PUSH2 0x0a7c 0A78 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A73 stack[0] = 0x01 } // Block ends with unconditional jump to 0x0a7c label_0A79: // Incoming jump from 0x0A72, if !stack[-1] // Inputs[2] // { // @0A83 stack[-10] // @0A84 stack[-2] // } 0A79 5B JUMPDEST 0A7A 60 PUSH1 0x00 0A7C 5B JUMPDEST 0A7D 60 PUSH1 0xff 0A7F 16 AND 0A80 61 PUSH2 0x0a89 0A83 8B DUP12 0A84 84 DUP5 0A85 61 PUSH2 0x1f53 0A88 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A7F stack[0] = 0xff & 0x00 // @0A80 stack[1] = 0x0a89 // @0A83 stack[2] = stack[-10] // @0A84 stack[3] = stack[-2] // } // Block ends with call to 0x1f53, returns to 0x0A89 label_0A89: // Incoming return from call to 0x1F53 at 0x0A88 // Incoming return from call to 0x1F53 at 0x0A88 // Inputs[2] // { // @0A8D stack[-2] // @0A8E stack[-1] // } 0A89 5B JUMPDEST 0A8A 61 PUSH2 0x0a93 0A8D 91 SWAP2 0A8E 90 SWAP1 0A8F 61 PUSH2 0x1f67 0A92 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0A8D stack[-2] = 0x0a93 // @0A8E stack[-1] = stack[-2] // @0A8E stack[0] = stack[-1] // } // Block ends with call to 0x1f67, returns to 0x0A93 label_0A93: // Incoming return from call to 0x1F67 at 0x0A92 // Inputs[3] // { // @0A94 stack[-1] // @0A94 stack[-2] // @0A97 stack[-10] // } 0A93 5B JUMPDEST 0A94 90 SWAP1 0A95 50 POP 0A96 80 DUP1 0A97 89 DUP10 0A98 10 LT 0A99 61 PUSH2 0x0aa1 0A9C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0A94 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0aa1, if stack[-10] < stack[-1] label_0A9D: // Incoming jump from 0x0A9C, if not stack[-10] < stack[-1] // Inputs[1] { @0AA0 memory[0x00:0x00] } 0A9D 60 PUSH1 0x00 0A9F 80 DUP1 0AA0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AA0 revert(memory[0x00:0x00]); } // Block terminates label_0AA1: // Incoming jump from 0x0A9C, if stack[-10] < stack[-1] // Inputs[2] // { // @0AA7 stack[-9] // @0AA8 stack[-10] // } 0AA1 5B JUMPDEST 0AA2 60 PUSH1 0x00 0AA4 61 PUSH2 0x0aad 0AA7 8A DUP11 0AA8 8C DUP13 0AA9 61 PUSH2 0x1f7f 0AAC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AA2 stack[0] = 0x00 // @0AA4 stack[1] = 0x0aad // @0AA7 stack[2] = stack[-9] // @0AA8 stack[3] = stack[-10] // } // Block ends with call to 0x1f7f, returns to 0x0AAD label_0AAD: // Incoming return from call to 0x1F7F at 0x0AAC // Inputs[3] // { // @0AAE stack[-1] // @0AAE stack[-2] // @0AB5 stack[-3] // } 0AAD 5B JUMPDEST 0AAE 90 SWAP1 0AAF 50 POP 0AB0 61 PUSH2 0x0aba 0AB3 60 PUSH1 0x01 0AB5 83 DUP4 0AB6 61 PUSH2 0x1f9e 0AB9 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0AAE stack[-2] = stack[-1] // @0AB0 stack[-1] = 0x0aba // @0AB3 stack[0] = 0x01 // @0AB5 stack[1] = stack[-3] // } // Block ends with call to 0x1f9e, returns to 0x0ABA label_0ABA: // Incoming return from call to 0x1F9E at 0x0AB9 // Inputs[2] // { // @0ABB stack[-11] // @0ABC stack[-1] // } 0ABA 5B JUMPDEST 0ABB 8A DUP11 0ABC 14 EQ 0ABD 80 DUP1 0ABE 15 ISZERO 0ABF 61 PUSH2 0x0ad0 0AC2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0ABC stack[-1] = stack[-11] == stack[-1] } // Block ends with conditional jump to 0x0ad0, if !(stack[-11] == stack[-1]) label_0AC3: // Incoming jump from 0x0AC2, if not !(stack[-11] == stack[-1]) // Inputs[2] // { // @0AC7 stack[-12] // @0AC8 stack[-4] // } 0AC3 50 POP 0AC4 61 PUSH2 0x0acd 0AC7 8B DUP12 0AC8 84 DUP5 0AC9 61 PUSH2 0x1f3f 0ACC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AC4 stack[-1] = 0x0acd // @0AC7 stack[0] = stack[-12] // @0AC8 stack[1] = stack[-4] // } // Block ends with call to 0x1f3f, returns to 0x0ACD label_0ACD: // Incoming return from call to 0x1F3F at 0x0ACC // Inputs[1] { @0ACE stack[-1] } 0ACD 5B JUMPDEST 0ACE 15 ISZERO 0ACF 15 ISZERO // Stack delta = +0 // Outputs[1] { @0ACF stack[-1] = !!stack[-1] } // Block continues label_0AD0: // Incoming jump from 0x0AC2, if !(stack[-11] == stack[-1]) // Incoming jump from 0x0ACF // Inputs[1] { @0AD1 stack[-1] } 0AD0 5B JUMPDEST 0AD1 15 ISZERO 0AD2 61 PUSH2 0x0ae2 0AD5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ae2, if !stack[-1] label_0AD6: // Incoming jump from 0x0AD5, if not !stack[-1] // Inputs[2] // { // @0AD9 stack[-11] // @0ADA stack[-3] // } 0AD6 61 PUSH2 0x0adf 0AD9 8B DUP12 0ADA 84 DUP5 0ADB 61 PUSH2 0x1f3f 0ADE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AD6 stack[0] = 0x0adf // @0AD9 stack[1] = stack[-11] // @0ADA stack[2] = stack[-3] // } // Block ends with call to 0x1f3f, returns to 0x0ADF label_0ADF: // Incoming return from call to 0x1F3F at 0x0ADE // Inputs[2] // { // @0AE0 stack[-1] // @0AE0 stack[-12] // } 0ADF 5B JUMPDEST 0AE0 9A SWAP11 0AE1 50 POP // Stack delta = -1 // Outputs[1] { @0AE0 stack[-12] = stack[-1] } // Block continues label_0AE2: // Incoming jump from 0x0AE1 // Incoming jump from 0x0AD5, if !stack[-1] // Inputs[1] { @0AE3 stack[-11] } 0AE2 5B JUMPDEST 0AE3 8A DUP11 0AE4 60 PUSH1 0x01 0AE6 60 PUSH1 0x01 0AE8 60 PUSH1 0x40 0AEA 1B SHL 0AEB 03 SUB 0AEC 81 DUP2 0AED 11 GT 0AEE 15 ISZERO 0AEF 61 PUSH2 0x0afa 0AF2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AE3 stack[0] = stack[-11] } // Block ends with conditional jump to 0x0afa, if !(stack[-11] > (0x01 << 0x40) - 0x01) label_0AF3: // Incoming jump from 0x0AF2, if not !(stack[-11] > (0x01 << 0x40) - 0x01) 0AF3 61 PUSH2 0x0afa 0AF6 61 PUSH2 0x190e 0AF9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AF3 stack[0] = 0x0afa } // Block ends with unconditional jump to 0x190e label_0AFA: // Incoming jump from 0x0AF2, if !(stack[-11] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0AFD memory[0x40:0x60] // @0AFE stack[-1] // } 0AFA 5B JUMPDEST 0AFB 60 PUSH1 0x40 0AFD 51 MLOAD 0AFE 90 SWAP1 0AFF 80 DUP1 0B00 82 DUP3 0B01 52 MSTORE 0B02 80 DUP1 0B03 60 PUSH1 0x20 0B05 02 MUL 0B06 60 PUSH1 0x20 0B08 01 ADD 0B09 82 DUP3 0B0A 01 ADD 0B0B 60 PUSH1 0x40 0B0D 52 MSTORE 0B0E 80 DUP1 0B0F 15 ISZERO 0B10 61 PUSH2 0x0b23 0B13 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0AFE stack[-1] = memory[0x40:0x60] // @0AFE stack[0] = stack[-1] // @0B01 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B0D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0b23, if !stack[-1] label_0B14: // Incoming jump from 0x0B13, if not !stack[-1] // Inputs[6] // { // @0B14 stack[-2] // @0B1A stack[-1] // @0B1D msg.data.length // @0B1F msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0B25 stack[-10] // @0B2A stack[-13] // } 0B14 81 DUP2 0B15 60 PUSH1 0x20 0B17 01 ADD 0B18 60 PUSH1 0x20 0B1A 82 DUP3 0B1B 02 MUL 0B1C 80 DUP1 0B1D 36 CALLDATASIZE 0B1E 83 DUP4 0B1F 37 CALLDATACOPY 0B20 01 ADD 0B21 90 SWAP1 0B22 50 POP 0B23 5B JUMPDEST 0B24 50 POP 0B25 97 SWAP8 0B26 50 POP 0B27 60 PUSH1 0x00 0B29 5B JUMPDEST 0B2A 8B DUP12 0B2B 81 DUP2 0B2C 10 LT 0B2D 15 ISZERO 0B2E 61 PUSH2 0x0b93 0B31 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0B1F memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0B25 stack[-10] = stack[-2] // @0B27 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0b93, if !(0x00 < stack[-13]) label_0B32: // Incoming jump from 0x0B31, if not !(0x00 < stack[-13]) // Incoming jump from 0x0B31, if not !(0x00 < stack[-13]) // Inputs[1] { @0B35 stack[-10] } 0B32 61 PUSH2 0x0b64 0B35 8A DUP11 0B36 61 PUSH2 0x0b5a 0B39 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B32 stack[0] = 0x0b64 } // Block ends with conditional jump to 0x0b5a, if stack[-10] label_0B3A: // Incoming jump from 0x0B39, if not stack[-10] // Inputs[3] // { // @0B3C stack[-2] // @0B40 stack[-3] // @0B41 stack[-5] // } 0B3A 60 PUSH1 0x01 0B3C 82 DUP3 0B3D 61 PUSH2 0x0b46 0B40 85 DUP6 0B41 88 DUP9 0B42 61 PUSH2 0x1f9e 0B45 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0B3A stack[0] = 0x01 // @0B3C stack[1] = stack[-2] // @0B3D stack[2] = 0x0b46 // @0B40 stack[3] = stack[-3] // @0B41 stack[4] = stack[-5] // } // Block ends with call to 0x1f9e, returns to 0x0B46 label_0B46: // Incoming return from call to 0x1F9E at 0x0B45 // Inputs[2] // { // @0B4A stack[-2] // @0B4B stack[-1] // } 0B46 5B JUMPDEST 0B47 61 PUSH2 0x0b50 0B4A 91 SWAP2 0B4B 90 SWAP1 0B4C 61 PUSH2 0x1f9e 0B4F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0B4A stack[-2] = 0x0b50 // @0B4B stack[-1] = stack[-2] // @0B4B stack[0] = stack[-1] // } // Block ends with call to 0x1f9e, returns to 0x0B50 label_0B50: // Incoming return from call to 0x1F9E at 0x0B4F // Inputs[2] // { // @0B54 stack[-2] // @0B55 stack[-1] // } 0B50 5B JUMPDEST 0B51 61 PUSH2 0x035f 0B54 91 SWAP2 0B55 90 SWAP1 0B56 61 PUSH2 0x1f9e 0B59 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0B54 stack[-2] = 0x035f // @0B55 stack[-1] = stack[-2] // @0B55 stack[0] = stack[-1] // } // Block ends with call to 0x1f9e, returns to 0x035F label_0B5A: // Incoming jump from 0x0B39, if stack[-10] // Inputs[2] // { // @0B5E stack[-2] // @0B5F stack[-3] // } 0B5A 5B JUMPDEST 0B5B 61 PUSH2 0x035f 0B5E 82 DUP3 0B5F 84 DUP5 0B60 61 PUSH2 0x1f67 0B63 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B5B stack[0] = 0x035f // @0B5E stack[1] = stack[-2] // @0B5F stack[2] = stack[-3] // } // Block ends with call to 0x1f67, returns to 0x035F 0B64 5B JUMPDEST 0B65 89 DUP10 0B66 82 DUP3 0B67 81 DUP2 0B68 51 MLOAD 0B69 81 DUP2 0B6A 10 LT 0B6B 61 PUSH2 0x0b76 0B6E 57 *JUMPI 0B6F 61 PUSH2 0x0b76 0B72 61 PUSH2 0x1ee2 0B75 56 *JUMP 0B76 5B JUMPDEST 0B77 60 PUSH1 0x20 0B79 90 SWAP1 0B7A 81 DUP2 0B7B 02 MUL 0B7C 91 SWAP2 0B7D 90 SWAP1 0B7E 91 SWAP2 0B7F 01 ADD 0B80 01 ADD 0B81 52 MSTORE 0B82 80 DUP1 0B83 61 PUSH2 0x0b8b 0B86 81 DUP2 0B87 61 PUSH2 0x1f0e 0B8A 56 *JUMP 0B8B 5B JUMPDEST 0B8C 91 SWAP2 0B8D 50 POP 0B8E 50 POP 0B8F 61 PUSH2 0x0b29 0B92 56 *JUMP label_0B93: // Incoming jump from 0x0B31, if !(0x00 < stack[-13]) // Incoming jump from 0x0B31, if !(0x00 < stack[-13]) 0B93 5B JUMPDEST 0B94 50 POP 0B95 50 POP 0B96 61 PUSH2 0x0bae 0B99 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x0bae label_0B9A: // Incoming jump from 0x0A63, if !storage[0x00] // Inputs[2] // { // @0B9F memory[0x40:0x60] // @0BAC stack[-7] // } 0B9A 5B JUMPDEST 0B9B 50 POP 0B9C 60 PUSH1 0x40 0B9E 80 DUP1 0B9F 51 MLOAD 0BA0 60 PUSH1 0x00 0BA2 80 DUP1 0BA3 82 DUP3 0BA4 52 MSTORE 0BA5 60 PUSH1 0x20 0BA7 82 DUP3 0BA8 01 ADD 0BA9 90 SWAP1 0BAA 92 SWAP3 0BAB 52 MSTORE 0BAC 96 SWAP7 0BAD 50 POP 0BAE 5B JUMPDEST 0BAF 61 PUSH2 0x0bb7 0BB2 87 DUP8 0BB3 61 PUSH2 0x07bd 0BB6 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0BA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0BAA stack[-1] = 0x00 // @0BAB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0BAC stack[-7] = memory[0x40:0x60] // @0BAF stack[0] = 0x0bb7 // @0BB2 stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x07bd, returns to 0x0BB7 label_0BB7: // Incoming return from call to 0x07BD at 0x0BB6 // Incoming return from call to 0x07BD at 0x0BB6 // Inputs[14] // { // @0BB8 stack[-1] // @0BB8 stack[-11] // @0BB9 stack[-15] // @0BBA stack[-4] // @0BBB stack[-14] // @0BBD stack[-3] // @0BBD stack[-2] // @0BBE stack[-13] // @0BC0 stack[-12] // @0BC2 stack[-6] // @0BC3 stack[-10] // @0BC5 stack[-9] // @0BC5 stack[-5] // @0BC7 stack[-8] // } 0BB7 5B JUMPDEST 0BB8 99 SWAP10 0BB9 9D SWAP14 0BBA 92 SWAP3 0BBB 9C SWAP13 0BBC 50 POP 0BBD 90 SWAP1 0BBE 9A SWAP11 0BBF 50 POP 0BC0 98 SWAP9 0BC1 50 POP 0BC2 91 SWAP2 0BC3 95 SWAP6 0BC4 50 POP 0BC5 93 SWAP4 0BC6 50 POP 0BC7 91 SWAP2 0BC8 50 POP 0BC9 50 POP 0BCA 56 *JUMP // Stack delta = -8 // Outputs[7] // { // @0BB8 stack[-11] = stack[-1] // @0BB9 stack[-15] = stack[-11] // @0BBB stack[-14] = stack[-4] // @0BBE stack[-13] = stack[-3] // @0BC0 stack[-12] = stack[-2] // @0BC3 stack[-10] = stack[-6] // @0BC5 stack[-9] = stack[-5] // } // Block ends with unconditional jump to stack[-15] label_0BCB: // Incoming call from 0x1050, returns to 0x1051 // Incoming jump from 0x0422 // Inputs[2] // { // @0BCF storage[0x00] // @0BD0 stack[-1] // } 0BCB 5B JUMPDEST 0BCC 60 PUSH1 0x00 0BCE 80 DUP1 0BCF 54 SLOAD 0BD0 82 DUP3 0BD1 10 LT 0BD2 61 PUSH2 0x0bda 0BD5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BCC stack[0] = 0x00 } // Block ends with conditional jump to 0x0bda, if stack[-1] < storage[0x00] label_0BD6: // Incoming jump from 0x0BD5, if not stack[-1] < storage[0x00] // Inputs[1] { @0BD9 memory[0x00:0x00] } 0BD6 60 PUSH1 0x00 0BD8 80 DUP1 0BD9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BD9 revert(memory[0x00:0x00]); } // Block terminates label_0BDA: // Incoming jump from 0x0BD5, if stack[-1] < storage[0x00] // Inputs[4] // { // @0BDE stack[-2] // @0BE9 memory[0x00:0x40] // @0BED storage[0x03 + keccak256(memory[0x00:0x40])] // @0BFE stack[-3] // } 0BDA 5B JUMPDEST 0BDB 50 POP 0BDC 60 PUSH1 0x00 0BDE 90 SWAP1 0BDF 81 DUP2 0BE0 52 MSTORE 0BE1 60 PUSH1 0x01 0BE3 60 PUSH1 0x20 0BE5 52 MSTORE 0BE6 60 PUSH1 0x40 0BE8 90 SWAP1 0BE9 20 SHA3 0BEA 60 PUSH1 0x03 0BEC 01 ADD 0BED 54 SLOAD 0BEE 60 PUSH1 0x01 0BF0 60 PUSH1 0x80 0BF2 1B SHL 0BF3 90 SWAP1 0BF4 04 DIV 0BF5 60 PUSH1 0x01 0BF7 60 PUSH1 0x01 0BF9 60 PUSH1 0x80 0BFB 1B SHL 0BFC 03 SUB 0BFD 16 AND 0BFE 90 SWAP1 0BFF 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0BE0 memory[0x00:0x20] = stack[-2] // @0BE5 memory[0x20:0x40] = 0x01 // @0BFE stack[-3] = (0x01 << 0x80) - 0x01 & storage[0x03 + keccak256(memory[0x00:0x40])] / (0x01 << 0x80) // } // Block ends with unconditional jump to stack[-3] label_0C00: // Incoming jump from 0x0435 // Inputs[3] // { // @0C09 stack[-1] // @0C18 memory[0x00:0x40] // @0C1C storage[0x04 + keccak256(memory[0x00:0x40])] // } 0C00 5B JUMPDEST 0C01 60 PUSH1 0x01 0C03 60 PUSH1 0x01 0C05 60 PUSH1 0xa0 0C07 1B SHL 0C08 03 SUB 0C09 81 DUP2 0C0A 16 AND 0C0B 60 PUSH1 0x00 0C0D 90 SWAP1 0C0E 81 DUP2 0C0F 52 MSTORE 0C10 60 PUSH1 0x02 0C12 60 PUSH1 0x20 0C14 52 MSTORE 0C15 60 PUSH1 0x40 0C17 81 DUP2 0C18 20 SHA3 0C19 60 PUSH1 0x04 0C1B 01 ADD 0C1C 54 SLOAD 0C1D 80 DUP1 0C1E 61 PUSH2 0x0c26 0C21 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0C0D stack[0] = 0x00 // @0C0F memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0C14 memory[0x20:0x40] = 0x02 // @0C1C stack[1] = storage[0x04 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0c26, if storage[0x04 + keccak256(memory[0x00:0x40])] label_0C22: // Incoming jump from 0x0C21, if not storage[0x04 + keccak256(memory[0x00:0x40])] // Inputs[1] { @0C25 memory[0x00:0x00] } 0C22 60 PUSH1 0x00 0C24 80 DUP1 0C25 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C25 revert(memory[0x00:0x00]); } // Block terminates label_0C26: // Incoming jump from 0x0C21, if storage[0x04 + keccak256(memory[0x00:0x40])] // Inputs[1] { @0C2C stack[-1] } 0C26 5B JUMPDEST 0C27 61 PUSH2 0x0c31 0C2A 60 PUSH1 0x01 0C2C 82 DUP3 0C2D 61 PUSH2 0x1f9e 0C30 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C27 stack[0] = 0x0c31 // @0C2A stack[1] = 0x01 // @0C2C stack[2] = stack[-1] // } // Block ends with call to 0x1f9e, returns to 0x0C31 label_0C31: // Incoming return from call to 0x1817 at 0x1855 // Incoming return from call to 0x1F9E at 0x0C30 // Incoming return from call to 0x17B1 at 0x17E6 // Incoming return from call to 0x186F at 0x18CC // Incoming return from call to 0x17B1 at 0x200E // Inputs[3] // { // @0C32 stack[-1] // @0C32 stack[-5] // @0C33 stack[-4] // } 0C31 5B JUMPDEST 0C32 93 SWAP4 0C33 92 SWAP3 0C34 50 POP 0C35 50 POP 0C36 50 POP 0C37 56 *JUMP // Stack delta = -4 // Outputs[1] { @0C32 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0C38: // Incoming call from 0x044E, returns to 0x026C // Inputs[6] // { // @0C3B storage[0x03] // @0C3F memory[0x40:0x60] // @0C4B memory[0x40:0x60] // @0C70 msg.gas // @0C71 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04] // @0C71 address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // } 0C38 5B JUMPDEST 0C39 60 PUSH1 0x03 0C3B 54 SLOAD 0C3C 60 PUSH1 0x40 0C3E 80 DUP1 0C3F 51 MLOAD 0C40 63 PUSH4 0x95d89b41 0C45 60 PUSH1 0xe0 0C47 1B SHL 0C48 81 DUP2 0C49 52 MSTORE 0C4A 90 SWAP1 0C4B 51 MLOAD 0C4C 60 PUSH1 0x60 0C4E 92 SWAP3 0C4F 60 PUSH1 0x01 0C51 60 PUSH1 0x01 0C53 60 PUSH1 0xa0 0C55 1B SHL 0C56 03 SUB 0C57 16 AND 0C58 91 SWAP2 0C59 63 PUSH4 0x95d89b41 0C5E 91 SWAP2 0C5F 60 PUSH1 0x04 0C61 80 DUP1 0C62 83 DUP4 0C63 01 ADD 0C64 92 SWAP3 0C65 60 PUSH1 0x00 0C67 92 SWAP3 0C68 91 SWAP2 0C69 90 SWAP1 0C6A 82 DUP3 0C6B 90 SWAP1 0C6C 03 SUB 0C6D 01 ADD 0C6E 81 DUP2 0C6F 86 DUP7 0C70 5A GAS 0C71 FA STATICCALL 0C72 15 ISZERO 0C73 80 DUP1 0C74 15 ISZERO 0C75 61 PUSH2 0x060f 0C78 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0C49 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x95d89b41 << 0xe0 // @0C4E stack[0] = 0x60 // @0C58 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @0C5E stack[2] = 0x95d89b41 // @0C64 stack[3] = memory[0x40:0x60] + 0x04 // @0C71 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // @0C72 stack[4] = !address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // } // Block ends with conditional jump to 0x060f, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) label_0C79: // Incoming jump from 0x0C78, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x04]) // Inputs[4] // { // @0C79 returndata.length // @0C7D returndata[0x00:0x00 + returndata.length] // @0C7E returndata.length // @0C81 memory[0x00:0x00 + returndata.length] // } 0C79 3D RETURNDATASIZE 0C7A 60 PUSH1 0x00 0C7C 80 DUP1 0C7D 3E RETURNDATACOPY 0C7E 3D RETURNDATASIZE 0C7F 60 PUSH1 0x00 0C81 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C7D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C81 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C82: // Incoming jump from 0x0461 // Inputs[10] // { // @0C83 msg.sender // @0C94 memory[0x00:0x40] // @0C9D stack[-2] // @0CA9 memory[0x00:0x40] // @0CAB storage[keccak256(memory[0x00:0x40])] // @0CB0 stack[-1] // @0CBA memory[0x40:0x60] // @0CE6 memory[0x40:0x60] // @0CEB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0CEE stack[-3] // } 0C82 5B JUMPDEST 0C83 33 CALLER 0C84 60 PUSH1 0x00 0C86 81 DUP2 0C87 81 DUP2 0C88 52 MSTORE 0C89 60 PUSH1 0x02 0C8B 60 PUSH1 0x20 0C8D 81 DUP2 0C8E 81 DUP2 0C8F 52 MSTORE 0C90 60 PUSH1 0x40 0C92 80 DUP1 0C93 84 DUP5 0C94 20 SHA3 0C95 60 PUSH1 0x01 0C97 60 PUSH1 0x01 0C99 60 PUSH1 0xa0 0C9B 1B SHL 0C9C 03 SUB 0C9D 88 DUP9 0C9E 16 AND 0C9F 80 DUP1 0CA0 86 DUP7 0CA1 52 MSTORE 0CA2 93 SWAP4 0CA3 01 ADD 0CA4 82 DUP3 0CA5 52 MSTORE 0CA6 92 SWAP3 0CA7 83 DUP4 0CA8 90 SWAP1 0CA9 20 SHA3 0CAA 80 DUP1 0CAB 54 SLOAD 0CAC 60 PUSH1 0xff 0CAE 19 NOT 0CAF 16 AND 0CB0 86 DUP7 0CB1 15 ISZERO 0CB2 15 ISZERO 0CB3 90 SWAP1 0CB4 81 DUP2 0CB5 17 OR 0CB6 90 SWAP1 0CB7 91 SWAP2 0CB8 55 SSTORE 0CB9 92 SWAP3 0CBA 51 MLOAD 0CBB 92 SWAP3 0CBC 83 DUP4 0CBD 52 MSTORE 0CBE 90 SWAP1 0CBF 92 SWAP3 0CC0 91 SWAP2 0CC1 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0CE2 91 SWAP2 0CE3 01 ADD 0CE4 60 PUSH1 0x40 0CE6 51 MLOAD 0CE7 80 DUP1 0CE8 91 SWAP2 0CE9 03 SUB 0CEA 90 SWAP1 0CEB A3 LOG3 0CEC 50 POP 0CED 50 POP 0CEE 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0C88 memory[0x00:0x20] = msg.sender // @0C8F memory[0x20:0x40] = 0x02 // @0CA1 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0CA5 memory[0x20:0x40] = 0x02 + keccak256(memory[0x00:0x40]) // @0CB8 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0CBD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0CEB 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_0CEF: // Incoming jump from 0x0474 // Incoming call from 0x107A, returns to 0x107B // Inputs[2] // { // @0CF3 storage[0x00] // @0CF4 stack[-1] // } 0CEF 5B JUMPDEST 0CF0 60 PUSH1 0x00 0CF2 80 DUP1 0CF3 54 SLOAD 0CF4 82 DUP3 0CF5 10 LT 0CF6 61 PUSH2 0x0cfe 0CF9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CF0 stack[0] = 0x00 } // Block ends with conditional jump to 0x0cfe, if stack[-1] < storage[0x00] label_0CFA: // Incoming jump from 0x0CF9, if not stack[-1] < storage[0x00] // Inputs[1] { @0CFD memory[0x00:0x00] } 0CFA 60 PUSH1 0x00 0CFC 80 DUP1 0CFD FD *REVERT // Stack delta = +0 // Outputs[1] { @0CFD revert(memory[0x00:0x00]); } // Block terminates label_0CFE: // Incoming jump from 0x0CF9, if stack[-1] < storage[0x00] // Inputs[4] // { // @0D02 stack[-2] // @0D0D memory[0x00:0x40] // @0D11 storage[0x05 + keccak256(memory[0x00:0x40])] // @0D1B stack[-3] // } 0CFE 5B JUMPDEST 0CFF 50 POP 0D00 60 PUSH1 0x00 0D02 90 SWAP1 0D03 81 DUP2 0D04 52 MSTORE 0D05 60 PUSH1 0x01 0D07 60 PUSH1 0x20 0D09 52 MSTORE 0D0A 60 PUSH1 0x40 0D0C 90 SWAP1 0D0D 20 SHA3 0D0E 60 PUSH1 0x05 0D10 01 ADD 0D11 54 SLOAD 0D12 60 PUSH1 0x01 0D14 60 PUSH1 0x01 0D16 60 PUSH1 0x80 0D18 1B SHL 0D19 03 SUB 0D1A 16 AND 0D1B 90 SWAP1 0D1C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0D04 memory[0x00:0x20] = stack[-2] // @0D09 memory[0x20:0x40] = 0x01 // @0D1B stack[-3] = (0x01 << 0x80) - 0x01 & storage[0x05 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0D1D: // Incoming jump from 0x0487 // Inputs[2] // { // @0D20 storage[0x04] // @0D2A msg.sender // } 0D1D 5B JUMPDEST 0D1E 60 PUSH1 0x04 0D20 54 SLOAD 0D21 60 PUSH1 0x01 0D23 60 PUSH1 0x01 0D25 60 PUSH1 0xa0 0D27 1B SHL 0D28 03 SUB 0D29 16 AND 0D2A 33 CALLER 0D2B 14 EQ 0D2C 61 PUSH2 0x0d34 0D2F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d34, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0D30: // Incoming jump from 0x0D2F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0D33 memory[0x00:0x00] } 0D30 60 PUSH1 0x00 0D32 80 DUP1 0D33 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D33 revert(memory[0x00:0x00]); } // Block terminates label_0D34: // Incoming jump from 0x0D2F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0D38 storage[0x00] } 0D34 5B JUMPDEST 0D35 60 PUSH1 0x00 0D37 80 DUP1 0D38 54 SLOAD 0D39 81 DUP2 0D3A 80 DUP1 0D3B 61 PUSH2 0x0d43 0D3E 83 DUP4 0D3F 61 PUSH2 0x1f0e 0D42 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0D35 stack[0] = 0x00 // @0D38 stack[1] = storage[0x00] // @0D39 stack[2] = 0x00 // @0D3A stack[3] = 0x00 // @0D3B stack[4] = 0x0d43 // @0D3E stack[5] = storage[0x00] // } // Block ends with call to 0x1f0e, returns to 0x0D43 label_0D43: // Incoming return from call to 0x1F0E at 0x0D42 // Inputs[6] // { // @0D44 stack[-1] // @0D44 stack[-3] // @0D45 stack[-2] // @0D48 stack[-5] // @0D48 stack[-4] // @0D4F storage[0x00] // } 0D43 5B JUMPDEST 0D44 91 SWAP2 0D45 90 SWAP1 0D46 50 POP 0D47 55 SSTORE 0D48 90 SWAP1 0D49 50 POP 0D4A 61 PUSH2 0x0d52 0D4D 60 PUSH1 0x00 0D4F 54 SLOAD 0D50 90 SWAP1 0D51 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0D47 storage[stack[-3]] = stack[-1] // @0D48 stack[-5] = stack[-4] // @0D50 stack[-4] = storage[0x00] // } // Block ends with unconditional jump to 0x0d52 label_0D52: // Incoming jump from 0x0D51 // Inputs[23] // { // @0D5A stack[-10] // @0D7A memory[0x00:0x40] // @0D7E stack[-1] // @0D8A stack[-2] // @0D98 memory[0x00:0x40] // @0DA7 storage[0x00 + keccak256(memory[0x00:0x40])] // @0DD0 storage[0x01 + keccak256(memory[0x00:0x40])] // @0DED stack[-9] // @0DF9 storage[0x03 + keccak256(memory[0x00:0x40])] // @0E16 stack[-8] // @0E22 storage[0x03 + keccak256(memory[0x00:0x40])] // @0E3F stack[-7] // @0E4B storage[0x04 + keccak256(memory[0x00:0x40])] // @0E68 stack[-6] // @0E74 storage[0x04 + keccak256(memory[0x00:0x40])] // @0E91 stack[-5] // @0E9D storage[0x05 + keccak256(memory[0x00:0x40])] // @0EBA stack[-4] // @0EC6 storage[0x05 + keccak256(memory[0x00:0x40])] // @0EE3 stack[-3] // @0EEF storage[0x05 + keccak256(memory[0x00:0x40])] // @0F34 memory[0x00:0x40] // @0F3B storage[0x00 + keccak256(memory[0x00:0x40])] // } 0D52 5B JUMPDEST 0D53 60 PUSH1 0x00 0D55 60 PUSH1 0x02 0D57 01 ADD 0D58 60 PUSH1 0x00 0D5A 8B DUP12 0D5B 60 PUSH1 0x01 0D5D 60 PUSH1 0x01 0D5F 60 PUSH1 0xa0 0D61 1B SHL 0D62 03 SUB 0D63 16 AND 0D64 60 PUSH1 0x01 0D66 60 PUSH1 0x01 0D68 60 PUSH1 0xa0 0D6A 1B SHL 0D6B 03 SUB 0D6C 16 AND 0D6D 81 DUP2 0D6E 52 MSTORE 0D6F 60 PUSH1 0x20 0D71 01 ADD 0D72 90 SWAP1 0D73 81 DUP2 0D74 52 MSTORE 0D75 60 PUSH1 0x20 0D77 01 ADD 0D78 60 PUSH1 0x00 0D7A 20 SHA3 0D7B 60 PUSH1 0x04 0D7D 01 ADD 0D7E 81 DUP2 0D7F 90 SWAP1 0D80 55 SSTORE 0D81 50 POP 0D82 60 PUSH1 0x00 0D84 80 DUP1 0D85 60 PUSH1 0x01 0D87 01 ADD 0D88 60 PUSH1 0x00 0D8A 83 DUP4 0D8B 81 DUP2 0D8C 52 MSTORE 0D8D 60 PUSH1 0x20 0D8F 01 ADD 0D90 90 SWAP1 0D91 81 DUP2 0D92 52 MSTORE 0D93 60 PUSH1 0x20 0D95 01 ADD 0D96 60 PUSH1 0x00 0D98 20 SHA3 0D99 90 SWAP1 0D9A 50 POP 0D9B 89 DUP10 0D9C 81 DUP2 0D9D 60 PUSH1 0x00 0D9F 01 ADD 0DA0 60 PUSH1 0x00 0DA2 61 PUSH2 0x0100 0DA5 0A EXP 0DA6 81 DUP2 0DA7 54 SLOAD 0DA8 81 DUP2 0DA9 60 PUSH1 0x01 0DAB 60 PUSH1 0x01 0DAD 60 PUSH1 0xa0 0DAF 1B SHL 0DB0 03 SUB 0DB1 02 MUL 0DB2 19 NOT 0DB3 16 AND 0DB4 90 SWAP1 0DB5 83 DUP4 0DB6 60 PUSH1 0x01 0DB8 60 PUSH1 0x01 0DBA 60 PUSH1 0xa0 0DBC 1B SHL 0DBD 03 SUB 0DBE 16 AND 0DBF 02 MUL 0DC0 17 OR 0DC1 90 SWAP1 0DC2 55 SSTORE 0DC3 50 POP 0DC4 89 DUP10 0DC5 81 DUP2 0DC6 60 PUSH1 0x01 0DC8 01 ADD 0DC9 60 PUSH1 0x00 0DCB 61 PUSH2 0x0100 0DCE 0A EXP 0DCF 81 DUP2 0DD0 54 SLOAD 0DD1 81 DUP2 0DD2 60 PUSH1 0x01 0DD4 60 PUSH1 0x01 0DD6 60 PUSH1 0xa0 0DD8 1B SHL 0DD9 03 SUB 0DDA 02 MUL 0DDB 19 NOT 0DDC 16 AND 0DDD 90 SWAP1 0DDE 83 DUP4 0DDF 60 PUSH1 0x01 0DE1 60 PUSH1 0x01 0DE3 60 PUSH1 0xa0 0DE5 1B SHL 0DE6 03 SUB 0DE7 16 AND 0DE8 02 MUL 0DE9 17 OR 0DEA 90 SWAP1 0DEB 55 SSTORE 0DEC 50 POP 0DED 88 DUP9 0DEE 81 DUP2 0DEF 60 PUSH1 0x03 0DF1 01 ADD 0DF2 60 PUSH1 0x00 0DF4 61 PUSH2 0x0100 0DF7 0A EXP 0DF8 81 DUP2 0DF9 54 SLOAD 0DFA 81 DUP2 0DFB 60 PUSH1 0x01 0DFD 60 PUSH1 0x01 0DFF 60 PUSH1 0x80 0E01 1B SHL 0E02 03 SUB 0E03 02 MUL 0E04 19 NOT 0E05 16 AND 0E06 90 SWAP1 0E07 83 DUP4 0E08 60 PUSH1 0x01 0E0A 60 PUSH1 0x01 0E0C 60 PUSH1 0x80 0E0E 1B SHL 0E0F 03 SUB 0E10 16 AND 0E11 02 MUL 0E12 17 OR 0E13 90 SWAP1 0E14 55 SSTORE 0E15 50 POP 0E16 87 DUP8 0E17 81 DUP2 0E18 60 PUSH1 0x03 0E1A 01 ADD 0E1B 60 PUSH1 0x10 0E1D 61 PUSH2 0x0100 0E20 0A EXP 0E21 81 DUP2 0E22 54 SLOAD 0E23 81 DUP2 0E24 60 PUSH1 0x01 0E26 60 PUSH1 0x01 0E28 60 PUSH1 0x80 0E2A 1B SHL 0E2B 03 SUB 0E2C 02 MUL 0E2D 19 NOT 0E2E 16 AND 0E2F 90 SWAP1 0E30 83 DUP4 0E31 60 PUSH1 0x01 0E33 60 PUSH1 0x01 0E35 60 PUSH1 0x80 0E37 1B SHL 0E38 03 SUB 0E39 16 AND 0E3A 02 MUL 0E3B 17 OR 0E3C 90 SWAP1 0E3D 55 SSTORE 0E3E 50 POP 0E3F 86 DUP7 0E40 81 DUP2 0E41 60 PUSH1 0x04 0E43 01 ADD 0E44 60 PUSH1 0x00 0E46 61 PUSH2 0x0100 0E49 0A EXP 0E4A 81 DUP2 0E4B 54 SLOAD 0E4C 81 DUP2 0E4D 60 PUSH1 0x01 0E4F 60 PUSH1 0x01 0E51 60 PUSH1 0x80 0E53 1B SHL 0E54 03 SUB 0E55 02 MUL 0E56 19 NOT 0E57 16 AND 0E58 90 SWAP1 0E59 83 DUP4 0E5A 60 PUSH1 0x01 0E5C 60 PUSH1 0x01 0E5E 60 PUSH1 0x80 0E60 1B SHL 0E61 03 SUB 0E62 16 AND 0E63 02 MUL 0E64 17 OR 0E65 90 SWAP1 0E66 55 SSTORE 0E67 50 POP 0E68 85 DUP6 0E69 81 DUP2 0E6A 60 PUSH1 0x04 0E6C 01 ADD 0E6D 60 PUSH1 0x10 0E6F 61 PUSH2 0x0100 0E72 0A EXP 0E73 81 DUP2 0E74 54 SLOAD 0E75 81 DUP2 0E76 60 PUSH1 0x01 0E78 60 PUSH1 0x01 0E7A 60 PUSH1 0x80 0E7C 1B SHL 0E7D 03 SUB 0E7E 02 MUL 0E7F 19 NOT 0E80 16 AND 0E81 90 SWAP1 0E82 83 DUP4 0E83 60 PUSH1 0x01 0E85 60 PUSH1 0x01 0E87 60 PUSH1 0x80 0E89 1B SHL 0E8A 03 SUB 0E8B 16 AND 0E8C 02 MUL 0E8D 17 OR 0E8E 90 SWAP1 0E8F 55 SSTORE 0E90 50 POP 0E91 84 DUP5 0E92 81 DUP2 0E93 60 PUSH1 0x05 0E95 01 ADD 0E96 60 PUSH1 0x00 0E98 61 PUSH2 0x0100 0E9B 0A EXP 0E9C 81 DUP2 0E9D 54 SLOAD 0E9E 81 DUP2 0E9F 60 PUSH1 0x01 0EA1 60 PUSH1 0x01 0EA3 60 PUSH1 0x80 0EA5 1B SHL 0EA6 03 SUB 0EA7 02 MUL 0EA8 19 NOT 0EA9 16 AND 0EAA 90 SWAP1 0EAB 83 DUP4 0EAC 60 PUSH1 0x01 0EAE 60 PUSH1 0x01 0EB0 60 PUSH1 0x80 0EB2 1B SHL 0EB3 03 SUB 0EB4 16 AND 0EB5 02 MUL 0EB6 17 OR 0EB7 90 SWAP1 0EB8 55 SSTORE 0EB9 50 POP 0EBA 83 DUP4 0EBB 81 DUP2 0EBC 60 PUSH1 0x05 0EBE 01 ADD 0EBF 60 PUSH1 0x10 0EC1 61 PUSH2 0x0100 0EC4 0A EXP 0EC5 81 DUP2 0EC6 54 SLOAD 0EC7 81 DUP2 0EC8 60 PUSH1 0x01 0ECA 60 PUSH1 0x01 0ECC 60 PUSH1 0x40 0ECE 1B SHL 0ECF 03 SUB 0ED0 02 MUL 0ED1 19 NOT 0ED2 16 AND 0ED3 90 SWAP1 0ED4 83 DUP4 0ED5 60 PUSH1 0x01 0ED7 60 PUSH1 0x01 0ED9 60 PUSH1 0x40 0EDB 1B SHL 0EDC 03 SUB 0EDD 16 AND 0EDE 02 MUL 0EDF 17 OR 0EE0 90 SWAP1 0EE1 55 SSTORE 0EE2 50 POP 0EE3 82 DUP3 0EE4 81 DUP2 0EE5 60 PUSH1 0x05 0EE7 01 ADD 0EE8 60 PUSH1 0x18 0EEA 61 PUSH2 0x0100 0EED 0A EXP 0EEE 81 DUP2 0EEF 54 SLOAD 0EF0 81 DUP2 0EF1 60 PUSH1 0x01 0EF3 60 PUSH1 0x01 0EF5 60 PUSH1 0x40 0EF7 1B SHL 0EF8 03 SUB 0EF9 02 MUL 0EFA 19 NOT 0EFB 16 AND 0EFC 90 SWAP1 0EFD 83 DUP4 0EFE 60 PUSH1 0x01 0F00 60 PUSH1 0x01 0F02 60 PUSH1 0x40 0F04 1B SHL 0F05 03 SUB 0F06 16 AND 0F07 02 MUL 0F08 17 OR 0F09 90 SWAP1 0F0A 55 SSTORE 0F0B 50 POP 0F0C 60 PUSH1 0x00 0F0E 80 DUP1 0F0F 60 PUSH1 0x02 0F11 01 ADD 0F12 60 PUSH1 0x00 0F14 8C DUP13 0F15 60 PUSH1 0x01 0F17 60 PUSH1 0x01 0F19 60 PUSH1 0xa0 0F1B 1B SHL 0F1C 03 SUB 0F1D 16 AND 0F1E 60 PUSH1 0x01 0F20 60 PUSH1 0x01 0F22 60 PUSH1 0xa0 0F24 1B SHL 0F25 03 SUB 0F26 16 AND 0F27 81 DUP2 0F28 52 MSTORE 0F29 60 PUSH1 0x20 0F2B 01 ADD 0F2C 90 SWAP1 0F2D 81 DUP2 0F2E 52 MSTORE 0F2F 60 PUSH1 0x20 0F31 01 ADD 0F32 60 PUSH1 0x00 0F34 20 SHA3 0F35 60 PUSH1 0x00 0F37 01 ADD 0F38 60 PUSH1 0x00 0F3A 81 DUP2 0F3B 54 SLOAD 0F3C 80 DUP1 0F3D 92 SWAP3 0F3E 91 SWAP2 0F3F 90 SWAP1 0F40 61 PUSH2 0x0f48 0F43 90 SWAP1 0F44 61 PUSH2 0x1f0e 0F47 56 *JUMP // Stack delta = +6 // Outputs[23] // { // @0D6E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-10] // @0D74 memory[0x20:0x40] = 0x02 + 0x00 // @0D80 storage[0x04 + keccak256(memory[0x00:0x40])] = stack[-1] // @0D8C memory[0x00:0x20] = stack[-2] // @0D92 memory[0x20:0x40] = 0x01 + 0x00 // @0D99 stack[-1] = keccak256(memory[0x00:0x40]) // @0DC2 storage[0x00 + keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & stack[-10]) * 0x0100 ** 0x00 | (~((0x01 << 0xa0) - 0x01 * 0x0100 ** 0x00) & storage[0x00 + keccak256(memory[0x00:0x40])]) // @0DEB storage[0x01 + keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & stack[-10]) * 0x0100 ** 0x00 | (~((0x01 << 0xa0) - 0x01 * 0x0100 ** 0x00) & storage[0x01 + keccak256(memory[0x00:0x40])]) // @0E14 storage[0x03 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-9]) * 0x0100 ** 0x00 | (~((0x01 << 0x80) - 0x01 * 0x0100 ** 0x00) & storage[0x03 + keccak256(memory[0x00:0x40])]) // @0E3D storage[0x03 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-8]) * 0x0100 ** 0x10 | (~((0x01 << 0x80) - 0x01 * 0x0100 ** 0x10) & storage[0x03 + keccak256(memory[0x00:0x40])]) // @0E66 storage[0x04 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-7]) * 0x0100 ** 0x00 | (~((0x01 << 0x80) - 0x01 * 0x0100 ** 0x00) & storage[0x04 + keccak256(memory[0x00:0x40])]) // @0E8F storage[0x04 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-6]) * 0x0100 ** 0x10 | (~((0x01 << 0x80) - 0x01 * 0x0100 ** 0x10) & storage[0x04 + keccak256(memory[0x00:0x40])]) // @0EB8 storage[0x05 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-5]) * 0x0100 ** 0x00 | (~((0x01 << 0x80) - 0x01 * 0x0100 ** 0x00) & storage[0x05 + keccak256(memory[0x00:0x40])]) // @0EE1 storage[0x05 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & stack[-4]) * 0x0100 ** 0x10 | (~((0x01 << 0x40) - 0x01 * 0x0100 ** 0x10) & storage[0x05 + keccak256(memory[0x00:0x40])]) // @0F0A storage[0x05 + keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & stack[-3]) * 0x0100 ** 0x18 | (~((0x01 << 0x40) - 0x01 * 0x0100 ** 0x18) & storage[0x05 + keccak256(memory[0x00:0x40])]) // @0F0C stack[0] = 0x00 // @0F28 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-10] // @0F2E memory[0x20:0x40] = 0x02 + 0x00 // @0F3D stack[1] = storage[0x00 + keccak256(memory[0x00:0x40])] // @0F3E stack[2] = 0x00 + keccak256(memory[0x00:0x40]) // @0F3F stack[3] = 0x00 // @0F43 stack[4] = 0x0f48 // @0F43 stack[5] = storage[0x00 + keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1f0e, returns to 0x0F48 label_0F48: // Incoming return from call to 0x1F0E at 0x0F47 // Inputs[5] // { // @0F49 stack[-1] // @0F49 stack[-2] // @0F4A stack[-3] // @0F4D stack[-5] // @0F4D stack[-4] // } 0F48 5B JUMPDEST 0F49 90 SWAP1 0F4A 91 SWAP2 0F4B 55 SSTORE 0F4C 50 POP 0F4D 90 SWAP1 0F4E 50 POP 0F4F 61 PUSH2 0x0f59 0F52 81 DUP2 0F53 60 PUSH1 0x01 0F55 61 PUSH2 0x1f67 0F58 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @0F4B storage[stack[-3]] = stack[-1] // @0F4D stack[-5] = stack[-4] // @0F4F stack[-4] = 0x0f59 // @0F52 stack[-3] = stack[-4] // @0F53 stack[-2] = 0x01 // } // Block ends with call to 0x1f67, returns to 0x0F59 label_0F59: // Incoming return from call to 0x1F67 at 0x0F58 // Inputs[20] // { // @0F62 stack[-12] // @0F74 memory[0x00:0x40] // @0F75 stack[-4] // @0F80 memory[0x00:0x40] // @0F81 stack[-1] // @0F85 stack[-2] // @0F91 memory[0x00:0x40] // @0F96 memory[0x40:0x60] // @0FBE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0FC2 memory[0x40:0x60] // @0FC3 stack[-11] // @0FCA stack[-10] // @0FD0 stack[-9] // @0FD7 stack[-8] // @0FDE stack[-7] // @0FE5 stack[-6] // @0FEC stack[-5] // @1023 memory[0x40:0x60] // @1028 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xe0 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1034 stack[-13] // } 0F59 5B JUMPDEST 0F5A 60 PUSH1 0x01 0F5C 60 PUSH1 0x01 0F5E 60 PUSH1 0xa0 0F60 1B SHL 0F61 03 SUB 0F62 8C DUP13 0F63 16 AND 0F64 60 PUSH1 0x00 0F66 81 DUP2 0F67 81 DUP2 0F68 52 MSTORE 0F69 60 PUSH1 0x02 0F6B 60 PUSH1 0x20 0F6D 90 SWAP1 0F6E 81 DUP2 0F6F 52 MSTORE 0F70 60 PUSH1 0x40 0F72 80 DUP1 0F73 83 DUP4 0F74 20 SHA3 0F75 88 DUP9 0F76 84 DUP5 0F77 52 MSTORE 0F78 60 PUSH1 0x03 0F7A 81 DUP2 0F7B 01 ADD 0F7C 83 DUP4 0F7D 52 MSTORE 0F7E 81 DUP2 0F7F 84 DUP5 0F80 20 SHA3 0F81 95 SWAP6 0F82 90 SWAP1 0F83 95 SWAP6 0F84 55 SSTORE 0F85 85 DUP6 0F86 83 DUP4 0F87 52 MSTORE 0F88 60 PUSH1 0x01 0F8A 90 SWAP1 0F8B 94 SWAP5 0F8C 01 ADD 0F8D 90 SWAP1 0F8E 52 MSTORE 0F8F 82 DUP3 0F90 81 DUP2 0F91 20 SHA3 0F92 86 DUP7 0F93 90 SWAP1 0F94 55 SSTORE 0F95 91 SWAP2 0F96 51 MLOAD 0F97 85 DUP6 0F98 92 SWAP3 0F99 90 SWAP1 0F9A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0FBB 90 SWAP1 0FBC 82 DUP3 0FBD 90 SWAP1 0FBE A4 LOG4 0FBF 60 PUSH1 0x40 0FC1 80 DUP1 0FC2 51 MLOAD 0FC3 8B DUP12 0FC4 81 DUP2 0FC5 52 MSTORE 0FC6 60 PUSH1 0x20 0FC8 81 DUP2 0FC9 01 ADD 0FCA 8B DUP12 0FCB 90 SWAP1 0FCC 52 MSTORE 0FCD 90 SWAP1 0FCE 81 DUP2 0FCF 01 ADD 0FD0 89 DUP10 0FD1 90 SWAP1 0FD2 52 MSTORE 0FD3 60 PUSH1 0x60 0FD5 81 DUP2 0FD6 01 ADD 0FD7 88 DUP9 0FD8 90 SWAP1 0FD9 52 MSTORE 0FDA 60 PUSH1 0x80 0FDC 81 DUP2 0FDD 01 ADD 0FDE 87 DUP8 0FDF 90 SWAP1 0FE0 52 MSTORE 0FE1 60 PUSH1 0xa0 0FE3 81 DUP2 0FE4 01 ADD 0FE5 86 DUP7 0FE6 90 SWAP1 0FE7 52 MSTORE 0FE8 60 PUSH1 0xc0 0FEA 81 DUP2 0FEB 01 ADD 0FEC 85 DUP6 0FED 90 SWAP1 0FEE 52 MSTORE 0FEF 83 DUP4 0FF0 90 SWAP1 0FF1 60 PUSH1 0x01 0FF3 60 PUSH1 0x01 0FF5 60 PUSH1 0xa0 0FF7 1B SHL 0FF8 03 SUB 0FF9 8D DUP14 0FFA 16 AND 0FFB 90 SWAP1 0FFC 7F PUSH32 0x7cc62fff527c1d370281620d7f175585dac25557e85f8bedc8e74b984e3bf2e7 101D 90 SWAP1 101E 60 PUSH1 0xe0 1020 01 ADD 1021 60 PUSH1 0x40 1023 51 MLOAD 1024 80 DUP1 1025 91 SWAP2 1026 03 SUB 1027 90 SWAP1 1028 A3 LOG3 1029 50 POP 102A 50 POP 102B 50 POP 102C 50 POP 102D 50 POP 102E 50 POP 102F 50 POP 1030 50 POP 1031 50 POP 1032 50 POP 1033 50 POP 1034 56 *JUMP // Stack delta = -13 // Outputs[17] // { // @0F68 memory[0x00:0x20] = stack[-12] & (0x01 << 0xa0) - 0x01 // @0F6F memory[0x20:0x40] = 0x02 // @0F77 memory[0x00:0x20] = stack[-4] // @0F7D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x03 // @0F84 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0F87 memory[0x00:0x20] = stack[-2] // @0F8E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x01 // @0F94 storage[keccak256(memory[0x00:0x40])] = stack[-4] // @0FBE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-12] & (0x01 << 0xa0) - 0x01, stack[-4]]); // @0FC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-11] // @0FCC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-10] // @0FD2 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-9] // @0FD9 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-8] // @0FE0 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-7] // @0FE7 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = stack[-6] // @0FEE memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-5] // @1028 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xe0 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x7cc62fff527c1d370281620d7f175585dac25557e85f8bedc8e74b984e3bf2e7, stack[-12] & (0x01 << 0xa0) - 0x01, stack[-4]]); // } // Block ends with unconditional jump to stack[-13] label_1035: // Incoming call from 0x12B7, returns to 0x12B8 // Incoming jump from 0x049A 1035 5B JUMPDEST 1036 61 PUSH2 0x103d 1039 61 PUSH2 0x1793 103C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1036 stack[0] = 0x103d } // Block ends with call to 0x1793, returns to 0x103D label_103D: // Incoming return from call to 0x1793 at 0x103C // Inputs[1] { @1041 stack[-2] } 103D 5B JUMPDEST 103E 61 PUSH2 0x1046 1041 82 DUP3 1042 61 PUSH2 0x14a1 1045 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @103E stack[0] = 0x1046 // @1041 stack[1] = stack[-2] // } // Block ends with call to 0x14a1, returns to 0x1046 label_1046: // Incoming return from call to 0x14A1 at 0x1045 // Inputs[3] // { // @1047 stack[-2] // @1048 stack[-1] // @104C stack[-3] // } 1046 5B JUMPDEST 1047 81 DUP2 1048 52 MSTORE 1049 61 PUSH2 0x1051 104C 82 DUP3 104D 61 PUSH2 0x0bcb 1050 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1048 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1049 stack[-1] = 0x1051 // @104C stack[0] = stack[-3] // } // Block ends with call to 0x0bcb, returns to 0x1051 label_1051: // Incoming return from call to 0x0BCB at 0x1050 // Inputs[3] // { // @1054 stack[-2] // @1056 stack[-1] // @105A stack[-3] // } 1051 5B JUMPDEST 1052 60 PUSH1 0x20 1054 82 DUP3 1055 01 ADD 1056 52 MSTORE 1057 61 PUSH2 0x105f 105A 82 DUP3 105B 61 PUSH2 0x1259 105E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1056 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @1057 stack[-1] = 0x105f // @105A stack[0] = stack[-3] // } // Block ends with call to 0x1259, returns to 0x105F label_105F: // Incoming return from call to 0x1259 at 0x105E // Inputs[3] // { // @1062 stack[-2] // @1064 stack[-1] // @1068 stack[-3] // } 105F 5B JUMPDEST 1060 60 PUSH1 0x40 1062 82 DUP3 1063 01 ADD 1064 52 MSTORE 1065 61 PUSH2 0x106d 1068 82 DUP3 1069 61 PUSH2 0x1101 106C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1064 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = stack[-1] // @1065 stack[-1] = 0x106d // @1068 stack[0] = stack[-3] // } // Block ends with call to 0x1101, returns to 0x106D label_106D: // Incoming return from call to 0x1101 at 0x106C // Inputs[3] // { // @1070 stack[-2] // @1072 stack[-1] // @1076 stack[-3] // } 106D 5B JUMPDEST 106E 60 PUSH1 0x60 1070 82 DUP3 1071 01 ADD 1072 52 MSTORE 1073 61 PUSH2 0x107b 1076 82 DUP3 1077 61 PUSH2 0x0cef 107A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1072 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = stack[-1] // @1073 stack[-1] = 0x107b // @1076 stack[0] = stack[-3] // } // Block ends with call to 0x0cef, returns to 0x107B label_107B: // Incoming return from call to 0x0CEF at 0x107A // Inputs[3] // { // @107E stack[-2] // @1080 stack[-1] // @1084 stack[-3] // } 107B 5B JUMPDEST 107C 60 PUSH1 0x80 107E 82 DUP3 107F 01 ADD 1080 52 MSTORE 1081 61 PUSH2 0x1089 1084 82 DUP3 1085 61 PUSH2 0x10a1 1088 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1080 memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] = stack[-1] // @1081 stack[-1] = 0x1089 // @1084 stack[0] = stack[-3] // } // Block ends with call to 0x10a1, returns to 0x1089 label_1089: // Incoming return from call to 0x10A1 at 0x1088 // Inputs[3] // { // @108C stack[-2] // @108E stack[-1] // @1092 stack[-3] // } 1089 5B JUMPDEST 108A 60 PUSH1 0xa0 108C 82 DUP3 108D 01 ADD 108E 52 MSTORE 108F 61 PUSH2 0x1097 1092 82 DUP3 1093 61 PUSH2 0x06ec 1096 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @108E memory[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] = stack[-1] // @108F stack[-1] = 0x1097 // @1092 stack[0] = stack[-3] // } // Block ends with call to 0x06ec, returns to 0x1097 label_1097: // Incoming return from call to 0x06EC at 0x1096 // Inputs[4] // { // @109A stack[-2] // @109C stack[-1] // @109D stack[-4] // @109E stack[-3] // } 1097 5B JUMPDEST 1098 60 PUSH1 0xc0 109A 82 DUP3 109B 01 ADD 109C 52 MSTORE 109D 91 SWAP2 109E 90 SWAP1 109F 50 POP 10A0 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @109C memory[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] = stack[-1] // @109D stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_10A1: // Incoming jump from 0x04BA // Incoming call from 0x1088, returns to 0x1089 // Inputs[2] // { // @10A5 storage[0x00] // @10A6 stack[-1] // } 10A1 5B JUMPDEST 10A2 60 PUSH1 0x00 10A4 80 DUP1 10A5 54 SLOAD 10A6 82 DUP3 10A7 10 LT 10A8 61 PUSH2 0x10b0 10AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x10b0, if stack[-1] < storage[0x00] label_10AC: // Incoming jump from 0x10AB, if not stack[-1] < storage[0x00] // Inputs[1] { @10AF memory[0x00:0x00] } 10AC 60 PUSH1 0x00 10AE 80 DUP1 10AF FD *REVERT // Stack delta = +0 // Outputs[1] { @10AF revert(memory[0x00:0x00]); } // Block terminates label_10B0: // Incoming jump from 0x10AB, if stack[-1] < storage[0x00] // Inputs[4] // { // @10B4 stack[-2] // @10BF memory[0x00:0x40] // @10C3 storage[0x05 + keccak256(memory[0x00:0x40])] // @10D4 stack[-3] // } 10B0 5B JUMPDEST 10B1 50 POP 10B2 60 PUSH1 0x00 10B4 90 SWAP1 10B5 81 DUP2 10B6 52 MSTORE 10B7 60 PUSH1 0x01 10B9 60 PUSH1 0x20 10BB 52 MSTORE 10BC 60 PUSH1 0x40 10BE 90 SWAP1 10BF 20 SHA3 10C0 60 PUSH1 0x05 10C2 01 ADD 10C3 54 SLOAD 10C4 60 PUSH1 0x01 10C6 60 PUSH1 0x80 10C8 1B SHL 10C9 90 SWAP1 10CA 04 DIV 10CB 60 PUSH1 0x01 10CD 60 PUSH1 0x01 10CF 60 PUSH1 0x40 10D1 1B SHL 10D2 03 SUB 10D3 16 AND 10D4 90 SWAP1 10D5 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @10B6 memory[0x00:0x20] = stack[-2] // @10BB memory[0x20:0x40] = 0x01 // @10D4 stack[-3] = (0x01 << 0x40) - 0x01 & storage[0x05 + keccak256(memory[0x00:0x40])] / (0x01 << 0x80) // } // Block ends with unconditional jump to stack[-3] label_10D6: // Incoming call from 0x12AE, returns to 0x12AF // Incoming jump from 0x04CD // Inputs[2] // { // @10DA storage[0x00] // @10DB stack[-1] // } 10D6 5B JUMPDEST 10D7 60 PUSH1 0x00 10D9 80 DUP1 10DA 54 SLOAD 10DB 82 DUP3 10DC 10 LT 10DD 61 PUSH2 0x10e5 10E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @10D7 stack[0] = 0x00 } // Block ends with conditional jump to 0x10e5, if stack[-1] < storage[0x00] label_10E1: // Incoming jump from 0x10E0, if not stack[-1] < storage[0x00] // Inputs[1] { @10E4 memory[0x00:0x00] } 10E1 60 PUSH1 0x00 10E3 80 DUP1 10E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @10E4 revert(memory[0x00:0x00]); } // Block terminates label_10E5: // Incoming jump from 0x10E0, if stack[-1] < storage[0x00] // Inputs[4] // { // @10E9 stack[-2] // @10F4 memory[0x00:0x40] // @10F5 storage[keccak256(memory[0x00:0x40])] // @10FF stack[-3] // } 10E5 5B JUMPDEST 10E6 50 POP 10E7 60 PUSH1 0x00 10E9 90 SWAP1 10EA 81 DUP2 10EB 52 MSTORE 10EC 60 PUSH1 0x01 10EE 60 PUSH1 0x20 10F0 52 MSTORE 10F1 60 PUSH1 0x40 10F3 90 SWAP1 10F4 20 SHA3 10F5 54 SLOAD 10F6 60 PUSH1 0x01 10F8 60 PUSH1 0x01 10FA 60 PUSH1 0xa0 10FC 1B SHL 10FD 03 SUB 10FE 16 AND 10FF 90 SWAP1 1100 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @10EB memory[0x00:0x20] = stack[-2] // @10F0 memory[0x20:0x40] = 0x01 // @10FF stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1101: // Incoming call from 0x106C, returns to 0x106D // Incoming jump from 0x04E0 // Inputs[2] // { // @1105 storage[0x00] // @1106 stack[-1] // } 1101 5B JUMPDEST 1102 60 PUSH1 0x00 1104 80 DUP1 1105 54 SLOAD 1106 82 DUP3 1107 10 LT 1108 61 PUSH2 0x1110 110B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1102 stack[0] = 0x00 } // Block ends with conditional jump to 0x1110, if stack[-1] < storage[0x00] label_110C: // Incoming jump from 0x110B, if not stack[-1] < storage[0x00] // Inputs[1] { @110F memory[0x00:0x00] } 110C 60 PUSH1 0x00 110E 80 DUP1 110F FD *REVERT // Stack delta = +0 // Outputs[1] { @110F revert(memory[0x00:0x00]); } // Block terminates label_1110: // Incoming jump from 0x110B, if stack[-1] < storage[0x00] // Inputs[4] // { // @1114 stack[-2] // @111F memory[0x00:0x40] // @1123 storage[0x04 + keccak256(memory[0x00:0x40])] // @1134 stack[-3] // } 1110 5B JUMPDEST 1111 50 POP 1112 60 PUSH1 0x00 1114 90 SWAP1 1115 81 DUP2 1116 52 MSTORE 1117 60 PUSH1 0x01 1119 60 PUSH1 0x20 111B 52 MSTORE 111C 60 PUSH1 0x40 111E 90 SWAP1 111F 20 SHA3 1120 60 PUSH1 0x04 1122 01 ADD 1123 54 SLOAD 1124 60 PUSH1 0x01 1126 60 PUSH1 0x80 1128 1B SHL 1129 90 SWAP1 112A 04 DIV 112B 60 PUSH1 0x01 112D 60 PUSH1 0x01 112F 60 PUSH1 0x80 1131 1B SHL 1132 03 SUB 1133 16 AND 1134 90 SWAP1 1135 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1116 memory[0x00:0x20] = stack[-2] // @111B memory[0x20:0x40] = 0x01 // @1134 stack[-3] = (0x01 << 0x80) - 0x01 & storage[0x04 + keccak256(memory[0x00:0x40])] / (0x01 << 0x80) // } // Block ends with unconditional jump to stack[-3] label_1136: // Incoming jump from 0x04F3 // Incoming call from 0x09CF, returns to 0x0765 // Inputs[3] // { // @113A stack[-4] // @113B stack[-3] // @113C stack[-2] // } 1136 5B JUMPDEST 1137 61 PUSH2 0x1141 113A 84 DUP5 113B 84 DUP5 113C 84 DUP5 113D 61 PUSH2 0x14cf 1140 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1137 stack[0] = 0x1141 // @113A stack[1] = stack[-4] // @113B stack[2] = stack[-3] // @113C stack[3] = stack[-2] // } // Block ends with call to 0x14cf, returns to 0x1141 label_1141: // Incoming return from call to 0x14CF at 0x1140 // Inputs[2] // { // @1142 stack[-3] // @1143 address(stack[-3]).code.length // } 1141 5B JUMPDEST 1142 82 DUP3 1143 3B EXTCODESIZE 1144 63 PUSH4 0xffffffff 1149 81 DUP2 114A 16 AND 114B 15 ISZERO 114C 61 PUSH2 0x11e0 114F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1143 stack[0] = address(stack[-3]).code.length } // Block ends with conditional jump to 0x11e0, if !(address(stack[-3]).code.length & 0xffffffff) label_1150: // Incoming jump from 0x114F, if not !(address(stack[-3]).code.length & 0xffffffff) // Inputs[6] // { // @1152 memory[0x40:0x60] // @1165 stack[-4] // @1172 msg.sender // @1174 stack[-5] // @1176 stack[-3] // @1178 stack[-2] // } 1150 60 PUSH1 0x40 1152 51 MLOAD 1153 63 PUSH4 0x0a85bd01 1158 60 PUSH1 0xe1 115A 1B SHL 115B 81 DUP2 115C 52 MSTORE 115D 60 PUSH1 0x01 115F 60 PUSH1 0x01 1161 60 PUSH1 0xa0 1163 1B SHL 1164 03 SUB 1165 85 DUP6 1166 16 AND 1167 90 SWAP1 1168 63 PUSH4 0x150b7a02 116D 90 SWAP1 116E 61 PUSH2 0x1181 1171 90 SWAP1 1172 33 CALLER 1173 90 SWAP1 1174 89 DUP10 1175 90 SWAP1 1176 88 DUP9 1177 90 SWAP1 1178 88 DUP9 1179 90 SWAP1 117A 60 PUSH1 0x04 117C 01 ADD 117D 61 PUSH2 0x1fb5 1180 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @115C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1167 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @116D stack[1] = 0x150b7a02 // @1171 stack[2] = 0x1181 // @1173 stack[3] = msg.sender // @1175 stack[4] = stack[-5] // @1177 stack[5] = stack[-3] // @1179 stack[6] = stack[-2] // @117C stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1fb5, returns to 0x1181 label_1181: // Incoming return from call to 0x1FB5 at 0x1180 // Inputs[6] // { // @1186 memory[0x40:0x60] // @1188 stack[-1] // @118D stack[-3] // @118E msg.gas // @118F address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @118F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1181 5B JUMPDEST 1182 60 PUSH1 0x20 1184 60 PUSH1 0x40 1186 51 MLOAD 1187 80 DUP1 1188 83 DUP4 1189 03 SUB 118A 81 DUP2 118B 60 PUSH1 0x00 118D 87 DUP8 118E 5A GAS 118F F1 CALL 1190 15 ISZERO 1191 80 DUP1 1192 15 ISZERO 1193 61 PUSH2 0x11a0 1196 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @118F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1190 stack[0] = !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x11a0, if !!address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1197: // Incoming jump from 0x1196, if not !!address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[4] // { // @1197 returndata.length // @119B returndata[0x00:0x00 + returndata.length] // @119C returndata.length // @119F memory[0x00:0x00 + returndata.length] // } 1197 3D RETURNDATASIZE 1198 60 PUSH1 0x00 119A 80 DUP1 119B 3E RETURNDATACOPY 119C 3D RETURNDATASIZE 119D 60 PUSH1 0x00 119F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @119B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @119F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_11A0: // Incoming jump from 0x1196, if !!address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @11A7 memory[0x40:0x60] // @11A8 returndata.length // } 11A0 5B JUMPDEST 11A1 50 POP 11A2 50 POP 11A3 50 POP 11A4 50 POP 11A5 60 PUSH1 0x40 11A7 51 MLOAD 11A8 3D RETURNDATASIZE 11A9 60 PUSH1 0x1f 11AB 19 NOT 11AC 60 PUSH1 0x1f 11AE 82 DUP3 11AF 01 ADD 11B0 16 AND 11B1 82 DUP3 11B2 01 ADD 11B3 80 DUP1 11B4 60 PUSH1 0x40 11B6 52 MSTORE 11B7 50 POP 11B8 81 DUP2 11B9 01 ADD 11BA 90 SWAP1 11BB 61 PUSH2 0x11c4 11BE 91 SWAP2 11BF 90 SWAP1 11C0 61 PUSH2 0x1ff2 11C3 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @11B6 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @11BE stack[-4] = 0x11c4 // @11BF stack[-2] = memory[0x40:0x60] // @11BF stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1ff2 11C4 5B JUMPDEST 11C5 60 PUSH1 0x01 11C7 60 PUSH1 0x01 11C9 60 PUSH1 0xe0 11CB 1B SHL 11CC 03 SUB 11CD 19 NOT 11CE 16 AND 11CF 63 PUSH4 0x150b7a02 11D4 60 PUSH1 0xe0 11D6 1B SHL 11D7 14 EQ 11D8 61 PUSH2 0x11e0 11DB 57 *JUMPI 11DC 60 PUSH1 0x00 11DE 80 DUP1 11DF FD *REVERT label_11E0: // Incoming jump from 0x114F, if !(address(stack[-3]).code.length & 0xffffffff) // Inputs[1] { @11E6 stack[-6] } 11E0 5B JUMPDEST 11E1 50 POP 11E2 50 POP 11E3 50 POP 11E4 50 POP 11E5 50 POP 11E6 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_11E7: // Incoming jump from 0x0506 // Inputs[7] // { // @11EA storage[0x03] // @11ED memory[0x40:0x60] // @11FC stack[-1] // @1219 memory[0x40:0x60] // @121F msg.gas // @1220 address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1220 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11E7 5B JUMPDEST 11E8 60 PUSH1 0x03 11EA 54 SLOAD 11EB 60 PUSH1 0x40 11ED 51 MLOAD 11EE 63 PUSH4 0xc87b56dd 11F3 60 PUSH1 0xe0 11F5 1B SHL 11F6 81 DUP2 11F7 52 MSTORE 11F8 60 PUSH1 0x04 11FA 81 DUP2 11FB 01 ADD 11FC 83 DUP4 11FD 90 SWAP1 11FE 52 MSTORE 11FF 60 PUSH1 0x60 1201 91 SWAP2 1202 60 PUSH1 0x01 1204 60 PUSH1 0x01 1206 60 PUSH1 0xa0 1208 1B SHL 1209 03 SUB 120A 16 AND 120B 90 SWAP1 120C 63 PUSH4 0xc87b56dd 1211 90 SWAP1 1212 60 PUSH1 0x24 1214 01 ADD 1215 60 PUSH1 0x00 1217 60 PUSH1 0x40 1219 51 MLOAD 121A 80 DUP1 121B 83 DUP4 121C 03 SUB 121D 81 DUP2 121E 86 DUP7 121F 5A GAS 1220 FA STATICCALL 1221 15 ISZERO 1222 80 DUP1 1223 15 ISZERO 1224 61 PUSH2 0x1231 1227 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @11F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc87b56dd << 0xe0 // @11FE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] // @1201 stack[0] = 0x60 // @120B stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @1211 stack[2] = 0xc87b56dd // @1214 stack[3] = 0x24 + memory[0x40:0x60] // @1220 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1221 stack[4] = !address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1231, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_1228: // Incoming jump from 0x1227, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1228 returndata.length // @122C returndata[0x00:0x00 + returndata.length] // @122D returndata.length // @1230 memory[0x00:0x00 + returndata.length] // } 1228 3D RETURNDATASIZE 1229 60 PUSH1 0x00 122B 80 DUP1 122C 3E RETURNDATACOPY 122D 3D RETURNDATASIZE 122E 60 PUSH1 0x00 1230 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @122C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1230 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1231: // Incoming jump from 0x1227, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1238 memory[0x40:0x60] // @1239 returndata.length // @123D returndata[0x00:0x00 + returndata.length] // @1240 returndata.length // } 1231 5B JUMPDEST 1232 50 POP 1233 50 POP 1234 50 POP 1235 50 POP 1236 60 PUSH1 0x40 1238 51 MLOAD 1239 3D RETURNDATASIZE 123A 60 PUSH1 0x00 123C 82 DUP3 123D 3E RETURNDATACOPY 123E 60 PUSH1 0x1f 1240 3D RETURNDATASIZE 1241 90 SWAP1 1242 81 DUP2 1243 01 ADD 1244 60 PUSH1 0x1f 1246 19 NOT 1247 16 AND 1248 82 DUP3 1249 01 ADD 124A 60 PUSH1 0x40 124C 52 MSTORE 124D 61 PUSH2 0x07b7 1250 91 SWAP2 1251 90 SWAP1 1252 81 DUP2 1253 01 ADD 1254 90 SWAP1 1255 61 PUSH2 0x1e75 1258 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @123D memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @124C memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1250 stack[-4] = 0x07b7 // @1254 stack[-2] = memory[0x40:0x60] // @1254 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x1e75, returns to 0x07B7 label_1259: // Incoming jump from 0x0519 // Incoming call from 0x105E, returns to 0x105F // Inputs[2] // { // @125D storage[0x00] // @125E stack[-1] // } 1259 5B JUMPDEST 125A 60 PUSH1 0x00 125C 80 DUP1 125D 54 SLOAD 125E 82 DUP3 125F 10 LT 1260 61 PUSH2 0x1268 1263 57 *JUMPI // Stack delta = +1 // Outputs[1] { @125A stack[0] = 0x00 } // Block ends with conditional jump to 0x1268, if stack[-1] < storage[0x00] label_1264: // Incoming jump from 0x1263, if not stack[-1] < storage[0x00] // Inputs[1] { @1267 memory[0x00:0x00] } 1264 60 PUSH1 0x00 1266 80 DUP1 1267 FD *REVERT // Stack delta = +0 // Outputs[1] { @1267 revert(memory[0x00:0x00]); } // Block terminates label_1268: // Incoming jump from 0x1263, if stack[-1] < storage[0x00] // Inputs[4] // { // @126C stack[-2] // @1277 memory[0x00:0x40] // @127B storage[0x04 + keccak256(memory[0x00:0x40])] // @1285 stack[-3] // } 1268 5B JUMPDEST 1269 50 POP 126A 60 PUSH1 0x00 126C 90 SWAP1 126D 81 DUP2 126E 52 MSTORE 126F 60 PUSH1 0x01 1271 60 PUSH1 0x20 1273 52 MSTORE 1274 60 PUSH1 0x40 1276 90 SWAP1 1277 20 SHA3 1278 60 PUSH1 0x04 127A 01 ADD 127B 54 SLOAD 127C 60 PUSH1 0x01 127E 60 PUSH1 0x01 1280 60 PUSH1 0x80 1282 1B SHL 1283 03 SUB 1284 16 AND 1285 90 SWAP1 1286 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @126E memory[0x00:0x20] = stack[-2] // @1273 memory[0x20:0x40] = 0x01 // @1285 stack[-3] = (0x01 << 0x80) - 0x01 & storage[0x04 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1287: // Incoming jump from 0x052C // Incoming jump from 0x0915 1287 5B JUMPDEST 1288 60 PUSH1 0x00 128A 80 DUP1 128B 60 PUSH1 0x00 128D 61 PUSH2 0x1294 1290 61 PUSH2 0x1793 1293 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1288 stack[0] = 0x00 // @128A stack[1] = 0x00 // @128B stack[2] = 0x00 // @128D stack[3] = 0x1294 // } // Block ends with call to 0x1793, returns to 0x1294 label_1294: // Incoming return from call to 0x1793 at 0x1293 // Inputs[1] { @1298 stack[-5] } 1294 5B JUMPDEST 1295 61 PUSH2 0x129d 1298 85 DUP6 1299 61 PUSH2 0x0a11 129C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1295 stack[0] = 0x129d // @1298 stack[1] = stack[-5] // } // Block ends with call to 0x0a11, returns to 0x129D label_129D: // Incoming return from call to 0x0A11 at 0x129C // Inputs[1] { @12A1 stack[-6] } 129D 5B JUMPDEST 129E 61 PUSH2 0x12a6 12A1 86 DUP7 12A2 61 PUSH2 0x063c 12A5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @129E stack[0] = 0x12a6 // @12A1 stack[1] = stack[-6] // } // Block ends with call to 0x063c, returns to 0x12A6 label_12A6: // Incoming return from call to 0x063C at 0x12A5 // Inputs[1] { @12AA stack[-7] } 12A6 5B JUMPDEST 12A7 61 PUSH2 0x12af 12AA 87 DUP8 12AB 61 PUSH2 0x10d6 12AE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12A7 stack[0] = 0x12af // @12AA stack[1] = stack[-7] // } // Block ends with call to 0x10d6, returns to 0x12AF label_12AF: // Incoming return from call to 0x10D6 at 0x12AE // Inputs[1] { @12B3 stack[-8] } 12AF 5B JUMPDEST 12B0 61 PUSH2 0x12b8 12B3 88 DUP9 12B4 61 PUSH2 0x1035 12B7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12B0 stack[0] = 0x12b8 // @12B3 stack[1] = stack[-8] // } // Block ends with call to 0x1035, returns to 0x12B8 label_12B8: // Incoming return from call to 0x1035 at 0x12B7 // Inputs[10] // { // @12B9 stack[-5] // @12B9 stack[-1] // @12BB stack[-2] // @12BB stack[-6] // @12BD stack[-3] // @12BD stack[-7] // @12BF stack[-8] // @12BF stack[-4] // @12C2 stack[-9] // @12C5 stack[-10] // } 12B8 5B JUMPDEST 12B9 93 SWAP4 12BA 50 POP 12BB 93 SWAP4 12BC 50 POP 12BD 93 SWAP4 12BE 50 POP 12BF 93 SWAP4 12C0 50 POP 12C1 91 SWAP2 12C2 93 SWAP4 12C3 50 POP 12C4 91 SWAP2 12C5 93 SWAP4 12C6 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @12C1 stack[-7] = stack[-1] // @12C2 stack[-9] = stack[-3] // @12C4 stack[-8] = stack[-2] // @12C5 stack[-10] = stack[-4] // } // Block ends with unconditional jump to stack[-10] label_12C7: // Incoming jump from 0x058C // Inputs[1] { @12D3 stack[-3] } 12C7 5B JUMPDEST 12C8 60 PUSH1 0x60 12CA 80 DUP1 12CB 60 PUSH1 0x60 12CD 80 DUP1 12CE 60 PUSH1 0x00 12D0 80 DUP1 12D1 60 PUSH1 0x00 12D3 89 DUP10 12D4 11 GT 12D5 61 PUSH2 0x12dd 12D8 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @12C8 stack[0] = 0x60 // @12CA stack[1] = 0x60 // @12CB stack[2] = 0x60 // @12CD stack[3] = 0x60 // @12CE stack[4] = 0x00 // @12D0 stack[5] = 0x00 // } // Block ends with conditional jump to 0x12dd, if stack[-3] > 0x00 label_12D9: // Incoming jump from 0x12D8, if not stack[-3] > 0x00 // Inputs[1] { @12DC memory[0x00:0x00] } 12D9 60 PUSH1 0x00 12DB 80 DUP1 12DC FD *REVERT // Stack delta = +0 // Outputs[1] { @12DC revert(memory[0x00:0x00]); } // Block terminates label_12DD: // Incoming jump from 0x12D8, if stack[-3] > 0x00 // Inputs[4] // { // @12E6 stack[-10] // @12F5 memory[0x00:0x40] // @12F6 storage[keccak256(memory[0x00:0x40])] // @12F7 stack[-2] // } 12DD 5B JUMPDEST 12DE 60 PUSH1 0x01 12E0 60 PUSH1 0x01 12E2 60 PUSH1 0xa0 12E4 1B SHL 12E5 03 SUB 12E6 8A DUP11 12E7 16 AND 12E8 60 PUSH1 0x00 12EA 90 SWAP1 12EB 81 DUP2 12EC 52 MSTORE 12ED 60 PUSH1 0x02 12EF 60 PUSH1 0x20 12F1 52 MSTORE 12F2 60 PUSH1 0x40 12F4 90 SWAP1 12F5 20 SHA3 12F6 54 SLOAD 12F7 91 SWAP2 12F8 50 POP 12F9 81 DUP2 12FA 15 ISZERO 12FB 61 PUSH2 0x1436 12FE 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @12EC memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @12F1 memory[0x20:0x40] = 0x02 // @12F7 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1436, if !storage[keccak256(memory[0x00:0x40])] label_12FF: // Incoming jump from 0x12FE, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1302 stack[-9] // @1303 stack[-2] // } 12FF 61 PUSH2 0x1308 1302 89 DUP10 1303 83 DUP4 1304 61 PUSH2 0x1f3f 1307 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12FF stack[0] = 0x1308 // @1302 stack[1] = stack[-9] // @1303 stack[2] = stack[-2] // } // Block ends with call to 0x1f3f, returns to 0x1308 label_1308: // Incoming return from call to 0x1F3F at 0x1307 // Inputs[1] { @1309 stack[-1] } 1308 5B JUMPDEST 1309 15 ISZERO 130A 61 PUSH2 0x1314 130D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1314, if !stack[-1] label_130E: // Incoming jump from 0x130D, if not !stack[-1] 130E 60 PUSH1 0x01 1310 61 PUSH2 0x1317 1313 56 *JUMP // Stack delta = +1 // Outputs[1] { @130E stack[0] = 0x01 } // Block ends with unconditional jump to 0x1317 label_1314: // Incoming jump from 0x130D, if !stack[-1] // Inputs[2] // { // @131E stack[-9] // @131F stack[-2] // } 1314 5B JUMPDEST 1315 60 PUSH1 0x00 1317 5B JUMPDEST 1318 60 PUSH1 0xff 131A 16 AND 131B 61 PUSH2 0x1324 131E 8A DUP11 131F 84 DUP5 1320 61 PUSH2 0x1f53 1323 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @131A stack[0] = 0xff & 0x00 // @131B stack[1] = 0x1324 // @131E stack[2] = stack[-9] // @131F stack[3] = stack[-2] // } // Block ends with call to 0x1f53, returns to 0x1324 label_1324: // Incoming return from call to 0x1F53 at 0x1323 // Incoming return from call to 0x1F53 at 0x1323 // Inputs[2] // { // @1328 stack[-2] // @1329 stack[-1] // } 1324 5B JUMPDEST 1325 61 PUSH2 0x132e 1328 91 SWAP2 1329 90 SWAP1 132A 61 PUSH2 0x1f67 132D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1328 stack[-2] = 0x132e // @1329 stack[-1] = stack[-2] // @1329 stack[0] = stack[-1] // } // Block ends with call to 0x1f67, returns to 0x132E label_132E: // Incoming return from call to 0x1F67 at 0x132D // Inputs[3] // { // @132F stack[-2] // @132F stack[-1] // @1332 stack[-9] // } 132E 5B JUMPDEST 132F 90 SWAP1 1330 50 POP 1331 80 DUP1 1332 88 DUP9 1333 10 LT 1334 61 PUSH2 0x133c 1337 57 *JUMPI // Stack delta = -1 // Outputs[1] { @132F stack[-2] = stack[-1] } // Block ends with conditional jump to 0x133c, if stack[-9] < stack[-1] label_1338: // Incoming jump from 0x1337, if not stack[-9] < stack[-1] // Inputs[1] { @133B memory[0x00:0x00] } 1338 60 PUSH1 0x00 133A 80 DUP1 133B FD *REVERT // Stack delta = +0 // Outputs[1] { @133B revert(memory[0x00:0x00]); } // Block terminates label_133C: // Incoming jump from 0x1337, if stack[-9] < stack[-1] // Inputs[2] // { // @1342 stack[-8] // @1343 stack[-9] // } 133C 5B JUMPDEST 133D 60 PUSH1 0x00 133F 61 PUSH2 0x1348 1342 89 DUP10 1343 8B DUP12 1344 61 PUSH2 0x1f7f 1347 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @133D stack[0] = 0x00 // @133F stack[1] = 0x1348 // @1342 stack[2] = stack[-8] // @1343 stack[3] = stack[-9] // } // Block ends with call to 0x1f7f, returns to 0x1348 label_1348: // Incoming return from call to 0x1F7F at 0x1347 // Inputs[3] // { // @1349 stack[-2] // @1349 stack[-1] // @1350 stack[-3] // } 1348 5B JUMPDEST 1349 90 SWAP1 134A 50 POP 134B 61 PUSH2 0x1355 134E 60 PUSH1 0x01 1350 83 DUP4 1351 61 PUSH2 0x1f9e 1354 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1349 stack[-2] = stack[-1] // @134B stack[-1] = 0x1355 // @134E stack[0] = 0x01 // @1350 stack[1] = stack[-3] // } // Block ends with call to 0x1f9e, returns to 0x1355 label_1355: // Incoming return from call to 0x1F9E at 0x1354 // Inputs[2] // { // @1356 stack[-10] // @1357 stack[-1] // } 1355 5B JUMPDEST 1356 89 DUP10 1357 14 EQ 1358 80 DUP1 1359 15 ISZERO 135A 61 PUSH2 0x136b 135D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1357 stack[-1] = stack[-10] == stack[-1] } // Block ends with conditional jump to 0x136b, if !(stack[-10] == stack[-1]) label_135E: // Incoming jump from 0x135D, if not !(stack[-10] == stack[-1]) // Inputs[2] // { // @1362 stack[-11] // @1363 stack[-4] // } 135E 50 POP 135F 61 PUSH2 0x1368 1362 8A DUP11 1363 84 DUP5 1364 61 PUSH2 0x1f3f 1367 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @135F stack[-1] = 0x1368 // @1362 stack[0] = stack[-11] // @1363 stack[1] = stack[-4] // } // Block ends with call to 0x1f3f, returns to 0x1368 label_1368: // Incoming return from call to 0x1F3F at 0x1367 // Inputs[1] { @1369 stack[-1] } 1368 5B JUMPDEST 1369 15 ISZERO 136A 15 ISZERO // Stack delta = +0 // Outputs[1] { @136A stack[-1] = !!stack[-1] } // Block continues label_136B: // Incoming jump from 0x135D, if !(stack[-10] == stack[-1]) // Incoming jump from 0x136A // Inputs[1] { @136C stack[-1] } 136B 5B JUMPDEST 136C 15 ISZERO 136D 61 PUSH2 0x137d 1370 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x137d, if !stack[-1] label_1371: // Incoming jump from 0x1370, if not !stack[-1] // Inputs[2] // { // @1374 stack[-10] // @1375 stack[-3] // } 1371 61 PUSH2 0x137a 1374 8A DUP11 1375 84 DUP5 1376 61 PUSH2 0x1f3f 1379 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1371 stack[0] = 0x137a // @1374 stack[1] = stack[-10] // @1375 stack[2] = stack[-3] // } // Block ends with call to 0x1f3f, returns to 0x137A label_137A: // Incoming return from call to 0x1F3F at 0x1379 // Inputs[2] // { // @137B stack[-1] // @137B stack[-11] // } 137A 5B JUMPDEST 137B 99 SWAP10 137C 50 POP // Stack delta = -1 // Outputs[1] { @137B stack[-11] = stack[-1] } // Block continues label_137D: // Incoming jump from 0x1370, if !stack[-1] // Incoming jump from 0x137C // Inputs[1] { @137E stack[-10] } 137D 5B JUMPDEST 137E 89 DUP10 137F 60 PUSH1 0x01 1381 60 PUSH1 0x01 1383 60 PUSH1 0x40 1385 1B SHL 1386 03 SUB 1387 81 DUP2 1388 11 GT 1389 15 ISZERO 138A 61 PUSH2 0x1395 138D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @137E stack[0] = stack[-10] } // Block ends with conditional jump to 0x1395, if !(stack[-10] > (0x01 << 0x40) - 0x01) label_138E: // Incoming jump from 0x138D, if not !(stack[-10] > (0x01 << 0x40) - 0x01) 138E 61 PUSH2 0x1395 1391 61 PUSH2 0x190e 1394 56 *JUMP // Stack delta = +1 // Outputs[1] { @138E stack[0] = 0x1395 } // Block ends with unconditional jump to 0x190e label_1395: // Incoming jump from 0x138D, if !(stack[-10] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1398 memory[0x40:0x60] // @1399 stack[-1] // } 1395 5B JUMPDEST 1396 60 PUSH1 0x40 1398 51 MLOAD 1399 90 SWAP1 139A 80 DUP1 139B 82 DUP3 139C 52 MSTORE 139D 80 DUP1 139E 60 PUSH1 0x20 13A0 02 MUL 13A1 60 PUSH1 0x20 13A3 01 ADD 13A4 82 DUP3 13A5 01 ADD 13A6 60 PUSH1 0x40 13A8 52 MSTORE 13A9 80 DUP1 13AA 15 ISZERO 13AB 61 PUSH2 0x13be 13AE 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1399 stack[-1] = memory[0x40:0x60] // @1399 stack[0] = stack[-1] // @139C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @13A8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x13be, if !stack[-1] label_13AF: // Incoming jump from 0x13AE, if not !stack[-1] // Inputs[6] // { // @13AF stack[-2] // @13B5 stack[-1] // @13B8 msg.data.length // @13BA msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @13C0 stack[-9] // @13C5 stack[-12] // } 13AF 81 DUP2 13B0 60 PUSH1 0x20 13B2 01 ADD 13B3 60 PUSH1 0x20 13B5 82 DUP3 13B6 02 MUL 13B7 80 DUP1 13B8 36 CALLDATASIZE 13B9 83 DUP4 13BA 37 CALLDATACOPY 13BB 01 ADD 13BC 90 SWAP1 13BD 50 POP 13BE 5B JUMPDEST 13BF 50 POP 13C0 96 SWAP7 13C1 50 POP 13C2 60 PUSH1 0x00 13C4 5B JUMPDEST 13C5 8A DUP11 13C6 81 DUP2 13C7 10 LT 13C8 15 ISZERO 13C9 61 PUSH2 0x142f 13CC 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @13BA memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @13C0 stack[-9] = stack[-2] // @13C2 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x142f, if !(0x00 < stack[-12]) label_13CD: // Incoming jump from 0x13CC, if not !(0x00 < stack[-12]) // Incoming jump from 0x13CC, if not !(0x00 < stack[-12]) // Inputs[2] // { // @13D0 stack[-12] // @13D1 stack[-9] // } 13CD 61 PUSH2 0x1400 13D0 8C DUP13 13D1 8A DUP11 13D2 61 PUSH2 0x13f6 13D5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13CD stack[0] = 0x1400 // @13D0 stack[1] = stack[-12] // } // Block ends with conditional jump to 0x13f6, if stack[-9] label_13D6: // Incoming jump from 0x13D5, if not stack[-9] // Inputs[3] // { // @13D8 stack[-3] // @13DC stack[-4] // @13DD stack[-6] // } 13D6 60 PUSH1 0x01 13D8 83 DUP4 13D9 61 PUSH2 0x13e2 13DC 86 DUP7 13DD 89 DUP10 13DE 61 PUSH2 0x1f9e 13E1 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @13D6 stack[0] = 0x01 // @13D8 stack[1] = stack[-3] // @13D9 stack[2] = 0x13e2 // @13DC stack[3] = stack[-4] // @13DD stack[4] = stack[-6] // } // Block ends with call to 0x1f9e, returns to 0x13E2 label_13E2: // Incoming return from call to 0x1F9E at 0x13E1 // Inputs[2] // { // @13E6 stack[-2] // @13E7 stack[-1] // } 13E2 5B JUMPDEST 13E3 61 PUSH2 0x13ec 13E6 91 SWAP2 13E7 90 SWAP1 13E8 61 PUSH2 0x1f9e 13EB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13E6 stack[-2] = 0x13ec // @13E7 stack[-1] = stack[-2] // @13E7 stack[0] = stack[-1] // } // Block ends with call to 0x1f9e, returns to 0x13EC label_13EC: // Incoming return from call to 0x1F9E at 0x13EB // Inputs[2] // { // @13F0 stack[-2] // @13F1 stack[-1] // } 13EC 5B JUMPDEST 13ED 61 PUSH2 0x0316 13F0 91 SWAP2 13F1 90 SWAP1 13F2 61 PUSH2 0x1f9e 13F5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13F0 stack[-2] = 0x0316 // @13F1 stack[-1] = stack[-2] // @13F1 stack[0] = stack[-1] // } // Block ends with call to 0x1f9e, returns to 0x0316 label_13F6: // Incoming jump from 0x13D5, if stack[-9] // Inputs[2] // { // @13FA stack[-3] // @13FB stack[-4] // } 13F6 5B JUMPDEST 13F7 61 PUSH2 0x0316 13FA 83 DUP4 13FB 85 DUP6 13FC 61 PUSH2 0x1f67 13FF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13F7 stack[0] = 0x0316 // @13FA stack[1] = stack[-3] // @13FB stack[2] = stack[-4] // } // Block ends with call to 0x1f67, returns to 0x0316 1400 5B JUMPDEST 1401 88 DUP9 1402 82 DUP3 1403 81 DUP2 1404 51 MLOAD 1405 81 DUP2 1406 10 LT 1407 61 PUSH2 0x1412 140A 57 *JUMPI 140B 61 PUSH2 0x1412 140E 61 PUSH2 0x1ee2 1411 56 *JUMP 1412 5B JUMPDEST 1413 60 PUSH1 0x20 1415 90 SWAP1 1416 81 DUP2 1417 02 MUL 1418 91 SWAP2 1419 90 SWAP1 141A 91 SWAP2 141B 01 ADD 141C 01 ADD 141D 52 MSTORE 141E 80 DUP1 141F 61 PUSH2 0x1427 1422 81 DUP2 1423 61 PUSH2 0x1f0e 1426 56 *JUMP 1427 5B JUMPDEST 1428 91 SWAP2 1429 50 POP 142A 50 POP 142B 61 PUSH2 0x13c4 142E 56 *JUMP label_142F: // Incoming jump from 0x13CC, if !(0x00 < stack[-12]) // Incoming jump from 0x13CC, if !(0x00 < stack[-12]) 142F 5B JUMPDEST 1430 50 POP 1431 50 POP 1432 61 PUSH2 0x144a 1435 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x144a label_1436: // Incoming jump from 0x12FE, if !storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @143B memory[0x40:0x60] // @1448 stack[-6] // } 1436 5B JUMPDEST 1437 50 POP 1438 60 PUSH1 0x40 143A 80 DUP1 143B 51 MLOAD 143C 60 PUSH1 0x00 143E 80 DUP1 143F 82 DUP3 1440 52 MSTORE 1441 60 PUSH1 0x20 1443 82 DUP3 1444 01 ADD 1445 90 SWAP1 1446 92 SWAP3 1447 52 MSTORE 1448 95 SWAP6 1449 50 POP 144A 5B JUMPDEST 144B 61 PUSH2 0x1453 144E 86 DUP7 144F 61 PUSH2 0x07bd 1452 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1440 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1446 stack[-1] = 0x00 // @1447 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1448 stack[-6] = memory[0x40:0x60] // @144B stack[0] = 0x1453 // @144E stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x07bd, returns to 0x1453 label_1453: // Incoming return from call to 0x07BD at 0x1452 // Incoming return from call to 0x07BD at 0x1452 // Inputs[13] // { // @1454 stack[-10] // @1454 stack[-1] // @1455 stack[-15] // @1456 stack[-3] // @1457 stack[-14] // @1459 stack[-13] // @1459 stack[-2] // @145C stack[-12] // @145E stack[-6] // @145E stack[-4] // @145F stack[-11] // @1461 stack[-5] // @1462 stack[-9] // } 1453 5B JUMPDEST 1454 98 SWAP9 1455 9D SWAP14 1456 91 SWAP2 1457 9C SWAP13 1458 50 POP 1459 9A SWAP11 145A 50 POP 145B 96 SWAP7 145C 98 SWAP9 145D 50 POP 145E 91 SWAP2 145F 96 SWAP7 1460 50 POP 1461 94 SWAP5 1462 93 SWAP4 1463 50 POP 1464 50 POP 1465 50 POP 1466 50 POP 1467 56 *JUMP // Stack delta = -9 // Outputs[6] // { // @1455 stack[-15] = stack[-10] // @1457 stack[-14] = stack[-3] // @1459 stack[-13] = stack[-2] // @145C stack[-12] = stack[-1] // @145F stack[-11] = stack[-6] // @1461 stack[-10] = stack[-5] // } // Block ends with unconditional jump to stack[-15] label_1468: // Incoming jump from 0x05B1 // Inputs[2] // { // @146B storage[0x05] // @1475 msg.sender // } 1468 5B JUMPDEST 1469 60 PUSH1 0x05 146B 54 SLOAD 146C 60 PUSH1 0x01 146E 60 PUSH1 0x01 1470 60 PUSH1 0xa0 1472 1B SHL 1473 03 SUB 1474 16 AND 1475 33 CALLER 1476 14 EQ 1477 61 PUSH2 0x147f 147A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x147f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_147B: // Incoming jump from 0x147A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @147E memory[0x00:0x00] } 147B 60 PUSH1 0x00 147D 80 DUP1 147E FD *REVERT // Stack delta = +0 // Outputs[1] { @147E revert(memory[0x00:0x00]); } // Block terminates label_147F: // Incoming jump from 0x147A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[3] // { // @1483 storage[0x03] // @1496 stack[-1] // @14A0 stack[-2] // } 147F 5B JUMPDEST 1480 60 PUSH1 0x03 1482 80 DUP1 1483 54 SLOAD 1484 60 PUSH1 0x01 1486 60 PUSH1 0x01 1488 60 PUSH1 0xa0 148A 1B SHL 148B 03 SUB 148C 19 NOT 148D 16 AND 148E 60 PUSH1 0x01 1490 60 PUSH1 0x01 1492 60 PUSH1 0xa0 1494 1B SHL 1495 03 SUB 1496 92 SWAP3 1497 90 SWAP1 1498 92 SWAP3 1499 16 AND 149A 91 SWAP2 149B 90 SWAP1 149C 91 SWAP2 149D 17 OR 149E 90 SWAP1 149F 55 SSTORE 14A0 56 *JUMP // Stack delta = -2 // Outputs[1] { @149F storage[0x03] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x03]) } // Block ends with unconditional jump to stack[-2] label_14A1: // Incoming call from 0x1045, returns to 0x1046 // Incoming jump from 0x05C4 // Inputs[2] // { // @14A5 storage[0x00] // @14A6 stack[-1] // } 14A1 5B JUMPDEST 14A2 60 PUSH1 0x00 14A4 80 DUP1 14A5 54 SLOAD 14A6 82 DUP3 14A7 10 LT 14A8 61 PUSH2 0x14b0 14AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x14b0, if stack[-1] < storage[0x00] label_14AC: // Incoming jump from 0x14AB, if not stack[-1] < storage[0x00] // Inputs[1] { @14AF memory[0x00:0x00] } 14AC 60 PUSH1 0x00 14AE 80 DUP1 14AF FD *REVERT // Stack delta = +0 // Outputs[1] { @14AF revert(memory[0x00:0x00]); } // Block terminates label_14B0: // Incoming jump from 0x14AB, if stack[-1] < storage[0x00] // Inputs[4] // { // @14B4 stack[-2] // @14BF memory[0x00:0x40] // @14C3 storage[0x03 + keccak256(memory[0x00:0x40])] // @14CD stack[-3] // } 14B0 5B JUMPDEST 14B1 50 POP 14B2 60 PUSH1 0x00 14B4 90 SWAP1 14B5 81 DUP2 14B6 52 MSTORE 14B7 60 PUSH1 0x01 14B9 60 PUSH1 0x20 14BB 52 MSTORE 14BC 60 PUSH1 0x40 14BE 90 SWAP1 14BF 20 SHA3 14C0 60 PUSH1 0x03 14C2 01 ADD 14C3 54 SLOAD 14C4 60 PUSH1 0x01 14C6 60 PUSH1 0x01 14C8 60 PUSH1 0x80 14CA 1B SHL 14CB 03 SUB 14CC 16 AND 14CD 90 SWAP1 14CE 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @14B6 memory[0x00:0x20] = stack[-2] // @14BB memory[0x20:0x40] = 0x01 // @14CD stack[-3] = (0x01 << 0x80) - 0x01 & storage[0x03 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_14CF: // Incoming call from 0x1140, returns to 0x1141 // Incoming call from 0x0764, returns to 0x0765 // Inputs[1] { @14D5 stack[-1] } 14CF 5B JUMPDEST 14D0 60 PUSH1 0x00 14D2 61 PUSH2 0x14da 14D5 82 DUP3 14D6 61 PUSH2 0x0a11 14D9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14D0 stack[0] = 0x00 // @14D2 stack[1] = 0x14da // @14D5 stack[2] = stack[-1] // } // Block ends with call to 0x0a11, returns to 0x14DA label_14DA: // Incoming return from call to 0x0A11 at 0x14D9 // Inputs[3] // { // @14DB stack[-2] // @14DB stack[-1] // @14E2 stack[-3] // } 14DA 5B JUMPDEST 14DB 90 SWAP1 14DC 50 POP 14DD 60 PUSH1 0x00 14DF 61 PUSH2 0x14e7 14E2 83 DUP4 14E3 61 PUSH2 0x063c 14E6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @14DB stack[-2] = stack[-1] // @14DD stack[-1] = 0x00 // @14DF stack[0] = 0x14e7 // @14E2 stack[1] = stack[-3] // } // Block ends with call to 0x063c, returns to 0x14E7 label_14E7: // Incoming return from call to 0x063C at 0x14E6 // Inputs[4] // { // @14E8 stack[-2] // @14E8 stack[-1] // @14EA stack[-3] // @14F4 stack[-6] // } 14E7 5B JUMPDEST 14E8 90 SWAP1 14E9 50 POP 14EA 81 DUP2 14EB 60 PUSH1 0x01 14ED 60 PUSH1 0x01 14EF 60 PUSH1 0xa0 14F1 1B SHL 14F2 03 SUB 14F3 16 AND 14F4 85 DUP6 14F5 60 PUSH1 0x01 14F7 60 PUSH1 0x01 14F9 60 PUSH1 0xa0 14FB 1B SHL 14FC 03 SUB 14FD 16 AND 14FE 14 EQ 14FF 61 PUSH2 0x1507 1502 57 *JUMPI // Stack delta = -1 // Outputs[1] { @14E8 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1507, if (0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-3] label_1503: // Incoming jump from 0x1502, if not (0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[1] { @1506 memory[0x00:0x00] } 1503 60 PUSH1 0x00 1505 80 DUP1 1506 FD *REVERT // Stack delta = +0 // Outputs[1] { @1506 revert(memory[0x00:0x00]); } // Block terminates label_1507: // Incoming jump from 0x1502, if (0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @1508 msg.sender // @1511 stack[-2] // } 1507 5B JUMPDEST 1508 33 CALLER 1509 60 PUSH1 0x01 150B 60 PUSH1 0x01 150D 60 PUSH1 0xa0 150F 1B SHL 1510 03 SUB 1511 83 DUP4 1512 16 AND 1513 14 EQ 1514 80 DUP1 1515 61 PUSH2 0x1526 1518 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1513 stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x1526, if stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender label_1519: // Incoming jump from 0x1518, if not stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @151A msg.sender // @1523 stack[-2] // } 1519 50 POP 151A 33 CALLER 151B 60 PUSH1 0x01 151D 60 PUSH1 0x01 151F 60 PUSH1 0xa0 1521 1B SHL 1522 03 SUB 1523 82 DUP3 1524 16 AND 1525 14 EQ 1526 5B JUMPDEST 1527 80 DUP1 1528 61 PUSH2 0x1556 152B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1525 stack[-1] = stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x1556, if stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender label_152C: // Incoming jump from 0x152B, if not stack[-1] // Incoming jump from 0x152B, if not stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[5] // { // @1535 stack[-3] // @1547 memory[0x00:0x40] // @1548 msg.sender // @1551 memory[0x00:0x40] // @1552 storage[keccak256(memory[0x00:0x40])] // } 152C 50 POP 152D 60 PUSH1 0x01 152F 60 PUSH1 0x01 1531 60 PUSH1 0xa0 1533 1B SHL 1534 03 SUB 1535 82 DUP3 1536 16 AND 1537 60 PUSH1 0x00 1539 90 SWAP1 153A 81 DUP2 153B 52 MSTORE 153C 60 PUSH1 0x02 153E 60 PUSH1 0x20 1540 81 DUP2 1541 81 DUP2 1542 52 MSTORE 1543 60 PUSH1 0x40 1545 80 DUP1 1546 84 DUP5 1547 20 SHA3 1548 33 CALLER 1549 85 DUP6 154A 52 MSTORE 154B 90 SWAP1 154C 92 SWAP3 154D 01 ADD 154E 90 SWAP1 154F 52 MSTORE 1550 90 SWAP1 1551 20 SHA3 1552 54 SLOAD 1553 60 PUSH1 0xff 1555 16 AND 1556 5B JUMPDEST 1557 61 PUSH2 0x155f 155A 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @153B memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1542 memory[0x20:0x40] = 0x02 // @154A memory[0x00:0x20] = msg.sender // @154F memory[0x20:0x40] = 0x02 + keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x155f, if 0xff & storage[keccak256(memory[0x00:0x40])] label_155B: // Incoming jump from 0x155A, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x155A, if not stack[-1] // Inputs[1] { @155E memory[0x00:0x00] } 155B 60 PUSH1 0x00 155D 80 DUP1 155E FD *REVERT // Stack delta = +0 // Outputs[1] { @155E revert(memory[0x00:0x00]); } // Block terminates label_155F: // Incoming jump from 0x155A, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x155A, if stack[-1] // Inputs[5] // { // @1562 stack[-3] // @1570 memory[0x00:0x40] // @1573 storage[keccak256(memory[0x00:0x40]) + 0x01] // @1586 stack[-4] // @1590 stack[-1] // } 155F 5B JUMPDEST 1560 60 PUSH1 0x00 1562 83 DUP4 1563 81 DUP2 1564 52 MSTORE 1565 60 PUSH1 0x01 1567 60 PUSH1 0x20 1569 81 DUP2 156A 90 SWAP1 156B 52 MSTORE 156C 60 PUSH1 0x40 156E 90 SWAP1 156F 91 SWAP2 1570 20 SHA3 1571 01 ADD 1572 80 DUP1 1573 54 SLOAD 1574 60 PUSH1 0x01 1576 60 PUSH1 0x01 1578 60 PUSH1 0xa0 157A 1B SHL 157B 03 SUB 157C 19 NOT 157D 16 AND 157E 60 PUSH1 0x01 1580 60 PUSH1 0x01 1582 60 PUSH1 0xa0 1584 1B SHL 1585 03 SUB 1586 86 DUP7 1587 81 DUP2 1588 16 AND 1589 91 SWAP2 158A 90 SWAP1 158B 91 SWAP2 158C 17 OR 158D 90 SWAP1 158E 91 SWAP2 158F 55 SSTORE 1590 81 DUP2 1591 16 AND 1592 15 ISZERO 1593 61 PUSH2 0x15e2 1596 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1564 memory[0x00:0x20] = stack[-3] // @156B memory[0x20:0x40] = 0x01 // @158F storage[keccak256(memory[0x00:0x40]) + 0x01] = ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40]) + 0x01]) // } // Block ends with conditional jump to 0x15e2, if !(stack[-1] & (0x01 << 0xa0) - 0x01) label_1597: // Incoming jump from 0x1596, if not !(stack[-1] & (0x01 << 0xa0) - 0x01) // Inputs[9] // { // @1599 stack[-3] // @15A5 memory[0x00:0x40] // @15AA storage[0x02 + keccak256(memory[0x00:0x40])] // @15B7 memory[0x40:0x60] // @15E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @15EB stack[-5] // @15FD memory[0x00:0x40] // @1608 memory[0x00:0x40] // @1609 storage[keccak256(memory[0x00:0x40])] // } 1597 60 PUSH1 0x00 1599 83 DUP4 159A 81 DUP2 159B 52 MSTORE 159C 60 PUSH1 0x01 159E 60 PUSH1 0x20 15A0 52 MSTORE 15A1 60 PUSH1 0x40 15A3 80 DUP1 15A4 82 DUP3 15A5 20 SHA3 15A6 60 PUSH1 0x02 15A8 01 ADD 15A9 80 DUP1 15AA 54 SLOAD 15AB 60 PUSH1 0x01 15AD 60 PUSH1 0x01 15AF 60 PUSH1 0xa0 15B1 1B SHL 15B2 03 SUB 15B3 19 NOT 15B4 16 AND 15B5 90 SWAP1 15B6 55 SSTORE 15B7 51 MLOAD 15B8 84 DUP5 15B9 91 SWAP2 15BA 90 SWAP1 15BB 81 DUP2 15BC 90 SWAP1 15BD 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 15DE 90 SWAP1 15DF 82 DUP3 15E0 90 SWAP1 15E1 A4 LOG4 15E2 5B JUMPDEST 15E3 60 PUSH1 0x01 15E5 60 PUSH1 0x01 15E7 60 PUSH1 0xa0 15E9 1B SHL 15EA 03 SUB 15EB 85 DUP6 15EC 16 AND 15ED 60 PUSH1 0x00 15EF 90 SWAP1 15F0 81 DUP2 15F1 52 MSTORE 15F2 60 PUSH1 0x02 15F4 60 PUSH1 0x20 15F6 90 SWAP1 15F7 81 DUP2 15F8 52 MSTORE 15F9 60 PUSH1 0x40 15FB 80 DUP1 15FC 83 DUP4 15FD 20 SHA3 15FE 86 DUP7 15FF 84 DUP5 1600 52 MSTORE 1601 60 PUSH1 0x03 1603 01 ADD 1604 90 SWAP1 1605 91 SWAP2 1606 52 MSTORE 1607 81 DUP2 1608 20 SHA3 1609 54 SLOAD 160A 61 PUSH2 0x1615 160D 90 SWAP1 160E 60 PUSH1 0x01 1610 90 SWAP1 1611 61 PUSH2 0x1f9e 1614 56 *JUMP // Stack delta = +4 // Outputs[12] // { // @159B memory[0x00:0x20] = stack[-3] // @15A0 memory[0x20:0x40] = 0x01 // @15B6 storage[0x02 + keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[0x02 + keccak256(memory[0x00:0x40])] // @15E1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, 0x00, 0x00, stack[-3]]); // @15EF stack[0] = 0x00 // @15F1 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @15F8 memory[0x20:0x40] = 0x02 // @1600 memory[0x00:0x20] = stack[-3] // @1606 memory[0x20:0x40] = 0x03 + keccak256(memory[0x00:0x40]) // @160D stack[1] = 0x1615 // @1610 stack[2] = 0x01 // @1610 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1f9e, returns to 0x1615 label_1615: // Incoming return from call to 0x1F9E at 0x1614 // Incoming return from call to 0x1F9E at 0x1614 // Inputs[5] // { // @161E stack[-7] // @162D memory[0x00:0x40] // @162F storage[keccak256(memory[0x00:0x40])] // @1630 stack[-1] // @1631 stack[-2] // } 1615 5B JUMPDEST 1616 60 PUSH1 0x01 1618 60 PUSH1 0x01 161A 60 PUSH1 0xa0 161C 1B SHL 161D 03 SUB 161E 87 DUP8 161F 16 AND 1620 60 PUSH1 0x00 1622 90 SWAP1 1623 81 DUP2 1624 52 MSTORE 1625 60 PUSH1 0x02 1627 60 PUSH1 0x20 1629 52 MSTORE 162A 60 PUSH1 0x40 162C 81 DUP2 162D 20 SHA3 162E 80 DUP1 162F 54 SLOAD 1630 92 SWAP3 1631 93 SWAP4 1632 50 POP 1633 90 SWAP1 1634 91 SWAP2 1635 60 PUSH1 0x01 1637 91 SWAP2 1638 82 DUP3 1639 01 ADD 163A 91 SWAP2 163B 83 DUP4 163C 91 SWAP2 163D 61 PUSH2 0x1646 1640 91 SWAP2 1641 90 SWAP1 1642 61 PUSH2 0x1f9e 1645 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @1624 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @1629 memory[0x20:0x40] = 0x02 // @1631 stack[-2] = stack[-1] // @1634 stack[-1] = 0x00 // @163A stack[0] = 0x01 + keccak256(memory[0x00:0x40]) // @163C stack[1] = 0x00 // @1640 stack[2] = 0x1646 // @1641 stack[3] = 0x01 // @1641 stack[4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1f9e, returns to 0x1646 label_1646: // Incoming return from call to 0x1F9E at 0x1645 // Inputs[10] // { // @1647 stack[-2] // @1648 stack[-1] // @164E stack[-3] // @165B memory[0x00:0x00 + 0x40 + stack[-2]] // @165C storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // @1665 stack[-10] // @166F memory[0x00:0x40] // @1670 stack[-5] // @167D memory[0x00:0x40] // @1681 stack[-4] // } 1646 5B JUMPDEST 1647 81 DUP2 1648 52 MSTORE 1649 60 PUSH1 0x20 164B 80 DUP1 164C 82 DUP3 164D 01 ADD 164E 92 SWAP3 164F 90 SWAP1 1650 92 SWAP3 1651 52 MSTORE 1652 60 PUSH1 0x40 1654 90 SWAP1 1655 81 DUP2 1656 01 ADD 1657 60 PUSH1 0x00 1659 90 SWAP1 165A 81 DUP2 165B 20 SHA3 165C 54 SLOAD 165D 60 PUSH1 0x01 165F 60 PUSH1 0x01 1661 60 PUSH1 0xa0 1663 1B SHL 1664 03 SUB 1665 8B DUP12 1666 16 AND 1667 82 DUP3 1668 52 MSTORE 1669 60 PUSH1 0x02 166B 84 DUP5 166C 52 MSTORE 166D 82 DUP3 166E 82 DUP3 166F 20 SHA3 1670 86 DUP7 1671 83 DUP4 1672 52 MSTORE 1673 60 PUSH1 0x01 1675 90 SWAP1 1676 81 DUP2 1677 01 ADD 1678 90 SWAP1 1679 94 SWAP5 167A 52 MSTORE 167B 91 SWAP2 167C 90 SWAP1 167D 20 SHA3 167E 81 DUP2 167F 90 SWAP1 1680 55 SSTORE 1681 91 SWAP2 1682 50 POP 1683 61 PUSH2 0x168d 1686 90 SWAP1 1687 83 DUP4 1688 90 SWAP1 1689 61 PUSH2 0x1f67 168C 56 *JUMP // Stack delta = +0 // Outputs[11] // { // @1648 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1651 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @1668 memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @166C memory[0x20:0x40] = 0x02 // @1672 memory[0x00:0x20] = stack[-5] // @167A memory[0x20:0x40] = 0x01 + keccak256(memory[0x00:0x40]) // @1680 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // @1681 stack[-4] = storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // @1686 stack[-3] = 0x168d // @1688 stack[-2] = stack[-5] // @1688 stack[-1] = 0x01 // } // Block ends with call to 0x1f67, returns to 0x168D label_168D: // Incoming return from call to 0x1F67 at 0x168C // Inputs[6] // { // @1696 stack[-8] // @16A8 memory[0x00:0x40] // @16A9 stack[-2] // @16B4 memory[0x00:0x40] // @16B5 stack[-1] // @16C0 storage[keccak256(memory[0x00:0x40])] // } 168D 5B JUMPDEST 168E 60 PUSH1 0x01 1690 60 PUSH1 0x01 1692 60 PUSH1 0xa0 1694 1B SHL 1695 03 SUB 1696 88 DUP9 1697 16 AND 1698 60 PUSH1 0x00 169A 81 DUP2 169B 81 DUP2 169C 52 MSTORE 169D 60 PUSH1 0x02 169F 60 PUSH1 0x20 16A1 81 DUP2 16A2 81 DUP2 16A3 52 MSTORE 16A4 60 PUSH1 0x40 16A6 80 DUP1 16A7 84 DUP5 16A8 20 SHA3 16A9 87 DUP8 16AA 85 DUP6 16AB 52 MSTORE 16AC 60 PUSH1 0x03 16AE 81 DUP2 16AF 01 ADD 16B0 83 DUP4 16B1 52 MSTORE 16B2 90 SWAP1 16B3 84 DUP5 16B4 20 SHA3 16B5 95 SWAP6 16B6 90 SWAP1 16B7 95 SWAP6 16B8 55 SSTORE 16B9 92 SWAP3 16BA 82 DUP3 16BB 52 MSTORE 16BC 90 SWAP1 16BD 91 SWAP2 16BE 52 MSTORE 16BF 81 DUP2 16C0 54 SLOAD 16C1 91 SWAP2 16C2 90 SWAP1 16C3 61 PUSH2 0x16cb 16C6 83 DUP4 16C7 61 PUSH2 0x200f 16CA 56 *JUMP // Stack delta = +4 // Outputs[12] // { // @169C memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @16A3 memory[0x20:0x40] = 0x02 // @16AB memory[0x00:0x20] = stack[-2] // @16B1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x03 // @16B8 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @16BB memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @16BE memory[0x20:0x40] = 0x02 // @16C1 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @16C2 stack[1] = 0x00 // @16C2 stack[0] = keccak256(memory[0x00:0x40]) // @16C3 stack[2] = 0x16cb // @16C6 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x200f, returns to 0x16CB label_16CB: // Incoming return from call to 0x200F at 0x16CA // Inputs[10] // { // @16CC stack[-1] // @16CC stack[-2] // @16CD stack[-3] // @16DA stack[-11] // @16EC memory[0x00:0x40] // @16ED stack[-9] // @16F7 memory[0x00:0x40] // @16FC stack[-10] // @1703 memory[0x00:0x40] // @1705 storage[keccak256(memory[0x00:0x40])] // } 16CB 5B JUMPDEST 16CC 90 SWAP1 16CD 91 SWAP2 16CE 55 SSTORE 16CF 50 POP 16D0 50 POP 16D1 60 PUSH1 0x01 16D3 60 PUSH1 0x01 16D5 60 PUSH1 0xa0 16D7 1B SHL 16D8 03 SUB 16D9 80 DUP1 16DA 88 DUP9 16DB 16 AND 16DC 60 PUSH1 0x00 16DE 90 SWAP1 16DF 81 DUP2 16E0 52 MSTORE 16E1 60 PUSH1 0x02 16E3 60 PUSH1 0x20 16E5 81 DUP2 16E6 81 DUP2 16E7 52 MSTORE 16E8 60 PUSH1 0x40 16EA 80 DUP1 16EB 84 DUP5 16EC 20 SHA3 16ED 8A DUP11 16EE 85 DUP6 16EF 52 MSTORE 16F0 60 PUSH1 0x03 16F2 01 ADD 16F3 82 DUP3 16F4 52 MSTORE 16F5 80 DUP1 16F6 84 DUP5 16F7 20 SHA3 16F8 84 DUP5 16F9 90 SWAP1 16FA 55 SSTORE 16FB 93 SWAP4 16FC 8A DUP11 16FD 16 AND 16FE 83 DUP4 16FF 52 MSTORE 1700 52 MSTORE 1701 90 SWAP1 1702 81 DUP2 1703 20 SHA3 1704 80 DUP1 1705 54 SLOAD 1706 90 SWAP1 1707 82 DUP3 1708 61 PUSH2 0x1710 170B 83 DUP4 170C 61 PUSH2 0x1f0e 170F 56 *JUMP // Stack delta = +2 // Outputs[14] // { // @16CE storage[stack[-3]] = stack[-1] // @16E0 memory[0x00:0x20] = stack[-11] & (0x01 << 0xa0) - 0x01 // @16E7 memory[0x20:0x40] = 0x02 // @16EF memory[0x00:0x20] = stack[-9] // @16F4 memory[0x20:0x40] = 0x03 + keccak256(memory[0x00:0x40]) // @16FA storage[keccak256(memory[0x00:0x40])] = 0x00 // @16FF memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @1700 memory[0x20:0x40] = 0x02 // @1701 stack[-4] = 0x00 // @1706 stack[-2] = keccak256(memory[0x00:0x40]) // @1706 stack[-3] = storage[keccak256(memory[0x00:0x40])] // @1707 stack[-1] = 0x00 // @1708 stack[0] = 0x1710 // @170B stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1f0e, returns to 0x1710 label_1710: // Incoming return from call to 0x1F0E at 0x170F // Inputs[5] // { // @1711 stack[-1] // @1711 stack[-2] // @1712 stack[-3] // @1715 stack[-4] // @1715 stack[-5] // } 1710 5B JUMPDEST 1711 90 SWAP1 1712 91 SWAP2 1713 55 SSTORE 1714 50 POP 1715 90 SWAP1 1716 50 POP 1717 61 PUSH2 0x1721 171A 81 DUP2 171B 60 PUSH1 0x01 171D 61 PUSH2 0x1f67 1720 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1713 storage[stack[-3]] = stack[-1] // @1715 stack[-5] = stack[-4] // @1717 stack[-4] = 0x1721 // @171A stack[-3] = stack[-4] // @171B stack[-2] = 0x01 // } // Block ends with call to 0x1f67, returns to 0x1721 label_1721: // Incoming return from call to 0x1F67 at 0x1720 // Inputs[11] // { // @172B stack[-8] // @173D memory[0x00:0x40] // @173E stack[-7] // @1749 memory[0x00:0x40] // @174A stack[-1] // @174E stack[-2] // @175A memory[0x00:0x40] // @175F memory[0x40:0x60] // @1764 stack[-9] // @1789 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1792 stack[-10] // } 1721 5B JUMPDEST 1722 60 PUSH1 0x01 1724 60 PUSH1 0x01 1726 60 PUSH1 0xa0 1728 1B SHL 1729 03 SUB 172A 80 DUP1 172B 89 DUP10 172C 16 AND 172D 60 PUSH1 0x00 172F 81 DUP2 1730 81 DUP2 1731 52 MSTORE 1732 60 PUSH1 0x02 1734 60 PUSH1 0x20 1736 90 SWAP1 1737 81 DUP2 1738 52 MSTORE 1739 60 PUSH1 0x40 173B 80 DUP1 173C 83 DUP4 173D 20 SHA3 173E 8C DUP13 173F 84 DUP5 1740 52 MSTORE 1741 60 PUSH1 0x03 1743 81 DUP2 1744 01 ADD 1745 83 DUP4 1746 52 MSTORE 1747 81 DUP2 1748 84 DUP5 1749 20 SHA3 174A 96 SWAP7 174B 90 SWAP1 174C 96 SWAP7 174D 55 SSTORE 174E 86 DUP7 174F 83 DUP4 1750 52 MSTORE 1751 60 PUSH1 0x01 1753 90 SWAP1 1754 95 SWAP6 1755 01 ADD 1756 90 SWAP1 1757 52 MSTORE 1758 83 DUP4 1759 81 DUP2 175A 20 SHA3 175B 8A DUP11 175C 90 SWAP1 175D 55 SSTORE 175E 92 SWAP3 175F 51 MLOAD 1760 89 DUP10 1761 93 SWAP4 1762 91 SWAP2 1763 92 SWAP3 1764 8C DUP13 1765 16 AND 1766 91 SWAP2 1767 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1788 91 SWAP2 1789 A4 LOG4 178A 50 POP 178B 50 POP 178C 50 POP 178D 50 POP 178E 50 POP 178F 50 POP 1790 50 POP 1791 50 POP 1792 56 *JUMP // Stack delta = -10 // Outputs[9] // { // @1731 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1738 memory[0x20:0x40] = 0x02 // @1740 memory[0x00:0x20] = stack[-7] // @1746 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x03 // @174D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1750 memory[0x00:0x20] = stack[-2] // @1757 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) + 0x01 // @175D storage[keccak256(memory[0x00:0x40])] = stack[-7] // @1789 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-9] & (0x01 << 0xa0) - 0x01, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7]]); // } // Block ends with unconditional jump to stack[-10] label_1793: // Incoming call from 0x103C, returns to 0x103D // Incoming call from 0x1293, returns to 0x1294 // Incoming call from 0x08D2, returns to 0x08D3 // Incoming call from 0x08D2, returns to 0x08D3 // Inputs[4] // { // @1796 memory[0x40:0x60] // @17A7 msg.data.length // @17A9 msg.data[msg.data.length:msg.data.length + 0x07 * 0x20] // @17AC stack[-1] // } 1793 5B JUMPDEST 1794 60 PUSH1 0x40 1796 51 MLOAD 1797 80 DUP1 1798 60 PUSH1 0xe0 179A 01 ADD 179B 60 PUSH1 0x40 179D 52 MSTORE 179E 80 DUP1 179F 60 PUSH1 0x07 17A1 90 SWAP1 17A2 60 PUSH1 0x20 17A4 82 DUP3 17A5 02 MUL 17A6 80 DUP1 17A7 36 CALLDATASIZE 17A8 83 DUP4 17A9 37 CALLDATACOPY 17AA 50 POP 17AB 91 SWAP2 17AC 92 SWAP3 17AD 91 SWAP2 17AE 50 POP 17AF 50 POP 17B0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @179D memory[0x40:0x60] = 0xe0 + memory[0x40:0x60] // @17A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x07 * 0x20] = msg.data[msg.data.length:msg.data.length + 0x07 * 0x20] // @17AC stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_17B1: // Incoming call from 0x17E6, returns to 0x0C31 // Incoming call from 0x200E, returns to 0x0C31 // Inputs[1] { @17BB stack[-1] } 17B1 5B JUMPDEST 17B2 60 PUSH1 0x01 17B4 60 PUSH1 0x01 17B6 60 PUSH1 0xe0 17B8 1B SHL 17B9 03 SUB 17BA 19 NOT 17BB 81 DUP2 17BC 16 AND 17BD 81 DUP2 17BE 14 EQ 17BF 61 PUSH2 0x17c7 17C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17c7, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_17C3: // Incoming jump from 0x17C2, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @17C6 memory[0x00:0x00] } 17C3 60 PUSH1 0x00 17C5 80 DUP1 17C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @17C6 revert(memory[0x00:0x00]); } // Block terminates label_17C7: // Incoming jump from 0x17C2, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x187F, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @17C9 stack[-2] } 17C7 5B JUMPDEST 17C8 50 POP 17C9 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_17CA: // Incoming call from 0x0239, returns to 0x023A // Inputs[2] // { // @17CF stack[-1] // @17D0 stack[-2] // } 17CA 5B JUMPDEST 17CB 60 PUSH1 0x00 17CD 60 PUSH1 0x20 17CF 82 DUP3 17D0 84 DUP5 17D1 03 SUB 17D2 12 SLT 17D3 15 ISZERO 17D4 61 PUSH2 0x17dc 17D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17CB stack[0] = 0x00 } // Block ends with conditional jump to 0x17dc, if !(stack[-2] - stack[-1] i< 0x20) label_17D8: // Incoming jump from 0x17D7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @17DB memory[0x00:0x00] } 17D8 60 PUSH1 0x00 17DA 80 DUP1 17DB FD *REVERT // Stack delta = +0 // Outputs[1] { @17DB revert(memory[0x00:0x00]); } // Block terminates label_17DC: // Incoming jump from 0x17D7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @17DD stack[-2] // @17DE msg.data[stack[-2]:stack[-2] + 0x20] // } 17DC 5B JUMPDEST 17DD 81 DUP2 17DE 35 CALLDATALOAD 17DF 61 PUSH2 0x0c31 17E2 81 DUP2 17E3 61 PUSH2 0x17b1 17E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17DE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @17DF stack[1] = 0x0c31 // @17E2 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x17b1, returns to 0x0C31 label_17E7: // Incoming call from 0x1EE1, returns to 0x1D88 // Incoming call from 0x182E, returns to 0x182F // Inputs[1] { @17EB stack[-3] } 17E7 5B JUMPDEST 17E8 60 PUSH1 0x00 17EA 5B JUMPDEST 17EB 83 DUP4 17EC 81 DUP2 17ED 10 LT 17EE 15 ISZERO 17EF 61 PUSH2 0x1802 17F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1802, if !(0x00 < stack[-3]) label_17F3: // Incoming jump from 0x17F2, if not !(0x00 < stack[-3]) // Incoming jump from 0x17F2, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @17F3 stack[-2] // @17F4 stack[-1] // @17F6 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17F7 stack[-3] // } 17F3 81 DUP2 17F4 81 DUP2 17F5 01 ADD 17F6 51 MLOAD 17F7 83 DUP4 17F8 82 DUP3 17F9 01 ADD 17FA 52 MSTORE 17FB 60 PUSH1 0x20 17FD 01 ADD 17FE 61 PUSH2 0x17ea 1801 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17FA memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @17FD stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x17ea label_1802: // Incoming jump from 0x17F2, if !(0x00 < stack[-3]) // Incoming jump from 0x17F2, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @1803 stack[-4] // @1804 stack[-1] // } 1802 5B JUMPDEST 1803 83 DUP4 1804 81 DUP2 1805 11 GT 1806 15 ISZERO 1807 61 PUSH2 0x1811 180A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1811, if !(stack[-1] > stack[-4]) label_180B: // Incoming jump from 0x180A, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @180D stack[-4] // @180E stack[-3] // @1816 stack[-5] // } 180B 60 PUSH1 0x00 180D 84 DUP5 180E 84 DUP5 180F 01 ADD 1810 52 MSTORE 1811 5B JUMPDEST 1812 50 POP 1813 50 POP 1814 50 POP 1815 50 POP 1816 56 *JUMP // Stack delta = -5 // Outputs[1] { @1810 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1817: // Incoming call from 0x1FE7, returns to 0x1FE8 // Incoming call from 0x1855, returns to 0x0C31 // Inputs[3] // { // @181A stack[-1] // @181B memory[stack[-1]:stack[-1] + 0x20] // @181D stack[-2] // } 1817 5B JUMPDEST 1818 60 PUSH1 0x00 181A 81 DUP2 181B 51 MLOAD 181C 80 DUP1 181D 84 DUP5 181E 52 MSTORE 181F 61 PUSH2 0x182f 1822 81 DUP2 1823 60 PUSH1 0x20 1825 86 DUP7 1826 01 ADD 1827 60 PUSH1 0x20 1829 86 DUP7 182A 01 ADD 182B 61 PUSH2 0x17e7 182E 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1818 stack[0] = 0x00 // @181B stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @181E memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @181F stack[2] = 0x182f // @1822 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1826 stack[4] = stack[-2] + 0x20 // @182A stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x17e7, returns to 0x182F label_182F: // Incoming return from call to 0x17E7 at 0x182E // Inputs[4] // { // @1832 stack[-1] // @1837 stack[-4] // @1838 stack[-2] // @183E stack[-5] // } 182F 5B JUMPDEST 1830 60 PUSH1 0x1f 1832 01 ADD 1833 60 PUSH1 0x1f 1835 19 NOT 1836 16 AND 1837 92 SWAP3 1838 90 SWAP1 1839 92 SWAP3 183A 01 ADD 183B 60 PUSH1 0x20 183D 01 ADD 183E 92 SWAP3 183F 91 SWAP2 1840 50 POP 1841 50 POP 1842 56 *JUMP // Stack delta = -4 // Outputs[1] { @183E stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1843: // Incoming jump from 0x0278 // Inputs[2] // { // @1846 stack[-1] // @1851 stack[-2] // } 1843 5B JUMPDEST 1844 60 PUSH1 0x20 1846 81 DUP2 1847 52 MSTORE 1848 60 PUSH1 0x00 184A 61 PUSH2 0x0c31 184D 60 PUSH1 0x20 184F 83 DUP4 1850 01 ADD 1851 84 DUP5 1852 61 PUSH2 0x1817 1855 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1847 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1848 stack[0] = 0x00 // @184A stack[1] = 0x0c31 // @1850 stack[2] = stack[-1] + 0x20 // @1851 stack[3] = stack[-2] // } // Block ends with call to 0x1817, returns to 0x0C31 label_1856: // Incoming call from 0x0501, returns to 0x0502 // Incoming call from 0x0527, returns to 0x0528 // Incoming call from 0x04DB, returns to 0x04DC // Incoming call from 0x0399, returns to 0x039A // Incoming call from 0x05BF, returns to 0x05C0 // Incoming call from 0x0495, returns to 0x0496 // Incoming call from 0x041D, returns to 0x041E // Incoming call from 0x0514, returns to 0x0515 // Incoming call from 0x02C6, returns to 0x02C7 // Incoming call from 0x04C8, returns to 0x04C9 // Incoming call from 0x0286, returns to 0x0287 // Incoming call from 0x046F, returns to 0x0470 // Incoming call from 0x04B5, returns to 0x04B6 // Incoming call from 0x035E, returns to 0x035F // Inputs[2] // { // @185B stack[-1] // @185C stack[-2] // } 1856 5B JUMPDEST 1857 60 PUSH1 0x00 1859 60 PUSH1 0x20 185B 82 DUP3 185C 84 DUP5 185D 03 SUB 185E 12 SLT 185F 15 ISZERO 1860 61 PUSH2 0x1868 1863 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1857 stack[0] = 0x00 } // Block ends with conditional jump to 0x1868, if !(stack[-2] - stack[-1] i< 0x20) label_1864: // Incoming jump from 0x1863, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1867 memory[0x00:0x00] } 1864 60 PUSH1 0x00 1866 80 DUP1 1867 FD *REVERT // Stack delta = +0 // Outputs[1] { @1867 revert(memory[0x00:0x00]); } // Block terminates label_1868: // Incoming jump from 0x1863, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @186A stack[-2] // @186A msg.data[stack[-2]:stack[-2] + 0x20] // @186B stack[-4] // @186C stack[-3] // } 1868 5B JUMPDEST 1869 50 POP 186A 35 CALLDATALOAD 186B 91 SWAP2 186C 90 SWAP1 186D 50 POP 186E 56 *JUMP // Stack delta = -3 // Outputs[1] { @186B stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_186F: // Incoming call from 0x18A1, returns to 0x18A2 // Incoming call from 0x1DBE, returns to 0x1DBF // Incoming call from 0x18CC, returns to 0x0C31 // Incoming call from 0x1DAE, returns to 0x1DAF // Incoming call from 0x1C01, returns to 0x1C02 // Incoming call from 0x18EC, returns to 0x18ED // Incoming call from 0x1CCC, returns to 0x1CCD // Incoming call from 0x1C40, returns to 0x1C41 // Incoming call from 0x18FC, returns to 0x18FD // Incoming call from 0x1CDC, returns to 0x1CDD // Incoming call from 0x1DEA, returns to 0x1DEB // Inputs[1] { @1878 stack[-1] } 186F 5B JUMPDEST 1870 60 PUSH1 0x01 1872 60 PUSH1 0x01 1874 60 PUSH1 0xa0 1876 1B SHL 1877 03 SUB 1878 81 DUP2 1879 16 AND 187A 81 DUP2 187B 14 EQ 187C 61 PUSH2 0x17c7 187F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17c7, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_1880: // Incoming jump from 0x187F, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1883 memory[0x00:0x00] } 1880 60 PUSH1 0x00 1882 80 DUP1 1883 FD *REVERT // Stack delta = +0 // Outputs[1] { @1883 revert(memory[0x00:0x00]); } // Block terminates label_1884: // Incoming call from 0x0315, returns to 0x0316 // Incoming call from 0x02B1, returns to 0x02B2 // Inputs[2] // { // @188A stack[-1] // @188B stack[-2] // } 1884 5B JUMPDEST 1885 60 PUSH1 0x00 1887 80 DUP1 1888 60 PUSH1 0x40 188A 83 DUP4 188B 85 DUP6 188C 03 SUB 188D 12 SLT 188E 15 ISZERO 188F 61 PUSH2 0x1897 1892 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1885 stack[0] = 0x00 // @1887 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1897, if !(stack[-2] - stack[-1] i< 0x40) label_1893: // Incoming jump from 0x1892, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1896 memory[0x00:0x00] } 1893 60 PUSH1 0x00 1895 80 DUP1 1896 FD *REVERT // Stack delta = +0 // Outputs[1] { @1896 revert(memory[0x00:0x00]); } // Block terminates label_1897: // Incoming jump from 0x1892, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1898 stack[-3] // @1899 msg.data[stack[-3]:stack[-3] + 0x20] // } 1897 5B JUMPDEST 1898 82 DUP3 1899 35 CALLDATALOAD 189A 61 PUSH2 0x18a2 189D 81 DUP2 189E 61 PUSH2 0x186f 18A1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1899 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @189A stack[1] = 0x18a2 // @189D stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x186f, returns to 0x18A2 label_18A2: // Incoming return from call to 0x186F at 0x18A1 // Inputs[5] // { // @18A3 stack[-1] // @18A3 stack[-6] // @18A6 stack[-4] // @18AA msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @18AB stack[-5] // } 18A2 5B JUMPDEST 18A3 94 SWAP5 18A4 60 PUSH1 0x20 18A6 93 SWAP4 18A7 90 SWAP1 18A8 93 SWAP4 18A9 01 ADD 18AA 35 CALLDATALOAD 18AB 93 SWAP4 18AC 50 POP 18AD 50 POP 18AE 50 POP 18AF 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @18A3 stack[-6] = stack[-1] // @18AB stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_18B0: // Incoming call from 0x0371, returns to 0x0372 // Incoming call from 0x05AC, returns to 0x05AD // Incoming call from 0x0430, returns to 0x0431 // Incoming call from 0x03F4, returns to 0x03F5 // Incoming call from 0x02E7, returns to 0x02E8 // Inputs[2] // { // @18B5 stack[-1] // @18B6 stack[-2] // } 18B0 5B JUMPDEST 18B1 60 PUSH1 0x00 18B3 60 PUSH1 0x20 18B5 82 DUP3 18B6 84 DUP5 18B7 03 SUB 18B8 12 SLT 18B9 15 ISZERO 18BA 61 PUSH2 0x18c2 18BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18B1 stack[0] = 0x00 } // Block ends with conditional jump to 0x18c2, if !(stack[-2] - stack[-1] i< 0x20) label_18BE: // Incoming jump from 0x18BD, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @18C1 memory[0x00:0x00] } 18BE 60 PUSH1 0x00 18C0 80 DUP1 18C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @18C1 revert(memory[0x00:0x00]); } // Block terminates label_18C2: // Incoming jump from 0x18BD, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @18C3 stack[-2] // @18C4 msg.data[stack[-2]:stack[-2] + 0x20] // } 18C2 5B JUMPDEST 18C3 81 DUP2 18C4 35 CALLDATALOAD 18C5 61 PUSH2 0x0c31 18C8 81 DUP2 18C9 61 PUSH2 0x186f 18CC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18C4 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @18C5 stack[1] = 0x0c31 // @18C8 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x186f, returns to 0x0C31 label_18CD: // Incoming call from 0x0302, returns to 0x0303 // Incoming call from 0x034B, returns to 0x034C // Inputs[2] // { // @18D5 stack[-1] // @18D6 stack[-2] // } 18CD 5B JUMPDEST 18CE 60 PUSH1 0x00 18D0 80 DUP1 18D1 60 PUSH1 0x00 18D3 60 PUSH1 0x60 18D5 84 DUP5 18D6 86 DUP7 18D7 03 SUB 18D8 12 SLT 18D9 15 ISZERO 18DA 61 PUSH2 0x18e2 18DD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @18CE stack[0] = 0x00 // @18D0 stack[1] = 0x00 // @18D1 stack[2] = 0x00 // } // Block ends with conditional jump to 0x18e2, if !(stack[-2] - stack[-1] i< 0x60) label_18DE: // Incoming jump from 0x18DD, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @18E1 memory[0x00:0x00] } 18DE 60 PUSH1 0x00 18E0 80 DUP1 18E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @18E1 revert(memory[0x00:0x00]); } // Block terminates label_18E2: // Incoming jump from 0x18DD, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @18E3 stack[-4] // @18E4 msg.data[stack[-4]:stack[-4] + 0x20] // } 18E2 5B JUMPDEST 18E3 83 DUP4 18E4 35 CALLDATALOAD 18E5 61 PUSH2 0x18ed 18E8 81 DUP2 18E9 61 PUSH2 0x186f 18EC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18E4 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @18E5 stack[1] = 0x18ed // @18E8 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x186f, returns to 0x18ED label_18ED: // Incoming return from call to 0x186F at 0x18EC // Inputs[4] // { // @18EE stack[-1] // @18EE stack[-4] // @18F2 stack[-5] // @18F4 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 18ED 5B JUMPDEST 18EE 92 SWAP3 18EF 50 POP 18F0 60 PUSH1 0x20 18F2 84 DUP5 18F3 01 ADD 18F4 35 CALLDATALOAD 18F5 61 PUSH2 0x18fd 18F8 81 DUP2 18F9 61 PUSH2 0x186f 18FC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @18EE stack[-4] = stack[-1] // @18F4 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @18F5 stack[0] = 0x18fd // @18F8 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x186f, returns to 0x18FD label_18FD: // Incoming return from call to 0x186F at 0x18FC // Inputs[6] // { // @18FE stack[-1] // @18FE stack[-4] // @18FF stack[-7] // @1901 stack[-6] // @1907 stack[-5] // @190B msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 18FD 5B JUMPDEST 18FE 92 SWAP3 18FF 95 SWAP6 1900 92 SWAP3 1901 94 SWAP5 1902 50 POP 1903 50 POP 1904 50 POP 1905 60 PUSH1 0x40 1907 91 SWAP2 1908 90 SWAP1 1909 91 SWAP2 190A 01 ADD 190B 35 CALLDATALOAD 190C 90 SWAP1 190D 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @18FF stack[-7] = stack[-4] // @1901 stack[-6] = stack[-1] // @190C stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_190E: // Incoming jump from 0x0868 // Incoming jump from 0x07E0 // Incoming jump from 0x0824 // Incoming jump from 0x1394 // Incoming jump from 0x19A3 // Incoming jump from 0x0AF9 // Incoming jump from 0x1C9D // Incoming jump from 0x08AC // Incoming jump from 0x194B // Inputs[1] { @1923 memory[0x00:0x24] } 190E 5B JUMPDEST 190F 63 PUSH4 0x4e487b71 1914 60 PUSH1 0xe0 1916 1B SHL 1917 60 PUSH1 0x00 1919 52 MSTORE 191A 60 PUSH1 0x41 191C 60 PUSH1 0x04 191E 52 MSTORE 191F 60 PUSH1 0x24 1921 60 PUSH1 0x00 1923 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1919 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @191E memory[0x04:0x24] = 0x41 // @1923 revert(memory[0x00:0x24]); // } // Block terminates label_1924: // Incoming call from 0x19B4, returns to 0x19B5 // Incoming jump from 0x1D22 // Inputs[2] // { // @1927 memory[0x40:0x60] // @192A stack[-1] // } 1924 5B JUMPDEST 1925 60 PUSH1 0x40 1927 51 MLOAD 1928 60 PUSH1 0x1f 192A 82 DUP3 192B 01 ADD 192C 60 PUSH1 0x1f 192E 19 NOT 192F 16 AND 1930 81 DUP2 1931 01 ADD 1932 60 PUSH1 0x01 1934 60 PUSH1 0x01 1936 60 PUSH1 0x40 1938 1B SHL 1939 03 SUB 193A 81 DUP2 193B 11 GT 193C 82 DUP3 193D 82 DUP3 193E 10 LT 193F 17 OR 1940 15 ISZERO 1941 61 PUSH2 0x194c 1944 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1927 stack[0] = memory[0x40:0x60] // @1931 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x194c, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) label_1945: // Incoming jump from 0x1944, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) 1945 61 PUSH2 0x194c 1948 61 PUSH2 0x190e 194B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1945 stack[0] = 0x194c } // Block ends with unconditional jump to 0x190e label_194C: // Incoming jump from 0x1944, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > (0x01 << 0x40) - 0x01)) // Inputs[4] // { // @194F stack[-1] // @1950 stack[-4] // @1950 stack[-2] // @1951 stack[-3] // } 194C 5B JUMPDEST 194D 60 PUSH1 0x40 194F 52 MSTORE 1950 91 SWAP2 1951 90 SWAP1 1952 50 POP 1953 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @194F memory[0x40:0x60] = stack[-1] // @1950 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_1954: // Incoming call from 0x0328, returns to 0x0329 // Inputs[2] // { // @195A stack[-1] // @195B stack[-2] // } 1954 5B JUMPDEST 1955 60 PUSH1 0x00 1957 60 PUSH1 0x20 1959 80 DUP1 195A 83 DUP4 195B 85 DUP6 195C 03 SUB 195D 12 SLT 195E 15 ISZERO 195F 61 PUSH2 0x1967 1962 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1955 stack[0] = 0x00 // @1957 stack[1] = 0x20 // } // Block ends with conditional jump to 0x1967, if !(stack[-2] - stack[-1] i< 0x20) label_1963: // Incoming jump from 0x1962, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1966 memory[0x00:0x00] } 1963 60 PUSH1 0x00 1965 80 DUP1 1966 FD *REVERT // Stack delta = +0 // Outputs[1] { @1966 revert(memory[0x00:0x00]); } // Block terminates label_1967: // Incoming jump from 0x1962, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1968 stack[-3] // @1969 msg.data[stack[-3]:stack[-3] + 0x20] // } 1967 5B JUMPDEST 1968 82 DUP3 1969 35 CALLDATALOAD 196A 60 PUSH1 0x01 196C 60 PUSH1 0x01 196E 60 PUSH1 0x40 1970 1B SHL 1971 03 SUB 1972 80 DUP1 1973 82 DUP3 1974 11 GT 1975 15 ISZERO 1976 61 PUSH2 0x197e 1979 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1969 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1971 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x197e, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_197A: // Incoming jump from 0x1979, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @197D memory[0x00:0x00] } 197A 60 PUSH1 0x00 197C 80 DUP1 197D FD *REVERT // Stack delta = +0 // Outputs[1] { @197D revert(memory[0x00:0x00]); } // Block terminates label_197E: // Incoming jump from 0x1979, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @197F stack[-2] // @1980 stack[-5] // @1984 stack[-6] // } 197E 5B JUMPDEST 197F 81 DUP2 1980 85 DUP6 1981 01 ADD 1982 91 SWAP2 1983 50 POP 1984 85 DUP6 1985 60 PUSH1 0x1f 1987 83 DUP4 1988 01 ADD 1989 12 SLT 198A 61 PUSH2 0x1992 198D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1982 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1992, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_198E: // Incoming jump from 0x198D, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1991 memory[0x00:0x00] } 198E 60 PUSH1 0x00 1990 80 DUP1 1991 FD *REVERT // Stack delta = +0 // Outputs[1] { @1991 revert(memory[0x00:0x00]); } // Block terminates label_1992: // Incoming jump from 0x198D, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1993 stack[-2] // @1994 msg.data[stack[-2]:stack[-2] + 0x20] // @1995 stack[-1] // } 1992 5B JUMPDEST 1993 81 DUP2 1994 35 CALLDATALOAD 1995 81 DUP2 1996 81 DUP2 1997 11 GT 1998 15 ISZERO 1999 61 PUSH2 0x19a4 199C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1994 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x19a4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_199D: // Incoming jump from 0x199C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 199D 61 PUSH2 0x19a4 19A0 61 PUSH2 0x190e 19A3 56 *JUMP // Stack delta = +1 // Outputs[1] { @199D stack[0] = 0x19a4 } // Block ends with unconditional jump to 0x190e label_19A4: // Incoming jump from 0x199C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @19A5 stack[-1] // @19A9 stack[-2] // @19AE stack[-4] // } 19A4 5B JUMPDEST 19A5 80 DUP1 19A6 60 PUSH1 0x05 19A8 1B SHL 19A9 91 SWAP2 19AA 50 POP 19AB 61 PUSH2 0x19b5 19AE 84 DUP5 19AF 83 DUP4 19B0 01 ADD 19B1 61 PUSH2 0x1924 19B4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19A9 stack[-2] = stack[-1] << 0x05 // @19AB stack[0] = 0x19b5 // @19B0 stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x1924, returns to 0x19B5 label_19B5: // Incoming return from call to 0x1924 at 0x19B4 // Inputs[6] // { // @19B6 stack[-2] // @19B7 stack[-1] // @19B9 stack[-3] // @19BA stack[-4] // @19BC stack[-5] // @19C3 stack[-8] // } 19B5 5B JUMPDEST 19B6 81 DUP2 19B7 81 DUP2 19B8 52 MSTORE 19B9 91 SWAP2 19BA 83 DUP4 19BB 01 ADD 19BC 84 DUP5 19BD 01 ADD 19BE 91 SWAP2 19BF 84 DUP5 19C0 81 DUP2 19C1 01 ADD 19C2 90 SWAP1 19C3 88 DUP9 19C4 84 DUP5 19C5 11 GT 19C6 15 ISZERO 19C7 61 PUSH2 0x19cf 19CA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @19B8 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @19BE stack[-3] = stack[-5] + stack[-4] + stack[-3] // @19C2 stack[-1] = stack[-1] + stack[-5] // @19C2 stack[0] = stack[-1] // } // Block ends with conditional jump to 0x19cf, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) label_19CB: // Incoming jump from 0x19CA, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[1] { @19CE memory[0x00:0x00] } 19CB 60 PUSH1 0x00 19CD 80 DUP1 19CE FD *REVERT // Stack delta = +0 // Outputs[1] { @19CE revert(memory[0x00:0x00]); } // Block terminates label_19CF: // Incoming jump from 0x19CA, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[4] // { // @19D0 stack[-5] // @19D0 stack[-1] // @19D1 stack[-6] // @19D5 stack[-4] // } 19CF 5B JUMPDEST 19D0 93 SWAP4 19D1 85 DUP6 19D2 01 ADD 19D3 93 SWAP4 19D4 5B JUMPDEST 19D5 83 DUP4 19D6 85 DUP6 19D7 10 LT 19D8 15 ISZERO 19D9 61 PUSH2 0x19ed 19DC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @19D3 stack[-5] = stack[-6] + stack[-5] // @19D3 stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x19ed, if !(stack[-6] + stack[-5] < stack[-4]) label_19DD: // Incoming jump from 0x19DC, if not !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x19DC, if not !(stack[-5] < stack[-4]) // Inputs[5] // { // @19DD stack[-5] // @19DE msg.data[stack[-5]:stack[-5] + 0x20] // @19DF stack[-2] // @19E1 stack[-1] // @19E2 stack[-6] // } 19DD 84 DUP5 19DE 35 CALLDATALOAD 19DF 82 DUP3 19E0 52 MSTORE 19E1 93 SWAP4 19E2 85 DUP6 19E3 01 ADD 19E4 93 SWAP4 19E5 90 SWAP1 19E6 85 DUP6 19E7 01 ADD 19E8 90 SWAP1 19E9 61 PUSH2 0x19d4 19EC 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @19E0 memory[stack[-2]:stack[-2] + 0x20] = msg.data[stack[-5]:stack[-5] + 0x20] // @19E4 stack[-5] = stack[-6] + stack[-5] // @19E8 stack[-1] = stack[-1] // @19E8 stack[-2] = stack[-6] + stack[-2] // } // Block ends with unconditional jump to 0x19d4 label_19ED: // Incoming jump from 0x19DC, if !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x19DC, if !(stack[-5] < stack[-4]) // Inputs[3] // { // @19EE stack[-10] // @19EE stack[-1] // @19EF stack[-9] // } 19ED 5B JUMPDEST 19EE 98 SWAP9 19EF 97 SWAP8 19F0 50 POP 19F1 50 POP 19F2 50 POP 19F3 50 POP 19F4 50 POP 19F5 50 POP 19F6 50 POP 19F7 50 POP 19F8 56 *JUMP // Stack delta = -9 // Outputs[1] { @19EE stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_19F9: // Incoming call from 0x1ABE, returns to 0x1ABF // Incoming call from 0x1B90, returns to 0x1B91 // Incoming call from 0x1BB8, returns to 0x1BB9 // Incoming call from 0x1AD2, returns to 0x1AD3 // Incoming call from 0x1E36, returns to 0x1E37 // Incoming call from 0x1AAC, returns to 0x1AAD // Incoming call from 0x1E4A, returns to 0x1E4B // Incoming call from 0x1BA4, returns to 0x1BA5 // Inputs[3] // { // @19FC stack[-1] // @19FD memory[stack[-1]:stack[-1] + 0x20] // @19FF stack[-2] // } 19F9 5B JUMPDEST 19FA 60 PUSH1 0x00 19FC 81 DUP2 19FD 51 MLOAD 19FE 80 DUP1 19FF 84 DUP5 1A00 52 MSTORE 1A01 60 PUSH1 0x20 1A03 80 DUP1 1A04 85 DUP6 1A05 01 ADD 1A06 94 SWAP5 1A07 50 POP 1A08 80 DUP1 1A09 84 DUP5 1A0A 01 ADD 1A0B 60 PUSH1 0x00 1A0D 5B JUMPDEST 1A0E 83 DUP4 1A0F 81 DUP2 1A10 10 LT 1A11 15 ISZERO 1A12 61 PUSH2 0x1a32 1A15 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @19FA stack[0] = 0x00 // @19FD stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1A00 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1A01 stack[2] = 0x20 // @1A06 stack[-2] = stack[-2] + 0x20 // @1A0A stack[3] = stack[-1] + 0x20 // @1A0B stack[4] = 0x00 // } // Block ends with conditional jump to 0x1a32, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1A16: // Incoming jump from 0x1A15, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1A15, if not !(stack[-1] < stack[-4]) // Inputs[5] // { // @1A16 stack[-2] // @1A17 memory[stack[-2]:stack[-2] + 0x20] // @1A21 stack[-7] // @1A23 stack[-1] // @1A24 stack[-3] // } 1A16 81 DUP2 1A17 51 MLOAD 1A18 60 PUSH1 0x01 1A1A 60 PUSH1 0x01 1A1C 60 PUSH1 0xa0 1A1E 1B SHL 1A1F 03 SUB 1A20 16 AND 1A21 87 DUP8 1A22 52 MSTORE 1A23 95 SWAP6 1A24 82 DUP3 1A25 01 ADD 1A26 95 SWAP6 1A27 90 SWAP1 1A28 82 DUP3 1A29 01 ADD 1A2A 90 SWAP1 1A2B 60 PUSH1 0x01 1A2D 01 ADD 1A2E 61 PUSH2 0x1a0d 1A31 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1A22 memory[stack[-7]:stack[-7] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @1A26 stack[-7] = stack[-3] + stack[-7] // @1A2A stack[-2] = stack[-3] + stack[-2] // @1A2D stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1a0d label_1A32: // Incoming jump from 0x1A15, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1B58, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1A15, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1A7C, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1A7C, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1B58, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1A34 stack[-2] // @1A34 stack[-7] // @1A35 stack[-8] // } 1A32 5B JUMPDEST 1A33 50 POP 1A34 94 SWAP5 1A35 95 SWAP6 1A36 94 SWAP5 1A37 50 POP 1A38 50 POP 1A39 50 POP 1A3A 50 POP 1A3B 50 POP 1A3C 56 *JUMP // Stack delta = -7 // Outputs[1] { @1A35 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1A3D: // Incoming call from 0x1C84, returns to 0x07B7 // Incoming call from 0x1D87, returns to 0x1D88 // Incoming call from 0x1A86, returns to 0x1A87 // Inputs[1] { @1A3E stack[-1] } 1A3D 5B JUMPDEST 1A3E 80 DUP1 1A3F 60 PUSH1 0x00 1A41 5B JUMPDEST 1A42 60 PUSH1 0x07 1A44 81 DUP2 1A45 10 LT 1A46 15 ISZERO 1A47 61 PUSH2 0x1811 1A4A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A3E stack[0] = stack[-1] // @1A3F stack[1] = 0x00 // } // Block ends with conditional jump to 0x1811, if !(0x00 < 0x07) label_1A4B: // Incoming jump from 0x1A4A, if not !(stack[-1] < 0x07) // Incoming jump from 0x1A4A, if not !(0x00 < 0x07) // Inputs[4] // { // @1A4B stack[-2] // @1A4C memory[stack[-2]:stack[-2] + 0x20] // @1A4D stack[-4] // @1A55 stack[-1] // } 1A4B 81 DUP2 1A4C 51 MLOAD 1A4D 84 DUP5 1A4E 52 MSTORE 1A4F 60 PUSH1 0x20 1A51 93 SWAP4 1A52 84 DUP5 1A53 01 ADD 1A54 93 SWAP4 1A55 90 SWAP1 1A56 91 SWAP2 1A57 01 ADD 1A58 90 SWAP1 1A59 60 PUSH1 0x01 1A5B 01 ADD 1A5C 61 PUSH2 0x1a41 1A5F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1A4E memory[stack[-4]:stack[-4] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1A54 stack[-4] = 0x20 + stack[-4] // @1A58 stack[-2] = stack[-2] + 0x20 // @1A5B stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1a41 label_1A60: // Incoming call from 0x1AE6, returns to 0x1AE7 // Incoming call from 0x1E5E, returns to 0x1E5F // Incoming call from 0x1BCC, returns to 0x1BCD // Inputs[3] // { // @1A63 stack[-1] // @1A64 memory[stack[-1]:stack[-1] + 0x20] // @1A66 stack[-2] // } 1A60 5B JUMPDEST 1A61 60 PUSH1 0x00 1A63 81 DUP2 1A64 51 MLOAD 1A65 80 DUP1 1A66 84 DUP5 1A67 52 MSTORE 1A68 60 PUSH1 0x20 1A6A 80 DUP1 1A6B 85 DUP6 1A6C 01 ADD 1A6D 94 SWAP5 1A6E 50 POP 1A6F 80 DUP1 1A70 84 DUP5 1A71 01 ADD 1A72 60 PUSH1 0x00 1A74 5B JUMPDEST 1A75 83 DUP4 1A76 81 DUP2 1A77 10 LT 1A78 15 ISZERO 1A79 61 PUSH2 0x1a32 1A7C 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @1A61 stack[0] = 0x00 // @1A64 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1A67 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1A68 stack[2] = 0x20 // @1A6D stack[-2] = stack[-2] + 0x20 // @1A71 stack[3] = stack[-1] + 0x20 // @1A72 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1a32, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1A7D: // Incoming jump from 0x1A7C, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1A7C, if not !(stack[-1] < stack[-4]) // Inputs[3] // { // @1A80 stack[-7] // @1A81 stack[-2] // @1A82 memory[stack[-2]:stack[-2] + 0x20] // } 1A7D 61 PUSH2 0x1a87 1A80 87 DUP8 1A81 83 DUP4 1A82 51 MLOAD 1A83 61 PUSH2 0x1a3d 1A86 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A7D stack[0] = 0x1a87 // @1A80 stack[1] = stack[-7] // @1A82 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1a3d, returns to 0x1A87 label_1A87: // Incoming return from call to 0x1A3D at 0x1A86 // Inputs[4] // { // @1A8A stack[-7] // @1A8B stack[-1] // @1A8F stack[-2] // @1A90 stack[-3] // } 1A87 5B JUMPDEST 1A88 60 PUSH1 0xe0 1A8A 96 SWAP7 1A8B 90 SWAP1 1A8C 96 SWAP7 1A8D 01 ADD 1A8E 95 SWAP6 1A8F 90 SWAP1 1A90 82 DUP3 1A91 01 ADD 1A92 90 SWAP1 1A93 60 PUSH1 0x01 1A95 01 ADD 1A96 61 PUSH2 0x1a74 1A99 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1A8E stack[-7] = 0xe0 + stack[-7] // @1A92 stack[-2] = stack[-3] + stack[-2] // @1A95 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1a74 label_1A9A: // Incoming call from 0x033D, returns to 0x025B // Inputs[2] // { // @1A9D stack[-1] // @1AA8 stack[-5] // } 1A9A 5B JUMPDEST 1A9B 60 PUSH1 0x80 1A9D 81 DUP2 1A9E 52 MSTORE 1A9F 60 PUSH1 0x00 1AA1 61 PUSH2 0x1aad 1AA4 60 PUSH1 0x80 1AA6 83 DUP4 1AA7 01 ADD 1AA8 87 DUP8 1AA9 61 PUSH2 0x19f9 1AAC 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1A9E memory[stack[-1]:stack[-1] + 0x20] = 0x80 // @1A9F stack[0] = 0x00 // @1AA1 stack[1] = 0x1aad // @1AA7 stack[2] = stack[-1] + 0x80 // @1AA8 stack[3] = stack[-5] // } // Block ends with call to 0x19f9, returns to 0x1AAD label_1AAD: // Incoming return from call to 0x19F9 at 0x1AAC // Inputs[3] // { // @1AAE stack[-3] // @1AAF stack[-1] // @1ABA stack[-6] // } 1AAD 5B JUMPDEST 1AAE 82 DUP3 1AAF 81 DUP2 1AB0 03 SUB 1AB1 60 PUSH1 0x20 1AB3 84 DUP5 1AB4 01 ADD 1AB5 52 MSTORE 1AB6 61 PUSH2 0x1abf 1AB9 81 DUP2 1ABA 87 DUP8 1ABB 61 PUSH2 0x19f9 1ABE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1AB5 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @1AB6 stack[0] = 0x1abf // @1AB9 stack[1] = stack[-1] // @1ABA stack[2] = stack[-6] // } // Block ends with call to 0x19f9, returns to 0x1ABF label_1ABF: // Incoming return from call to 0x19F9 at 0x1ABE // Inputs[4] // { // @1AC0 stack[-1] // @1AC0 stack[-2] // @1AC2 stack[-4] // @1ACE stack[-6] // } 1ABF 5B JUMPDEST 1AC0 90 SWAP1 1AC1 50 POP 1AC2 82 DUP3 1AC3 81 DUP2 1AC4 03 SUB 1AC5 60 PUSH1 0x40 1AC7 84 DUP5 1AC8 01 ADD 1AC9 52 MSTORE 1ACA 61 PUSH2 0x1ad3 1ACD 81 DUP2 1ACE 86 DUP7 1ACF 61 PUSH2 0x19f9 1AD2 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1AC0 stack[-2] = stack[-1] // @1AC9 memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] = stack[-1] - stack[-4] // @1ACA stack[-1] = 0x1ad3 // @1ACD stack[0] = stack[-1] // @1ACE stack[1] = stack[-6] // } // Block ends with call to 0x19f9, returns to 0x1AD3 label_1AD3: // Incoming return from call to 0x19F9 at 0x1AD2 // Inputs[4] // { // @1AD4 stack[-1] // @1AD4 stack[-2] // @1AD6 stack[-4] // @1AE2 stack[-5] // } 1AD3 5B JUMPDEST 1AD4 90 SWAP1 1AD5 50 POP 1AD6 82 DUP3 1AD7 81 DUP2 1AD8 03 SUB 1AD9 60 PUSH1 0x60 1ADB 84 DUP5 1ADC 01 ADD 1ADD 52 MSTORE 1ADE 61 PUSH2 0x1ae7 1AE1 81 DUP2 1AE2 85 DUP6 1AE3 61 PUSH2 0x1a60 1AE6 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1AD4 stack[-2] = stack[-1] // @1ADD memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] = stack[-1] - stack[-4] // @1ADE stack[-1] = 0x1ae7 // @1AE1 stack[0] = stack[-1] // @1AE2 stack[1] = stack[-5] // } // Block ends with call to 0x1a60, returns to 0x1AE7 label_1AE7: // Incoming return from call to 0x1A60 at 0x1AE6 // Inputs[3] // { // @1AE8 stack[-9] // @1AE8 stack[-1] // @1AE9 stack[-8] // } 1AE7 5B JUMPDEST 1AE8 97 SWAP8 1AE9 96 SWAP7 1AEA 50 POP 1AEB 50 POP 1AEC 50 POP 1AED 50 POP 1AEE 50 POP 1AEF 50 POP 1AF0 50 POP 1AF1 56 *JUMP // Stack delta = -8 // Outputs[1] { @1AE8 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_1AF2: // Incoming call from 0x1C0F, returns to 0x1C10 // Incoming call from 0x1B32, returns to 0x1B33 // Incoming call from 0x1E06, returns to 0x1E07 // Inputs[2] // { // @1AF3 stack[-1] // @1AF4 msg.data[stack[-1]:stack[-1] + 0x20] // } 1AF2 5B JUMPDEST 1AF3 80 DUP1 1AF4 35 CALLDATALOAD 1AF5 80 DUP1 1AF6 15 ISZERO 1AF7 15 ISZERO 1AF8 81 DUP2 1AF9 14 EQ 1AFA 61 PUSH2 0x1b02 1AFD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AF4 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1b02, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_1AFE: // Incoming jump from 0x1AFD, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @1B01 memory[0x00:0x00] } 1AFE 60 PUSH1 0x00 1B00 80 DUP1 1B01 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B01 revert(memory[0x00:0x00]); } // Block terminates label_1B02: // Incoming jump from 0x1AFD, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1B03 stack[-1] // @1B03 stack[-3] // @1B04 stack[-2] // } 1B02 5B JUMPDEST 1B03 91 SWAP2 1B04 90 SWAP1 1B05 50 POP 1B06 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B03 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1B07: // Incoming call from 0x03AC, returns to 0x03AD // Inputs[2] // { // @1B0F stack[-1] // @1B10 stack[-2] // } 1B07 5B JUMPDEST 1B08 60 PUSH1 0x00 1B0A 80 DUP1 1B0B 60 PUSH1 0x00 1B0D 60 PUSH1 0x60 1B0F 84 DUP5 1B10 86 DUP7 1B11 03 SUB 1B12 12 SLT 1B13 15 ISZERO 1B14 61 PUSH2 0x1b1c 1B17 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1B08 stack[0] = 0x00 // @1B0A stack[1] = 0x00 // @1B0B stack[2] = 0x00 // } // Block ends with conditional jump to 0x1b1c, if !(stack[-2] - stack[-1] i< 0x60) label_1B18: // Incoming jump from 0x1B17, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1B1B memory[0x00:0x00] } 1B18 60 PUSH1 0x00 1B1A 80 DUP1 1B1B FD *REVERT // Stack delta = +0 // Outputs[1] { @1B1B revert(memory[0x00:0x00]); } // Block terminates label_1B1C: // Incoming jump from 0x1B17, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[5] // { // @1B1D stack[-4] // @1B1E msg.data[stack[-4]:stack[-4] + 0x20] // @1B1F stack[-3] // @1B25 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1B26 stack[-2] // } 1B1C 5B JUMPDEST 1B1D 83 DUP4 1B1E 35 CALLDATALOAD 1B1F 92 SWAP3 1B20 50 POP 1B21 60 PUSH1 0x20 1B23 84 DUP5 1B24 01 ADD 1B25 35 CALLDATALOAD 1B26 91 SWAP2 1B27 50 POP 1B28 61 PUSH2 0x1b33 1B2B 60 PUSH1 0x40 1B2D 85 DUP6 1B2E 01 ADD 1B2F 61 PUSH2 0x1af2 1B32 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1B1F stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @1B26 stack[-2] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1B28 stack[0] = 0x1b33 // @1B2E stack[1] = stack[-4] + 0x40 // } // Block ends with call to 0x1af2, returns to 0x1B33 label_1B33: // Incoming return from call to 0x1AF2 at 0x1B32 // Inputs[7] // { // @1B34 stack[-2] // @1B34 stack[-1] // @1B36 stack[-5] // @1B38 stack[-6] // @1B38 stack[-3] // @1B3A stack[-7] // @1B3A stack[-4] // } 1B33 5B JUMPDEST 1B34 90 SWAP1 1B35 50 POP 1B36 92 SWAP3 1B37 50 POP 1B38 92 SWAP3 1B39 50 POP 1B3A 92 SWAP3 1B3B 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1B36 stack[-5] = stack[-1] // @1B38 stack[-6] = stack[-3] // @1B3A stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1B3C: // Incoming call from 0x1B7E, returns to 0x1B7F // Incoming call from 0x1E24, returns to 0x1E25 // Inputs[3] // { // @1B3F stack[-1] // @1B40 memory[stack[-1]:stack[-1] + 0x20] // @1B42 stack[-2] // } 1B3C 5B JUMPDEST 1B3D 60 PUSH1 0x00 1B3F 81 DUP2 1B40 51 MLOAD 1B41 80 DUP1 1B42 84 DUP5 1B43 52 MSTORE 1B44 60 PUSH1 0x20 1B46 80 DUP1 1B47 85 DUP6 1B48 01 ADD 1B49 94 SWAP5 1B4A 50 POP 1B4B 80 DUP1 1B4C 84 DUP5 1B4D 01 ADD 1B4E 60 PUSH1 0x00 1B50 5B JUMPDEST 1B51 83 DUP4 1B52 81 DUP2 1B53 10 LT 1B54 15 ISZERO 1B55 61 PUSH2 0x1a32 1B58 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @1B3D stack[0] = 0x00 // @1B40 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1B43 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1B44 stack[2] = 0x20 // @1B49 stack[-2] = stack[-2] + 0x20 // @1B4D stack[3] = stack[-1] + 0x20 // @1B4E stack[4] = 0x00 // } // Block ends with conditional jump to 0x1a32, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1B59: // Incoming jump from 0x1B58, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1B58, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @1B59 stack[-2] // @1B5A memory[stack[-2]:stack[-2] + 0x20] // @1B5B stack[-7] // @1B5D stack[-1] // @1B5E stack[-3] // } 1B59 81 DUP2 1B5A 51 MLOAD 1B5B 87 DUP8 1B5C 52 MSTORE 1B5D 95 SWAP6 1B5E 82 DUP3 1B5F 01 ADD 1B60 95 SWAP6 1B61 90 SWAP1 1B62 82 DUP3 1B63 01 ADD 1B64 90 SWAP1 1B65 60 PUSH1 0x01 1B67 01 ADD 1B68 61 PUSH2 0x1b50 1B6B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1B5C memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1B60 stack[-7] = stack[-3] + stack[-7] // @1B64 stack[-2] = stack[-3] + stack[-2] // @1B67 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1b50 label_1B6C: // Incoming call from 0x03C4, returns to 0x025B // Inputs[2] // { // @1B6F stack[-1] // @1B7A stack[-8] // } 1B6C 5B JUMPDEST 1B6D 60 PUSH1 0xe0 1B6F 81 DUP2 1B70 52 MSTORE 1B71 60 PUSH1 0x00 1B73 61 PUSH2 0x1b7f 1B76 60 PUSH1 0xe0 1B78 83 DUP4 1B79 01 ADD 1B7A 8A DUP11 1B7B 61 PUSH2 0x1b3c 1B7E 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1B70 memory[stack[-1]:stack[-1] + 0x20] = 0xe0 // @1B71 stack[0] = 0x00 // @1B73 stack[1] = 0x1b7f // @1B79 stack[2] = stack[-1] + 0xe0 // @1B7A stack[3] = stack[-8] // } // Block ends with call to 0x1b3c, returns to 0x1B7F label_1B7F: // Incoming return from call to 0x1B3C at 0x1B7E // Inputs[3] // { // @1B80 stack[-3] // @1B81 stack[-1] // @1B8C stack[-9] // } 1B7F 5B JUMPDEST 1B80 82 DUP3 1B81 81 DUP2 1B82 03 SUB 1B83 60 PUSH1 0x20 1B85 84 DUP5 1B86 01 ADD 1B87 52 MSTORE 1B88 61 PUSH2 0x1b91 1B8B 81 DUP2 1B8C 8A DUP11 1B8D 61 PUSH2 0x19f9 1B90 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1B87 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @1B88 stack[0] = 0x1b91 // @1B8B stack[1] = stack[-1] // @1B8C stack[2] = stack[-9] // } // Block ends with call to 0x19f9, returns to 0x1B91 label_1B91: // Incoming return from call to 0x19F9 at 0x1B90 // Inputs[4] // { // @1B92 stack[-1] // @1B92 stack[-2] // @1B94 stack[-4] // @1BA0 stack[-9] // } 1B91 5B JUMPDEST 1B92 90 SWAP1 1B93 50 POP 1B94 82 DUP3 1B95 81 DUP2 1B96 03 SUB 1B97 60 PUSH1 0x40 1B99 84 DUP5 1B9A 01 ADD 1B9B 52 MSTORE 1B9C 61 PUSH2 0x1ba5 1B9F 81 DUP2 1BA0 89 DUP10 1BA1 61 PUSH2 0x19f9 1BA4 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1B92 stack[-2] = stack[-1] // @1B9B memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] = stack[-1] - stack[-4] // @1B9C stack[-1] = 0x1ba5 // @1B9F stack[0] = stack[-1] // @1BA0 stack[1] = stack[-9] // } // Block ends with call to 0x19f9, returns to 0x1BA5 label_1BA5: // Incoming return from call to 0x19F9 at 0x1BA4 // Inputs[4] // { // @1BA6 stack[-2] // @1BA6 stack[-1] // @1BA8 stack[-4] // @1BB4 stack[-8] // } 1BA5 5B JUMPDEST 1BA6 90 SWAP1 1BA7 50 POP 1BA8 82 DUP3 1BA9 81 DUP2 1BAA 03 SUB 1BAB 60 PUSH1 0x60 1BAD 84 DUP5 1BAE 01 ADD 1BAF 52 MSTORE 1BB0 61 PUSH2 0x1bb9 1BB3 81 DUP2 1BB4 88 DUP9 1BB5 61 PUSH2 0x19f9 1BB8 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1BA6 stack[-2] = stack[-1] // @1BAF memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] = stack[-1] - stack[-4] // @1BB0 stack[-1] = 0x1bb9 // @1BB3 stack[0] = stack[-1] // @1BB4 stack[1] = stack[-8] // } // Block ends with call to 0x19f9, returns to 0x1BB9 label_1BB9: // Incoming return from call to 0x19F9 at 0x1BB8 // Inputs[4] // { // @1BBA stack[-2] // @1BBA stack[-1] // @1BBC stack[-4] // @1BC8 stack[-7] // } 1BB9 5B JUMPDEST 1BBA 90 SWAP1 1BBB 50 POP 1BBC 82 DUP3 1BBD 81 DUP2 1BBE 03 SUB 1BBF 60 PUSH1 0x80 1BC1 84 DUP5 1BC2 01 ADD 1BC3 52 MSTORE 1BC4 61 PUSH2 0x1bcd 1BC7 81 DUP2 1BC8 87 DUP8 1BC9 61 PUSH2 0x1a60 1BCC 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1BBA stack[-2] = stack[-1] // @1BC3 memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] = stack[-1] - stack[-4] // @1BC4 stack[-1] = 0x1bcd // @1BC7 stack[0] = stack[-1] // @1BC8 stack[1] = stack[-7] // } // Block ends with call to 0x1a60, returns to 0x1BCD label_1BCD: // Incoming return from call to 0x1A60 at 0x1BCC // Inputs[6] // { // @1BD0 stack[-4] // @1BD2 stack[-6] // @1BD3 stack[-1] // @1BDB stack[-5] // @1BDC stack[-12] // @1BDD stack[-11] // } 1BCD 5B JUMPDEST 1BCE 60 PUSH1 0xa0 1BD0 84 DUP5 1BD1 01 ADD 1BD2 95 SWAP6 1BD3 90 SWAP1 1BD4 95 SWAP6 1BD5 52 MSTORE 1BD6 50 POP 1BD7 50 POP 1BD8 60 PUSH1 0xc0 1BDA 01 ADD 1BDB 52 MSTORE 1BDC 95 SWAP6 1BDD 94 SWAP5 1BDE 50 POP 1BDF 50 POP 1BE0 50 POP 1BE1 50 POP 1BE2 50 POP 1BE3 56 *JUMP // Stack delta = -11 // Outputs[3] // { // @1BD5 memory[stack[-4] + 0xa0:stack[-4] + 0xa0 + 0x20] = stack[-6] // @1BDB memory[0xc0 + stack[-4]:0xc0 + stack[-4] + 0x20] = stack[-5] // @1BDC stack[-12] = stack[-1] // } // Block ends with unconditional jump to stack[-12] label_1BE4: // Incoming call from 0x045C, returns to 0x045D // Inputs[2] // { // @1BEA stack[-1] // @1BEB stack[-2] // } 1BE4 5B JUMPDEST 1BE5 60 PUSH1 0x00 1BE7 80 DUP1 1BE8 60 PUSH1 0x40 1BEA 83 DUP4 1BEB 85 DUP6 1BEC 03 SUB 1BED 12 SLT 1BEE 15 ISZERO 1BEF 61 PUSH2 0x1bf7 1BF2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BE5 stack[0] = 0x00 // @1BE7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1bf7, if !(stack[-2] - stack[-1] i< 0x40) label_1BF3: // Incoming jump from 0x1BF2, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1BF6 memory[0x00:0x00] } 1BF3 60 PUSH1 0x00 1BF5 80 DUP1 1BF6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BF6 revert(memory[0x00:0x00]); } // Block terminates label_1BF7: // Incoming jump from 0x1BF2, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1BF8 stack[-3] // @1BF9 msg.data[stack[-3]:stack[-3] + 0x20] // } 1BF7 5B JUMPDEST 1BF8 82 DUP3 1BF9 35 CALLDATALOAD 1BFA 61 PUSH2 0x1c02 1BFD 81 DUP2 1BFE 61 PUSH2 0x186f 1C01 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BF9 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1BFA stack[1] = 0x1c02 // @1BFD stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x186f, returns to 0x1C02 label_1C02: // Incoming return from call to 0x186F at 0x1C01 // Inputs[3] // { // @1C03 stack[-1] // @1C03 stack[-3] // @1C0A stack[-4] // } 1C02 5B JUMPDEST 1C03 91 SWAP2 1C04 50 POP 1C05 61 PUSH2 0x1c10 1C08 60 PUSH1 0x20 1C0A 84 DUP5 1C0B 01 ADD 1C0C 61 PUSH2 0x1af2 1C0F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C03 stack[-3] = stack[-1] // @1C05 stack[-1] = 0x1c10 // @1C0B stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1af2, returns to 0x1C10 label_1C10: // Incoming return from call to 0x1AF2 at 0x1C0F // Inputs[6] // { // @1C11 stack[-2] // @1C11 stack[-1] // @1C13 stack[-5] // @1C15 stack[-3] // @1C15 stack[-6] // @1C16 stack[-4] // } 1C10 5B JUMPDEST 1C11 90 SWAP1 1C12 50 POP 1C13 92 SWAP3 1C14 50 POP 1C15 92 SWAP3 1C16 90 SWAP1 1C17 50 POP 1C18 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1C13 stack[-5] = stack[-1] // @1C15 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1C19: // Incoming call from 0x0482, returns to 0x0483 // Inputs[2] // { // @1C29 stack[-1] // @1C2A stack[-2] // } 1C19 5B JUMPDEST 1C1A 60 PUSH1 0x00 1C1C 80 DUP1 1C1D 60 PUSH1 0x00 1C1F 80 DUP1 1C20 60 PUSH1 0x00 1C22 80 DUP1 1C23 60 PUSH1 0x00 1C25 80 DUP1 1C26 61 PUSH2 0x0100 1C29 89 DUP10 1C2A 8B DUP12 1C2B 03 SUB 1C2C 12 SLT 1C2D 15 ISZERO 1C2E 61 PUSH2 0x1c36 1C31 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @1C1A stack[0] = 0x00 // @1C1C stack[1] = 0x00 // @1C1D stack[2] = 0x00 // @1C1F stack[3] = 0x00 // @1C20 stack[4] = 0x00 // @1C22 stack[5] = 0x00 // @1C23 stack[6] = 0x00 // @1C25 stack[7] = 0x00 // } // Block ends with conditional jump to 0x1c36, if !(stack[-2] - stack[-1] i< 0x0100) label_1C32: // Incoming jump from 0x1C31, if not !(stack[-2] - stack[-1] i< 0x0100) // Inputs[1] { @1C35 memory[0x00:0x00] } 1C32 60 PUSH1 0x00 1C34 80 DUP1 1C35 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C35 revert(memory[0x00:0x00]); } // Block terminates label_1C36: // Incoming jump from 0x1C31, if !(stack[-2] - stack[-1] i< 0x0100) // Inputs[2] // { // @1C37 stack[-9] // @1C38 msg.data[stack[-9]:stack[-9] + 0x20] // } 1C36 5B JUMPDEST 1C37 88 DUP9 1C38 35 CALLDATALOAD 1C39 61 PUSH2 0x1c41 1C3C 81 DUP2 1C3D 61 PUSH2 0x186f 1C40 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C38 stack[0] = msg.data[stack[-9]:stack[-9] + 0x20] // @1C39 stack[1] = 0x1c41 // @1C3C stack[2] = msg.data[stack[-9]:stack[-9] + 0x20] // } // Block ends with call to 0x186f, returns to 0x1C41 label_1C41: // Incoming return from call to 0x186F at 0x1C40 // Inputs[17] // { // @1C42 stack[-1] // @1C42 stack[-12] // @1C45 stack[-10] // @1C47 msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] // @1C48 stack[-11] // @1C4E msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] // @1C54 msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @1C55 stack[-9] // @1C5B msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @1C5C stack[-8] // @1C62 msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @1C63 stack[-7] // @1C69 msg.data[stack[-10] + 0xc0:stack[-10] + 0xc0 + 0x20] // @1C6A stack[-6] // @1C6F msg.data[0xe0 + stack[-10]:0xe0 + stack[-10] + 0x20] // @1C70 stack[-5] // @1C72 stack[-4] // } 1C41 5B JUMPDEST 1C42 9A SWAP11 1C43 60 PUSH1 0x20 1C45 8A DUP11 1C46 01 ADD 1C47 35 CALLDATALOAD 1C48 9A SWAP11 1C49 50 POP 1C4A 60 PUSH1 0x40 1C4C 8A DUP11 1C4D 01 ADD 1C4E 35 CALLDATALOAD 1C4F 99 SWAP10 1C50 60 PUSH1 0x60 1C52 81 DUP2 1C53 01 ADD 1C54 35 CALLDATALOAD 1C55 99 SWAP10 1C56 50 POP 1C57 60 PUSH1 0x80 1C59 81 DUP2 1C5A 01 ADD 1C5B 35 CALLDATALOAD 1C5C 98 SWAP9 1C5D 50 POP 1C5E 60 PUSH1 0xa0 1C60 81 DUP2 1C61 01 ADD 1C62 35 CALLDATALOAD 1C63 97 SWAP8 1C64 50 POP 1C65 60 PUSH1 0xc0 1C67 81 DUP2 1C68 01 ADD 1C69 35 CALLDATALOAD 1C6A 96 SWAP7 1C6B 50 POP 1C6C 60 PUSH1 0xe0 1C6E 01 ADD 1C6F 35 CALLDATALOAD 1C70 94 SWAP5 1C71 50 POP 1C72 92 SWAP3 1C73 50 POP 1C74 50 POP 1C75 50 POP 1C76 56 *JUMP // Stack delta = -4 // Outputs[8] // { // @1C42 stack[-12] = stack[-1] // @1C48 stack[-11] = msg.data[stack[-10] + 0x20:stack[-10] + 0x20 + 0x20] // @1C4F stack[-10] = msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] // @1C55 stack[-9] = msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @1C5C stack[-8] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @1C63 stack[-7] = msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @1C6A stack[-6] = msg.data[stack[-10] + 0xc0:stack[-10] + 0xc0 + 0x20] // @1C70 stack[-5] = msg.data[0xe0 + stack[-10]:0xe0 + stack[-10] + 0x20] // } // Block ends with unconditional jump to stack[-12] label_1C77: // Incoming jump from 0x04A7 // Inputs[2] // { // @1C7A stack[-1] // @1C80 stack[-2] // } 1C77 5B JUMPDEST 1C78 60 PUSH1 0xe0 1C7A 81 DUP2 1C7B 01 ADD 1C7C 61 PUSH2 0x07b7 1C7F 82 DUP3 1C80 84 DUP5 1C81 61 PUSH2 0x1a3d 1C84 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C7B stack[0] = stack[-1] + 0xe0 // @1C7C stack[1] = 0x07b7 // @1C7F stack[2] = stack[-1] // @1C80 stack[3] = stack[-2] // } // Block ends with call to 0x1a3d, returns to 0x07B7 label_1C85: // Incoming call from 0x1EBB, returns to 0x1D1E // Incoming call from 0x1D1D, returns to 0x1D1E // Inputs[1] { @1C90 stack[-1] } 1C85 5B JUMPDEST 1C86 60 PUSH1 0x00 1C88 60 PUSH1 0x01 1C8A 60 PUSH1 0x01 1C8C 60 PUSH1 0x40 1C8E 1B SHL 1C8F 03 SUB 1C90 82 DUP3 1C91 11 GT 1C92 15 ISZERO 1C93 61 PUSH2 0x1c9e 1C96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C86 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c9e, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_1C97: // Incoming jump from 0x1C96, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 1C97 61 PUSH2 0x1c9e 1C9A 61 PUSH2 0x190e 1C9D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C97 stack[0] = 0x1c9e } // Block ends with unconditional jump to 0x190e label_1C9E: // Incoming jump from 0x1C96, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1CA2 stack[-2] // @1CAA stack[-3] // } 1C9E 5B JUMPDEST 1C9F 50 POP 1CA0 60 PUSH1 0x1f 1CA2 01 ADD 1CA3 60 PUSH1 0x1f 1CA5 19 NOT 1CA6 16 AND 1CA7 60 PUSH1 0x20 1CA9 01 ADD 1CAA 90 SWAP1 1CAB 56 *JUMP // Stack delta = -2 // Outputs[1] { @1CAA stack[-3] = 0x20 + (~0x1f & 0x1f + stack[-2]) } // Block ends with unconditional jump to stack[-3] label_1CAC: // Incoming call from 0x04EE, returns to 0x04EF // Inputs[2] // { // @1CB5 stack[-1] // @1CB6 stack[-2] // } 1CAC 5B JUMPDEST 1CAD 60 PUSH1 0x00 1CAF 80 DUP1 1CB0 60 PUSH1 0x00 1CB2 80 DUP1 1CB3 60 PUSH1 0x80 1CB5 85 DUP6 1CB6 87 DUP8 1CB7 03 SUB 1CB8 12 SLT 1CB9 15 ISZERO 1CBA 61 PUSH2 0x1cc2 1CBD 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1CAD stack[0] = 0x00 // @1CAF stack[1] = 0x00 // @1CB0 stack[2] = 0x00 // @1CB2 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1cc2, if !(stack[-2] - stack[-1] i< 0x80) label_1CBE: // Incoming jump from 0x1CBD, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1CC1 memory[0x00:0x00] } 1CBE 60 PUSH1 0x00 1CC0 80 DUP1 1CC1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CC1 revert(memory[0x00:0x00]); } // Block terminates label_1CC2: // Incoming jump from 0x1CBD, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1CC3 stack[-5] // @1CC4 msg.data[stack[-5]:stack[-5] + 0x20] // } 1CC2 5B JUMPDEST 1CC3 84 DUP5 1CC4 35 CALLDATALOAD 1CC5 61 PUSH2 0x1ccd 1CC8 81 DUP2 1CC9 61 PUSH2 0x186f 1CCC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CC4 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @1CC5 stack[1] = 0x1ccd // @1CC8 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x186f, returns to 0x1CCD label_1CCD: // Incoming return from call to 0x186F at 0x1CCC // Inputs[4] // { // @1CCE stack[-1] // @1CCE stack[-5] // @1CD2 stack[-6] // @1CD4 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 1CCD 5B JUMPDEST 1CCE 93 SWAP4 1CCF 50 POP 1CD0 60 PUSH1 0x20 1CD2 85 DUP6 1CD3 01 ADD 1CD4 35 CALLDATALOAD 1CD5 61 PUSH2 0x1cdd 1CD8 81 DUP2 1CD9 61 PUSH2 0x186f 1CDC 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1CCE stack[-5] = stack[-1] // @1CD4 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1CD5 stack[0] = 0x1cdd // @1CD8 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x186f, returns to 0x1CDD label_1CDD: // Incoming return from call to 0x186F at 0x1CDC // Inputs[6] // { // @1CDE stack[-1] // @1CDE stack[-4] // @1CE2 stack[-6] // @1CE4 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1CE5 stack[-3] // @1CEB msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1CDD 5B JUMPDEST 1CDE 92 SWAP3 1CDF 50 POP 1CE0 60 PUSH1 0x40 1CE2 85 DUP6 1CE3 01 ADD 1CE4 35 CALLDATALOAD 1CE5 91 SWAP2 1CE6 50 POP 1CE7 60 PUSH1 0x60 1CE9 85 DUP6 1CEA 01 ADD 1CEB 35 CALLDATALOAD 1CEC 60 PUSH1 0x01 1CEE 60 PUSH1 0x01 1CF0 60 PUSH1 0x40 1CF2 1B SHL 1CF3 03 SUB 1CF4 81 DUP2 1CF5 11 GT 1CF6 15 ISZERO 1CF7 61 PUSH2 0x1cff 1CFA 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1CDE stack[-4] = stack[-1] // @1CE5 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1CEB stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1cff, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_1CFB: // Incoming jump from 0x1CFA, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1CFE memory[0x00:0x00] } 1CFB 60 PUSH1 0x00 1CFD 80 DUP1 1CFE FD *REVERT // Stack delta = +0 // Outputs[1] { @1CFE revert(memory[0x00:0x00]); } // Block terminates label_1CFF: // Incoming jump from 0x1CFA, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1D00 stack[-6] // @1D01 stack[-1] // @1D06 stack[-7] // } 1CFF 5B JUMPDEST 1D00 85 DUP6 1D01 01 ADD 1D02 60 PUSH1 0x1f 1D04 81 DUP2 1D05 01 ADD 1D06 87 DUP8 1D07 13 SGT 1D08 61 PUSH2 0x1d10 1D0B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1D01 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1d10, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1D0C: // Incoming jump from 0x1D0B, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @1D0F memory[0x00:0x00] } 1D0C 60 PUSH1 0x00 1D0E 80 DUP1 1D0F FD *REVERT // Stack delta = +0 // Outputs[1] { @1D0F revert(memory[0x00:0x00]); } // Block terminates label_1D10: // Incoming jump from 0x1D0B, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @1D11 stack[-1] // @1D12 msg.data[stack[-1]:stack[-1] + 0x20] // } 1D10 5B JUMPDEST 1D11 80 DUP1 1D12 35 CALLDATALOAD 1D13 61 PUSH2 0x1d23 1D16 61 PUSH2 0x1d1e 1D19 82 DUP3 1D1A 61 PUSH2 0x1c85 1D1D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D12 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1D13 stack[1] = 0x1d23 // @1D16 stack[2] = 0x1d1e // @1D19 stack[3] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1c85, returns to 0x1D1E label_1D1E: // Incoming return from call to 0x1C85 at 0x1EBB // Incoming return from call to 0x1C85 at 0x1D1D 1D1E 5B JUMPDEST 1D1F 61 PUSH2 0x1924 1D22 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1924 label_1D23: // Incoming return from call to 0x1D1E at 0x1D1D // Inputs[4] // { // @1D24 stack[-2] // @1D25 stack[-1] // @1D27 stack[-9] // @1D2B stack[-3] // } 1D23 5B JUMPDEST 1D24 81 DUP2 1D25 81 DUP2 1D26 52 MSTORE 1D27 88 DUP9 1D28 60 PUSH1 0x20 1D2A 83 DUP4 1D2B 85 DUP6 1D2C 01 ADD 1D2D 01 ADD 1D2E 11 GT 1D2F 15 ISZERO 1D30 61 PUSH2 0x1d38 1D33 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1D26 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x1d38, if !(stack[-3] + stack[-2] + 0x20 > stack[-9]) label_1D34: // Incoming jump from 0x1D33, if not !(stack[-3] + stack[-2] + 0x20 > stack[-9]) // Inputs[1] { @1D37 memory[0x00:0x00] } 1D34 60 PUSH1 0x00 1D36 80 DUP1 1D37 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D37 revert(memory[0x00:0x00]); } // Block terminates label_1D38: // Incoming jump from 0x1D33, if !(stack[-3] + stack[-2] + 0x20 > stack[-9]) // Inputs[11] // { // @1D39 stack[-2] // @1D3C stack[-3] // @1D40 stack[-1] // @1D42 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-2]] // @1D4D stack[-4] // @1D52 stack[-7] // @1D53 stack[-10] // @1D54 stack[-6] // @1D55 stack[-9] // @1D57 stack[-5] // @1D57 stack[-8] // } 1D38 5B JUMPDEST 1D39 81 DUP2 1D3A 60 PUSH1 0x20 1D3C 84 DUP5 1D3D 01 ADD 1D3E 60 PUSH1 0x20 1D40 83 DUP4 1D41 01 ADD 1D42 37 CALLDATACOPY 1D43 60 PUSH1 0x00 1D45 60 PUSH1 0x20 1D47 83 DUP4 1D48 83 DUP4 1D49 01 ADD 1D4A 01 ADD 1D4B 52 MSTORE 1D4C 80 DUP1 1D4D 93 SWAP4 1D4E 50 POP 1D4F 50 POP 1D50 50 POP 1D51 50 POP 1D52 92 SWAP3 1D53 95 SWAP6 1D54 91 SWAP2 1D55 94 SWAP5 1D56 50 POP 1D57 92 SWAP3 1D58 50 POP 1D59 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @1D42 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-2]] // @1D4B memory[stack[-1] + stack[-2] + 0x20:stack[-1] + stack[-2] + 0x20 + 0x20] = 0x00 // @1D52 stack[-7] = stack[-1] // @1D53 stack[-10] = stack[-7] // @1D55 stack[-9] = stack[-6] // @1D57 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1D5A: // Incoming jump from 0x053C // Inputs[5] // { // @1D63 stack[-5] // @1D66 stack[-1] // @1D68 stack[-4] // @1D70 stack[-3] // @1D83 stack[-2] // } 1D5A 5B JUMPDEST 1D5B 60 PUSH1 0x01 1D5D 60 PUSH1 0x01 1D5F 60 PUSH1 0xa0 1D61 1B SHL 1D62 03 SUB 1D63 85 DUP6 1D64 81 DUP2 1D65 16 AND 1D66 82 DUP3 1D67 52 MSTORE 1D68 84 DUP5 1D69 81 DUP2 1D6A 16 AND 1D6B 60 PUSH1 0x20 1D6D 83 DUP4 1D6E 01 ADD 1D6F 52 MSTORE 1D70 83 DUP4 1D71 16 AND 1D72 60 PUSH1 0x40 1D74 82 DUP3 1D75 01 ADD 1D76 52 MSTORE 1D77 61 PUSH2 0x0140 1D7A 81 DUP2 1D7B 01 ADD 1D7C 61 PUSH2 0x1d88 1D7F 60 PUSH1 0x60 1D81 83 DUP4 1D82 01 ADD 1D83 84 DUP5 1D84 61 PUSH2 0x1a3d 1D87 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1D67 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1D6F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1D76 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1D7B stack[0] = stack[-1] + 0x0140 // @1D7C stack[1] = 0x1d88 // @1D82 stack[2] = stack[-1] + 0x60 // @1D83 stack[3] = stack[-2] // } // Block ends with call to 0x1a3d, returns to 0x1D88 label_1D88: // Incoming return from call to 0x17E7 at 0x1EE1 // Incoming return from call to 0x1A3D at 0x1D87 // Inputs[3] // { // @1D89 stack[-7] // @1D89 stack[-1] // @1D8A stack[-6] // } 1D88 5B JUMPDEST 1D89 95 SWAP6 1D8A 94 SWAP5 1D8B 50 POP 1D8C 50 POP 1D8D 50 POP 1D8E 50 POP 1D8F 50 POP 1D90 56 *JUMP // Stack delta = -6 // Outputs[1] { @1D89 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_1D91: // Incoming call from 0x054A, returns to 0x054B // Inputs[2] // { // @1D97 stack[-1] // @1D98 stack[-2] // } 1D91 5B JUMPDEST 1D92 60 PUSH1 0x00 1D94 80 DUP1 1D95 60 PUSH1 0x40 1D97 83 DUP4 1D98 85 DUP6 1D99 03 SUB 1D9A 12 SLT 1D9B 15 ISZERO 1D9C 61 PUSH2 0x1da4 1D9F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D92 stack[0] = 0x00 // @1D94 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1da4, if !(stack[-2] - stack[-1] i< 0x40) label_1DA0: // Incoming jump from 0x1D9F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DA3 memory[0x00:0x00] } 1DA0 60 PUSH1 0x00 1DA2 80 DUP1 1DA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DA3 revert(memory[0x00:0x00]); } // Block terminates label_1DA4: // Incoming jump from 0x1D9F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DA5 stack[-3] // @1DA6 msg.data[stack[-3]:stack[-3] + 0x20] // } 1DA4 5B JUMPDEST 1DA5 82 DUP3 1DA6 35 CALLDATALOAD 1DA7 61 PUSH2 0x1daf 1DAA 81 DUP2 1DAB 61 PUSH2 0x186f 1DAE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DA6 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1DA7 stack[1] = 0x1daf // @1DAA stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x186f, returns to 0x1DAF label_1DAF: // Incoming return from call to 0x186F at 0x1DAE // Inputs[4] // { // @1DB0 stack[-3] // @1DB0 stack[-1] // @1DB4 stack[-4] // @1DB6 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1DAF 5B JUMPDEST 1DB0 91 SWAP2 1DB1 50 POP 1DB2 60 PUSH1 0x20 1DB4 83 DUP4 1DB5 01 ADD 1DB6 35 CALLDATALOAD 1DB7 61 PUSH2 0x1dbf 1DBA 81 DUP2 1DBB 61 PUSH2 0x186f 1DBE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1DB0 stack[-3] = stack[-1] // @1DB6 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @1DB7 stack[0] = 0x1dbf // @1DBA stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x186f, returns to 0x1DBF label_1DBF: // Incoming return from call to 0x186F at 0x1DBE // Inputs[6] // { // @1DC0 stack[-1] // @1DC1 stack[-2] // @1DC4 stack[-5] // @1DC6 stack[-6] // @1DC6 stack[-3] // @1DC7 stack[-4] // } 1DBF 5B JUMPDEST 1DC0 80 DUP1 1DC1 91 SWAP2 1DC2 50 POP 1DC3 50 POP 1DC4 92 SWAP3 1DC5 50 POP 1DC6 92 SWAP3 1DC7 90 SWAP1 1DC8 50 POP 1DC9 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1DC4 stack[-5] = stack[-1] // @1DC6 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1DCA: // Incoming call from 0x0587, returns to 0x0588 // Inputs[2] // { // @1DD3 stack[-1] // @1DD4 stack[-2] // } 1DCA 5B JUMPDEST 1DCB 60 PUSH1 0x00 1DCD 80 DUP1 1DCE 60 PUSH1 0x00 1DD0 80 DUP1 1DD1 60 PUSH1 0x80 1DD3 85 DUP6 1DD4 87 DUP8 1DD5 03 SUB 1DD6 12 SLT 1DD7 15 ISZERO 1DD8 61 PUSH2 0x1de0 1DDB 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1DCB stack[0] = 0x00 // @1DCD stack[1] = 0x00 // @1DCE stack[2] = 0x00 // @1DD0 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1de0, if !(stack[-2] - stack[-1] i< 0x80) label_1DDC: // Incoming jump from 0x1DDB, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1DDF memory[0x00:0x00] } 1DDC 60 PUSH1 0x00 1DDE 80 DUP1 1DDF FD *REVERT // Stack delta = +0 // Outputs[1] { @1DDF revert(memory[0x00:0x00]); } // Block terminates label_1DE0: // Incoming jump from 0x1DDB, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1DE1 stack[-5] // @1DE2 msg.data[stack[-5]:stack[-5] + 0x20] // } 1DE0 5B JUMPDEST 1DE1 84 DUP5 1DE2 35 CALLDATALOAD 1DE3 61 PUSH2 0x1deb 1DE6 81 DUP2 1DE7 61 PUSH2 0x186f 1DEA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DE2 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @1DE3 stack[1] = 0x1deb // @1DE6 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x186f, returns to 0x1DEB label_1DEB: // Incoming return from call to 0x186F at 0x1DEA // Inputs[7] // { // @1DEC stack[-5] // @1DEC stack[-1] // @1DF0 stack[-6] // @1DF2 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1DF3 stack[-4] // @1DF9 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1DFA stack[-3] // } 1DEB 5B JUMPDEST 1DEC 93 SWAP4 1DED 50 POP 1DEE 60 PUSH1 0x20 1DF0 85 DUP6 1DF1 01 ADD 1DF2 35 CALLDATALOAD 1DF3 92 SWAP3 1DF4 50 POP 1DF5 60 PUSH1 0x40 1DF7 85 DUP6 1DF8 01 ADD 1DF9 35 CALLDATALOAD 1DFA 91 SWAP2 1DFB 50 POP 1DFC 61 PUSH2 0x1e07 1DFF 60 PUSH1 0x60 1E01 86 DUP7 1E02 01 ADD 1E03 61 PUSH2 0x1af2 1E06 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1DEC stack[-5] = stack[-1] // @1DF3 stack[-4] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1DFA stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1DFC stack[-1] = 0x1e07 // @1E02 stack[0] = stack[-6] + 0x60 // } // Block ends with call to 0x1af2, returns to 0x1E07 label_1E07: // Incoming return from call to 0x1AF2 at 0x1E06 // Inputs[8] // { // @1E08 stack[-2] // @1E08 stack[-1] // @1E0A stack[-5] // @1E0B stack[-8] // @1E0C stack[-4] // @1E0D stack[-7] // @1E0F stack[-6] // @1E0F stack[-3] // } 1E07 5B JUMPDEST 1E08 90 SWAP1 1E09 50 POP 1E0A 92 SWAP3 1E0B 95 SWAP6 1E0C 91 SWAP2 1E0D 94 SWAP5 1E0E 50 POP 1E0F 92 SWAP3 1E10 50 POP 1E11 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1E0A stack[-5] = stack[-1] // @1E0B stack[-8] = stack[-5] // @1E0D stack[-7] = stack[-4] // @1E0F stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-8] label_1E12: // Incoming call from 0x059E, returns to 0x025B // Inputs[2] // { // @1E15 stack[-1] // @1E20 stack[-7] // } 1E12 5B JUMPDEST 1E13 60 PUSH1 0xc0 1E15 81 DUP2 1E16 52 MSTORE 1E17 60 PUSH1 0x00 1E19 61 PUSH2 0x1e25 1E1C 60 PUSH1 0xc0 1E1E 83 DUP4 1E1F 01 ADD 1E20 89 DUP10 1E21 61 PUSH2 0x1b3c 1E24 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1E16 memory[stack[-1]:stack[-1] + 0x20] = 0xc0 // @1E17 stack[0] = 0x00 // @1E19 stack[1] = 0x1e25 // @1E1F stack[2] = stack[-1] + 0xc0 // @1E20 stack[3] = stack[-7] // } // Block ends with call to 0x1b3c, returns to 0x1E25 label_1E25: // Incoming return from call to 0x1B3C at 0x1E24 // Inputs[3] // { // @1E26 stack[-3] // @1E27 stack[-1] // @1E32 stack[-8] // } 1E25 5B JUMPDEST 1E26 82 DUP3 1E27 81 DUP2 1E28 03 SUB 1E29 60 PUSH1 0x20 1E2B 84 DUP5 1E2C 01 ADD 1E2D 52 MSTORE 1E2E 61 PUSH2 0x1e37 1E31 81 DUP2 1E32 89 DUP10 1E33 61 PUSH2 0x19f9 1E36 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1E2D memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @1E2E stack[0] = 0x1e37 // @1E31 stack[1] = stack[-1] // @1E32 stack[2] = stack[-8] // } // Block ends with call to 0x19f9, returns to 0x1E37 label_1E37: // Incoming return from call to 0x19F9 at 0x1E36 // Inputs[4] // { // @1E38 stack[-1] // @1E38 stack[-2] // @1E3A stack[-4] // @1E46 stack[-8] // } 1E37 5B JUMPDEST 1E38 90 SWAP1 1E39 50 POP 1E3A 82 DUP3 1E3B 81 DUP2 1E3C 03 SUB 1E3D 60 PUSH1 0x40 1E3F 84 DUP5 1E40 01 ADD 1E41 52 MSTORE 1E42 61 PUSH2 0x1e4b 1E45 81 DUP2 1E46 88 DUP9 1E47 61 PUSH2 0x19f9 1E4A 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1E38 stack[-2] = stack[-1] // @1E41 memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] = stack[-1] - stack[-4] // @1E42 stack[-1] = 0x1e4b // @1E45 stack[0] = stack[-1] // @1E46 stack[1] = stack[-8] // } // Block ends with call to 0x19f9, returns to 0x1E4B label_1E4B: // Incoming return from call to 0x19F9 at 0x1E4A // Inputs[4] // { // @1E4C stack[-1] // @1E4C stack[-2] // @1E4E stack[-4] // @1E5A stack[-7] // } 1E4B 5B JUMPDEST 1E4C 90 SWAP1 1E4D 50 POP 1E4E 82 DUP3 1E4F 81 DUP2 1E50 03 SUB 1E51 60 PUSH1 0x60 1E53 84 DUP5 1E54 01 ADD 1E55 52 MSTORE 1E56 61 PUSH2 0x1e5f 1E59 81 DUP2 1E5A 87 DUP8 1E5B 61 PUSH2 0x1a60 1E5E 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1E4C stack[-2] = stack[-1] // @1E55 memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] = stack[-1] - stack[-4] // @1E56 stack[-1] = 0x1e5f // @1E59 stack[0] = stack[-1] // @1E5A stack[1] = stack[-7] // } // Block ends with call to 0x1a60, returns to 0x1E5F label_1E5F: // Incoming return from call to 0x1A60 at 0x1E5E // Inputs[6] // { // @1E62 stack[-4] // @1E64 stack[-6] // @1E65 stack[-1] // @1E6D stack[-5] // @1E6E stack[-11] // @1E6F stack[-10] // } 1E5F 5B JUMPDEST 1E60 60 PUSH1 0x80 1E62 84 DUP5 1E63 01 ADD 1E64 95 SWAP6 1E65 90 SWAP1 1E66 95 SWAP6 1E67 52 MSTORE 1E68 50 POP 1E69 50 POP 1E6A 60 PUSH1 0xa0 1E6C 01 ADD 1E6D 52 MSTORE 1E6E 94 SWAP5 1E6F 93 SWAP4 1E70 50 POP 1E71 50 POP 1E72 50 POP 1E73 50 POP 1E74 56 *JUMP // Stack delta = -10 // Outputs[3] // { // @1E67 memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] = stack[-6] // @1E6D memory[0xa0 + stack[-4]:0xa0 + stack[-4] + 0x20] = stack[-5] // @1E6E stack[-11] = stack[-1] // } // Block ends with unconditional jump to stack[-11] label_1E75: // Incoming call from 0x1258, returns to 0x07B7 // Incoming call from 0x0636, returns to 0x0637 // Inputs[2] // { // @1E7A stack[-1] // @1E7B stack[-2] // } 1E75 5B JUMPDEST 1E76 60 PUSH1 0x00 1E78 60 PUSH1 0x20 1E7A 82 DUP3 1E7B 84 DUP5 1E7C 03 SUB 1E7D 12 SLT 1E7E 15 ISZERO 1E7F 61 PUSH2 0x1e87 1E82 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E76 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e87, if !(stack[-2] - stack[-1] i< 0x20) label_1E83: // Incoming jump from 0x1E82, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E86 memory[0x00:0x00] } 1E83 60 PUSH1 0x00 1E85 80 DUP1 1E86 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E86 revert(memory[0x00:0x00]); } // Block terminates label_1E87: // Incoming jump from 0x1E82, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E88 stack[-2] // @1E89 memory[stack[-2]:stack[-2] + 0x20] // } 1E87 5B JUMPDEST 1E88 81 DUP2 1E89 51 MLOAD 1E8A 60 PUSH1 0x01 1E8C 60 PUSH1 0x01 1E8E 60 PUSH1 0x40 1E90 1B SHL 1E91 03 SUB 1E92 81 DUP2 1E93 11 GT 1E94 15 ISZERO 1E95 61 PUSH2 0x1e9d 1E98 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E89 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e9d, if !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_1E99: // Incoming jump from 0x1E98, if not !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1E9C memory[0x00:0x00] } 1E99 60 PUSH1 0x00 1E9B 80 DUP1 1E9C FD *REVERT // Stack delta = +0 // Outputs[1] { @1E9C revert(memory[0x00:0x00]); } // Block terminates label_1E9D: // Incoming jump from 0x1E98, if !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1E9E stack[-3] // @1E9F stack[-1] // @1EA4 stack[-4] // } 1E9D 5B JUMPDEST 1E9E 82 DUP3 1E9F 01 ADD 1EA0 60 PUSH1 0x1f 1EA2 81 DUP2 1EA3 01 ADD 1EA4 84 DUP5 1EA5 13 SGT 1EA6 61 PUSH2 0x1eae 1EA9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E9F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1eae, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1EAA: // Incoming jump from 0x1EA9, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1EAD memory[0x00:0x00] } 1EAA 60 PUSH1 0x00 1EAC 80 DUP1 1EAD FD *REVERT // Stack delta = +0 // Outputs[1] { @1EAD revert(memory[0x00:0x00]); } // Block terminates label_1EAE: // Incoming jump from 0x1EA9, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @1EAF stack[-1] // @1EB0 memory[stack[-1]:stack[-1] + 0x20] // } 1EAE 5B JUMPDEST 1EAF 80 DUP1 1EB0 51 MLOAD 1EB1 61 PUSH2 0x1ebc 1EB4 61 PUSH2 0x1d1e 1EB7 82 DUP3 1EB8 61 PUSH2 0x1c85 1EBB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EB0 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @1EB1 stack[1] = 0x1ebc // @1EB4 stack[2] = 0x1d1e // @1EB7 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1c85, returns to 0x1D1E label_1EBC: // Incoming return from call to 0x1D1E at 0x1EBB // Inputs[4] // { // @1EBD stack[-2] // @1EBE stack[-1] // @1EC0 stack[-6] // @1EC4 stack[-3] // } 1EBC 5B JUMPDEST 1EBD 81 DUP2 1EBE 81 DUP2 1EBF 52 MSTORE 1EC0 85 DUP6 1EC1 60 PUSH1 0x20 1EC3 83 DUP4 1EC4 85 DUP6 1EC5 01 ADD 1EC6 01 ADD 1EC7 11 GT 1EC8 15 ISZERO 1EC9 61 PUSH2 0x1ed1 1ECC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EBF memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x1ed1, if !(stack[-3] + stack[-2] + 0x20 > stack[-6]) label_1ECD: // Incoming jump from 0x1ECC, if not !(stack[-3] + stack[-2] + 0x20 > stack[-6]) // Inputs[1] { @1ED0 memory[0x00:0x00] } 1ECD 60 PUSH1 0x00 1ECF 80 DUP1 1ED0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1ED0 revert(memory[0x00:0x00]); } // Block terminates label_1ED1: // Incoming jump from 0x1ECC, if !(stack[-3] + stack[-2] + 0x20 > stack[-6]) // Inputs[3] // { // @1ED5 stack[-2] // @1ED8 stack[-1] // @1EDC stack[-3] // } 1ED1 5B JUMPDEST 1ED2 61 PUSH2 0x1d88 1ED5 82 DUP3 1ED6 60 PUSH1 0x20 1ED8 83 DUP4 1ED9 01 ADD 1EDA 60 PUSH1 0x20 1EDC 86 DUP7 1EDD 01 ADD 1EDE 61 PUSH2 0x17e7 1EE1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1ED2 stack[0] = 0x1d88 // @1ED5 stack[1] = stack[-2] // @1ED9 stack[2] = stack[-1] + 0x20 // @1EDD stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x17e7, returns to 0x1D88 label_1EE2: // Incoming jump from 0x0940 // Incoming jump from 0x0959 // Incoming jump from 0x0927 // Incoming jump from 0x0972 // Incoming jump from 0x0908 // Inputs[1] { @1EF7 memory[0x00:0x24] } 1EE2 5B JUMPDEST 1EE3 63 PUSH4 0x4e487b71 1EE8 60 PUSH1 0xe0 1EEA 1B SHL 1EEB 60 PUSH1 0x00 1EED 52 MSTORE 1EEE 60 PUSH1 0x32 1EF0 60 PUSH1 0x04 1EF2 52 MSTORE 1EF3 60 PUSH1 0x24 1EF5 60 PUSH1 0x00 1EF7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1EED memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1EF2 memory[0x04:0x24] = 0x32 // @1EF7 revert(memory[0x00:0x24]); // } // Block terminates label_1EF8: // Incoming jump from 0x1F21 // Incoming jump from 0x1FAF // Incoming jump from 0x1F98 // Incoming jump from 0x201D // Incoming jump from 0x1F79 // Inputs[1] { @1F0D memory[0x00:0x24] } 1EF8 5B JUMPDEST 1EF9 63 PUSH4 0x4e487b71 1EFE 60 PUSH1 0xe0 1F00 1B SHL 1F01 60 PUSH1 0x00 1F03 52 MSTORE 1F04 60 PUSH1 0x11 1F06 60 PUSH1 0x04 1F08 52 MSTORE 1F09 60 PUSH1 0x24 1F0B 60 PUSH1 0x00 1F0D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1F03 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1F08 memory[0x04:0x24] = 0x11 // @1F0D revert(memory[0x00:0x24]); // } // Block terminates label_1F0E: // Incoming call from 0x0D42, returns to 0x0D43 // Incoming call from 0x09A3, returns to 0x09A4 // Incoming call from 0x0F47, returns to 0x0F48 // Incoming call from 0x170F, returns to 0x1710 // Inputs[1] { @1F14 stack[-1] } 1F0E 5B JUMPDEST 1F0F 60 PUSH1 0x00 1F11 60 PUSH1 0x00 1F13 19 NOT 1F14 82 DUP3 1F15 14 EQ 1F16 15 ISZERO 1F17 61 PUSH2 0x1f22 1F1A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F0F stack[0] = 0x00 } // Block ends with conditional jump to 0x1f22, if !(stack[-1] == ~0x00) label_1F1B: // Incoming jump from 0x1F1A, if not !(stack[-1] == ~0x00) 1F1B 61 PUSH2 0x1f22 1F1E 61 PUSH2 0x1ef8 1F21 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F1B stack[0] = 0x1f22 } // Block ends with unconditional jump to 0x1ef8 label_1F22: // Incoming jump from 0x1F1A, if !(stack[-1] == ~0x00) // Inputs[2] // { // @1F26 stack[-2] // @1F27 stack[-3] // } 1F22 5B JUMPDEST 1F23 50 POP 1F24 60 PUSH1 0x01 1F26 01 ADD 1F27 90 SWAP1 1F28 56 *JUMP // Stack delta = -2 // Outputs[1] { @1F27 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1F29: // Incoming jump from 0x1F61 // Incoming jump from 0x1F4D // Inputs[1] { @1F3E memory[0x00:0x24] } 1F29 5B JUMPDEST 1F2A 63 PUSH4 0x4e487b71 1F2F 60 PUSH1 0xe0 1F31 1B SHL 1F32 60 PUSH1 0x00 1F34 52 MSTORE 1F35 60 PUSH1 0x12 1F37 60 PUSH1 0x04 1F39 52 MSTORE 1F3A 60 PUSH1 0x24 1F3C 60 PUSH1 0x00 1F3E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1F34 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1F39 memory[0x04:0x24] = 0x12 // @1F3E revert(memory[0x00:0x24]); // } // Block terminates label_1F3F: // Incoming call from 0x0A6C, returns to 0x0A6D // Incoming call from 0x1367, returns to 0x1368 // Incoming call from 0x1307, returns to 0x1308 // Incoming call from 0x0ACC, returns to 0x0ACD // Incoming call from 0x1379, returns to 0x137A // Incoming call from 0x0ADE, returns to 0x0ADF // Inputs[1] { @1F42 stack[-2] } 1F3F 5B JUMPDEST 1F40 60 PUSH1 0x00 1F42 82 DUP3 1F43 61 PUSH2 0x1f4e 1F46 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F40 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f4e, if stack[-2] label_1F47: // Incoming jump from 0x1F46, if not stack[-2] 1F47 61 PUSH2 0x1f4e 1F4A 61 PUSH2 0x1f29 1F4D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F47 stack[0] = 0x1f4e } // Block ends with unconditional jump to 0x1f29 label_1F4E: // Incoming jump from 0x1F46, if stack[-2] // Inputs[3] // { // @1F50 stack[-3] // @1F50 stack[-2] // @1F51 stack[-4] // } 1F4E 5B JUMPDEST 1F4F 50 POP 1F50 06 MOD 1F51 90 SWAP1 1F52 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F51 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_1F53: // Incoming call from 0x1323, returns to 0x1324 // Incoming call from 0x0A88, returns to 0x0A89 // Incoming call from 0x1323, returns to 0x1324 // Incoming call from 0x0A88, returns to 0x0A89 // Inputs[1] { @1F56 stack[-2] } 1F53 5B JUMPDEST 1F54 60 PUSH1 0x00 1F56 82 DUP3 1F57 61 PUSH2 0x1f62 1F5A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F54 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f62, if stack[-2] label_1F5B: // Incoming jump from 0x1F5A, if not stack[-2] 1F5B 61 PUSH2 0x1f62 1F5E 61 PUSH2 0x1f29 1F61 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F5B stack[0] = 0x1f62 } // Block ends with unconditional jump to 0x1f29 label_1F62: // Incoming jump from 0x1F5A, if stack[-2] // Inputs[3] // { // @1F64 stack[-2] // @1F64 stack[-3] // @1F65 stack[-4] // } 1F62 5B JUMPDEST 1F63 50 POP 1F64 04 DIV 1F65 90 SWAP1 1F66 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F65 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_1F67: // Incoming call from 0x0A92, returns to 0x0A93 // Incoming call from 0x0B63, returns to 0x035F // Incoming call from 0x13FF, returns to 0x0316 // Incoming call from 0x132D, returns to 0x132E // Incoming call from 0x1720, returns to 0x1721 // Incoming call from 0x168C, returns to 0x168D // Incoming call from 0x0F58, returns to 0x0F59 // Inputs[2] // { // @1F6A stack[-2] // @1F6C stack[-1] // } 1F67 5B JUMPDEST 1F68 60 PUSH1 0x00 1F6A 82 DUP3 1F6B 19 NOT 1F6C 82 DUP3 1F6D 11 GT 1F6E 15 ISZERO 1F6F 61 PUSH2 0x1f7a 1F72 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F68 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f7a, if !(stack[-1] > ~stack[-2]) label_1F73: // Incoming jump from 0x1F72, if not !(stack[-1] > ~stack[-2]) 1F73 61 PUSH2 0x1f7a 1F76 61 PUSH2 0x1ef8 1F79 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F73 stack[0] = 0x1f7a } // Block ends with unconditional jump to 0x1ef8 label_1F7A: // Incoming jump from 0x1F72, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1F7C stack[-2] // @1F7C stack[-3] // @1F7D stack[-4] // } 1F7A 5B JUMPDEST 1F7B 50 POP 1F7C 01 ADD 1F7D 90 SWAP1 1F7E 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F7D stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1F7F: // Incoming call from 0x1347, returns to 0x1348 // Incoming call from 0x0AAC, returns to 0x0AAD // Inputs[2] // { // @1F82 stack[-1] // @1F87 stack[-2] // } 1F7F 5B JUMPDEST 1F80 60 PUSH1 0x00 1F82 81 DUP2 1F83 60 PUSH1 0x00 1F85 19 NOT 1F86 04 DIV 1F87 83 DUP4 1F88 11 GT 1F89 82 DUP3 1F8A 15 ISZERO 1F8B 15 ISZERO 1F8C 16 AND 1F8D 15 ISZERO 1F8E 61 PUSH2 0x1f99 1F91 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F80 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f99, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_1F92: // Incoming jump from 0x1F91, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 1F92 61 PUSH2 0x1f99 1F95 61 PUSH2 0x1ef8 1F98 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F92 stack[0] = 0x1f99 } // Block ends with unconditional jump to 0x1ef8 label_1F99: // Incoming jump from 0x1F91, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @1F9B stack[-2] // @1F9B stack[-3] // @1F9C stack[-4] // } 1F99 5B JUMPDEST 1F9A 50 POP 1F9B 02 MUL 1F9C 90 SWAP1 1F9D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F9C stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_1F9E: // Incoming call from 0x1354, returns to 0x1355 // Incoming call from 0x0C30, returns to 0x0C31 // Incoming call from 0x13F5, returns to 0x0316 // Incoming call from 0x13EB, returns to 0x13EC // Incoming call from 0x0AB9, returns to 0x0ABA // Incoming call from 0x1645, returns to 0x1646 // Incoming call from 0x0B4F, returns to 0x0B50 // Incoming call from 0x13E1, returns to 0x13E2 // Incoming call from 0x1614, returns to 0x1615 // Incoming call from 0x1614, returns to 0x1615 // Incoming call from 0x0B45, returns to 0x0B46 // Incoming call from 0x0B59, returns to 0x035F // Inputs[2] // { // @1FA1 stack[-2] // @1FA2 stack[-1] // } 1F9E 5B JUMPDEST 1F9F 60 PUSH1 0x00 1FA1 82 DUP3 1FA2 82 DUP3 1FA3 10 LT 1FA4 15 ISZERO 1FA5 61 PUSH2 0x1fb0 1FA8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F9F stack[0] = 0x00 } // Block ends with conditional jump to 0x1fb0, if !(stack[-1] < stack[-2]) label_1FA9: // Incoming jump from 0x1FA8, if not !(stack[-1] < stack[-2]) 1FA9 61 PUSH2 0x1fb0 1FAC 61 PUSH2 0x1ef8 1FAF 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FA9 stack[0] = 0x1fb0 } // Block ends with unconditional jump to 0x1ef8 label_1FB0: // Incoming jump from 0x1FA8, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @1FB2 stack[-3] // @1FB2 stack[-2] // @1FB3 stack[-4] // } 1FB0 5B JUMPDEST 1FB1 50 POP 1FB2 03 SUB 1FB3 90 SWAP1 1FB4 56 *JUMP // Stack delta = -3 // Outputs[1] { @1FB3 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_1FB5: // Incoming call from 0x1180, returns to 0x1181 // Inputs[5] // { // @1FBE stack[-5] // @1FC1 stack[-1] // @1FC3 stack[-4] // @1FCE stack[-3] // @1FE3 stack[-2] // } 1FB5 5B JUMPDEST 1FB6 60 PUSH1 0x01 1FB8 60 PUSH1 0x01 1FBA 60 PUSH1 0xa0 1FBC 1B SHL 1FBD 03 SUB 1FBE 85 DUP6 1FBF 81 DUP2 1FC0 16 AND 1FC1 82 DUP3 1FC2 52 MSTORE 1FC3 84 DUP5 1FC4 16 AND 1FC5 60 PUSH1 0x20 1FC7 82 DUP3 1FC8 01 ADD 1FC9 52 MSTORE 1FCA 60 PUSH1 0x40 1FCC 81 DUP2 1FCD 01 ADD 1FCE 83 DUP4 1FCF 90 SWAP1 1FD0 52 MSTORE 1FD1 60 PUSH1 0x80 1FD3 60 PUSH1 0x60 1FD5 82 DUP3 1FD6 01 ADD 1FD7 81 DUP2 1FD8 90 SWAP1 1FD9 52 MSTORE 1FDA 60 PUSH1 0x00 1FDC 90 SWAP1 1FDD 61 PUSH2 0x1fe8 1FE0 90 SWAP1 1FE1 83 DUP4 1FE2 01 ADD 1FE3 84 DUP5 1FE4 61 PUSH2 0x1817 1FE7 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1FC2 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1FC9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1FD0 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1FD9 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @1FDC stack[0] = 0x00 // @1FE0 stack[1] = 0x1fe8 // @1FE2 stack[2] = stack[-1] + 0x80 // @1FE3 stack[3] = stack[-2] // } // Block ends with call to 0x1817, returns to 0x1FE8 label_1FE8: // Incoming return from call to 0x1817 at 0x1FE7 // Inputs[3] // { // @1FE9 stack[-8] // @1FE9 stack[-1] // @1FEA stack[-7] // } 1FE8 5B JUMPDEST 1FE9 96 SWAP7 1FEA 95 SWAP6 1FEB 50 POP 1FEC 50 POP 1FED 50 POP 1FEE 50 POP 1FEF 50 POP 1FF0 50 POP 1FF1 56 *JUMP // Stack delta = -7 // Outputs[1] { @1FE9 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1FF2: // Incoming jump from 0x11C3 // Inputs[2] // { // @1FF7 stack[-1] // @1FF8 stack[-2] // } 1FF2 5B JUMPDEST 1FF3 60 PUSH1 0x00 1FF5 60 PUSH1 0x20 1FF7 82 DUP3 1FF8 84 DUP5 1FF9 03 SUB 1FFA 12 SLT 1FFB 15 ISZERO 1FFC 61 PUSH2 0x2004 1FFF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FF3 stack[0] = 0x00 } // Block ends with conditional jump to 0x2004, if !(stack[-2] - stack[-1] i< 0x20) label_2000: // Incoming jump from 0x1FFF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2003 memory[0x00:0x00] } 2000 60 PUSH1 0x00 2002 80 DUP1 2003 FD *REVERT // Stack delta = +0 // Outputs[1] { @2003 revert(memory[0x00:0x00]); } // Block terminates label_2004: // Incoming jump from 0x1FFF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2005 stack[-2] // @2006 memory[stack[-2]:stack[-2] + 0x20] // } 2004 5B JUMPDEST 2005 81 DUP2 2006 51 MLOAD 2007 61 PUSH2 0x0c31 200A 81 DUP2 200B 61 PUSH2 0x17b1 200E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2006 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2007 stack[1] = 0x0c31 // @200A stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x17b1, returns to 0x0C31 label_200F: // Incoming call from 0x16CA, returns to 0x16CB // Inputs[1] { @2012 stack[-1] } 200F 5B JUMPDEST 2010 60 PUSH1 0x00 2012 81 DUP2 2013 61 PUSH2 0x201e 2016 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2010 stack[0] = 0x00 } // Block ends with conditional jump to 0x201e, if stack[-1] label_2017: // Incoming jump from 0x2016, if not stack[-1] 2017 61 PUSH2 0x201e 201A 61 PUSH2 0x1ef8 201D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2017 stack[0] = 0x201e } // Block ends with unconditional jump to 0x1ef8 label_201E: // Incoming jump from 0x2016, if stack[-1] // Inputs[2] // { // @2023 stack[-2] // @2024 stack[-3] // } 201E 5B JUMPDEST 201F 50 POP 2020 60 PUSH1 0x00 2022 19 NOT 2023 01 ADD 2024 90 SWAP1 2025 56 *JUMP // Stack delta = -2 // Outputs[1] { @2024 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] 2026 FE *ASSERT 2027 A2 LOG2 2028 64 PUSH5 0x6970667358 202E 22 22 202F 12 SLT 2030 20 SHA3 2031 12 SLT 2032 B4 B4 2033 DD DD 2034 25 25 2035 FC FC 2036 22 22 2037 61 PUSH2 0xf595 203A A9 A9 203B D7 D7 203C 22 22 203D F2 CALLCODE 203E 69 PUSH10 0xb7d04e7f63401ca7c429 2049 EF EF 204A 3F EXTCODEHASH 204B 73 PUSH20 0x854b39eb7764736f6c634300080b0033