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 0x0232 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0232, 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 0x7c69eae2 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 0x7c69eae2 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x7c69eae2 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb5466669 0031 11 GT 0032 61 PUSH2 0x00b8 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b8, if 0xb5466669 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb5466669 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd284d97a 003C 11 GT 003D 61 PUSH2 0x007c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xd284d97a > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd284d97a > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd284d97a 0047 14 EQ 0048 61 PUSH2 0x0d4e 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d4e, if 0xd284d97a == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd284d97a == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xd8d3cc6e 0052 14 EQ 0053 61 PUSH2 0x0dbc 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dbc, if 0xd8d3cc6e == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xd8d3cc6e == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe67ca8a3 005D 14 EQ 005E 61 PUSH2 0x0e3f 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e3f, if 0xe67ca8a3 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe67ca8a3 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xe985e9c5 0068 14 EQ 0069 61 PUSH2 0x0e5c 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e5c, if 0xe985e9c5 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xebf0c717 0073 14 EQ 0074 61 PUSH2 0x0e8a 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e8a, if 0xebf0c717 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xebf0c717 == stack[-1] 0078 61 PUSH2 0x0232 007B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_007C: // Incoming jump from 0x0040, if 0xd284d97a > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xb5466669 0083 14 EQ 0084 61 PUSH2 0x09ce 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ce, if 0xb5466669 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xb5466669 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb88d4fde 008E 14 EQ 008F 61 PUSH2 0x0a51 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a51, if 0xb88d4fde == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xc29b52f9 0099 14 EQ 009A 61 PUSH2 0x0b15 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b15, if 0xc29b52f9 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xc29b52f9 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x0c5e 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c5e, 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 0xce9fb82b 00AF 14 EQ 00B0 61 PUSH2 0x0c7b 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c7b, if 0xce9fb82b == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xce9fb82b == stack[-1] 00B4 61 PUSH2 0x0232 00B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_00B8: // Incoming jump from 0x0035, if 0xb5466669 > 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 0x090b 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x090b, 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 0xa7fc7a07 00D5 14 EQ 00D6 61 PUSH2 0x0939 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0939, if 0xa7fc7a07 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0xa7fc7a07 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0xab3b87fe 00E0 14 EQ 00E1 61 PUSH2 0x095f 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x095f, if 0xab3b87fe == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0xab3b87fe == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0xb3f9e4cb 00EB 14 EQ 00EC 61 PUSH2 0x098b 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x098b, if 0xb3f9e4cb == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0xb3f9e4cb == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0xb429afeb 00F6 14 EQ 00F7 61 PUSH2 0x09a8 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09a8, if 0xb429afeb == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0xb429afeb == stack[-1] 00FB 61 PUSH2 0x0232 00FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_00FF: // Incoming jump from 0x00C3, if 0xa22cb465 > stack[-1] // Inputs[1] { @0100 stack[-1] } 00FF 5B JUMPDEST 0100 80 DUP1 0101 63 PUSH4 0x7c69eae2 0106 14 EQ 0107 61 PUSH2 0x0764 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0764, if 0x7c69eae2 == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x7c69eae2 == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x95d89b41 0111 14 EQ 0112 61 PUSH2 0x07e7 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e7, if 0x95d89b41 == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x9d743989 011C 14 EQ 011D 61 PUSH2 0x07ef 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ef, if 0x9d743989 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x9d743989 == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x9e5be9a5 0127 14 EQ 0128 61 PUSH2 0x087d 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x087d, if 0x9e5be9a5 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x9e5be9a5 == stack[-1] 012C 61 PUSH2 0x0232 012F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_0130: // Incoming jump from 0x002A, if 0x7c69eae2 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0131 stack[-1] } 0130 5B JUMPDEST 0131 80 DUP1 0132 63 PUSH4 0x42842e0e 0137 11 GT 0138 61 PUSH2 0x01be 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01be, if 0x42842e0e > stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x42842e0e > stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x5cbe1112 0142 11 GT 0143 61 PUSH2 0x0182 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0182, if 0x5cbe1112 > stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x5cbe1112 > stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x5cbe1112 014D 14 EQ 014E 61 PUSH2 0x061d 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061d, if 0x5cbe1112 == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x5cbe1112 == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x6352211e 0158 14 EQ 0159 61 PUSH2 0x0692 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0692, if 0x6352211e == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x6352211e == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x66ac3b68 0163 14 EQ 0164 61 PUSH2 0x06af 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06af, if 0x66ac3b68 == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x66ac3b68 == stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x68b62d32 016E 14 EQ 016F 61 PUSH2 0x06b7 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b7, if 0x68b62d32 == stack[-1] label_0173: // Incoming jump from 0x0172, if not 0x68b62d32 == stack[-1] // Inputs[1] { @0173 stack[-1] } 0173 80 DUP1 0174 63 PUSH4 0x70a08231 0179 14 EQ 017A 61 PUSH2 0x073e 017D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073e, if 0x70a08231 == stack[-1] label_017E: // Incoming jump from 0x017D, if not 0x70a08231 == stack[-1] 017E 61 PUSH2 0x0232 0181 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_0182: // Incoming jump from 0x0146, if 0x5cbe1112 > stack[-1] // Inputs[1] { @0183 stack[-1] } 0182 5B JUMPDEST 0183 80 DUP1 0184 63 PUSH4 0x42842e0e 0189 14 EQ 018A 61 PUSH2 0x04ed 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ed, if 0x42842e0e == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x42842e0e == stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0x42966c68 0194 14 EQ 0195 61 PUSH2 0x0523 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0523, if 0x42966c68 == stack[-1] label_0199: // Incoming jump from 0x0198, if not 0x42966c68 == stack[-1] // Inputs[1] { @0199 stack[-1] } 0199 80 DUP1 019A 63 PUSH4 0x430c2081 019F 14 EQ 01A0 61 PUSH2 0x0540 01A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0540, if 0x430c2081 == stack[-1] label_01A4: // Incoming jump from 0x01A3, if not 0x430c2081 == stack[-1] // Inputs[1] { @01A4 stack[-1] } 01A4 80 DUP1 01A5 63 PUSH4 0x538361a7 01AA 14 EQ 01AB 61 PUSH2 0x056c 01AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056c, if 0x538361a7 == stack[-1] label_01AF: // Incoming jump from 0x01AE, if not 0x538361a7 == stack[-1] // Inputs[1] { @01AF stack[-1] } 01AF 80 DUP1 01B0 63 PUSH4 0x57aac574 01B5 14 EQ 01B6 61 PUSH2 0x058f 01B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058f, if 0x57aac574 == stack[-1] label_01BA: // Incoming jump from 0x01B9, if not 0x57aac574 == stack[-1] 01BA 61 PUSH2 0x0232 01BD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_01BE: // Incoming jump from 0x013B, if 0x42842e0e > stack[-1] // Inputs[1] { @01BF stack[-1] } 01BE 5B JUMPDEST 01BF 80 DUP1 01C0 63 PUSH4 0x081812fc 01C5 11 GT 01C6 61 PUSH2 0x0205 01C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0205, if 0x081812fc > stack[-1] label_01CA: // Incoming jump from 0x01C9, if not 0x081812fc > stack[-1] // Inputs[1] { @01CA stack[-1] } 01CA 80 DUP1 01CB 63 PUSH4 0x081812fc 01D0 14 EQ 01D1 61 PUSH2 0x03fa 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fa, if 0x081812fc == stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x081812fc == stack[-1] // Inputs[1] { @01D5 stack[-1] } 01D5 80 DUP1 01D6 63 PUSH4 0x095ea7b3 01DB 14 EQ 01DC 61 PUSH2 0x0433 01DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0433, if 0x095ea7b3 == stack[-1] label_01E0: // Incoming jump from 0x01DF, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01E0 stack[-1] } 01E0 80 DUP1 01E1 63 PUSH4 0x2392c189 01E6 14 EQ 01E7 61 PUSH2 0x045f 01EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045f, if 0x2392c189 == stack[-1] label_01EB: // Incoming jump from 0x01EA, if not 0x2392c189 == stack[-1] // Inputs[1] { @01EB stack[-1] } 01EB 80 DUP1 01EC 63 PUSH4 0x23b872dd 01F1 14 EQ 01F2 61 PUSH2 0x048b 01F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048b, if 0x23b872dd == stack[-1] label_01F6: // Incoming jump from 0x01F5, if not 0x23b872dd == stack[-1] // Inputs[1] { @01F6 stack[-1] } 01F6 80 DUP1 01F7 63 PUSH4 0x2525d06a 01FC 14 EQ 01FD 61 PUSH2 0x04c1 0200 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c1, if 0x2525d06a == stack[-1] label_0201: // Incoming jump from 0x0200, if not 0x2525d06a == stack[-1] 0201 61 PUSH2 0x0232 0204 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0232 label_0205: // Incoming jump from 0x01C9, if 0x081812fc > stack[-1] // Inputs[1] { @0206 stack[-1] } 0205 5B JUMPDEST 0206 80 DUP1 0207 63 PUSH4 0x01ffc9a7 020C 14 EQ 020D 61 PUSH2 0x0237 0210 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0237, if 0x01ffc9a7 == stack[-1] label_0211: // Incoming jump from 0x0210, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0211 stack[-1] } 0211 80 DUP1 0212 63 PUSH4 0x02759c37 0217 14 EQ 0218 61 PUSH2 0x0272 021B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0272, if 0x02759c37 == stack[-1] label_021C: // Incoming jump from 0x021B, if not 0x02759c37 == stack[-1] // Inputs[1] { @021C stack[-1] } 021C 80 DUP1 021D 63 PUSH4 0x0467e014 0222 14 EQ 0223 61 PUSH2 0x02aa 0226 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02aa, if 0x0467e014 == stack[-1] label_0227: // Incoming jump from 0x0226, if not 0x0467e014 == stack[-1] // Inputs[1] { @0227 stack[-1] } 0227 80 DUP1 0228 63 PUSH4 0x06fdde03 022D 14 EQ 022E 61 PUSH2 0x037d 0231 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037d, if 0x06fdde03 == stack[-1] label_0232: // Incoming jump from 0x0204 // Incoming jump from 0x00FE // Incoming jump from 0x0181 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x012F // Incoming jump from 0x00B7 // Incoming jump from 0x01BD // Incoming jump from 0x0231, if not 0x06fdde03 == stack[-1] // Incoming jump from 0x007B // Inputs[1] { @0236 memory[0x00:0x00] } 0232 5B JUMPDEST 0233 60 PUSH1 0x00 0235 80 DUP1 0236 FD *REVERT // Stack delta = +0 // Outputs[1] { @0236 revert(memory[0x00:0x00]); } // Block terminates label_0237: // Incoming jump from 0x0210, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @023E msg.data.length } 0237 5B JUMPDEST 0238 61 PUSH2 0x025e 023B 60 PUSH1 0x04 023D 80 DUP1 023E 36 CALLDATASIZE 023F 03 SUB 0240 60 PUSH1 0x20 0242 81 DUP2 0243 10 LT 0244 15 ISZERO 0245 61 PUSH2 0x024d 0248 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0238 stack[0] = 0x025e // @023B stack[1] = 0x04 // @023F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x024d, returns to 0x025E, if !(msg.data.length - 0x04 < 0x20) label_0249: // Incoming jump from 0x0248, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @024C memory[0x00:0x00] } 0249 60 PUSH1 0x00 024B 80 DUP1 024C FD *REVERT // Stack delta = +0 // Outputs[1] { @024C revert(memory[0x00:0x00]); } // Block terminates label_024D: // Incoming call from 0x0248, returns to 0x025E, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @024F msg.data[stack[-2]:stack[-2] + 0x20] // @024F stack[-2] // } 024D 5B JUMPDEST 024E 50 POP 024F 35 CALLDATALOAD 0250 60 PUSH1 0x01 0252 60 PUSH1 0x01 0254 60 PUSH1 0xe0 0256 1B SHL 0257 03 SUB 0258 19 NOT 0259 16 AND 025A 61 PUSH2 0x0e92 025D 56 *JUMP // Stack delta = -1 // Outputs[1] { @0259 stack[-2] = ~((0x01 << 0xe0) - 0x01) & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0e92 label_025E: // Incoming return from call to 0x0556 at 0x0551 // Incoming return from call to 0x024D at 0x0248 // Incoming return from call to 0x0E72 at 0x0E6D // Inputs[4] // { // @0262 memory[0x40:0x60] // @0263 stack[-1] // @0268 memory[0x40:0x60] // @0271 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 025E 5B JUMPDEST 025F 60 PUSH1 0x40 0261 80 DUP1 0262 51 MLOAD 0263 91 SWAP2 0264 15 ISZERO 0265 15 ISZERO 0266 82 DUP3 0267 52 MSTORE 0268 51 MLOAD 0269 90 SWAP1 026A 81 DUP2 026B 90 SWAP1 026C 03 SUB 026D 60 PUSH1 0x20 026F 01 ADD 0270 90 SWAP1 0271 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0267 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0271 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0272: // Incoming jump from 0x021B, if 0x02759c37 == stack[-1] // Inputs[1] { @0279 msg.data.length } 0272 5B JUMPDEST 0273 61 PUSH2 0x02a8 0276 60 PUSH1 0x04 0278 80 DUP1 0279 36 CALLDATASIZE 027A 03 SUB 027B 60 PUSH1 0x60 027D 81 DUP2 027E 10 LT 027F 15 ISZERO 0280 61 PUSH2 0x0288 0283 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0273 stack[0] = 0x02a8 // @0276 stack[1] = 0x04 // @027A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0288, if !(msg.data.length - 0x04 < 0x60) label_0284: // Incoming jump from 0x0283, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0287 memory[0x00:0x00] } 0284 60 PUSH1 0x00 0286 80 DUP1 0287 FD *REVERT // Stack delta = +0 // Outputs[1] { @0287 revert(memory[0x00:0x00]); } // Block terminates label_0288: // Incoming jump from 0x0283, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0292 stack[-2] // @0293 msg.data[stack[-2]:stack[-2] + 0x20] // @029B msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02A3 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0288 5B JUMPDEST 0289 50 POP 028A 60 PUSH1 0x01 028C 60 PUSH1 0x01 028E 60 PUSH1 0xa0 0290 1B SHL 0291 03 SUB 0292 81 DUP2 0293 35 CALLDATALOAD 0294 81 DUP2 0295 16 AND 0296 91 SWAP2 0297 60 PUSH1 0x20 0299 81 DUP2 029A 01 ADD 029B 35 CALLDATALOAD 029C 90 SWAP1 029D 91 SWAP2 029E 16 AND 029F 90 SWAP1 02A0 60 PUSH1 0x40 02A2 01 ADD 02A3 35 CALLDATALOAD 02A4 61 PUSH2 0x0eb1 02A7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0296 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @029F stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02A3 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0eb1 label_02A8: // Incoming return from call to 0x0893 at 0x088E // Incoming return from call to 0x0805 at 0x0800 // Incoming return from call to 0x0B2B at 0x0B26 // Incoming return from call to 0x0921 at 0x091C // Incoming return from call to 0x0582 at 0x057D // Incoming return from call to 0x137A at 0x06B6 // Incoming return from call to 0x0449 at 0x0444 // Incoming return from call to 0x0475 at 0x0470 // Incoming return from call to 0x0975 at 0x0970 02A8 5B JUMPDEST 02A9 00 *STOP // Stack delta = +0 // Outputs[1] { @02A9 stop(); } // Block terminates label_02AA: // Incoming jump from 0x0226, if 0x0467e014 == stack[-1] // Inputs[1] { @02B1 msg.data.length } 02AA 5B JUMPDEST 02AB 61 PUSH2 0x02a8 02AE 60 PUSH1 0x04 02B0 80 DUP1 02B1 36 CALLDATASIZE 02B2 03 SUB 02B3 60 PUSH1 0x80 02B5 81 DUP2 02B6 10 LT 02B7 15 ISZERO 02B8 61 PUSH2 0x02c0 02BB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02AB stack[0] = 0x02a8 // @02AE stack[1] = 0x04 // @02B2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x02c0, if !(msg.data.length - 0x04 < 0x80) label_02BC: // Incoming jump from 0x02BB, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @02BF memory[0x00:0x00] } 02BC 60 PUSH1 0x00 02BE 80 DUP1 02BF FD *REVERT // Stack delta = +0 // Outputs[1] { @02BF revert(memory[0x00:0x00]); } // Block terminates label_02C0: // Incoming jump from 0x02BB, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @02C9 stack[-2] // @02CA msg.data[stack[-2]:stack[-2] + 0x20] // @02D1 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02D2 stack[-1] // @02DE msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 02C0 5B JUMPDEST 02C1 60 PUSH1 0x01 02C3 60 PUSH1 0x01 02C5 60 PUSH1 0xa0 02C7 1B SHL 02C8 03 SUB 02C9 82 DUP3 02CA 35 CALLDATALOAD 02CB 16 AND 02CC 91 SWAP2 02CD 60 PUSH1 0x20 02CF 81 DUP2 02D0 01 ADD 02D1 35 CALLDATALOAD 02D2 91 SWAP2 02D3 81 DUP2 02D4 01 ADD 02D5 90 SWAP1 02D6 60 PUSH1 0x60 02D8 81 DUP2 02D9 01 ADD 02DA 60 PUSH1 0x40 02DC 82 DUP3 02DD 01 ADD 02DE 35 CALLDATALOAD 02DF 60 PUSH1 0x01 02E1 60 PUSH1 0x20 02E3 1B SHL 02E4 81 DUP2 02E5 11 GT 02E6 15 ISZERO 02E7 61 PUSH2 0x02ef 02EA 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @02CC stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @02D2 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02D5 stack[0] = stack[-2] + stack[-1] // @02D5 stack[1] = stack[-2] // @02D9 stack[2] = stack[-2] + 0x60 // @02DE stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x02ef, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_02EB: // Incoming jump from 0x02EA, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @02EE memory[0x00:0x00] } 02EB 60 PUSH1 0x00 02ED 80 DUP1 02EE FD *REVERT // Stack delta = +0 // Outputs[1] { @02EE revert(memory[0x00:0x00]); } // Block terminates label_02EF: // Incoming jump from 0x02EA, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @02F0 stack[-3] // @02F1 stack[-1] // @02F2 stack[-4] // } 02EF 5B JUMPDEST 02F0 82 DUP3 02F1 01 ADD 02F2 83 DUP4 02F3 60 PUSH1 0x20 02F5 82 DUP3 02F6 01 ADD 02F7 11 GT 02F8 15 ISZERO 02F9 61 PUSH2 0x0301 02FC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @02F1 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0301, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_02FD: // Incoming jump from 0x02FC, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0300 memory[0x00:0x00] } 02FD 60 PUSH1 0x00 02FF 80 DUP1 0300 FD *REVERT // Stack delta = +0 // Outputs[1] { @0300 revert(memory[0x00:0x00]); } // Block terminates label_0301: // Incoming jump from 0x02FC, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0302 stack[-1] // @0303 msg.data[stack[-1]:stack[-1] + 0x20] // @0308 stack[-2] // @0309 stack[-4] // } 0301 5B JUMPDEST 0302 80 DUP1 0303 35 CALLDATALOAD 0304 90 SWAP1 0305 60 PUSH1 0x20 0307 01 ADD 0308 91 SWAP2 0309 84 DUP5 030A 60 PUSH1 0x01 030C 83 DUP4 030D 02 MUL 030E 84 DUP5 030F 01 ADD 0310 11 GT 0311 60 PUSH1 0x01 0313 60 PUSH1 0x20 0315 1B SHL 0316 83 DUP4 0317 11 GT 0318 17 OR 0319 15 ISZERO 031A 61 PUSH2 0x0322 031D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0304 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0308 stack[0] = stack[-2] // @0308 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0322, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_031E: // Incoming jump from 0x031D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0321 memory[0x00:0x00] } 031E 60 PUSH1 0x00 0320 80 DUP1 0321 FD *REVERT // Stack delta = +0 // Outputs[1] { @0321 revert(memory[0x00:0x00]); } // Block terminates label_0322: // Incoming jump from 0x031D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[6] // { // @0323 stack[-3] // @0323 stack[-1] // @0324 stack[-5] // @0325 stack[-2] // @0326 stack[-4] // @032E msg.data[stack[-1]:stack[-1] + 0x20] // } 0322 5B JUMPDEST 0323 91 SWAP2 0324 93 SWAP4 0325 90 SWAP1 0326 92 SWAP3 0327 90 SWAP1 0328 91 SWAP2 0329 60 PUSH1 0x20 032B 81 DUP2 032C 01 ADD 032D 90 SWAP1 032E 35 CALLDATALOAD 032F 60 PUSH1 0x01 0331 60 PUSH1 0x20 0333 1B SHL 0334 81 DUP2 0335 11 GT 0336 15 ISZERO 0337 61 PUSH2 0x033f 033A 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0324 stack[-5] = stack[-3] // @0326 stack[-4] = stack[-2] // @0327 stack[-2] = stack[-4] // @0328 stack[-3] = stack[-5] // @032D stack[-1] = stack[-1] + 0x20 // @032E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x033f, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_033B: // Incoming jump from 0x033A, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @033E memory[0x00:0x00] } 033B 60 PUSH1 0x00 033D 80 DUP1 033E FD *REVERT // Stack delta = +0 // Outputs[1] { @033E revert(memory[0x00:0x00]); } // Block terminates label_033F: // Incoming jump from 0x033A, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0340 stack[-3] // @0341 stack[-1] // @0342 stack[-4] // } 033F 5B JUMPDEST 0340 82 DUP3 0341 01 ADD 0342 83 DUP4 0343 60 PUSH1 0x20 0345 82 DUP3 0346 01 ADD 0347 11 GT 0348 15 ISZERO 0349 61 PUSH2 0x0351 034C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0341 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0351, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_034D: // Incoming jump from 0x034C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0350 memory[0x00:0x00] } 034D 60 PUSH1 0x00 034F 80 DUP1 0350 FD *REVERT // Stack delta = +0 // Outputs[1] { @0350 revert(memory[0x00:0x00]); } // Block terminates label_0351: // Incoming jump from 0x034C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0352 stack[-1] // @0353 msg.data[stack[-1]:stack[-1] + 0x20] // @0358 stack[-2] // @0359 stack[-4] // } 0351 5B JUMPDEST 0352 80 DUP1 0353 35 CALLDATALOAD 0354 90 SWAP1 0355 60 PUSH1 0x20 0357 01 ADD 0358 91 SWAP2 0359 84 DUP5 035A 60 PUSH1 0x01 035C 83 DUP4 035D 02 MUL 035E 84 DUP5 035F 01 ADD 0360 11 GT 0361 60 PUSH1 0x01 0363 60 PUSH1 0x20 0365 1B SHL 0366 83 DUP4 0367 11 GT 0368 17 OR 0369 15 ISZERO 036A 61 PUSH2 0x0372 036D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0354 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0358 stack[0] = stack[-2] // @0358 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0372, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_036E: // Incoming jump from 0x036D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0371 memory[0x00:0x00] } 036E 60 PUSH1 0x00 0370 80 DUP1 0371 FD *REVERT // Stack delta = +0 // Outputs[1] { @0371 revert(memory[0x00:0x00]); } // Block terminates label_0372: // Incoming jump from 0x036D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0374 stack[-3] // @0374 stack[-2] // @0375 stack[-5] // @0377 stack[-4] // } 0372 5B JUMPDEST 0373 50 POP 0374 90 SWAP1 0375 92 SWAP3 0376 50 POP 0377 90 SWAP1 0378 50 POP 0379 61 PUSH2 0x0ed3 037C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0375 stack[-5] = stack[-3] // @0377 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x0ed3 label_037D: // Incoming jump from 0x0231, if 0x06fdde03 == stack[-1] 037D 5B JUMPDEST 037E 61 PUSH2 0x0385 0381 61 PUSH2 0x0f62 0384 56 *JUMP // Stack delta = +1 // Outputs[1] { @037E stack[0] = 0x0385 } // Block ends with call to 0x0f62, returns to 0x0385 label_0385: // Incoming return from call to 0x149A at 0x07EE // Incoming return from call to 0x0C74 at 0x0C6F // Incoming return from call to 0x0F62 at 0x0384 // Inputs[4] // { // @0389 memory[0x40:0x60] // @038F stack[-1] // @0390 memory[stack[-1]:stack[-1] + 0x20] // @0396 memory[stack[-1]:stack[-1] + 0x20] // } 0385 5B JUMPDEST 0386 60 PUSH1 0x40 0388 80 DUP1 0389 51 MLOAD 038A 60 PUSH1 0x20 038C 80 DUP1 038D 82 DUP3 038E 52 MSTORE 038F 83 DUP4 0390 51 MLOAD 0391 81 DUP2 0392 83 DUP4 0393 01 ADD 0394 52 MSTORE 0395 83 DUP4 0396 51 MLOAD 0397 91 SWAP2 0398 92 SWAP3 0399 83 DUP4 039A 92 SWAP3 039B 90 SWAP1 039C 83 DUP4 039D 01 ADD 039E 91 SWAP2 039F 85 DUP6 03A0 01 ADD 03A1 90 SWAP1 03A2 80 DUP1 03A3 83 DUP4 03A4 83 DUP4 03A5 60 PUSH1 0x00 03A7 5B JUMPDEST 03A8 83 DUP4 03A9 81 DUP2 03AA 10 LT 03AB 15 ISZERO 03AC 61 PUSH2 0x03bf 03AF 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @038E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0394 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0398 stack[0] = memory[0x40:0x60] // @039A stack[1] = memory[0x40:0x60] // @039E stack[2] = memory[0x40:0x60] + 0x40 // @03A1 stack[3] = stack[-1] + 0x20 // @03A1 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @03A2 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @03A3 stack[6] = memory[0x40:0x60] + 0x40 // @03A4 stack[7] = stack[-1] + 0x20 // @03A5 stack[8] = 0x00 // } // Block ends with conditional jump to 0x03bf, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_03B0: // Incoming jump from 0x03AF, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x03AF, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @03B0 stack[-2] // @03B1 stack[-1] // @03B3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @03B4 stack[-3] // } 03B0 81 DUP2 03B1 81 DUP2 03B2 01 ADD 03B3 51 MLOAD 03B4 83 DUP4 03B5 82 DUP3 03B6 01 ADD 03B7 52 MSTORE 03B8 60 PUSH1 0x20 03BA 01 ADD 03BB 61 PUSH2 0x03a7 03BE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03B7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @03BA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x03a7 label_03BF: // Incoming jump from 0x03AF, if !(stack[-1] < stack[-4]) // Incoming jump from 0x03AF, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @03C4 stack[-6] // @03C4 stack[-5] // @03C6 stack[-7] // } 03BF 5B JUMPDEST 03C0 50 POP 03C1 50 POP 03C2 50 POP 03C3 50 POP 03C4 90 SWAP1 03C5 50 POP 03C6 90 SWAP1 03C7 81 DUP2 03C8 01 ADD 03C9 90 SWAP1 03CA 60 PUSH1 0x1f 03CC 16 AND 03CD 80 DUP1 03CE 15 ISZERO 03CF 61 PUSH2 0x03ec 03D2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @03C9 stack[-7] = stack[-5] + stack[-7] // @03CC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x03ec, if !(0x1f & stack[-5]) label_03D3: // Incoming jump from 0x03D2, if not !(0x1f & stack[-5]) // Inputs[6] // { // @03D3 stack[-1] // @03D4 stack[-2] // @03D7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03EE stack[-5] // @03F4 memory[0x40:0x60] // @03F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 03D3 80 DUP1 03D4 82 DUP3 03D5 03 SUB 03D6 80 DUP1 03D7 51 MLOAD 03D8 60 PUSH1 0x01 03DA 83 DUP4 03DB 60 PUSH1 0x20 03DD 03 SUB 03DE 61 PUSH2 0x0100 03E1 0A EXP 03E2 03 SUB 03E3 19 NOT 03E4 16 AND 03E5 81 DUP2 03E6 52 MSTORE 03E7 60 PUSH1 0x20 03E9 01 ADD 03EA 91 SWAP2 03EB 50 POP 03EC 5B JUMPDEST 03ED 50 POP 03EE 92 SWAP3 03EF 50 POP 03F0 50 POP 03F1 50 POP 03F2 60 PUSH1 0x40 03F4 51 MLOAD 03F5 80 DUP1 03F6 91 SWAP2 03F7 03 SUB 03F8 90 SWAP1 03F9 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @03E6 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @03F9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_03FA: // Incoming jump from 0x01D4, if 0x081812fc == stack[-1] // Inputs[1] { @0401 msg.data.length } 03FA 5B JUMPDEST 03FB 61 PUSH2 0x0417 03FE 60 PUSH1 0x04 0400 80 DUP1 0401 36 CALLDATASIZE 0402 03 SUB 0403 60 PUSH1 0x20 0405 81 DUP2 0406 10 LT 0407 15 ISZERO 0408 61 PUSH2 0x0410 040B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03FB stack[0] = 0x0417 // @03FE stack[1] = 0x04 // @0402 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0410, returns to 0x0417, if !(msg.data.length - 0x04 < 0x20) label_040C: // Incoming jump from 0x040B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @040F memory[0x00:0x00] } 040C 60 PUSH1 0x00 040E 80 DUP1 040F FD *REVERT // Stack delta = +0 // Outputs[1] { @040F revert(memory[0x00:0x00]); } // Block terminates label_0410: // Incoming call from 0x040B, returns to 0x0417, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0412 stack[-2] // @0412 msg.data[stack[-2]:stack[-2] + 0x20] // } 0410 5B JUMPDEST 0411 50 POP 0412 35 CALLDATALOAD 0413 61 PUSH2 0x0f84 0416 56 *JUMP // Stack delta = -1 // Outputs[1] { @0412 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0f84 label_0417: // Incoming return from call to 0x0410 at 0x040B // Incoming return from call to 0x09A1 at 0x099C // Incoming return from call to 0x06A8 at 0x06A3 // Inputs[4] // { // @041B memory[0x40:0x60] // @0425 stack[-1] // @0429 memory[0x40:0x60] // @0432 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0417 5B JUMPDEST 0418 60 PUSH1 0x40 041A 80 DUP1 041B 51 MLOAD 041C 60 PUSH1 0x01 041E 60 PUSH1 0x01 0420 60 PUSH1 0xa0 0422 1B SHL 0423 03 SUB 0424 90 SWAP1 0425 92 SWAP3 0426 16 AND 0427 82 DUP3 0428 52 MSTORE 0429 51 MLOAD 042A 90 SWAP1 042B 81 DUP2 042C 90 SWAP1 042D 03 SUB 042E 60 PUSH1 0x20 0430 01 ADD 0431 90 SWAP1 0432 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0428 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0432 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0433: // Incoming jump from 0x01DF, if 0x095ea7b3 == stack[-1] // Inputs[1] { @043A msg.data.length } 0433 5B JUMPDEST 0434 61 PUSH2 0x02a8 0437 60 PUSH1 0x04 0439 80 DUP1 043A 36 CALLDATASIZE 043B 03 SUB 043C 60 PUSH1 0x40 043E 81 DUP2 043F 10 LT 0440 15 ISZERO 0441 61 PUSH2 0x0449 0444 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0434 stack[0] = 0x02a8 // @0437 stack[1] = 0x04 // @043B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0449, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) label_0445: // Incoming jump from 0x0444, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0448 memory[0x00:0x00] } 0445 60 PUSH1 0x00 0447 80 DUP1 0448 FD *REVERT // Stack delta = +0 // Outputs[1] { @0448 revert(memory[0x00:0x00]); } // Block terminates label_0449: // Incoming call from 0x0444, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0453 stack[-2] // @0454 msg.data[stack[-2]:stack[-2] + 0x20] // @045A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0449 5B JUMPDEST 044A 50 POP 044B 60 PUSH1 0x01 044D 60 PUSH1 0x01 044F 60 PUSH1 0xa0 0451 1B SHL 0452 03 SUB 0453 81 DUP2 0454 35 CALLDATALOAD 0455 16 AND 0456 90 SWAP1 0457 60 PUSH1 0x20 0459 01 ADD 045A 35 CALLDATALOAD 045B 61 PUSH2 0x0fe6 045E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0456 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @045A stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0fe6 label_045F: // Incoming jump from 0x01EA, if 0x2392c189 == stack[-1] // Inputs[1] { @0466 msg.data.length } 045F 5B JUMPDEST 0460 61 PUSH2 0x02a8 0463 60 PUSH1 0x04 0465 80 DUP1 0466 36 CALLDATASIZE 0467 03 SUB 0468 60 PUSH1 0x40 046A 81 DUP2 046B 10 LT 046C 15 ISZERO 046D 61 PUSH2 0x0475 0470 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0460 stack[0] = 0x02a8 // @0463 stack[1] = 0x04 // @0467 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0475, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) label_0471: // Incoming jump from 0x0470, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0474 memory[0x00:0x00] } 0471 60 PUSH1 0x00 0473 80 DUP1 0474 FD *REVERT // Stack delta = +0 // Outputs[1] { @0474 revert(memory[0x00:0x00]); } // Block terminates label_0475: // Incoming call from 0x0470, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @047F stack[-2] // @0480 msg.data[stack[-2]:stack[-2] + 0x20] // @0486 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0475 5B JUMPDEST 0476 50 POP 0477 60 PUSH1 0x01 0479 60 PUSH1 0x01 047B 60 PUSH1 0xa0 047D 1B SHL 047E 03 SUB 047F 81 DUP2 0480 35 CALLDATALOAD 0481 16 AND 0482 90 SWAP1 0483 60 PUSH1 0x20 0485 01 ADD 0486 35 CALLDATALOAD 0487 61 PUSH2 0x10f7 048A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0482 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0486 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x10f7 label_048B: // Incoming jump from 0x01F5, if 0x23b872dd == stack[-1] // Inputs[1] { @0492 msg.data.length } 048B 5B JUMPDEST 048C 61 PUSH2 0x02a8 048F 60 PUSH1 0x04 0491 80 DUP1 0492 36 CALLDATASIZE 0493 03 SUB 0494 60 PUSH1 0x60 0496 81 DUP2 0497 10 LT 0498 15 ISZERO 0499 61 PUSH2 0x04a1 049C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @048C stack[0] = 0x02a8 // @048F stack[1] = 0x04 // @0493 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x04a1, if !(msg.data.length - 0x04 < 0x60) label_049D: // Incoming jump from 0x049C, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @04A0 memory[0x00:0x00] } 049D 60 PUSH1 0x00 049F 80 DUP1 04A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A0 revert(memory[0x00:0x00]); } // Block terminates label_04A1: // Incoming jump from 0x049C, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @04AB stack[-2] // @04AC msg.data[stack[-2]:stack[-2] + 0x20] // @04B4 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @04BC msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 04A1 5B JUMPDEST 04A2 50 POP 04A3 60 PUSH1 0x01 04A5 60 PUSH1 0x01 04A7 60 PUSH1 0xa0 04A9 1B SHL 04AA 03 SUB 04AB 81 DUP2 04AC 35 CALLDATALOAD 04AD 81 DUP2 04AE 16 AND 04AF 91 SWAP2 04B0 60 PUSH1 0x20 04B2 81 DUP2 04B3 01 ADD 04B4 35 CALLDATALOAD 04B5 90 SWAP1 04B6 91 SWAP2 04B7 16 AND 04B8 90 SWAP1 04B9 60 PUSH1 0x40 04BB 01 ADD 04BC 35 CALLDATALOAD 04BD 61 PUSH2 0x1115 04C0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @04AF stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @04B8 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @04BC stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1115 label_04C1: // Incoming jump from 0x0200, if 0x2525d06a == stack[-1] // Inputs[1] { @04C8 msg.data.length } 04C1 5B JUMPDEST 04C2 61 PUSH2 0x02a8 04C5 60 PUSH1 0x04 04C7 80 DUP1 04C8 36 CALLDATASIZE 04C9 03 SUB 04CA 60 PUSH1 0x40 04CC 81 DUP2 04CD 10 LT 04CE 15 ISZERO 04CF 61 PUSH2 0x04d7 04D2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04C2 stack[0] = 0x02a8 // @04C5 stack[1] = 0x04 // @04C9 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x04d7, if !(msg.data.length - 0x04 < 0x40) label_04D3: // Incoming jump from 0x04D2, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04D6 memory[0x00:0x00] } 04D3 60 PUSH1 0x00 04D5 80 DUP1 04D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D6 revert(memory[0x00:0x00]); } // Block terminates label_04D7: // Incoming jump from 0x04D2, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @04E1 stack[-2] // @04E2 msg.data[stack[-2]:stack[-2] + 0x20] // @04E8 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 04D7 5B JUMPDEST 04D8 50 POP 04D9 60 PUSH1 0x01 04DB 60 PUSH1 0x01 04DD 60 PUSH1 0xa0 04DF 1B SHL 04E0 03 SUB 04E1 81 DUP2 04E2 35 CALLDATALOAD 04E3 16 AND 04E4 90 SWAP1 04E5 60 PUSH1 0x20 04E7 01 ADD 04E8 35 CALLDATALOAD 04E9 61 PUSH2 0x115a 04EC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @04E4 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @04E8 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x115a label_04ED: // Incoming jump from 0x018D, if 0x42842e0e == stack[-1] // Inputs[1] { @04F4 msg.data.length } 04ED 5B JUMPDEST 04EE 61 PUSH2 0x02a8 04F1 60 PUSH1 0x04 04F3 80 DUP1 04F4 36 CALLDATASIZE 04F5 03 SUB 04F6 60 PUSH1 0x60 04F8 81 DUP2 04F9 10 LT 04FA 15 ISZERO 04FB 61 PUSH2 0x0503 04FE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04EE stack[0] = 0x02a8 // @04F1 stack[1] = 0x04 // @04F5 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0503, if !(msg.data.length - 0x04 < 0x60) label_04FF: // Incoming jump from 0x04FE, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0502 memory[0x00:0x00] } 04FF 60 PUSH1 0x00 0501 80 DUP1 0502 FD *REVERT // Stack delta = +0 // Outputs[1] { @0502 revert(memory[0x00:0x00]); } // Block terminates label_0503: // Incoming jump from 0x04FE, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @050D stack[-2] // @050E msg.data[stack[-2]:stack[-2] + 0x20] // @0516 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @051E msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0503 5B JUMPDEST 0504 50 POP 0505 60 PUSH1 0x01 0507 60 PUSH1 0x01 0509 60 PUSH1 0xa0 050B 1B SHL 050C 03 SUB 050D 81 DUP2 050E 35 CALLDATALOAD 050F 81 DUP2 0510 16 AND 0511 91 SWAP2 0512 60 PUSH1 0x20 0514 81 DUP2 0515 01 ADD 0516 35 CALLDATALOAD 0517 90 SWAP1 0518 91 SWAP2 0519 16 AND 051A 90 SWAP1 051B 60 PUSH1 0x40 051D 01 ADD 051E 35 CALLDATALOAD 051F 61 PUSH2 0x117a 0522 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0511 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @051A stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @051E stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x117a label_0523: // Incoming jump from 0x0198, if 0x42966c68 == stack[-1] // Inputs[1] { @052A msg.data.length } 0523 5B JUMPDEST 0524 61 PUSH2 0x02a8 0527 60 PUSH1 0x04 0529 80 DUP1 052A 36 CALLDATASIZE 052B 03 SUB 052C 60 PUSH1 0x20 052E 81 DUP2 052F 10 LT 0530 15 ISZERO 0531 61 PUSH2 0x0539 0534 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0524 stack[0] = 0x02a8 // @0527 stack[1] = 0x04 // @052B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0539, if !(msg.data.length - 0x04 < 0x20) label_0535: // Incoming jump from 0x0534, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0538 memory[0x00:0x00] } 0535 60 PUSH1 0x00 0537 80 DUP1 0538 FD *REVERT // Stack delta = +0 // Outputs[1] { @0538 revert(memory[0x00:0x00]); } // Block terminates label_0539: // Incoming jump from 0x0534, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @053B stack[-2] // @053B msg.data[stack[-2]:stack[-2] + 0x20] // } 0539 5B JUMPDEST 053A 50 POP 053B 35 CALLDATALOAD 053C 61 PUSH2 0x1195 053F 56 *JUMP // Stack delta = -1 // Outputs[1] { @053B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1195 label_0540: // Incoming jump from 0x01A3, if 0x430c2081 == stack[-1] // Inputs[1] { @0547 msg.data.length } 0540 5B JUMPDEST 0541 61 PUSH2 0x025e 0544 60 PUSH1 0x04 0546 80 DUP1 0547 36 CALLDATASIZE 0548 03 SUB 0549 60 PUSH1 0x40 054B 81 DUP2 054C 10 LT 054D 15 ISZERO 054E 61 PUSH2 0x0556 0551 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0541 stack[0] = 0x025e // @0544 stack[1] = 0x04 // @0548 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0556, returns to 0x025E, if !(msg.data.length - 0x04 < 0x40) label_0552: // Incoming jump from 0x0551, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0555 memory[0x00:0x00] } 0552 60 PUSH1 0x00 0554 80 DUP1 0555 FD *REVERT // Stack delta = +0 // Outputs[1] { @0555 revert(memory[0x00:0x00]); } // Block terminates label_0556: // Incoming call from 0x0551, returns to 0x025E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0560 stack[-2] // @0561 msg.data[stack[-2]:stack[-2] + 0x20] // @0567 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0556 5B JUMPDEST 0557 50 POP 0558 60 PUSH1 0x01 055A 60 PUSH1 0x01 055C 60 PUSH1 0xa0 055E 1B SHL 055F 03 SUB 0560 81 DUP2 0561 35 CALLDATALOAD 0562 16 AND 0563 90 SWAP1 0564 60 PUSH1 0x20 0566 01 ADD 0567 35 CALLDATALOAD 0568 61 PUSH2 0x11e6 056B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0563 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0567 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x11e6 label_056C: // Incoming jump from 0x01AE, if 0x538361a7 == stack[-1] // Inputs[1] { @0573 msg.data.length } 056C 5B JUMPDEST 056D 61 PUSH2 0x02a8 0570 60 PUSH1 0x04 0572 80 DUP1 0573 36 CALLDATASIZE 0574 03 SUB 0575 60 PUSH1 0x40 0577 81 DUP2 0578 10 LT 0579 15 ISZERO 057A 61 PUSH2 0x0582 057D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @056D stack[0] = 0x02a8 // @0570 stack[1] = 0x04 // @0574 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0582, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) label_057E: // Incoming jump from 0x057D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0581 memory[0x00:0x00] } 057E 60 PUSH1 0x00 0580 80 DUP1 0581 FD *REVERT // Stack delta = +0 // Outputs[1] { @0581 revert(memory[0x00:0x00]); } // Block terminates label_0582: // Incoming call from 0x057D, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0584 stack[-2] // @0585 msg.data[stack[-2]:stack[-2] + 0x20] // @058A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0582 5B JUMPDEST 0583 50 POP 0584 80 DUP1 0585 35 CALLDATALOAD 0586 90 SWAP1 0587 60 PUSH1 0x20 0589 01 ADD 058A 35 CALLDATALOAD 058B 61 PUSH2 0x11f9 058E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0586 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @058A stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x11f9 label_058F: // Incoming jump from 0x01B9, if 0x57aac574 == stack[-1] // Inputs[1] { @0596 msg.data.length } 058F 5B JUMPDEST 0590 61 PUSH2 0x02a8 0593 60 PUSH1 0x04 0595 80 DUP1 0596 36 CALLDATASIZE 0597 03 SUB 0598 60 PUSH1 0x80 059A 81 DUP2 059B 10 LT 059C 15 ISZERO 059D 61 PUSH2 0x05a5 05A0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0590 stack[0] = 0x02a8 // @0593 stack[1] = 0x04 // @0597 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x05a5, if !(msg.data.length - 0x04 < 0x80) label_05A1: // Incoming jump from 0x05A0, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @05A4 memory[0x00:0x00] } 05A1 60 PUSH1 0x00 05A3 80 DUP1 05A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A4 revert(memory[0x00:0x00]); } // Block terminates label_05A5: // Incoming jump from 0x05A0, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @05AE stack[-2] // @05AF msg.data[stack[-2]:stack[-2] + 0x20] // @05B7 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @05BB stack[-1] // @05C0 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @05CE msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 05A5 5B JUMPDEST 05A6 60 PUSH1 0x01 05A8 60 PUSH1 0x01 05AA 60 PUSH1 0xa0 05AC 1B SHL 05AD 03 SUB 05AE 82 DUP3 05AF 35 CALLDATALOAD 05B0 81 DUP2 05B1 16 AND 05B2 92 SWAP3 05B3 60 PUSH1 0x20 05B5 81 DUP2 05B6 01 ADD 05B7 35 CALLDATALOAD 05B8 90 SWAP1 05B9 91 SWAP2 05BA 16 AND 05BB 91 SWAP2 05BC 60 PUSH1 0x40 05BE 82 DUP3 05BF 01 ADD 05C0 35 CALLDATALOAD 05C1 91 SWAP2 05C2 90 SWAP1 05C3 81 DUP2 05C4 01 ADD 05C5 90 SWAP1 05C6 60 PUSH1 0x80 05C8 81 DUP2 05C9 01 ADD 05CA 60 PUSH1 0x60 05CC 82 DUP3 05CD 01 ADD 05CE 35 CALLDATALOAD 05CF 60 PUSH1 0x01 05D1 60 PUSH1 0x20 05D3 1B SHL 05D4 81 DUP2 05D5 11 GT 05D6 15 ISZERO 05D7 61 PUSH2 0x05df 05DA 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @05B2 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @05BB stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @05C1 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @05C5 stack[1] = stack[-2] + stack[-1] // @05C5 stack[2] = stack[-2] // @05C9 stack[3] = stack[-2] + 0x80 // @05CE stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x05df, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_05DB: // Incoming jump from 0x05DA, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @05DE memory[0x00:0x00] } 05DB 60 PUSH1 0x00 05DD 80 DUP1 05DE FD *REVERT // Stack delta = +0 // Outputs[1] { @05DE revert(memory[0x00:0x00]); } // Block terminates label_05DF: // Incoming jump from 0x05DA, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @05E0 stack[-3] // @05E1 stack[-1] // @05E2 stack[-4] // } 05DF 5B JUMPDEST 05E0 82 DUP3 05E1 01 ADD 05E2 83 DUP4 05E3 60 PUSH1 0x20 05E5 82 DUP3 05E6 01 ADD 05E7 11 GT 05E8 15 ISZERO 05E9 61 PUSH2 0x05f1 05EC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05E1 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x05f1, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_05ED: // Incoming jump from 0x05EC, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @05F0 memory[0x00:0x00] } 05ED 60 PUSH1 0x00 05EF 80 DUP1 05F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F0 revert(memory[0x00:0x00]); } // Block terminates label_05F1: // Incoming jump from 0x05EC, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @05F2 stack[-1] // @05F3 msg.data[stack[-1]:stack[-1] + 0x20] // @05F8 stack[-2] // @05F9 stack[-4] // } 05F1 5B JUMPDEST 05F2 80 DUP1 05F3 35 CALLDATALOAD 05F4 90 SWAP1 05F5 60 PUSH1 0x20 05F7 01 ADD 05F8 91 SWAP2 05F9 84 DUP5 05FA 60 PUSH1 0x01 05FC 83 DUP4 05FD 02 MUL 05FE 84 DUP5 05FF 01 ADD 0600 11 GT 0601 60 PUSH1 0x01 0603 60 PUSH1 0x20 0605 1B SHL 0606 83 DUP4 0607 11 GT 0608 17 OR 0609 15 ISZERO 060A 61 PUSH2 0x0612 060D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05F4 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05F8 stack[0] = stack[-2] // @05F8 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0612, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_060E: // Incoming jump from 0x060D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0611 memory[0x00:0x00] } 060E 60 PUSH1 0x00 0610 80 DUP1 0611 FD *REVERT // Stack delta = +0 // Outputs[1] { @0611 revert(memory[0x00:0x00]); } // Block terminates label_0612: // Incoming jump from 0x060D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0614 stack[-2] // @0614 stack[-3] // @0615 stack[-5] // @0617 stack[-4] // } 0612 5B JUMPDEST 0613 50 POP 0614 90 SWAP1 0615 92 SWAP3 0616 50 POP 0617 90 SWAP1 0618 50 POP 0619 61 PUSH2 0x124f 061C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0615 stack[-5] = stack[-3] // @0617 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x124f label_061D: // Incoming jump from 0x0151, if 0x5cbe1112 == stack[-1] // Inputs[1] { @0624 msg.data.length } 061D 5B JUMPDEST 061E 61 PUSH2 0x02a8 0621 60 PUSH1 0x04 0623 80 DUP1 0624 36 CALLDATASIZE 0625 03 SUB 0626 60 PUSH1 0x40 0628 81 DUP2 0629 10 LT 062A 15 ISZERO 062B 61 PUSH2 0x0633 062E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @061E stack[0] = 0x02a8 // @0621 stack[1] = 0x04 // @0625 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0633, if !(msg.data.length - 0x04 < 0x40) label_062F: // Incoming jump from 0x062E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0632 memory[0x00:0x00] } 062F 60 PUSH1 0x00 0631 80 DUP1 0632 FD *REVERT // Stack delta = +0 // Outputs[1] { @0632 revert(memory[0x00:0x00]); } // Block terminates label_0633: // Incoming jump from 0x062E, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0634 stack[-2] // @0635 msg.data[stack[-2]:stack[-2] + 0x20] // @0637 stack[-1] // @0643 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 0633 5B JUMPDEST 0634 81 DUP2 0635 35 CALLDATALOAD 0636 91 SWAP2 0637 90 SWAP1 0638 81 DUP2 0639 01 ADD 063A 90 SWAP1 063B 60 PUSH1 0x40 063D 81 DUP2 063E 01 ADD 063F 60 PUSH1 0x20 0641 82 DUP3 0642 01 ADD 0643 35 CALLDATALOAD 0644 60 PUSH1 0x01 0646 60 PUSH1 0x20 0648 1B SHL 0649 81 DUP2 064A 11 GT 064B 15 ISZERO 064C 61 PUSH2 0x0654 064F 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0636 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @063A stack[0] = stack[-2] // @063A stack[-1] = stack[-2] + stack[-1] // @063E stack[1] = stack[-2] + 0x40 // @0643 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x0654, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_0650: // Incoming jump from 0x064F, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0653 memory[0x00:0x00] } 0650 60 PUSH1 0x00 0652 80 DUP1 0653 FD *REVERT // Stack delta = +0 // Outputs[1] { @0653 revert(memory[0x00:0x00]); } // Block terminates label_0654: // Incoming jump from 0x064F, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0655 stack[-3] // @0656 stack[-1] // @0657 stack[-4] // } 0654 5B JUMPDEST 0655 82 DUP3 0656 01 ADD 0657 83 DUP4 0658 60 PUSH1 0x20 065A 82 DUP3 065B 01 ADD 065C 11 GT 065D 15 ISZERO 065E 61 PUSH2 0x0666 0661 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0656 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0666, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0662: // Incoming jump from 0x0661, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0665 memory[0x00:0x00] } 0662 60 PUSH1 0x00 0664 80 DUP1 0665 FD *REVERT // Stack delta = +0 // Outputs[1] { @0665 revert(memory[0x00:0x00]); } // Block terminates label_0666: // Incoming jump from 0x0661, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0667 stack[-1] // @0668 msg.data[stack[-1]:stack[-1] + 0x20] // @066D stack[-2] // @066E stack[-4] // } 0666 5B JUMPDEST 0667 80 DUP1 0668 35 CALLDATALOAD 0669 90 SWAP1 066A 60 PUSH1 0x20 066C 01 ADD 066D 91 SWAP2 066E 84 DUP5 066F 60 PUSH1 0x01 0671 83 DUP4 0672 02 MUL 0673 84 DUP5 0674 01 ADD 0675 11 GT 0676 60 PUSH1 0x01 0678 60 PUSH1 0x20 067A 1B SHL 067B 83 DUP4 067C 11 GT 067D 17 OR 067E 15 ISZERO 067F 61 PUSH2 0x0687 0682 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0669 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @066D stack[0] = stack[-2] // @066D stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0687, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0683: // Incoming jump from 0x0682, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0686 memory[0x00:0x00] } 0683 60 PUSH1 0x00 0685 80 DUP1 0686 FD *REVERT // Stack delta = +0 // Outputs[1] { @0686 revert(memory[0x00:0x00]); } // Block terminates label_0687: // Incoming jump from 0x0682, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0689 stack[-2] // @0689 stack[-3] // @068A stack[-5] // @068C stack[-4] // } 0687 5B JUMPDEST 0688 50 POP 0689 90 SWAP1 068A 92 SWAP3 068B 50 POP 068C 90 SWAP1 068D 50 POP 068E 61 PUSH2 0x12be 0691 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @068A stack[-5] = stack[-3] // @068C stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x12be label_0692: // Incoming jump from 0x015C, if 0x6352211e == stack[-1] // Inputs[1] { @0699 msg.data.length } 0692 5B JUMPDEST 0693 61 PUSH2 0x0417 0696 60 PUSH1 0x04 0698 80 DUP1 0699 36 CALLDATASIZE 069A 03 SUB 069B 60 PUSH1 0x20 069D 81 DUP2 069E 10 LT 069F 15 ISZERO 06A0 61 PUSH2 0x06a8 06A3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0693 stack[0] = 0x0417 // @0696 stack[1] = 0x04 // @069A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06a8, returns to 0x0417, if !(msg.data.length - 0x04 < 0x20) label_06A4: // Incoming jump from 0x06A3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06A7 memory[0x00:0x00] } 06A4 60 PUSH1 0x00 06A6 80 DUP1 06A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A7 revert(memory[0x00:0x00]); } // Block terminates label_06A8: // Incoming call from 0x06A3, returns to 0x0417, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @06AA msg.data[stack[-2]:stack[-2] + 0x20] // @06AA stack[-2] // } 06A8 5B JUMPDEST 06A9 50 POP 06AA 35 CALLDATALOAD 06AB 61 PUSH2 0x1320 06AE 56 *JUMP // Stack delta = -1 // Outputs[1] { @06AA stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1320 label_06AF: // Incoming jump from 0x0167, if 0x66ac3b68 == stack[-1] 06AF 5B JUMPDEST 06B0 61 PUSH2 0x02a8 06B3 61 PUSH2 0x137a 06B6 56 *JUMP // Stack delta = +1 // Outputs[1] { @06B0 stack[0] = 0x02a8 } // Block ends with call to 0x137a, returns to 0x02A8 label_06B7: // Incoming jump from 0x0172, if 0x68b62d32 == stack[-1] // Inputs[1] { @06BE msg.data.length } 06B7 5B JUMPDEST 06B8 61 PUSH2 0x072c 06BB 60 PUSH1 0x04 06BD 80 DUP1 06BE 36 CALLDATASIZE 06BF 03 SUB 06C0 60 PUSH1 0x40 06C2 81 DUP2 06C3 10 LT 06C4 15 ISZERO 06C5 61 PUSH2 0x06cd 06C8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06B8 stack[0] = 0x072c // @06BB stack[1] = 0x04 // @06BF stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06cd, returns to 0x072C, if !(msg.data.length - 0x04 < 0x40) label_06C9: // Incoming jump from 0x06C8, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06CC memory[0x00:0x00] } 06C9 60 PUSH1 0x00 06CB 80 DUP1 06CC FD *REVERT // Stack delta = +0 // Outputs[1] { @06CC revert(memory[0x00:0x00]); } // Block terminates label_06CD: // Incoming call from 0x06C8, returns to 0x072C, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @06CE stack[-2] // @06CF msg.data[stack[-2]:stack[-2] + 0x20] // @06D1 stack[-1] // @06DD msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 06CD 5B JUMPDEST 06CE 81 DUP2 06CF 35 CALLDATALOAD 06D0 91 SWAP2 06D1 90 SWAP1 06D2 81 DUP2 06D3 01 ADD 06D4 90 SWAP1 06D5 60 PUSH1 0x40 06D7 81 DUP2 06D8 01 ADD 06D9 60 PUSH1 0x20 06DB 82 DUP3 06DC 01 ADD 06DD 35 CALLDATALOAD 06DE 60 PUSH1 0x01 06E0 60 PUSH1 0x20 06E2 1B SHL 06E3 81 DUP2 06E4 11 GT 06E5 15 ISZERO 06E6 61 PUSH2 0x06ee 06E9 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @06D0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @06D4 stack[0] = stack[-2] // @06D4 stack[-1] = stack[-2] + stack[-1] // @06D8 stack[1] = stack[-2] + 0x40 // @06DD stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x06ee, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_06EA: // Incoming jump from 0x06E9, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @06ED memory[0x00:0x00] } 06EA 60 PUSH1 0x00 06EC 80 DUP1 06ED FD *REVERT // Stack delta = +0 // Outputs[1] { @06ED revert(memory[0x00:0x00]); } // Block terminates label_06EE: // Incoming jump from 0x06E9, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @06EF stack[-3] // @06F0 stack[-1] // @06F1 stack[-4] // } 06EE 5B JUMPDEST 06EF 82 DUP3 06F0 01 ADD 06F1 83 DUP4 06F2 60 PUSH1 0x20 06F4 82 DUP3 06F5 01 ADD 06F6 11 GT 06F7 15 ISZERO 06F8 61 PUSH2 0x0700 06FB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06F0 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0700, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_06FC: // Incoming jump from 0x06FB, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @06FF memory[0x00:0x00] } 06FC 60 PUSH1 0x00 06FE 80 DUP1 06FF FD *REVERT // Stack delta = +0 // Outputs[1] { @06FF revert(memory[0x00:0x00]); } // Block terminates label_0700: // Incoming jump from 0x06FB, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0701 stack[-1] // @0702 msg.data[stack[-1]:stack[-1] + 0x20] // @0707 stack[-2] // @0708 stack[-4] // } 0700 5B JUMPDEST 0701 80 DUP1 0702 35 CALLDATALOAD 0703 90 SWAP1 0704 60 PUSH1 0x20 0706 01 ADD 0707 91 SWAP2 0708 84 DUP5 0709 60 PUSH1 0x01 070B 83 DUP4 070C 02 MUL 070D 84 DUP5 070E 01 ADD 070F 11 GT 0710 60 PUSH1 0x01 0712 60 PUSH1 0x20 0714 1B SHL 0715 83 DUP4 0716 11 GT 0717 17 OR 0718 15 ISZERO 0719 61 PUSH2 0x0721 071C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0703 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0707 stack[0] = stack[-2] // @0707 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0721, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_071D: // Incoming jump from 0x071C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0720 memory[0x00:0x00] } 071D 60 PUSH1 0x00 071F 80 DUP1 0720 FD *REVERT // Stack delta = +0 // Outputs[1] { @0720 revert(memory[0x00:0x00]); } // Block terminates label_0721: // Incoming jump from 0x071C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0723 stack[-3] // @0723 stack[-2] // @0724 stack[-5] // @0726 stack[-4] // } 0721 5B JUMPDEST 0722 50 POP 0723 90 SWAP1 0724 92 SWAP3 0725 50 POP 0726 90 SWAP1 0727 50 POP 0728 61 PUSH2 0x1385 072B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0724 stack[-5] = stack[-3] // @0726 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x1385 label_072C: // Incoming return from call to 0x1A33 at 0x0E91 // Incoming return from call to 0x06CD at 0x06C8 // Inputs[4] // { // @0730 memory[0x40:0x60] // @0731 stack[-1] // @0734 memory[0x40:0x60] // @073D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 072C 5B JUMPDEST 072D 60 PUSH1 0x40 072F 80 DUP1 0730 51 MLOAD 0731 91 SWAP2 0732 82 DUP3 0733 52 MSTORE 0734 51 MLOAD 0735 90 SWAP1 0736 81 DUP2 0737 90 SWAP1 0738 03 SUB 0739 60 PUSH1 0x20 073B 01 ADD 073C 90 SWAP1 073D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0733 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @073D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_073E: // Incoming jump from 0x017D, if 0x70a08231 == stack[-1] // Inputs[1] { @0745 msg.data.length } 073E 5B JUMPDEST 073F 61 PUSH2 0x072c 0742 60 PUSH1 0x04 0744 80 DUP1 0745 36 CALLDATASIZE 0746 03 SUB 0747 60 PUSH1 0x20 0749 81 DUP2 074A 10 LT 074B 15 ISZERO 074C 61 PUSH2 0x0754 074F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @073F stack[0] = 0x072c // @0742 stack[1] = 0x04 // @0746 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0754, if !(msg.data.length - 0x04 < 0x20) label_0750: // Incoming jump from 0x074F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0753 memory[0x00:0x00] } 0750 60 PUSH1 0x00 0752 80 DUP1 0753 FD *REVERT // Stack delta = +0 // Outputs[1] { @0753 revert(memory[0x00:0x00]); } // Block terminates label_0754: // Incoming jump from 0x074F, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0756 msg.data[stack[-2]:stack[-2] + 0x20] // @0756 stack[-2] // } 0754 5B JUMPDEST 0755 50 POP 0756 35 CALLDATALOAD 0757 60 PUSH1 0x01 0759 60 PUSH1 0x01 075B 60 PUSH1 0xa0 075D 1B SHL 075E 03 SUB 075F 16 AND 0760 61 PUSH2 0x13cf 0763 56 *JUMP // Stack delta = -1 // Outputs[1] { @075F stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x13cf label_0764: // Incoming jump from 0x010A, if 0x7c69eae2 == stack[-1] // Inputs[1] { @076B msg.data.length } 0764 5B JUMPDEST 0765 61 PUSH2 0x02a8 0768 60 PUSH1 0x04 076A 80 DUP1 076B 36 CALLDATASIZE 076C 03 SUB 076D 60 PUSH1 0x60 076F 81 DUP2 0770 10 LT 0771 15 ISZERO 0772 61 PUSH2 0x077a 0775 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0765 stack[0] = 0x02a8 // @0768 stack[1] = 0x04 // @076C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x077a, if !(msg.data.length - 0x04 < 0x60) label_0776: // Incoming jump from 0x0775, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0779 memory[0x00:0x00] } 0776 60 PUSH1 0x00 0778 80 DUP1 0779 FD *REVERT // Stack delta = +0 // Outputs[1] { @0779 revert(memory[0x00:0x00]); } // Block terminates label_077A: // Incoming jump from 0x0775, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0783 stack[-2] // @0784 msg.data[stack[-2]:stack[-2] + 0x20] // @078B msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @078C stack[-1] // @0798 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 077A 5B JUMPDEST 077B 60 PUSH1 0x01 077D 60 PUSH1 0x01 077F 60 PUSH1 0xa0 0781 1B SHL 0782 03 SUB 0783 82 DUP3 0784 35 CALLDATALOAD 0785 16 AND 0786 91 SWAP2 0787 60 PUSH1 0x20 0789 81 DUP2 078A 01 ADD 078B 35 CALLDATALOAD 078C 91 SWAP2 078D 81 DUP2 078E 01 ADD 078F 90 SWAP1 0790 60 PUSH1 0x60 0792 81 DUP2 0793 01 ADD 0794 60 PUSH1 0x40 0796 82 DUP3 0797 01 ADD 0798 35 CALLDATALOAD 0799 60 PUSH1 0x01 079B 60 PUSH1 0x20 079D 1B SHL 079E 81 DUP2 079F 11 GT 07A0 15 ISZERO 07A1 61 PUSH2 0x07a9 07A4 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0786 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @078C stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @078F stack[0] = stack[-2] + stack[-1] // @078F stack[1] = stack[-2] // @0793 stack[2] = stack[-2] + 0x60 // @0798 stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x07a9, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_07A5: // Incoming jump from 0x07A4, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @07A8 memory[0x00:0x00] } 07A5 60 PUSH1 0x00 07A7 80 DUP1 07A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @07A8 revert(memory[0x00:0x00]); } // Block terminates label_07A9: // Incoming jump from 0x07A4, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @07AA stack[-3] // @07AB stack[-1] // @07AC stack[-4] // } 07A9 5B JUMPDEST 07AA 82 DUP3 07AB 01 ADD 07AC 83 DUP4 07AD 60 PUSH1 0x20 07AF 82 DUP3 07B0 01 ADD 07B1 11 GT 07B2 15 ISZERO 07B3 61 PUSH2 0x07bb 07B6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07AB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x07bb, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_07B7: // Incoming jump from 0x07B6, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @07BA memory[0x00:0x00] } 07B7 60 PUSH1 0x00 07B9 80 DUP1 07BA FD *REVERT // Stack delta = +0 // Outputs[1] { @07BA revert(memory[0x00:0x00]); } // Block terminates label_07BB: // Incoming jump from 0x07B6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @07BC stack[-1] // @07BD msg.data[stack[-1]:stack[-1] + 0x20] // @07C2 stack[-2] // @07C3 stack[-4] // } 07BB 5B JUMPDEST 07BC 80 DUP1 07BD 35 CALLDATALOAD 07BE 90 SWAP1 07BF 60 PUSH1 0x20 07C1 01 ADD 07C2 91 SWAP2 07C3 84 DUP5 07C4 60 PUSH1 0x01 07C6 83 DUP4 07C7 02 MUL 07C8 84 DUP5 07C9 01 ADD 07CA 11 GT 07CB 60 PUSH1 0x01 07CD 60 PUSH1 0x20 07CF 1B SHL 07D0 83 DUP4 07D1 11 GT 07D2 17 OR 07D3 15 ISZERO 07D4 61 PUSH2 0x07dc 07D7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07BE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @07C2 stack[0] = stack[-2] // @07C2 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x07dc, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_07D8: // Incoming jump from 0x07D7, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @07DB memory[0x00:0x00] } 07D8 60 PUSH1 0x00 07DA 80 DUP1 07DB FD *REVERT // Stack delta = +0 // Outputs[1] { @07DB revert(memory[0x00:0x00]); } // Block terminates label_07DC: // Incoming jump from 0x07D7, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @07DE stack[-2] // @07DE stack[-3] // @07DF stack[-5] // @07E1 stack[-4] // } 07DC 5B JUMPDEST 07DD 50 POP 07DE 90 SWAP1 07DF 92 SWAP3 07E0 50 POP 07E1 90 SWAP1 07E2 50 POP 07E3 61 PUSH2 0x1437 07E6 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @07DF stack[-5] = stack[-3] // @07E1 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x1437 label_07E7: // Incoming jump from 0x0115, if 0x95d89b41 == stack[-1] 07E7 5B JUMPDEST 07E8 61 PUSH2 0x0385 07EB 61 PUSH2 0x149a 07EE 56 *JUMP // Stack delta = +1 // Outputs[1] { @07E8 stack[0] = 0x0385 } // Block ends with call to 0x149a, returns to 0x0385 label_07EF: // Incoming jump from 0x0120, if 0x9d743989 == stack[-1] // Inputs[1] { @07F6 msg.data.length } 07EF 5B JUMPDEST 07F0 61 PUSH2 0x02a8 07F3 60 PUSH1 0x04 07F5 80 DUP1 07F6 36 CALLDATASIZE 07F7 03 SUB 07F8 60 PUSH1 0x80 07FA 81 DUP2 07FB 10 LT 07FC 15 ISZERO 07FD 61 PUSH2 0x0805 0800 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07F0 stack[0] = 0x02a8 // @07F3 stack[1] = 0x04 // @07F7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0805, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x80) label_0801: // Incoming jump from 0x0800, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0804 memory[0x00:0x00] } 0801 60 PUSH1 0x00 0803 80 DUP1 0804 FD *REVERT // Stack delta = +0 // Outputs[1] { @0804 revert(memory[0x00:0x00]); } // Block terminates label_0805: // Incoming call from 0x0800, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @080E stack[-2] // @080F msg.data[stack[-2]:stack[-2] + 0x20] // @0817 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @081B stack[-1] // @0820 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @082E msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0805 5B JUMPDEST 0806 60 PUSH1 0x01 0808 60 PUSH1 0x01 080A 60 PUSH1 0xa0 080C 1B SHL 080D 03 SUB 080E 82 DUP3 080F 35 CALLDATALOAD 0810 81 DUP2 0811 16 AND 0812 92 SWAP3 0813 60 PUSH1 0x20 0815 81 DUP2 0816 01 ADD 0817 35 CALLDATALOAD 0818 90 SWAP1 0819 91 SWAP2 081A 16 AND 081B 91 SWAP2 081C 60 PUSH1 0x40 081E 82 DUP3 081F 01 ADD 0820 35 CALLDATALOAD 0821 91 SWAP2 0822 90 SWAP1 0823 81 DUP2 0824 01 ADD 0825 90 SWAP1 0826 60 PUSH1 0x80 0828 81 DUP2 0829 01 ADD 082A 60 PUSH1 0x60 082C 82 DUP3 082D 01 ADD 082E 35 CALLDATALOAD 082F 60 PUSH1 0x01 0831 60 PUSH1 0x20 0833 1B SHL 0834 81 DUP2 0835 11 GT 0836 15 ISZERO 0837 61 PUSH2 0x083f 083A 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0812 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @081B stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0821 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0825 stack[1] = stack[-2] + stack[-1] // @0825 stack[2] = stack[-2] // @0829 stack[3] = stack[-2] + 0x80 // @082E stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x083f, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_083B: // Incoming jump from 0x083A, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @083E memory[0x00:0x00] } 083B 60 PUSH1 0x00 083D 80 DUP1 083E FD *REVERT // Stack delta = +0 // Outputs[1] { @083E revert(memory[0x00:0x00]); } // Block terminates label_083F: // Incoming jump from 0x083A, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0840 stack[-3] // @0841 stack[-1] // @0842 stack[-4] // } 083F 5B JUMPDEST 0840 82 DUP3 0841 01 ADD 0842 83 DUP4 0843 60 PUSH1 0x20 0845 82 DUP3 0846 01 ADD 0847 11 GT 0848 15 ISZERO 0849 61 PUSH2 0x0851 084C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0841 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0851, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_084D: // Incoming jump from 0x084C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0850 memory[0x00:0x00] } 084D 60 PUSH1 0x00 084F 80 DUP1 0850 FD *REVERT // Stack delta = +0 // Outputs[1] { @0850 revert(memory[0x00:0x00]); } // Block terminates label_0851: // Incoming jump from 0x084C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0852 stack[-1] // @0853 msg.data[stack[-1]:stack[-1] + 0x20] // @0858 stack[-2] // @0859 stack[-4] // } 0851 5B JUMPDEST 0852 80 DUP1 0853 35 CALLDATALOAD 0854 90 SWAP1 0855 60 PUSH1 0x20 0857 01 ADD 0858 91 SWAP2 0859 84 DUP5 085A 60 PUSH1 0x01 085C 83 DUP4 085D 02 MUL 085E 84 DUP5 085F 01 ADD 0860 11 GT 0861 60 PUSH1 0x01 0863 60 PUSH1 0x20 0865 1B SHL 0866 83 DUP4 0867 11 GT 0868 17 OR 0869 15 ISZERO 086A 61 PUSH2 0x0872 086D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0854 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0858 stack[0] = stack[-2] // @0858 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0872, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_086E: // Incoming jump from 0x086D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0871 memory[0x00:0x00] } 086E 60 PUSH1 0x00 0870 80 DUP1 0871 FD *REVERT // Stack delta = +0 // Outputs[1] { @0871 revert(memory[0x00:0x00]); } // Block terminates label_0872: // Incoming jump from 0x086D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0874 stack[-2] // @0874 stack[-3] // @0875 stack[-5] // @0877 stack[-4] // } 0872 5B JUMPDEST 0873 50 POP 0874 90 SWAP1 0875 92 SWAP3 0876 50 POP 0877 90 SWAP1 0878 50 POP 0879 61 PUSH2 0x14b6 087C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0875 stack[-5] = stack[-3] // @0877 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x14b6 label_087D: // Incoming jump from 0x012B, if 0x9e5be9a5 == stack[-1] // Inputs[1] { @0884 msg.data.length } 087D 5B JUMPDEST 087E 61 PUSH2 0x02a8 0881 60 PUSH1 0x04 0883 80 DUP1 0884 36 CALLDATASIZE 0885 03 SUB 0886 60 PUSH1 0x80 0888 81 DUP2 0889 10 LT 088A 15 ISZERO 088B 61 PUSH2 0x0893 088E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @087E stack[0] = 0x02a8 // @0881 stack[1] = 0x04 // @0885 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0893, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x80) label_088F: // Incoming jump from 0x088E, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0892 memory[0x00:0x00] } 088F 60 PUSH1 0x00 0891 80 DUP1 0892 FD *REVERT // Stack delta = +0 // Outputs[1] { @0892 revert(memory[0x00:0x00]); } // Block terminates label_0893: // Incoming call from 0x088E, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @089C stack[-2] // @089D msg.data[stack[-2]:stack[-2] + 0x20] // @08A5 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @08A9 stack[-1] // @08AE msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @08BC msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0893 5B JUMPDEST 0894 60 PUSH1 0x01 0896 60 PUSH1 0x01 0898 60 PUSH1 0xa0 089A 1B SHL 089B 03 SUB 089C 82 DUP3 089D 35 CALLDATALOAD 089E 81 DUP2 089F 16 AND 08A0 92 SWAP3 08A1 60 PUSH1 0x20 08A3 81 DUP2 08A4 01 ADD 08A5 35 CALLDATALOAD 08A6 90 SWAP1 08A7 91 SWAP2 08A8 16 AND 08A9 91 SWAP2 08AA 60 PUSH1 0x40 08AC 82 DUP3 08AD 01 ADD 08AE 35 CALLDATALOAD 08AF 91 SWAP2 08B0 90 SWAP1 08B1 81 DUP2 08B2 01 ADD 08B3 90 SWAP1 08B4 60 PUSH1 0x80 08B6 81 DUP2 08B7 01 ADD 08B8 60 PUSH1 0x60 08BA 82 DUP3 08BB 01 ADD 08BC 35 CALLDATALOAD 08BD 60 PUSH1 0x01 08BF 60 PUSH1 0x20 08C1 1B SHL 08C2 81 DUP2 08C3 11 GT 08C4 15 ISZERO 08C5 61 PUSH2 0x08cd 08C8 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @08A0 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @08A9 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @08AF stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @08B3 stack[1] = stack[-2] + stack[-1] // @08B3 stack[2] = stack[-2] // @08B7 stack[3] = stack[-2] + 0x80 // @08BC stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x08cd, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_08C9: // Incoming jump from 0x08C8, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @08CC memory[0x00:0x00] } 08C9 60 PUSH1 0x00 08CB 80 DUP1 08CC FD *REVERT // Stack delta = +0 // Outputs[1] { @08CC revert(memory[0x00:0x00]); } // Block terminates label_08CD: // Incoming jump from 0x08C8, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @08CE stack[-3] // @08CF stack[-1] // @08D0 stack[-4] // } 08CD 5B JUMPDEST 08CE 82 DUP3 08CF 01 ADD 08D0 83 DUP4 08D1 60 PUSH1 0x20 08D3 82 DUP3 08D4 01 ADD 08D5 11 GT 08D6 15 ISZERO 08D7 61 PUSH2 0x08df 08DA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @08CF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x08df, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_08DB: // Incoming jump from 0x08DA, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @08DE memory[0x00:0x00] } 08DB 60 PUSH1 0x00 08DD 80 DUP1 08DE FD *REVERT // Stack delta = +0 // Outputs[1] { @08DE revert(memory[0x00:0x00]); } // Block terminates label_08DF: // Incoming jump from 0x08DA, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @08E0 stack[-1] // @08E1 msg.data[stack[-1]:stack[-1] + 0x20] // @08E6 stack[-2] // @08E7 stack[-4] // } 08DF 5B JUMPDEST 08E0 80 DUP1 08E1 35 CALLDATALOAD 08E2 90 SWAP1 08E3 60 PUSH1 0x20 08E5 01 ADD 08E6 91 SWAP2 08E7 84 DUP5 08E8 60 PUSH1 0x01 08EA 83 DUP4 08EB 02 MUL 08EC 84 DUP5 08ED 01 ADD 08EE 11 GT 08EF 60 PUSH1 0x01 08F1 60 PUSH1 0x20 08F3 1B SHL 08F4 83 DUP4 08F5 11 GT 08F6 17 OR 08F7 15 ISZERO 08F8 61 PUSH2 0x0900 08FB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @08E2 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @08E6 stack[0] = stack[-2] // @08E6 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0900, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_08FC: // Incoming jump from 0x08FB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @08FF memory[0x00:0x00] } 08FC 60 PUSH1 0x00 08FE 80 DUP1 08FF FD *REVERT // Stack delta = +0 // Outputs[1] { @08FF revert(memory[0x00:0x00]); } // Block terminates label_0900: // Incoming jump from 0x08FB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0902 stack[-3] // @0902 stack[-2] // @0903 stack[-5] // @0905 stack[-4] // } 0900 5B JUMPDEST 0901 50 POP 0902 90 SWAP1 0903 92 SWAP3 0904 50 POP 0905 90 SWAP1 0906 50 POP 0907 61 PUSH2 0x1506 090A 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0903 stack[-5] = stack[-3] // @0905 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x1506 label_090B: // Incoming jump from 0x00CE, if 0xa22cb465 == stack[-1] // Inputs[1] { @0912 msg.data.length } 090B 5B JUMPDEST 090C 61 PUSH2 0x02a8 090F 60 PUSH1 0x04 0911 80 DUP1 0912 36 CALLDATASIZE 0913 03 SUB 0914 60 PUSH1 0x40 0916 81 DUP2 0917 10 LT 0918 15 ISZERO 0919 61 PUSH2 0x0921 091C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @090C stack[0] = 0x02a8 // @090F stack[1] = 0x04 // @0913 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0921, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) label_091D: // Incoming jump from 0x091C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0920 memory[0x00:0x00] } 091D 60 PUSH1 0x00 091F 80 DUP1 0920 FD *REVERT // Stack delta = +0 // Outputs[1] { @0920 revert(memory[0x00:0x00]); } // Block terminates label_0921: // Incoming call from 0x091C, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @092B stack[-2] // @092C msg.data[stack[-2]:stack[-2] + 0x20] // @0932 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0921 5B JUMPDEST 0922 50 POP 0923 60 PUSH1 0x01 0925 60 PUSH1 0x01 0927 60 PUSH1 0xa0 0929 1B SHL 092A 03 SUB 092B 81 DUP2 092C 35 CALLDATALOAD 092D 16 AND 092E 90 SWAP1 092F 60 PUSH1 0x20 0931 01 ADD 0932 35 CALLDATALOAD 0933 15 ISZERO 0934 15 ISZERO 0935 61 PUSH2 0x1564 0938 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @092E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0934 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1564 label_0939: // Incoming jump from 0x00D9, if 0xa7fc7a07 == stack[-1] // Inputs[1] { @0940 msg.data.length } 0939 5B JUMPDEST 093A 61 PUSH2 0x02a8 093D 60 PUSH1 0x04 093F 80 DUP1 0940 36 CALLDATASIZE 0941 03 SUB 0942 60 PUSH1 0x20 0944 81 DUP2 0945 10 LT 0946 15 ISZERO 0947 61 PUSH2 0x094f 094A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @093A stack[0] = 0x02a8 // @093D stack[1] = 0x04 // @0941 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x094f, if !(msg.data.length - 0x04 < 0x20) label_094B: // Incoming jump from 0x094A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @094E memory[0x00:0x00] } 094B 60 PUSH1 0x00 094D 80 DUP1 094E FD *REVERT // Stack delta = +0 // Outputs[1] { @094E revert(memory[0x00:0x00]); } // Block terminates label_094F: // Incoming jump from 0x094A, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0951 stack[-2] // @0951 msg.data[stack[-2]:stack[-2] + 0x20] // } 094F 5B JUMPDEST 0950 50 POP 0951 35 CALLDATALOAD 0952 60 PUSH1 0x01 0954 60 PUSH1 0x01 0956 60 PUSH1 0xa0 0958 1B SHL 0959 03 SUB 095A 16 AND 095B 61 PUSH2 0x1630 095E 56 *JUMP // Stack delta = -1 // Outputs[1] { @095A stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1630 label_095F: // Incoming jump from 0x00E4, if 0xab3b87fe == stack[-1] // Inputs[1] { @0966 msg.data.length } 095F 5B JUMPDEST 0960 61 PUSH2 0x02a8 0963 60 PUSH1 0x04 0965 80 DUP1 0966 36 CALLDATASIZE 0967 03 SUB 0968 60 PUSH1 0x40 096A 81 DUP2 096B 10 LT 096C 15 ISZERO 096D 61 PUSH2 0x0975 0970 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0960 stack[0] = 0x02a8 // @0963 stack[1] = 0x04 // @0967 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0975, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) label_0971: // Incoming jump from 0x0970, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0974 memory[0x00:0x00] } 0971 60 PUSH1 0x00 0973 80 DUP1 0974 FD *REVERT // Stack delta = +0 // Outputs[1] { @0974 revert(memory[0x00:0x00]); } // Block terminates label_0975: // Incoming call from 0x0970, returns to 0x02A8, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @097F stack[-2] // @0980 msg.data[stack[-2]:stack[-2] + 0x20] // @0986 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0975 5B JUMPDEST 0976 50 POP 0977 60 PUSH1 0x01 0979 60 PUSH1 0x01 097B 60 PUSH1 0xa0 097D 1B SHL 097E 03 SUB 097F 81 DUP2 0980 35 CALLDATALOAD 0981 16 AND 0982 90 SWAP1 0983 60 PUSH1 0x20 0985 01 ADD 0986 35 CALLDATALOAD 0987 61 PUSH2 0x164b 098A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0982 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0986 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x164b label_098B: // Incoming jump from 0x00EF, if 0xb3f9e4cb == stack[-1] // Inputs[1] { @0992 msg.data.length } 098B 5B JUMPDEST 098C 61 PUSH2 0x0417 098F 60 PUSH1 0x04 0991 80 DUP1 0992 36 CALLDATASIZE 0993 03 SUB 0994 60 PUSH1 0x20 0996 81 DUP2 0997 10 LT 0998 15 ISZERO 0999 61 PUSH2 0x09a1 099C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @098C stack[0] = 0x0417 // @098F stack[1] = 0x04 // @0993 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09a1, returns to 0x0417, if !(msg.data.length - 0x04 < 0x20) label_099D: // Incoming jump from 0x099C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @09A0 memory[0x00:0x00] } 099D 60 PUSH1 0x00 099F 80 DUP1 09A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @09A0 revert(memory[0x00:0x00]); } // Block terminates label_09A1: // Incoming call from 0x099C, returns to 0x0417, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @09A3 stack[-2] // @09A3 msg.data[stack[-2]:stack[-2] + 0x20] // } 09A1 5B JUMPDEST 09A2 50 POP 09A3 35 CALLDATALOAD 09A4 61 PUSH2 0x1672 09A7 56 *JUMP // Stack delta = -1 // Outputs[1] { @09A3 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1672 label_09A8: // Incoming jump from 0x00FA, if 0xb429afeb == stack[-1] // Inputs[1] { @09AF msg.data.length } 09A8 5B JUMPDEST 09A9 61 PUSH2 0x025e 09AC 60 PUSH1 0x04 09AE 80 DUP1 09AF 36 CALLDATASIZE 09B0 03 SUB 09B1 60 PUSH1 0x20 09B3 81 DUP2 09B4 10 LT 09B5 15 ISZERO 09B6 61 PUSH2 0x09be 09B9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09A9 stack[0] = 0x025e // @09AC stack[1] = 0x04 // @09B0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x09be, if !(msg.data.length - 0x04 < 0x20) label_09BA: // Incoming jump from 0x09B9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @09BD memory[0x00:0x00] } 09BA 60 PUSH1 0x00 09BC 80 DUP1 09BD FD *REVERT // Stack delta = +0 // Outputs[1] { @09BD revert(memory[0x00:0x00]); } // Block terminates label_09BE: // Incoming jump from 0x09B9, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @09C0 stack[-2] // @09C0 msg.data[stack[-2]:stack[-2] + 0x20] // } 09BE 5B JUMPDEST 09BF 50 POP 09C0 35 CALLDATALOAD 09C1 60 PUSH1 0x01 09C3 60 PUSH1 0x01 09C5 60 PUSH1 0xa0 09C7 1B SHL 09C8 03 SUB 09C9 16 AND 09CA 61 PUSH2 0x1694 09CD 56 *JUMP // Stack delta = -1 // Outputs[1] { @09C9 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1694 label_09CE: // Incoming jump from 0x0087, if 0xb5466669 == stack[-1] // Inputs[1] { @09D5 msg.data.length } 09CE 5B JUMPDEST 09CF 61 PUSH2 0x02a8 09D2 60 PUSH1 0x04 09D4 80 DUP1 09D5 36 CALLDATASIZE 09D6 03 SUB 09D7 60 PUSH1 0x60 09D9 81 DUP2 09DA 10 LT 09DB 15 ISZERO 09DC 61 PUSH2 0x09e4 09DF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09CF stack[0] = 0x02a8 // @09D2 stack[1] = 0x04 // @09D6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x09e4, if !(msg.data.length - 0x04 < 0x60) label_09E0: // Incoming jump from 0x09DF, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @09E3 memory[0x00:0x00] } 09E0 60 PUSH1 0x00 09E2 80 DUP1 09E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @09E3 revert(memory[0x00:0x00]); } // Block terminates label_09E4: // Incoming jump from 0x09DF, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @09ED stack[-2] // @09EE msg.data[stack[-2]:stack[-2] + 0x20] // @09F5 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @09F6 stack[-1] // @0A02 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 09E4 5B JUMPDEST 09E5 60 PUSH1 0x01 09E7 60 PUSH1 0x01 09E9 60 PUSH1 0xa0 09EB 1B SHL 09EC 03 SUB 09ED 82 DUP3 09EE 35 CALLDATALOAD 09EF 16 AND 09F0 91 SWAP2 09F1 60 PUSH1 0x20 09F3 81 DUP2 09F4 01 ADD 09F5 35 CALLDATALOAD 09F6 91 SWAP2 09F7 81 DUP2 09F8 01 ADD 09F9 90 SWAP1 09FA 60 PUSH1 0x60 09FC 81 DUP2 09FD 01 ADD 09FE 60 PUSH1 0x40 0A00 82 DUP3 0A01 01 ADD 0A02 35 CALLDATALOAD 0A03 60 PUSH1 0x01 0A05 60 PUSH1 0x20 0A07 1B SHL 0A08 81 DUP2 0A09 11 GT 0A0A 15 ISZERO 0A0B 61 PUSH2 0x0a13 0A0E 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @09F0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @09F6 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @09F9 stack[0] = stack[-2] + stack[-1] // @09F9 stack[1] = stack[-2] // @09FD stack[2] = stack[-2] + 0x60 // @0A02 stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0a13, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_0A0F: // Incoming jump from 0x0A0E, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0A12 memory[0x00:0x00] } 0A0F 60 PUSH1 0x00 0A11 80 DUP1 0A12 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A12 revert(memory[0x00:0x00]); } // Block terminates label_0A13: // Incoming jump from 0x0A0E, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0A14 stack[-3] // @0A15 stack[-1] // @0A16 stack[-4] // } 0A13 5B JUMPDEST 0A14 82 DUP3 0A15 01 ADD 0A16 83 DUP4 0A17 60 PUSH1 0x20 0A19 82 DUP3 0A1A 01 ADD 0A1B 11 GT 0A1C 15 ISZERO 0A1D 61 PUSH2 0x0a25 0A20 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A15 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0a25, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0A21: // Incoming jump from 0x0A20, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0A24 memory[0x00:0x00] } 0A21 60 PUSH1 0x00 0A23 80 DUP1 0A24 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A24 revert(memory[0x00:0x00]); } // Block terminates label_0A25: // Incoming jump from 0x0A20, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0A26 stack[-1] // @0A27 msg.data[stack[-1]:stack[-1] + 0x20] // @0A2C stack[-2] // @0A2D stack[-4] // } 0A25 5B JUMPDEST 0A26 80 DUP1 0A27 35 CALLDATALOAD 0A28 90 SWAP1 0A29 60 PUSH1 0x20 0A2B 01 ADD 0A2C 91 SWAP2 0A2D 84 DUP5 0A2E 60 PUSH1 0x01 0A30 83 DUP4 0A31 02 MUL 0A32 84 DUP5 0A33 01 ADD 0A34 11 GT 0A35 60 PUSH1 0x01 0A37 60 PUSH1 0x20 0A39 1B SHL 0A3A 83 DUP4 0A3B 11 GT 0A3C 17 OR 0A3D 15 ISZERO 0A3E 61 PUSH2 0x0a46 0A41 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A28 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0A2C stack[0] = stack[-2] // @0A2C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0a46, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0A42: // Incoming jump from 0x0A41, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0A45 memory[0x00:0x00] } 0A42 60 PUSH1 0x00 0A44 80 DUP1 0A45 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A45 revert(memory[0x00:0x00]); } // Block terminates label_0A46: // Incoming jump from 0x0A41, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0A48 stack[-3] // @0A48 stack[-2] // @0A49 stack[-5] // @0A4B stack[-4] // } 0A46 5B JUMPDEST 0A47 50 POP 0A48 90 SWAP1 0A49 92 SWAP3 0A4A 50 POP 0A4B 90 SWAP1 0A4C 50 POP 0A4D 61 PUSH2 0x16a7 0A50 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0A49 stack[-5] = stack[-3] // @0A4B stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x16a7 label_0A51: // Incoming jump from 0x0092, if 0xb88d4fde == stack[-1] // Inputs[1] { @0A58 msg.data.length } 0A51 5B JUMPDEST 0A52 61 PUSH2 0x02a8 0A55 60 PUSH1 0x04 0A57 80 DUP1 0A58 36 CALLDATASIZE 0A59 03 SUB 0A5A 60 PUSH1 0x80 0A5C 81 DUP2 0A5D 10 LT 0A5E 15 ISZERO 0A5F 61 PUSH2 0x0a67 0A62 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A52 stack[0] = 0x02a8 // @0A55 stack[1] = 0x04 // @0A59 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0a67, if !(msg.data.length - 0x04 < 0x80) label_0A63: // Incoming jump from 0x0A62, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0A66 memory[0x00:0x00] } 0A63 60 PUSH1 0x00 0A65 80 DUP1 0A66 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A66 revert(memory[0x00:0x00]); } // Block terminates label_0A67: // Incoming jump from 0x0A62, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0A70 stack[-2] // @0A71 msg.data[stack[-2]:stack[-2] + 0x20] // @0A79 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0A7D stack[-1] // @0A82 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0A90 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0A67 5B JUMPDEST 0A68 60 PUSH1 0x01 0A6A 60 PUSH1 0x01 0A6C 60 PUSH1 0xa0 0A6E 1B SHL 0A6F 03 SUB 0A70 82 DUP3 0A71 35 CALLDATALOAD 0A72 81 DUP2 0A73 16 AND 0A74 92 SWAP3 0A75 60 PUSH1 0x20 0A77 81 DUP2 0A78 01 ADD 0A79 35 CALLDATALOAD 0A7A 90 SWAP1 0A7B 91 SWAP2 0A7C 16 AND 0A7D 91 SWAP2 0A7E 60 PUSH1 0x40 0A80 82 DUP3 0A81 01 ADD 0A82 35 CALLDATALOAD 0A83 91 SWAP2 0A84 90 SWAP1 0A85 81 DUP2 0A86 01 ADD 0A87 90 SWAP1 0A88 60 PUSH1 0x80 0A8A 81 DUP2 0A8B 01 ADD 0A8C 60 PUSH1 0x60 0A8E 82 DUP3 0A8F 01 ADD 0A90 35 CALLDATALOAD 0A91 60 PUSH1 0x01 0A93 60 PUSH1 0x20 0A95 1B SHL 0A96 81 DUP2 0A97 11 GT 0A98 15 ISZERO 0A99 61 PUSH2 0x0aa1 0A9C 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0A74 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0A7D stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0A83 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0A87 stack[1] = stack[-2] + stack[-1] // @0A87 stack[2] = stack[-2] // @0A8B stack[3] = stack[-2] + 0x80 // @0A90 stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x0aa1, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_0A9D: // Incoming jump from 0x0A9C, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // 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 !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0AA2 stack[-3] // @0AA3 stack[-1] // @0AA4 stack[-4] // } 0AA1 5B JUMPDEST 0AA2 82 DUP3 0AA3 01 ADD 0AA4 83 DUP4 0AA5 60 PUSH1 0x20 0AA7 82 DUP3 0AA8 01 ADD 0AA9 11 GT 0AAA 15 ISZERO 0AAB 61 PUSH2 0x0ab3 0AAE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0AA3 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0ab3, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0AAF: // Incoming jump from 0x0AAE, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0AB2 memory[0x00:0x00] } 0AAF 60 PUSH1 0x00 0AB1 80 DUP1 0AB2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB2 revert(memory[0x00:0x00]); } // Block terminates label_0AB3: // Incoming jump from 0x0AAE, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0AB4 stack[-1] // @0AB5 msg.data[stack[-1]:stack[-1] + 0x20] // @0ABA stack[-2] // @0ABB stack[-4] // } 0AB3 5B JUMPDEST 0AB4 80 DUP1 0AB5 35 CALLDATALOAD 0AB6 90 SWAP1 0AB7 60 PUSH1 0x20 0AB9 01 ADD 0ABA 91 SWAP2 0ABB 84 DUP5 0ABC 60 PUSH1 0x01 0ABE 83 DUP4 0ABF 02 MUL 0AC0 84 DUP5 0AC1 01 ADD 0AC2 11 GT 0AC3 60 PUSH1 0x01 0AC5 60 PUSH1 0x20 0AC7 1B SHL 0AC8 83 DUP4 0AC9 11 GT 0ACA 17 OR 0ACB 15 ISZERO 0ACC 61 PUSH2 0x0ad4 0ACF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0AB6 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0ABA stack[0] = stack[-2] // @0ABA stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0ad4, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0AD0: // Incoming jump from 0x0ACF, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0AD3 memory[0x00:0x00] } 0AD0 60 PUSH1 0x00 0AD2 80 DUP1 0AD3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AD3 revert(memory[0x00:0x00]); } // Block terminates label_0AD4: // Incoming jump from 0x0ACF, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0AD5 stack[-3] // @0AD5 stack[-1] // @0AD6 stack[-2] // @0AE7 memory[0x40:0x60] // @0AFE msg.data[stack[-3]:stack[-3] + stack[-2]] // @0B09 stack[-5] // @0B0E stack[-4] // } 0AD4 5B JUMPDEST 0AD5 91 SWAP2 0AD6 90 SWAP1 0AD7 80 DUP1 0AD8 80 DUP1 0AD9 60 PUSH1 0x1f 0ADB 01 ADD 0ADC 60 PUSH1 0x20 0ADE 80 DUP1 0ADF 91 SWAP2 0AE0 04 DIV 0AE1 02 MUL 0AE2 60 PUSH1 0x20 0AE4 01 ADD 0AE5 60 PUSH1 0x40 0AE7 51 MLOAD 0AE8 90 SWAP1 0AE9 81 DUP2 0AEA 01 ADD 0AEB 60 PUSH1 0x40 0AED 52 MSTORE 0AEE 80 DUP1 0AEF 93 SWAP4 0AF0 92 SWAP3 0AF1 91 SWAP2 0AF2 90 SWAP1 0AF3 81 DUP2 0AF4 81 DUP2 0AF5 52 MSTORE 0AF6 60 PUSH1 0x20 0AF8 01 ADD 0AF9 83 DUP4 0AFA 83 DUP4 0AFB 80 DUP1 0AFC 82 DUP3 0AFD 84 DUP5 0AFE 37 CALLDATACOPY 0AFF 60 PUSH1 0x00 0B01 92 SWAP3 0B02 01 ADD 0B03 91 SWAP2 0B04 90 SWAP1 0B05 91 SWAP2 0B06 52 MSTORE 0B07 50 POP 0B08 92 SWAP3 0B09 95 SWAP6 0B0A 50 POP 0B0B 61 PUSH2 0x16fa 0B0E 94 SWAP5 0B0F 50 POP 0B10 50 POP 0B11 50 POP 0B12 50 POP 0B13 50 POP 0B14 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0AED memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0AF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0AFE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0B06 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0B09 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x16fa label_0B15: // Incoming jump from 0x009D, if 0xc29b52f9 == stack[-1] // Inputs[1] { @0B1C msg.data.length } 0B15 5B JUMPDEST 0B16 61 PUSH2 0x02a8 0B19 60 PUSH1 0x04 0B1B 80 DUP1 0B1C 36 CALLDATASIZE 0B1D 03 SUB 0B1E 60 PUSH1 0xa0 0B20 81 DUP2 0B21 10 LT 0B22 15 ISZERO 0B23 61 PUSH2 0x0b2b 0B26 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0B16 stack[0] = 0x02a8 // @0B19 stack[1] = 0x04 // @0B1D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0b2b, returns to 0x02A8, if !(msg.data.length - 0x04 < 0xa0) label_0B27: // Incoming jump from 0x0B26, if not !(msg.data.length - 0x04 < 0xa0) // Inputs[1] { @0B2A memory[0x00:0x00] } 0B27 60 PUSH1 0x00 0B29 80 DUP1 0B2A FD *REVERT // Stack delta = +0 // Outputs[1] { @0B2A revert(memory[0x00:0x00]); } // Block terminates label_0B2B: // Incoming call from 0x0B26, returns to 0x02A8, if !(msg.data.length - 0x04 < 0xa0) // Inputs[6] // { // @0B34 stack[-2] // @0B35 msg.data[stack[-2]:stack[-2] + 0x20] // @0B3D msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0B41 stack[-1] // @0B46 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0B54 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0B2B 5B JUMPDEST 0B2C 60 PUSH1 0x01 0B2E 60 PUSH1 0x01 0B30 60 PUSH1 0xa0 0B32 1B SHL 0B33 03 SUB 0B34 82 DUP3 0B35 35 CALLDATALOAD 0B36 81 DUP2 0B37 16 AND 0B38 92 SWAP3 0B39 60 PUSH1 0x20 0B3B 81 DUP2 0B3C 01 ADD 0B3D 35 CALLDATALOAD 0B3E 90 SWAP1 0B3F 91 SWAP2 0B40 16 AND 0B41 91 SWAP2 0B42 60 PUSH1 0x40 0B44 82 DUP3 0B45 01 ADD 0B46 35 CALLDATALOAD 0B47 91 SWAP2 0B48 90 SWAP1 0B49 81 DUP2 0B4A 01 ADD 0B4B 90 SWAP1 0B4C 60 PUSH1 0x80 0B4E 81 DUP2 0B4F 01 ADD 0B50 60 PUSH1 0x60 0B52 82 DUP3 0B53 01 ADD 0B54 35 CALLDATALOAD 0B55 60 PUSH1 0x01 0B57 60 PUSH1 0x20 0B59 1B SHL 0B5A 81 DUP2 0B5B 11 GT 0B5C 15 ISZERO 0B5D 61 PUSH2 0x0b65 0B60 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0B38 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0B41 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0B47 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0B4B stack[1] = stack[-2] + stack[-1] // @0B4B stack[2] = stack[-2] // @0B4F stack[3] = stack[-2] + 0x80 // @0B54 stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x0b65, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_0B61: // Incoming jump from 0x0B60, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0B64 memory[0x00:0x00] } 0B61 60 PUSH1 0x00 0B63 80 DUP1 0B64 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B64 revert(memory[0x00:0x00]); } // Block terminates label_0B65: // Incoming jump from 0x0B60, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0B66 stack[-3] // @0B67 stack[-1] // @0B68 stack[-4] // } 0B65 5B JUMPDEST 0B66 82 DUP3 0B67 01 ADD 0B68 83 DUP4 0B69 60 PUSH1 0x20 0B6B 82 DUP3 0B6C 01 ADD 0B6D 11 GT 0B6E 15 ISZERO 0B6F 61 PUSH2 0x0b77 0B72 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0B67 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0b77, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0B73: // Incoming jump from 0x0B72, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0B76 memory[0x00:0x00] } 0B73 60 PUSH1 0x00 0B75 80 DUP1 0B76 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B76 revert(memory[0x00:0x00]); } // Block terminates label_0B77: // Incoming jump from 0x0B72, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0B78 stack[-1] // @0B79 msg.data[stack[-1]:stack[-1] + 0x20] // @0B7E stack[-2] // @0B7F stack[-4] // } 0B77 5B JUMPDEST 0B78 80 DUP1 0B79 35 CALLDATALOAD 0B7A 90 SWAP1 0B7B 60 PUSH1 0x20 0B7D 01 ADD 0B7E 91 SWAP2 0B7F 84 DUP5 0B80 60 PUSH1 0x01 0B82 83 DUP4 0B83 02 MUL 0B84 84 DUP5 0B85 01 ADD 0B86 11 GT 0B87 60 PUSH1 0x01 0B89 60 PUSH1 0x20 0B8B 1B SHL 0B8C 83 DUP4 0B8D 11 GT 0B8E 17 OR 0B8F 15 ISZERO 0B90 61 PUSH2 0x0b98 0B93 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B7A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0B7E stack[0] = stack[-2] // @0B7E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0b98, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0B94: // Incoming jump from 0x0B93, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0B97 memory[0x00:0x00] } 0B94 60 PUSH1 0x00 0B96 80 DUP1 0B97 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B97 revert(memory[0x00:0x00]); } // Block terminates label_0B98: // Incoming jump from 0x0B93, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @0B99 stack[-3] // @0B99 stack[-1] // @0B9A stack[-2] // @0BAB memory[0x40:0x60] // @0BC2 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0BCD stack[-5] // @0BCE stack[-4] // @0BD6 msg.data[stack[-1]:stack[-1] + 0x20] // } 0B98 5B JUMPDEST 0B99 91 SWAP2 0B9A 90 SWAP1 0B9B 80 DUP1 0B9C 80 DUP1 0B9D 60 PUSH1 0x1f 0B9F 01 ADD 0BA0 60 PUSH1 0x20 0BA2 80 DUP1 0BA3 91 SWAP2 0BA4 04 DIV 0BA5 02 MUL 0BA6 60 PUSH1 0x20 0BA8 01 ADD 0BA9 60 PUSH1 0x40 0BAB 51 MLOAD 0BAC 90 SWAP1 0BAD 81 DUP2 0BAE 01 ADD 0BAF 60 PUSH1 0x40 0BB1 52 MSTORE 0BB2 80 DUP1 0BB3 93 SWAP4 0BB4 92 SWAP3 0BB5 91 SWAP2 0BB6 90 SWAP1 0BB7 81 DUP2 0BB8 81 DUP2 0BB9 52 MSTORE 0BBA 60 PUSH1 0x20 0BBC 01 ADD 0BBD 83 DUP4 0BBE 83 DUP4 0BBF 80 DUP1 0BC0 82 DUP3 0BC1 84 DUP5 0BC2 37 CALLDATACOPY 0BC3 60 PUSH1 0x00 0BC5 92 SWAP3 0BC6 01 ADD 0BC7 91 SWAP2 0BC8 90 SWAP1 0BC9 91 SWAP2 0BCA 52 MSTORE 0BCB 50 POP 0BCC 92 SWAP3 0BCD 95 SWAP6 0BCE 94 SWAP5 0BCF 93 SWAP4 0BD0 60 PUSH1 0x20 0BD2 81 DUP2 0BD3 01 ADD 0BD4 93 SWAP4 0BD5 50 POP 0BD6 35 CALLDATALOAD 0BD7 91 SWAP2 0BD8 50 POP 0BD9 50 POP 0BDA 60 PUSH1 0x01 0BDC 60 PUSH1 0x20 0BDE 1B SHL 0BDF 81 DUP2 0BE0 11 GT 0BE1 15 ISZERO 0BE2 61 PUSH2 0x0bea 0BE5 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0BB1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0BB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0BC2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0BCA memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0BCD stack[-5] = memory[0x40:0x60] // @0BCE stack[-4] = stack[-5] // @0BCF stack[-3] = stack[-4] // @0BD4 stack[-2] = stack[-1] + 0x20 // @0BD7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0bea, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0BE6: // Incoming jump from 0x0BE5, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0BE9 memory[0x00:0x00] } 0BE6 60 PUSH1 0x00 0BE8 80 DUP1 0BE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BE9 revert(memory[0x00:0x00]); } // Block terminates label_0BEA: // Incoming jump from 0x0BE5, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0BEB stack[-3] // @0BEC stack[-1] // @0BED stack[-4] // } 0BEA 5B JUMPDEST 0BEB 82 DUP3 0BEC 01 ADD 0BED 83 DUP4 0BEE 60 PUSH1 0x20 0BF0 82 DUP3 0BF1 01 ADD 0BF2 11 GT 0BF3 15 ISZERO 0BF4 61 PUSH2 0x0bfc 0BF7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0BEC stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0bfc, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0BF8: // Incoming jump from 0x0BF7, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0BFB memory[0x00:0x00] } 0BF8 60 PUSH1 0x00 0BFA 80 DUP1 0BFB FD *REVERT // Stack delta = +0 // Outputs[1] { @0BFB revert(memory[0x00:0x00]); } // Block terminates label_0BFC: // Incoming jump from 0x0BF7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0BFD stack[-1] // @0BFE msg.data[stack[-1]:stack[-1] + 0x20] // @0C03 stack[-2] // @0C04 stack[-4] // } 0BFC 5B JUMPDEST 0BFD 80 DUP1 0BFE 35 CALLDATALOAD 0BFF 90 SWAP1 0C00 60 PUSH1 0x20 0C02 01 ADD 0C03 91 SWAP2 0C04 84 DUP5 0C05 60 PUSH1 0x01 0C07 83 DUP4 0C08 02 MUL 0C09 84 DUP5 0C0A 01 ADD 0C0B 11 GT 0C0C 60 PUSH1 0x01 0C0E 60 PUSH1 0x20 0C10 1B SHL 0C11 83 DUP4 0C12 11 GT 0C13 17 OR 0C14 15 ISZERO 0C15 61 PUSH2 0x0c1d 0C18 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0BFF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0C03 stack[0] = stack[-2] // @0C03 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0c1d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0C19: // Incoming jump from 0x0C18, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0C1C memory[0x00:0x00] } 0C19 60 PUSH1 0x00 0C1B 80 DUP1 0C1C FD *REVERT // Stack delta = +0 // Outputs[1] { @0C1C revert(memory[0x00:0x00]); } // Block terminates label_0C1D: // Incoming jump from 0x0C18, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0C1E stack[-1] // @0C1E stack[-3] // @0C1F stack[-2] // @0C30 memory[0x40:0x60] // @0C47 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0C52 stack[-5] // @0C57 stack[-4] // } 0C1D 5B JUMPDEST 0C1E 91 SWAP2 0C1F 90 SWAP1 0C20 80 DUP1 0C21 80 DUP1 0C22 60 PUSH1 0x1f 0C24 01 ADD 0C25 60 PUSH1 0x20 0C27 80 DUP1 0C28 91 SWAP2 0C29 04 DIV 0C2A 02 MUL 0C2B 60 PUSH1 0x20 0C2D 01 ADD 0C2E 60 PUSH1 0x40 0C30 51 MLOAD 0C31 90 SWAP1 0C32 81 DUP2 0C33 01 ADD 0C34 60 PUSH1 0x40 0C36 52 MSTORE 0C37 80 DUP1 0C38 93 SWAP4 0C39 92 SWAP3 0C3A 91 SWAP2 0C3B 90 SWAP1 0C3C 81 DUP2 0C3D 81 DUP2 0C3E 52 MSTORE 0C3F 60 PUSH1 0x20 0C41 01 ADD 0C42 83 DUP4 0C43 83 DUP4 0C44 80 DUP1 0C45 82 DUP3 0C46 84 DUP5 0C47 37 CALLDATACOPY 0C48 60 PUSH1 0x00 0C4A 92 SWAP3 0C4B 01 ADD 0C4C 91 SWAP2 0C4D 90 SWAP1 0C4E 91 SWAP2 0C4F 52 MSTORE 0C50 50 POP 0C51 92 SWAP3 0C52 95 SWAP6 0C53 50 POP 0C54 61 PUSH2 0x174c 0C57 94 SWAP5 0C58 50 POP 0C59 50 POP 0C5A 50 POP 0C5B 50 POP 0C5C 50 POP 0C5D 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0C36 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0C3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0C47 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0C4F memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0C52 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x174c label_0C5E: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @0C65 msg.data.length } 0C5E 5B JUMPDEST 0C5F 61 PUSH2 0x0385 0C62 60 PUSH1 0x04 0C64 80 DUP1 0C65 36 CALLDATASIZE 0C66 03 SUB 0C67 60 PUSH1 0x20 0C69 81 DUP2 0C6A 10 LT 0C6B 15 ISZERO 0C6C 61 PUSH2 0x0c74 0C6F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C5F stack[0] = 0x0385 // @0C62 stack[1] = 0x04 // @0C66 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0c74, returns to 0x0385, if !(msg.data.length - 0x04 < 0x20) label_0C70: // Incoming jump from 0x0C6F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0C73 memory[0x00:0x00] } 0C70 60 PUSH1 0x00 0C72 80 DUP1 0C73 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C73 revert(memory[0x00:0x00]); } // Block terminates label_0C74: // Incoming call from 0x0C6F, returns to 0x0385, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0C76 stack[-2] // @0C76 msg.data[stack[-2]:stack[-2] + 0x20] // } 0C74 5B JUMPDEST 0C75 50 POP 0C76 35 CALLDATALOAD 0C77 61 PUSH2 0x1797 0C7A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C76 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1797 label_0C7B: // Incoming jump from 0x00B3, if 0xce9fb82b == stack[-1] // Inputs[1] { @0C82 msg.data.length } 0C7B 5B JUMPDEST 0C7C 61 PUSH2 0x02a8 0C7F 60 PUSH1 0x04 0C81 80 DUP1 0C82 36 CALLDATASIZE 0C83 03 SUB 0C84 60 PUSH1 0x80 0C86 81 DUP2 0C87 10 LT 0C88 15 ISZERO 0C89 61 PUSH2 0x0c91 0C8C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C7C stack[0] = 0x02a8 // @0C7F stack[1] = 0x04 // @0C83 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0c91, if !(msg.data.length - 0x04 < 0x80) label_0C8D: // Incoming jump from 0x0C8C, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0C90 memory[0x00:0x00] } 0C8D 60 PUSH1 0x00 0C8F 80 DUP1 0C90 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C90 revert(memory[0x00:0x00]); } // Block terminates label_0C91: // Incoming jump from 0x0C8C, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @0C9A stack[-2] // @0C9B msg.data[stack[-2]:stack[-2] + 0x20] // @0CA2 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0CA3 stack[-1] // @0CAF msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0C91 5B JUMPDEST 0C92 60 PUSH1 0x01 0C94 60 PUSH1 0x01 0C96 60 PUSH1 0xa0 0C98 1B SHL 0C99 03 SUB 0C9A 82 DUP3 0C9B 35 CALLDATALOAD 0C9C 16 AND 0C9D 91 SWAP2 0C9E 60 PUSH1 0x20 0CA0 81 DUP2 0CA1 01 ADD 0CA2 35 CALLDATALOAD 0CA3 91 SWAP2 0CA4 81 DUP2 0CA5 01 ADD 0CA6 90 SWAP1 0CA7 60 PUSH1 0x60 0CA9 81 DUP2 0CAA 01 ADD 0CAB 60 PUSH1 0x40 0CAD 82 DUP3 0CAE 01 ADD 0CAF 35 CALLDATALOAD 0CB0 60 PUSH1 0x01 0CB2 60 PUSH1 0x20 0CB4 1B SHL 0CB5 81 DUP2 0CB6 11 GT 0CB7 15 ISZERO 0CB8 61 PUSH2 0x0cc0 0CBB 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0C9D stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0CA3 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0CA6 stack[0] = stack[-2] + stack[-1] // @0CA6 stack[1] = stack[-2] // @0CAA stack[2] = stack[-2] + 0x60 // @0CAF stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0cc0, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_0CBC: // Incoming jump from 0x0CBB, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0CBF memory[0x00:0x00] } 0CBC 60 PUSH1 0x00 0CBE 80 DUP1 0CBF FD *REVERT // Stack delta = +0 // Outputs[1] { @0CBF revert(memory[0x00:0x00]); } // Block terminates label_0CC0: // Incoming jump from 0x0CBB, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0CC1 stack[-3] // @0CC2 stack[-1] // @0CC3 stack[-4] // } 0CC0 5B JUMPDEST 0CC1 82 DUP3 0CC2 01 ADD 0CC3 83 DUP4 0CC4 60 PUSH1 0x20 0CC6 82 DUP3 0CC7 01 ADD 0CC8 11 GT 0CC9 15 ISZERO 0CCA 61 PUSH2 0x0cd2 0CCD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0CC2 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0cd2, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0CCE: // Incoming jump from 0x0CCD, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0CD1 memory[0x00:0x00] } 0CCE 60 PUSH1 0x00 0CD0 80 DUP1 0CD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CD1 revert(memory[0x00:0x00]); } // Block terminates label_0CD2: // Incoming jump from 0x0CCD, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0CD3 stack[-1] // @0CD4 msg.data[stack[-1]:stack[-1] + 0x20] // @0CD9 stack[-2] // @0CDA stack[-4] // } 0CD2 5B JUMPDEST 0CD3 80 DUP1 0CD4 35 CALLDATALOAD 0CD5 90 SWAP1 0CD6 60 PUSH1 0x20 0CD8 01 ADD 0CD9 91 SWAP2 0CDA 84 DUP5 0CDB 60 PUSH1 0x01 0CDD 83 DUP4 0CDE 02 MUL 0CDF 84 DUP5 0CE0 01 ADD 0CE1 11 GT 0CE2 60 PUSH1 0x01 0CE4 60 PUSH1 0x20 0CE6 1B SHL 0CE7 83 DUP4 0CE8 11 GT 0CE9 17 OR 0CEA 15 ISZERO 0CEB 61 PUSH2 0x0cf3 0CEE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CD5 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0CD9 stack[0] = stack[-2] // @0CD9 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0cf3, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0CEF: // Incoming jump from 0x0CEE, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0CF2 memory[0x00:0x00] } 0CEF 60 PUSH1 0x00 0CF1 80 DUP1 0CF2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CF2 revert(memory[0x00:0x00]); } // Block terminates label_0CF3: // Incoming jump from 0x0CEE, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[6] // { // @0CF4 stack[-3] // @0CF4 stack[-1] // @0CF5 stack[-5] // @0CF6 stack[-2] // @0CF7 stack[-4] // @0CFF msg.data[stack[-1]:stack[-1] + 0x20] // } 0CF3 5B JUMPDEST 0CF4 91 SWAP2 0CF5 93 SWAP4 0CF6 90 SWAP1 0CF7 92 SWAP3 0CF8 90 SWAP1 0CF9 91 SWAP2 0CFA 60 PUSH1 0x20 0CFC 81 DUP2 0CFD 01 ADD 0CFE 90 SWAP1 0CFF 35 CALLDATALOAD 0D00 60 PUSH1 0x01 0D02 60 PUSH1 0x20 0D04 1B SHL 0D05 81 DUP2 0D06 11 GT 0D07 15 ISZERO 0D08 61 PUSH2 0x0d10 0D0B 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0CF5 stack[-5] = stack[-3] // @0CF7 stack[-4] = stack[-2] // @0CF8 stack[-2] = stack[-4] // @0CF9 stack[-3] = stack[-5] // @0CFE stack[-1] = stack[-1] + 0x20 // @0CFF stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0d10, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0D0C: // Incoming jump from 0x0D0B, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0D0F memory[0x00:0x00] } 0D0C 60 PUSH1 0x00 0D0E 80 DUP1 0D0F FD *REVERT // Stack delta = +0 // Outputs[1] { @0D0F revert(memory[0x00:0x00]); } // Block terminates label_0D10: // Incoming jump from 0x0D0B, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0D11 stack[-3] // @0D12 stack[-1] // @0D13 stack[-4] // } 0D10 5B JUMPDEST 0D11 82 DUP3 0D12 01 ADD 0D13 83 DUP4 0D14 60 PUSH1 0x20 0D16 82 DUP3 0D17 01 ADD 0D18 11 GT 0D19 15 ISZERO 0D1A 61 PUSH2 0x0d22 0D1D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D12 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0d22, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0D1E: // Incoming jump from 0x0D1D, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0D21 memory[0x00:0x00] } 0D1E 60 PUSH1 0x00 0D20 80 DUP1 0D21 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D21 revert(memory[0x00:0x00]); } // Block terminates label_0D22: // Incoming jump from 0x0D1D, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0D23 stack[-1] // @0D24 msg.data[stack[-1]:stack[-1] + 0x20] // @0D29 stack[-2] // @0D2A stack[-4] // } 0D22 5B JUMPDEST 0D23 80 DUP1 0D24 35 CALLDATALOAD 0D25 90 SWAP1 0D26 60 PUSH1 0x20 0D28 01 ADD 0D29 91 SWAP2 0D2A 84 DUP5 0D2B 60 PUSH1 0x01 0D2D 83 DUP4 0D2E 02 MUL 0D2F 84 DUP5 0D30 01 ADD 0D31 11 GT 0D32 60 PUSH1 0x01 0D34 60 PUSH1 0x20 0D36 1B SHL 0D37 83 DUP4 0D38 11 GT 0D39 17 OR 0D3A 15 ISZERO 0D3B 61 PUSH2 0x0d43 0D3E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0D25 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0D29 stack[0] = stack[-2] // @0D29 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0d43, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0D3F: // Incoming jump from 0x0D3E, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0D42 memory[0x00:0x00] } 0D3F 60 PUSH1 0x00 0D41 80 DUP1 0D42 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D42 revert(memory[0x00:0x00]); } // Block terminates label_0D43: // Incoming jump from 0x0D3E, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0D45 stack[-2] // @0D45 stack[-3] // @0D46 stack[-5] // @0D48 stack[-4] // } 0D43 5B JUMPDEST 0D44 50 POP 0D45 90 SWAP1 0D46 92 SWAP3 0D47 50 POP 0D48 90 SWAP1 0D49 50 POP 0D4A 61 PUSH2 0x1892 0D4D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0D46 stack[-5] = stack[-3] // @0D48 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x1892 label_0D4E: // Incoming jump from 0x004B, if 0xd284d97a == stack[-1] // Inputs[1] { @0D55 msg.data.length } 0D4E 5B JUMPDEST 0D4F 61 PUSH2 0x02a8 0D52 60 PUSH1 0x04 0D54 80 DUP1 0D55 36 CALLDATASIZE 0D56 03 SUB 0D57 60 PUSH1 0x20 0D59 81 DUP2 0D5A 10 LT 0D5B 15 ISZERO 0D5C 61 PUSH2 0x0d64 0D5F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0D4F stack[0] = 0x02a8 // @0D52 stack[1] = 0x04 // @0D56 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0d64, if !(msg.data.length - 0x04 < 0x20) label_0D60: // Incoming jump from 0x0D5F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0D63 memory[0x00:0x00] } 0D60 60 PUSH1 0x00 0D62 80 DUP1 0D63 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D63 revert(memory[0x00:0x00]); } // Block terminates label_0D64: // Incoming jump from 0x0D5F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0D65 stack[-2] // @0D66 stack[-1] // @0D6D msg.data[stack[-2]:stack[-2] + 0x20] // } 0D64 5B JUMPDEST 0D65 81 DUP2 0D66 01 ADD 0D67 90 SWAP1 0D68 60 PUSH1 0x20 0D6A 81 DUP2 0D6B 01 ADD 0D6C 81 DUP2 0D6D 35 CALLDATALOAD 0D6E 60 PUSH1 0x01 0D70 60 PUSH1 0x20 0D72 1B SHL 0D73 81 DUP2 0D74 11 GT 0D75 15 ISZERO 0D76 61 PUSH2 0x0d7e 0D79 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0D67 stack[-1] = stack[-2] // @0D67 stack[-2] = stack[-2] + stack[-1] // @0D6B stack[0] = stack[-2] + 0x20 // @0D6D stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0d7e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0D7A: // Incoming jump from 0x0D79, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0D7D memory[0x00:0x00] } 0D7A 60 PUSH1 0x00 0D7C 80 DUP1 0D7D FD *REVERT // Stack delta = +0 // Outputs[1] { @0D7D revert(memory[0x00:0x00]); } // Block terminates label_0D7E: // Incoming jump from 0x0D79, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0D7F stack[-3] // @0D80 stack[-1] // @0D81 stack[-4] // } 0D7E 5B JUMPDEST 0D7F 82 DUP3 0D80 01 ADD 0D81 83 DUP4 0D82 60 PUSH1 0x20 0D84 82 DUP3 0D85 01 ADD 0D86 11 GT 0D87 15 ISZERO 0D88 61 PUSH2 0x0d90 0D8B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D80 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0d90, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0D8C: // Incoming jump from 0x0D8B, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0D8F memory[0x00:0x00] } 0D8C 60 PUSH1 0x00 0D8E 80 DUP1 0D8F FD *REVERT // Stack delta = +0 // Outputs[1] { @0D8F revert(memory[0x00:0x00]); } // Block terminates label_0D90: // Incoming jump from 0x0D8B, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0D91 stack[-1] // @0D92 msg.data[stack[-1]:stack[-1] + 0x20] // @0D97 stack[-2] // @0D98 stack[-4] // } 0D90 5B JUMPDEST 0D91 80 DUP1 0D92 35 CALLDATALOAD 0D93 90 SWAP1 0D94 60 PUSH1 0x20 0D96 01 ADD 0D97 91 SWAP2 0D98 84 DUP5 0D99 60 PUSH1 0x01 0D9B 83 DUP4 0D9C 02 MUL 0D9D 84 DUP5 0D9E 01 ADD 0D9F 11 GT 0DA0 60 PUSH1 0x01 0DA2 60 PUSH1 0x20 0DA4 1B SHL 0DA5 83 DUP4 0DA6 11 GT 0DA7 17 OR 0DA8 15 ISZERO 0DA9 61 PUSH2 0x0db1 0DAC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0D93 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0D97 stack[0] = stack[-2] // @0D97 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0db1, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0DAD: // Incoming jump from 0x0DAC, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0DB0 memory[0x00:0x00] } 0DAD 60 PUSH1 0x00 0DAF 80 DUP1 0DB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DB0 revert(memory[0x00:0x00]); } // Block terminates label_0DB1: // Incoming jump from 0x0DAC, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0DB3 stack[-3] // @0DB3 stack[-2] // @0DB4 stack[-5] // @0DB6 stack[-4] // } 0DB1 5B JUMPDEST 0DB2 50 POP 0DB3 90 SWAP1 0DB4 92 SWAP3 0DB5 50 POP 0DB6 90 SWAP1 0DB7 50 POP 0DB8 61 PUSH2 0x191b 0DBB 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0DB4 stack[-5] = stack[-3] // @0DB6 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x191b label_0DBC: // Incoming jump from 0x0056, if 0xd8d3cc6e == stack[-1] // Inputs[1] { @0DC3 msg.data.length } 0DBC 5B JUMPDEST 0DBD 61 PUSH2 0x02a8 0DC0 60 PUSH1 0x04 0DC2 80 DUP1 0DC3 36 CALLDATASIZE 0DC4 03 SUB 0DC5 60 PUSH1 0x60 0DC7 81 DUP2 0DC8 10 LT 0DC9 15 ISZERO 0DCA 61 PUSH2 0x0dd2 0DCD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0DBD stack[0] = 0x02a8 // @0DC0 stack[1] = 0x04 // @0DC4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0dd2, if !(msg.data.length - 0x04 < 0x60) label_0DCE: // Incoming jump from 0x0DCD, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0DD1 memory[0x00:0x00] } 0DCE 60 PUSH1 0x00 0DD0 80 DUP1 0DD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DD1 revert(memory[0x00:0x00]); } // Block terminates label_0DD2: // Incoming jump from 0x0DCD, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0DDB stack[-2] // @0DDC msg.data[stack[-2]:stack[-2] + 0x20] // @0DE3 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0DE4 stack[-1] // @0DF0 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0DD2 5B JUMPDEST 0DD3 60 PUSH1 0x01 0DD5 60 PUSH1 0x01 0DD7 60 PUSH1 0xa0 0DD9 1B SHL 0DDA 03 SUB 0DDB 82 DUP3 0DDC 35 CALLDATALOAD 0DDD 16 AND 0DDE 91 SWAP2 0DDF 60 PUSH1 0x20 0DE1 81 DUP2 0DE2 01 ADD 0DE3 35 CALLDATALOAD 0DE4 91 SWAP2 0DE5 81 DUP2 0DE6 01 ADD 0DE7 90 SWAP1 0DE8 60 PUSH1 0x60 0DEA 81 DUP2 0DEB 01 ADD 0DEC 60 PUSH1 0x40 0DEE 82 DUP3 0DEF 01 ADD 0DF0 35 CALLDATALOAD 0DF1 60 PUSH1 0x01 0DF3 60 PUSH1 0x20 0DF5 1B SHL 0DF6 81 DUP2 0DF7 11 GT 0DF8 15 ISZERO 0DF9 61 PUSH2 0x0e01 0DFC 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0DDE stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0DE4 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0DE7 stack[0] = stack[-2] + stack[-1] // @0DE7 stack[1] = stack[-2] // @0DEB stack[2] = stack[-2] + 0x60 // @0DF0 stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0e01, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_0DFD: // Incoming jump from 0x0DFC, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0E00 memory[0x00:0x00] } 0DFD 60 PUSH1 0x00 0DFF 80 DUP1 0E00 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E00 revert(memory[0x00:0x00]); } // Block terminates label_0E01: // Incoming jump from 0x0DFC, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0E02 stack[-3] // @0E03 stack[-1] // @0E04 stack[-4] // } 0E01 5B JUMPDEST 0E02 82 DUP3 0E03 01 ADD 0E04 83 DUP4 0E05 60 PUSH1 0x20 0E07 82 DUP3 0E08 01 ADD 0E09 11 GT 0E0A 15 ISZERO 0E0B 61 PUSH2 0x0e13 0E0E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E03 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0e13, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0E0F: // Incoming jump from 0x0E0E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0E12 memory[0x00:0x00] } 0E0F 60 PUSH1 0x00 0E11 80 DUP1 0E12 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E12 revert(memory[0x00:0x00]); } // Block terminates label_0E13: // Incoming jump from 0x0E0E, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0E14 stack[-1] // @0E15 msg.data[stack[-1]:stack[-1] + 0x20] // @0E1A stack[-2] // @0E1B stack[-4] // } 0E13 5B JUMPDEST 0E14 80 DUP1 0E15 35 CALLDATALOAD 0E16 90 SWAP1 0E17 60 PUSH1 0x20 0E19 01 ADD 0E1A 91 SWAP2 0E1B 84 DUP5 0E1C 60 PUSH1 0x01 0E1E 83 DUP4 0E1F 02 MUL 0E20 84 DUP5 0E21 01 ADD 0E22 11 GT 0E23 60 PUSH1 0x01 0E25 60 PUSH1 0x20 0E27 1B SHL 0E28 83 DUP4 0E29 11 GT 0E2A 17 OR 0E2B 15 ISZERO 0E2C 61 PUSH2 0x0e34 0E2F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E16 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0E1A stack[0] = stack[-2] // @0E1A stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0e34, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0E30: // Incoming jump from 0x0E2F, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0E33 memory[0x00:0x00] } 0E30 60 PUSH1 0x00 0E32 80 DUP1 0E33 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E33 revert(memory[0x00:0x00]); } // Block terminates label_0E34: // Incoming jump from 0x0E2F, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @0E36 stack[-3] // @0E36 stack[-2] // @0E37 stack[-5] // @0E39 stack[-4] // } 0E34 5B JUMPDEST 0E35 50 POP 0E36 90 SWAP1 0E37 92 SWAP3 0E38 50 POP 0E39 90 SWAP1 0E3A 50 POP 0E3B 61 PUSH2 0x199e 0E3E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0E37 stack[-5] = stack[-3] // @0E39 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x199e label_0E3F: // Incoming jump from 0x0061, if 0xe67ca8a3 == stack[-1] // Inputs[1] { @0E46 msg.data.length } 0E3F 5B JUMPDEST 0E40 61 PUSH2 0x02a8 0E43 60 PUSH1 0x04 0E45 80 DUP1 0E46 36 CALLDATASIZE 0E47 03 SUB 0E48 60 PUSH1 0x20 0E4A 81 DUP2 0E4B 10 LT 0E4C 15 ISZERO 0E4D 61 PUSH2 0x0e55 0E50 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E40 stack[0] = 0x02a8 // @0E43 stack[1] = 0x04 // @0E47 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0e55, if !(msg.data.length - 0x04 < 0x20) label_0E51: // Incoming jump from 0x0E50, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0E54 memory[0x00:0x00] } 0E51 60 PUSH1 0x00 0E53 80 DUP1 0E54 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E54 revert(memory[0x00:0x00]); } // Block terminates label_0E55: // Incoming jump from 0x0E50, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0E57 stack[-2] // @0E57 msg.data[stack[-2]:stack[-2] + 0x20] // } 0E55 5B JUMPDEST 0E56 50 POP 0E57 35 CALLDATALOAD 0E58 61 PUSH2 0x19f3 0E5B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E57 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x19f3 label_0E5C: // Incoming jump from 0x006C, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0E63 msg.data.length } 0E5C 5B JUMPDEST 0E5D 61 PUSH2 0x025e 0E60 60 PUSH1 0x04 0E62 80 DUP1 0E63 36 CALLDATASIZE 0E64 03 SUB 0E65 60 PUSH1 0x40 0E67 81 DUP2 0E68 10 LT 0E69 15 ISZERO 0E6A 61 PUSH2 0x0e72 0E6D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E5D stack[0] = 0x025e // @0E60 stack[1] = 0x04 // @0E64 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e72, returns to 0x025E, if !(msg.data.length - 0x04 < 0x40) label_0E6E: // Incoming jump from 0x0E6D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0E71 memory[0x00:0x00] } 0E6E 60 PUSH1 0x00 0E70 80 DUP1 0E71 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E71 revert(memory[0x00:0x00]); } // Block terminates label_0E72: // Incoming call from 0x0E6D, returns to 0x025E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0E7C stack[-2] // @0E7D msg.data[stack[-2]:stack[-2] + 0x20] // @0E84 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0E72 5B JUMPDEST 0E73 50 POP 0E74 60 PUSH1 0x01 0E76 60 PUSH1 0x01 0E78 60 PUSH1 0xa0 0E7A 1B SHL 0E7B 03 SUB 0E7C 81 DUP2 0E7D 35 CALLDATALOAD 0E7E 81 DUP2 0E7F 16 AND 0E80 91 SWAP2 0E81 60 PUSH1 0x20 0E83 01 ADD 0E84 35 CALLDATALOAD 0E85 16 AND 0E86 61 PUSH2 0x1a05 0E89 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E80 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0E85 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x1a05 label_0E8A: // Incoming jump from 0x0077, if 0xebf0c717 == stack[-1] 0E8A 5B JUMPDEST 0E8B 61 PUSH2 0x072c 0E8E 61 PUSH2 0x1a33 0E91 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E8B stack[0] = 0x072c } // Block ends with call to 0x1a33, returns to 0x072C label_0E92: // Incoming jump from 0x025D // Inputs[4] // { // @0E9C stack[-1] // @0EAA memory[0x00:0x40] // @0EAB storage[keccak256(memory[0x00:0x40])] // @0EAF stack[-2] // } 0E92 5B JUMPDEST 0E93 60 PUSH1 0x01 0E95 60 PUSH1 0x01 0E97 60 PUSH1 0xe0 0E99 1B SHL 0E9A 03 SUB 0E9B 19 NOT 0E9C 16 AND 0E9D 60 PUSH1 0x00 0E9F 90 SWAP1 0EA0 81 DUP2 0EA1 52 MSTORE 0EA2 60 PUSH1 0x20 0EA4 81 DUP2 0EA5 90 SWAP1 0EA6 52 MSTORE 0EA7 60 PUSH1 0x40 0EA9 90 SWAP1 0EAA 20 SHA3 0EAB 54 SLOAD 0EAC 60 PUSH1 0xff 0EAE 16 AND 0EAF 90 SWAP1 0EB0 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0EA1 memory[0x00:0x20] = ~((0x01 << 0xe0) - 0x01) & stack[-1] // @0EA6 memory[0x20:0x40] = 0x00 // @0EAF stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0EB1: // Incoming jump from 0x02A7 // Inputs[1] { @0EB5 msg.sender } 0EB1 5B JUMPDEST 0EB2 61 PUSH2 0x0eba 0EB5 33 CALLER 0EB6 61 PUSH2 0x1694 0EB9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EB2 stack[0] = 0x0eba // @0EB5 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 0EBA 5B JUMPDEST 0EBB 61 PUSH2 0x0ec3 0EBE 57 *JUMPI 0EBF 60 PUSH1 0x00 0EC1 80 DUP1 0EC2 FD *REVERT label_0EC3: // Incoming jump from 0x1123, if stack[-1] // Inputs[3] // { // @0EC7 stack[-3] // @0EC8 stack[-2] // @0EC9 stack[-1] // } 0EC3 5B JUMPDEST 0EC4 61 PUSH2 0x0ece 0EC7 83 DUP4 0EC8 83 DUP4 0EC9 83 DUP4 0ECA 61 PUSH2 0x1a57 0ECD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EC4 stack[0] = 0x0ece // @0EC7 stack[1] = stack[-3] // @0EC8 stack[2] = stack[-2] // @0EC9 stack[3] = stack[-1] // } // Block ends with call to 0x1a57, returns to 0x0ECE label_0ECE: // Incoming jump from 0x1A7F, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Incoming return from call to 0x166B at 0x166A // Incoming return from call to 0x1B82 at 0x1114 // Incoming return from call to 0x1A57 at 0x0ECD // Inputs[1] { @0ED2 stack[-4] } 0ECE 5B JUMPDEST 0ECF 50 POP 0ED0 50 POP 0ED1 50 POP 0ED2 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0ED3: // Incoming jump from 0x037C // Inputs[1] { @0ED7 msg.sender } 0ED3 5B JUMPDEST 0ED4 61 PUSH2 0x0edc 0ED7 33 CALLER 0ED8 61 PUSH2 0x1694 0EDB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0ED4 stack[0] = 0x0edc // @0ED7 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 0EDC 5B JUMPDEST 0EDD 61 PUSH2 0x0ee5 0EE0 57 *JUMPI 0EE1 60 PUSH1 0x00 0EE3 80 DUP1 0EE4 FD *REVERT 0EE5 5B JUMPDEST 0EE6 61 PUSH2 0x0f5a 0EE9 86 DUP7 0EEA 86 DUP7 0EEB 86 DUP7 0EEC 86 DUP7 0EED 80 DUP1 0EEE 80 DUP1 0EEF 60 PUSH1 0x1f 0EF1 01 ADD 0EF2 60 PUSH1 0x20 0EF4 80 DUP1 0EF5 91 SWAP2 0EF6 04 DIV 0EF7 02 MUL 0EF8 60 PUSH1 0x20 0EFA 01 ADD 0EFB 60 PUSH1 0x40 0EFD 51 MLOAD 0EFE 90 SWAP1 0EFF 81 DUP2 0F00 01 ADD 0F01 60 PUSH1 0x40 0F03 52 MSTORE 0F04 80 DUP1 0F05 93 SWAP4 0F06 92 SWAP3 0F07 91 SWAP2 0F08 90 SWAP1 0F09 81 DUP2 0F0A 81 DUP2 0F0B 52 MSTORE 0F0C 60 PUSH1 0x20 0F0E 01 ADD 0F0F 83 DUP4 0F10 83 DUP4 0F11 80 DUP1 0F12 82 DUP3 0F13 84 DUP5 0F14 37 CALLDATACOPY 0F15 60 PUSH1 0x00 0F17 92 SWAP3 0F18 01 ADD 0F19 91 SWAP2 0F1A 90 SWAP1 0F1B 91 SWAP2 0F1C 52 MSTORE 0F1D 50 POP 0F1E 50 POP 0F1F 60 PUSH1 0x40 0F21 80 DUP1 0F22 51 MLOAD 0F23 60 PUSH1 0x20 0F25 60 PUSH1 0x1f 0F27 8A DUP11 0F28 01 ADD 0F29 81 DUP2 0F2A 90 SWAP1 0F2B 04 DIV 0F2C 81 DUP2 0F2D 02 MUL 0F2E 82 DUP3 0F2F 01 ADD 0F30 81 DUP2 0F31 01 ADD 0F32 90 SWAP1 0F33 92 SWAP3 0F34 52 MSTORE 0F35 88 DUP9 0F36 81 DUP2 0F37 52 MSTORE 0F38 92 SWAP3 0F39 50 POP 0F3A 88 DUP9 0F3B 91 SWAP2 0F3C 50 POP 0F3D 87 DUP8 0F3E 90 SWAP1 0F3F 81 DUP2 0F40 90 SWAP1 0F41 84 DUP5 0F42 01 ADD 0F43 83 DUP4 0F44 82 DUP3 0F45 80 DUP1 0F46 82 DUP3 0F47 84 DUP5 0F48 37 CALLDATACOPY 0F49 60 PUSH1 0x00 0F4B 92 SWAP3 0F4C 01 ADD 0F4D 91 SWAP2 0F4E 90 SWAP1 0F4F 91 SWAP2 0F50 52 MSTORE 0F51 50 POP 0F52 61 PUSH2 0x1a9f 0F55 92 SWAP3 0F56 50 POP 0F57 50 POP 0F58 50 POP 0F59 56 *JUMP label_0F5A: // Incoming return from call to 0x155F at 0x155E // Inputs[1] { @0F61 stack[-7] } 0F5A 5B JUMPDEST 0F5B 50 POP 0F5C 50 POP 0F5D 50 POP 0F5E 50 POP 0F5F 50 POP 0F60 50 POP 0F61 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0F62: // Incoming call from 0x0384, returns to 0x0385 // Inputs[2] // { // @0F66 memory[0x40:0x60] // @0F82 stack[-1] // } 0F62 5B JUMPDEST 0F63 60 PUSH1 0x40 0F65 80 DUP1 0F66 51 MLOAD 0F67 80 DUP1 0F68 82 DUP3 0F69 01 ADD 0F6A 90 SWAP1 0F6B 91 SWAP2 0F6C 52 MSTORE 0F6D 60 PUSH1 0x07 0F6F 81 DUP2 0F70 52 MSTORE 0F71 66 PUSH7 0x2e63727970746f 0F79 60 PUSH1 0xc8 0F7B 1B SHL 0F7C 60 PUSH1 0x20 0F7E 82 DUP3 0F7F 01 ADD 0F80 52 MSTORE 0F81 5B JUMPDEST 0F82 90 SWAP1 0F83 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0F6C memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0F70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x07 // @0F80 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x2e63727970746f << 0xc8 // @0F82 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_0F84: // Incoming jump from 0x0416 // Incoming call from 0x1B66, returns to 0x1B67 // Inputs[1] { @0F8A stack[-1] } 0F84 5B JUMPDEST 0F85 60 PUSH1 0x00 0F87 61 PUSH2 0x0f8f 0F8A 82 DUP3 0F8B 61 PUSH2 0x1ac9 0F8E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F85 stack[0] = 0x00 // @0F87 stack[1] = 0x0f8f // @0F8A stack[2] = stack[-1] // } // Block ends with call to 0x1ac9, returns to 0x0F8F label_0F8F: // Incoming return from call to 0x1AC9 at 0x0F8E // Inputs[1] { @0F93 stack[-1] } 0F8F 5B JUMPDEST 0F90 61 PUSH2 0x0fca 0F93 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fca, if stack[-1] label_0F94: // Incoming jump from 0x0F93, if not stack[-1] // Inputs[3] // { // @0F96 memory[0x40:0x60] // @0FC4 memory[0x40:0x60] // @0FC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F94 60 PUSH1 0x40 0F96 51 MLOAD 0F97 62 PUSH3 0x461bcd 0F9B 60 PUSH1 0xe5 0F9D 1B SHL 0F9E 81 DUP2 0F9F 52 MSTORE 0FA0 60 PUSH1 0x04 0FA2 01 ADD 0FA3 80 DUP1 0FA4 80 DUP1 0FA5 60 PUSH1 0x20 0FA7 01 ADD 0FA8 82 DUP3 0FA9 81 DUP2 0FAA 03 SUB 0FAB 82 DUP3 0FAC 52 MSTORE 0FAD 60 PUSH1 0x2c 0FAF 81 DUP2 0FB0 52 MSTORE 0FB1 60 PUSH1 0x20 0FB3 01 ADD 0FB4 80 DUP1 0FB5 61 PUSH2 0x2848 0FB8 60 PUSH1 0x2c 0FBA 91 SWAP2 0FBB 39 CODECOPY 0FBC 60 PUSH1 0x40 0FBE 01 ADD 0FBF 91 SWAP2 0FC0 50 POP 0FC1 50 POP 0FC2 60 PUSH1 0x40 0FC4 51 MLOAD 0FC5 80 DUP1 0FC6 91 SWAP2 0FC7 03 SUB 0FC8 90 SWAP1 0FC9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FAC memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0FB0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @0FBB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x2848:0x2874] // @0FC9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FCA: // Incoming jump from 0x0F93, if stack[-1] // Inputs[4] // { // @0FCE stack[-2] // @0FD9 memory[0x00:0x40] // @0FDA storage[keccak256(memory[0x00:0x40])] // @0FE4 stack[-3] // } 0FCA 5B JUMPDEST 0FCB 50 POP 0FCC 60 PUSH1 0x00 0FCE 90 SWAP1 0FCF 81 DUP2 0FD0 52 MSTORE 0FD1 60 PUSH1 0x03 0FD3 60 PUSH1 0x20 0FD5 52 MSTORE 0FD6 60 PUSH1 0x40 0FD8 90 SWAP1 0FD9 20 SHA3 0FDA 54 SLOAD 0FDB 60 PUSH1 0x01 0FDD 60 PUSH1 0x01 0FDF 60 PUSH1 0xa0 0FE1 1B SHL 0FE2 03 SUB 0FE3 16 AND 0FE4 90 SWAP1 0FE5 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0FD0 memory[0x00:0x20] = stack[-2] // @0FD5 memory[0x20:0x40] = 0x03 // @0FE4 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0FE6: // Incoming jump from 0x045E // Inputs[1] { @0FEC stack[-1] } 0FE6 5B JUMPDEST 0FE7 60 PUSH1 0x00 0FE9 61 PUSH2 0x0ff1 0FEC 82 DUP3 0FED 61 PUSH2 0x1320 0FF0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FE7 stack[0] = 0x00 // @0FE9 stack[1] = 0x0ff1 // @0FEC stack[2] = stack[-1] // } // Block ends with call to 0x1320, returns to 0x0FF1 label_0FF1: // Incoming return from call to 0x1320 at 0x0FF0 // Inputs[3] // { // @0FF2 stack[-2] // @0FF2 stack[-1] // @0FFE stack[-4] // } 0FF1 5B JUMPDEST 0FF2 90 SWAP1 0FF3 50 POP 0FF4 80 DUP1 0FF5 60 PUSH1 0x01 0FF7 60 PUSH1 0x01 0FF9 60 PUSH1 0xa0 0FFB 1B SHL 0FFC 03 SUB 0FFD 16 AND 0FFE 83 DUP4 0FFF 60 PUSH1 0x01 1001 60 PUSH1 0x01 1003 60 PUSH1 0xa0 1005 1B SHL 1006 03 SUB 1007 16 AND 1008 14 EQ 1009 15 ISZERO 100A 61 PUSH2 0x1044 100D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0FF2 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1044, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_100E: // Incoming jump from 0x100D, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @1010 memory[0x40:0x60] // @103E memory[0x40:0x60] // @1043 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 100E 60 PUSH1 0x40 1010 51 MLOAD 1011 62 PUSH3 0x461bcd 1015 60 PUSH1 0xe5 1017 1B SHL 1018 81 DUP2 1019 52 MSTORE 101A 60 PUSH1 0x04 101C 01 ADD 101D 80 DUP1 101E 80 DUP1 101F 60 PUSH1 0x20 1021 01 ADD 1022 82 DUP3 1023 81 DUP2 1024 03 SUB 1025 82 DUP3 1026 52 MSTORE 1027 60 PUSH1 0x21 1029 81 DUP2 102A 52 MSTORE 102B 60 PUSH1 0x20 102D 01 ADD 102E 80 DUP1 102F 61 PUSH2 0x28bf 1032 60 PUSH1 0x21 1034 91 SWAP2 1035 39 CODECOPY 1036 60 PUSH1 0x40 1038 01 ADD 1039 91 SWAP2 103A 50 POP 103B 50 POP 103C 60 PUSH1 0x40 103E 51 MLOAD 103F 80 DUP1 1040 91 SWAP2 1041 03 SUB 1042 90 SWAP1 1043 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1019 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1026 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @102A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @1035 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x28bf:0x28e0] // @1043 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1044: // Incoming jump from 0x100D, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @1045 msg.sender // @104E stack[-1] // } 1044 5B JUMPDEST 1045 33 CALLER 1046 60 PUSH1 0x01 1048 60 PUSH1 0x01 104A 60 PUSH1 0xa0 104C 1B SHL 104D 03 SUB 104E 82 DUP3 104F 16 AND 1050 14 EQ 1051 80 DUP1 1052 61 PUSH2 0x1060 1055 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1050 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x1060, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_1056: // Incoming jump from 0x1055, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @105A stack[-2] // @105B msg.sender // } 1056 50 POP 1057 61 PUSH2 0x1060 105A 81 DUP2 105B 33 CALLER 105C 61 PUSH2 0x1a05 105F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1057 stack[-1] = 0x1060 // @105A stack[0] = stack[-2] // @105B stack[1] = msg.sender // } // Block ends with call to 0x1a05, returns to 0x1060 label_1060: // Incoming return from call to 0x1A05 at 0x105F // Incoming jump from 0x1055, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @1064 stack[-1] } 1060 5B JUMPDEST 1061 61 PUSH2 0x109b 1064 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x109b, if stack[-1] label_1065: // Incoming jump from 0x1064, if not stack[-1] // Inputs[3] // { // @1067 memory[0x40:0x60] // @1095 memory[0x40:0x60] // @109A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1065 60 PUSH1 0x40 1067 51 MLOAD 1068 62 PUSH3 0x461bcd 106C 60 PUSH1 0xe5 106E 1B SHL 106F 81 DUP2 1070 52 MSTORE 1071 60 PUSH1 0x04 1073 01 ADD 1074 80 DUP1 1075 80 DUP1 1076 60 PUSH1 0x20 1078 01 ADD 1079 82 DUP3 107A 81 DUP2 107B 03 SUB 107C 82 DUP3 107D 52 MSTORE 107E 60 PUSH1 0x38 1080 81 DUP2 1081 52 MSTORE 1082 60 PUSH1 0x20 1084 01 ADD 1085 80 DUP1 1086 61 PUSH2 0x279c 1089 60 PUSH1 0x38 108B 91 SWAP2 108C 39 CODECOPY 108D 60 PUSH1 0x40 108F 01 ADD 1090 91 SWAP2 1091 50 POP 1092 50 POP 1093 60 PUSH1 0x40 1095 51 MLOAD 1096 80 DUP1 1097 91 SWAP2 1098 03 SUB 1099 90 SWAP1 109A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1070 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @107D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1081 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x38 // @108C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x38] = code[0x279c:0x27d4] // @109A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_109B: // Incoming jump from 0x1064, if stack[-1] // Inputs[8] // { // @109E stack[-2] // @10AA memory[0x00:0x40] // @10AC storage[keccak256(memory[0x00:0x40])] // @10BF stack[-3] // @10C9 memory[0x40:0x60] // @10CD stack[-1] // @10F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @10F6 stack[-4] // } 109B 5B JUMPDEST 109C 60 PUSH1 0x00 109E 82 DUP3 109F 81 DUP2 10A0 52 MSTORE 10A1 60 PUSH1 0x03 10A3 60 PUSH1 0x20 10A5 52 MSTORE 10A6 60 PUSH1 0x40 10A8 80 DUP1 10A9 82 DUP3 10AA 20 SHA3 10AB 80 DUP1 10AC 54 SLOAD 10AD 60 PUSH1 0x01 10AF 60 PUSH1 0x01 10B1 60 PUSH1 0xa0 10B3 1B SHL 10B4 03 SUB 10B5 19 NOT 10B6 16 AND 10B7 60 PUSH1 0x01 10B9 60 PUSH1 0x01 10BB 60 PUSH1 0xa0 10BD 1B SHL 10BE 03 SUB 10BF 87 DUP8 10C0 81 DUP2 10C1 16 AND 10C2 91 SWAP2 10C3 82 DUP3 10C4 17 OR 10C5 90 SWAP1 10C6 92 SWAP3 10C7 55 SSTORE 10C8 91 SWAP2 10C9 51 MLOAD 10CA 85 DUP6 10CB 93 SWAP4 10CC 91 SWAP2 10CD 85 DUP6 10CE 16 AND 10CF 91 SWAP2 10D0 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 10F1 91 SWAP2 10F2 A4 LOG4 10F3 50 POP 10F4 50 POP 10F5 50 POP 10F6 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @10A0 memory[0x00:0x20] = stack[-2] // @10A5 memory[0x20:0x40] = 0x03 // @10C7 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @10F2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_10F7: // Incoming jump from 0x048A // Inputs[2] // { // @10F8 stack[-1] // @10FC msg.sender // } 10F7 5B JUMPDEST 10F8 80 DUP1 10F9 61 PUSH2 0x1102 10FC 33 CALLER 10FD 82 DUP3 10FE 61 PUSH2 0x1ae6 1101 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10F8 stack[0] = stack[-1] // @10F9 stack[1] = 0x1102 // @10FC stack[2] = msg.sender // @10FD stack[3] = stack[-1] // } // Block ends with call to 0x1ae6, returns to 0x1102 label_1102: // Incoming return from call to 0x1AE6 at 0x1101 // Inputs[1] { @1106 stack[-1] } 1102 5B JUMPDEST 1103 61 PUSH2 0x110b 1106 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x110b, if stack[-1] label_1107: // Incoming jump from 0x1106, if not stack[-1] // Inputs[1] { @110A memory[0x00:0x00] } 1107 60 PUSH1 0x00 1109 80 DUP1 110A FD *REVERT // Stack delta = +0 // Outputs[1] { @110A revert(memory[0x00:0x00]); } // Block terminates label_110B: // Incoming jump from 0x1106, if stack[-1] // Inputs[2] // { // @110F stack[-3] // @1110 stack[-2] // } 110B 5B JUMPDEST 110C 61 PUSH2 0x0ece 110F 83 DUP4 1110 83 DUP4 1111 61 PUSH2 0x1b82 1114 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @110C stack[0] = 0x0ece // @110F stack[1] = stack[-3] // @1110 stack[2] = stack[-2] // } // Block ends with call to 0x1b82, returns to 0x0ECE label_1115: // Incoming jump from 0x1704 // Incoming jump from 0x04C0 // Inputs[2] // { // @1119 msg.sender // @111A stack[-1] // } 1115 5B JUMPDEST 1116 61 PUSH2 0x111f 1119 33 CALLER 111A 82 DUP3 111B 61 PUSH2 0x1ae6 111E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1116 stack[0] = 0x111f // @1119 stack[1] = msg.sender // @111A stack[2] = stack[-1] // } // Block ends with call to 0x1ae6, returns to 0x111F label_111F: // Incoming return from call to 0x1AE6 at 0x111E // Inputs[1] { @1123 stack[-1] } 111F 5B JUMPDEST 1120 61 PUSH2 0x0ec3 1123 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ec3, if stack[-1] label_1124: // Incoming jump from 0x1123, if not stack[-1] // Inputs[3] // { // @1126 memory[0x40:0x60] // @1154 memory[0x40:0x60] // @1159 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1124 60 PUSH1 0x40 1126 51 MLOAD 1127 62 PUSH3 0x461bcd 112B 60 PUSH1 0xe5 112D 1B SHL 112E 81 DUP2 112F 52 MSTORE 1130 60 PUSH1 0x04 1132 01 ADD 1133 80 DUP1 1134 80 DUP1 1135 60 PUSH1 0x20 1137 01 ADD 1138 82 DUP3 1139 81 DUP2 113A 03 SUB 113B 82 DUP3 113C 52 MSTORE 113D 60 PUSH1 0x31 113F 81 DUP2 1140 52 MSTORE 1141 60 PUSH1 0x20 1143 01 ADD 1144 80 DUP1 1145 61 PUSH2 0x28e0 1148 60 PUSH1 0x31 114A 91 SWAP2 114B 39 CODECOPY 114C 60 PUSH1 0x40 114E 01 ADD 114F 91 SWAP2 1150 50 POP 1151 50 POP 1152 60 PUSH1 0x40 1154 51 MLOAD 1155 80 DUP1 1156 91 SWAP2 1157 03 SUB 1158 90 SWAP1 1159 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @112F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @113C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1140 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @114B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x28e0:0x2911] // @1159 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_115A: // Incoming jump from 0x04EC // Inputs[1] { @115E msg.sender } 115A 5B JUMPDEST 115B 61 PUSH2 0x1163 115E 33 CALLER 115F 61 PUSH2 0x1694 1162 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @115B stack[0] = 0x1163 // @115E stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 1163 5B JUMPDEST 1164 61 PUSH2 0x116c 1167 57 *JUMPI 1168 60 PUSH1 0x00 116A 80 DUP1 116B FD *REVERT 116C 5B JUMPDEST 116D 61 PUSH2 0x1176 1170 82 DUP3 1171 82 DUP3 1172 61 PUSH2 0x1b82 1175 56 *JUMP 1176 5B JUMPDEST 1177 50 POP 1178 50 POP 1179 56 *JUMP label_117A: // Incoming jump from 0x0522 // Inputs[4] // { // @117E stack[-3] // @117F stack[-2] // @1180 stack[-1] // @1183 memory[0x40:0x60] // } 117A 5B JUMPDEST 117B 61 PUSH2 0x0ece 117E 83 DUP4 117F 83 DUP4 1180 83 DUP4 1181 60 PUSH1 0x40 1183 51 MLOAD 1184 80 DUP1 1185 60 PUSH1 0x20 1187 01 ADD 1188 60 PUSH1 0x40 118A 52 MSTORE 118B 80 DUP1 118C 60 PUSH1 0x00 118E 81 DUP2 118F 52 MSTORE 1190 50 POP 1191 61 PUSH2 0x16fa 1194 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @117B stack[0] = 0x0ece // @117E stack[1] = stack[-3] // @117F stack[2] = stack[-2] // @1180 stack[3] = stack[-1] // @1183 stack[4] = memory[0x40:0x60] // @118A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @118F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x16fa label_1195: // Incoming jump from 0x053F // Inputs[2] // { // @1199 msg.sender // @119A stack[-1] // } 1195 5B JUMPDEST 1196 61 PUSH2 0x119f 1199 33 CALLER 119A 82 DUP3 119B 61 PUSH2 0x1ae6 119E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1196 stack[0] = 0x119f // @1199 stack[1] = msg.sender // @119A stack[2] = stack[-1] // } // Block ends with call to 0x1ae6, returns to 0x119F label_119F: // Incoming return from call to 0x1AE6 at 0x119E // Inputs[1] { @11A3 stack[-1] } 119F 5B JUMPDEST 11A0 61 PUSH2 0x11da 11A3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11da, if stack[-1] label_11A4: // Incoming jump from 0x11A3, if not stack[-1] // Inputs[3] // { // @11A6 memory[0x40:0x60] // @11D4 memory[0x40:0x60] // @11D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11A4 60 PUSH1 0x40 11A6 51 MLOAD 11A7 62 PUSH3 0x461bcd 11AB 60 PUSH1 0xe5 11AD 1B SHL 11AE 81 DUP2 11AF 52 MSTORE 11B0 60 PUSH1 0x04 11B2 01 ADD 11B3 80 DUP1 11B4 80 DUP1 11B5 60 PUSH1 0x20 11B7 01 ADD 11B8 82 DUP3 11B9 81 DUP2 11BA 03 SUB 11BB 82 DUP3 11BC 52 MSTORE 11BD 60 PUSH1 0x30 11BF 81 DUP2 11C0 52 MSTORE 11C1 60 PUSH1 0x20 11C3 01 ADD 11C4 80 DUP1 11C5 61 PUSH2 0x2936 11C8 60 PUSH1 0x30 11CA 91 SWAP2 11CB 39 CODECOPY 11CC 60 PUSH1 0x40 11CE 01 ADD 11CF 91 SWAP2 11D0 50 POP 11D1 50 POP 11D2 60 PUSH1 0x40 11D4 51 MLOAD 11D5 80 DUP1 11D6 91 SWAP2 11D7 03 SUB 11D8 90 SWAP1 11D9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @11AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11BC memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @11C0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x30 // @11CB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x30] = code[0x2936:0x2966] // @11D9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_11DA: // Incoming jump from 0x11A3, if stack[-1] // Inputs[1] { @11DE stack[-1] } 11DA 5B JUMPDEST 11DB 61 PUSH2 0x11e3 11DE 81 DUP2 11DF 61 PUSH2 0x1bf8 11E2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11DB stack[0] = 0x11e3 // @11DE stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1bf8 label_11E3: // Incoming return from call to 0x2227 at 0x1E74 // Incoming return from call to 0x221B at 0x221A // Incoming jump from 0x232C, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @11E5 stack[-2] } 11E3 5B JUMPDEST 11E4 50 POP 11E5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_11E6: // Incoming jump from 0x056B // Inputs[2] // { // @11EC stack[-2] // @11ED stack[-1] // } 11E6 5B JUMPDEST 11E7 60 PUSH1 0x00 11E9 61 PUSH2 0x11f2 11EC 83 DUP4 11ED 83 DUP4 11EE 61 PUSH2 0x1ae6 11F1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11E7 stack[0] = 0x00 // @11E9 stack[1] = 0x11f2 // @11EC stack[2] = stack[-2] // @11ED stack[3] = stack[-1] // } // Block ends with call to 0x1ae6, returns to 0x11F2 label_11F2: // Incoming return from call to 0x1AE6 at 0x11F1 // Inputs[3] // { // @11F3 stack[-5] // @11F3 stack[-1] // @11F4 stack[-4] // } 11F2 5B JUMPDEST 11F3 93 SWAP4 11F4 92 SWAP3 11F5 50 POP 11F6 50 POP 11F7 50 POP 11F8 56 *JUMP // Stack delta = -4 // Outputs[1] { @11F3 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_11F9: // Incoming jump from 0x058E // Inputs[4] // { // @11FC stack[-2] // @1207 memory[0x00:0x40] // @1208 storage[keccak256(memory[0x00:0x40])] // @1212 msg.sender // } 11F9 5B JUMPDEST 11FA 60 PUSH1 0x00 11FC 82 DUP3 11FD 81 DUP2 11FE 52 MSTORE 11FF 60 PUSH1 0x08 1201 60 PUSH1 0x20 1203 52 MSTORE 1204 60 PUSH1 0x40 1206 90 SWAP1 1207 20 SHA3 1208 54 SLOAD 1209 60 PUSH1 0x01 120B 60 PUSH1 0x01 120D 60 PUSH1 0xa0 120F 1B SHL 1210 03 SUB 1211 16 AND 1212 33 CALLER 1213 14 EQ 1214 61 PUSH2 0x121c 1217 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @11FE memory[0x00:0x20] = stack[-2] // @1203 memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x121c, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1218: // Incoming jump from 0x1217, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @121B memory[0x00:0x00] } 1218 60 PUSH1 0x00 121A 80 DUP1 121B FD *REVERT // Stack delta = +0 // Outputs[1] { @121B revert(memory[0x00:0x00]); } // Block terminates label_121C: // Incoming jump from 0x1217, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @121F memory[0x40:0x60] // @1220 stack[-2] // @1222 stack[-1] // @1224 msg.sender // @124B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @124E stack[-3] // } 121C 5B JUMPDEST 121D 60 PUSH1 0x40 121F 51 MLOAD 1220 82 DUP3 1221 90 SWAP1 1222 82 DUP3 1223 90 SWAP1 1224 33 CALLER 1225 90 SWAP1 1226 7F PUSH32 0xf10fc780c78f994a214c79a2ae8d8b7bfe7cc3f0f935a8f05a29525e71d7f127 1247 90 SWAP1 1248 60 PUSH1 0x00 124A 90 SWAP1 124B A4 LOG4 124C 50 POP 124D 50 POP 124E 56 *JUMP // Stack delta = -3 // Outputs[1] { @124B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xf10fc780c78f994a214c79a2ae8d8b7bfe7cc3f0f935a8f05a29525e71d7f127, msg.sender, stack[-1], stack[-2]]); } // Block ends with unconditional jump to stack[-3] label_124F: // Incoming jump from 0x061C // Inputs[1] { @1253 msg.sender } 124F 5B JUMPDEST 1250 61 PUSH2 0x1258 1253 33 CALLER 1254 61 PUSH2 0x1694 1257 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1250 stack[0] = 0x1258 // @1253 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 1258 5B JUMPDEST 1259 61 PUSH2 0x1261 125C 57 *JUMPI 125D 60 PUSH1 0x00 125F 80 DUP1 1260 FD *REVERT 1261 5B JUMPDEST 1262 61 PUSH2 0x126c 1265 85 DUP6 1266 85 DUP6 1267 85 DUP6 1268 61 PUSH2 0x1a57 126B 56 *JUMP 126C 5B JUMPDEST 126D 61 PUSH2 0x12ae 1270 85 DUP6 1271 85 DUP6 1272 85 DUP6 1273 85 DUP6 1274 85 DUP6 1275 80 DUP1 1276 80 DUP1 1277 60 PUSH1 0x1f 1279 01 ADD 127A 60 PUSH1 0x20 127C 80 DUP1 127D 91 SWAP2 127E 04 DIV 127F 02 MUL 1280 60 PUSH1 0x20 1282 01 ADD 1283 60 PUSH1 0x40 1285 51 MLOAD 1286 90 SWAP1 1287 81 DUP2 1288 01 ADD 1289 60 PUSH1 0x40 128B 52 MSTORE 128C 80 DUP1 128D 93 SWAP4 128E 92 SWAP3 128F 91 SWAP2 1290 90 SWAP1 1291 81 DUP2 1292 81 DUP2 1293 52 MSTORE 1294 60 PUSH1 0x20 1296 01 ADD 1297 83 DUP4 1298 83 DUP4 1299 80 DUP1 129A 82 DUP3 129B 84 DUP5 129C 37 CALLDATACOPY 129D 60 PUSH1 0x00 129F 92 SWAP3 12A0 01 ADD 12A1 91 SWAP2 12A2 90 SWAP1 12A3 91 SWAP2 12A4 52 MSTORE 12A5 50 POP 12A6 61 PUSH2 0x1c79 12A9 92 SWAP3 12AA 50 POP 12AB 50 POP 12AC 50 POP 12AD 56 *JUMP 12AE 5B JUMPDEST 12AF 61 PUSH2 0x12b7 12B2 57 *JUMPI 12B3 60 PUSH1 0x00 12B5 80 DUP1 12B6 FD *REVERT label_12B7: // Incoming return from call to 0x174C at 0x1505 // Inputs[1] { @12BD stack[-6] } 12B7 5B JUMPDEST 12B8 50 POP 12B9 50 POP 12BA 50 POP 12BB 50 POP 12BC 50 POP 12BD 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_12BE: // Incoming jump from 0x0691 // Inputs[2] // { // @12BF stack[-3] // @12C3 msg.sender // } 12BE 5B JUMPDEST 12BF 82 DUP3 12C0 61 PUSH2 0x12c9 12C3 33 CALLER 12C4 82 DUP3 12C5 61 PUSH2 0x1ae6 12C8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12BF stack[0] = stack[-3] // @12C0 stack[1] = 0x12c9 // @12C3 stack[2] = msg.sender // @12C4 stack[3] = stack[-3] // } // Block ends with call to 0x1ae6, returns to 0x12C9 label_12C9: // Incoming return from call to 0x1AE6 at 0x12C8 // Inputs[1] { @12CD stack[-1] } 12C9 5B JUMPDEST 12CA 61 PUSH2 0x12d2 12CD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12d2, if stack[-1] label_12CE: // Incoming jump from 0x12CD, if not stack[-1] // Inputs[1] { @12D1 memory[0x00:0x00] } 12CE 60 PUSH1 0x00 12D0 80 DUP1 12D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @12D1 revert(memory[0x00:0x00]); } // Block terminates label_12D2: // Incoming jump from 0x12CD, if stack[-1] // Inputs[5] // { // @12D9 stack[-4] // @12DA stack[-3] // @12DB stack[-2] // @12EC memory[0x40:0x60] // @1303 msg.data[stack[-3]:stack[-3] + stack[-2]] // } 12D2 5B JUMPDEST 12D3 61 PUSH2 0x131a 12D6 61 PUSH2 0x1315 12D9 85 DUP6 12DA 85 DUP6 12DB 85 DUP6 12DC 80 DUP1 12DD 80 DUP1 12DE 60 PUSH1 0x1f 12E0 01 ADD 12E1 60 PUSH1 0x20 12E3 80 DUP1 12E4 91 SWAP2 12E5 04 DIV 12E6 02 MUL 12E7 60 PUSH1 0x20 12E9 01 ADD 12EA 60 PUSH1 0x40 12EC 51 MLOAD 12ED 90 SWAP1 12EE 81 DUP2 12EF 01 ADD 12F0 60 PUSH1 0x40 12F2 52 MSTORE 12F3 80 DUP1 12F4 93 SWAP4 12F5 92 SWAP3 12F6 91 SWAP2 12F7 90 SWAP1 12F8 81 DUP2 12F9 81 DUP2 12FA 52 MSTORE 12FB 60 PUSH1 0x20 12FD 01 ADD 12FE 83 DUP4 12FF 83 DUP4 1300 80 DUP1 1301 82 DUP3 1302 84 DUP5 1303 37 CALLDATACOPY 1304 60 PUSH1 0x00 1306 92 SWAP3 1307 01 ADD 1308 91 SWAP2 1309 90 SWAP1 130A 91 SWAP2 130B 52 MSTORE 130C 50 POP 130D 61 PUSH2 0x1dac 1310 92 SWAP3 1311 50 POP 1312 50 POP 1313 50 POP 1314 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @12D3 stack[0] = 0x131a // @12D6 stack[1] = 0x1315 // @12D9 stack[2] = stack[-4] // @12F2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @12F4 stack[3] = memory[0x40:0x60] // @12FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1303 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @130B memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // } // Block ends with call to 0x1dac, returns to 0x1315 label_1315: // Incoming return from call to 0x1DAC at 0x1314 1315 5B JUMPDEST 1316 61 PUSH2 0x1bf8 1319 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1bf8 131A 5B JUMPDEST 131B 50 POP 131C 50 POP 131D 50 POP 131E 50 POP 131F 56 *JUMP label_1320: // Incoming call from 0x24AD, returns to 0x24AE // Incoming jump from 0x06AE // Incoming call from 0x1B36, returns to 0x1B37 // Incoming call from 0x0FF0, returns to 0x0FF1 // Incoming call from 0x166A, returns to 0x166B // Incoming call from 0x1E9C, returns to 0x1E9D // Incoming call from 0x221A, returns to 0x221B // Inputs[3] // { // @1323 stack[-1] // @132E memory[0x00:0x40] // @132F storage[keccak256(memory[0x00:0x40])] // } 1320 5B JUMPDEST 1321 60 PUSH1 0x00 1323 81 DUP2 1324 81 DUP2 1325 52 MSTORE 1326 60 PUSH1 0x02 1328 60 PUSH1 0x20 132A 52 MSTORE 132B 60 PUSH1 0x40 132D 81 DUP2 132E 20 SHA3 132F 54 SLOAD 1330 60 PUSH1 0x01 1332 60 PUSH1 0x01 1334 60 PUSH1 0xa0 1336 1B SHL 1337 03 SUB 1338 16 AND 1339 80 DUP1 133A 61 PUSH2 0x1374 133D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1321 stack[0] = 0x00 // @1325 memory[0x00:0x20] = stack[-1] // @132A memory[0x20:0x40] = 0x02 // @1338 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1374, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_133E: // Incoming jump from 0x133D, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @1340 memory[0x40:0x60] // @136E memory[0x40:0x60] // @1373 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 133E 60 PUSH1 0x40 1340 51 MLOAD 1341 62 PUSH3 0x461bcd 1345 60 PUSH1 0xe5 1347 1B SHL 1348 81 DUP2 1349 52 MSTORE 134A 60 PUSH1 0x04 134C 01 ADD 134D 80 DUP1 134E 80 DUP1 134F 60 PUSH1 0x20 1351 01 ADD 1352 82 DUP3 1353 81 DUP2 1354 03 SUB 1355 82 DUP3 1356 52 MSTORE 1357 60 PUSH1 0x29 1359 81 DUP2 135A 52 MSTORE 135B 60 PUSH1 0x20 135D 01 ADD 135E 80 DUP1 135F 61 PUSH2 0x27fe 1362 60 PUSH1 0x29 1364 91 SWAP2 1365 39 CODECOPY 1366 60 PUSH1 0x40 1368 01 ADD 1369 91 SWAP2 136A 50 POP 136B 50 POP 136C 60 PUSH1 0x40 136E 51 MLOAD 136F 80 DUP1 1370 91 SWAP2 1371 03 SUB 1372 90 SWAP1 1373 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1349 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1356 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @135A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @1365 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x27fe:0x2827] // @1373 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1374: // Incoming jump from 0x168F, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming return from call to 0x1E75 at 0x1436 // Incoming return from call to 0x1FCE at 0x16A6 // Incoming jump from 0x133D, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @1375 stack[-4] // @1375 stack[-1] // @1376 stack[-3] // } 1374 5B JUMPDEST 1375 92 SWAP3 1376 91 SWAP2 1377 50 POP 1378 50 POP 1379 56 *JUMP // Stack delta = -3 // Outputs[1] { @1375 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_137A: // Incoming call from 0x06B6, returns to 0x02A8 // Inputs[1] { @137E msg.sender } 137A 5B JUMPDEST 137B 61 PUSH2 0x1383 137E 33 CALLER 137F 61 PUSH2 0x1e64 1382 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @137B stack[0] = 0x1383 // @137E stack[1] = msg.sender // } // Block ends with call to 0x1e64, returns to 0x1383 label_1383: // Incoming return from call to 0x1E64 at 0x1382 // Inputs[1] { @1384 stack[-1] } 1383 5B JUMPDEST 1384 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_1385: // Incoming jump from 0x072B // Inputs[5] // { // @138B stack[-3] // @138C stack[-2] // @138D stack[-1] // @139E memory[0x40:0x60] // @13B5 msg.data[stack[-2]:stack[-2] + stack[-1]] // } 1385 5B JUMPDEST 1386 60 PUSH1 0x00 1388 61 PUSH2 0x13c7 138B 84 DUP5 138C 84 DUP5 138D 84 DUP5 138E 80 DUP1 138F 80 DUP1 1390 60 PUSH1 0x1f 1392 01 ADD 1393 60 PUSH1 0x20 1395 80 DUP1 1396 91 SWAP2 1397 04 DIV 1398 02 MUL 1399 60 PUSH1 0x20 139B 01 ADD 139C 60 PUSH1 0x40 139E 51 MLOAD 139F 90 SWAP1 13A0 81 DUP2 13A1 01 ADD 13A2 60 PUSH1 0x40 13A4 52 MSTORE 13A5 80 DUP1 13A6 93 SWAP4 13A7 92 SWAP3 13A8 91 SWAP2 13A9 90 SWAP1 13AA 81 DUP2 13AB 81 DUP2 13AC 52 MSTORE 13AD 60 PUSH1 0x20 13AF 01 ADD 13B0 83 DUP4 13B1 83 DUP4 13B2 80 DUP1 13B3 82 DUP3 13B4 84 DUP5 13B5 37 CALLDATACOPY 13B6 60 PUSH1 0x00 13B8 92 SWAP3 13B9 01 ADD 13BA 91 SWAP2 13BB 90 SWAP1 13BC 91 SWAP2 13BD 52 MSTORE 13BE 50 POP 13BF 61 PUSH2 0x1dac 13C2 92 SWAP3 13C3 50 POP 13C4 50 POP 13C5 50 POP 13C6 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1386 stack[0] = 0x00 // @1388 stack[1] = 0x13c7 // @138B stack[2] = stack[-3] // @13A4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @13A6 stack[3] = memory[0x40:0x60] // @13AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @13B5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @13BD memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // } // Block ends with call to 0x1dac, returns to 0x13C7 label_13C7: // Incoming jump from 0x1B77, if stack[-1] // Incoming return from call to 0x1A05 at 0x1B81 // Incoming jump from 0x1C98 // Incoming return from call to 0x1DAC at 0x13C6 // Inputs[3] // { // @13C8 stack[-1] // @13C8 stack[-6] // @13C9 stack[-5] // } 13C7 5B JUMPDEST 13C8 94 SWAP5 13C9 93 SWAP4 13CA 50 POP 13CB 50 POP 13CC 50 POP 13CD 50 POP 13CE 56 *JUMP // Stack delta = -5 // Outputs[1] { @13C8 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_13CF: // Incoming jump from 0x0763 // Inputs[1] { @13DA stack[-1] } 13CF 5B JUMPDEST 13D0 60 PUSH1 0x00 13D2 60 PUSH1 0x01 13D4 60 PUSH1 0x01 13D6 60 PUSH1 0xa0 13D8 1B SHL 13D9 03 SUB 13DA 82 DUP3 13DB 16 AND 13DC 61 PUSH2 0x1416 13DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x1416, if stack[-1] & (0x01 << 0xa0) - 0x01 label_13E0: // Incoming jump from 0x13DF, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @13E2 memory[0x40:0x60] // @1410 memory[0x40:0x60] // @1415 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 13E0 60 PUSH1 0x40 13E2 51 MLOAD 13E3 62 PUSH3 0x461bcd 13E7 60 PUSH1 0xe5 13E9 1B SHL 13EA 81 DUP2 13EB 52 MSTORE 13EC 60 PUSH1 0x04 13EE 01 ADD 13EF 80 DUP1 13F0 80 DUP1 13F1 60 PUSH1 0x20 13F3 01 ADD 13F4 82 DUP3 13F5 81 DUP2 13F6 03 SUB 13F7 82 DUP3 13F8 52 MSTORE 13F9 60 PUSH1 0x2a 13FB 81 DUP2 13FC 52 MSTORE 13FD 60 PUSH1 0x20 13FF 01 ADD 1400 80 DUP1 1401 61 PUSH2 0x27d4 1404 60 PUSH1 0x2a 1406 91 SWAP2 1407 39 CODECOPY 1408 60 PUSH1 0x40 140A 01 ADD 140B 91 SWAP2 140C 50 POP 140D 50 POP 140E 60 PUSH1 0x40 1410 51 MLOAD 1411 80 DUP1 1412 91 SWAP2 1413 03 SUB 1414 90 SWAP1 1415 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13F8 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @13FC memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @1407 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x27d4:0x27fe] // @1415 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1416: // Incoming jump from 0x13DF, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @141F stack[-2] // @142E memory[0x00:0x40] // } 1416 5B JUMPDEST 1417 60 PUSH1 0x01 1419 60 PUSH1 0x01 141B 60 PUSH1 0xa0 141D 1B SHL 141E 03 SUB 141F 82 DUP3 1420 16 AND 1421 60 PUSH1 0x00 1423 90 SWAP1 1424 81 DUP2 1425 52 MSTORE 1426 60 PUSH1 0x04 1428 60 PUSH1 0x20 142A 52 MSTORE 142B 60 PUSH1 0x40 142D 90 SWAP1 142E 20 SHA3 142F 61 PUSH2 0x1374 1432 90 SWAP1 1433 61 PUSH2 0x1e75 1436 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1425 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @142A memory[0x20:0x40] = 0x04 // @1432 stack[0] = 0x1374 // @1432 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x1e75, returns to 0x1374 label_1437: // Incoming jump from 0x07E6 // Inputs[2] // { // @1438 stack[-3] // @143C msg.sender // } 1437 5B JUMPDEST 1438 82 DUP3 1439 61 PUSH2 0x1442 143C 33 CALLER 143D 82 DUP3 143E 61 PUSH2 0x1ae6 1441 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1438 stack[0] = stack[-3] // @1439 stack[1] = 0x1442 // @143C stack[2] = msg.sender // @143D stack[3] = stack[-3] // } // Block ends with call to 0x1ae6, returns to 0x1442 label_1442: // Incoming return from call to 0x1AE6 at 0x1441 // Inputs[1] { @1446 stack[-1] } 1442 5B JUMPDEST 1443 61 PUSH2 0x144b 1446 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x144b, if stack[-1] label_1447: // Incoming jump from 0x1446, if not stack[-1] // Inputs[1] { @144A memory[0x00:0x00] } 1447 60 PUSH1 0x00 1449 80 DUP1 144A FD *REVERT // Stack delta = +0 // Outputs[1] { @144A revert(memory[0x00:0x00]); } // Block terminates label_144B: // Incoming jump from 0x1446, if stack[-1] // Inputs[7] // { // @144F stack[-5] // @1450 stack[-4] // @1451 stack[-3] // @1452 stack[-2] // @1463 memory[0x40:0x60] // @147A msg.data[stack[-3]:stack[-3] + stack[-2]] // @1486 memory[0x40:0x60] // } 144B 5B JUMPDEST 144C 61 PUSH2 0x12b7 144F 85 DUP6 1450 85 DUP6 1451 85 DUP6 1452 85 DUP6 1453 80 DUP1 1454 80 DUP1 1455 60 PUSH1 0x1f 1457 01 ADD 1458 60 PUSH1 0x20 145A 80 DUP1 145B 91 SWAP2 145C 04 DIV 145D 02 MUL 145E 60 PUSH1 0x20 1460 01 ADD 1461 60 PUSH1 0x40 1463 51 MLOAD 1464 90 SWAP1 1465 81 DUP2 1466 01 ADD 1467 60 PUSH1 0x40 1469 52 MSTORE 146A 80 DUP1 146B 93 SWAP4 146C 92 SWAP3 146D 91 SWAP2 146E 90 SWAP1 146F 81 DUP2 1470 81 DUP2 1471 52 MSTORE 1472 60 PUSH1 0x20 1474 01 ADD 1475 83 DUP4 1476 83 DUP4 1477 80 DUP1 1478 82 DUP3 1479 84 DUP5 147A 37 CALLDATACOPY 147B 60 PUSH1 0x00 147D 92 SWAP3 147E 01 ADD 147F 82 DUP3 1480 90 SWAP1 1481 52 MSTORE 1482 50 POP 1483 60 PUSH1 0x40 1485 80 DUP1 1486 51 MLOAD 1487 60 PUSH1 0x20 1489 81 DUP2 148A 01 ADD 148B 90 SWAP1 148C 91 SWAP2 148D 52 MSTORE 148E 90 SWAP1 148F 81 DUP2 1490 52 MSTORE 1491 92 SWAP3 1492 50 POP 1493 61 PUSH2 0x1a9f 1496 91 SWAP2 1497 50 POP 1498 50 POP 1499 56 *JUMP // Stack delta = +5 // Outputs[11] // { // @144C stack[0] = 0x12b7 // @144F stack[1] = stack[-5] // @1450 stack[2] = stack[-4] // @1469 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @146B stack[3] = memory[0x40:0x60] // @1471 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @147A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1481 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @148D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1490 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1491 stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1a9f label_149A: // Incoming call from 0x07EE, returns to 0x0385 // Inputs[2] // { // @149E memory[0x40:0x60] // @14B4 stack[-1] // } 149A 5B JUMPDEST 149B 60 PUSH1 0x40 149D 80 DUP1 149E 51 MLOAD 149F 80 DUP1 14A0 82 DUP3 14A1 01 ADD 14A2 90 SWAP1 14A3 91 SWAP2 14A4 52 MSTORE 14A5 60 PUSH1 0x02 14A7 81 DUP2 14A8 52 MSTORE 14A9 61 PUSH2 0x1551 14AC 60 PUSH1 0xf2 14AE 1B SHL 14AF 60 PUSH1 0x20 14B1 82 DUP3 14B2 01 ADD 14B3 52 MSTORE 14B4 90 SWAP1 14B5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @14A4 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @14A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @14B3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x1551 << 0xf2 // @14B4 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_14B6: // Incoming jump from 0x087C // Inputs[8] // { // @14BA stack[-5] // @14BB stack[-4] // @14BC stack[-3] // @14BD stack[-2] // @14BE stack[-1] // @14CF memory[0x40:0x60] // @14E6 msg.data[stack[-2]:stack[-2] + stack[-1]] // @14F2 memory[0x40:0x60] // } 14B6 5B JUMPDEST 14B7 61 PUSH2 0x12b7 14BA 85 DUP6 14BB 85 DUP6 14BC 85 DUP6 14BD 85 DUP6 14BE 85 DUP6 14BF 80 DUP1 14C0 80 DUP1 14C1 60 PUSH1 0x1f 14C3 01 ADD 14C4 60 PUSH1 0x20 14C6 80 DUP1 14C7 91 SWAP2 14C8 04 DIV 14C9 02 MUL 14CA 60 PUSH1 0x20 14CC 01 ADD 14CD 60 PUSH1 0x40 14CF 51 MLOAD 14D0 90 SWAP1 14D1 81 DUP2 14D2 01 ADD 14D3 60 PUSH1 0x40 14D5 52 MSTORE 14D6 80 DUP1 14D7 93 SWAP4 14D8 92 SWAP3 14D9 91 SWAP2 14DA 90 SWAP1 14DB 81 DUP2 14DC 81 DUP2 14DD 52 MSTORE 14DE 60 PUSH1 0x20 14E0 01 ADD 14E1 83 DUP4 14E2 83 DUP4 14E3 80 DUP1 14E4 82 DUP3 14E5 84 DUP5 14E6 37 CALLDATACOPY 14E7 60 PUSH1 0x00 14E9 92 SWAP3 14EA 01 ADD 14EB 82 DUP3 14EC 90 SWAP1 14ED 52 MSTORE 14EE 50 POP 14EF 60 PUSH1 0x40 14F1 80 DUP1 14F2 51 MLOAD 14F3 60 PUSH1 0x20 14F5 81 DUP2 14F6 01 ADD 14F7 90 SWAP1 14F8 91 SWAP2 14F9 52 MSTORE 14FA 90 SWAP1 14FB 81 DUP2 14FC 52 MSTORE 14FD 92 SWAP3 14FE 50 POP 14FF 61 PUSH2 0x174c 1502 91 SWAP2 1503 50 POP 1504 50 POP 1505 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @14B7 stack[0] = 0x12b7 // @14BA stack[1] = stack[-5] // @14BB stack[2] = stack[-4] // @14BC stack[3] = stack[-3] // @14D5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @14D7 stack[4] = memory[0x40:0x60] // @14DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @14E6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @14ED memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // @14F9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @14FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @14FD stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x174c, returns to 0x12B7 label_1506: // Incoming jump from 0x090A // Inputs[2] // { // @1507 stack[-3] // @150B msg.sender // } 1506 5B JUMPDEST 1507 82 DUP3 1508 61 PUSH2 0x1511 150B 33 CALLER 150C 82 DUP3 150D 61 PUSH2 0x1ae6 1510 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1507 stack[0] = stack[-3] // @1508 stack[1] = 0x1511 // @150B stack[2] = msg.sender // @150C stack[3] = stack[-3] // } // Block ends with call to 0x1ae6, returns to 0x1511 label_1511: // Incoming return from call to 0x1AE6 at 0x1510 // Inputs[1] { @1515 stack[-1] } 1511 5B JUMPDEST 1512 61 PUSH2 0x151a 1515 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x151a, if stack[-1] label_1516: // Incoming jump from 0x1515, if not stack[-1] // Inputs[1] { @1519 memory[0x00:0x00] } 1516 60 PUSH1 0x00 1518 80 DUP1 1519 FD *REVERT // Stack delta = +0 // Outputs[1] { @1519 revert(memory[0x00:0x00]); } // Block terminates label_151A: // Incoming jump from 0x1515, if stack[-1] // Inputs[7] // { // @151E stack[-6] // @151F stack[-5] // @1523 stack[-4] // @1524 stack[-3] // @1525 stack[-2] // @1536 memory[0x40:0x60] // @154D msg.data[stack[-3]:stack[-3] + stack[-2]] // } 151A 5B JUMPDEST 151B 61 PUSH2 0x0f5a 151E 86 DUP7 151F 86 DUP7 1520 61 PUSH2 0x155f 1523 87 DUP8 1524 87 DUP8 1525 87 DUP8 1526 80 DUP1 1527 80 DUP1 1528 60 PUSH1 0x1f 152A 01 ADD 152B 60 PUSH1 0x20 152D 80 DUP1 152E 91 SWAP2 152F 04 DIV 1530 02 MUL 1531 60 PUSH1 0x20 1533 01 ADD 1534 60 PUSH1 0x40 1536 51 MLOAD 1537 90 SWAP1 1538 81 DUP2 1539 01 ADD 153A 60 PUSH1 0x40 153C 52 MSTORE 153D 80 DUP1 153E 93 SWAP4 153F 92 SWAP3 1540 91 SWAP2 1541 90 SWAP1 1542 81 DUP2 1543 81 DUP2 1544 52 MSTORE 1545 60 PUSH1 0x20 1547 01 ADD 1548 83 DUP4 1549 83 DUP4 154A 80 DUP1 154B 82 DUP3 154C 84 DUP5 154D 37 CALLDATACOPY 154E 60 PUSH1 0x00 1550 92 SWAP3 1551 01 ADD 1552 91 SWAP2 1553 90 SWAP1 1554 91 SWAP2 1555 52 MSTORE 1556 50 POP 1557 61 PUSH2 0x1dac 155A 92 SWAP3 155B 50 POP 155C 50 POP 155D 50 POP 155E 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @151B stack[0] = 0x0f5a // @151E stack[1] = stack[-6] // @151F stack[2] = stack[-5] // @1520 stack[3] = 0x155f // @1523 stack[4] = stack[-4] // @153C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @153E stack[5] = memory[0x40:0x60] // @1544 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @154D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1555 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // } // Block ends with call to 0x1dac, returns to 0x155F label_155F: // Incoming return from call to 0x1DAC at 0x155E 155F 5B JUMPDEST 1560 61 PUSH2 0x1a57 1563 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1a57 label_1564: // Incoming jump from 0x0938 // Inputs[2] // { // @156D stack[-2] // @156F msg.sender // } 1564 5B JUMPDEST 1565 60 PUSH1 0x01 1567 60 PUSH1 0x01 1569 60 PUSH1 0xa0 156B 1B SHL 156C 03 SUB 156D 82 DUP3 156E 16 AND 156F 33 CALLER 1570 14 EQ 1571 15 ISZERO 1572 61 PUSH2 0x15c2 1575 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15c2, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_1576: // Incoming jump from 0x1575, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1579 memory[0x40:0x60] // @15B8 memory[0x40:0x60] // @15C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1576 60 PUSH1 0x40 1578 80 DUP1 1579 51 MLOAD 157A 62 PUSH3 0x461bcd 157E 60 PUSH1 0xe5 1580 1B SHL 1581 81 DUP2 1582 52 MSTORE 1583 60 PUSH1 0x20 1585 60 PUSH1 0x04 1587 82 DUP3 1588 01 ADD 1589 52 MSTORE 158A 60 PUSH1 0x19 158C 60 PUSH1 0x24 158E 82 DUP3 158F 01 ADD 1590 52 MSTORE 1591 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 15B2 60 PUSH1 0x44 15B4 82 DUP3 15B5 01 ADD 15B6 52 MSTORE 15B7 90 SWAP1 15B8 51 MLOAD 15B9 90 SWAP1 15BA 81 DUP2 15BB 90 SWAP1 15BC 03 SUB 15BD 60 PUSH1 0x64 15BF 01 ADD 15C0 90 SWAP1 15C1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1582 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1589 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1590 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @15B6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @15C1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_15C2: // Incoming jump from 0x1575, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @15C3 msg.sender // @15D4 memory[0x00:0x40] // @15DD stack[-2] // @15E8 memory[0x00:0x40] // @15EA storage[keccak256(memory[0x00:0x40])] // @15EF stack[-1] // @15F9 memory[0x40:0x60] // @15FE memory[0x40:0x60] // @162C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @162F stack[-3] // } 15C2 5B JUMPDEST 15C3 33 CALLER 15C4 60 PUSH1 0x00 15C6 81 DUP2 15C7 81 DUP2 15C8 52 MSTORE 15C9 60 PUSH1 0x05 15CB 60 PUSH1 0x20 15CD 90 SWAP1 15CE 81 DUP2 15CF 52 MSTORE 15D0 60 PUSH1 0x40 15D2 80 DUP1 15D3 83 DUP4 15D4 20 SHA3 15D5 60 PUSH1 0x01 15D7 60 PUSH1 0x01 15D9 60 PUSH1 0xa0 15DB 1B SHL 15DC 03 SUB 15DD 87 DUP8 15DE 16 AND 15DF 80 DUP1 15E0 85 DUP6 15E1 52 MSTORE 15E2 90 SWAP1 15E3 83 DUP4 15E4 52 MSTORE 15E5 92 SWAP3 15E6 81 DUP2 15E7 90 SWAP1 15E8 20 SHA3 15E9 80 DUP1 15EA 54 SLOAD 15EB 60 PUSH1 0xff 15ED 19 NOT 15EE 16 AND 15EF 86 DUP7 15F0 15 ISZERO 15F1 15 ISZERO 15F2 90 SWAP1 15F3 81 DUP2 15F4 17 OR 15F5 90 SWAP1 15F6 91 SWAP2 15F7 55 SSTORE 15F8 81 DUP2 15F9 51 MLOAD 15FA 90 SWAP1 15FB 81 DUP2 15FC 52 MSTORE 15FD 90 SWAP1 15FE 51 MLOAD 15FF 92 SWAP3 1600 93 SWAP4 1601 92 SWAP3 1602 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1623 92 SWAP3 1624 91 SWAP2 1625 81 DUP2 1626 90 SWAP1 1627 03 SUB 1628 90 SWAP1 1629 91 SWAP2 162A 01 ADD 162B 90 SWAP1 162C A3 LOG3 162D 50 POP 162E 50 POP 162F 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @15C8 memory[0x00:0x20] = msg.sender // @15CF memory[0x20:0x40] = 0x05 // @15E1 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @15E4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @15F7 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @15FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @162C 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_1630: // Incoming jump from 0x095E // Inputs[1] { @1634 msg.sender } 1630 5B JUMPDEST 1631 61 PUSH2 0x1639 1634 33 CALLER 1635 61 PUSH2 0x1694 1638 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1631 stack[0] = 0x1639 // @1634 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 1639 5B JUMPDEST 163A 61 PUSH2 0x1642 163D 57 *JUMPI 163E 60 PUSH1 0x00 1640 80 DUP1 1641 FD *REVERT 1642 5B JUMPDEST 1643 61 PUSH2 0x11e3 1646 81 DUP2 1647 61 PUSH2 0x1e79 164A 56 *JUMP label_164B: // Incoming jump from 0x098A // Inputs[2] // { // @164C stack[-1] // @1650 msg.sender // } 164B 5B JUMPDEST 164C 80 DUP1 164D 61 PUSH2 0x1656 1650 33 CALLER 1651 82 DUP3 1652 61 PUSH2 0x1ae6 1655 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @164C stack[0] = stack[-1] // @164D stack[1] = 0x1656 // @1650 stack[2] = msg.sender // @1651 stack[3] = stack[-1] // } // Block ends with call to 0x1ae6, returns to 0x1656 label_1656: // Incoming return from call to 0x1AE6 at 0x1655 // Inputs[1] { @165A stack[-1] } 1656 5B JUMPDEST 1657 61 PUSH2 0x165f 165A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x165f, if stack[-1] label_165B: // Incoming jump from 0x165A, if not stack[-1] // Inputs[1] { @165E memory[0x00:0x00] } 165B 60 PUSH1 0x00 165D 80 DUP1 165E FD *REVERT // Stack delta = +0 // Outputs[1] { @165E revert(memory[0x00:0x00]); } // Block terminates label_165F: // Incoming jump from 0x165A, if stack[-1] // Inputs[1] { @1666 stack[-2] } 165F 5B JUMPDEST 1660 61 PUSH2 0x0ece 1663 61 PUSH2 0x166b 1666 83 DUP4 1667 61 PUSH2 0x1320 166A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1660 stack[0] = 0x0ece // @1663 stack[1] = 0x166b // @1666 stack[2] = stack[-2] // } // Block ends with call to 0x1320, returns to 0x166B label_166B: // Incoming return from call to 0x1320 at 0x166A // Inputs[2] // { // @166C stack[-5] // @166D stack[-4] // } 166B 5B JUMPDEST 166C 84 DUP5 166D 84 DUP5 166E 61 PUSH2 0x1e8a 1671 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @166C stack[0] = stack[-5] // @166D stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x1e8a label_1672: // Incoming jump from 0x09A7 // Inputs[3] // { // @1675 stack[-1] // @1680 memory[0x00:0x40] // @1681 storage[keccak256(memory[0x00:0x40])] // } 1672 5B JUMPDEST 1673 60 PUSH1 0x00 1675 81 DUP2 1676 81 DUP2 1677 52 MSTORE 1678 60 PUSH1 0x08 167A 60 PUSH1 0x20 167C 52 MSTORE 167D 60 PUSH1 0x40 167F 81 DUP2 1680 20 SHA3 1681 54 SLOAD 1682 60 PUSH1 0x01 1684 60 PUSH1 0x01 1686 60 PUSH1 0xa0 1688 1B SHL 1689 03 SUB 168A 16 AND 168B 80 DUP1 168C 61 PUSH2 0x1374 168F 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1673 stack[0] = 0x00 // @1677 memory[0x00:0x20] = stack[-1] // @167C memory[0x20:0x40] = 0x08 // @168A stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1374, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1690: // Incoming jump from 0x168F, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1693 memory[0x00:0x00] } 1690 60 PUSH1 0x00 1692 80 DUP1 1693 FD *REVERT // Stack delta = +0 // Outputs[1] { @1693 revert(memory[0x00:0x00]); } // Block terminates label_1694: // Incoming jump from 0x19FB // Incoming jump from 0x16AF // Incoming jump from 0x09CD // Incoming jump from 0x1162 // Incoming jump from 0x1923 // Incoming jump from 0x1257 // Incoming jump from 0x0EDB // Incoming jump from 0x1638 // Incoming jump from 0x0EB9 // Inputs[1] { @169C stack[-1] } 1694 5B JUMPDEST 1695 60 PUSH1 0x00 1697 61 PUSH2 0x1374 169A 60 PUSH1 0x01 169C 83 DUP4 169D 63 PUSH4 0xffffffff 16A2 61 PUSH2 0x1fce 16A5 16 AND 16A6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1695 stack[0] = 0x00 // @1697 stack[1] = 0x1374 // @169A stack[2] = 0x01 // @169C stack[3] = stack[-1] // } // Block ends with call to 0x1fce & 0xffffffff, returns to 0x1374 label_16A7: // Incoming jump from 0x0A50 // Inputs[1] { @16AB msg.sender } 16A7 5B JUMPDEST 16A8 61 PUSH2 0x16b0 16AB 33 CALLER 16AC 61 PUSH2 0x1694 16AF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16A8 stack[0] = 0x16b0 // @16AB stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 16B0 5B JUMPDEST 16B1 61 PUSH2 0x16b9 16B4 57 *JUMPI 16B5 60 PUSH1 0x00 16B7 80 DUP1 16B8 FD *REVERT 16B9 5B JUMPDEST 16BA 61 PUSH2 0x131a 16BD 84 DUP5 16BE 84 DUP5 16BF 84 DUP5 16C0 84 DUP5 16C1 80 DUP1 16C2 80 DUP1 16C3 60 PUSH1 0x1f 16C5 01 ADD 16C6 60 PUSH1 0x20 16C8 80 DUP1 16C9 91 SWAP2 16CA 04 DIV 16CB 02 MUL 16CC 60 PUSH1 0x20 16CE 01 ADD 16CF 60 PUSH1 0x40 16D1 51 MLOAD 16D2 90 SWAP1 16D3 81 DUP2 16D4 01 ADD 16D5 60 PUSH1 0x40 16D7 52 MSTORE 16D8 80 DUP1 16D9 93 SWAP4 16DA 92 SWAP3 16DB 91 SWAP2 16DC 90 SWAP1 16DD 81 DUP2 16DE 81 DUP2 16DF 52 MSTORE 16E0 60 PUSH1 0x20 16E2 01 ADD 16E3 83 DUP4 16E4 83 DUP4 16E5 80 DUP1 16E6 82 DUP3 16E7 84 DUP5 16E8 37 CALLDATACOPY 16E9 60 PUSH1 0x00 16EB 92 SWAP3 16EC 01 ADD 16ED 91 SWAP2 16EE 90 SWAP1 16EF 91 SWAP2 16F0 52 MSTORE 16F1 50 POP 16F2 61 PUSH2 0x2035 16F5 92 SWAP3 16F6 50 POP 16F7 50 POP 16F8 50 POP 16F9 56 *JUMP label_16FA: // Incoming jump from 0x0B14 // Incoming jump from 0x1194 // Inputs[3] // { // @16FE stack[-4] // @16FF stack[-3] // @1700 stack[-2] // } 16FA 5B JUMPDEST 16FB 61 PUSH2 0x1705 16FE 84 DUP5 16FF 84 DUP5 1700 84 DUP5 1701 61 PUSH2 0x1115 1704 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16FB stack[0] = 0x1705 // @16FE stack[1] = stack[-4] // @16FF stack[2] = stack[-3] // @1700 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1115 1705 5B JUMPDEST 1706 61 PUSH2 0x1711 1709 84 DUP5 170A 84 DUP5 170B 84 DUP5 170C 84 DUP5 170D 61 PUSH2 0x1c79 1710 56 *JUMP 1711 5B JUMPDEST 1712 61 PUSH2 0x131a 1715 57 *JUMPI 1716 60 PUSH1 0x40 1718 51 MLOAD 1719 62 PUSH3 0x461bcd 171D 60 PUSH1 0xe5 171F 1B SHL 1720 81 DUP2 1721 52 MSTORE 1722 60 PUSH1 0x04 1724 01 ADD 1725 80 DUP1 1726 80 DUP1 1727 60 PUSH1 0x20 1729 01 ADD 172A 82 DUP3 172B 81 DUP2 172C 03 SUB 172D 82 DUP3 172E 52 MSTORE 172F 60 PUSH1 0x32 1731 81 DUP2 1732 52 MSTORE 1733 60 PUSH1 0x20 1735 01 ADD 1736 80 DUP1 1737 61 PUSH2 0x271a 173A 60 PUSH1 0x32 173C 91 SWAP2 173D 39 CODECOPY 173E 60 PUSH1 0x40 1740 01 ADD 1741 91 SWAP2 1742 50 POP 1743 50 POP 1744 60 PUSH1 0x40 1746 51 MLOAD 1747 80 DUP1 1748 91 SWAP2 1749 03 SUB 174A 90 SWAP1 174B FD *REVERT label_174C: // Incoming call from 0x1505, returns to 0x12B7 // Incoming jump from 0x0C5D // Inputs[2] // { // @174D stack[-3] // @1751 msg.sender // } 174C 5B JUMPDEST 174D 82 DUP3 174E 61 PUSH2 0x1757 1751 33 CALLER 1752 82 DUP3 1753 61 PUSH2 0x1ae6 1756 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @174D stack[0] = stack[-3] // @174E stack[1] = 0x1757 // @1751 stack[2] = msg.sender // @1752 stack[3] = stack[-3] // } // Block ends with call to 0x1ae6, returns to 0x1757 label_1757: // Incoming return from call to 0x1AE6 at 0x1756 // Inputs[1] { @175B stack[-1] } 1757 5B JUMPDEST 1758 61 PUSH2 0x1760 175B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1760, if stack[-1] label_175C: // Incoming jump from 0x175B, if not stack[-1] // Inputs[1] { @175F memory[0x00:0x00] } 175C 60 PUSH1 0x00 175E 80 DUP1 175F FD *REVERT // Stack delta = +0 // Outputs[1] { @175F revert(memory[0x00:0x00]); } // Block terminates label_1760: // Incoming jump from 0x175B, if stack[-1] // Inputs[2] // { // @1766 stack[-4] // @1767 stack[-3] // } 1760 5B JUMPDEST 1761 60 PUSH1 0x00 1763 61 PUSH2 0x176c 1766 85 DUP6 1767 85 DUP6 1768 61 PUSH2 0x1dac 176B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1761 stack[0] = 0x00 // @1763 stack[1] = 0x176c // @1766 stack[2] = stack[-4] // @1767 stack[3] = stack[-3] // } // Block ends with call to 0x1dac, returns to 0x176C label_176C: // Incoming return from call to 0x1DAC at 0x176B // Inputs[4] // { // @176D stack[-2] // @176D stack[-1] // @1772 stack[-8] // @1773 stack[-7] // } 176C 5B JUMPDEST 176D 90 SWAP1 176E 50 POP 176F 61 PUSH2 0x1779 1772 87 DUP8 1773 87 DUP8 1774 83 DUP4 1775 61 PUSH2 0x1a57 1778 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @176D stack[-2] = stack[-1] // @176F stack[-1] = 0x1779 // @1772 stack[0] = stack[-8] // @1773 stack[1] = stack[-7] // @1774 stack[2] = stack[-1] // } // Block ends with call to 0x1a57, returns to 0x1779 label_1779: // Incoming return from call to 0x1A57 at 0x1778 // Inputs[4] // { // @177D stack[-7] // @177E stack[-6] // @177F stack[-1] // @1780 stack[-3] // } 1779 5B JUMPDEST 177A 61 PUSH2 0x1785 177D 87 DUP8 177E 87 DUP8 177F 83 DUP4 1780 86 DUP7 1781 61 PUSH2 0x1c79 1784 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @177A stack[0] = 0x1785 // @177D stack[1] = stack[-7] // @177E stack[2] = stack[-6] // @177F stack[3] = stack[-1] // @1780 stack[4] = stack[-3] // } // Block ends with call to 0x1c79, returns to 0x1785 label_1785: // Incoming return from call to 0x1C79 at 0x1784 // Inputs[1] { @1789 stack[-1] } 1785 5B JUMPDEST 1786 61 PUSH2 0x178e 1789 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x178e, if stack[-1] label_178A: // Incoming jump from 0x1789, if not stack[-1] // Inputs[1] { @178D memory[0x00:0x00] } 178A 60 PUSH1 0x00 178C 80 DUP1 178D FD *REVERT // Stack delta = +0 // Outputs[1] { @178D revert(memory[0x00:0x00]); } // Block terminates label_178E: // Incoming jump from 0x1789, if stack[-1] // Inputs[1] { @1796 stack[-8] } 178E 5B JUMPDEST 178F 50 POP 1790 50 POP 1791 50 POP 1792 50 POP 1793 50 POP 1794 50 POP 1795 50 POP 1796 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1797: // Incoming jump from 0x0C7A // Inputs[1] { @179D stack[-1] } 1797 5B JUMPDEST 1798 60 PUSH1 0x60 179A 61 PUSH2 0x17a2 179D 82 DUP3 179E 61 PUSH2 0x1ac9 17A1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1798 stack[0] = 0x60 // @179A stack[1] = 0x17a2 // @179D stack[2] = stack[-1] // } // Block ends with call to 0x1ac9, returns to 0x17A2 label_17A2: // Incoming return from call to 0x1AC9 at 0x17A1 // Inputs[1] { @17A6 stack[-1] } 17A2 5B JUMPDEST 17A3 61 PUSH2 0x17ab 17A6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17ab, if stack[-1] label_17A7: // Incoming jump from 0x17A6, if not stack[-1] // Inputs[1] { @17AA memory[0x00:0x00] } 17A7 60 PUSH1 0x00 17A9 80 DUP1 17AA FD *REVERT // Stack delta = +0 // Outputs[1] { @17AA revert(memory[0x00:0x00]); } // Block terminates label_17AB: // Incoming jump from 0x17A6, if stack[-1] // Inputs[4] // { // @17B2 stack[-2] // @17C0 memory[0x00:0x40] // @17C3 memory[0x40:0x60] // @17CA storage[0x07] // } 17AB 5B JUMPDEST 17AC 60 PUSH1 0x07 17AE 60 PUSH1 0x06 17B0 60 PUSH1 0x00 17B2 84 DUP5 17B3 81 DUP2 17B4 52 MSTORE 17B5 60 PUSH1 0x20 17B7 01 ADD 17B8 90 SWAP1 17B9 81 DUP2 17BA 52 MSTORE 17BB 60 PUSH1 0x20 17BD 01 ADD 17BE 60 PUSH1 0x00 17C0 20 SHA3 17C1 60 PUSH1 0x40 17C3 51 MLOAD 17C4 60 PUSH1 0x20 17C6 01 ADD 17C7 80 DUP1 17C8 83 DUP4 17C9 80 DUP1 17CA 54 SLOAD 17CB 60 PUSH1 0x01 17CD 81 DUP2 17CE 60 PUSH1 0x01 17D0 16 AND 17D1 15 ISZERO 17D2 61 PUSH2 0x0100 17D5 02 MUL 17D6 03 SUB 17D7 16 AND 17D8 60 PUSH1 0x02 17DA 90 SWAP1 17DB 04 DIV 17DC 80 DUP1 17DD 15 ISZERO 17DE 61 PUSH2 0x181e 17E1 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @17AC stack[0] = 0x07 // @17B4 memory[0x00:0x20] = stack[-2] // @17BA memory[0x20:0x40] = 0x06 // @17C0 stack[1] = keccak256(memory[0x00:0x40]) // @17C6 stack[2] = 0x20 + memory[0x40:0x60] // @17C7 stack[3] = 0x20 + memory[0x40:0x60] // @17C8 stack[4] = 0x07 // @17DB stack[5] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // } // Block ends with conditional jump to 0x181e, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) label_17E2: // Incoming jump from 0x17E1, if not !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Inputs[1] { @17E2 stack[-1] } 17E2 80 DUP1 17E3 60 PUSH1 0x1f 17E5 10 LT 17E6 61 PUSH2 0x17fc 17E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17fc, if 0x1f < stack[-1] label_17EA: // Incoming jump from 0x17E9, if not 0x1f < stack[-1] // Inputs[4] // { // @17EE stack[-2] // @17EF storage[stack[-2]] // @17F2 stack[-3] // @17F4 stack[-1] // } 17EA 61 PUSH2 0x0100 17ED 80 DUP1 17EE 83 DUP4 17EF 54 SLOAD 17F0 04 DIV 17F1 02 MUL 17F2 83 DUP4 17F3 52 MSTORE 17F4 91 SWAP2 17F5 82 DUP3 17F6 01 ADD 17F7 91 SWAP2 17F8 61 PUSH2 0x181e 17FB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @17F3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @17F7 stack[-1] = stack[-1] // @17F7 stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x181e label_17FC: // Incoming jump from 0x17E9, if 0x1f < stack[-1] // Inputs[5] // { // @17FD stack[-3] // @17FE stack[-1] // @1800 stack[-2] // @1808 memory[0x00:0x20] // @180C storage[keccak256(memory[0x00:0x20])] // } 17FC 5B JUMPDEST 17FD 82 DUP3 17FE 01 ADD 17FF 91 SWAP2 1800 90 SWAP1 1801 60 PUSH1 0x00 1803 52 MSTORE 1804 60 PUSH1 0x20 1806 60 PUSH1 0x00 1808 20 SHA3 1809 90 SWAP1 180A 5B JUMPDEST 180B 81 DUP2 180C 54 SLOAD 180D 81 DUP2 180E 52 MSTORE 180F 90 SWAP1 1810 60 PUSH1 0x01 1812 01 ADD 1813 90 SWAP1 1814 60 PUSH1 0x20 1816 01 ADD 1817 80 DUP1 1818 83 DUP4 1819 11 GT 181A 61 PUSH2 0x180a 181D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @17FF stack[-3] = stack[-3] + stack[-1] // @1803 memory[0x00:0x20] = stack[-2] // @180E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1813 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1816 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x180a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_181E: // Incoming jump from 0x17E1, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Incoming jump from 0x17FB // Incoming jump from 0x181D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x181D, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1821 stack[-5] // @1823 storage[stack[-5]] // } 181E 5B JUMPDEST 181F 50 POP 1820 50 POP 1821 82 DUP3 1822 80 DUP1 1823 54 SLOAD 1824 60 PUSH1 0x01 1826 81 DUP2 1827 60 PUSH1 0x01 1829 16 AND 182A 15 ISZERO 182B 61 PUSH2 0x0100 182E 02 MUL 182F 03 SUB 1830 16 AND 1831 60 PUSH1 0x02 1833 90 SWAP1 1834 04 DIV 1835 80 DUP1 1836 15 ISZERO 1837 61 PUSH2 0x1877 183A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1821 stack[-2] = stack[-5] // @1834 stack[-1] = (0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02 // } // Block ends with conditional jump to 0x1877, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) label_183B: // Incoming jump from 0x183A, if not !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Inputs[1] { @183B stack[-1] } 183B 80 DUP1 183C 60 PUSH1 0x1f 183E 10 LT 183F 61 PUSH2 0x1855 1842 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1855, if 0x1f < stack[-1] label_1843: // Incoming jump from 0x1842, if not 0x1f < stack[-1] // Inputs[4] // { // @1847 stack[-2] // @1848 storage[stack[-2]] // @184B stack[-3] // @184D stack[-1] // } 1843 61 PUSH2 0x0100 1846 80 DUP1 1847 83 DUP4 1848 54 SLOAD 1849 04 DIV 184A 02 MUL 184B 83 DUP4 184C 52 MSTORE 184D 91 SWAP2 184E 82 DUP3 184F 01 ADD 1850 91 SWAP2 1851 61 PUSH2 0x1877 1854 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @184C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1850 stack[-1] = stack[-1] // @1850 stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x1877 label_1855: // Incoming jump from 0x1842, if 0x1f < stack[-1] // Inputs[5] // { // @1856 stack[-3] // @1857 stack[-1] // @1859 stack[-2] // @1861 memory[0x00:0x20] // @1865 storage[keccak256(memory[0x00:0x20])] // } 1855 5B JUMPDEST 1856 82 DUP3 1857 01 ADD 1858 91 SWAP2 1859 90 SWAP1 185A 60 PUSH1 0x00 185C 52 MSTORE 185D 60 PUSH1 0x20 185F 60 PUSH1 0x00 1861 20 SHA3 1862 90 SWAP1 1863 5B JUMPDEST 1864 81 DUP2 1865 54 SLOAD 1866 81 DUP2 1867 52 MSTORE 1868 90 SWAP1 1869 60 PUSH1 0x01 186B 01 ADD 186C 90 SWAP1 186D 60 PUSH1 0x20 186F 01 ADD 1870 80 DUP1 1871 83 DUP4 1872 11 GT 1873 61 PUSH2 0x1863 1876 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1858 stack[-3] = stack[-3] + stack[-1] // @185C memory[0x00:0x20] = stack[-2] // @1867 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @186C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @186F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1863, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1877: // Incoming jump from 0x1854 // Incoming jump from 0x183A, if !((0x0100 * !(0x01 & storage[stack[-5]]) - 0x01 & storage[stack[-5]]) / 0x02) // Incoming jump from 0x1876, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1876, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[4] // { // @187D memory[0x40:0x60] // @1882 stack[-3] // @188A stack[-9] // @188B stack[-8] // } 1877 5B JUMPDEST 1878 50 POP 1879 50 POP 187A 60 PUSH1 0x40 187C 80 DUP1 187D 51 MLOAD 187E 60 PUSH1 0x1f 1880 19 NOT 1881 81 DUP2 1882 84 DUP5 1883 03 SUB 1884 01 ADD 1885 81 DUP2 1886 52 MSTORE 1887 91 SWAP2 1888 90 SWAP1 1889 52 MSTORE 188A 95 SWAP6 188B 94 SWAP5 188C 50 POP 188D 50 POP 188E 50 POP 188F 50 POP 1890 50 POP 1891 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @1886 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] - memory[0x40:0x60] + ~0x1f // @1889 memory[0x40:0x60] = stack[-3] // @188A stack[-9] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-9] label_1892: // Incoming jump from 0x0D4D // Inputs[2] // { // @1893 stack[-5] // @1897 msg.sender // } 1892 5B JUMPDEST 1893 84 DUP5 1894 61 PUSH2 0x189d 1897 33 CALLER 1898 82 DUP3 1899 61 PUSH2 0x1ae6 189C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1893 stack[0] = stack[-5] // @1894 stack[1] = 0x189d // @1897 stack[2] = msg.sender // @1898 stack[3] = stack[-5] // } // Block ends with call to 0x1ae6, returns to 0x189D label_189D: // Incoming return from call to 0x1AE6 at 0x189C // Inputs[1] { @18A1 stack[-1] } 189D 5B JUMPDEST 189E 61 PUSH2 0x18a6 18A1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18a6, if stack[-1] label_18A2: // Incoming jump from 0x18A1, if not stack[-1] // Inputs[1] { @18A5 memory[0x00:0x00] } 18A2 60 PUSH1 0x00 18A4 80 DUP1 18A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @18A5 revert(memory[0x00:0x00]); } // Block terminates label_18A6: // Incoming jump from 0x18A1, if stack[-1] // Inputs[10] // { // @18AA stack[-7] // @18AB stack[-6] // @18AC stack[-5] // @18AD stack[-4] // @18BE memory[0x40:0x60] // @18D5 msg.data[stack[-5]:stack[-5] + stack[-4]] // @18E3 memory[0x40:0x60] // @18E8 stack[-2] // @18FB stack[-3] // @1909 msg.data[stack[-3]:stack[-3] + stack[-2]] // } 18A6 5B JUMPDEST 18A7 61 PUSH2 0x178e 18AA 87 DUP8 18AB 87 DUP8 18AC 87 DUP8 18AD 87 DUP8 18AE 80 DUP1 18AF 80 DUP1 18B0 60 PUSH1 0x1f 18B2 01 ADD 18B3 60 PUSH1 0x20 18B5 80 DUP1 18B6 91 SWAP2 18B7 04 DIV 18B8 02 MUL 18B9 60 PUSH1 0x20 18BB 01 ADD 18BC 60 PUSH1 0x40 18BE 51 MLOAD 18BF 90 SWAP1 18C0 81 DUP2 18C1 01 ADD 18C2 60 PUSH1 0x40 18C4 52 MSTORE 18C5 80 DUP1 18C6 93 SWAP4 18C7 92 SWAP3 18C8 91 SWAP2 18C9 90 SWAP1 18CA 81 DUP2 18CB 81 DUP2 18CC 52 MSTORE 18CD 60 PUSH1 0x20 18CF 01 ADD 18D0 83 DUP4 18D1 83 DUP4 18D2 80 DUP1 18D3 82 DUP3 18D4 84 DUP5 18D5 37 CALLDATACOPY 18D6 60 PUSH1 0x00 18D8 92 SWAP3 18D9 01 ADD 18DA 91 SWAP2 18DB 90 SWAP1 18DC 91 SWAP2 18DD 52 MSTORE 18DE 50 POP 18DF 50 POP 18E0 60 PUSH1 0x40 18E2 80 DUP1 18E3 51 MLOAD 18E4 60 PUSH1 0x20 18E6 60 PUSH1 0x1f 18E8 8B DUP12 18E9 01 ADD 18EA 81 DUP2 18EB 90 SWAP1 18EC 04 DIV 18ED 81 DUP2 18EE 02 MUL 18EF 82 DUP3 18F0 01 ADD 18F1 81 DUP2 18F2 01 ADD 18F3 90 SWAP1 18F4 92 SWAP3 18F5 52 MSTORE 18F6 89 DUP10 18F7 81 DUP2 18F8 52 MSTORE 18F9 92 SWAP3 18FA 50 POP 18FB 89 DUP10 18FC 91 SWAP2 18FD 50 POP 18FE 88 DUP9 18FF 90 SWAP1 1900 81 DUP2 1901 90 SWAP1 1902 84 DUP5 1903 01 ADD 1904 83 DUP4 1905 82 DUP3 1906 80 DUP1 1907 82 DUP3 1908 84 DUP5 1909 37 CALLDATACOPY 190A 60 PUSH1 0x00 190C 92 SWAP3 190D 01 ADD 190E 91 SWAP2 190F 90 SWAP1 1910 91 SWAP2 1911 52 MSTORE 1912 50 POP 1913 61 PUSH2 0x1a9f 1916 92 SWAP3 1917 50 POP 1918 50 POP 1919 50 POP 191A 56 *JUMP // Stack delta = +5 // Outputs[13] // { // @18A7 stack[0] = 0x178e // @18AA stack[1] = stack[-7] // @18AB stack[2] = stack[-6] // @18C4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-4]) / 0x20 * 0x20 // @18C6 stack[3] = memory[0x40:0x60] // @18CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @18D5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-4]] = msg.data[stack[-5]:stack[-5] + stack[-4]] // @18DD memory[0x20 + memory[0x40:0x60] + stack[-4]:0x20 + memory[0x40:0x60] + stack[-4] + 0x20] = 0x00 // @18F5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * ((stack[-2] + 0x1f) / 0x20) // @18F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @18F9 stack[4] = memory[0x40:0x60] // @1909 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @1911 memory[memory[0x40:0x60] + 0x20 + stack[-2]:memory[0x40:0x60] + 0x20 + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1a9f label_191B: // Incoming jump from 0x0DBB // Inputs[1] { @191F msg.sender } 191B 5B JUMPDEST 191C 61 PUSH2 0x1924 191F 33 CALLER 1920 61 PUSH2 0x1694 1923 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @191C stack[0] = 0x1924 // @191F stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 1924 5B JUMPDEST 1925 61 PUSH2 0x192d 1928 57 *JUMPI 1929 60 PUSH1 0x00 192B 80 DUP1 192C FD *REVERT 192D 5B JUMPDEST 192E 61 PUSH2 0x1939 1931 60 PUSH1 0x07 1933 83 DUP4 1934 83 DUP4 1935 61 PUSH2 0x25cf 1938 56 *JUMP 1939 5B JUMPDEST 193A 50 POP 193B 7F PUSH32 0x4b120d6a959a84a520fa48f5f937cca0e79129423487af7901213b5d2e89313b 195C 82 DUP3 195D 82 DUP3 195E 60 PUSH1 0x40 1960 51 MLOAD 1961 80 DUP1 1962 80 DUP1 1963 60 PUSH1 0x20 1965 01 ADD 1966 82 DUP3 1967 81 DUP2 1968 03 SUB 1969 82 DUP3 196A 52 MSTORE 196B 84 DUP5 196C 84 DUP5 196D 82 DUP3 196E 81 DUP2 196F 81 DUP2 1970 52 MSTORE 1971 60 PUSH1 0x20 1973 01 ADD 1974 92 SWAP3 1975 50 POP 1976 80 DUP1 1977 82 DUP3 1978 84 DUP5 1979 37 CALLDATACOPY 197A 60 PUSH1 0x00 197C 83 DUP4 197D 82 DUP3 197E 01 ADD 197F 52 MSTORE 1980 60 PUSH1 0x40 1982 51 MLOAD 1983 60 PUSH1 0x1f 1985 90 SWAP1 1986 91 SWAP2 1987 01 ADD 1988 60 PUSH1 0x1f 198A 19 NOT 198B 16 AND 198C 90 SWAP1 198D 92 SWAP3 198E 01 ADD 198F 82 DUP3 1990 90 SWAP1 1991 03 SUB 1992 95 SWAP6 1993 50 POP 1994 90 SWAP1 1995 93 SWAP4 1996 50 POP 1997 50 POP 1998 50 POP 1999 50 POP 199A A1 LOG1 199B 50 POP 199C 50 POP 199D 56 *JUMP label_199E: // Incoming jump from 0x0E3E // Inputs[2] // { // @199F stack[-3] // @19A3 msg.sender // } 199E 5B JUMPDEST 199F 82 DUP3 19A0 61 PUSH2 0x19a9 19A3 33 CALLER 19A4 82 DUP3 19A5 61 PUSH2 0x1ae6 19A8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @199F stack[0] = stack[-3] // @19A0 stack[1] = 0x19a9 // @19A3 stack[2] = msg.sender // @19A4 stack[3] = stack[-3] // } // Block ends with call to 0x1ae6, returns to 0x19A9 label_19A9: // Incoming return from call to 0x1AE6 at 0x19A8 // Inputs[1] { @19AD stack[-1] } 19A9 5B JUMPDEST 19AA 61 PUSH2 0x19b2 19AD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19b2, if stack[-1] label_19AE: // Incoming jump from 0x19AD, if not stack[-1] // Inputs[1] { @19B1 memory[0x00:0x00] } 19AE 60 PUSH1 0x00 19B0 80 DUP1 19B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @19B1 revert(memory[0x00:0x00]); } // Block terminates label_19B2: // Incoming jump from 0x19AD, if stack[-1] // Inputs[6] // { // @19B6 stack[-5] // @19B7 stack[-4] // @19B8 stack[-3] // @19B9 stack[-2] // @19CA memory[0x40:0x60] // @19E1 msg.data[stack[-3]:stack[-3] + stack[-2]] // } 19B2 5B JUMPDEST 19B3 61 PUSH2 0x12b7 19B6 85 DUP6 19B7 85 DUP6 19B8 85 DUP6 19B9 85 DUP6 19BA 80 DUP1 19BB 80 DUP1 19BC 60 PUSH1 0x1f 19BE 01 ADD 19BF 60 PUSH1 0x20 19C1 80 DUP1 19C2 91 SWAP2 19C3 04 DIV 19C4 02 MUL 19C5 60 PUSH1 0x20 19C7 01 ADD 19C8 60 PUSH1 0x40 19CA 51 MLOAD 19CB 90 SWAP1 19CC 81 DUP2 19CD 01 ADD 19CE 60 PUSH1 0x40 19D0 52 MSTORE 19D1 80 DUP1 19D2 93 SWAP4 19D3 92 SWAP3 19D4 91 SWAP2 19D5 90 SWAP1 19D6 81 DUP2 19D7 81 DUP2 19D8 52 MSTORE 19D9 60 PUSH1 0x20 19DB 01 ADD 19DC 83 DUP4 19DD 83 DUP4 19DE 80 DUP1 19DF 82 DUP3 19E0 84 DUP5 19E1 37 CALLDATACOPY 19E2 60 PUSH1 0x00 19E4 92 SWAP3 19E5 01 ADD 19E6 91 SWAP2 19E7 90 SWAP1 19E8 91 SWAP2 19E9 52 MSTORE 19EA 50 POP 19EB 61 PUSH2 0x2035 19EE 92 SWAP3 19EF 50 POP 19F0 50 POP 19F1 50 POP 19F2 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @19B3 stack[0] = 0x12b7 // @19B6 stack[1] = stack[-5] // @19B7 stack[2] = stack[-4] // @19D0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @19D2 stack[3] = memory[0x40:0x60] // @19D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @19E1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @19E9 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x2035 label_19F3: // Incoming jump from 0x0E5B // Inputs[1] { @19F7 msg.sender } 19F3 5B JUMPDEST 19F4 61 PUSH2 0x19fc 19F7 33 CALLER 19F8 61 PUSH2 0x1694 19FB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19F4 stack[0] = 0x19fc // @19F7 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1694 19FC 5B JUMPDEST 19FD 61 PUSH2 0x11da 1A00 57 *JUMPI 1A01 60 PUSH1 0x00 1A03 80 DUP1 1A04 FD *REVERT label_1A05: // Incoming call from 0x105F, returns to 0x1060 // Incoming call from 0x1B81, returns to 0x13C7 // Incoming jump from 0x0E89 // Inputs[6] // { // @1A0E stack[-2] // @1A21 memory[0x00:0x40] // @1A22 stack[-1] // @1A2C memory[0x00:0x40] // @1A2D storage[keccak256(memory[0x00:0x40])] // @1A31 stack[-3] // } 1A05 5B JUMPDEST 1A06 60 PUSH1 0x01 1A08 60 PUSH1 0x01 1A0A 60 PUSH1 0xa0 1A0C 1B SHL 1A0D 03 SUB 1A0E 91 SWAP2 1A0F 82 DUP3 1A10 16 AND 1A11 60 PUSH1 0x00 1A13 90 SWAP1 1A14 81 DUP2 1A15 52 MSTORE 1A16 60 PUSH1 0x05 1A18 60 PUSH1 0x20 1A1A 90 SWAP1 1A1B 81 DUP2 1A1C 52 MSTORE 1A1D 60 PUSH1 0x40 1A1F 80 DUP1 1A20 83 DUP4 1A21 20 SHA3 1A22 93 SWAP4 1A23 90 SWAP1 1A24 94 SWAP5 1A25 16 AND 1A26 82 DUP3 1A27 52 MSTORE 1A28 91 SWAP2 1A29 90 SWAP1 1A2A 91 SWAP2 1A2B 52 MSTORE 1A2C 20 SHA3 1A2D 54 SLOAD 1A2E 60 PUSH1 0xff 1A30 16 AND 1A31 90 SWAP1 1A32 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1A15 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1A1C memory[0x20:0x40] = 0x05 // @1A27 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1A2B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1A31 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1A33: // Incoming call from 0x0E91, returns to 0x072C // Inputs[1] { @1A55 stack[-1] } 1A33 5B JUMPDEST 1A34 7F PUSH32 0x0f4a10a4f46c288cea365fcf45cccf0e9d901b945b9829ccdb54c10dc3cb7a6f 1A55 90 SWAP1 1A56 56 *JUMP // Stack delta = +0 // Outputs[1] { @1A55 stack[-1] = 0x0f4a10a4f46c288cea365fcf45cccf0e9d901b945b9829ccdb54c10dc3cb7a6f } // Block ends with unconditional jump to stack[-1] label_1A57: // Incoming call from 0x1778, returns to 0x1779 // Incoming jump from 0x1563 // Incoming call from 0x0ECD, returns to 0x0ECE // Inputs[3] // { // @1A5B stack[-3] // @1A5C stack[-2] // @1A5D stack[-1] // } 1A57 5B JUMPDEST 1A58 61 PUSH2 0x1a62 1A5B 83 DUP4 1A5C 83 DUP4 1A5D 83 DUP4 1A5E 61 PUSH2 0x1e8a 1A61 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A58 stack[0] = 0x1a62 // @1A5B stack[1] = stack[-3] // @1A5C stack[2] = stack[-2] // @1A5D stack[3] = stack[-1] // } // Block ends with call to 0x1e8a, returns to 0x1A62 label_1A62: // Incoming return from call to 0x1E8A at 0x1A61 // Inputs[3] // { // @1A65 stack[-1] // @1A70 memory[0x00:0x40] // @1A71 storage[keccak256(memory[0x00:0x40])] // } 1A62 5B JUMPDEST 1A63 60 PUSH1 0x00 1A65 81 DUP2 1A66 81 DUP2 1A67 52 MSTORE 1A68 60 PUSH1 0x08 1A6A 60 PUSH1 0x20 1A6C 52 MSTORE 1A6D 60 PUSH1 0x40 1A6F 90 SWAP1 1A70 20 SHA3 1A71 54 SLOAD 1A72 60 PUSH1 0x01 1A74 60 PUSH1 0x01 1A76 60 PUSH1 0xa0 1A78 1B SHL 1A79 03 SUB 1A7A 16 AND 1A7B 15 ISZERO 1A7C 61 PUSH2 0x0ece 1A7F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1A67 memory[0x00:0x20] = stack[-1] // @1A6C memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x0ece, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1A80: // Incoming jump from 0x1A7F, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @1A82 stack[-1] // @1A8D memory[0x00:0x40] // @1A8F storage[keccak256(memory[0x00:0x40])] // @1A9E stack[-4] // } 1A80 60 PUSH1 0x00 1A82 90 SWAP1 1A83 81 DUP2 1A84 52 MSTORE 1A85 60 PUSH1 0x08 1A87 60 PUSH1 0x20 1A89 52 MSTORE 1A8A 60 PUSH1 0x40 1A8C 90 SWAP1 1A8D 20 SHA3 1A8E 80 DUP1 1A8F 54 SLOAD 1A90 60 PUSH1 0x01 1A92 60 PUSH1 0x01 1A94 60 PUSH1 0xa0 1A96 1B SHL 1A97 03 SUB 1A98 19 NOT 1A99 16 AND 1A9A 90 SWAP1 1A9B 55 SSTORE 1A9C 50 POP 1A9D 50 POP 1A9E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1A84 memory[0x00:0x20] = stack[-1] // @1A89 memory[0x20:0x40] = 0x08 // @1A9B storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_1A9F: // Incoming jump from 0x191A // Incoming jump from 0x1499 // Inputs[3] // { // @1AA3 stack[-4] // @1AA4 stack[-3] // @1AA5 stack[-2] // } 1A9F 5B JUMPDEST 1AA0 61 PUSH2 0x1aaa 1AA3 84 DUP5 1AA4 84 DUP5 1AA5 84 DUP5 1AA6 61 PUSH2 0x2035 1AA9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AA0 stack[0] = 0x1aaa // @1AA3 stack[1] = stack[-4] // @1AA4 stack[2] = stack[-3] // @1AA5 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x2035 1AAA 5B JUMPDEST 1AAB 61 PUSH2 0x1ac0 1AAE 60 PUSH1 0x00 1AB0 85 DUP6 1AB1 61 PUSH2 0x1aba 1AB4 86 DUP7 1AB5 86 DUP7 1AB6 61 PUSH2 0x1dac 1AB9 56 *JUMP 1ABA 5B JUMPDEST 1ABB 84 DUP5 1ABC 61 PUSH2 0x1c79 1ABF 56 *JUMP 1AC0 5B JUMPDEST 1AC1 61 PUSH2 0x131a 1AC4 57 *JUMPI 1AC5 60 PUSH1 0x00 1AC7 80 DUP1 1AC8 FD *REVERT label_1AC9: // Incoming call from 0x1AF0, returns to 0x1AF1 // Incoming call from 0x2060, returns to 0x2061 // Incoming call from 0x17A1, returns to 0x17A2 // Incoming call from 0x0F8E, returns to 0x0F8F // Incoming call from 0x23CD, returns to 0x23CE // Incoming call from 0x1B8A, returns to 0x1B8B // Inputs[4] // { // @1ACC stack[-1] // @1AD7 memory[0x00:0x40] // @1AD8 storage[keccak256(memory[0x00:0x40])] // @1AE4 stack[-2] // } 1AC9 5B JUMPDEST 1ACA 60 PUSH1 0x00 1ACC 90 SWAP1 1ACD 81 DUP2 1ACE 52 MSTORE 1ACF 60 PUSH1 0x02 1AD1 60 PUSH1 0x20 1AD3 52 MSTORE 1AD4 60 PUSH1 0x40 1AD6 90 SWAP1 1AD7 20 SHA3 1AD8 54 SLOAD 1AD9 60 PUSH1 0x01 1ADB 60 PUSH1 0x01 1ADD 60 PUSH1 0xa0 1ADF 1B SHL 1AE0 03 SUB 1AE1 16 AND 1AE2 15 ISZERO 1AE3 15 ISZERO 1AE4 90 SWAP1 1AE5 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1ACE memory[0x00:0x20] = stack[-1] // @1AD3 memory[0x20:0x40] = 0x02 // @1AE4 stack[-2] = !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_1AE6: // Incoming call from 0x1756, returns to 0x1757 // Incoming call from 0x11F1, returns to 0x11F2 // Incoming call from 0x119E, returns to 0x119F // Incoming call from 0x12C8, returns to 0x12C9 // Incoming call from 0x19A8, returns to 0x19A9 // Incoming call from 0x1510, returns to 0x1511 // Incoming call from 0x1655, returns to 0x1656 // Incoming call from 0x1101, returns to 0x1102 // Incoming call from 0x111E, returns to 0x111F // Incoming call from 0x1441, returns to 0x1442 // Incoming call from 0x189C, returns to 0x189D // Inputs[1] { @1AEC stack[-1] } 1AE6 5B JUMPDEST 1AE7 60 PUSH1 0x00 1AE9 61 PUSH2 0x1af1 1AEC 82 DUP3 1AED 61 PUSH2 0x1ac9 1AF0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AE7 stack[0] = 0x00 // @1AE9 stack[1] = 0x1af1 // @1AEC stack[2] = stack[-1] // } // Block ends with call to 0x1ac9, returns to 0x1AF1 label_1AF1: // Incoming return from call to 0x1AC9 at 0x1AF0 // Inputs[1] { @1AF5 stack[-1] } 1AF1 5B JUMPDEST 1AF2 61 PUSH2 0x1b2c 1AF5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b2c, if stack[-1] label_1AF6: // Incoming jump from 0x1AF5, if not stack[-1] // Inputs[3] // { // @1AF8 memory[0x40:0x60] // @1B26 memory[0x40:0x60] // @1B2B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AF6 60 PUSH1 0x40 1AF8 51 MLOAD 1AF9 62 PUSH3 0x461bcd 1AFD 60 PUSH1 0xe5 1AFF 1B SHL 1B00 81 DUP2 1B01 52 MSTORE 1B02 60 PUSH1 0x04 1B04 01 ADD 1B05 80 DUP1 1B06 80 DUP1 1B07 60 PUSH1 0x20 1B09 01 ADD 1B0A 82 DUP3 1B0B 81 DUP2 1B0C 03 SUB 1B0D 82 DUP3 1B0E 52 MSTORE 1B0F 60 PUSH1 0x2c 1B11 81 DUP2 1B12 52 MSTORE 1B13 60 PUSH1 0x20 1B15 01 ADD 1B16 80 DUP1 1B17 61 PUSH2 0x2770 1B1A 60 PUSH1 0x2c 1B1C 91 SWAP2 1B1D 39 CODECOPY 1B1E 60 PUSH1 0x40 1B20 01 ADD 1B21 91 SWAP2 1B22 50 POP 1B23 50 POP 1B24 60 PUSH1 0x40 1B26 51 MLOAD 1B27 80 DUP1 1B28 91 SWAP2 1B29 03 SUB 1B2A 90 SWAP1 1B2B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B01 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B0E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B12 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @1B1D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x2770:0x279c] // @1B2B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B2C: // Incoming jump from 0x1AF5, if stack[-1] // Inputs[1] { @1B32 stack[-2] } 1B2C 5B JUMPDEST 1B2D 60 PUSH1 0x00 1B2F 61 PUSH2 0x1b37 1B32 83 DUP4 1B33 61 PUSH2 0x1320 1B36 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B2D stack[0] = 0x00 // @1B2F stack[1] = 0x1b37 // @1B32 stack[2] = stack[-2] // } // Block ends with call to 0x1320, returns to 0x1B37 label_1B37: // Incoming return from call to 0x1320 at 0x1B36 // Inputs[3] // { // @1B38 stack[-1] // @1B38 stack[-2] // @1B44 stack[-5] // } 1B37 5B JUMPDEST 1B38 90 SWAP1 1B39 50 POP 1B3A 80 DUP1 1B3B 60 PUSH1 0x01 1B3D 60 PUSH1 0x01 1B3F 60 PUSH1 0xa0 1B41 1B SHL 1B42 03 SUB 1B43 16 AND 1B44 84 DUP5 1B45 60 PUSH1 0x01 1B47 60 PUSH1 0x01 1B49 60 PUSH1 0xa0 1B4B 1B SHL 1B4C 03 SUB 1B4D 16 AND 1B4E 14 EQ 1B4F 80 DUP1 1B50 61 PUSH2 0x1b72 1B53 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1B38 stack[-2] = stack[-1] // @1B4E stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x1b72, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_1B54: // Incoming jump from 0x1B53, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @1B55 stack[-5] // @1B62 stack[-4] // } 1B54 50 POP 1B55 83 DUP4 1B56 60 PUSH1 0x01 1B58 60 PUSH1 0x01 1B5A 60 PUSH1 0xa0 1B5C 1B SHL 1B5D 03 SUB 1B5E 16 AND 1B5F 61 PUSH2 0x1b67 1B62 84 DUP5 1B63 61 PUSH2 0x0f84 1B66 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B5E stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1B5F stack[0] = 0x1b67 // @1B62 stack[1] = stack[-4] // } // Block ends with call to 0x0f84, returns to 0x1B67 label_1B67: // Incoming return from call to 0x0F84 at 0x1B66 // Inputs[2] // { // @1B70 stack[-1] // @1B71 stack[-2] // } 1B67 5B JUMPDEST 1B68 60 PUSH1 0x01 1B6A 60 PUSH1 0x01 1B6C 60 PUSH1 0xa0 1B6E 1B SHL 1B6F 03 SUB 1B70 16 AND 1B71 14 EQ // Stack delta = -1 // Outputs[1] { @1B71 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1B72: // Incoming jump from 0x1B53, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x1B71 // Inputs[1] { @1B73 stack[-1] } 1B72 5B JUMPDEST 1B73 80 DUP1 1B74 61 PUSH2 0x13c7 1B77 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13c7, if stack[-1] label_1B78: // Incoming jump from 0x1B77, if not stack[-1] // Inputs[2] // { // @1B7C stack[-2] // @1B7D stack[-5] // } 1B78 50 POP 1B79 61 PUSH2 0x13c7 1B7C 81 DUP2 1B7D 85 DUP6 1B7E 61 PUSH2 0x1a05 1B81 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B79 stack[-1] = 0x13c7 // @1B7C stack[0] = stack[-2] // @1B7D stack[1] = stack[-5] // } // Block ends with call to 0x1a05, returns to 0x13C7 label_1B82: // Incoming call from 0x1114, returns to 0x0ECE // Inputs[1] { @1B86 stack[-1] } 1B82 5B JUMPDEST 1B83 61 PUSH2 0x1b8b 1B86 81 DUP2 1B87 61 PUSH2 0x1ac9 1B8A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B83 stack[0] = 0x1b8b // @1B86 stack[1] = stack[-1] // } // Block ends with call to 0x1ac9, returns to 0x1B8B label_1B8B: // Incoming return from call to 0x1AC9 at 0x1B8A // Inputs[1] { @1B8F stack[-1] } 1B8B 5B JUMPDEST 1B8C 61 PUSH2 0x1b94 1B8F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b94, if stack[-1] label_1B90: // Incoming jump from 0x1B8F, if not stack[-1] // Inputs[1] { @1B93 memory[0x00:0x00] } 1B90 60 PUSH1 0x00 1B92 80 DUP1 1B93 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B93 revert(memory[0x00:0x00]); } // Block terminates label_1B94: // Incoming jump from 0x1B8F, if stack[-1] // Inputs[7] // { // @1B97 memory[0x40:0x60] // @1BA0 stack[-2] // @1BA3 stack[-1] // @1BCA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1BD8 memory[0x00:0x40] // @1BDA storage[keccak256(memory[0x00:0x40])] // @1BF7 stack[-3] // } 1B94 5B JUMPDEST 1B95 60 PUSH1 0x40 1B97 51 MLOAD 1B98 60 PUSH1 0x01 1B9A 60 PUSH1 0x01 1B9C 60 PUSH1 0xa0 1B9E 1B SHL 1B9F 03 SUB 1BA0 83 DUP4 1BA1 16 AND 1BA2 90 SWAP1 1BA3 82 DUP3 1BA4 90 SWAP1 1BA5 7F PUSH32 0xb1b34e6d89e1c584527d447f4b29ffad55635a37edeeb564939a6483401b31a5 1BC6 90 SWAP1 1BC7 60 PUSH1 0x00 1BC9 90 SWAP1 1BCA A3 LOG3 1BCB 60 PUSH1 0x00 1BCD 90 SWAP1 1BCE 81 DUP2 1BCF 52 MSTORE 1BD0 60 PUSH1 0x08 1BD2 60 PUSH1 0x20 1BD4 52 MSTORE 1BD5 60 PUSH1 0x40 1BD7 90 SWAP1 1BD8 20 SHA3 1BD9 80 DUP1 1BDA 54 SLOAD 1BDB 60 PUSH1 0x01 1BDD 60 PUSH1 0x01 1BDF 60 PUSH1 0xa0 1BE1 1B SHL 1BE2 03 SUB 1BE3 19 NOT 1BE4 16 AND 1BE5 60 PUSH1 0x01 1BE7 60 PUSH1 0x01 1BE9 60 PUSH1 0xa0 1BEB 1B SHL 1BEC 03 SUB 1BED 92 SWAP3 1BEE 90 SWAP1 1BEF 92 SWAP3 1BF0 16 AND 1BF1 91 SWAP2 1BF2 90 SWAP1 1BF3 91 SWAP2 1BF4 17 OR 1BF5 90 SWAP1 1BF6 55 SSTORE 1BF7 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1BCA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xb1b34e6d89e1c584527d447f4b29ffad55635a37edeeb564939a6483401b31a5, stack[-1], stack[-2] & (0x01 << 0xa0) - 0x01]); // @1BCF memory[0x00:0x20] = stack[-1] // @1BD4 memory[0x20:0x40] = 0x08 // @1BF6 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_1BF8: // Incoming jump from 0x11E2 // Incoming jump from 0x1319 // Inputs[1] { @1BFC stack[-1] } 1BF8 5B JUMPDEST 1BF9 61 PUSH2 0x1c01 1BFC 81 DUP2 1BFD 61 PUSH2 0x220f 1C00 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BF9 stack[0] = 0x1c01 // @1BFC stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x220f 1C01 5B JUMPDEST 1C02 60 PUSH1 0x00 1C04 81 DUP2 1C05 81 DUP2 1C06 52 MSTORE 1C07 60 PUSH1 0x08 1C09 60 PUSH1 0x20 1C0B 52 MSTORE 1C0C 60 PUSH1 0x40 1C0E 90 SWAP1 1C0F 20 SHA3 1C10 54 SLOAD 1C11 60 PUSH1 0x01 1C13 60 PUSH1 0x01 1C15 60 PUSH1 0xa0 1C17 1B SHL 1C18 03 SUB 1C19 16 AND 1C1A 15 ISZERO 1C1B 61 PUSH2 0x1c3b 1C1E 57 *JUMPI 1C1F 60 PUSH1 0x00 1C21 81 DUP2 1C22 81 DUP2 1C23 52 MSTORE 1C24 60 PUSH1 0x08 1C26 60 PUSH1 0x20 1C28 52 MSTORE 1C29 60 PUSH1 0x40 1C2B 90 SWAP1 1C2C 20 SHA3 1C2D 80 DUP1 1C2E 54 SLOAD 1C2F 60 PUSH1 0x01 1C31 60 PUSH1 0x01 1C33 60 PUSH1 0xa0 1C35 1B SHL 1C36 03 SUB 1C37 19 NOT 1C38 16 AND 1C39 90 SWAP1 1C3A 55 SSTORE 1C3B 5B JUMPDEST 1C3C 60 PUSH1 0x00 1C3E 81 DUP2 1C3F 81 DUP2 1C40 52 MSTORE 1C41 60 PUSH1 0x06 1C43 60 PUSH1 0x20 1C45 52 MSTORE 1C46 60 PUSH1 0x40 1C48 90 SWAP1 1C49 20 SHA3 1C4A 54 SLOAD 1C4B 60 PUSH1 0x02 1C4D 60 PUSH1 0x00 1C4F 19 NOT 1C50 61 PUSH2 0x0100 1C53 60 PUSH1 0x01 1C55 84 DUP5 1C56 16 AND 1C57 15 ISZERO 1C58 02 MUL 1C59 01 ADD 1C5A 90 SWAP1 1C5B 91 SWAP2 1C5C 16 AND 1C5D 04 DIV 1C5E 15 ISZERO 1C5F 61 PUSH2 0x11e3 1C62 57 *JUMPI 1C63 60 PUSH1 0x00 1C65 81 DUP2 1C66 81 DUP2 1C67 52 MSTORE 1C68 60 PUSH1 0x06 1C6A 60 PUSH1 0x20 1C6C 52 MSTORE 1C6D 60 PUSH1 0x40 1C6F 81 DUP2 1C70 20 SHA3 1C71 61 PUSH2 0x11e3 1C74 91 SWAP2 1C75 61 PUSH2 0x264d 1C78 56 *JUMP label_1C79: // Incoming call from 0x1784, returns to 0x1785 // Inputs[1] { @1C7F stack[-3] } 1C79 5B JUMPDEST 1C7A 60 PUSH1 0x00 1C7C 61 PUSH2 0x1c8d 1C7F 84 DUP5 1C80 60 PUSH1 0x01 1C82 60 PUSH1 0x01 1C84 60 PUSH1 0xa0 1C86 1B SHL 1C87 03 SUB 1C88 16 AND 1C89 61 PUSH2 0x2221 1C8C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C7A stack[0] = 0x00 // @1C7C stack[1] = 0x1c8d // @1C88 stack[2] = (0x01 << 0xa0) - 0x01 & stack[-3] // } // Block ends with call to 0x2221, returns to 0x1C8D label_1C8D: // Incoming return from call to 0x2221 at 0x1C8C // Inputs[1] { @1C91 stack[-1] } 1C8D 5B JUMPDEST 1C8E 61 PUSH2 0x1c99 1C91 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c99, if stack[-1] label_1C92: // Incoming jump from 0x1C91, if not stack[-1] 1C92 50 POP 1C93 60 PUSH1 0x01 1C95 61 PUSH2 0x13c7 1C98 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C93 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x13c7 label_1C99: // Incoming jump from 0x1C91, if stack[-1] // Inputs[8] // { // @1C9C memory[0x40:0x60] // @1CA7 msg.sender // @1CB7 stack[-5] // @1CC3 stack[-3] // @1CCF stack[-2] // @1CD0 memory[stack[-2]:stack[-2] + 0x20] // @1CD7 memory[stack[-2]:stack[-2] + 0x20] // @1CDC stack[-4] // } 1C99 5B JUMPDEST 1C9A 60 PUSH1 0x40 1C9C 51 MLOAD 1C9D 63 PUSH4 0x0a85bd01 1CA2 60 PUSH1 0xe1 1CA4 1B SHL 1CA5 81 DUP2 1CA6 52 MSTORE 1CA7 33 CALLER 1CA8 60 PUSH1 0x04 1CAA 82 DUP3 1CAB 01 ADD 1CAC 81 DUP2 1CAD 81 DUP2 1CAE 52 MSTORE 1CAF 60 PUSH1 0x01 1CB1 60 PUSH1 0x01 1CB3 60 PUSH1 0xa0 1CB5 1B SHL 1CB6 03 SUB 1CB7 88 DUP9 1CB8 81 DUP2 1CB9 16 AND 1CBA 60 PUSH1 0x24 1CBC 85 DUP6 1CBD 01 ADD 1CBE 52 MSTORE 1CBF 60 PUSH1 0x44 1CC1 84 DUP5 1CC2 01 ADD 1CC3 87 DUP8 1CC4 90 SWAP1 1CC5 52 MSTORE 1CC6 60 PUSH1 0x80 1CC8 60 PUSH1 0x64 1CCA 85 DUP6 1CCB 01 ADD 1CCC 90 SWAP1 1CCD 81 DUP2 1CCE 52 MSTORE 1CCF 86 DUP7 1CD0 51 MLOAD 1CD1 60 PUSH1 0x84 1CD3 86 DUP7 1CD4 01 ADD 1CD5 52 MSTORE 1CD6 86 DUP7 1CD7 51 MLOAD 1CD8 60 PUSH1 0x00 1CDA 95 SWAP6 1CDB 92 SWAP3 1CDC 8A DUP11 1CDD 16 AND 1CDE 94 SWAP5 1CDF 63 PUSH4 0x150b7a02 1CE4 94 SWAP5 1CE5 90 SWAP1 1CE6 93 SWAP4 1CE7 8C DUP13 1CE8 93 SWAP4 1CE9 8B DUP12 1CEA 93 SWAP4 1CEB 8B DUP12 1CEC 93 SWAP4 1CED 92 SWAP3 1CEE 60 PUSH1 0xa4 1CF0 01 ADD 1CF1 90 SWAP1 1CF2 60 PUSH1 0x20 1CF4 85 DUP6 1CF5 01 ADD 1CF6 90 SWAP1 1CF7 80 DUP1 1CF8 83 DUP4 1CF9 83 DUP4 1CFA 8E DUP15 1CFB 5B JUMPDEST 1CFC 83 DUP4 1CFD 81 DUP2 1CFE 10 LT 1CFF 15 ISZERO 1D00 61 PUSH2 0x1d13 1D03 57 *JUMPI // Stack delta = +16 // Outputs[22] // { // @1CA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1CAE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @1CBE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1CC5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-3] // @1CCE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x80 // @1CD5 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1CDA stack[0] = 0x00 // @1CDE stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1CE4 stack[2] = 0x150b7a02 // @1CE6 stack[3] = msg.sender // @1CE8 stack[8] = memory[0x40:0x60] + 0x64 // @1CE8 stack[4] = stack[-5] // @1CEA stack[5] = stack[-3] // @1CEC stack[6] = stack[-2] // @1CED stack[7] = memory[0x40:0x60] + 0x04 // @1CF1 stack[9] = 0xa4 + memory[0x40:0x60] // @1CF6 stack[11] = memory[stack[-2]:stack[-2] + 0x20] // @1CF6 stack[10] = stack[-2] + 0x20 // @1CF7 stack[12] = memory[stack[-2]:stack[-2] + 0x20] // @1CF8 stack[13] = 0xa4 + memory[0x40:0x60] // @1CF9 stack[14] = stack[-2] + 0x20 // @1CFA stack[15] = 0x00 // } // Block ends with conditional jump to 0x1d13, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1D04: // Incoming jump from 0x1D03, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1D03, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @1D04 stack[-2] // @1D05 stack[-1] // @1D07 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D08 stack[-3] // } 1D04 81 DUP2 1D05 81 DUP2 1D06 01 ADD 1D07 51 MLOAD 1D08 83 DUP4 1D09 82 DUP3 1D0A 01 ADD 1D0B 52 MSTORE 1D0C 60 PUSH1 0x20 1D0E 01 ADD 1D0F 61 PUSH2 0x1cfb 1D12 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1D0B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D0E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1cfb label_1D13: // Incoming jump from 0x1D03, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1D03, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1D18 stack[-5] // @1D18 stack[-6] // @1D1A stack[-7] // } 1D13 5B JUMPDEST 1D14 50 POP 1D15 50 POP 1D16 50 POP 1D17 50 POP 1D18 90 SWAP1 1D19 50 POP 1D1A 90 SWAP1 1D1B 81 DUP2 1D1C 01 ADD 1D1D 90 SWAP1 1D1E 60 PUSH1 0x1f 1D20 16 AND 1D21 80 DUP1 1D22 15 ISZERO 1D23 61 PUSH2 0x1d40 1D26 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1D1D stack[-7] = stack[-5] + stack[-7] // @1D20 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1d40, if !(0x1f & stack[-5]) label_1D27: // Incoming jump from 0x1D26, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1D27 stack[-1] // @1D28 stack[-2] // @1D2B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1D42 stack[-8] // @1D4D memory[0x40:0x60] // @1D54 stack[-10] // @1D56 address(stack[-10]).code.length // } 1D27 80 DUP1 1D28 82 DUP3 1D29 03 SUB 1D2A 80 DUP1 1D2B 51 MLOAD 1D2C 60 PUSH1 0x01 1D2E 83 DUP4 1D2F 60 PUSH1 0x20 1D31 03 SUB 1D32 61 PUSH2 0x0100 1D35 0A EXP 1D36 03 SUB 1D37 19 NOT 1D38 16 AND 1D39 81 DUP2 1D3A 52 MSTORE 1D3B 60 PUSH1 0x20 1D3D 01 ADD 1D3E 91 SWAP2 1D3F 50 POP 1D40 5B JUMPDEST 1D41 50 POP 1D42 95 SWAP6 1D43 50 POP 1D44 50 POP 1D45 50 POP 1D46 50 POP 1D47 50 POP 1D48 50 POP 1D49 60 PUSH1 0x20 1D4B 60 PUSH1 0x40 1D4D 51 MLOAD 1D4E 80 DUP1 1D4F 83 DUP4 1D50 03 SUB 1D51 81 DUP2 1D52 60 PUSH1 0x00 1D54 87 DUP8 1D55 80 DUP1 1D56 3B EXTCODESIZE 1D57 15 ISZERO 1D58 80 DUP1 1D59 15 ISZERO 1D5A 61 PUSH2 0x1d62 1D5D 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1D3A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1D42 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @1D49 stack[-7] = 0x20 // @1D4D stack[-6] = memory[0x40:0x60] // @1D50 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1D51 stack[-4] = memory[0x40:0x60] // @1D52 stack[-3] = 0x00 // @1D54 stack[-2] = stack[-10] // @1D57 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x1d62, if !!address(stack[-10]).code.length label_1D5E: // Incoming jump from 0x1D5D, if not !!address(stack[-10]).code.length // Incoming jump from 0x1D5D, if not !!address(stack[-10]).code.length // Inputs[1] { @1D61 memory[0x00:0x00] } 1D5E 60 PUSH1 0x00 1D60 80 DUP1 1D61 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D61 revert(memory[0x00:0x00]); } // Block terminates label_1D62: // Incoming jump from 0x1D5D, if !!address(stack[-10]).code.length // Incoming jump from 0x1D5D, if !!address(stack[-10]).code.length // Inputs[9] // { // @1D64 msg.gas // @1D65 stack[-3] // @1D65 stack[-6] // @1D65 stack[-7] // @1D65 memory[stack[-4]:stack[-4] + stack[-5]] // @1D65 stack[-4] // @1D65 stack[-2] // @1D65 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D65 stack[-5] // } 1D62 5B JUMPDEST 1D63 50 POP 1D64 5A GAS 1D65 F1 CALL 1D66 15 ISZERO 1D67 80 DUP1 1D68 15 ISZERO 1D69 61 PUSH2 0x1d76 1D6C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1D65 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D66 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1d76, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1D6D: // Incoming jump from 0x1D6C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1D6D returndata.length // @1D71 returndata[0x00:0x00 + returndata.length] // @1D72 returndata.length // @1D75 memory[0x00:0x00 + returndata.length] // } 1D6D 3D RETURNDATASIZE 1D6E 60 PUSH1 0x00 1D70 80 DUP1 1D71 3E RETURNDATACOPY 1D72 3D RETURNDATASIZE 1D73 60 PUSH1 0x00 1D75 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D71 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1D75 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D76: // Incoming jump from 0x1D6C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1D7D memory[0x40:0x60] // @1D7E returndata.length // } 1D76 5B JUMPDEST 1D77 50 POP 1D78 50 POP 1D79 50 POP 1D7A 50 POP 1D7B 60 PUSH1 0x40 1D7D 51 MLOAD 1D7E 3D RETURNDATASIZE 1D7F 60 PUSH1 0x20 1D81 81 DUP2 1D82 10 LT 1D83 15 ISZERO 1D84 61 PUSH2 0x1d8c 1D87 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D7D stack[-4] = memory[0x40:0x60] // @1D7E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1d8c, if !(returndata.length < 0x20) label_1D88: // Incoming jump from 0x1D87, if not !(returndata.length < 0x20) // Inputs[1] { @1D8B memory[0x00:0x00] } 1D88 60 PUSH1 0x00 1D8A 80 DUP1 1D8B FD *REVERT // Stack delta = +0 // Outputs[1] { @1D8B revert(memory[0x00:0x00]); } // Block terminates label_1D8C: // Incoming jump from 0x1D87, if !(returndata.length < 0x20) // Inputs[5] // { // @1D8E stack[-2] // @1D8E memory[stack[-2]:stack[-2] + 0x20] // @1DA2 stack[-4] // @1DA5 stack[-9] // @1DA6 stack[-8] // } 1D8C 5B JUMPDEST 1D8D 50 POP 1D8E 51 MLOAD 1D8F 60 PUSH1 0x01 1D91 60 PUSH1 0x01 1D93 60 PUSH1 0xe0 1D95 1B SHL 1D96 03 SUB 1D97 19 NOT 1D98 16 AND 1D99 63 PUSH4 0x0a85bd01 1D9E 60 PUSH1 0xe1 1DA0 1B SHL 1DA1 14 EQ 1DA2 91 SWAP2 1DA3 50 POP 1DA4 50 POP 1DA5 94 SWAP5 1DA6 93 SWAP4 1DA7 50 POP 1DA8 50 POP 1DA9 50 POP 1DAA 50 POP 1DAB 56 *JUMP // Stack delta = -8 // Outputs[1] { @1DA5 stack[-9] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-9] label_1DAC: // Incoming call from 0x176B, returns to 0x176C // Incoming call from 0x13C6, returns to 0x13C7 // Incoming call from 0x155E, returns to 0x155F // Incoming call from 0x1314, returns to 0x1315 // Incoming call from 0x2040, returns to 0x2041 // Inputs[2] // { // @1DAF stack[-1] // @1DB0 memory[stack[-1]:stack[-1] + 0x20] // } 1DAC 5B JUMPDEST 1DAD 60 PUSH1 0x00 1DAF 81 DUP2 1DB0 51 MLOAD 1DB1 60 PUSH1 0x00 1DB3 14 EQ 1DB4 15 ISZERO 1DB5 61 PUSH2 0x1dbd 1DB8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DAD stack[0] = 0x00 } // Block ends with conditional jump to 0x1dbd, if !(0x00 == memory[stack[-1]:stack[-1] + 0x20]) label_1DB9: // Incoming jump from 0x1DB8, if not !(0x00 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @1DBC memory[0x00:0x00] } 1DB9 60 PUSH1 0x00 1DBB 80 DUP1 1DBC FD *REVERT // Stack delta = +0 // Outputs[1] { @1DBC revert(memory[0x00:0x00]); } // Block terminates label_1DBD: // Incoming jump from 0x1DB8, if !(0x00 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @1DBE stack[-3] // @1DBF stack[-2] // @1DC2 memory[0x40:0x60] // @1DC9 memory[stack[-2]:stack[-2] + 0x20] // } 1DBD 5B JUMPDEST 1DBE 82 DUP3 1DBF 82 DUP3 1DC0 60 PUSH1 0x40 1DC2 51 MLOAD 1DC3 60 PUSH1 0x20 1DC5 01 ADD 1DC6 80 DUP1 1DC7 82 DUP3 1DC8 80 DUP1 1DC9 51 MLOAD 1DCA 90 SWAP1 1DCB 60 PUSH1 0x20 1DCD 01 ADD 1DCE 90 SWAP1 1DCF 80 DUP1 1DD0 83 DUP4 1DD1 83 DUP4 1DD2 5B JUMPDEST 1DD3 60 PUSH1 0x20 1DD5 83 DUP4 1DD6 10 LT 1DD7 61 PUSH2 0x1df1 1DDA 57 *JUMPI // Stack delta = +9 // Outputs[9] // { // @1DBE stack[0] = stack[-3] // @1DBF stack[1] = stack[-2] // @1DC5 stack[2] = 0x20 + memory[0x40:0x60] // @1DC6 stack[3] = 0x20 + memory[0x40:0x60] // @1DCE stack[4] = 0x20 + stack[-2] // @1DCE stack[5] = memory[stack[-2]:stack[-2] + 0x20] // @1DCF stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @1DD0 stack[7] = 0x20 + memory[0x40:0x60] // @1DD1 stack[8] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x1df1, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 label_1DDB: // Incoming jump from 0x1DDA, if not memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Incoming jump from 0x1DDA, if not stack[-3] < 0x20 // Inputs[4] // { // @1DDB stack[-1] // @1DDC memory[stack[-1]:stack[-1] + 0x20] // @1DDD stack[-2] // @1DE3 stack[-3] // } 1DDB 80 DUP1 1DDC 51 MLOAD 1DDD 82 DUP3 1DDE 52 MSTORE 1DDF 60 PUSH1 0x1f 1DE1 19 NOT 1DE2 90 SWAP1 1DE3 92 SWAP3 1DE4 01 ADD 1DE5 91 SWAP2 1DE6 60 PUSH1 0x20 1DE8 91 SWAP2 1DE9 82 DUP3 1DEA 01 ADD 1DEB 91 SWAP2 1DEC 01 ADD 1DED 61 PUSH2 0x1dd2 1DF0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1DDE memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1DE5 stack[-3] = stack[-3] + ~0x1f // @1DEB stack[-2] = 0x20 + stack[-2] // @1DEC stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1dd2 label_1DF1: // Incoming jump from 0x1DDA, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Incoming jump from 0x1DDA, if stack[-3] < 0x20 // Inputs[20] // { // @1DF4 stack[-3] // @1DFF stack[-1] // @1E00 memory[stack[-1]:stack[-1] + 0x20] // @1E03 stack[-2] // @1E04 memory[stack[-2]:stack[-2] + 0x20] // @1E11 stack[-4] // @1E11 stack[-5] // @1E13 stack[-6] // @1E14 stack[-8] // @1E19 memory[0x40:0x60] // @1E27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1E2C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1E2F memory[0x40:0x60] // @1E34 stack[-9] // @1E46 memory[0x40:0x60] // @1E54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1E59 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1E5D stack[-10] // @1E5F stack[-13] // @1E60 stack[-12] // } 1DF1 5B JUMPDEST 1DF2 60 PUSH1 0x01 1DF4 83 DUP4 1DF5 60 PUSH1 0x20 1DF7 03 SUB 1DF8 61 PUSH2 0x0100 1DFB 0A EXP 1DFC 03 SUB 1DFD 80 DUP1 1DFE 19 NOT 1DFF 82 DUP3 1E00 51 MLOAD 1E01 16 AND 1E02 81 DUP2 1E03 84 DUP5 1E04 51 MLOAD 1E05 16 AND 1E06 80 DUP1 1E07 82 DUP3 1E08 17 OR 1E09 85 DUP6 1E0A 52 MSTORE 1E0B 50 POP 1E0C 50 POP 1E0D 50 POP 1E0E 50 POP 1E0F 50 POP 1E10 50 POP 1E11 90 SWAP1 1E12 50 POP 1E13 01 ADD 1E14 91 SWAP2 1E15 50 POP 1E16 50 POP 1E17 60 PUSH1 0x40 1E19 51 MLOAD 1E1A 60 PUSH1 0x20 1E1C 81 DUP2 1E1D 83 DUP4 1E1E 03 SUB 1E1F 03 SUB 1E20 81 DUP2 1E21 52 MSTORE 1E22 90 SWAP1 1E23 60 PUSH1 0x40 1E25 52 MSTORE 1E26 80 DUP1 1E27 51 MLOAD 1E28 90 SWAP1 1E29 60 PUSH1 0x20 1E2B 01 ADD 1E2C 20 SHA3 1E2D 60 PUSH1 0x40 1E2F 51 MLOAD 1E30 60 PUSH1 0x20 1E32 01 ADD 1E33 80 DUP1 1E34 83 DUP4 1E35 81 DUP2 1E36 52 MSTORE 1E37 60 PUSH1 0x20 1E39 01 ADD 1E3A 82 DUP3 1E3B 81 DUP2 1E3C 52 MSTORE 1E3D 60 PUSH1 0x20 1E3F 01 ADD 1E40 92 SWAP3 1E41 50 POP 1E42 50 POP 1E43 50 POP 1E44 60 PUSH1 0x40 1E46 51 MLOAD 1E47 60 PUSH1 0x20 1E49 81 DUP2 1E4A 83 DUP4 1E4B 03 SUB 1E4C 03 SUB 1E4D 81 DUP2 1E4E 52 MSTORE 1E4F 90 SWAP1 1E50 60 PUSH1 0x40 1E52 52 MSTORE 1E53 80 DUP1 1E54 51 MLOAD 1E55 90 SWAP1 1E56 60 PUSH1 0x20 1E58 01 ADD 1E59 20 SHA3 1E5A 60 PUSH1 0x00 1E5C 1C SHR 1E5D 90 SWAP1 1E5E 50 POP 1E5F 92 SWAP3 1E60 91 SWAP2 1E61 50 POP 1E62 50 POP 1E63 56 *JUMP // Stack delta = -12 // Outputs[8] // { // @1E0A memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1E21 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @1E25 memory[0x40:0x60] = stack[-4] + stack[-6] // @1E36 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-9] // @1E3C memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1E4E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1E52 memory[0x40:0x60] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @1E5F stack[-13] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) >> 0x00 // } // Block ends with unconditional jump to stack[-13] label_1E64: // Incoming call from 0x1382, returns to 0x1383 // Inputs[1] { @1E6A stack[-1] } 1E64 5B JUMPDEST 1E65 61 PUSH2 0x11e3 1E68 60 PUSH1 0x01 1E6A 82 DUP3 1E6B 63 PUSH4 0xffffffff 1E70 61 PUSH2 0x2227 1E73 16 AND 1E74 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E65 stack[0] = 0x11e3 // @1E68 stack[1] = 0x01 // @1E6A stack[2] = stack[-1] // } // Block ends with call to 0x2227 & 0xffffffff, returns to 0x11E3 label_1E75: // Incoming call from 0x1436, returns to 0x1374 // Inputs[3] // { // @1E76 storage[stack[-1]] // @1E76 stack[-1] // @1E77 stack[-2] // } 1E75 5B JUMPDEST 1E76 54 SLOAD 1E77 90 SWAP1 1E78 56 *JUMP // Stack delta = -1 // Outputs[1] { @1E77 stack[-2] = storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] 1E79 5B JUMPDEST 1E7A 61 PUSH2 0x11e3 1E7D 60 PUSH1 0x01 1E7F 82 DUP3 1E80 63 PUSH4 0xffffffff 1E85 61 PUSH2 0x228e 1E88 16 AND 1E89 56 *JUMP label_1E8A: // Incoming jump from 0x1671 // Incoming call from 0x1A61, returns to 0x1A62 // Inputs[2] // { // @1E8B stack[-3] // @1E98 stack[-1] // } 1E8A 5B JUMPDEST 1E8B 82 DUP3 1E8C 60 PUSH1 0x01 1E8E 60 PUSH1 0x01 1E90 60 PUSH1 0xa0 1E92 1B SHL 1E93 03 SUB 1E94 16 AND 1E95 61 PUSH2 0x1e9d 1E98 82 DUP3 1E99 61 PUSH2 0x1320 1E9C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E94 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1E95 stack[1] = 0x1e9d // @1E98 stack[2] = stack[-1] // } // Block ends with call to 0x1320, returns to 0x1E9D label_1E9D: // Incoming return from call to 0x1320 at 0x1E9C // Inputs[2] // { // @1EA6 stack[-1] // @1EA7 stack[-2] // } 1E9D 5B JUMPDEST 1E9E 60 PUSH1 0x01 1EA0 60 PUSH1 0x01 1EA2 60 PUSH1 0xa0 1EA4 1B SHL 1EA5 03 SUB 1EA6 16 AND 1EA7 14 EQ 1EA8 61 PUSH2 0x1ee2 1EAB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1ee2, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1EAC: // Incoming jump from 0x1EAB, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @1EAE memory[0x40:0x60] // @1EDC memory[0x40:0x60] // @1EE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EAC 60 PUSH1 0x40 1EAE 51 MLOAD 1EAF 62 PUSH3 0x461bcd 1EB3 60 PUSH1 0xe5 1EB5 1B SHL 1EB6 81 DUP2 1EB7 52 MSTORE 1EB8 60 PUSH1 0x04 1EBA 01 ADD 1EBB 80 DUP1 1EBC 80 DUP1 1EBD 60 PUSH1 0x20 1EBF 01 ADD 1EC0 82 DUP3 1EC1 81 DUP2 1EC2 03 SUB 1EC3 82 DUP3 1EC4 52 MSTORE 1EC5 60 PUSH1 0x29 1EC7 81 DUP2 1EC8 52 MSTORE 1EC9 60 PUSH1 0x20 1ECB 01 ADD 1ECC 80 DUP1 1ECD 61 PUSH2 0x2896 1ED0 60 PUSH1 0x29 1ED2 91 SWAP2 1ED3 39 CODECOPY 1ED4 60 PUSH1 0x40 1ED6 01 ADD 1ED7 91 SWAP2 1ED8 50 POP 1ED9 50 POP 1EDA 60 PUSH1 0x40 1EDC 51 MLOAD 1EDD 80 DUP1 1EDE 91 SWAP2 1EDF 03 SUB 1EE0 90 SWAP1 1EE1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1EB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1EC4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1EC8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @1ED3 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x2896:0x28bf] // @1EE1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1EE2: // Incoming jump from 0x1EAB, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1EEB stack[-2] } 1EE2 5B JUMPDEST 1EE3 60 PUSH1 0x01 1EE5 60 PUSH1 0x01 1EE7 60 PUSH1 0xa0 1EE9 1B SHL 1EEA 03 SUB 1EEB 82 DUP3 1EEC 16 AND 1EED 61 PUSH2 0x1f27 1EF0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f27, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1EF1: // Incoming jump from 0x1EF0, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1EF3 memory[0x40:0x60] // @1F21 memory[0x40:0x60] // @1F26 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EF1 60 PUSH1 0x40 1EF3 51 MLOAD 1EF4 62 PUSH3 0x461bcd 1EF8 60 PUSH1 0xe5 1EFA 1B SHL 1EFB 81 DUP2 1EFC 52 MSTORE 1EFD 60 PUSH1 0x04 1EFF 01 ADD 1F00 80 DUP1 1F01 80 DUP1 1F02 60 PUSH1 0x20 1F04 01 ADD 1F05 82 DUP3 1F06 81 DUP2 1F07 03 SUB 1F08 82 DUP3 1F09 52 MSTORE 1F0A 60 PUSH1 0x24 1F0C 81 DUP2 1F0D 52 MSTORE 1F0E 60 PUSH1 0x20 1F10 01 ADD 1F11 80 DUP1 1F12 61 PUSH2 0x274c 1F15 60 PUSH1 0x24 1F17 91 SWAP2 1F18 39 CODECOPY 1F19 60 PUSH1 0x40 1F1B 01 ADD 1F1C 91 SWAP2 1F1D 50 POP 1F1E 50 POP 1F1F 60 PUSH1 0x40 1F21 51 MLOAD 1F22 80 DUP1 1F23 91 SWAP2 1F24 03 SUB 1F25 90 SWAP1 1F26 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1EFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F09 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1F0D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @1F18 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x274c:0x2770] // @1F26 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1F27: // Incoming jump from 0x1EF0, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1F2B stack[-1] } 1F27 5B JUMPDEST 1F28 61 PUSH2 0x1f30 1F2B 81 DUP2 1F2C 61 PUSH2 0x230f 1F2F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F28 stack[0] = 0x1f30 // @1F2B stack[1] = stack[-1] // } // Block ends with call to 0x230f, returns to 0x1F30 label_1F30: // Incoming return from call to 0x230F at 0x1F2F // Inputs[2] // { // @1F39 stack[-3] // @1F48 memory[0x00:0x40] // } 1F30 5B JUMPDEST 1F31 60 PUSH1 0x01 1F33 60 PUSH1 0x01 1F35 60 PUSH1 0xa0 1F37 1B SHL 1F38 03 SUB 1F39 83 DUP4 1F3A 16 AND 1F3B 60 PUSH1 0x00 1F3D 90 SWAP1 1F3E 81 DUP2 1F3F 52 MSTORE 1F40 60 PUSH1 0x04 1F42 60 PUSH1 0x20 1F44 52 MSTORE 1F45 60 PUSH1 0x40 1F47 90 SWAP1 1F48 20 SHA3 1F49 61 PUSH2 0x1f51 1F4C 90 SWAP1 1F4D 61 PUSH2 0x234a 1F50 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1F3F memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1F44 memory[0x20:0x40] = 0x04 // @1F4C stack[0] = 0x1f51 // @1F4C stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x234a, returns to 0x1F51 label_1F51: // Incoming return from call to 0x234A at 0x1F50 // Inputs[2] // { // @1F5A stack[-2] // @1F69 memory[0x00:0x40] // } 1F51 5B JUMPDEST 1F52 60 PUSH1 0x01 1F54 60 PUSH1 0x01 1F56 60 PUSH1 0xa0 1F58 1B SHL 1F59 03 SUB 1F5A 82 DUP3 1F5B 16 AND 1F5C 60 PUSH1 0x00 1F5E 90 SWAP1 1F5F 81 DUP2 1F60 52 MSTORE 1F61 60 PUSH1 0x04 1F63 60 PUSH1 0x20 1F65 52 MSTORE 1F66 60 PUSH1 0x40 1F68 90 SWAP1 1F69 20 SHA3 1F6A 61 PUSH2 0x1f72 1F6D 90 SWAP1 1F6E 61 PUSH2 0x2361 1F71 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1F60 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1F65 memory[0x20:0x40] = 0x04 // @1F6D stack[0] = 0x1f72 // @1F6D stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2361, returns to 0x1F72 label_1F72: // Incoming return from call to 0x2361 at 0x1F71 // Inputs[8] // { // @1F75 stack[-1] // @1F81 memory[0x00:0x40] // @1F83 storage[keccak256(memory[0x00:0x40])] // @1F96 stack[-2] // @1FA0 memory[0x40:0x60] // @1FA4 stack[-3] // @1FC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1FCD stack[-4] // } 1F72 5B JUMPDEST 1F73 60 PUSH1 0x00 1F75 81 DUP2 1F76 81 DUP2 1F77 52 MSTORE 1F78 60 PUSH1 0x02 1F7A 60 PUSH1 0x20 1F7C 52 MSTORE 1F7D 60 PUSH1 0x40 1F7F 80 DUP1 1F80 82 DUP3 1F81 20 SHA3 1F82 80 DUP1 1F83 54 SLOAD 1F84 60 PUSH1 0x01 1F86 60 PUSH1 0x01 1F88 60 PUSH1 0xa0 1F8A 1B SHL 1F8B 03 SUB 1F8C 19 NOT 1F8D 16 AND 1F8E 60 PUSH1 0x01 1F90 60 PUSH1 0x01 1F92 60 PUSH1 0xa0 1F94 1B SHL 1F95 03 SUB 1F96 86 DUP7 1F97 81 DUP2 1F98 16 AND 1F99 91 SWAP2 1F9A 82 DUP3 1F9B 17 OR 1F9C 90 SWAP1 1F9D 92 SWAP3 1F9E 55 SSTORE 1F9F 91 SWAP2 1FA0 51 MLOAD 1FA1 84 DUP5 1FA2 93 SWAP4 1FA3 91 SWAP2 1FA4 87 DUP8 1FA5 16 AND 1FA6 91 SWAP2 1FA7 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1FC8 91 SWAP2 1FC9 A4 LOG4 1FCA 50 POP 1FCB 50 POP 1FCC 50 POP 1FCD 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1F77 memory[0x00:0x20] = stack[-1] // @1F7C memory[0x20:0x40] = 0x02 // @1F9E storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1FC9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); // } // Block ends with unconditional jump to stack[-4] label_1FCE: // Incoming call from 0x16A6, returns to 0x1374 // Incoming call from 0x2230, returns to 0x2231 // Inputs[1] { @1FD9 stack[-1] } 1FCE 5B JUMPDEST 1FCF 60 PUSH1 0x00 1FD1 60 PUSH1 0x01 1FD3 60 PUSH1 0x01 1FD5 60 PUSH1 0xa0 1FD7 1B SHL 1FD8 03 SUB 1FD9 82 DUP3 1FDA 16 AND 1FDB 61 PUSH2 0x2015 1FDE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FCF stack[0] = 0x00 } // Block ends with conditional jump to 0x2015, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1FDF: // Incoming jump from 0x1FDE, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1FE1 memory[0x40:0x60] // @200F memory[0x40:0x60] // @2014 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1FDF 60 PUSH1 0x40 1FE1 51 MLOAD 1FE2 62 PUSH3 0x461bcd 1FE6 60 PUSH1 0xe5 1FE8 1B SHL 1FE9 81 DUP2 1FEA 52 MSTORE 1FEB 60 PUSH1 0x04 1FED 01 ADD 1FEE 80 DUP1 1FEF 80 DUP1 1FF0 60 PUSH1 0x20 1FF2 01 ADD 1FF3 82 DUP3 1FF4 81 DUP2 1FF5 03 SUB 1FF6 82 DUP3 1FF7 52 MSTORE 1FF8 60 PUSH1 0x22 1FFA 81 DUP2 1FFB 52 MSTORE 1FFC 60 PUSH1 0x20 1FFE 01 ADD 1FFF 80 DUP1 2000 61 PUSH2 0x2874 2003 60 PUSH1 0x22 2005 91 SWAP2 2006 39 CODECOPY 2007 60 PUSH1 0x40 2009 01 ADD 200A 91 SWAP2 200B 50 POP 200C 50 POP 200D 60 PUSH1 0x40 200F 51 MLOAD 2010 80 DUP1 2011 91 SWAP2 2012 03 SUB 2013 90 SWAP1 2014 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1FEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1FF7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1FFB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @2006 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x2874:0x2896] // @2014 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2015: // Incoming jump from 0x1FDE, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @201F stack[-2] // @2027 stack[-3] // @202E memory[0x00:0x40] // @202F storage[keccak256(memory[0x00:0x40])] // @2033 stack[-4] // } 2015 5B JUMPDEST 2016 50 POP 2017 60 PUSH1 0x01 2019 60 PUSH1 0x01 201B 60 PUSH1 0xa0 201D 1B SHL 201E 03 SUB 201F 16 AND 2020 60 PUSH1 0x00 2022 90 SWAP1 2023 81 DUP2 2024 52 MSTORE 2025 60 PUSH1 0x20 2027 91 SWAP2 2028 90 SWAP1 2029 91 SWAP2 202A 52 MSTORE 202B 60 PUSH1 0x40 202D 90 SWAP1 202E 20 SHA3 202F 54 SLOAD 2030 60 PUSH1 0xff 2032 16 AND 2033 90 SWAP1 2034 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2024 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @202A memory[0x20:0x40] = stack[-3] // @2033 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_2035: // Incoming jump from 0x19F2 // Incoming jump from 0x1AA9 // Inputs[2] // { // @203B stack[-2] // @203C stack[-1] // } 2035 5B JUMPDEST 2036 60 PUSH1 0x00 2038 61 PUSH2 0x2041 203B 83 DUP4 203C 83 DUP4 203D 61 PUSH2 0x1dac 2040 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2036 stack[0] = 0x00 // @2038 stack[1] = 0x2041 // @203B stack[2] = stack[-2] // @203C stack[3] = stack[-1] // } // Block ends with call to 0x1dac, returns to 0x2041 label_2041: // Incoming return from call to 0x1DAC at 0x2040 // Inputs[3] // { // @2042 stack[-1] // @2042 stack[-2] // @2047 stack[-5] // } 2041 5B JUMPDEST 2042 90 SWAP1 2043 50 POP 2044 61 PUSH2 0x204d 2047 84 DUP5 2048 82 DUP3 2049 61 PUSH2 0x236a 204C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2042 stack[-2] = stack[-1] // @2044 stack[-1] = 0x204d // @2047 stack[0] = stack[-5] // @2048 stack[1] = stack[-1] // } // Block ends with call to 0x236a, returns to 0x204D label_204D: // Incoming return from call to 0x236A at 0x204C // Inputs[2] // { // @204E stack[-2] // @204F memory[stack[-2]:stack[-2] + 0x20] // } 204D 5B JUMPDEST 204E 81 DUP2 204F 51 MLOAD 2050 61 PUSH2 0x2058 2053 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2058, if memory[stack[-2]:stack[-2] + 0x20] label_2054: // Incoming jump from 0x2053, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @2057 memory[0x00:0x00] } 2054 60 PUSH1 0x00 2056 80 DUP1 2057 FD *REVERT // Stack delta = +0 // Outputs[1] { @2057 revert(memory[0x00:0x00]); } // Block terminates label_2058: // Incoming jump from 0x2053, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @205C stack[-1] } 2058 5B JUMPDEST 2059 61 PUSH2 0x2061 205C 81 DUP2 205D 61 PUSH2 0x1ac9 2060 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2059 stack[0] = 0x2061 // @205C stack[1] = stack[-1] // } // Block ends with call to 0x1ac9, returns to 0x2061 label_2061: // Incoming return from call to 0x1AC9 at 0x2060 // Inputs[1] { @2065 stack[-1] } 2061 5B JUMPDEST 2062 61 PUSH2 0x206a 2065 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x206a, if stack[-1] label_2066: // Incoming jump from 0x2065, if not stack[-1] // Inputs[1] { @2069 memory[0x00:0x00] } 2066 60 PUSH1 0x00 2068 80 DUP1 2069 FD *REVERT // Stack delta = +0 // Outputs[1] { @2069 revert(memory[0x00:0x00]); } // Block terminates label_206A: // Incoming jump from 0x2065, if stack[-1] // Inputs[5] // { // @206D stack[-2] // @2072 stack[-3] // @2080 memory[0x00:0x40] // @2083 memory[0x40:0x60] // @208A memory[stack[-2]:stack[-2] + 0x20] // } 206A 5B JUMPDEST 206B 60 PUSH1 0x60 206D 82 DUP3 206E 60 PUSH1 0x06 2070 60 PUSH1 0x00 2072 86 DUP7 2073 81 DUP2 2074 52 MSTORE 2075 60 PUSH1 0x20 2077 01 ADD 2078 90 SWAP1 2079 81 DUP2 207A 52 MSTORE 207B 60 PUSH1 0x20 207D 01 ADD 207E 60 PUSH1 0x00 2080 20 SHA3 2081 60 PUSH1 0x40 2083 51 MLOAD 2084 60 PUSH1 0x20 2086 01 ADD 2087 80 DUP1 2088 83 DUP4 2089 80 DUP1 208A 51 MLOAD 208B 90 SWAP1 208C 60 PUSH1 0x20 208E 01 ADD 208F 90 SWAP1 2090 80 DUP1 2091 83 DUP4 2092 83 DUP4 2093 5B JUMPDEST 2094 60 PUSH1 0x20 2096 83 DUP4 2097 10 LT 2098 61 PUSH2 0x20b2 209B 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @206B stack[0] = 0x60 // @206D stack[1] = stack[-2] // @2074 memory[0x00:0x20] = stack[-3] // @207A memory[0x20:0x40] = 0x06 // @2080 stack[2] = keccak256(memory[0x00:0x40]) // @2086 stack[3] = 0x20 + memory[0x40:0x60] // @2087 stack[4] = 0x20 + memory[0x40:0x60] // @208F stack[5] = 0x20 + stack[-2] // @208F stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @2090 stack[7] = memory[stack[-2]:stack[-2] + 0x20] // @2091 stack[8] = 0x20 + memory[0x40:0x60] // @2092 stack[9] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x20b2, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 label_209C: // Incoming jump from 0x209B, if not stack[-3] < 0x20 // Incoming jump from 0x209B, if not memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Inputs[4] // { // @209C stack[-1] // @209D memory[stack[-1]:stack[-1] + 0x20] // @209E stack[-2] // @20A4 stack[-3] // } 209C 80 DUP1 209D 51 MLOAD 209E 82 DUP3 209F 52 MSTORE 20A0 60 PUSH1 0x1f 20A2 19 NOT 20A3 90 SWAP1 20A4 92 SWAP3 20A5 01 ADD 20A6 91 SWAP2 20A7 60 PUSH1 0x20 20A9 91 SWAP2 20AA 82 DUP3 20AB 01 ADD 20AC 91 SWAP2 20AD 01 ADD 20AE 61 PUSH2 0x2093 20B1 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @209F memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @20A6 stack[-3] = stack[-3] + ~0x1f // @20AC stack[-2] = 0x20 + stack[-2] // @20AD stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2093 label_20B2: // Incoming jump from 0x209B, if stack[-3] < 0x20 // Incoming jump from 0x209B, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Inputs[10] // { // @20B5 stack[-3] // @20C0 stack[-1] // @20C1 memory[stack[-1]:stack[-1] + 0x20] // @20C4 stack[-2] // @20C5 memory[stack[-2]:stack[-2] + 0x20] // @20D2 stack[-4] // @20D2 stack[-5] // @20D4 stack[-6] // @20E1 stack[-8] // @20E3 storage[stack[-8]] // } 20B2 5B JUMPDEST 20B3 60 PUSH1 0x01 20B5 83 DUP4 20B6 60 PUSH1 0x20 20B8 03 SUB 20B9 61 PUSH2 0x0100 20BC 0A EXP 20BD 03 SUB 20BE 80 DUP1 20BF 19 NOT 20C0 82 DUP3 20C1 51 MLOAD 20C2 16 AND 20C3 81 DUP2 20C4 84 DUP5 20C5 51 MLOAD 20C6 16 AND 20C7 80 DUP1 20C8 82 DUP3 20C9 17 OR 20CA 85 DUP6 20CB 52 MSTORE 20CC 50 POP 20CD 50 POP 20CE 50 POP 20CF 50 POP 20D0 50 POP 20D1 50 POP 20D2 90 SWAP1 20D3 50 POP 20D4 01 ADD 20D5 80 DUP1 20D6 60 PUSH1 0x17 20D8 60 PUSH1 0xf9 20DA 1B SHL 20DB 81 DUP2 20DC 52 MSTORE 20DD 50 POP 20DE 60 PUSH1 0x01 20E0 01 ADD 20E1 82 DUP3 20E2 80 DUP1 20E3 54 SLOAD 20E4 60 PUSH1 0x01 20E6 81 DUP2 20E7 60 PUSH1 0x01 20E9 16 AND 20EA 15 ISZERO 20EB 61 PUSH2 0x0100 20EE 02 MUL 20EF 03 SUB 20F0 16 AND 20F1 60 PUSH1 0x02 20F3 90 SWAP1 20F4 04 DIV 20F5 80 DUP1 20F6 15 ISZERO 20F7 61 PUSH2 0x2137 20FA 57 *JUMPI // Stack delta = -3 // Outputs[5] // { // @20CB memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @20DC memory[stack[-4] + stack[-6]:stack[-4] + stack[-6] + 0x20] = 0x17 << 0xf9 // @20E0 stack[-6] = 0x01 + stack[-4] + stack[-6] // @20E1 stack[-5] = stack[-8] // @20F4 stack[-4] = (0x0100 * !(0x01 & storage[stack[-8]]) - 0x01 & storage[stack[-8]]) / 0x02 // } // Block ends with conditional jump to 0x2137, if !((0x0100 * !(0x01 & storage[stack[-8]]) - 0x01 & storage[stack[-8]]) / 0x02) label_20FB: // Incoming jump from 0x20FA, if not !((0x0100 * !(0x01 & storage[stack[-8]]) - 0x01 & storage[stack[-8]]) / 0x02) // Inputs[1] { @20FB stack[-1] } 20FB 80 DUP1 20FC 60 PUSH1 0x1f 20FE 10 LT 20FF 61 PUSH2 0x2115 2102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2115, if 0x1f < stack[-1] label_2103: // Incoming jump from 0x2102, if not 0x1f < stack[-1] // Inputs[4] // { // @2107 stack[-2] // @2108 storage[stack[-2]] // @210B stack[-3] // @210D stack[-1] // } 2103 61 PUSH2 0x0100 2106 80 DUP1 2107 83 DUP4 2108 54 SLOAD 2109 04 DIV 210A 02 MUL 210B 83 DUP4 210C 52 MSTORE 210D 91 SWAP2 210E 82 DUP3 210F 01 ADD 2110 91 SWAP2 2111 61 PUSH2 0x2137 2114 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @210C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2110 stack[-1] = stack[-1] // @2110 stack[-3] = stack[-1] + stack[-3] // } // Block ends with unconditional jump to 0x2137 label_2115: // Incoming jump from 0x2102, if 0x1f < stack[-1] // Inputs[5] // { // @2116 stack[-3] // @2117 stack[-1] // @2119 stack[-2] // @2121 memory[0x00:0x20] // @2125 storage[keccak256(memory[0x00:0x20])] // } 2115 5B JUMPDEST 2116 82 DUP3 2117 01 ADD 2118 91 SWAP2 2119 90 SWAP1 211A 60 PUSH1 0x00 211C 52 MSTORE 211D 60 PUSH1 0x20 211F 60 PUSH1 0x00 2121 20 SHA3 2122 90 SWAP1 2123 5B JUMPDEST 2124 81 DUP2 2125 54 SLOAD 2126 81 DUP2 2127 52 MSTORE 2128 90 SWAP1 2129 60 PUSH1 0x01 212B 01 ADD 212C 90 SWAP1 212D 60 PUSH1 0x20 212F 01 ADD 2130 80 DUP1 2131 83 DUP4 2132 11 GT 2133 61 PUSH2 0x2123 2136 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @2118 stack[-3] = stack[-3] + stack[-1] // @211C memory[0x00:0x20] = stack[-2] // @2127 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @212C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @212F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2123, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2137: // Incoming jump from 0x2114 // Incoming jump from 0x2136, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x20FA, if !((0x0100 * !(0x01 & storage[stack[-8]]) - 0x01 & storage[stack[-8]]) / 0x02) // Incoming jump from 0x2136, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[9] // { // @213D memory[0x40:0x60] // @2142 stack[-3] // @214C stack[-8] // @2158 memory[0x00:0x40] // @215A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @215C stack[-7] // @2161 stack[-6] // @2163 stack[-5] // @2167 stack[-4] // } 2137 5B JUMPDEST 2138 50 POP 2139 50 POP 213A 60 PUSH1 0x40 213C 80 DUP1 213D 51 MLOAD 213E 60 PUSH1 0x1f 2140 19 NOT 2141 81 DUP2 2142 84 DUP5 2143 03 SUB 2144 01 ADD 2145 81 DUP2 2146 52 MSTORE 2147 91 SWAP2 2148 81 DUP2 2149 52 MSTORE 214A 60 PUSH1 0x00 214C 87 DUP8 214D 81 DUP2 214E 52 MSTORE 214F 60 PUSH1 0x06 2151 60 PUSH1 0x20 2153 90 SWAP1 2154 81 DUP2 2155 52 MSTORE 2156 91 SWAP2 2157 90 SWAP1 2158 20 SHA3 2159 82 DUP3 215A 51 MLOAD 215B 92 SWAP3 215C 96 SWAP7 215D 50 POP 215E 61 PUSH2 0x216d 2161 95 SWAP6 2162 50 POP 2163 93 SWAP4 2164 50 POP 2165 85 DUP6 2166 01 ADD 2167 91 SWAP2 2168 50 POP 2169 61 PUSH2 0x2691 216C 56 *JUMP // Stack delta = -2 // Outputs[9] // { // @2146 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] - memory[0x40:0x60] + ~0x1f // @2149 memory[0x40:0x60] = stack[-3] // @214E memory[0x00:0x20] = stack[-8] // @2155 memory[0x20:0x40] = 0x06 // @215B stack[-3] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @215C stack[-7] = memory[0x40:0x60] // @2161 stack[-6] = 0x216d // @2163 stack[-5] = keccak256(memory[0x00:0x40]) // @2167 stack[-4] = memory[0x40:0x60] + 0x20 // } // Block ends with unconditional jump to 0x2691 216D 5B JUMPDEST 216E 50 POP 216F 81 DUP2 2170 7F PUSH32 0xc5beef08f693b11c316c0c8394a377a0033c9cf701b8cd8afd79cecef60c3952 2191 82 DUP3 2192 60 PUSH1 0x40 2194 51 MLOAD 2195 80 DUP1 2196 80 DUP1 2197 60 PUSH1 0x20 2199 01 ADD 219A 82 DUP3 219B 81 DUP2 219C 03 SUB 219D 82 DUP3 219E 52 MSTORE 219F 83 DUP4 21A0 81 DUP2 21A1 81 DUP2 21A2 51 MLOAD 21A3 81 DUP2 21A4 52 MSTORE 21A5 60 PUSH1 0x20 21A7 01 ADD 21A8 91 SWAP2 21A9 50 POP 21AA 80 DUP1 21AB 51 MLOAD 21AC 90 SWAP1 21AD 60 PUSH1 0x20 21AF 01 ADD 21B0 90 SWAP1 21B1 80 DUP1 21B2 83 DUP4 21B3 83 DUP4 21B4 60 PUSH1 0x00 21B6 5B JUMPDEST 21B7 83 DUP4 21B8 81 DUP2 21B9 10 LT 21BA 15 ISZERO 21BB 61 PUSH2 0x21ce 21BE 57 *JUMPI 21BF 81 DUP2 21C0 81 DUP2 21C1 01 ADD 21C2 51 MLOAD 21C3 83 DUP4 21C4 82 DUP3 21C5 01 ADD 21C6 52 MSTORE 21C7 60 PUSH1 0x20 21C9 01 ADD 21CA 61 PUSH2 0x21b6 21CD 56 *JUMP 21CE 5B JUMPDEST 21CF 50 POP 21D0 50 POP 21D1 50 POP 21D2 50 POP 21D3 90 SWAP1 21D4 50 POP 21D5 90 SWAP1 21D6 81 DUP2 21D7 01 ADD 21D8 90 SWAP1 21D9 60 PUSH1 0x1f 21DB 16 AND 21DC 80 DUP1 21DD 15 ISZERO 21DE 61 PUSH2 0x21fb 21E1 57 *JUMPI 21E2 80 DUP1 21E3 82 DUP3 21E4 03 SUB 21E5 80 DUP1 21E6 51 MLOAD 21E7 60 PUSH1 0x01 21E9 83 DUP4 21EA 60 PUSH1 0x20 21EC 03 SUB 21ED 61 PUSH2 0x0100 21F0 0A EXP 21F1 03 SUB 21F2 19 NOT 21F3 16 AND 21F4 81 DUP2 21F5 52 MSTORE 21F6 60 PUSH1 0x20 21F8 01 ADD 21F9 91 SWAP2 21FA 50 POP 21FB 5B JUMPDEST 21FC 50 POP 21FD 92 SWAP3 21FE 50 POP 21FF 50 POP 2200 50 POP 2201 60 PUSH1 0x40 2203 51 MLOAD 2204 80 DUP1 2205 91 SWAP2 2206 03 SUB 2207 90 SWAP1 2208 A2 LOG2 2209 50 POP 220A 50 POP 220B 50 POP 220C 50 POP 220D 50 POP 220E 56 *JUMP label_220F: // Incoming jump from 0x1C00 // Inputs[1] { @2216 stack[-1] } 220F 5B JUMPDEST 2210 61 PUSH2 0x11e3 2213 61 PUSH2 0x221b 2216 82 DUP3 2217 61 PUSH2 0x1320 221A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2210 stack[0] = 0x11e3 // @2213 stack[1] = 0x221b // @2216 stack[2] = stack[-1] // } // Block ends with call to 0x1320, returns to 0x221B label_221B: // Incoming return from call to 0x1320 at 0x221A // Inputs[1] { @221C stack[-3] } 221B 5B JUMPDEST 221C 82 DUP3 221D 61 PUSH2 0x249b 2220 56 *JUMP // Stack delta = +1 // Outputs[1] { @221C stack[0] = stack[-3] } // Block ends with unconditional jump to 0x249b label_2221: // Incoming call from 0x1C8C, returns to 0x1C8D // Inputs[3] // { // @2222 address(stack[-1]).code.length // @2222 stack[-1] // @2225 stack[-2] // } 2221 5B JUMPDEST 2222 3B EXTCODESIZE 2223 15 ISZERO 2224 15 ISZERO 2225 90 SWAP1 2226 56 *JUMP // Stack delta = -1 // Outputs[1] { @2225 stack[-2] = !!address(stack[-1]).code.length } // Block ends with unconditional jump to stack[-2] label_2227: // Incoming call from 0x1E74, returns to 0x11E3 // Inputs[2] // { // @222B stack[-2] // @222C stack[-1] // } 2227 5B JUMPDEST 2228 61 PUSH2 0x2231 222B 82 DUP3 222C 82 DUP3 222D 61 PUSH2 0x1fce 2230 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2228 stack[0] = 0x2231 // @222B stack[1] = stack[-2] // @222C stack[2] = stack[-1] // } // Block ends with call to 0x1fce, returns to 0x2231 label_2231: // Incoming return from call to 0x1FCE at 0x2230 // Inputs[1] { @2235 stack[-1] } 2231 5B JUMPDEST 2232 61 PUSH2 0x226c 2235 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x226c, if stack[-1] label_2236: // Incoming jump from 0x2235, if not stack[-1] // Inputs[3] // { // @2238 memory[0x40:0x60] // @2266 memory[0x40:0x60] // @226B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2236 60 PUSH1 0x40 2238 51 MLOAD 2239 62 PUSH3 0x461bcd 223D 60 PUSH1 0xe5 223F 1B SHL 2240 81 DUP2 2241 52 MSTORE 2242 60 PUSH1 0x04 2244 01 ADD 2245 80 DUP1 2246 80 DUP1 2247 60 PUSH1 0x20 2249 01 ADD 224A 82 DUP3 224B 81 DUP2 224C 03 SUB 224D 82 DUP3 224E 52 MSTORE 224F 60 PUSH1 0x21 2251 81 DUP2 2252 52 MSTORE 2253 60 PUSH1 0x20 2255 01 ADD 2256 80 DUP1 2257 61 PUSH2 0x2827 225A 60 PUSH1 0x21 225C 91 SWAP2 225D 39 CODECOPY 225E 60 PUSH1 0x40 2260 01 ADD 2261 91 SWAP2 2262 50 POP 2263 50 POP 2264 60 PUSH1 0x40 2266 51 MLOAD 2267 80 DUP1 2268 91 SWAP2 2269 03 SUB 226A 90 SWAP1 226B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2241 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @224E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2252 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @225D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x2827:0x2848] // @226B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_226C: // Incoming jump from 0x2235, if stack[-1] // Inputs[5] // { // @2275 stack[-1] // @227D stack[-2] // @2284 memory[0x00:0x40] // @2286 storage[keccak256(memory[0x00:0x40])] // @228D stack[-3] // } 226C 5B JUMPDEST 226D 60 PUSH1 0x01 226F 60 PUSH1 0x01 2271 60 PUSH1 0xa0 2273 1B SHL 2274 03 SUB 2275 16 AND 2276 60 PUSH1 0x00 2278 90 SWAP1 2279 81 DUP2 227A 52 MSTORE 227B 60 PUSH1 0x20 227D 91 SWAP2 227E 90 SWAP1 227F 91 SWAP2 2280 52 MSTORE 2281 60 PUSH1 0x40 2283 90 SWAP1 2284 20 SHA3 2285 80 DUP1 2286 54 SLOAD 2287 60 PUSH1 0xff 2289 19 NOT 228A 16 AND 228B 90 SWAP1 228C 55 SSTORE 228D 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @227A memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2280 memory[0x20:0x40] = stack[-2] // @228C storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 228E 5B JUMPDEST 228F 61 PUSH2 0x2298 2292 82 DUP3 2293 82 DUP3 2294 61 PUSH2 0x1fce 2297 56 *JUMP 2298 5B JUMPDEST 2299 15 ISZERO 229A 61 PUSH2 0x22ea 229D 57 *JUMPI 229E 60 PUSH1 0x40 22A0 80 DUP1 22A1 51 MLOAD 22A2 62 PUSH3 0x461bcd 22A6 60 PUSH1 0xe5 22A8 1B SHL 22A9 81 DUP2 22AA 52 MSTORE 22AB 60 PUSH1 0x20 22AD 60 PUSH1 0x04 22AF 82 DUP3 22B0 01 ADD 22B1 52 MSTORE 22B2 60 PUSH1 0x1f 22B4 60 PUSH1 0x24 22B6 82 DUP3 22B7 01 ADD 22B8 52 MSTORE 22B9 7F PUSH32 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 22DA 60 PUSH1 0x44 22DC 82 DUP3 22DD 01 ADD 22DE 52 MSTORE 22DF 90 SWAP1 22E0 51 MLOAD 22E1 90 SWAP1 22E2 81 DUP2 22E3 90 SWAP1 22E4 03 SUB 22E5 60 PUSH1 0x64 22E7 01 ADD 22E8 90 SWAP1 22E9 FD *REVERT 22EA 5B JUMPDEST 22EB 60 PUSH1 0x01 22ED 60 PUSH1 0x01 22EF 60 PUSH1 0xa0 22F1 1B SHL 22F2 03 SUB 22F3 16 AND 22F4 60 PUSH1 0x00 22F6 90 SWAP1 22F7 81 DUP2 22F8 52 MSTORE 22F9 60 PUSH1 0x20 22FB 91 SWAP2 22FC 90 SWAP1 22FD 91 SWAP2 22FE 52 MSTORE 22FF 60 PUSH1 0x40 2301 90 SWAP1 2302 20 SHA3 2303 80 DUP1 2304 54 SLOAD 2305 60 PUSH1 0xff 2307 19 NOT 2308 16 AND 2309 60 PUSH1 0x01 230B 17 OR 230C 90 SWAP1 230D 55 SSTORE 230E 56 *JUMP label_230F: // Incoming call from 0x24FB, returns to 0x24FC // Incoming call from 0x1F2F, returns to 0x1F30 // Inputs[3] // { // @2312 stack[-1] // @231D memory[0x00:0x40] // @231E storage[keccak256(memory[0x00:0x40])] // } 230F 5B JUMPDEST 2310 60 PUSH1 0x00 2312 81 DUP2 2313 81 DUP2 2314 52 MSTORE 2315 60 PUSH1 0x03 2317 60 PUSH1 0x20 2319 52 MSTORE 231A 60 PUSH1 0x40 231C 90 SWAP1 231D 20 SHA3 231E 54 SLOAD 231F 60 PUSH1 0x01 2321 60 PUSH1 0x01 2323 60 PUSH1 0xa0 2325 1B SHL 2326 03 SUB 2327 16 AND 2328 15 ISZERO 2329 61 PUSH2 0x11e3 232C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2314 memory[0x00:0x20] = stack[-1] // @2319 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x11e3, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_232D: // Incoming jump from 0x232C, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @232F stack[-1] // @233A memory[0x00:0x40] // @233C storage[keccak256(memory[0x00:0x40])] // @2349 stack[-2] // } 232D 60 PUSH1 0x00 232F 90 SWAP1 2330 81 DUP2 2331 52 MSTORE 2332 60 PUSH1 0x03 2334 60 PUSH1 0x20 2336 52 MSTORE 2337 60 PUSH1 0x40 2339 90 SWAP1 233A 20 SHA3 233B 80 DUP1 233C 54 SLOAD 233D 60 PUSH1 0x01 233F 60 PUSH1 0x01 2341 60 PUSH1 0xa0 2343 1B SHL 2344 03 SUB 2345 19 NOT 2346 16 AND 2347 90 SWAP1 2348 55 SSTORE 2349 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2331 memory[0x00:0x20] = stack[-1] // @2336 memory[0x20:0x40] = 0x03 // @2348 storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_234A: // Incoming call from 0x1F50, returns to 0x1F51 // Incoming call from 0x251C, returns to 0x251D // Inputs[2] // { // @234B stack[-1] // @234C storage[stack[-1]] // } 234A 5B JUMPDEST 234B 80 DUP1 234C 54 SLOAD 234D 61 PUSH2 0x235d 2350 90 SWAP1 2351 60 PUSH1 0x01 2353 63 PUSH4 0xffffffff 2358 61 PUSH2 0x2572 235B 16 AND 235C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2350 stack[0] = 0x235d // @2350 stack[1] = storage[stack[-1]] // @2351 stack[2] = 0x01 // } // Block ends with call to 0x2572 & 0xffffffff, returns to 0x235D label_235D: // Incoming return from call to 0x2572 at 0x235C // Inputs[3] // { // @235E stack[-1] // @235E stack[-2] // @2360 stack[-3] // } 235D 5B JUMPDEST 235E 90 SWAP1 235F 55 SSTORE 2360 56 *JUMP // Stack delta = -3 // Outputs[1] { @235F storage[stack[-2]] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2361: // Incoming call from 0x245E, returns to 0x245F // Incoming call from 0x1F71, returns to 0x1F72 // Inputs[3] // { // @2362 stack[-1] // @2363 storage[stack[-1]] // @2369 stack[-2] // } 2361 5B JUMPDEST 2362 80 DUP1 2363 54 SLOAD 2364 60 PUSH1 0x01 2366 01 ADD 2367 90 SWAP1 2368 55 SSTORE 2369 56 *JUMP // Stack delta = -2 // Outputs[1] { @2368 storage[stack[-1]] = 0x01 + storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] label_236A: // Incoming call from 0x204C, returns to 0x204D // Inputs[1] { @2373 stack[-2] } 236A 5B JUMPDEST 236B 60 PUSH1 0x01 236D 60 PUSH1 0x01 236F 60 PUSH1 0xa0 2371 1B SHL 2372 03 SUB 2373 82 DUP3 2374 16 AND 2375 61 PUSH2 0x23c5 2378 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23c5, if stack[-2] & (0x01 << 0xa0) - 0x01 label_2379: // Incoming jump from 0x2378, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @237C memory[0x40:0x60] // @23BB memory[0x40:0x60] // @23C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2379 60 PUSH1 0x40 237B 80 DUP1 237C 51 MLOAD 237D 62 PUSH3 0x461bcd 2381 60 PUSH1 0xe5 2383 1B SHL 2384 81 DUP2 2385 52 MSTORE 2386 60 PUSH1 0x20 2388 60 PUSH1 0x04 238A 82 DUP3 238B 01 ADD 238C 81 DUP2 238D 90 SWAP1 238E 52 MSTORE 238F 60 PUSH1 0x24 2391 82 DUP3 2392 01 ADD 2393 52 MSTORE 2394 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 23B5 60 PUSH1 0x44 23B7 82 DUP3 23B8 01 ADD 23B9 52 MSTORE 23BA 90 SWAP1 23BB 51 MLOAD 23BC 90 SWAP1 23BD 81 DUP2 23BE 90 SWAP1 23BF 03 SUB 23C0 60 PUSH1 0x64 23C2 01 ADD 23C3 90 SWAP1 23C4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2385 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @238E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2393 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @23B9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @23C4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_23C5: // Incoming jump from 0x2378, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @23C9 stack[-1] } 23C5 5B JUMPDEST 23C6 61 PUSH2 0x23ce 23C9 81 DUP2 23CA 61 PUSH2 0x1ac9 23CD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23C6 stack[0] = 0x23ce // @23C9 stack[1] = stack[-1] // } // Block ends with call to 0x1ac9, returns to 0x23CE label_23CE: // Incoming return from call to 0x1AC9 at 0x23CD // Inputs[1] { @23CF stack[-1] } 23CE 5B JUMPDEST 23CF 15 ISZERO 23D0 61 PUSH2 0x2420 23D3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2420, if !stack[-1] label_23D4: // Incoming jump from 0x23D3, if not !stack[-1] // Inputs[3] // { // @23D7 memory[0x40:0x60] // @2416 memory[0x40:0x60] // @241F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 23D4 60 PUSH1 0x40 23D6 80 DUP1 23D7 51 MLOAD 23D8 62 PUSH3 0x461bcd 23DC 60 PUSH1 0xe5 23DE 1B SHL 23DF 81 DUP2 23E0 52 MSTORE 23E1 60 PUSH1 0x20 23E3 60 PUSH1 0x04 23E5 82 DUP3 23E6 01 ADD 23E7 52 MSTORE 23E8 60 PUSH1 0x1c 23EA 60 PUSH1 0x24 23EC 82 DUP3 23ED 01 ADD 23EE 52 MSTORE 23EF 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2410 60 PUSH1 0x44 2412 82 DUP3 2413 01 ADD 2414 52 MSTORE 2415 90 SWAP1 2416 51 MLOAD 2417 90 SWAP1 2418 81 DUP2 2419 90 SWAP1 241A 03 SUB 241B 60 PUSH1 0x64 241D 01 ADD 241E 90 SWAP1 241F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @23E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @23E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @23EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @2414 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @241F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2420: // Incoming jump from 0x23D3, if !stack[-1] // Inputs[5] // { // @2423 stack[-1] // @2431 memory[0x00:0x40] // @2433 storage[keccak256(memory[0x00:0x40])] // @2446 stack[-2] // @2456 memory[0x00:0x40] // } 2420 5B JUMPDEST 2421 60 PUSH1 0x00 2423 81 DUP2 2424 81 DUP2 2425 52 MSTORE 2426 60 PUSH1 0x02 2428 60 PUSH1 0x20 242A 90 SWAP1 242B 81 DUP2 242C 52 MSTORE 242D 60 PUSH1 0x40 242F 80 DUP1 2430 83 DUP4 2431 20 SHA3 2432 80 DUP1 2433 54 SLOAD 2434 60 PUSH1 0x01 2436 60 PUSH1 0x01 2438 60 PUSH1 0xa0 243A 1B SHL 243B 03 SUB 243C 19 NOT 243D 16 AND 243E 60 PUSH1 0x01 2440 60 PUSH1 0x01 2442 60 PUSH1 0xa0 2444 1B SHL 2445 03 SUB 2446 87 DUP8 2447 16 AND 2448 90 SWAP1 2449 81 DUP2 244A 17 OR 244B 90 SWAP1 244C 91 SWAP2 244D 55 SSTORE 244E 83 DUP4 244F 52 MSTORE 2450 60 PUSH1 0x04 2452 90 SWAP1 2453 91 SWAP2 2454 52 MSTORE 2455 90 SWAP1 2456 20 SHA3 2457 61 PUSH2 0x245f 245A 90 SWAP1 245B 61 PUSH2 0x2361 245E 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @2425 memory[0x00:0x20] = stack[-1] // @242C memory[0x20:0x40] = 0x02 // @244D storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @244F memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @2454 memory[0x20:0x40] = 0x04 // @245A stack[0] = 0x245f // @245A stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2361, returns to 0x245F label_245F: // Incoming return from call to 0x2361 at 0x245E // Inputs[5] // { // @2462 memory[0x40:0x60] // @2463 stack[-1] // @246D stack[-2] // @2497 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @249A stack[-3] // } 245F 5B JUMPDEST 2460 60 PUSH1 0x40 2462 51 MLOAD 2463 81 DUP2 2464 90 SWAP1 2465 60 PUSH1 0x01 2467 60 PUSH1 0x01 2469 60 PUSH1 0xa0 246B 1B SHL 246C 03 SUB 246D 84 DUP5 246E 16 AND 246F 90 SWAP1 2470 60 PUSH1 0x00 2472 90 SWAP1 2473 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2494 90 SWAP1 2495 82 DUP3 2496 90 SWAP1 2497 A4 LOG4 2498 50 POP 2499 50 POP 249A 56 *JUMP // Stack delta = -3 // Outputs[1] { @2497 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1]]); } // Block ends with unconditional jump to stack[-3] label_249B: // Incoming jump from 0x2220 // Inputs[2] // { // @249C stack[-2] // @24A9 stack[-1] // } 249B 5B JUMPDEST 249C 81 DUP2 249D 60 PUSH1 0x01 249F 60 PUSH1 0x01 24A1 60 PUSH1 0xa0 24A3 1B SHL 24A4 03 SUB 24A5 16 AND 24A6 61 PUSH2 0x24ae 24A9 82 DUP3 24AA 61 PUSH2 0x1320 24AD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24A5 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @24A6 stack[1] = 0x24ae // @24A9 stack[2] = stack[-1] // } // Block ends with call to 0x1320, returns to 0x24AE label_24AE: // Incoming return from call to 0x1320 at 0x24AD // Inputs[2] // { // @24B7 stack[-1] // @24B8 stack[-2] // } 24AE 5B JUMPDEST 24AF 60 PUSH1 0x01 24B1 60 PUSH1 0x01 24B3 60 PUSH1 0xa0 24B5 1B SHL 24B6 03 SUB 24B7 16 AND 24B8 14 EQ 24B9 61 PUSH2 0x24f3 24BC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x24f3, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_24BD: // Incoming jump from 0x24BC, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @24BF memory[0x40:0x60] // @24ED memory[0x40:0x60] // @24F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 24BD 60 PUSH1 0x40 24BF 51 MLOAD 24C0 62 PUSH3 0x461bcd 24C4 60 PUSH1 0xe5 24C6 1B SHL 24C7 81 DUP2 24C8 52 MSTORE 24C9 60 PUSH1 0x04 24CB 01 ADD 24CC 80 DUP1 24CD 80 DUP1 24CE 60 PUSH1 0x20 24D0 01 ADD 24D1 82 DUP3 24D2 81 DUP2 24D3 03 SUB 24D4 82 DUP3 24D5 52 MSTORE 24D6 60 PUSH1 0x25 24D8 81 DUP2 24D9 52 MSTORE 24DA 60 PUSH1 0x20 24DC 01 ADD 24DD 80 DUP1 24DE 61 PUSH2 0x2911 24E1 60 PUSH1 0x25 24E3 91 SWAP2 24E4 39 CODECOPY 24E5 60 PUSH1 0x40 24E7 01 ADD 24E8 91 SWAP2 24E9 50 POP 24EA 50 POP 24EB 60 PUSH1 0x40 24ED 51 MLOAD 24EE 80 DUP1 24EF 91 SWAP2 24F0 03 SUB 24F1 90 SWAP1 24F2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @24C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @24D5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @24D9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @24E4 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2911:0x2936] // @24F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_24F3: // Incoming jump from 0x24BC, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @24F7 stack[-1] } 24F3 5B JUMPDEST 24F4 61 PUSH2 0x24fc 24F7 81 DUP2 24F8 61 PUSH2 0x230f 24FB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24F4 stack[0] = 0x24fc // @24F7 stack[1] = stack[-1] // } // Block ends with call to 0x230f, returns to 0x24FC label_24FC: // Incoming return from call to 0x230F at 0x24FB // Inputs[2] // { // @2505 stack[-2] // @2514 memory[0x00:0x40] // } 24FC 5B JUMPDEST 24FD 60 PUSH1 0x01 24FF 60 PUSH1 0x01 2501 60 PUSH1 0xa0 2503 1B SHL 2504 03 SUB 2505 82 DUP3 2506 16 AND 2507 60 PUSH1 0x00 2509 90 SWAP1 250A 81 DUP2 250B 52 MSTORE 250C 60 PUSH1 0x04 250E 60 PUSH1 0x20 2510 52 MSTORE 2511 60 PUSH1 0x40 2513 90 SWAP1 2514 20 SHA3 2515 61 PUSH2 0x251d 2518 90 SWAP1 2519 61 PUSH2 0x234a 251C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @250B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @2510 memory[0x20:0x40] = 0x04 // @2518 stack[0] = 0x251d // @2518 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x234a, returns to 0x251D label_251D: // Incoming return from call to 0x234A at 0x251C // Inputs[7] // { // @2520 stack[-1] // @252C memory[0x00:0x40] // @252E storage[keccak256(memory[0x00:0x40])] // @253B memory[0x40:0x60] // @2547 stack[-2] // @256E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2571 stack[-3] // } 251D 5B JUMPDEST 251E 60 PUSH1 0x00 2520 81 DUP2 2521 81 DUP2 2522 52 MSTORE 2523 60 PUSH1 0x02 2525 60 PUSH1 0x20 2527 52 MSTORE 2528 60 PUSH1 0x40 252A 80 DUP1 252B 82 DUP3 252C 20 SHA3 252D 80 DUP1 252E 54 SLOAD 252F 60 PUSH1 0x01 2531 60 PUSH1 0x01 2533 60 PUSH1 0xa0 2535 1B SHL 2536 03 SUB 2537 19 NOT 2538 16 AND 2539 90 SWAP1 253A 55 SSTORE 253B 51 MLOAD 253C 82 DUP3 253D 91 SWAP2 253E 90 SWAP1 253F 60 PUSH1 0x01 2541 60 PUSH1 0x01 2543 60 PUSH1 0xa0 2545 1B SHL 2546 03 SUB 2547 85 DUP6 2548 16 AND 2549 90 SWAP1 254A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 256B 90 SWAP1 256C 83 DUP4 256D 90 SWAP1 256E A4 LOG4 256F 50 POP 2570 50 POP 2571 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @2522 memory[0x00:0x20] = stack[-1] // @2527 memory[0x20:0x40] = 0x02 // @253A storage[keccak256(memory[0x00:0x40])] = ~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])] // @256E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-2] & (0x01 << 0xa0) - 0x01, 0x00, stack[-1]]); // } // Block ends with unconditional jump to stack[-3] label_2572: // Incoming call from 0x235C, returns to 0x235D // Inputs[2] // { // @2575 stack[-2] // @2576 stack[-1] // } 2572 5B JUMPDEST 2573 60 PUSH1 0x00 2575 82 DUP3 2576 82 DUP3 2577 11 GT 2578 15 ISZERO 2579 61 PUSH2 0x25c9 257C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2573 stack[0] = 0x00 } // Block ends with conditional jump to 0x25c9, if !(stack[-1] > stack[-2]) label_257D: // Incoming jump from 0x257C, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @2580 memory[0x40:0x60] // @25BF memory[0x40:0x60] // @25C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 257D 60 PUSH1 0x40 257F 80 DUP1 2580 51 MLOAD 2581 62 PUSH3 0x461bcd 2585 60 PUSH1 0xe5 2587 1B SHL 2588 81 DUP2 2589 52 MSTORE 258A 60 PUSH1 0x20 258C 60 PUSH1 0x04 258E 82 DUP3 258F 01 ADD 2590 52 MSTORE 2591 60 PUSH1 0x1e 2593 60 PUSH1 0x24 2595 82 DUP3 2596 01 ADD 2597 52 MSTORE 2598 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 25B9 60 PUSH1 0x44 25BB 82 DUP3 25BC 01 ADD 25BD 52 MSTORE 25BE 90 SWAP1 25BF 51 MLOAD 25C0 90 SWAP1 25C1 81 DUP2 25C2 90 SWAP1 25C3 03 SUB 25C4 60 PUSH1 0x64 25C6 01 ADD 25C7 90 SWAP1 25C8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2589 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2590 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2597 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @25BD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // @25C8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_25C9: // Incoming jump from 0x257C, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @25CB stack[-2] // @25CB stack[-3] // @25CD stack[-4] // } 25C9 5B JUMPDEST 25CA 50 POP 25CB 90 SWAP1 25CC 03 SUB 25CD 90 SWAP1 25CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @25CD stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] 25CF 5B JUMPDEST 25D0 82 DUP3 25D1 80 DUP1 25D2 54 SLOAD 25D3 60 PUSH1 0x01 25D5 81 DUP2 25D6 60 PUSH1 0x01 25D8 16 AND 25D9 15 ISZERO 25DA 61 PUSH2 0x0100 25DD 02 MUL 25DE 03 SUB 25DF 16 AND 25E0 60 PUSH1 0x02 25E2 90 SWAP1 25E3 04 DIV 25E4 90 SWAP1 25E5 60 PUSH1 0x00 25E7 52 MSTORE 25E8 60 PUSH1 0x20 25EA 60 PUSH1 0x00 25EC 20 SHA3 25ED 90 SWAP1 25EE 60 PUSH1 0x1f 25F0 01 ADD 25F1 60 PUSH1 0x20 25F3 90 SWAP1 25F4 04 DIV 25F5 81 DUP2 25F6 01 ADD 25F7 92 SWAP3 25F8 82 DUP3 25F9 60 PUSH1 0x1f 25FB 10 LT 25FC 61 PUSH2 0x2610 25FF 57 *JUMPI 2600 82 DUP3 2601 80 DUP1 2602 01 ADD 2603 60 PUSH1 0xff 2605 19 NOT 2606 82 DUP3 2607 35 CALLDATALOAD 2608 16 AND 2609 17 OR 260A 85 DUP6 260B 55 SSTORE 260C 61 PUSH2 0x263d 260F 56 *JUMP 2610 5B JUMPDEST 2611 82 DUP3 2612 80 DUP1 2613 01 ADD 2614 60 PUSH1 0x01 2616 01 ADD 2617 85 DUP6 2618 55 SSTORE 2619 82 DUP3 261A 15 ISZERO 261B 61 PUSH2 0x263d 261E 57 *JUMPI 261F 91 SWAP2 2620 82 DUP3 2621 01 ADD 2622 5B JUMPDEST 2623 82 DUP3 2624 81 DUP2 2625 11 GT 2626 15 ISZERO 2627 61 PUSH2 0x263d 262A 57 *JUMPI 262B 82 DUP3 262C 35 CALLDATALOAD 262D 82 DUP3 262E 55 SSTORE 262F 91 SWAP2 2630 60 PUSH1 0x20 2632 01 ADD 2633 91 SWAP2 2634 90 SWAP1 2635 60 PUSH1 0x01 2637 01 ADD 2638 90 SWAP1 2639 61 PUSH2 0x2622 263C 56 *JUMP label_263D: // Incoming jump from 0x26EC, if !(stack[-1] > stack[-3]) // Incoming jump from 0x26EC, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x26D1 // Incoming jump from 0x26E0, if !stack[-3] // Inputs[2] // { // @2642 stack[-4] // @2643 stack[-3] // } 263D 5B JUMPDEST 263E 50 POP 263F 61 PUSH2 0x2649 2642 92 SWAP3 2643 91 SWAP2 2644 50 POP 2645 61 PUSH2 0x26ff 2648 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2642 stack[-4] = 0x2649 // @2643 stack[-3] = stack[-4] // } // Block ends with call to 0x26ff, returns to 0x2649 label_2649: // Incoming call from 0x270D, returns to 0x0F81, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x26FF at 0x2648 // Incoming jump from 0x270D, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @264B stack[-2] // @264B stack[-3] // } 2649 5B JUMPDEST 264A 50 POP 264B 90 SWAP1 264C 56 *JUMP // Stack delta = -2 // Outputs[1] { @264B stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] 264D 5B JUMPDEST 264E 50 POP 264F 80 DUP1 2650 54 SLOAD 2651 60 PUSH1 0x01 2653 81 DUP2 2654 60 PUSH1 0x01 2656 16 AND 2657 15 ISZERO 2658 61 PUSH2 0x0100 265B 02 MUL 265C 03 SUB 265D 16 AND 265E 60 PUSH1 0x02 2660 90 SWAP1 2661 04 DIV 2662 60 PUSH1 0x00 2664 82 DUP3 2665 55 SSTORE 2666 80 DUP1 2667 60 PUSH1 0x1f 2669 10 LT 266A 61 PUSH2 0x2673 266D 57 *JUMPI 266E 50 POP 266F 61 PUSH2 0x11e3 2672 56 *JUMP 2673 5B JUMPDEST 2674 60 PUSH1 0x1f 2676 01 ADD 2677 60 PUSH1 0x20 2679 90 SWAP1 267A 04 DIV 267B 90 SWAP1 267C 60 PUSH1 0x00 267E 52 MSTORE 267F 60 PUSH1 0x20 2681 60 PUSH1 0x00 2683 20 SHA3 2684 90 SWAP1 2685 81 DUP2 2686 01 ADD 2687 90 SWAP1 2688 61 PUSH2 0x11e3 268B 91 SWAP2 268C 90 SWAP1 268D 61 PUSH2 0x26ff 2690 56 *JUMP label_2691: // Incoming jump from 0x216C // Inputs[5] // { // @2692 stack[-3] // @2694 storage[stack[-3]] // @26AE memory[0x00:0x20] // @26B9 stack[-2] // @26BA stack[-1] // } 2691 5B JUMPDEST 2692 82 DUP3 2693 80 DUP1 2694 54 SLOAD 2695 60 PUSH1 0x01 2697 81 DUP2 2698 60 PUSH1 0x01 269A 16 AND 269B 15 ISZERO 269C 61 PUSH2 0x0100 269F 02 MUL 26A0 03 SUB 26A1 16 AND 26A2 60 PUSH1 0x02 26A4 90 SWAP1 26A5 04 DIV 26A6 90 SWAP1 26A7 60 PUSH1 0x00 26A9 52 MSTORE 26AA 60 PUSH1 0x20 26AC 60 PUSH1 0x00 26AE 20 SHA3 26AF 90 SWAP1 26B0 60 PUSH1 0x1f 26B2 01 ADD 26B3 60 PUSH1 0x20 26B5 90 SWAP1 26B6 04 DIV 26B7 81 DUP2 26B8 01 ADD 26B9 92 SWAP3 26BA 82 DUP3 26BB 60 PUSH1 0x1f 26BD 10 LT 26BE 61 PUSH2 0x26d2 26C1 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @26A9 memory[0x00:0x20] = stack[-3] // @26AF stack[0] = keccak256(memory[0x00:0x20]) // @26B9 stack[1] = stack[-2] // @26B9 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x26d2, if 0x1f < stack[-1] label_26C2: // Incoming jump from 0x26C1, if not 0x1f < stack[-1] // Inputs[4] // { // @26C2 stack[-1] // @26C3 memory[stack[-1]:stack[-1] + 0x20] // @26C8 stack[-3] // @26CC stack[-5] // } 26C2 80 DUP1 26C3 51 MLOAD 26C4 60 PUSH1 0xff 26C6 19 NOT 26C7 16 AND 26C8 83 DUP4 26C9 80 DUP1 26CA 01 ADD 26CB 17 OR 26CC 85 DUP6 26CD 55 SSTORE 26CE 61 PUSH2 0x263d 26D1 56 *JUMP // Stack delta = +0 // Outputs[1] { @26CD storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x263d label_26D2: // Incoming jump from 0x26C1, if 0x1f < stack[-1] // Inputs[2] // { // @26D3 stack[-3] // @26D9 stack[-5] // } 26D2 5B JUMPDEST 26D3 82 DUP3 26D4 80 DUP1 26D5 01 ADD 26D6 60 PUSH1 0x01 26D8 01 ADD 26D9 85 DUP6 26DA 55 SSTORE 26DB 82 DUP3 26DC 15 ISZERO 26DD 61 PUSH2 0x263d 26E0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26DA storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x263d, if !stack[-3] label_26E1: // Incoming jump from 0x26E0, if not !stack[-3] // Inputs[2] // { // @26E1 stack[-3] // @26E1 stack[-1] // } 26E1 91 SWAP2 26E2 82 DUP3 26E3 01 ADD 26E4 5B JUMPDEST 26E5 82 DUP3 26E6 81 DUP2 26E7 11 GT 26E8 15 ISZERO 26E9 61 PUSH2 0x263d 26EC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @26E1 stack[-3] = stack[-1] // @26E3 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x263d, if !(stack[-1] + stack[-3] > stack[-1]) label_26ED: // Incoming jump from 0x26EC, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x26EC, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @26ED stack[-3] // @26EE memory[stack[-3]:stack[-3] + 0x20] // @26EF stack[-2] // @26F1 stack[-1] // } 26ED 82 DUP3 26EE 51 MLOAD 26EF 82 DUP3 26F0 55 SSTORE 26F1 91 SWAP2 26F2 60 PUSH1 0x20 26F4 01 ADD 26F5 91 SWAP2 26F6 90 SWAP1 26F7 60 PUSH1 0x01 26F9 01 ADD 26FA 90 SWAP1 26FB 61 PUSH2 0x26e4 26FE 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @26F0 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @26F5 stack[-3] = 0x20 + stack[-3] // @26FA stack[-2] = 0x01 + stack[-2] // @26FA stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x26e4 label_26FF: // Incoming call from 0x2648, returns to 0x2649 // Inputs[2] // { // @2703 stack[-2] // @2704 stack[-1] // } 26FF 5B JUMPDEST 2700 61 PUSH2 0x0f81 2703 91 SWAP2 2704 90 SWAP1 2705 5B JUMPDEST 2706 80 DUP1 2707 82 DUP3 2708 11 GT 2709 15 ISZERO 270A 61 PUSH2 0x2649 270D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2703 stack[-2] = 0x0f81 // @2704 stack[-1] = stack[-2] // @2704 stack[0] = stack[-1] // } // Block ends with conditional call to 0x2649, returns to 0x0F81, if !(stack[-2] > stack[-1]) label_270E: // Incoming jump from 0x270D, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x270D, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2710 stack[-1] } 270E 60 PUSH1 0x00 2710 81 DUP2 2711 55 SSTORE 2712 60 PUSH1 0x01 2714 01 ADD 2715 61 PUSH2 0x2705 2718 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2711 storage[stack[-1]] = 0x00 // @2714 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2705 2719 FE *ASSERT 271A 45 GASLIMIT 271B 52 MSTORE 271C 43 NUMBER 271D 37 CALLDATACOPY 271E 32 ORIGIN 271F 31 BALANCE 2720 3A GASPRICE 2721 20 SHA3 2722 74 PUSH21 0x72616e7366657220746f206e6f6e20455243373231 2738 52 MSTORE 2739 65 PUSH6 0x636569766572 2740 20 SHA3 2741 69 PUSH10 0x6d706c656d656e746572 274C 45 GASLIMIT 274D 52 MSTORE 274E 43 NUMBER 274F 37 CALLDATACOPY 2750 32 ORIGIN 2751 31 BALANCE 2752 3A GASPRICE 2753 20 SHA3 2754 74 PUSH21 0x72616e7366657220746f20746865207a65726f2061 276A 64 PUSH5 0x6472657373 2770 45 GASLIMIT 2771 52 MSTORE 2772 43 NUMBER 2773 37 CALLDATACOPY 2774 32 ORIGIN 2775 31 BALANCE 2776 3A GASPRICE 2777 20 SHA3 2778 6F PUSH16 0x70657261746f7220717565727920666f 2789 72 PUSH19 0x206e6f6e6578697374656e7420746f6b656e45 279D 52 MSTORE 279E 43 NUMBER 279F 37 CALLDATACOPY 27A0 32 ORIGIN 27A1 31 BALANCE 27A2 3A GASPRICE 27A3 20 SHA3 27A4 61 PUSH2 0x7070 27A7 72 PUSH19 0x6f76652063616c6c6572206973206e6f74206f 27BB 77 PUSH24 0x6e6572206e6f7220617070726f76656420666f7220616c6c 27D4 45 GASLIMIT 27D5 52 MSTORE 27D6 43 NUMBER 27D7 37 CALLDATACOPY 27D8 32 ORIGIN 27D9 31 BALANCE 27DA 3A GASPRICE 27DB 20 SHA3 27DC 62 PUSH3 0x616c61 27E0 6E PUSH15 0x636520717565727920666f72207468 27F0 65 PUSH6 0x207a65726f20 27F7 61 PUSH2 0x6464 27FA 72 PUSH19 0x6573734552433732313a206f776e6572207175 280E 65 PUSH6 0x727920666f72 2815 20 SHA3 2816 6E PUSH15 0x6f6e6578697374656e7420746f6b65 2826 6E PUSH15 0x526f6c65733a206163636f756e7420 2836 64 PUSH5 0x6f6573206e 283C 6F PUSH16 0x74206861766520726f6c654552433732 284D 31 BALANCE 284E 3A GASPRICE 284F 20 SHA3 2850 61 PUSH2 0x7070 2853 72 PUSH19 0x6f76656420717565727920666f72206e6f6e65 2867 78 PUSH25 0x697374656e7420746f6b656e526f6c65733a206163636f756e 2881 74 PUSH21 0x20697320746865207a65726f206164647265737345 2897 52 MSTORE 2898 43 NUMBER 2899 37 CALLDATACOPY 289A 32 ORIGIN 289B 31 BALANCE 289C 3A GASPRICE 289D 20 SHA3 289E 74 PUSH21 0x72616e73666572206f6620746f6b656e2074686174 28B4 20 SHA3 28B5 69 PUSH10 0x73206e6f74206f776e45 28C0 52 MSTORE 28C1 43 NUMBER 28C2 37 CALLDATACOPY 28C3 32 ORIGIN 28C4 31 BALANCE 28C5 3A GASPRICE 28C6 20 SHA3 28C7 61 PUSH2 0x7070 28CA 72 PUSH19 0x6f76616c20746f2063757272656e74206f776e 28DE 65 PUSH6 0x724552433732 28E5 31 BALANCE 28E6 3A GASPRICE 28E7 20 SHA3 28E8 74 PUSH21 0x72616e736665722063616c6c6572206973206e6f74 28FE 20 SHA3 28FF 6F PUSH16 0x776e6572206e6f7220617070726f7665 2910 64 PUSH5 0x4552433732 2916 31 BALANCE 2917 3A GASPRICE 2918 20 SHA3 2919 62 PUSH3 0x75726e 291D 20 SHA3 291E 6F PUSH16 0x6620746f6b656e207468617420697320 292F 6E PUSH15 0x6f74206f776e455243373231427572 293F 6E PUSH15 0x61626c653a2063616c6c6572206973 294F 20 SHA3 2950 6E PUSH15 0x6f74206f776e6572206e6f72206170 2960 70 PUSH17 0x726f766564a265627a7a72315820196c8e 2972 A6 A6 2973 F9 F9 2974 1B SHL 2975 FC FC 2976 52 MSTORE 2977 EE EE 2978 0E 0E 2979 F6 F6 297A EC EC 297B 6F PUSH16 0x335cf8d25d80ae878ca64e903dce64a9 298C 86 DUP7 298D 7E PUSH31 0x5964736f6c634300050c0032