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 0x0157 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0157, 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 0x8da5cb5b 0026 11 GT 0027 61 PUSH2 0x00c3 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00c3, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xccbcdd8c 0031 11 GT 0032 61 PUSH2 0x007c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xccbcdd8c > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xccbcdd8c > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xccbcdd8c 003C 14 EQ 003D 61 PUSH2 0x02f8 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f8, if 0xccbcdd8c == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xccbcdd8c == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x030b 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030b, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x0347 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0347, if 0xf242432a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf242432a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x035a 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035a, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf5298aca 0068 14 EQ 0069 61 PUSH2 0x036d 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036d, if 0xf5298aca == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf5298aca == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf851a440 0073 14 EQ 0074 61 PUSH2 0x0380 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0380, if 0xf851a440 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf851a440 == stack[-1] // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x0035, if 0xccbcdd8c > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0x8da5cb5b 0083 14 EQ 0084 61 PUSH2 0x0274 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0274, if 0x8da5cb5b == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x945633c1 008E 14 EQ 008F 61 PUSH2 0x0299 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0299, if 0x945633c1 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x945633c1 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0x97aba7f9 0099 14 EQ 009A 61 PUSH2 0x02ac 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ac, if 0x97aba7f9 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0x97aba7f9 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0x9a90d277 00A4 14 EQ 00A5 61 PUSH2 0x02bf 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bf, if 0x9a90d277 == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0x9a90d277 == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0xa22cb465 00AF 14 EQ 00B0 61 PUSH2 0x02d2 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d2, if 0xa22cb465 == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00B4 stack[-1] } 00B4 80 DUP1 00B5 63 PUSH4 0xc11d23f0 00BA 14 EQ 00BB 61 PUSH2 0x02e5 00BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e5, if 0xc11d23f0 == stack[-1] label_00BF: // Incoming jump from 0x00BE, if not 0xc11d23f0 == stack[-1] // Inputs[1] { @00C2 memory[0x00:0x00] } 00BF 60 PUSH1 0x00 00C1 80 DUP1 00C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00C2 revert(memory[0x00:0x00]); } // Block terminates label_00C3: // Incoming jump from 0x002A, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00C4 stack[-1] } 00C3 5B JUMPDEST 00C4 80 DUP1 00C5 63 PUSH4 0x2eb2c2d6 00CA 11 GT 00CB 61 PUSH2 0x0115 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0115, if 0x2eb2c2d6 > stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x2eb2c2d6 > stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x2eb2c2d6 00D5 14 EQ 00D6 61 PUSH2 0x0200 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0200, if 0x2eb2c2d6 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x4e1273f4 00E0 14 EQ 00E1 61 PUSH2 0x0213 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0213, if 0x4e1273f4 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x631a1264 00EB 14 EQ 00EC 61 PUSH2 0x0233 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0233, if 0x631a1264 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x631a1264 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x6b20c454 00F6 14 EQ 00F7 61 PUSH2 0x0246 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0246, if 0x6b20c454 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x6b20c454 == stack[-1] // Inputs[1] { @00FB stack[-1] } 00FB 80 DUP1 00FC 63 PUSH4 0x715018a6 0101 14 EQ 0102 61 PUSH2 0x0259 0105 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0259, if 0x715018a6 == stack[-1] label_0106: // Incoming jump from 0x0105, if not 0x715018a6 == stack[-1] // Inputs[1] { @0106 stack[-1] } 0106 80 DUP1 0107 63 PUSH4 0x75829def 010C 14 EQ 010D 61 PUSH2 0x0261 0110 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0261, if 0x75829def == stack[-1] label_0111: // Incoming jump from 0x0110, if not 0x75829def == stack[-1] // Inputs[1] { @0114 memory[0x00:0x00] } 0111 60 PUSH1 0x00 0113 80 DUP1 0114 FD *REVERT // Stack delta = +0 // Outputs[1] { @0114 revert(memory[0x00:0x00]); } // Block terminates label_0115: // Incoming jump from 0x00CE, if 0x2eb2c2d6 > stack[-1] // Inputs[1] { @0116 stack[-1] } 0115 5B JUMPDEST 0116 80 DUP1 0117 62 PUSH3 0xfdd58e 011B 14 EQ 011C 61 PUSH2 0x015c 011F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015c, if 0xfdd58e == stack[-1] label_0120: // Incoming jump from 0x011F, if not 0xfdd58e == stack[-1] // Inputs[1] { @0120 stack[-1] } 0120 80 DUP1 0121 63 PUSH4 0x01ffc9a7 0126 14 EQ 0127 61 PUSH2 0x0182 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0182, if 0x01ffc9a7 == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @012B stack[-1] } 012B 80 DUP1 012C 63 PUSH4 0x05496cf4 0131 14 EQ 0132 61 PUSH2 0x01a5 0135 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a5, if 0x05496cf4 == stack[-1] label_0136: // Incoming jump from 0x0135, if not 0x05496cf4 == stack[-1] // Inputs[1] { @0136 stack[-1] } 0136 80 DUP1 0137 63 PUSH4 0x0e89341c 013C 14 EQ 013D 61 PUSH2 0x01ba 0140 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ba, if 0x0e89341c == stack[-1] label_0141: // Incoming jump from 0x0140, if not 0x0e89341c == stack[-1] // Inputs[1] { @0141 stack[-1] } 0141 80 DUP1 0142 63 PUSH4 0x1a5a3b86 0147 14 EQ 0148 61 PUSH2 0x01da 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01da, if 0x1a5a3b86 == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x1a5a3b86 == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x234b0fa8 0152 14 EQ 0153 61 PUSH2 0x01ed 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ed, if 0x234b0fa8 == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x234b0fa8 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @015B memory[0x00:0x00] } 0157 5B JUMPDEST 0158 60 PUSH1 0x00 015A 80 DUP1 015B FD *REVERT // Stack delta = +0 // Outputs[1] { @015B revert(memory[0x00:0x00]); } // Block terminates label_015C: // Incoming jump from 0x011F, if 0xfdd58e == stack[-1] // Inputs[1] { @0163 msg.data.length } 015C 5B JUMPDEST 015D 61 PUSH2 0x016f 0160 61 PUSH2 0x016a 0163 36 CALLDATASIZE 0164 60 PUSH1 0x04 0166 61 PUSH2 0x1aa2 0169 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @015D stack[0] = 0x016f // @0160 stack[1] = 0x016a // @0163 stack[2] = msg.data.length // @0164 stack[3] = 0x04 // } // Block ends with call to 0x1aa2, returns to 0x016A label_016A: // Incoming return from call to 0x1AA2 at 0x0169 016A 5B JUMPDEST 016B 61 PUSH2 0x0391 016E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0391 label_016F: // Incoming return from call to 0x02A7 at 0x02A6 // Incoming return from call to 0x016A at 0x0169 // Inputs[2] // { // @0172 memory[0x40:0x60] // @0173 stack[-1] // } 016F 5B JUMPDEST 0170 60 PUSH1 0x40 0172 51 MLOAD 0173 90 SWAP1 0174 81 DUP2 0175 52 MSTORE 0176 60 PUSH1 0x20 0178 01 ADD // Stack delta = +0 // Outputs[2] // { // @0175 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0178 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0179: // Incoming jump from 0x0298 // Incoming jump from 0x0178 // Incoming jump from 0x0298 // Incoming jump from 0x01A4 // Inputs[3] // { // @017C memory[0x40:0x60] // @017E stack[-1] // @0181 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0179 5B JUMPDEST 017A 60 PUSH1 0x40 017C 51 MLOAD 017D 80 DUP1 017E 91 SWAP2 017F 03 SUB 0180 90 SWAP1 0181 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0181 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0182: // Incoming jump from 0x012A, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0189 msg.data.length } 0182 5B JUMPDEST 0183 61 PUSH2 0x0195 0186 61 PUSH2 0x0190 0189 36 CALLDATASIZE 018A 60 PUSH1 0x04 018C 61 PUSH2 0x1ae2 018F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0183 stack[0] = 0x0195 // @0186 stack[1] = 0x0190 // @0189 stack[2] = msg.data.length // @018A stack[3] = 0x04 // } // Block ends with call to 0x1ae2, returns to 0x0190 label_0190: // Incoming return from call to 0x1AE2 at 0x018F 0190 5B JUMPDEST 0191 61 PUSH2 0x042a 0194 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x042a label_0195: // Incoming return from call to 0x01E8 at 0x01E7 // Incoming return from call to 0x0190 at 0x018F // Incoming return from call to 0x0319 at 0x0318 // Inputs[2] // { // @0198 memory[0x40:0x60] // @0199 stack[-1] // } 0195 5B JUMPDEST 0196 60 PUSH1 0x40 0198 51 MLOAD 0199 90 SWAP1 019A 15 ISZERO 019B 15 ISZERO 019C 81 DUP2 019D 52 MSTORE 019E 60 PUSH1 0x20 01A0 01 ADD 01A1 61 PUSH2 0x0179 01A4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @019D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01A0 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0179 label_01A5: // Incoming jump from 0x0135, if 0x05496cf4 == stack[-1] // Inputs[1] { @01AC msg.data.length } 01A5 5B JUMPDEST 01A6 61 PUSH2 0x01b8 01A9 61 PUSH2 0x01b3 01AC 36 CALLDATASIZE 01AD 60 PUSH1 0x04 01AF 61 PUSH2 0x1c5f 01B2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01A6 stack[0] = 0x01b8 // @01A9 stack[1] = 0x01b3 // @01AC stack[2] = msg.data.length // @01AD stack[3] = 0x04 // } // Block ends with call to 0x1c5f, returns to 0x01B3 label_01B3: // Incoming return from call to 0x1C5F at 0x01B2 01B3 5B JUMPDEST 01B4 61 PUSH2 0x047a 01B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x047a label_01B8: // Incoming return from call to 0x02E0 at 0x02DF // Incoming return from call to 0x037B at 0x037A // Incoming return from call to 0x01B3 at 0x01B2 // Incoming return from call to 0x01FB at 0x01FA // Incoming return from call to 0x026F at 0x026E 01B8 5B JUMPDEST 01B9 00 *STOP // Stack delta = +0 // Outputs[1] { @01B9 stop(); } // Block terminates label_01BA: // Incoming jump from 0x0140, if 0x0e89341c == stack[-1] // Inputs[1] { @01C1 msg.data.length } 01BA 5B JUMPDEST 01BB 61 PUSH2 0x01cd 01BE 61 PUSH2 0x01c8 01C1 36 CALLDATASIZE 01C2 60 PUSH1 0x04 01C4 61 PUSH2 0x1d1a 01C7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01BB stack[0] = 0x01cd // @01BE stack[1] = 0x01c8 // @01C1 stack[2] = msg.data.length // @01C2 stack[3] = 0x04 // } // Block ends with call to 0x1d1a, returns to 0x01C8 label_01C8: // Incoming return from call to 0x1D1A at 0x01C7 01C8 5B JUMPDEST 01C9 61 PUSH2 0x0519 01CC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0519 label_01CD: // Incoming return from call to 0x01C8 at 0x01C7 // Inputs[2] // { // @01D0 memory[0x40:0x60] // @01D4 stack[-1] // } 01CD 5B JUMPDEST 01CE 60 PUSH1 0x40 01D0 51 MLOAD 01D1 61 PUSH2 0x0179 01D4 91 SWAP2 01D5 90 SWAP1 01D6 61 PUSH2 0x1d83 01D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01D4 stack[-1] = 0x0179 // @01D5 stack[1] = memory[0x40:0x60] // @01D5 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1d83 label_01DA: // Incoming jump from 0x014B, if 0x1a5a3b86 == stack[-1] // Inputs[1] { @01E1 msg.data.length } 01DA 5B JUMPDEST 01DB 61 PUSH2 0x0195 01DE 61 PUSH2 0x01e8 01E1 36 CALLDATASIZE 01E2 60 PUSH1 0x04 01E4 61 PUSH2 0x1d1a 01E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01DB stack[0] = 0x0195 // @01DE stack[1] = 0x01e8 // @01E1 stack[2] = msg.data.length // @01E2 stack[3] = 0x04 // } // Block ends with call to 0x1d1a, returns to 0x01E8 label_01E8: // Incoming return from call to 0x1D1A at 0x01E7 01E8 5B JUMPDEST 01E9 61 PUSH2 0x05ad 01EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05ad label_01ED: // Incoming jump from 0x0156, if 0x234b0fa8 == stack[-1] // Inputs[1] { @01F4 msg.data.length } 01ED 5B JUMPDEST 01EE 61 PUSH2 0x01b8 01F1 61 PUSH2 0x01fb 01F4 36 CALLDATASIZE 01F5 60 PUSH1 0x04 01F7 61 PUSH2 0x1d1a 01FA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01EE stack[0] = 0x01b8 // @01F1 stack[1] = 0x01fb // @01F4 stack[2] = msg.data.length // @01F5 stack[3] = 0x04 // } // Block ends with call to 0x1d1a, returns to 0x01FB label_01FB: // Incoming return from call to 0x1D1A at 0x01FA 01FB 5B JUMPDEST 01FC 61 PUSH2 0x0602 01FF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0602 label_0200: // Incoming jump from 0x00D9, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0207 msg.data.length } 0200 5B JUMPDEST 0201 61 PUSH2 0x01b8 0204 61 PUSH2 0x020e 0207 36 CALLDATASIZE 0208 60 PUSH1 0x04 020A 61 PUSH2 0x1e13 020D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0201 stack[0] = 0x01b8 // @0204 stack[1] = 0x020e // @0207 stack[2] = msg.data.length // @0208 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1e13 020E 5B JUMPDEST 020F 61 PUSH2 0x063f 0212 56 *JUMP label_0213: // Incoming jump from 0x00E4, if 0x4e1273f4 == stack[-1] // Inputs[1] { @021A msg.data.length } 0213 5B JUMPDEST 0214 61 PUSH2 0x0226 0217 61 PUSH2 0x0221 021A 36 CALLDATASIZE 021B 60 PUSH1 0x04 021D 61 PUSH2 0x1ebc 0220 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0214 stack[0] = 0x0226 // @0217 stack[1] = 0x0221 // @021A stack[2] = msg.data.length // @021B stack[3] = 0x04 // } // Block ends with call to 0x1ebc, returns to 0x0221 label_0221: // Incoming return from call to 0x1EBC at 0x0220 0221 5B JUMPDEST 0222 61 PUSH2 0x0684 0225 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0684 label_0226: // Incoming return from call to 0x0221 at 0x0220 // Inputs[2] // { // @0229 memory[0x40:0x60] // @022D stack[-1] // } 0226 5B JUMPDEST 0227 60 PUSH1 0x40 0229 51 MLOAD 022A 61 PUSH2 0x0179 022D 91 SWAP2 022E 90 SWAP1 022F 61 PUSH2 0x1fc1 0232 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @022D stack[-1] = 0x0179 // @022E stack[1] = memory[0x40:0x60] // @022E stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1fc1 label_0233: // Incoming jump from 0x00EF, if 0x631a1264 == stack[-1] // Inputs[1] { @023A msg.data.length } 0233 5B JUMPDEST 0234 61 PUSH2 0x01b8 0237 61 PUSH2 0x0241 023A 36 CALLDATASIZE 023B 60 PUSH1 0x04 023D 61 PUSH2 0x1fd4 0240 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0234 stack[0] = 0x01b8 // @0237 stack[1] = 0x0241 // @023A stack[2] = msg.data.length // @023B stack[3] = 0x04 // } // Block ends with call to 0x1fd4, returns to 0x0241 label_0241: // Incoming return from call to 0x1FD4 at 0x0240 0241 5B JUMPDEST 0242 61 PUSH2 0x07ad 0245 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07ad label_0246: // Incoming jump from 0x00FA, if 0x6b20c454 == stack[-1] // Inputs[1] { @024D msg.data.length } 0246 5B JUMPDEST 0247 61 PUSH2 0x01b8 024A 61 PUSH2 0x0254 024D 36 CALLDATASIZE 024E 60 PUSH1 0x04 0250 61 PUSH2 0x201c 0253 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0247 stack[0] = 0x01b8 // @024A stack[1] = 0x0254 // @024D stack[2] = msg.data.length // @024E stack[3] = 0x04 // } // Block ends with call to 0x201c, returns to 0x0254 label_0254: // Incoming return from call to 0x201C at 0x0253 0254 5B JUMPDEST 0255 61 PUSH2 0x07c1 0258 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07c1 label_0259: // Incoming jump from 0x0105, if 0x715018a6 == stack[-1] 0259 5B JUMPDEST 025A 61 PUSH2 0x01b8 025D 61 PUSH2 0x0809 0260 56 *JUMP // Stack delta = +1 // Outputs[1] { @025A stack[0] = 0x01b8 } // Block ends with unconditional jump to 0x0809 label_0261: // Incoming jump from 0x0110, if 0x75829def == stack[-1] // Inputs[1] { @0268 msg.data.length } 0261 5B JUMPDEST 0262 61 PUSH2 0x01b8 0265 61 PUSH2 0x026f 0268 36 CALLDATASIZE 0269 60 PUSH1 0x04 026B 61 PUSH2 0x208f 026E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0262 stack[0] = 0x01b8 // @0265 stack[1] = 0x026f // @0268 stack[2] = msg.data.length // @0269 stack[3] = 0x04 // } // Block ends with call to 0x208f, returns to 0x026F label_026F: // Incoming return from call to 0x208F at 0x026E 026F 5B JUMPDEST 0270 61 PUSH2 0x081d 0273 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x081d label_0274: // Incoming jump from 0x0087, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @0277 storage[0x03] // @0284 memory[0x40:0x60] // } 0274 5B JUMPDEST 0275 60 PUSH1 0x03 0277 54 SLOAD 0278 60 PUSH1 0x01 027A 60 PUSH1 0x01 027C 60 PUSH1 0xa0 027E 1B SHL 027F 03 SUB 0280 16 AND 0281 5B JUMPDEST 0282 60 PUSH1 0x40 0284 51 MLOAD 0285 60 PUSH1 0x01 0287 60 PUSH1 0x01 0289 60 PUSH1 0xa0 028B 1B SHL 028C 03 SUB 028D 90 SWAP1 028E 91 SWAP2 028F 16 AND 0290 81 DUP2 0291 52 MSTORE 0292 60 PUSH1 0x20 0294 01 ADD 0295 61 PUSH2 0x0179 0298 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0291 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & storage[0x03] & (0x01 << 0xa0) - 0x01 // @0294 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0179 label_0299: // Incoming jump from 0x0092, if 0x945633c1 == stack[-1] // Inputs[1] { @02A0 msg.data.length } 0299 5B JUMPDEST 029A 61 PUSH2 0x016f 029D 61 PUSH2 0x02a7 02A0 36 CALLDATASIZE 02A1 60 PUSH1 0x04 02A3 61 PUSH2 0x1d1a 02A6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @029A stack[0] = 0x016f // @029D stack[1] = 0x02a7 // @02A0 stack[2] = msg.data.length // @02A1 stack[3] = 0x04 // } // Block ends with call to 0x1d1a, returns to 0x02A7 label_02A7: // Incoming return from call to 0x1D1A at 0x02A6 02A7 5B JUMPDEST 02A8 61 PUSH2 0x0847 02AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0847 label_02AC: // Incoming jump from 0x009D, if 0x97aba7f9 == stack[-1] // Inputs[1] { @02B3 msg.data.length } 02AC 5B JUMPDEST 02AD 61 PUSH2 0x0281 02B0 61 PUSH2 0x02ba 02B3 36 CALLDATASIZE 02B4 60 PUSH1 0x04 02B6 61 PUSH2 0x20aa 02B9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AD stack[0] = 0x0281 // @02B0 stack[1] = 0x02ba // @02B3 stack[2] = msg.data.length // @02B4 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20aa 02BA 5B JUMPDEST 02BB 61 PUSH2 0x0868 02BE 56 *JUMP label_02BF: // Incoming jump from 0x00A8, if 0x9a90d277 == stack[-1] // Inputs[1] { @02C6 msg.data.length } 02BF 5B JUMPDEST 02C0 61 PUSH2 0x016f 02C3 61 PUSH2 0x02cd 02C6 36 CALLDATASIZE 02C7 60 PUSH1 0x04 02C9 61 PUSH2 0x20e6 02CC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02C0 stack[0] = 0x016f // @02C3 stack[1] = 0x02cd // @02C6 stack[2] = msg.data.length // @02C7 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x20e6 02CD 5B JUMPDEST 02CE 61 PUSH2 0x08ca 02D1 56 *JUMP label_02D2: // Incoming jump from 0x00B3, if 0xa22cb465 == stack[-1] // Inputs[1] { @02D9 msg.data.length } 02D2 5B JUMPDEST 02D3 61 PUSH2 0x01b8 02D6 61 PUSH2 0x02e0 02D9 36 CALLDATASIZE 02DA 60 PUSH1 0x04 02DC 61 PUSH2 0x212a 02DF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02D3 stack[0] = 0x01b8 // @02D6 stack[1] = 0x02e0 // @02D9 stack[2] = msg.data.length // @02DA stack[3] = 0x04 // } // Block ends with call to 0x212a, returns to 0x02E0 label_02E0: // Incoming return from call to 0x212A at 0x02DF 02E0 5B JUMPDEST 02E1 61 PUSH2 0x090a 02E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x090a label_02E5: // Incoming jump from 0x00BE, if 0xc11d23f0 == stack[-1] // Inputs[1] { @02EC msg.data.length } 02E5 5B JUMPDEST 02E6 61 PUSH2 0x0195 02E9 61 PUSH2 0x02f3 02EC 36 CALLDATASIZE 02ED 60 PUSH1 0x04 02EF 61 PUSH2 0x2166 02F2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E6 stack[0] = 0x0195 // @02E9 stack[1] = 0x02f3 // @02EC stack[2] = msg.data.length // @02ED stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2166 02F3 5B JUMPDEST 02F4 61 PUSH2 0x0919 02F7 56 *JUMP label_02F8: // Incoming jump from 0x0040, if 0xccbcdd8c == stack[-1] // Inputs[1] { @02FF msg.data.length } 02F8 5B JUMPDEST 02F9 61 PUSH2 0x01b8 02FC 61 PUSH2 0x0306 02FF 36 CALLDATASIZE 0300 60 PUSH1 0x04 0302 61 PUSH2 0x219a 0305 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F9 stack[0] = 0x01b8 // @02FC stack[1] = 0x0306 // @02FF stack[2] = msg.data.length // @0300 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x219a 0306 5B JUMPDEST 0307 61 PUSH2 0x0969 030A 56 *JUMP label_030B: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0312 msg.data.length } 030B 5B JUMPDEST 030C 61 PUSH2 0x0195 030F 61 PUSH2 0x0319 0312 36 CALLDATASIZE 0313 60 PUSH1 0x04 0315 61 PUSH2 0x2244 0318 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @030C stack[0] = 0x0195 // @030F stack[1] = 0x0319 // @0312 stack[2] = msg.data.length // @0313 stack[3] = 0x04 // } // Block ends with call to 0x2244, returns to 0x0319 label_0319: // Incoming call from 0x07DC, returns to 0x07DD // Incoming call from 0x0B58, returns to 0x0B59 // Incoming return from call to 0x2244 at 0x0318 // Inputs[6] // { // @0322 stack[-2] // @0335 memory[0x00:0x40] // @0336 stack[-1] // @0340 memory[0x00:0x40] // @0341 storage[keccak256(memory[0x00:0x40])] // @0345 stack[-3] // } 0319 5B JUMPDEST 031A 60 PUSH1 0x01 031C 60 PUSH1 0x01 031E 60 PUSH1 0xa0 0320 1B SHL 0321 03 SUB 0322 91 SWAP2 0323 82 DUP3 0324 16 AND 0325 60 PUSH1 0x00 0327 90 SWAP1 0328 81 DUP2 0329 52 MSTORE 032A 60 PUSH1 0x01 032C 60 PUSH1 0x20 032E 90 SWAP1 032F 81 DUP2 0330 52 MSTORE 0331 60 PUSH1 0x40 0333 80 DUP1 0334 83 DUP4 0335 20 SHA3 0336 93 SWAP4 0337 90 SWAP1 0338 94 SWAP5 0339 16 AND 033A 82 DUP3 033B 52 MSTORE 033C 91 SWAP2 033D 90 SWAP1 033E 91 SWAP2 033F 52 MSTORE 0340 20 SHA3 0341 54 SLOAD 0342 60 PUSH1 0xff 0344 16 AND 0345 90 SWAP1 0346 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0329 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0330 memory[0x20:0x40] = 0x01 // @033B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @033F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0345 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0347: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @034E msg.data.length } 0347 5B JUMPDEST 0348 61 PUSH2 0x01b8 034B 61 PUSH2 0x0355 034E 36 CALLDATASIZE 034F 60 PUSH1 0x04 0351 61 PUSH2 0x2277 0354 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0348 stack[0] = 0x01b8 // @034B stack[1] = 0x0355 // @034E stack[2] = msg.data.length // @034F stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2277 0355 5B JUMPDEST 0356 61 PUSH2 0x0a82 0359 56 *JUMP label_035A: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @0361 msg.data.length } 035A 5B JUMPDEST 035B 61 PUSH2 0x01b8 035E 61 PUSH2 0x0368 0361 36 CALLDATASIZE 0362 60 PUSH1 0x04 0364 61 PUSH2 0x208f 0367 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @035B stack[0] = 0x01b8 // @035E stack[1] = 0x0368 // @0361 stack[2] = msg.data.length // @0362 stack[3] = 0x04 // } // Block ends with call to 0x208f, returns to 0x0368 label_0368: // Incoming return from call to 0x208F at 0x0367 0368 5B JUMPDEST 0369 61 PUSH2 0x0ac7 036C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ac7 label_036D: // Incoming jump from 0x006C, if 0xf5298aca == stack[-1] // Inputs[1] { @0374 msg.data.length } 036D 5B JUMPDEST 036E 61 PUSH2 0x01b8 0371 61 PUSH2 0x037b 0374 36 CALLDATASIZE 0375 60 PUSH1 0x04 0377 61 PUSH2 0x22db 037A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036E stack[0] = 0x01b8 // @0371 stack[1] = 0x037b // @0374 stack[2] = msg.data.length // @0375 stack[3] = 0x04 // } // Block ends with call to 0x22db, returns to 0x037B label_037B: // Incoming return from call to 0x22DB at 0x037A 037B 5B JUMPDEST 037C 61 PUSH2 0x0b3d 037F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b3d label_0380: // Incoming jump from 0x0077, if 0xf851a440 == stack[-1] // Inputs[1] { @0383 storage[0x04] } 0380 5B JUMPDEST 0381 60 PUSH1 0x04 0383 54 SLOAD 0384 60 PUSH1 0x01 0386 60 PUSH1 0x01 0388 60 PUSH1 0xa0 038A 1B SHL 038B 03 SUB 038C 16 AND 038D 61 PUSH2 0x0281 0390 56 *JUMP // Stack delta = +1 // Outputs[1] { @038C stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x04] } // Block ends with unconditional jump to 0x0281 label_0391: // Incoming jump from 0x0777 // Incoming jump from 0x016E // Inputs[1] { @039C stack[-2] } 0391 5B JUMPDEST 0392 60 PUSH1 0x00 0394 60 PUSH1 0x01 0396 60 PUSH1 0x01 0398 60 PUSH1 0xa0 039A 1B SHL 039B 03 SUB 039C 83 DUP4 039D 16 AND 039E 61 PUSH2 0x0401 03A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0392 stack[0] = 0x00 } // Block ends with conditional jump to 0x0401, if stack[-2] & (0x01 << 0xa0) - 0x01 label_03A2: // Incoming jump from 0x03A1, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @03A4 memory[0x40:0x60] } 03A2 60 PUSH1 0x40 03A4 51 MLOAD 03A5 62 PUSH3 0x461bcd 03A9 60 PUSH1 0xe5 03AB 1B SHL 03AC 81 DUP2 03AD 52 MSTORE 03AE 60 PUSH1 0x20 03B0 60 PUSH1 0x04 03B2 82 DUP3 03B3 01 ADD 03B4 52 MSTORE 03B5 60 PUSH1 0x2a 03B7 60 PUSH1 0x24 03B9 82 DUP3 03BA 01 ADD 03BB 52 MSTORE 03BC 7F PUSH32 0x455243313135353a2061646472657373207a65726f206973206e6f7420612076 03DD 60 PUSH1 0x44 03DF 82 DUP3 03E0 01 ADD 03E1 52 MSTORE 03E2 69 PUSH10 0x30b634b21037bbb732b9 03ED 60 PUSH1 0xb1 03EF 1B SHL 03F0 60 PUSH1 0x64 03F2 82 DUP3 03F3 01 ADD 03F4 52 MSTORE 03F5 60 PUSH1 0x84 03F7 01 ADD // Stack delta = +1 // Outputs[6] // { // @03AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @03B4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @03BB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @03E1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2061646472657373207a65726f206973206e6f7420612076 // @03F4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x30b634b21037bbb732b9 << 0xb1 // @03F7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_03F8: // Incoming jump from 0x06E8 // Incoming jump from 0x1100 // Incoming jump from 0x1667 // Incoming jump from 0x03F7 // Incoming return from call to 0x238D at 0x0B74 // Incoming return from call to 0x2658 at 0x14BF // Incoming jump from 0x0C4E // Incoming return from call to 0x23F8 at 0x0C6F // Incoming return from call to 0x2615 at 0x1459 // Incoming return from call to 0x2615 at 0x0F41 // Incoming jump from 0x0BEE // Incoming jump from 0x0B33 // Incoming jump from 0x1667 // Incoming return from call to 0x27BC at 0x1697 // Incoming jump from 0x11E1 // Incoming return from call to 0x238D at 0x07F8 // Incoming return from call to 0x23F8 at 0x0F62 // Incoming return from call to 0x2658 at 0x1001 // Inputs[3] // { // @03FB memory[0x40:0x60] // @03FD stack[-1] // @0400 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03F8 5B JUMPDEST 03F9 60 PUSH1 0x40 03FB 51 MLOAD 03FC 80 DUP1 03FD 91 SWAP2 03FE 03 SUB 03FF 90 SWAP1 0400 FD *REVERT // Stack delta = -1 // Outputs[1] { @0400 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0401: // Incoming jump from 0x03A1, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0405 stack[-2] // @0411 memory[0x00:0x40] // @041A stack[-3] // @0422 memory[0x00:0x40] // @0423 storage[keccak256(memory[0x00:0x40])] // @0425 stack[-4] // } 0401 5B JUMPDEST 0402 50 POP 0403 60 PUSH1 0x00 0405 81 DUP2 0406 81 DUP2 0407 52 MSTORE 0408 60 PUSH1 0x20 040A 81 DUP2 040B 81 DUP2 040C 52 MSTORE 040D 60 PUSH1 0x40 040F 80 DUP1 0410 83 DUP4 0411 20 SHA3 0412 60 PUSH1 0x01 0414 60 PUSH1 0x01 0416 60 PUSH1 0xa0 0418 1B SHL 0419 03 SUB 041A 86 DUP7 041B 16 AND 041C 84 DUP5 041D 52 MSTORE 041E 90 SWAP1 041F 91 SWAP2 0420 52 MSTORE 0421 90 SWAP1 0422 20 SHA3 0423 54 SLOAD 0424 5B JUMPDEST 0425 92 SWAP3 0426 91 SWAP2 0427 50 POP 0428 50 POP 0429 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0407 memory[0x00:0x20] = stack[-2] // @040C memory[0x20:0x40] = 0x00 // @041D memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0420 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0425 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_042A: // Incoming jump from 0x0194 // Inputs[1] { @0436 stack[-1] } 042A 5B JUMPDEST 042B 60 PUSH1 0x00 042D 60 PUSH1 0x01 042F 60 PUSH1 0x01 0431 60 PUSH1 0xe0 0433 1B SHL 0434 03 SUB 0435 19 NOT 0436 82 DUP3 0437 16 AND 0438 63 PUSH4 0x6cdb3d13 043D 60 PUSH1 0xe1 043F 1B SHL 0440 14 EQ 0441 80 DUP1 0442 61 PUSH2 0x045b 0445 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @042B stack[0] = 0x00 // @0440 stack[1] = 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x045b, if 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0446: // Incoming jump from 0x0445, if not 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0450 stack[-3] } 0446 50 POP 0447 60 PUSH1 0x01 0449 60 PUSH1 0x01 044B 60 PUSH1 0xe0 044D 1B SHL 044E 03 SUB 044F 19 NOT 0450 82 DUP3 0451 16 AND 0452 63 PUSH4 0x03a24d07 0457 60 PUSH1 0xe2 0459 1B SHL 045A 14 EQ 045B 5B JUMPDEST 045C 80 DUP1 045D 61 PUSH2 0x0424 0460 57 *JUMPI // Stack delta = +0 // Outputs[1] { @045A stack[-1] = 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0424, if 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0461: // Incoming jump from 0x0460, if not stack[-1] // Incoming jump from 0x0460, if not 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0473 stack[-3] } 0461 50 POP 0462 63 PUSH4 0x01ffc9a7 0467 60 PUSH1 0xe0 0469 1B SHL 046A 60 PUSH1 0x01 046C 60 PUSH1 0x01 046E 60 PUSH1 0xe0 0470 1B SHL 0471 03 SUB 0472 19 NOT 0473 83 DUP4 0474 16 AND 0475 14 EQ 0476 61 PUSH2 0x0424 0479 56 *JUMP // Stack delta = +0 // Outputs[1] { @0475 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x0424 label_047A: // Incoming jump from 0x01B7 047A 5B JUMPDEST 047B 61 PUSH2 0x0482 047E 61 PUSH2 0x0b80 0481 56 *JUMP // Stack delta = +1 // Outputs[1] { @047B stack[0] = 0x0482 } // Block ends with call to 0x0b80, returns to 0x0482 label_0482: // Incoming return from call to 0x0B80 at 0x0481 // Inputs[1] { @0486 stack[-3] } 0482 5B JUMPDEST 0483 60 PUSH1 0x00 0485 5B JUMPDEST 0486 83 DUP4 0487 81 DUP2 0488 10 LT 0489 15 ISZERO 048A 61 PUSH2 0x0512 048D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0483 stack[0] = 0x00 } // Block ends with conditional jump to 0x0512, if !(0x00 < stack[-3]) label_048E: // Incoming jump from 0x048D, if not !(0x00 < stack[-3]) // Inputs[3] // { // @0491 stack[-5] // @0492 stack[-4] // @0493 stack[-1] // } 048E 61 PUSH2 0x0500 0491 85 DUP6 0492 85 DUP6 0493 83 DUP4 0494 81 DUP2 0495 81 DUP2 0496 10 LT 0497 61 PUSH2 0x04a2 049A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @048E stack[0] = 0x0500 // @0491 stack[1] = stack[-5] // @0492 stack[2] = stack[-4] // @0493 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x04a2, if stack[-1] < stack[-4] label_049B: // Incoming jump from 0x049A, if not stack[-1] < stack[-4] 049B 61 PUSH2 0x04a2 049E 61 PUSH2 0x230e 04A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @049B stack[0] = 0x04a2 } // Block ends with unconditional jump to 0x230e label_04A2: // Incoming jump from 0x049A, if stack[-1] < stack[-4] // Inputs[3] // { // @04A3 stack[-2] // @04A3 stack[-1] // @04A8 stack[-3] // } 04A2 5B JUMPDEST 04A3 90 SWAP1 04A4 50 POP 04A5 60 PUSH1 0x20 04A7 02 MUL 04A8 01 ADD 04A9 60 PUSH1 0x20 04AB 81 DUP2 04AC 01 ADD 04AD 90 SWAP1 04AE 61 PUSH2 0x04b7 04B1 91 SWAP2 04B2 90 SWAP1 04B3 61 PUSH2 0x208f 04B6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04B1 stack[-3] = 0x04b7 // @04B2 stack[-1] = 0x20 * stack[-1] + stack[-3] // @04B2 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x208f, returns to 0x04B7 label_04B7: // Incoming return from call to 0x208F at 0x04B6 // Inputs[3] // { // @04B8 stack[-5] // @04B9 stack[-3] // @04BB memory[stack[-5]:stack[-5] + 0x20] // } 04B7 5B JUMPDEST 04B8 84 DUP5 04B9 83 DUP4 04BA 81 DUP2 04BB 51 MLOAD 04BC 81 DUP2 04BD 10 LT 04BE 61 PUSH2 0x04c9 04C1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @04B8 stack[0] = stack[-5] // @04B9 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x04c9, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] label_04C2: // Incoming jump from 0x04C1, if not stack[-3] < memory[stack[-5]:stack[-5] + 0x20] 04C2 61 PUSH2 0x04c9 04C5 61 PUSH2 0x230e 04C8 56 *JUMP // Stack delta = +1 // Outputs[1] { @04C2 stack[0] = 0x04c9 } // Block ends with unconditional jump to 0x230e label_04C9: // Incoming jump from 0x04C1, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @04CC stack[-1] // @04D0 stack[-2] // @04D1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @04D2 stack[-6] // @04D3 stack[-5] // @04D5 memory[stack[-6]:stack[-6] + 0x20] // } 04C9 5B JUMPDEST 04CA 60 PUSH1 0x20 04CC 02 MUL 04CD 60 PUSH1 0x20 04CF 01 ADD 04D0 01 ADD 04D1 51 MLOAD 04D2 84 DUP5 04D3 84 DUP5 04D4 81 DUP2 04D5 51 MLOAD 04D6 81 DUP2 04D7 10 LT 04D8 61 PUSH2 0x04e3 04DB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04D1 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @04D2 stack[-1] = stack[-6] // @04D3 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x04e3, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_04DC: // Incoming jump from 0x04DB, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 04DC 61 PUSH2 0x04e3 04DF 61 PUSH2 0x230e 04E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @04DC stack[0] = 0x04e3 } // Block ends with unconditional jump to 0x230e label_04E3: // Incoming jump from 0x04DB, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @04E6 stack[-1] // @04EA stack[-2] // @04EB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @04EE memory[0x40:0x60] // } 04E3 5B JUMPDEST 04E4 60 PUSH1 0x20 04E6 02 MUL 04E7 60 PUSH1 0x20 04E9 01 ADD 04EA 01 ADD 04EB 51 MLOAD 04EC 60 PUSH1 0x40 04EE 51 MLOAD 04EF 80 DUP1 04F0 60 PUSH1 0x20 04F2 01 ADD 04F3 60 PUSH1 0x40 04F5 52 MSTORE 04F6 80 DUP1 04F7 60 PUSH1 0x00 04F9 81 DUP2 04FA 52 MSTORE 04FB 50 POP 04FC 61 PUSH2 0x0bef 04FF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @04EB stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @04EE stack[-1] = memory[0x40:0x60] // @04F5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @04FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0bef 0500 5B JUMPDEST 0501 80 DUP1 0502 61 PUSH2 0x050a 0505 81 DUP2 0506 61 PUSH2 0x233a 0509 56 *JUMP 050A 5B JUMPDEST 050B 91 SWAP2 050C 50 POP 050D 50 POP 050E 61 PUSH2 0x0485 0511 56 *JUMP label_0512: // Incoming return from call to 0x153D at 0x0D73 // Incoming jump from 0x048D, if !(0x00 < stack[-3]) // Inputs[1] { @0518 stack[-6] } 0512 5B JUMPDEST 0513 50 POP 0514 50 POP 0515 50 POP 0516 50 POP 0517 50 POP 0518 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0519: // Incoming jump from 0x01CC // Inputs[1] { @051F storage[0x02] } 0519 5B JUMPDEST 051A 60 PUSH1 0x60 051C 60 PUSH1 0x02 051E 80 DUP1 051F 54 SLOAD 0520 61 PUSH2 0x0528 0523 90 SWAP1 0524 61 PUSH2 0x2353 0527 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @051A stack[0] = 0x60 // @051C stack[1] = 0x02 // @0523 stack[2] = 0x0528 // @0523 stack[3] = storage[0x02] // } // Block ends with call to 0x2353, returns to 0x0528 label_0528: // Incoming return from call to 0x2353 at 0x0527 // Inputs[4] // { // @0529 stack[-1] // @0538 memory[0x40:0x60] // @0540 stack[-2] // @054B storage[stack[-2]] // } 0528 5B JUMPDEST 0529 80 DUP1 052A 60 PUSH1 0x1f 052C 01 ADD 052D 60 PUSH1 0x20 052F 80 DUP1 0530 91 SWAP2 0531 04 DIV 0532 02 MUL 0533 60 PUSH1 0x20 0535 01 ADD 0536 60 PUSH1 0x40 0538 51 MLOAD 0539 90 SWAP1 053A 81 DUP2 053B 01 ADD 053C 60 PUSH1 0x40 053E 52 MSTORE 053F 80 DUP1 0540 92 SWAP3 0541 91 SWAP2 0542 90 SWAP1 0543 81 DUP2 0544 81 DUP2 0545 52 MSTORE 0546 60 PUSH1 0x20 0548 01 ADD 0549 82 DUP3 054A 80 DUP1 054B 54 SLOAD 054C 61 PUSH2 0x0554 054F 90 SWAP1 0550 61 PUSH2 0x2353 0553 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @053E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0540 stack[-2] = memory[0x40:0x60] // @0541 stack[-1] = stack[-2] // @0542 stack[0] = stack[-1] // @0545 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0548 stack[1] = 0x20 + memory[0x40:0x60] // @0549 stack[2] = stack[-2] // @054F stack[4] = storage[stack[-2]] // @054F stack[3] = 0x0554 // } // Block ends with call to 0x2353, returns to 0x0554 label_0554: // Incoming return from call to 0x2353 at 0x0553 // Inputs[1] { @0555 stack[-1] } 0554 5B JUMPDEST 0555 80 DUP1 0556 15 ISZERO 0557 61 PUSH2 0x05a1 055A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a1, if !stack[-1] label_055B: // Incoming jump from 0x055A, if not !stack[-1] // Inputs[1] { @055B stack[-1] } 055B 80 DUP1 055C 60 PUSH1 0x1f 055E 10 LT 055F 61 PUSH2 0x0576 0562 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0576, if 0x1f < stack[-1] label_0563: // Incoming jump from 0x0562, if not 0x1f < stack[-1] // Inputs[4] // { // @0567 stack[-2] // @0568 storage[stack[-2]] // @056B stack[-3] // @056D stack[-1] // } 0563 61 PUSH2 0x0100 0566 80 DUP1 0567 83 DUP4 0568 54 SLOAD 0569 04 DIV 056A 02 MUL 056B 83 DUP4 056C 52 MSTORE 056D 91 SWAP2 056E 60 PUSH1 0x20 0570 01 ADD 0571 91 SWAP2 0572 61 PUSH2 0x05a1 0575 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @056C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0571 stack[-1] = stack[-1] // @0571 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x05a1 label_0576: // Incoming jump from 0x0562, if 0x1f < stack[-1] // Inputs[5] // { // @0577 stack[-3] // @0578 stack[-1] // @057A stack[-2] // @0582 memory[0x00:0x20] // @0586 storage[keccak256(memory[0x00:0x20])] // } 0576 5B JUMPDEST 0577 82 DUP3 0578 01 ADD 0579 91 SWAP2 057A 90 SWAP1 057B 60 PUSH1 0x00 057D 52 MSTORE 057E 60 PUSH1 0x20 0580 60 PUSH1 0x00 0582 20 SHA3 0583 90 SWAP1 0584 5B JUMPDEST 0585 81 DUP2 0586 54 SLOAD 0587 81 DUP2 0588 52 MSTORE 0589 90 SWAP1 058A 60 PUSH1 0x01 058C 01 ADD 058D 90 SWAP1 058E 60 PUSH1 0x20 0590 01 ADD 0591 80 DUP1 0592 83 DUP4 0593 11 GT 0594 61 PUSH2 0x0584 0597 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0579 stack[-3] = stack[-3] + stack[-1] // @057D memory[0x00:0x20] = stack[-2] // @0588 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @058D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0590 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0584, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0598: // Incoming jump from 0x0597, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0597, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0598 stack[-3] // @0599 stack[-1] // } 0598 82 DUP3 0599 90 SWAP1 059A 03 SUB 059B 60 PUSH1 0x1f 059D 16 AND 059E 82 DUP3 059F 01 ADD 05A0 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @05A0 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @05A0 stack[-1] = stack[-3] // } // Block continues label_05A1: // Incoming jump from 0x0575 // Incoming jump from 0x055A, if !stack[-1] // Incoming jump from 0x05A0 // Inputs[4] // { // @05A7 stack[-7] // @05A7 stack[-6] // @05A9 stack[-9] // @05AA stack[-8] // } 05A1 5B JUMPDEST 05A2 50 POP 05A3 50 POP 05A4 50 POP 05A5 50 POP 05A6 50 POP 05A7 90 SWAP1 05A8 50 POP 05A9 91 SWAP2 05AA 90 SWAP1 05AB 50 POP 05AC 56 *JUMP // Stack delta = -8 // Outputs[1] { @05A9 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_05AD: // Incoming jump from 0x01EC // Inputs[1] { @05B5 storage[0x05] } 05AD 5B JUMPDEST 05AE 60 PUSH1 0x00 05B0 80 DUP1 05B1 80 DUP1 05B2 5B JUMPDEST 05B3 60 PUSH1 0x05 05B5 54 SLOAD 05B6 81 DUP2 05B7 10 LT 05B8 15 ISZERO 05B9 61 PUSH2 0x05fb 05BC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05AE stack[0] = 0x00 // @05B0 stack[1] = 0x00 // @05B1 stack[2] = 0x00 // } // Block ends with conditional jump to 0x05fb, if !(0x00 < storage[0x05]) label_05BD: // Incoming jump from 0x05BC, if not !(stack[-1] < storage[0x05]) // Incoming jump from 0x05BC, if not !(0x00 < storage[0x05]) // Inputs[3] // { // @05BD stack[-4] // @05C0 stack[-1] // @05C2 storage[0x05] // } 05BD 83 DUP4 05BE 60 PUSH1 0x05 05C0 82 DUP3 05C1 81 DUP2 05C2 54 SLOAD 05C3 81 DUP2 05C4 10 LT 05C5 61 PUSH2 0x05d0 05C8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05BD stack[0] = stack[-4] // @05BE stack[1] = 0x05 // @05C0 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x05d0, if stack[-1] < storage[0x05] label_05C9: // Incoming jump from 0x05C8, if not stack[-1] < storage[0x05] 05C9 61 PUSH2 0x05d0 05CC 61 PUSH2 0x230e 05CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @05C9 stack[0] = 0x05d0 } // Block ends with unconditional jump to 0x230e label_05D0: // Incoming jump from 0x05C8, if stack[-1] < storage[0x05] // Inputs[5] // { // @05D1 stack[-1] // @05D1 stack[-2] // @05D9 memory[0x00:0x20] // @05DB storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @05DC stack[-3] // } 05D0 5B JUMPDEST 05D1 90 SWAP1 05D2 60 PUSH1 0x00 05D4 52 MSTORE 05D5 60 PUSH1 0x20 05D7 60 PUSH1 0x00 05D9 20 SHA3 05DA 01 ADD 05DB 54 SLOAD 05DC 03 SUB 05DD 61 PUSH2 0x05e9 05E0 57 *JUMPI // Stack delta = -3 // Outputs[1] { @05D4 memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x05e9, if storage[keccak256(memory[0x00:0x20]) + stack[-1]] - stack[-3] label_05E1: // Incoming jump from 0x05E0, if not storage[keccak256(memory[0x00:0x20]) + stack[-1]] - stack[-3] // Inputs[1] { @05E3 stack[-2] } 05E1 60 PUSH1 0x01 05E3 91 SWAP2 05E4 50 POP 05E5 61 PUSH2 0x05fb 05E8 56 *JUMP // Stack delta = +0 // Outputs[1] { @05E3 stack[-2] = 0x01 } // Block ends with unconditional jump to 0x05fb label_05E9: // Incoming jump from 0x05E0, if storage[keccak256(memory[0x00:0x20]) + stack[-1]] - stack[-3] // Inputs[1] { @05EA stack[-1] } 05E9 5B JUMPDEST 05EA 80 DUP1 05EB 61 PUSH2 0x05f3 05EE 81 DUP2 05EF 61 PUSH2 0x233a 05F2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05EA stack[0] = stack[-1] // @05EB stack[1] = 0x05f3 // @05EE stack[2] = stack[-1] // } // Block ends with call to 0x233a, returns to 0x05F3 label_05F3: // Incoming return from call to 0x233A at 0x05F2 // Inputs[2] // { // @05F4 stack[-1] // @05F4 stack[-3] // } 05F3 5B JUMPDEST 05F4 91 SWAP2 05F5 50 POP 05F6 50 POP 05F7 61 PUSH2 0x05b2 05FA 56 *JUMP // Stack delta = -2 // Outputs[1] { @05F4 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x05b2 label_05FB: // Incoming jump from 0x05E8 // Incoming jump from 0x05BC, if !(stack[-1] < storage[0x05]) // Incoming jump from 0x05BC, if !(0x00 < storage[0x05]) // Inputs[3] // { // @05FD stack[-2] // @05FD stack[-5] // @05FE stack[-4] // } 05FB 5B JUMPDEST 05FC 50 POP 05FD 92 SWAP3 05FE 91 SWAP2 05FF 50 POP 0600 50 POP 0601 56 *JUMP // Stack delta = -4 // Outputs[1] { @05FD stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_0602: // Incoming jump from 0x01FF 0602 5B JUMPDEST 0603 61 PUSH2 0x060a 0606 61 PUSH2 0x0b80 0609 56 *JUMP // Stack delta = +1 // Outputs[1] { @0603 stack[0] = 0x060a } // Block ends with call to 0x0b80, returns to 0x060A label_060A: // Incoming return from call to 0x0B80 at 0x0609 // Inputs[3] // { // @060E storage[0x05] // @063D stack[-1] // @063E stack[-2] // } 060A 5B JUMPDEST 060B 60 PUSH1 0x05 060D 80 DUP1 060E 54 SLOAD 060F 60 PUSH1 0x01 0611 81 DUP2 0612 01 ADD 0613 82 DUP3 0614 55 SSTORE 0615 60 PUSH1 0x00 0617 91 SWAP2 0618 90 SWAP1 0619 91 SWAP2 061A 52 MSTORE 061B 7F PUSH32 0x036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db0 063C 01 ADD 063D 55 SSTORE 063E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0614 storage[0x05] = storage[0x05] + 0x01 // @061A memory[0x00:0x20] = 0x05 // @063D storage[0x036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db0 + storage[0x05]] = stack[-1] // } // Block ends with unconditional jump to stack[-2] 063F 5B JUMPDEST 0640 60 PUSH1 0x01 0642 60 PUSH1 0x01 0644 60 PUSH1 0xa0 0646 1B SHL 0647 03 SUB 0648 85 DUP6 0649 16 AND 064A 33 CALLER 064B 14 EQ 064C 80 DUP1 064D 61 PUSH2 0x065b 0650 57 *JUMPI 0651 50 POP 0652 61 PUSH2 0x065b 0655 85 DUP6 0656 33 CALLER 0657 61 PUSH2 0x0319 065A 56 *JUMP 065B 5B JUMPDEST 065C 61 PUSH2 0x0677 065F 57 *JUMPI 0660 60 PUSH1 0x40 0662 51 MLOAD 0663 62 PUSH3 0x461bcd 0667 60 PUSH1 0xe5 0669 1B SHL 066A 81 DUP2 066B 52 MSTORE 066C 60 PUSH1 0x04 066E 01 ADD 066F 61 PUSH2 0x03f8 0672 90 SWAP1 0673 61 PUSH2 0x238d 0676 56 *JUMP 0677 5B JUMPDEST 0678 61 PUSH2 0x0512 067B 85 DUP6 067C 85 DUP6 067D 85 DUP6 067E 85 DUP6 067F 85 DUP6 0680 61 PUSH2 0x0d74 0683 56 *JUMP label_0684: // Incoming jump from 0x0225 // Inputs[4] // { // @0687 stack[-1] // @0688 memory[stack[-1]:stack[-1] + 0x20] // @0689 stack[-2] // @068A memory[stack[-2]:stack[-2] + 0x20] // } 0684 5B JUMPDEST 0685 60 PUSH1 0x60 0687 81 DUP2 0688 51 MLOAD 0689 83 DUP4 068A 51 MLOAD 068B 14 EQ 068C 61 PUSH2 0x06e9 068F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0685 stack[0] = 0x60 } // Block ends with conditional jump to 0x06e9, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_0690: // Incoming jump from 0x068F, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0692 memory[0x40:0x60] } 0690 60 PUSH1 0x40 0692 51 MLOAD 0693 62 PUSH3 0x461bcd 0697 60 PUSH1 0xe5 0699 1B SHL 069A 81 DUP2 069B 52 MSTORE 069C 60 PUSH1 0x20 069E 60 PUSH1 0x04 06A0 82 DUP3 06A1 01 ADD 06A2 52 MSTORE 06A3 60 PUSH1 0x29 06A5 60 PUSH1 0x24 06A7 82 DUP3 06A8 01 ADD 06A9 52 MSTORE 06AA 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 06CB 60 PUSH1 0x44 06CD 82 DUP3 06CE 01 ADD 06CF 52 MSTORE 06D0 68 PUSH9 0x040dad2e6dac2e8c6d 06DA 60 PUSH1 0xbb 06DC 1B SHL 06DD 60 PUSH1 0x64 06DF 82 DUP3 06E0 01 ADD 06E1 52 MSTORE 06E2 60 PUSH1 0x84 06E4 01 ADD 06E5 61 PUSH2 0x03f8 06E8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @069B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06A2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06A9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @06CF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @06E1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x040dad2e6dac2e8c6d << 0xbb // @06E4 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_06E9: // Incoming jump from 0x068F, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @06EC stack[-3] // @06ED memory[stack[-3]:stack[-3] + 0x20] // } 06E9 5B JUMPDEST 06EA 60 PUSH1 0x00 06EC 83 DUP4 06ED 51 MLOAD 06EE 60 PUSH1 0x01 06F0 60 PUSH1 0x01 06F2 60 PUSH1 0x40 06F4 1B SHL 06F5 03 SUB 06F6 81 DUP2 06F7 11 GT 06F8 15 ISZERO 06F9 61 PUSH2 0x0704 06FC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @06EA stack[0] = 0x00 // @06ED stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x0704, if !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_06FD: // Incoming jump from 0x06FC, if not !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) 06FD 61 PUSH2 0x0704 0700 61 PUSH2 0x1aff 0703 56 *JUMP // Stack delta = +1 // Outputs[1] { @06FD stack[0] = 0x0704 } // Block ends with unconditional jump to 0x1aff label_0704: // Incoming jump from 0x06FC, if !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0707 memory[0x40:0x60] // @0708 stack[-1] // } 0704 5B JUMPDEST 0705 60 PUSH1 0x40 0707 51 MLOAD 0708 90 SWAP1 0709 80 DUP1 070A 82 DUP3 070B 52 MSTORE 070C 80 DUP1 070D 60 PUSH1 0x20 070F 02 MUL 0710 60 PUSH1 0x20 0712 01 ADD 0713 82 DUP3 0714 01 ADD 0715 60 PUSH1 0x40 0717 52 MSTORE 0718 80 DUP1 0719 15 ISZERO 071A 61 PUSH2 0x072d 071D 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0708 stack[-1] = memory[0x40:0x60] // @0708 stack[0] = stack[-1] // @070B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0717 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x072d, if !stack[-1] label_071E: // Incoming jump from 0x071D, if not !stack[-1] // Inputs[7] // { // @071E stack[-2] // @0724 stack[-1] // @0727 msg.data.length // @0729 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @072F stack[-3] // @0734 stack[-6] // @0735 memory[stack[-6]:stack[-6] + 0x20] // } 071E 81 DUP2 071F 60 PUSH1 0x20 0721 01 ADD 0722 60 PUSH1 0x20 0724 82 DUP3 0725 02 MUL 0726 80 DUP1 0727 36 CALLDATASIZE 0728 83 DUP4 0729 37 CALLDATACOPY 072A 01 ADD 072B 90 SWAP1 072C 50 POP 072D 5B JUMPDEST 072E 50 POP 072F 90 SWAP1 0730 50 POP 0731 60 PUSH1 0x00 0733 5B JUMPDEST 0734 84 DUP5 0735 51 MLOAD 0736 81 DUP2 0737 10 LT 0738 15 ISZERO 0739 61 PUSH2 0x07a5 073C 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0729 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @072F stack[-3] = stack[-2] // @0731 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x07a5, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_073D: // Incoming jump from 0x073C, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x073C, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x073C, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @0740 stack[-5] // @0741 stack[-1] // @0743 memory[stack[-5]:stack[-5] + 0x20] // } 073D 61 PUSH2 0x0778 0740 85 DUP6 0741 82 DUP3 0742 81 DUP2 0743 51 MLOAD 0744 81 DUP2 0745 10 LT 0746 61 PUSH2 0x0751 0749 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @073D stack[0] = 0x0778 // @0740 stack[1] = stack[-5] // @0741 stack[2] = stack[-1] // } // Block ends with conditional call to 0x0751, returns to 0x0778, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_074A: // Incoming jump from 0x0749, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 074A 61 PUSH2 0x0751 074D 61 PUSH2 0x230e 0750 56 *JUMP // Stack delta = +1 // Outputs[1] { @074A stack[0] = 0x0751 } // Block ends with unconditional jump to 0x230e label_0751: // Incoming call from 0x0749, returns to 0x0778, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @0754 stack[-1] // @0758 stack[-2] // @0759 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @075A stack[-7] // @075B stack[-4] // @075D memory[stack[-7]:stack[-7] + 0x20] // } 0751 5B JUMPDEST 0752 60 PUSH1 0x20 0754 02 MUL 0755 60 PUSH1 0x20 0757 01 ADD 0758 01 ADD 0759 51 MLOAD 075A 85 DUP6 075B 83 DUP4 075C 81 DUP2 075D 51 MLOAD 075E 81 DUP2 075F 10 LT 0760 61 PUSH2 0x076b 0763 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0759 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @075A stack[-1] = stack[-7] // @075B stack[0] = stack[-4] // } // Block ends with conditional jump to 0x076b, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_0764: // Incoming jump from 0x0763, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 0764 61 PUSH2 0x076b 0767 61 PUSH2 0x230e 076A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0764 stack[0] = 0x076b } // Block ends with unconditional jump to 0x230e label_076B: // Incoming jump from 0x0763, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @076E stack[-1] // @0772 stack[-2] // @0773 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 076B 5B JUMPDEST 076C 60 PUSH1 0x20 076E 02 MUL 076F 60 PUSH1 0x20 0771 01 ADD 0772 01 ADD 0773 51 MLOAD 0774 61 PUSH2 0x0391 0777 56 *JUMP // Stack delta = -1 // Outputs[1] { @0773 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0391 label_0778: // Incoming return from call to 0x0751 at 0x0749 // Inputs[3] // { // @0779 stack[-3] // @077A stack[-2] // @077C memory[stack[-3]:stack[-3] + 0x20] // } 0778 5B JUMPDEST 0779 82 DUP3 077A 82 DUP3 077B 81 DUP2 077C 51 MLOAD 077D 81 DUP2 077E 10 LT 077F 61 PUSH2 0x078a 0782 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0779 stack[0] = stack[-3] // @077A stack[1] = stack[-2] // } // Block ends with conditional jump to 0x078a, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0783: // Incoming jump from 0x0782, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 0783 61 PUSH2 0x078a 0786 61 PUSH2 0x230e 0789 56 *JUMP // Stack delta = +1 // Outputs[1] { @0783 stack[0] = 0x078a } // Block ends with unconditional jump to 0x230e label_078A: // Incoming jump from 0x0782, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @078D stack[-1] // @0790 stack[-2] // @0795 stack[-3] // @0799 stack[-4] // } 078A 5B JUMPDEST 078B 60 PUSH1 0x20 078D 90 SWAP1 078E 81 DUP2 078F 02 MUL 0790 91 SWAP2 0791 90 SWAP1 0792 91 SWAP2 0793 01 ADD 0794 01 ADD 0795 52 MSTORE 0796 61 PUSH2 0x079e 0799 81 DUP2 079A 61 PUSH2 0x233a 079D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0795 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0796 stack[-3] = 0x079e // @0799 stack[-2] = stack[-4] // } // Block ends with call to 0x233a, returns to 0x079E label_079E: // Incoming return from call to 0x233A at 0x079D // Inputs[2] // { // @079F stack[-2] // @079F stack[-1] // } 079E 5B JUMPDEST 079F 90 SWAP1 07A0 50 POP 07A1 61 PUSH2 0x0733 07A4 56 *JUMP // Stack delta = -1 // Outputs[1] { @079F stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0733 label_07A5: // Incoming jump from 0x073C, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x073C, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x073C, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @07A7 stack[-6] // @07A7 stack[-2] // @07A8 stack[-5] // } 07A5 5B JUMPDEST 07A6 50 POP 07A7 93 SWAP4 07A8 92 SWAP3 07A9 50 POP 07AA 50 POP 07AB 50 POP 07AC 56 *JUMP // Stack delta = -5 // Outputs[1] { @07A7 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_07AD: // Incoming jump from 0x0245 07AD 5B JUMPDEST 07AE 61 PUSH2 0x07b5 07B1 61 PUSH2 0x0b80 07B4 56 *JUMP // Stack delta = +1 // Outputs[1] { @07AE stack[0] = 0x07b5 } // Block ends with call to 0x0b80, returns to 0x07B5 label_07B5: // Incoming return from call to 0x0B80 at 0x07B4 // Inputs[1] { @07B9 stack[-1] } 07B5 5B JUMPDEST 07B6 61 PUSH2 0x07be 07B9 81 DUP2 07BA 61 PUSH2 0x0f10 07BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07B6 stack[0] = 0x07be // @07B9 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x0f10 label_07BE: // Incoming jump from 0x1ADD, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1101 at 0x0B3C // Inputs[1] { @07C0 stack[-2] } 07BE 5B JUMPDEST 07BF 50 POP 07C0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_07C1: // Incoming jump from 0x0258 // Inputs[2] // { // @07CA stack[-3] // @07CC msg.sender // } 07C1 5B JUMPDEST 07C2 60 PUSH1 0x01 07C4 60 PUSH1 0x01 07C6 60 PUSH1 0xa0 07C8 1B SHL 07C9 03 SUB 07CA 83 DUP4 07CB 16 AND 07CC 33 CALLER 07CD 14 EQ 07CE 80 DUP1 07CF 61 PUSH2 0x07dd 07D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07CD stack[0] = msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x07dd, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_07D3: // Incoming jump from 0x07D2, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @07D7 stack[-4] // @07D8 msg.sender // } 07D3 50 POP 07D4 61 PUSH2 0x07dd 07D7 83 DUP4 07D8 33 CALLER 07D9 61 PUSH2 0x0319 07DC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07D4 stack[-1] = 0x07dd // @07D7 stack[0] = stack[-4] // @07D8 stack[1] = msg.sender // } // Block ends with call to 0x0319, returns to 0x07DD label_07DD: // Incoming return from call to 0x0319 at 0x07DC // Incoming jump from 0x07D2, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @07E1 stack[-1] } 07DD 5B JUMPDEST 07DE 61 PUSH2 0x07f9 07E1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07f9, if stack[-1] label_07E2: // Incoming jump from 0x07E1, if not stack[-1] // Inputs[1] { @07E4 memory[0x40:0x60] } 07E2 60 PUSH1 0x40 07E4 51 MLOAD 07E5 62 PUSH3 0x461bcd 07E9 60 PUSH1 0xe5 07EB 1B SHL 07EC 81 DUP2 07ED 52 MSTORE 07EE 60 PUSH1 0x04 07F0 01 ADD 07F1 61 PUSH2 0x03f8 07F4 90 SWAP1 07F5 61 PUSH2 0x238d 07F8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07F4 stack[0] = 0x03f8 // @07F4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x238d, returns to 0x03F8 label_07F9: // Incoming jump from 0x07E1, if stack[-1] // Inputs[3] // { // @07FD stack[-3] // @07FE stack[-2] // @07FF stack[-1] // } 07F9 5B JUMPDEST 07FA 61 PUSH2 0x0804 07FD 83 DUP4 07FE 83 DUP4 07FF 83 DUP4 0800 61 PUSH2 0x0f1c 0803 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07FA stack[0] = 0x0804 // @07FD stack[1] = stack[-3] // @07FE stack[2] = stack[-2] // @07FF stack[3] = stack[-1] // } // Block ends with call to 0x0f1c, returns to 0x0804 label_0804: // Incoming jump from 0x2519, if !(stack[-2] > 0x1f) // Incoming return from call to 0x0F1C at 0x0803 // Incoming return from call to 0x1434 at 0x0B7F // Inputs[1] { @0808 stack[-4] } 0804 5B JUMPDEST 0805 50 POP 0806 50 POP 0807 50 POP 0808 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0809: // Incoming jump from 0x0260 0809 5B JUMPDEST 080A 61 PUSH2 0x0811 080D 61 PUSH2 0x10a7 0810 56 *JUMP // Stack delta = +1 // Outputs[1] { @080A stack[0] = 0x0811 } // Block ends with call to 0x10a7, returns to 0x0811 label_0811: // Incoming return from call to 0x10A7 at 0x0810 0811 5B JUMPDEST 0812 61 PUSH2 0x081b 0815 60 PUSH1 0x00 0817 61 PUSH2 0x1101 081A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0812 stack[0] = 0x081b // @0815 stack[1] = 0x00 // } // Block ends with call to 0x1101, returns to 0x081B label_081B: // Incoming jump from 0x10B9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Incoming return from call to 0x1101 at 0x081A // Incoming jump from 0x0BA7, if stack[-1] // Incoming jump from 0x0BA7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @081C stack[-1] } 081B 5B JUMPDEST 081C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_081D: // Incoming jump from 0x0273 081D 5B JUMPDEST 081E 61 PUSH2 0x0825 0821 61 PUSH2 0x10a7 0824 56 *JUMP // Stack delta = +1 // Outputs[1] { @081E stack[0] = 0x0825 } // Block ends with call to 0x10a7, returns to 0x0825 label_0825: // Incoming return from call to 0x10A7 at 0x0824 // Inputs[3] // { // @0829 storage[0x04] // @083C stack[-1] // @0846 stack[-2] // } 0825 5B JUMPDEST 0826 60 PUSH1 0x04 0828 80 DUP1 0829 54 SLOAD 082A 60 PUSH1 0x01 082C 60 PUSH1 0x01 082E 60 PUSH1 0xa0 0830 1B SHL 0831 03 SUB 0832 19 NOT 0833 16 AND 0834 60 PUSH1 0x01 0836 60 PUSH1 0x01 0838 60 PUSH1 0xa0 083A 1B SHL 083B 03 SUB 083C 92 SWAP3 083D 90 SWAP1 083E 92 SWAP3 083F 16 AND 0840 91 SWAP2 0841 90 SWAP1 0842 91 SWAP2 0843 17 OR 0844 90 SWAP1 0845 55 SSTORE 0846 56 *JUMP // Stack delta = -2 // Outputs[1] { @0845 storage[0x04] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x04]) } // Block ends with unconditional jump to stack[-2] label_0847: // Incoming jump from 0x02AB // Inputs[2] // { // @084A stack[-1] // @084C storage[0x05] // } 0847 5B JUMPDEST 0848 60 PUSH1 0x05 084A 81 DUP2 084B 81 DUP2 084C 54 SLOAD 084D 81 DUP2 084E 10 LT 084F 61 PUSH2 0x0857 0852 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0848 stack[0] = 0x05 // @084A stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0857, if stack[-1] < storage[0x05] label_0853: // Incoming jump from 0x0852, if not stack[-1] < storage[0x05] // Inputs[1] { @0856 memory[0x00:0x00] } 0853 60 PUSH1 0x00 0855 80 DUP1 0856 FD *REVERT // Stack delta = +0 // Outputs[1] { @0856 revert(memory[0x00:0x00]); } // Block terminates label_0857: // Incoming jump from 0x0852, if stack[-1] < storage[0x05] // Inputs[6] // { // @085A stack[-2] // @085F stack[-1] // @0861 memory[0x00:0x20] // @0863 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0864 stack[-3] // @0866 stack[-4] // } 0857 5B JUMPDEST 0858 60 PUSH1 0x00 085A 91 SWAP2 085B 82 DUP3 085C 52 MSTORE 085D 60 PUSH1 0x20 085F 90 SWAP1 0860 91 SWAP2 0861 20 SHA3 0862 01 ADD 0863 54 SLOAD 0864 90 SWAP1 0865 50 POP 0866 81 DUP2 0867 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @085C memory[0x00:0x20] = stack[-2] // @0864 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-4] 0868 5B JUMPDEST 0869 60 PUSH1 0x40 086B 51 MLOAD 086C 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 088D 60 PUSH1 0x20 088F 82 DUP3 0890 01 ADD 0891 52 MSTORE 0892 60 PUSH1 0x3c 0894 81 DUP2 0895 01 ADD 0896 83 DUP4 0897 90 SWAP1 0898 52 MSTORE 0899 60 PUSH1 0x00 089B 90 SWAP1 089C 81 DUP2 089D 90 SWAP1 089E 60 PUSH1 0x5c 08A0 01 ADD 08A1 60 PUSH1 0x40 08A3 51 MLOAD 08A4 60 PUSH1 0x20 08A6 81 DUP2 08A7 83 DUP4 08A8 03 SUB 08A9 03 SUB 08AA 81 DUP2 08AB 52 MSTORE 08AC 90 SWAP1 08AD 60 PUSH1 0x40 08AF 52 MSTORE 08B0 80 DUP1 08B1 51 MLOAD 08B2 90 SWAP1 08B3 60 PUSH1 0x20 08B5 01 ADD 08B6 20 SHA3 08B7 90 SWAP1 08B8 50 POP 08B9 61 PUSH2 0x08c2 08BC 81 DUP2 08BD 84 DUP5 08BE 61 PUSH2 0x1153 08C1 56 *JUMP label_08C2: // Incoming return from call to 0x1D96 at 0x201B // Incoming return from call to 0x1B64 at 0x2199 // Inputs[3] // { // @08C3 stack[-1] // @08C3 stack[-6] // @08C4 stack[-5] // } 08C2 5B JUMPDEST 08C3 94 SWAP5 08C4 93 SWAP4 08C5 50 POP 08C6 50 POP 08C7 50 POP 08C8 50 POP 08C9 56 *JUMP // Stack delta = -5 // Outputs[1] { @08C3 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 08CA 5B JUMPDEST 08CB 81 DUP2 08CC 51 MLOAD 08CD 60 PUSH1 0x20 08CF 81 DUP2 08D0 84 DUP5 08D1 01 ADD 08D2 81 DUP2 08D3 01 ADD 08D4 80 DUP1 08D5 51 MLOAD 08D6 60 PUSH1 0x06 08D8 82 DUP3 08D9 52 MSTORE 08DA 92 SWAP3 08DB 82 DUP3 08DC 01 ADD 08DD 91 SWAP2 08DE 85 DUP6 08DF 01 ADD 08E0 91 SWAP2 08E1 90 SWAP1 08E2 91 SWAP2 08E3 20 SHA3 08E4 91 SWAP2 08E5 90 SWAP1 08E6 52 MSTORE 08E7 80 DUP1 08E8 54 SLOAD 08E9 82 DUP3 08EA 90 SWAP1 08EB 81 DUP2 08EC 10 LT 08ED 61 PUSH2 0x08f5 08F0 57 *JUMPI 08F1 60 PUSH1 0x00 08F3 80 DUP1 08F4 FD *REVERT 08F5 5B JUMPDEST 08F6 90 SWAP1 08F7 60 PUSH1 0x00 08F9 52 MSTORE 08FA 60 PUSH1 0x20 08FC 60 PUSH1 0x00 08FE 20 SHA3 08FF 01 ADD 0900 60 PUSH1 0x00 0902 91 SWAP2 0903 50 POP 0904 91 SWAP2 0905 50 POP 0906 50 POP 0907 54 SLOAD 0908 81 DUP2 0909 56 *JUMP label_090A: // Incoming jump from 0x02E4 // Inputs[3] // { // @090E msg.sender // @090F stack[-2] // @0910 stack[-1] // } 090A 5B JUMPDEST 090B 61 PUSH2 0x0915 090E 33 CALLER 090F 83 DUP4 0910 83 DUP4 0911 61 PUSH2 0x116f 0914 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @090B stack[0] = 0x0915 // @090E stack[1] = msg.sender // @090F stack[2] = stack[-2] // @0910 stack[3] = stack[-1] // } // Block ends with call to 0x116f, returns to 0x0915 label_0915: // Incoming return from call to 0x2556 at 0x0F1B // Incoming return from call to 0x116F at 0x0914 // Inputs[1] { @0918 stack[-3] } 0915 5B JUMPDEST 0916 50 POP 0917 50 POP 0918 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] 0919 5B JUMPDEST 091A 60 PUSH1 0x00 091C 80 DUP1 091D 80 DUP1 091E 5B JUMPDEST 091F 83 DUP4 0920 51 MLOAD 0921 81 DUP2 0922 10 LT 0923 15 ISZERO 0924 61 PUSH2 0x05fb 0927 57 *JUMPI 0928 61 PUSH2 0x0949 092B 84 DUP5 092C 82 DUP3 092D 81 DUP2 092E 51 MLOAD 092F 81 DUP2 0930 10 LT 0931 61 PUSH2 0x093c 0934 57 *JUMPI 0935 61 PUSH2 0x093c 0938 61 PUSH2 0x230e 093B 56 *JUMP 093C 5B JUMPDEST 093D 60 PUSH1 0x20 093F 02 MUL 0940 60 PUSH1 0x20 0942 01 ADD 0943 01 ADD 0944 51 MLOAD 0945 61 PUSH2 0x05ad 0948 56 *JUMP 0949 5B JUMPDEST 094A 15 ISZERO 094B 61 PUSH2 0x0957 094E 57 *JUMPI 094F 60 PUSH1 0x01 0951 91 SWAP2 0952 50 POP 0953 61 PUSH2 0x05fb 0956 56 *JUMP 0957 5B JUMPDEST 0958 80 DUP1 0959 61 PUSH2 0x0961 095C 81 DUP2 095D 61 PUSH2 0x233a 0960 56 *JUMP 0961 5B JUMPDEST 0962 91 SWAP2 0963 50 POP 0964 50 POP 0965 61 PUSH2 0x091e 0968 56 *JUMP 0969 5B JUMPDEST 096A 60 PUSH1 0x03 096C 54 SLOAD 096D 60 PUSH1 0x01 096F 60 PUSH1 0x01 0971 60 PUSH1 0xa0 0973 1B SHL 0974 03 SUB 0975 16 AND 0976 61 PUSH2 0x097f 0979 83 DUP4 097A 83 DUP4 097B 61 PUSH2 0x0868 097E 56 *JUMP 097F 5B JUMPDEST 0980 60 PUSH1 0x01 0982 60 PUSH1 0x01 0984 60 PUSH1 0xa0 0986 1B SHL 0987 03 SUB 0988 16 AND 0989 14 EQ 098A 61 PUSH2 0x09d5 098D 57 *JUMPI 098E 60 PUSH1 0x40 0990 51 MLOAD 0991 62 PUSH3 0x461bcd 0995 60 PUSH1 0xe5 0997 1B SHL 0998 81 DUP2 0999 52 MSTORE 099A 60 PUSH1 0x20 099C 60 PUSH1 0x04 099E 82 DUP3 099F 01 ADD 09A0 52 MSTORE 09A1 60 PUSH1 0x1a 09A3 60 PUSH1 0x24 09A5 82 DUP3 09A6 01 ADD 09A7 52 MSTORE 09A8 7F PUSH32 0x41646472657373206973206e6f7420616c6c6f776c6973746564000000000000 09C9 60 PUSH1 0x44 09CB 82 DUP3 09CC 01 ADD 09CD 52 MSTORE 09CE 60 PUSH1 0x64 09D0 01 ADD 09D1 61 PUSH2 0x03f8 09D4 56 *JUMP 09D5 5B JUMPDEST 09D6 61 PUSH2 0x09df 09D9 81 DUP2 09DA 84 DUP5 09DB 61 PUSH2 0x124f 09DE 56 *JUMP 09DF 5B JUMPDEST 09E0 61 PUSH2 0x0a2b 09E3 57 *JUMPI 09E4 60 PUSH1 0x40 09E6 51 MLOAD 09E7 62 PUSH3 0x461bcd 09EB 60 PUSH1 0xe5 09ED 1B SHL 09EE 81 DUP2 09EF 52 MSTORE 09F0 60 PUSH1 0x20 09F2 60 PUSH1 0x04 09F4 82 DUP3 09F5 01 ADD 09F6 81 DUP2 09F7 90 SWAP1 09F8 52 MSTORE 09F9 60 PUSH1 0x24 09FB 82 DUP3 09FC 01 ADD 09FD 52 MSTORE 09FE 7F PUSH32 0x5369676e61747572652068617320616c7265616479206265656e20757365642e 0A1F 60 PUSH1 0x44 0A21 82 DUP3 0A22 01 ADD 0A23 52 MSTORE 0A24 60 PUSH1 0x64 0A26 01 ADD 0A27 61 PUSH2 0x03f8 0A2A 56 *JUMP 0A2B 5B JUMPDEST 0A2C 61 PUSH2 0x0a46 0A2F 86 DUP7 0A30 86 DUP7 0A31 86 DUP7 0A32 60 PUSH1 0x40 0A34 51 MLOAD 0A35 80 DUP1 0A36 60 PUSH1 0x20 0A38 01 ADD 0A39 60 PUSH1 0x40 0A3B 52 MSTORE 0A3C 80 DUP1 0A3D 60 PUSH1 0x00 0A3F 81 DUP2 0A40 52 MSTORE 0A41 50 POP 0A42 61 PUSH2 0x0bef 0A45 56 *JUMP 0A46 5B JUMPDEST 0A47 60 PUSH1 0x06 0A49 81 DUP2 0A4A 60 PUSH1 0x40 0A4C 51 MLOAD 0A4D 61 PUSH2 0x0a56 0A50 91 SWAP2 0A51 90 SWAP1 0A52 61 PUSH2 0x23dc 0A55 56 *JUMP 0A56 5B JUMPDEST 0A57 90 SWAP1 0A58 81 DUP2 0A59 52 MSTORE 0A5A 60 PUSH1 0x40 0A5C 51 MLOAD 0A5D 60 PUSH1 0x20 0A5F 91 SWAP2 0A60 81 DUP2 0A61 90 SWAP1 0A62 03 SUB 0A63 82 DUP3 0A64 01 ADD 0A65 90 SWAP1 0A66 20 SHA3 0A67 80 DUP1 0A68 54 SLOAD 0A69 60 PUSH1 0x01 0A6B 81 DUP2 0A6C 01 ADD 0A6D 82 DUP3 0A6E 55 SSTORE 0A6F 60 PUSH1 0x00 0A71 91 SWAP2 0A72 82 DUP3 0A73 52 MSTORE 0A74 91 SWAP2 0A75 90 SWAP1 0A76 20 SHA3 0A77 01 ADD 0A78 92 SWAP3 0A79 90 SWAP1 0A7A 92 SWAP3 0A7B 55 SSTORE 0A7C 50 POP 0A7D 50 POP 0A7E 50 POP 0A7F 50 POP 0A80 50 POP 0A81 56 *JUMP 0A82 5B JUMPDEST 0A83 60 PUSH1 0x01 0A85 60 PUSH1 0x01 0A87 60 PUSH1 0xa0 0A89 1B SHL 0A8A 03 SUB 0A8B 85 DUP6 0A8C 16 AND 0A8D 33 CALLER 0A8E 14 EQ 0A8F 80 DUP1 0A90 61 PUSH2 0x0a9e 0A93 57 *JUMPI 0A94 50 POP 0A95 61 PUSH2 0x0a9e 0A98 85 DUP6 0A99 33 CALLER 0A9A 61 PUSH2 0x0319 0A9D 56 *JUMP 0A9E 5B JUMPDEST 0A9F 61 PUSH2 0x0aba 0AA2 57 *JUMPI 0AA3 60 PUSH1 0x40 0AA5 51 MLOAD 0AA6 62 PUSH3 0x461bcd 0AAA 60 PUSH1 0xe5 0AAC 1B SHL 0AAD 81 DUP2 0AAE 52 MSTORE 0AAF 60 PUSH1 0x04 0AB1 01 ADD 0AB2 61 PUSH2 0x03f8 0AB5 90 SWAP1 0AB6 61 PUSH2 0x238d 0AB9 56 *JUMP 0ABA 5B JUMPDEST 0ABB 61 PUSH2 0x0512 0ABE 85 DUP6 0ABF 85 DUP6 0AC0 85 DUP6 0AC1 85 DUP6 0AC2 85 DUP6 0AC3 61 PUSH2 0x130a 0AC6 56 *JUMP label_0AC7: // Incoming jump from 0x036C 0AC7 5B JUMPDEST 0AC8 61 PUSH2 0x0acf 0ACB 61 PUSH2 0x10a7 0ACE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AC8 stack[0] = 0x0acf } // Block ends with call to 0x10a7, returns to 0x0ACF label_0ACF: // Incoming return from call to 0x10A7 at 0x0ACE // Inputs[1] { @0AD8 stack[-1] } 0ACF 5B JUMPDEST 0AD0 60 PUSH1 0x01 0AD2 60 PUSH1 0x01 0AD4 60 PUSH1 0xa0 0AD6 1B SHL 0AD7 03 SUB 0AD8 81 DUP2 0AD9 16 AND 0ADA 61 PUSH2 0x0b34 0ADD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b34, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0ADE: // Incoming jump from 0x0ADD, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0AE0 memory[0x40:0x60] } 0ADE 60 PUSH1 0x40 0AE0 51 MLOAD 0AE1 62 PUSH3 0x461bcd 0AE5 60 PUSH1 0xe5 0AE7 1B SHL 0AE8 81 DUP2 0AE9 52 MSTORE 0AEA 60 PUSH1 0x20 0AEC 60 PUSH1 0x04 0AEE 82 DUP3 0AEF 01 ADD 0AF0 52 MSTORE 0AF1 60 PUSH1 0x26 0AF3 60 PUSH1 0x24 0AF5 82 DUP3 0AF6 01 ADD 0AF7 52 MSTORE 0AF8 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0B19 60 PUSH1 0x44 0B1B 82 DUP3 0B1C 01 ADD 0B1D 52 MSTORE 0B1E 65 PUSH6 0x646472657373 0B25 60 PUSH1 0xd0 0B27 1B SHL 0B28 60 PUSH1 0x64 0B2A 82 DUP3 0B2B 01 ADD 0B2C 52 MSTORE 0B2D 60 PUSH1 0x84 0B2F 01 ADD 0B30 61 PUSH2 0x03f8 0B33 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0AE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AF0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AF7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0B1D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0B2C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0B2F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_0B34: // Incoming jump from 0x0ADD, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B38 stack[-1] } 0B34 5B JUMPDEST 0B35 61 PUSH2 0x07be 0B38 81 DUP2 0B39 61 PUSH2 0x1101 0B3C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B35 stack[0] = 0x07be // @0B38 stack[1] = stack[-1] // } // Block ends with call to 0x1101, returns to 0x07BE label_0B3D: // Incoming jump from 0x037F // Inputs[2] // { // @0B46 stack[-3] // @0B48 msg.sender // } 0B3D 5B JUMPDEST 0B3E 60 PUSH1 0x01 0B40 60 PUSH1 0x01 0B42 60 PUSH1 0xa0 0B44 1B SHL 0B45 03 SUB 0B46 83 DUP4 0B47 16 AND 0B48 33 CALLER 0B49 14 EQ 0B4A 80 DUP1 0B4B 61 PUSH2 0x0b59 0B4E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B49 stack[0] = msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x0b59, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0B4F: // Incoming jump from 0x0B4E, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0B53 stack[-4] // @0B54 msg.sender // } 0B4F 50 POP 0B50 61 PUSH2 0x0b59 0B53 83 DUP4 0B54 33 CALLER 0B55 61 PUSH2 0x0319 0B58 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B50 stack[-1] = 0x0b59 // @0B53 stack[0] = stack[-4] // @0B54 stack[1] = msg.sender // } // Block ends with call to 0x0319, returns to 0x0B59 label_0B59: // Incoming return from call to 0x0319 at 0x0B58 // Incoming jump from 0x0B4E, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B5D stack[-1] } 0B59 5B JUMPDEST 0B5A 61 PUSH2 0x0b75 0B5D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b75, if stack[-1] label_0B5E: // Incoming jump from 0x0B5D, if not stack[-1] // Inputs[1] { @0B60 memory[0x40:0x60] } 0B5E 60 PUSH1 0x40 0B60 51 MLOAD 0B61 62 PUSH3 0x461bcd 0B65 60 PUSH1 0xe5 0B67 1B SHL 0B68 81 DUP2 0B69 52 MSTORE 0B6A 60 PUSH1 0x04 0B6C 01 ADD 0B6D 61 PUSH2 0x03f8 0B70 90 SWAP1 0B71 61 PUSH2 0x238d 0B74 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B70 stack[0] = 0x03f8 // @0B70 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x238d, returns to 0x03F8 label_0B75: // Incoming jump from 0x0B5D, if stack[-1] // Inputs[3] // { // @0B79 stack[-3] // @0B7A stack[-2] // @0B7B stack[-1] // } 0B75 5B JUMPDEST 0B76 61 PUSH2 0x0804 0B79 83 DUP4 0B7A 83 DUP4 0B7B 83 DUP4 0B7C 61 PUSH2 0x1434 0B7F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B76 stack[0] = 0x0804 // @0B79 stack[1] = stack[-3] // @0B7A stack[2] = stack[-2] // @0B7B stack[3] = stack[-1] // } // Block ends with call to 0x1434, returns to 0x0804 label_0B80: // Incoming call from 0x0609, returns to 0x060A // Incoming call from 0x07B4, returns to 0x07B5 // Incoming call from 0x0481, returns to 0x0482 // Inputs[2] // { // @0B83 storage[0x03] // @0B8D msg.sender // } 0B80 5B JUMPDEST 0B81 60 PUSH1 0x03 0B83 54 SLOAD 0B84 60 PUSH1 0x01 0B86 60 PUSH1 0x01 0B88 60 PUSH1 0xa0 0B8A 1B SHL 0B8B 03 SUB 0B8C 16 AND 0B8D 33 CALLER 0B8E 14 EQ 0B8F 80 DUP1 0B90 61 PUSH2 0x0ba3 0B93 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B8E stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] } // Block ends with conditional jump to 0x0ba3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0B94: // Incoming jump from 0x0B93, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @0B97 storage[0x04] // @0BA1 msg.sender // } 0B94 50 POP 0B95 60 PUSH1 0x04 0B97 54 SLOAD 0B98 60 PUSH1 0x01 0B9A 60 PUSH1 0x01 0B9C 60 PUSH1 0xa0 0B9E 1B SHL 0B9F 03 SUB 0BA0 16 AND 0BA1 33 CALLER 0BA2 14 EQ 0BA3 5B JUMPDEST 0BA4 61 PUSH2 0x081b 0BA7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x081b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0BA8: // Incoming jump from 0x0BA7, if not stack[-1] // Incoming jump from 0x0BA7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0BAA memory[0x40:0x60] } 0BA8 60 PUSH1 0x40 0BAA 51 MLOAD 0BAB 62 PUSH3 0x461bcd 0BAF 60 PUSH1 0xe5 0BB1 1B SHL 0BB2 81 DUP2 0BB3 52 MSTORE 0BB4 60 PUSH1 0x20 0BB6 60 PUSH1 0x04 0BB8 82 DUP3 0BB9 01 ADD 0BBA 81 DUP2 0BBB 90 SWAP1 0BBC 52 MSTORE 0BBD 60 PUSH1 0x24 0BBF 82 DUP3 0BC0 01 ADD 0BC1 52 MSTORE 0BC2 7F PUSH32 0x43616c6c6572206973206e6f7420746865206f776e6572206f722061646d696e 0BE3 60 PUSH1 0x44 0BE5 82 DUP3 0BE6 01 ADD 0BE7 52 MSTORE 0BE8 60 PUSH1 0x64 0BEA 01 ADD 0BEB 61 PUSH2 0x03f8 0BEE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BBC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BC1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0BE7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616c6c6572206973206e6f7420746865206f776e6572206f722061646d696e // @0BEA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_0BEF: // Incoming jump from 0x04FF // Inputs[1] { @0BF8 stack[-4] } 0BEF 5B JUMPDEST 0BF0 60 PUSH1 0x01 0BF2 60 PUSH1 0x01 0BF4 60 PUSH1 0xa0 0BF6 1B SHL 0BF7 03 SUB 0BF8 84 DUP5 0BF9 16 AND 0BFA 61 PUSH2 0x0c4f 0BFD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c4f, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0BFE: // Incoming jump from 0x0BFD, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C00 memory[0x40:0x60] } 0BFE 60 PUSH1 0x40 0C00 51 MLOAD 0C01 62 PUSH3 0x461bcd 0C05 60 PUSH1 0xe5 0C07 1B SHL 0C08 81 DUP2 0C09 52 MSTORE 0C0A 60 PUSH1 0x20 0C0C 60 PUSH1 0x04 0C0E 82 DUP3 0C0F 01 ADD 0C10 52 MSTORE 0C11 60 PUSH1 0x21 0C13 60 PUSH1 0x24 0C15 82 DUP3 0C16 01 ADD 0C17 52 MSTORE 0C18 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 0C39 60 PUSH1 0x44 0C3B 82 DUP3 0C3C 01 ADD 0C3D 52 MSTORE 0C3E 60 PUSH1 0x73 0C40 60 PUSH1 0xf8 0C42 1B SHL 0C43 60 PUSH1 0x64 0C45 82 DUP3 0C46 01 ADD 0C47 52 MSTORE 0C48 60 PUSH1 0x84 0C4A 01 ADD 0C4B 61 PUSH2 0x03f8 0C4E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C10 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C17 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @0C3D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @0C47 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73 << 0xf8 // @0C4A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_0C4F: // Incoming jump from 0x0BFD, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0C50 stack[-2] // @0C51 memory[stack[-2]:stack[-2] + 0x20] // @0C52 stack[-3] // @0C53 memory[stack[-3]:stack[-3] + 0x20] // } 0C4F 5B JUMPDEST 0C50 81 DUP2 0C51 51 MLOAD 0C52 83 DUP4 0C53 51 MLOAD 0C54 14 EQ 0C55 61 PUSH2 0x0c70 0C58 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c70, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] label_0C59: // Incoming jump from 0x0C58, if not memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0C5B memory[0x40:0x60] } 0C59 60 PUSH1 0x40 0C5B 51 MLOAD 0C5C 62 PUSH3 0x461bcd 0C60 60 PUSH1 0xe5 0C62 1B SHL 0C63 81 DUP2 0C64 52 MSTORE 0C65 60 PUSH1 0x04 0C67 01 ADD 0C68 61 PUSH2 0x03f8 0C6B 90 SWAP1 0C6C 61 PUSH2 0x23f8 0C6F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C6B stack[0] = 0x03f8 // @0C6B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23f8, returns to 0x03F8 label_0C70: // Incoming jump from 0x0C58, if memory[stack[-3]:stack[-3] + 0x20] == memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0C71 msg.sender // @0C75 stack[-3] // @0C76 memory[stack[-3]:stack[-3] + 0x20] // } 0C70 5B JUMPDEST 0C71 33 CALLER 0C72 60 PUSH1 0x00 0C74 5B JUMPDEST 0C75 84 DUP5 0C76 51 MLOAD 0C77 81 DUP2 0C78 10 LT 0C79 15 ISZERO 0C7A 61 PUSH2 0x0d0c 0C7D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C71 stack[0] = msg.sender // @0C72 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0d0c, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_0C7E: // Incoming jump from 0x0C7D, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0C7D, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @0C7E stack[-4] // @0C7F stack[-1] // @0C81 memory[stack[-4]:stack[-4] + 0x20] // } 0C7E 83 DUP4 0C7F 81 DUP2 0C80 81 DUP2 0C81 51 MLOAD 0C82 81 DUP2 0C83 10 LT 0C84 61 PUSH2 0x0c8f 0C87 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C7E stack[0] = stack[-4] // @0C7F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0c8f, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_0C88: // Incoming jump from 0x0C87, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 0C88 61 PUSH2 0x0c8f 0C8B 61 PUSH2 0x230e 0C8E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C88 stack[0] = 0x0c8f } // Block ends with unconditional jump to 0x230e label_0C8F: // Incoming jump from 0x0C87, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @0C92 stack[-1] // @0C96 stack[-2] // @0C97 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0C9B stack[-7] // @0C9C stack[-3] // @0C9E memory[stack[-7]:stack[-7] + 0x20] // } 0C8F 5B JUMPDEST 0C90 60 PUSH1 0x20 0C92 02 MUL 0C93 60 PUSH1 0x20 0C95 01 ADD 0C96 01 ADD 0C97 51 MLOAD 0C98 60 PUSH1 0x00 0C9A 80 DUP1 0C9B 87 DUP8 0C9C 84 DUP5 0C9D 81 DUP2 0C9E 51 MLOAD 0C9F 81 DUP2 0CA0 10 LT 0CA1 61 PUSH2 0x0cac 0CA4 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0C97 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0C98 stack[-1] = 0x00 // @0C9A stack[0] = 0x00 // @0C9B stack[1] = stack[-7] // @0C9C stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0cac, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] label_0CA5: // Incoming jump from 0x0CA4, if not stack[-3] < memory[stack[-7]:stack[-7] + 0x20] 0CA5 61 PUSH2 0x0cac 0CA8 61 PUSH2 0x230e 0CAB 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CA5 stack[0] = 0x0cac } // Block ends with unconditional jump to 0x230e label_0CAC: // Incoming jump from 0x0CA4, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[10] // { // @0CAF stack[-1] // @0CB3 stack[-2] // @0CB4 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CB5 stack[-3] // @0CBA stack[-4] // @0CC2 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0CC5 stack[-11] // @0CE5 memory[0x00:0x40] // @0CE8 stack[-5] // @0CEA storage[keccak256(memory[0x00:0x40])] // } 0CAC 5B JUMPDEST 0CAD 60 PUSH1 0x20 0CAF 02 MUL 0CB0 60 PUSH1 0x20 0CB2 01 ADD 0CB3 01 ADD 0CB4 51 MLOAD 0CB5 81 DUP2 0CB6 52 MSTORE 0CB7 60 PUSH1 0x20 0CB9 01 ADD 0CBA 90 SWAP1 0CBB 81 DUP2 0CBC 52 MSTORE 0CBD 60 PUSH1 0x20 0CBF 01 ADD 0CC0 60 PUSH1 0x00 0CC2 20 SHA3 0CC3 60 PUSH1 0x00 0CC5 88 DUP9 0CC6 60 PUSH1 0x01 0CC8 60 PUSH1 0x01 0CCA 60 PUSH1 0xa0 0CCC 1B SHL 0CCD 03 SUB 0CCE 16 AND 0CCF 60 PUSH1 0x01 0CD1 60 PUSH1 0x01 0CD3 60 PUSH1 0xa0 0CD5 1B SHL 0CD6 03 SUB 0CD7 16 AND 0CD8 81 DUP2 0CD9 52 MSTORE 0CDA 60 PUSH1 0x20 0CDC 01 ADD 0CDD 90 SWAP1 0CDE 81 DUP2 0CDF 52 MSTORE 0CE0 60 PUSH1 0x20 0CE2 01 ADD 0CE3 60 PUSH1 0x00 0CE5 20 SHA3 0CE6 60 PUSH1 0x00 0CE8 82 DUP3 0CE9 82 DUP3 0CEA 54 SLOAD 0CEB 61 PUSH2 0x0cf4 0CEE 91 SWAP2 0CEF 90 SWAP1 0CF0 61 PUSH2 0x2440 0CF3 56 *JUMP // Stack delta = +1 // Outputs[9] // { // @0CB6 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CBC memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0CD9 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-11] // @0CDF memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @0CE5 stack[-4] = keccak256(memory[0x00:0x40]) // @0CE6 stack[-3] = 0x00 // @0CEE stack[-2] = 0x0cf4 // @0CEF stack[-1] = stack[-5] // @0CEF stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2440, returns to 0x0CF4 label_0CF4: // Incoming return from call to 0x2440 at 0x0CF3 // Inputs[5] // { // @0CF5 stack[-1] // @0CF5 stack[-2] // @0CF6 stack[-3] // @0CF9 stack[-5] // @0CFA stack[-4] // } 0CF4 5B JUMPDEST 0CF5 90 SWAP1 0CF6 91 SWAP2 0CF7 55 SSTORE 0CF8 50 POP 0CF9 81 DUP2 0CFA 90 SWAP1 0CFB 50 POP 0CFC 61 PUSH2 0x0d04 0CFF 81 DUP2 0D00 61 PUSH2 0x233a 0D03 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0CF7 storage[stack[-3]] = stack[-1] // @0CFA stack[-4] = stack[-5] // @0CFC stack[-3] = 0x0d04 // @0CFF stack[-2] = stack[-5] // } // Block ends with call to 0x233a, returns to 0x0D04 label_0D04: // Incoming return from call to 0x233A at 0x0D03 // Inputs[2] // { // @0D05 stack[-3] // @0D05 stack[-1] // } 0D04 5B JUMPDEST 0D05 91 SWAP2 0D06 50 POP 0D07 50 POP 0D08 61 PUSH2 0x0c74 0D0B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D05 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0c74 label_0D0C: // Incoming jump from 0x0C7D, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0C7D, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[5] // { // @0D0E stack[-6] // @0D23 stack[-2] // @0D4E stack[-5] // @0D4F stack[-4] // @0D52 memory[0x40:0x60] // } 0D0C 5B JUMPDEST 0D0D 50 POP 0D0E 84 DUP5 0D0F 60 PUSH1 0x01 0D11 60 PUSH1 0x01 0D13 60 PUSH1 0xa0 0D15 1B SHL 0D16 03 SUB 0D17 16 AND 0D18 60 PUSH1 0x00 0D1A 60 PUSH1 0x01 0D1C 60 PUSH1 0x01 0D1E 60 PUSH1 0xa0 0D20 1B SHL 0D21 03 SUB 0D22 16 AND 0D23 82 DUP3 0D24 60 PUSH1 0x01 0D26 60 PUSH1 0x01 0D28 60 PUSH1 0xa0 0D2A 1B SHL 0D2B 03 SUB 0D2C 16 AND 0D2D 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 0D4E 87 DUP8 0D4F 87 DUP8 0D50 60 PUSH1 0x40 0D52 51 MLOAD 0D53 61 PUSH2 0x0d5d 0D56 92 SWAP3 0D57 91 SWAP2 0D58 90 SWAP1 0D59 61 PUSH2 0x2453 0D5C 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @0D17 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0D22 stack[0] = (0x01 << 0xa0) - 0x01 & 0x00 // @0D2C stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0D2D stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @0D56 stack[3] = 0x0d5d // @0D57 stack[4] = stack[-5] // @0D58 stack[6] = memory[0x40:0x60] // @0D58 stack[5] = stack[-4] // } // Block ends with call to 0x2453, returns to 0x0D5D label_0D5D: // Incoming return from call to 0x2453 at 0x0D5C // Inputs[12] // { // @0D60 memory[0x40:0x60] // @0D62 stack[-1] // @0D65 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0D65 stack[-4] // @0D65 stack[-5] // @0D65 stack[-2] // @0D65 stack[-3] // @0D69 stack[-6] // @0D6C stack[-10] // @0D6D stack[-9] // @0D6E stack[-8] // @0D6F stack[-7] // } 0D5D 5B JUMPDEST 0D5E 60 PUSH1 0x40 0D60 51 MLOAD 0D61 80 DUP1 0D62 91 SWAP2 0D63 03 SUB 0D64 90 SWAP1 0D65 A4 LOG4 0D66 61 PUSH2 0x0512 0D69 81 DUP2 0D6A 60 PUSH1 0x00 0D6C 87 DUP8 0D6D 87 DUP8 0D6E 87 DUP8 0D6F 87 DUP8 0D70 61 PUSH2 0x153d 0D73 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0D65 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @0D66 stack[-5] = 0x0512 // @0D69 stack[-4] = stack[-6] // @0D6A stack[-3] = 0x00 // @0D6C stack[-2] = stack[-10] // @0D6D stack[-1] = stack[-9] // @0D6E stack[0] = stack[-8] // @0D6F stack[1] = stack[-7] // } // Block ends with call to 0x153d, returns to 0x0512 0D74 5B JUMPDEST 0D75 81 DUP2 0D76 51 MLOAD 0D77 83 DUP4 0D78 51 MLOAD 0D79 14 EQ 0D7A 61 PUSH2 0x0d95 0D7D 57 *JUMPI 0D7E 60 PUSH1 0x40 0D80 51 MLOAD 0D81 62 PUSH3 0x461bcd 0D85 60 PUSH1 0xe5 0D87 1B SHL 0D88 81 DUP2 0D89 52 MSTORE 0D8A 60 PUSH1 0x04 0D8C 01 ADD 0D8D 61 PUSH2 0x03f8 0D90 90 SWAP1 0D91 61 PUSH2 0x23f8 0D94 56 *JUMP 0D95 5B JUMPDEST 0D96 60 PUSH1 0x01 0D98 60 PUSH1 0x01 0D9A 60 PUSH1 0xa0 0D9C 1B SHL 0D9D 03 SUB 0D9E 84 DUP5 0D9F 16 AND 0DA0 61 PUSH2 0x0dbb 0DA3 57 *JUMPI 0DA4 60 PUSH1 0x40 0DA6 51 MLOAD 0DA7 62 PUSH3 0x461bcd 0DAB 60 PUSH1 0xe5 0DAD 1B SHL 0DAE 81 DUP2 0DAF 52 MSTORE 0DB0 60 PUSH1 0x04 0DB2 01 ADD 0DB3 61 PUSH2 0x03f8 0DB6 90 SWAP1 0DB7 61 PUSH2 0x2481 0DBA 56 *JUMP 0DBB 5B JUMPDEST 0DBC 33 CALLER 0DBD 60 PUSH1 0x00 0DBF 5B JUMPDEST 0DC0 84 DUP5 0DC1 51 MLOAD 0DC2 81 DUP2 0DC3 10 LT 0DC4 15 ISZERO 0DC5 61 PUSH2 0x0ea2 0DC8 57 *JUMPI 0DC9 60 PUSH1 0x00 0DCB 85 DUP6 0DCC 82 DUP3 0DCD 81 DUP2 0DCE 51 MLOAD 0DCF 81 DUP2 0DD0 10 LT 0DD1 61 PUSH2 0x0ddc 0DD4 57 *JUMPI 0DD5 61 PUSH2 0x0ddc 0DD8 61 PUSH2 0x230e 0DDB 56 *JUMP 0DDC 5B JUMPDEST 0DDD 60 PUSH1 0x20 0DDF 02 MUL 0DE0 60 PUSH1 0x20 0DE2 01 ADD 0DE3 01 ADD 0DE4 51 MLOAD 0DE5 90 SWAP1 0DE6 50 POP 0DE7 60 PUSH1 0x00 0DE9 85 DUP6 0DEA 83 DUP4 0DEB 81 DUP2 0DEC 51 MLOAD 0DED 81 DUP2 0DEE 10 LT 0DEF 61 PUSH2 0x0dfa 0DF2 57 *JUMPI 0DF3 61 PUSH2 0x0dfa 0DF6 61 PUSH2 0x230e 0DF9 56 *JUMP 0DFA 5B JUMPDEST 0DFB 60 PUSH1 0x20 0DFD 90 SWAP1 0DFE 81 DUP2 0DFF 02 MUL 0E00 91 SWAP2 0E01 90 SWAP1 0E02 91 SWAP2 0E03 01 ADD 0E04 81 DUP2 0E05 01 ADD 0E06 51 MLOAD 0E07 60 PUSH1 0x00 0E09 84 DUP5 0E0A 81 DUP2 0E0B 52 MSTORE 0E0C 80 DUP1 0E0D 83 DUP4 0E0E 52 MSTORE 0E0F 60 PUSH1 0x40 0E11 80 DUP1 0E12 82 DUP3 0E13 20 SHA3 0E14 60 PUSH1 0x01 0E16 60 PUSH1 0x01 0E18 60 PUSH1 0xa0 0E1A 1B SHL 0E1B 03 SUB 0E1C 8E DUP15 0E1D 16 AND 0E1E 83 DUP4 0E1F 52 MSTORE 0E20 90 SWAP1 0E21 93 SWAP4 0E22 52 MSTORE 0E23 91 SWAP2 0E24 90 SWAP1 0E25 91 SWAP2 0E26 20 SHA3 0E27 54 SLOAD 0E28 90 SWAP1 0E29 91 SWAP2 0E2A 50 POP 0E2B 81 DUP2 0E2C 81 DUP2 0E2D 10 LT 0E2E 15 ISZERO 0E2F 61 PUSH2 0x0e4a 0E32 57 *JUMPI 0E33 60 PUSH1 0x40 0E35 51 MLOAD 0E36 62 PUSH3 0x461bcd 0E3A 60 PUSH1 0xe5 0E3C 1B SHL 0E3D 81 DUP2 0E3E 52 MSTORE 0E3F 60 PUSH1 0x04 0E41 01 ADD 0E42 61 PUSH2 0x03f8 0E45 90 SWAP1 0E46 61 PUSH2 0x24c6 0E49 56 *JUMP 0E4A 5B JUMPDEST 0E4B 60 PUSH1 0x00 0E4D 83 DUP4 0E4E 81 DUP2 0E4F 52 MSTORE 0E50 60 PUSH1 0x20 0E52 81 DUP2 0E53 81 DUP2 0E54 52 MSTORE 0E55 60 PUSH1 0x40 0E57 80 DUP1 0E58 83 DUP4 0E59 20 SHA3 0E5A 60 PUSH1 0x01 0E5C 60 PUSH1 0x01 0E5E 60 PUSH1 0xa0 0E60 1B SHL 0E61 03 SUB 0E62 8E DUP15 0E63 81 DUP2 0E64 16 AND 0E65 85 DUP6 0E66 52 MSTORE 0E67 92 SWAP3 0E68 52 MSTORE 0E69 80 DUP1 0E6A 83 DUP4 0E6B 20 SHA3 0E6C 85 DUP6 0E6D 85 DUP6 0E6E 03 SUB 0E6F 90 SWAP1 0E70 55 SSTORE 0E71 90 SWAP1 0E72 8B DUP12 0E73 16 AND 0E74 82 DUP3 0E75 52 MSTORE 0E76 81 DUP2 0E77 20 SHA3 0E78 80 DUP1 0E79 54 SLOAD 0E7A 84 DUP5 0E7B 92 SWAP3 0E7C 90 SWAP1 0E7D 61 PUSH2 0x0e87 0E80 90 SWAP1 0E81 84 DUP5 0E82 90 SWAP1 0E83 61 PUSH2 0x2440 0E86 56 *JUMP 0E87 5B JUMPDEST 0E88 92 SWAP3 0E89 50 POP 0E8A 50 POP 0E8B 81 DUP2 0E8C 90 SWAP1 0E8D 55 SSTORE 0E8E 50 POP 0E8F 50 POP 0E90 50 POP 0E91 50 POP 0E92 80 DUP1 0E93 61 PUSH2 0x0e9b 0E96 90 SWAP1 0E97 61 PUSH2 0x233a 0E9A 56 *JUMP 0E9B 5B JUMPDEST 0E9C 90 SWAP1 0E9D 50 POP 0E9E 61 PUSH2 0x0dbf 0EA1 56 *JUMP 0EA2 5B JUMPDEST 0EA3 50 POP 0EA4 84 DUP5 0EA5 60 PUSH1 0x01 0EA7 60 PUSH1 0x01 0EA9 60 PUSH1 0xa0 0EAB 1B SHL 0EAC 03 SUB 0EAD 16 AND 0EAE 86 DUP7 0EAF 60 PUSH1 0x01 0EB1 60 PUSH1 0x01 0EB3 60 PUSH1 0xa0 0EB5 1B SHL 0EB6 03 SUB 0EB7 16 AND 0EB8 82 DUP3 0EB9 60 PUSH1 0x01 0EBB 60 PUSH1 0x01 0EBD 60 PUSH1 0xa0 0EBF 1B SHL 0EC0 03 SUB 0EC1 16 AND 0EC2 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 0EE3 87 DUP8 0EE4 87 DUP8 0EE5 60 PUSH1 0x40 0EE7 51 MLOAD 0EE8 61 PUSH2 0x0ef2 0EEB 92 SWAP3 0EEC 91 SWAP2 0EED 90 SWAP1 0EEE 61 PUSH2 0x2453 0EF1 56 *JUMP 0EF2 5B JUMPDEST 0EF3 60 PUSH1 0x40 0EF5 51 MLOAD 0EF6 80 DUP1 0EF7 91 SWAP2 0EF8 03 SUB 0EF9 90 SWAP1 0EFA A4 LOG4 0EFB 61 PUSH2 0x0f08 0EFE 81 DUP2 0EFF 87 DUP8 0F00 87 DUP8 0F01 87 DUP8 0F02 87 DUP8 0F03 87 DUP8 0F04 61 PUSH2 0x153d 0F07 56 *JUMP label_0F08: // Incoming jump from 0x254B, if !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x254B, if !(stack[-1] < stack[-2]) // Incoming jump from 0x154D, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x25B7 // Incoming jump from 0x254B, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x25B7 // Inputs[1] { @0F0F stack[-7] } 0F08 5B JUMPDEST 0F09 50 POP 0F0A 50 POP 0F0B 50 POP 0F0C 50 POP 0F0D 50 POP 0F0E 50 POP 0F0F 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0F10: // Incoming jump from 0x07BD // Inputs[1] { @0F16 stack[-1] } 0F10 5B JUMPDEST 0F11 60 PUSH1 0x02 0F13 61 PUSH2 0x0915 0F16 82 DUP3 0F17 82 DUP3 0F18 61 PUSH2 0x2556 0F1B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F11 stack[0] = 0x02 // @0F13 stack[1] = 0x0915 // @0F16 stack[2] = stack[-1] // @0F17 stack[3] = 0x02 // } // Block ends with call to 0x2556, returns to 0x0915 label_0F1C: // Incoming call from 0x0803, returns to 0x0804 // Inputs[1] { @0F25 stack[-3] } 0F1C 5B JUMPDEST 0F1D 60 PUSH1 0x01 0F1F 60 PUSH1 0x01 0F21 60 PUSH1 0xa0 0F23 1B SHL 0F24 03 SUB 0F25 83 DUP4 0F26 16 AND 0F27 61 PUSH2 0x0f42 0F2A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f42, if stack[-3] & (0x01 << 0xa0) - 0x01 label_0F2B: // Incoming jump from 0x0F2A, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F2D memory[0x40:0x60] } 0F2B 60 PUSH1 0x40 0F2D 51 MLOAD 0F2E 62 PUSH3 0x461bcd 0F32 60 PUSH1 0xe5 0F34 1B SHL 0F35 81 DUP2 0F36 52 MSTORE 0F37 60 PUSH1 0x04 0F39 01 ADD 0F3A 61 PUSH2 0x03f8 0F3D 90 SWAP1 0F3E 61 PUSH2 0x2615 0F41 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F3D stack[0] = 0x03f8 // @0F3D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2615, returns to 0x03F8 label_0F42: // Incoming jump from 0x0F2A, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0F43 stack[-1] // @0F44 memory[stack[-1]:stack[-1] + 0x20] // @0F45 stack[-2] // @0F46 memory[stack[-2]:stack[-2] + 0x20] // } 0F42 5B JUMPDEST 0F43 80 DUP1 0F44 51 MLOAD 0F45 82 DUP3 0F46 51 MLOAD 0F47 14 EQ 0F48 61 PUSH2 0x0f63 0F4B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f63, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_0F4C: // Incoming jump from 0x0F4B, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0F4E memory[0x40:0x60] } 0F4C 60 PUSH1 0x40 0F4E 51 MLOAD 0F4F 62 PUSH3 0x461bcd 0F53 60 PUSH1 0xe5 0F55 1B SHL 0F56 81 DUP2 0F57 52 MSTORE 0F58 60 PUSH1 0x04 0F5A 01 ADD 0F5B 61 PUSH2 0x03f8 0F5E 90 SWAP1 0F5F 61 PUSH2 0x23f8 0F62 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F5E stack[0] = 0x03f8 // @0F5E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23f8, returns to 0x03F8 label_0F63: // Incoming jump from 0x0F4B, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @0F67 memory[0x40:0x60] // @0F75 msg.sender // @0F78 stack[-2] // @0F79 memory[stack[-2]:stack[-2] + 0x20] // } 0F63 5B JUMPDEST 0F64 60 PUSH1 0x40 0F66 80 DUP1 0F67 51 MLOAD 0F68 60 PUSH1 0x20 0F6A 81 DUP2 0F6B 01 ADD 0F6C 90 SWAP1 0F6D 91 SWAP2 0F6E 52 MSTORE 0F6F 60 PUSH1 0x00 0F71 90 SWAP1 0F72 81 DUP2 0F73 90 SWAP1 0F74 52 MSTORE 0F75 33 CALLER 0F76 90 SWAP1 0F77 5B JUMPDEST 0F78 83 DUP4 0F79 51 MLOAD 0F7A 81 DUP2 0F7B 10 LT 0F7C 15 ISZERO 0F7D 61 PUSH2 0x1039 0F80 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0F6E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0F74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0F76 stack[0] = msg.sender // @0F76 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1039, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0F81: // Incoming jump from 0x0F80, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0F80, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0F83 stack[-4] // @0F84 stack[-1] // @0F86 memory[stack[-4]:stack[-4] + 0x20] // } 0F81 60 PUSH1 0x00 0F83 84 DUP5 0F84 82 DUP3 0F85 81 DUP2 0F86 51 MLOAD 0F87 81 DUP2 0F88 10 LT 0F89 61 PUSH2 0x0f94 0F8C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0F81 stack[0] = 0x00 // @0F83 stack[1] = stack[-4] // @0F84 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0f94, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_0F8D: // Incoming jump from 0x0F8C, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 0F8D 61 PUSH2 0x0f94 0F90 61 PUSH2 0x230e 0F93 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F8D stack[0] = 0x0f94 } // Block ends with unconditional jump to 0x230e label_0F94: // Incoming jump from 0x0F8C, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @0F97 stack[-1] // @0F9B stack[-2] // @0F9C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0F9D stack[-3] // @0FA1 stack[-6] // @0FA2 stack[-4] // @0FA4 memory[stack[-6]:stack[-6] + 0x20] // } 0F94 5B JUMPDEST 0F95 60 PUSH1 0x20 0F97 02 MUL 0F98 60 PUSH1 0x20 0F9A 01 ADD 0F9B 01 ADD 0F9C 51 MLOAD 0F9D 90 SWAP1 0F9E 50 POP 0F9F 60 PUSH1 0x00 0FA1 84 DUP5 0FA2 83 DUP4 0FA3 81 DUP2 0FA4 51 MLOAD 0FA5 81 DUP2 0FA6 10 LT 0FA7 61 PUSH2 0x0fb2 0FAA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0F9D stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0F9F stack[-2] = 0x00 // @0FA1 stack[-1] = stack[-6] // @0FA2 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0fb2, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] label_0FAB: // Incoming jump from 0x0FAA, if not stack[-4] < memory[stack[-6]:stack[-6] + 0x20] 0FAB 61 PUSH2 0x0fb2 0FAE 61 PUSH2 0x230e 0FB1 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FAB stack[0] = 0x0fb2 } // Block ends with unconditional jump to 0x230e label_0FB2: // Incoming jump from 0x0FAA, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[9] // { // @0FB5 stack[-1] // @0FB8 stack[-2] // @0FBE memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0FC1 stack[-4] // @0FCB memory[0x00:0x40] // @0FD4 stack[-9] // @0FDE memory[0x00:0x40] // @0FDF storage[keccak256(memory[0x00:0x40])] // @0FE1 stack[-3] // } 0FB2 5B JUMPDEST 0FB3 60 PUSH1 0x20 0FB5 90 SWAP1 0FB6 81 DUP2 0FB7 02 MUL 0FB8 91 SWAP2 0FB9 90 SWAP1 0FBA 91 SWAP2 0FBB 01 ADD 0FBC 81 DUP2 0FBD 01 ADD 0FBE 51 MLOAD 0FBF 60 PUSH1 0x00 0FC1 84 DUP5 0FC2 81 DUP2 0FC3 52 MSTORE 0FC4 80 DUP1 0FC5 83 DUP4 0FC6 52 MSTORE 0FC7 60 PUSH1 0x40 0FC9 80 DUP1 0FCA 82 DUP3 0FCB 20 SHA3 0FCC 60 PUSH1 0x01 0FCE 60 PUSH1 0x01 0FD0 60 PUSH1 0xa0 0FD2 1B SHL 0FD3 03 SUB 0FD4 8C DUP13 0FD5 16 AND 0FD6 83 DUP4 0FD7 52 MSTORE 0FD8 90 SWAP1 0FD9 93 SWAP4 0FDA 52 MSTORE 0FDB 91 SWAP2 0FDC 90 SWAP1 0FDD 91 SWAP2 0FDE 20 SHA3 0FDF 54 SLOAD 0FE0 90 SWAP1 0FE1 91 SWAP2 0FE2 50 POP 0FE3 81 DUP2 0FE4 81 DUP2 0FE5 10 LT 0FE6 15 ISZERO 0FE7 61 PUSH2 0x1002 0FEA 57 *JUMPI // Stack delta = -1 // Outputs[6] // { // @0FC3 memory[0x00:0x20] = stack[-4] // @0FC6 memory[0x20:0x40] = 0x00 // @0FD7 memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @0FDA memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0FE0 stack[-2] = storage[keccak256(memory[0x00:0x40])] // @0FE1 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1002, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) label_0FEB: // Incoming jump from 0x0FEA, if not !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[1] { @0FED memory[0x40:0x60] } 0FEB 60 PUSH1 0x40 0FED 51 MLOAD 0FEE 62 PUSH3 0x461bcd 0FF2 60 PUSH1 0xe5 0FF4 1B SHL 0FF5 81 DUP2 0FF6 52 MSTORE 0FF7 60 PUSH1 0x04 0FF9 01 ADD 0FFA 61 PUSH2 0x03f8 0FFD 90 SWAP1 0FFE 61 PUSH2 0x2658 1001 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FFD stack[0] = 0x03f8 // @0FFD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2658, returns to 0x03F8 label_1002: // Incoming jump from 0x0FEA, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[7] // { // @1005 stack[-3] // @1011 memory[0x00:0x40] // @101A stack[-8] // @1021 stack[-1] // @1023 memory[0x00:0x40] // @1025 stack[-2] // @1028 stack[-4] // } 1002 5B JUMPDEST 1003 60 PUSH1 0x00 1005 92 SWAP3 1006 83 DUP4 1007 52 MSTORE 1008 60 PUSH1 0x20 100A 83 DUP4 100B 81 DUP2 100C 52 MSTORE 100D 60 PUSH1 0x40 100F 80 DUP1 1010 85 DUP6 1011 20 SHA3 1012 60 PUSH1 0x01 1014 60 PUSH1 0x01 1016 60 PUSH1 0xa0 1018 1B SHL 1019 03 SUB 101A 8B DUP12 101B 16 AND 101C 86 DUP7 101D 52 MSTORE 101E 90 SWAP1 101F 91 SWAP2 1020 52 MSTORE 1021 90 SWAP1 1022 92 SWAP3 1023 20 SHA3 1024 91 SWAP2 1025 03 SUB 1026 90 SWAP1 1027 55 SSTORE 1028 80 DUP1 1029 61 PUSH2 0x1031 102C 81 DUP2 102D 61 PUSH2 0x233a 1030 56 *JUMP // Stack delta = +0 // Outputs[8] // { // @1007 memory[0x00:0x20] = stack[-3] // @100C memory[0x20:0x40] = 0x00 // @101D memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1020 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1027 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @1028 stack[-3] = stack[-4] // @1029 stack[-2] = 0x1031 // @102C stack[-1] = stack[-4] // } // Block ends with call to 0x233a, returns to 0x1031 label_1031: // Incoming return from call to 0x233A at 0x1030 // Inputs[2] // { // @1032 stack[-1] // @1032 stack[-3] // } 1031 5B JUMPDEST 1032 91 SWAP2 1033 50 POP 1034 50 POP 1035 61 PUSH2 0x0f77 1038 56 *JUMP // Stack delta = -2 // Outputs[1] { @1032 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0f77 label_1039: // Incoming jump from 0x0F80, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0F80, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @1046 stack[-5] // @1050 stack[-2] // @107B stack[-4] // @107C stack[-3] // @107F memory[0x40:0x60] // } 1039 5B JUMPDEST 103A 50 POP 103B 60 PUSH1 0x00 103D 60 PUSH1 0x01 103F 60 PUSH1 0x01 1041 60 PUSH1 0xa0 1043 1B SHL 1044 03 SUB 1045 16 AND 1046 84 DUP5 1047 60 PUSH1 0x01 1049 60 PUSH1 0x01 104B 60 PUSH1 0xa0 104D 1B SHL 104E 03 SUB 104F 16 AND 1050 82 DUP3 1051 60 PUSH1 0x01 1053 60 PUSH1 0x01 1055 60 PUSH1 0xa0 1057 1B SHL 1058 03 SUB 1059 16 AND 105A 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 107B 86 DUP7 107C 86 DUP7 107D 60 PUSH1 0x40 107F 51 MLOAD 1080 61 PUSH2 0x108a 1083 92 SWAP3 1084 91 SWAP2 1085 90 SWAP1 1086 61 PUSH2 0x2453 1089 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @1045 stack[-1] = (0x01 << 0xa0) - 0x01 & 0x00 // @104F stack[0] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1059 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] // @105A stack[2] = 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb // @1083 stack[3] = 0x108a // @1084 stack[4] = stack[-4] // @1085 stack[6] = memory[0x40:0x60] // @1085 stack[5] = stack[-3] // } // Block ends with call to 0x2453, returns to 0x108A label_108A: // Incoming return from call to 0x2453 at 0x1089 // Inputs[9] // { // @108D memory[0x40:0x60] // @108F stack[-1] // @1092 stack[-2] // @1092 stack[-3] // @1092 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1092 stack[-4] // @1092 stack[-5] // @1096 memory[0x40:0x60] // @10A6 stack[-10] // } 108A 5B JUMPDEST 108B 60 PUSH1 0x40 108D 51 MLOAD 108E 80 DUP1 108F 91 SWAP2 1090 03 SUB 1091 90 SWAP1 1092 A4 LOG4 1093 60 PUSH1 0x40 1095 80 DUP1 1096 51 MLOAD 1097 60 PUSH1 0x20 1099 81 DUP2 109A 01 ADD 109B 90 SWAP1 109C 91 SWAP2 109D 52 MSTORE 109E 60 PUSH1 0x00 10A0 90 SWAP1 10A1 52 MSTORE 10A2 50 POP 10A3 50 POP 10A4 50 POP 10A5 50 POP 10A6 56 *JUMP // Stack delta = -10 // Outputs[3] // { // @1092 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @109D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @10A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-10] label_10A7: // Incoming call from 0x0824, returns to 0x0825 // Incoming call from 0x0ACE, returns to 0x0ACF // Incoming call from 0x0810, returns to 0x0811 // Inputs[2] // { // @10AA storage[0x03] // @10B4 msg.sender // } 10A7 5B JUMPDEST 10A8 60 PUSH1 0x03 10AA 54 SLOAD 10AB 60 PUSH1 0x01 10AD 60 PUSH1 0x01 10AF 60 PUSH1 0xa0 10B1 1B SHL 10B2 03 SUB 10B3 16 AND 10B4 33 CALLER 10B5 14 EQ 10B6 61 PUSH2 0x081b 10B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x081b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_10BA: // Incoming jump from 0x10B9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @10BC memory[0x40:0x60] } 10BA 60 PUSH1 0x40 10BC 51 MLOAD 10BD 62 PUSH3 0x461bcd 10C1 60 PUSH1 0xe5 10C3 1B SHL 10C4 81 DUP2 10C5 52 MSTORE 10C6 60 PUSH1 0x20 10C8 60 PUSH1 0x04 10CA 82 DUP3 10CB 01 ADD 10CC 81 DUP2 10CD 90 SWAP1 10CE 52 MSTORE 10CF 60 PUSH1 0x24 10D1 82 DUP3 10D2 01 ADD 10D3 52 MSTORE 10D4 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 10F5 60 PUSH1 0x44 10F7 82 DUP3 10F8 01 ADD 10F9 52 MSTORE 10FA 60 PUSH1 0x64 10FC 01 ADD 10FD 61 PUSH2 0x03f8 1100 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10CE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10D3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @10F9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @10FC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_1101: // Incoming call from 0x0B3C, returns to 0x07BE // Incoming call from 0x081A, returns to 0x081B // Inputs[5] // { // @1105 storage[0x03] // @110E stack[-1] // @1123 memory[0x40:0x60] // @114F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1152 stack[-2] // } 1101 5B JUMPDEST 1102 60 PUSH1 0x03 1104 80 DUP1 1105 54 SLOAD 1106 60 PUSH1 0x01 1108 60 PUSH1 0x01 110A 60 PUSH1 0xa0 110C 1B SHL 110D 03 SUB 110E 83 DUP4 110F 81 DUP2 1110 16 AND 1111 60 PUSH1 0x01 1113 60 PUSH1 0x01 1115 60 PUSH1 0xa0 1117 1B SHL 1118 03 SUB 1119 19 NOT 111A 83 DUP4 111B 16 AND 111C 81 DUP2 111D 17 OR 111E 90 SWAP1 111F 93 SWAP4 1120 55 SSTORE 1121 60 PUSH1 0x40 1123 51 MLOAD 1124 91 SWAP2 1125 16 AND 1126 91 SWAP2 1127 90 SWAP1 1128 82 DUP3 1129 90 SWAP1 112A 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 114B 90 SWAP1 114C 60 PUSH1 0x00 114E 90 SWAP1 114F A3 LOG3 1150 50 POP 1151 50 POP 1152 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1120 storage[0x03] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x03] & ~((0x01 << 0xa0) - 0x01)) // @114F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1153 5B JUMPDEST 1154 60 PUSH1 0x00 1156 80 DUP1 1157 60 PUSH1 0x00 1159 61 PUSH2 0x1162 115C 85 DUP6 115D 85 DUP6 115E 61 PUSH2 0x1698 1161 56 *JUMP 1162 5B JUMPDEST 1163 91 SWAP2 1164 50 POP 1165 91 SWAP2 1166 50 POP 1167 61 PUSH2 0x07a5 116A 81 DUP2 116B 61 PUSH2 0x16dd 116E 56 *JUMP label_116F: // Incoming call from 0x0914, returns to 0x0915 // Inputs[2] // { // @1170 stack[-2] // @117A stack[-3] // } 116F 5B JUMPDEST 1170 81 DUP2 1171 60 PUSH1 0x01 1173 60 PUSH1 0x01 1175 60 PUSH1 0xa0 1177 1B SHL 1178 03 SUB 1179 16 AND 117A 83 DUP4 117B 60 PUSH1 0x01 117D 60 PUSH1 0x01 117F 60 PUSH1 0xa0 1181 1B SHL 1182 03 SUB 1183 16 AND 1184 03 SUB 1185 61 PUSH2 0x11e2 1188 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11e2, if ((0x01 << 0xa0) - 0x01 & stack[-3]) - ((0x01 << 0xa0) - 0x01 & stack[-2]) label_1189: // Incoming jump from 0x1188, if not ((0x01 << 0xa0) - 0x01 & stack[-3]) - ((0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[1] { @118B memory[0x40:0x60] } 1189 60 PUSH1 0x40 118B 51 MLOAD 118C 62 PUSH3 0x461bcd 1190 60 PUSH1 0xe5 1192 1B SHL 1193 81 DUP2 1194 52 MSTORE 1195 60 PUSH1 0x20 1197 60 PUSH1 0x04 1199 82 DUP3 119A 01 ADD 119B 52 MSTORE 119C 60 PUSH1 0x29 119E 60 PUSH1 0x24 11A0 82 DUP3 11A1 01 ADD 11A2 52 MSTORE 11A3 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 11C4 60 PUSH1 0x44 11C6 82 DUP3 11C7 01 ADD 11C8 52 MSTORE 11C9 68 PUSH9 0x103337b91039b2b633 11D3 60 PUSH1 0xb9 11D5 1B SHL 11D6 60 PUSH1 0x64 11D8 82 DUP3 11D9 01 ADD 11DA 52 MSTORE 11DB 60 PUSH1 0x84 11DD 01 ADD 11DE 61 PUSH2 0x03f8 11E1 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1194 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @119B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11A2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @11C8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @11DA memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103337b91039b2b633 << 0xb9 // @11DD stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_11E2: // Incoming jump from 0x1188, if ((0x01 << 0xa0) - 0x01 & stack[-3]) - ((0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[10] // { // @11EB stack[-3] // @11FE memory[0x00:0x40] // @1200 stack[-2] // @120B memory[0x00:0x40] // @120D storage[keccak256(memory[0x00:0x40])] // @1212 stack[-1] // @121C memory[0x40:0x60] // @1245 memory[0x40:0x60] // @124A memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]] // @124E stack[-4] // } 11E2 5B JUMPDEST 11E3 60 PUSH1 0x01 11E5 60 PUSH1 0x01 11E7 60 PUSH1 0xa0 11E9 1B SHL 11EA 03 SUB 11EB 83 DUP4 11EC 81 DUP2 11ED 16 AND 11EE 60 PUSH1 0x00 11F0 81 DUP2 11F1 81 DUP2 11F2 52 MSTORE 11F3 60 PUSH1 0x01 11F5 60 PUSH1 0x20 11F7 90 SWAP1 11F8 81 DUP2 11F9 52 MSTORE 11FA 60 PUSH1 0x40 11FC 80 DUP1 11FD 83 DUP4 11FE 20 SHA3 11FF 94 SWAP5 1200 87 DUP8 1201 16 AND 1202 80 DUP1 1203 84 DUP5 1204 52 MSTORE 1205 94 SWAP5 1206 82 DUP3 1207 52 MSTORE 1208 91 SWAP2 1209 82 DUP3 120A 90 SWAP1 120B 20 SHA3 120C 80 DUP1 120D 54 SLOAD 120E 60 PUSH1 0xff 1210 19 NOT 1211 16 AND 1212 86 DUP7 1213 15 ISZERO 1214 15 ISZERO 1215 90 SWAP1 1216 81 DUP2 1217 17 OR 1218 90 SWAP1 1219 91 SWAP2 121A 55 SSTORE 121B 91 SWAP2 121C 51 MLOAD 121D 91 SWAP2 121E 82 DUP3 121F 52 MSTORE 1220 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1241 91 SWAP2 1242 01 ADD 1243 60 PUSH1 0x40 1245 51 MLOAD 1246 80 DUP1 1247 91 SWAP2 1248 03 SUB 1249 90 SWAP1 124A A3 LOG3 124B 50 POP 124C 50 POP 124D 50 POP 124E 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @11F2 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @11F9 memory[0x20:0x40] = 0x01 // @1204 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1207 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @121A storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @121F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @124A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] 124F 5B JUMPDEST 1250 60 PUSH1 0x00 1252 80 DUP1 1253 60 PUSH1 0x01 1255 90 SWAP1 1256 50 POP 1257 60 PUSH1 0x00 1259 60 PUSH1 0x06 125B 85 DUP6 125C 60 PUSH1 0x40 125E 51 MLOAD 125F 61 PUSH2 0x1268 1262 91 SWAP2 1263 90 SWAP1 1264 61 PUSH2 0x23dc 1267 56 *JUMP 1268 5B JUMPDEST 1269 90 SWAP1 126A 81 DUP2 126B 52 MSTORE 126C 60 PUSH1 0x40 126E 51 MLOAD 126F 90 SWAP1 1270 81 DUP2 1271 90 SWAP1 1272 03 SUB 1273 60 PUSH1 0x20 1275 01 ADD 1276 90 SWAP1 1277 20 SHA3 1278 54 SLOAD 1279 11 GT 127A 15 ISZERO 127B 61 PUSH2 0x1303 127E 57 *JUMPI 127F 60 PUSH1 0x00 1281 5B JUMPDEST 1282 60 PUSH1 0x06 1284 85 DUP6 1285 60 PUSH1 0x40 1287 51 MLOAD 1288 61 PUSH2 0x1291 128B 91 SWAP2 128C 90 SWAP1 128D 61 PUSH2 0x23dc 1290 56 *JUMP 1291 5B JUMPDEST 1292 90 SWAP1 1293 81 DUP2 1294 52 MSTORE 1295 60 PUSH1 0x40 1297 51 MLOAD 1298 90 SWAP1 1299 81 DUP2 129A 90 SWAP1 129B 03 SUB 129C 60 PUSH1 0x20 129E 01 ADD 129F 90 SWAP1 12A0 20 SHA3 12A1 54 SLOAD 12A2 81 DUP2 12A3 10 LT 12A4 15 ISZERO 12A5 61 PUSH2 0x07a5 12A8 57 *JUMPI 12A9 83 DUP4 12AA 60 PUSH1 0x06 12AC 86 DUP7 12AD 60 PUSH1 0x40 12AF 51 MLOAD 12B0 61 PUSH2 0x12b9 12B3 91 SWAP2 12B4 90 SWAP1 12B5 61 PUSH2 0x23dc 12B8 56 *JUMP 12B9 5B JUMPDEST 12BA 90 SWAP1 12BB 81 DUP2 12BC 52 MSTORE 12BD 60 PUSH1 0x20 12BF 01 ADD 12C0 60 PUSH1 0x40 12C2 51 MLOAD 12C3 80 DUP1 12C4 91 SWAP2 12C5 03 SUB 12C6 90 SWAP1 12C7 20 SHA3 12C8 82 DUP3 12C9 81 DUP2 12CA 54 SLOAD 12CB 81 DUP2 12CC 10 LT 12CD 61 PUSH2 0x12d8 12D0 57 *JUMPI 12D1 61 PUSH2 0x12d8 12D4 61 PUSH2 0x230e 12D7 56 *JUMP 12D8 5B JUMPDEST 12D9 90 SWAP1 12DA 60 PUSH1 0x00 12DC 52 MSTORE 12DD 60 PUSH1 0x20 12DF 60 PUSH1 0x00 12E1 20 SHA3 12E2 01 ADD 12E3 54 SLOAD 12E4 03 SUB 12E5 61 PUSH2 0x12f1 12E8 57 *JUMPI 12E9 60 PUSH1 0x00 12EB 91 SWAP2 12EC 50 POP 12ED 61 PUSH2 0x07a5 12F0 56 *JUMP 12F1 5B JUMPDEST 12F2 80 DUP1 12F3 61 PUSH2 0x12fb 12F6 81 DUP2 12F7 61 PUSH2 0x233a 12FA 56 *JUMP 12FB 5B JUMPDEST 12FC 91 SWAP2 12FD 50 POP 12FE 50 POP 12FF 61 PUSH2 0x1281 1302 56 *JUMP label_1303: // Incoming return from call to 0x1A86 at 0x20A9 // Incoming return from call to 0x1ACC at 0x1AFE // Incoming return from call to 0x1D57 at 0x1D95 // Incoming return from call to 0x1D96 at 0x1E12 // Incoming return from call to 0x1ACC at 0x2716 // Incoming return from call to 0x1F86 at 0x1FD3 // Inputs[3] // { // @1304 stack[-5] // @1304 stack[-1] // @1305 stack[-4] // } 1303 5B JUMPDEST 1304 93 SWAP4 1305 92 SWAP3 1306 50 POP 1307 50 POP 1308 50 POP 1309 56 *JUMP // Stack delta = -4 // Outputs[1] { @1304 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 130A 5B JUMPDEST 130B 60 PUSH1 0x01 130D 60 PUSH1 0x01 130F 60 PUSH1 0xa0 1311 1B SHL 1312 03 SUB 1313 84 DUP5 1314 16 AND 1315 61 PUSH2 0x1330 1318 57 *JUMPI 1319 60 PUSH1 0x40 131B 51 MLOAD 131C 62 PUSH3 0x461bcd 1320 60 PUSH1 0xe5 1322 1B SHL 1323 81 DUP2 1324 52 MSTORE 1325 60 PUSH1 0x04 1327 01 ADD 1328 61 PUSH2 0x03f8 132B 90 SWAP1 132C 61 PUSH2 0x2481 132F 56 *JUMP 1330 5B JUMPDEST 1331 33 CALLER 1332 60 PUSH1 0x00 1334 61 PUSH2 0x133c 1337 85 DUP6 1338 61 PUSH2 0x1893 133B 56 *JUMP 133C 5B JUMPDEST 133D 90 SWAP1 133E 50 POP 133F 60 PUSH1 0x00 1341 61 PUSH2 0x1349 1344 85 DUP6 1345 61 PUSH2 0x1893 1348 56 *JUMP 1349 5B JUMPDEST 134A 90 SWAP1 134B 50 POP 134C 60 PUSH1 0x00 134E 86 DUP7 134F 81 DUP2 1350 52 MSTORE 1351 60 PUSH1 0x20 1353 81 DUP2 1354 81 DUP2 1355 52 MSTORE 1356 60 PUSH1 0x40 1358 80 DUP1 1359 83 DUP4 135A 20 SHA3 135B 60 PUSH1 0x01 135D 60 PUSH1 0x01 135F 60 PUSH1 0xa0 1361 1B SHL 1362 03 SUB 1363 8C DUP13 1364 16 AND 1365 84 DUP5 1366 52 MSTORE 1367 90 SWAP1 1368 91 SWAP2 1369 52 MSTORE 136A 90 SWAP1 136B 20 SHA3 136C 54 SLOAD 136D 85 DUP6 136E 81 DUP2 136F 10 LT 1370 15 ISZERO 1371 61 PUSH2 0x138c 1374 57 *JUMPI 1375 60 PUSH1 0x40 1377 51 MLOAD 1378 62 PUSH3 0x461bcd 137C 60 PUSH1 0xe5 137E 1B SHL 137F 81 DUP2 1380 52 MSTORE 1381 60 PUSH1 0x04 1383 01 ADD 1384 61 PUSH2 0x03f8 1387 90 SWAP1 1388 61 PUSH2 0x24c6 138B 56 *JUMP 138C 5B JUMPDEST 138D 60 PUSH1 0x00 138F 87 DUP8 1390 81 DUP2 1391 52 MSTORE 1392 60 PUSH1 0x20 1394 81 DUP2 1395 81 DUP2 1396 52 MSTORE 1397 60 PUSH1 0x40 1399 80 DUP1 139A 83 DUP4 139B 20 SHA3 139C 60 PUSH1 0x01 139E 60 PUSH1 0x01 13A0 60 PUSH1 0xa0 13A2 1B SHL 13A3 03 SUB 13A4 8D DUP14 13A5 81 DUP2 13A6 16 AND 13A7 85 DUP6 13A8 52 MSTORE 13A9 92 SWAP3 13AA 52 MSTORE 13AB 80 DUP1 13AC 83 DUP4 13AD 20 SHA3 13AE 89 DUP10 13AF 85 DUP6 13B0 03 SUB 13B1 90 SWAP1 13B2 55 SSTORE 13B3 90 SWAP1 13B4 8A DUP11 13B5 16 AND 13B6 82 DUP3 13B7 52 MSTORE 13B8 81 DUP2 13B9 20 SHA3 13BA 80 DUP1 13BB 54 SLOAD 13BC 88 DUP9 13BD 92 SWAP3 13BE 90 SWAP1 13BF 61 PUSH2 0x13c9 13C2 90 SWAP1 13C3 84 DUP5 13C4 90 SWAP1 13C5 61 PUSH2 0x2440 13C8 56 *JUMP 13C9 5B JUMPDEST 13CA 90 SWAP1 13CB 91 SWAP2 13CC 55 SSTORE 13CD 50 POP 13CE 50 POP 13CF 60 PUSH1 0x40 13D1 80 DUP1 13D2 51 MLOAD 13D3 88 DUP9 13D4 81 DUP2 13D5 52 MSTORE 13D6 60 PUSH1 0x20 13D8 81 DUP2 13D9 01 ADD 13DA 88 DUP9 13DB 90 SWAP1 13DC 52 MSTORE 13DD 60 PUSH1 0x01 13DF 60 PUSH1 0x01 13E1 60 PUSH1 0xa0 13E3 1B SHL 13E4 03 SUB 13E5 80 DUP1 13E6 8B DUP12 13E7 16 AND 13E8 92 SWAP3 13E9 8C DUP13 13EA 82 DUP3 13EB 16 AND 13EC 92 SWAP3 13ED 91 SWAP2 13EE 88 DUP9 13EF 16 AND 13F0 91 SWAP2 13F1 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1412 91 SWAP2 1413 01 ADD 1414 60 PUSH1 0x40 1416 51 MLOAD 1417 80 DUP1 1418 91 SWAP2 1419 03 SUB 141A 90 SWAP1 141B A4 LOG4 141C 61 PUSH2 0x1429 141F 84 DUP5 1420 8A DUP11 1421 8A DUP11 1422 8A DUP11 1423 8A DUP11 1424 8A DUP11 1425 61 PUSH2 0x18de 1428 56 *JUMP 1429 5B JUMPDEST 142A 50 POP 142B 50 POP 142C 50 POP 142D 50 POP 142E 50 POP 142F 50 POP 1430 50 POP 1431 50 POP 1432 50 POP 1433 56 *JUMP label_1434: // Incoming call from 0x0B7F, returns to 0x0804 // Inputs[1] { @143D stack[-3] } 1434 5B JUMPDEST 1435 60 PUSH1 0x01 1437 60 PUSH1 0x01 1439 60 PUSH1 0xa0 143B 1B SHL 143C 03 SUB 143D 83 DUP4 143E 16 AND 143F 61 PUSH2 0x145a 1442 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x145a, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1443: // Incoming jump from 0x1442, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1445 memory[0x40:0x60] } 1443 60 PUSH1 0x40 1445 51 MLOAD 1446 62 PUSH3 0x461bcd 144A 60 PUSH1 0xe5 144C 1B SHL 144D 81 DUP2 144E 52 MSTORE 144F 60 PUSH1 0x04 1451 01 ADD 1452 61 PUSH2 0x03f8 1455 90 SWAP1 1456 61 PUSH2 0x2615 1459 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @144E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1455 stack[0] = 0x03f8 // @1455 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2615, returns to 0x03F8 label_145A: // Incoming jump from 0x1442, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @145B msg.sender // @1461 stack[-2] // } 145A 5B JUMPDEST 145B 33 CALLER 145C 60 PUSH1 0x00 145E 61 PUSH2 0x1466 1461 84 DUP5 1462 61 PUSH2 0x1893 1465 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @145B stack[0] = msg.sender // @145C stack[1] = 0x00 // @145E stack[2] = 0x1466 // @1461 stack[3] = stack[-2] // } // Block ends with call to 0x1893, returns to 0x1466 label_1466: // Incoming return from call to 0x1893 at 0x1465 // Inputs[3] // { // @1467 stack[-2] // @1467 stack[-1] // @146E stack[-4] // } 1466 5B JUMPDEST 1467 90 SWAP1 1468 50 POP 1469 60 PUSH1 0x00 146B 61 PUSH2 0x1473 146E 84 DUP5 146F 61 PUSH2 0x1893 1472 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1467 stack[-2] = stack[-1] // @1469 stack[-1] = 0x00 // @146B stack[0] = 0x1473 // @146E stack[1] = stack[-4] // } // Block ends with call to 0x1893, returns to 0x1473 label_1473: // Incoming return from call to 0x1893 at 0x1472 // Inputs[9] // { // @1477 memory[0x40:0x60] // @1485 stack[-6] // @148D memory[0x00:0x40] // @1496 stack[-7] // @149C memory[0x00:0x40] // @149D storage[keccak256(memory[0x00:0x40])] // @149E stack[-1] // @149F stack[-2] // @14A1 stack[-5] // } 1473 5B JUMPDEST 1474 60 PUSH1 0x40 1476 80 DUP1 1477 51 MLOAD 1478 60 PUSH1 0x20 147A 80 DUP1 147B 82 DUP3 147C 01 ADD 147D 83 DUP4 147E 52 MSTORE 147F 60 PUSH1 0x00 1481 91 SWAP2 1482 82 DUP3 1483 90 SWAP1 1484 52 MSTORE 1485 88 DUP9 1486 82 DUP3 1487 52 MSTORE 1488 81 DUP2 1489 81 DUP2 148A 52 MSTORE 148B 82 DUP3 148C 82 DUP3 148D 20 SHA3 148E 60 PUSH1 0x01 1490 60 PUSH1 0x01 1492 60 PUSH1 0xa0 1494 1B SHL 1495 03 SUB 1496 8B DUP12 1497 16 AND 1498 83 DUP4 1499 52 MSTORE 149A 90 SWAP1 149B 52 MSTORE 149C 20 SHA3 149D 54 SLOAD 149E 90 SWAP1 149F 91 SWAP2 14A0 50 POP 14A1 84 DUP5 14A2 81 DUP2 14A3 10 LT 14A4 15 ISZERO 14A5 61 PUSH2 0x14c0 14A8 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @147E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1484 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1487 memory[0x00:0x20] = stack[-6] // @148A memory[0x20:0x40] = 0x00 // @1499 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @149B memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @149E stack[-1] = storage[keccak256(memory[0x00:0x40])] // @149F stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x14c0, if !(storage[keccak256(memory[0x00:0x40])] < stack[-5]) label_14A9: // Incoming jump from 0x14A8, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-5]) // Inputs[1] { @14AB memory[0x40:0x60] } 14A9 60 PUSH1 0x40 14AB 51 MLOAD 14AC 62 PUSH3 0x461bcd 14B0 60 PUSH1 0xe5 14B2 1B SHL 14B3 81 DUP2 14B4 52 MSTORE 14B5 60 PUSH1 0x04 14B7 01 ADD 14B8 61 PUSH2 0x03f8 14BB 90 SWAP1 14BC 61 PUSH2 0x2658 14BF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14BB stack[0] = 0x03f8 // @14BB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2658, returns to 0x03F8 label_14C0: // Incoming jump from 0x14A8, if !(storage[keccak256(memory[0x00:0x40])] < stack[-5]) // Inputs[12] // { // @14C3 stack[-6] // @14CF memory[0x00:0x40] // @14D8 stack[-7] // @14E3 memory[0x00:0x40] // @14E4 stack[-5] // @14E5 stack[-1] // @14EA memory[0x40:0x60] // @14F7 stack[-4] // @151F memory[0x40:0x60] // @1524 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x40) - memory[0x40:0x60]] // @1528 memory[0x40:0x60] // @153C stack[-8] // } 14C0 5B JUMPDEST 14C1 60 PUSH1 0x00 14C3 86 DUP7 14C4 81 DUP2 14C5 52 MSTORE 14C6 60 PUSH1 0x20 14C8 81 DUP2 14C9 81 DUP2 14CA 52 MSTORE 14CB 60 PUSH1 0x40 14CD 80 DUP1 14CE 83 DUP4 14CF 20 SHA3 14D0 60 PUSH1 0x01 14D2 60 PUSH1 0x01 14D4 60 PUSH1 0xa0 14D6 1B SHL 14D7 03 SUB 14D8 8B DUP12 14D9 81 DUP2 14DA 16 AND 14DB 80 DUP1 14DC 86 DUP7 14DD 52 MSTORE 14DE 91 SWAP2 14DF 84 DUP5 14E0 52 MSTORE 14E1 82 DUP3 14E2 85 DUP6 14E3 20 SHA3 14E4 8A DUP11 14E5 87 DUP8 14E6 03 SUB 14E7 90 SWAP1 14E8 55 SSTORE 14E9 82 DUP3 14EA 51 MLOAD 14EB 8B DUP12 14EC 81 DUP2 14ED 52 MSTORE 14EE 93 SWAP4 14EF 84 DUP5 14F0 01 ADD 14F1 8A DUP11 14F2 90 SWAP1 14F3 52 MSTORE 14F4 90 SWAP1 14F5 92 SWAP3 14F6 90 SWAP1 14F7 88 DUP9 14F8 16 AND 14F9 91 SWAP2 14FA 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 151B 91 SWAP2 151C 01 ADD 151D 60 PUSH1 0x40 151F 51 MLOAD 1520 80 DUP1 1521 91 SWAP2 1522 03 SUB 1523 90 SWAP1 1524 A4 LOG4 1525 60 PUSH1 0x40 1527 80 DUP1 1528 51 MLOAD 1529 60 PUSH1 0x20 152B 81 DUP2 152C 01 ADD 152D 90 SWAP1 152E 91 SWAP2 152F 52 MSTORE 1530 60 PUSH1 0x00 1532 90 SWAP1 1533 52 MSTORE 1534 5B JUMPDEST 1535 50 POP 1536 50 POP 1537 50 POP 1538 50 POP 1539 50 POP 153A 50 POP 153B 50 POP 153C 56 *JUMP // Stack delta = -8 // Outputs[10] // { // @14C5 memory[0x00:0x20] = stack[-6] // @14CA memory[0x20:0x40] = 0x00 // @14DD memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @14E0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @14E8 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-5] // @14ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-6] // @14F3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-5] // @1524 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x40) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, 0x00]); // @152F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1533 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-8] label_153D: // Incoming call from 0x0D73, returns to 0x0512 // Inputs[2] // { // @1546 stack[-4] // @1548 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 153D 5B JUMPDEST 153E 60 PUSH1 0x01 1540 60 PUSH1 0x01 1542 60 PUSH1 0xa0 1544 1B SHL 1545 03 SUB 1546 84 DUP5 1547 16 AND 1548 3B EXTCODESIZE 1549 15 ISZERO 154A 61 PUSH2 0x0f08 154D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f08, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_154E: // Incoming jump from 0x154D, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @1550 memory[0x40:0x60] // @1563 stack[-4] // @1570 stack[-6] // @1572 stack[-5] // @1574 stack[-3] // @1576 stack[-2] // @1578 stack[-1] // } 154E 60 PUSH1 0x40 1550 51 MLOAD 1551 63 PUSH4 0xbc197c81 1556 60 PUSH1 0xe0 1558 1B SHL 1559 81 DUP2 155A 52 MSTORE 155B 60 PUSH1 0x01 155D 60 PUSH1 0x01 155F 60 PUSH1 0xa0 1561 1B SHL 1562 03 SUB 1563 85 DUP6 1564 16 AND 1565 90 SWAP1 1566 63 PUSH4 0xbc197c81 156B 90 SWAP1 156C 61 PUSH2 0x1581 156F 90 SWAP1 1570 89 DUP10 1571 90 SWAP1 1572 89 DUP10 1573 90 SWAP1 1574 88 DUP9 1575 90 SWAP1 1576 88 DUP9 1577 90 SWAP1 1578 88 DUP9 1579 90 SWAP1 157A 60 PUSH1 0x04 157C 01 ADD 157D 61 PUSH2 0x269c 1580 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @155A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbc197c81 << 0xe0 // @1565 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @156B stack[1] = 0xbc197c81 // @156F stack[2] = 0x1581 // @1571 stack[3] = stack[-6] // @1573 stack[4] = stack[-5] // @1575 stack[5] = stack[-3] // @1577 stack[6] = stack[-2] // @1579 stack[7] = stack[-1] // @157C stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x269c, returns to 0x1581 label_1581: // Incoming return from call to 0x269C at 0x1580 // Inputs[6] // { // @1586 memory[0x40:0x60] // @1588 stack[-1] // @158D stack[-3] // @158E msg.gas // @158F address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @158F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1581 5B JUMPDEST 1582 60 PUSH1 0x20 1584 60 PUSH1 0x40 1586 51 MLOAD 1587 80 DUP1 1588 83 DUP4 1589 03 SUB 158A 81 DUP2 158B 60 PUSH1 0x00 158D 87 DUP8 158E 5A GAS 158F F1 CALL 1590 92 SWAP3 1591 50 POP 1592 50 POP 1593 50 POP 1594 80 DUP1 1595 15 ISZERO 1596 61 PUSH2 0x15bc 1599 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @158F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1590 stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x15bc, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_159A: // Incoming jump from 0x1599, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @159E memory[0x40:0x60] // @15A1 returndata.length // } 159A 50 POP 159B 60 PUSH1 0x40 159D 80 DUP1 159E 51 MLOAD 159F 60 PUSH1 0x1f 15A1 3D RETURNDATASIZE 15A2 90 SWAP1 15A3 81 DUP2 15A4 01 ADD 15A5 60 PUSH1 0x1f 15A7 19 NOT 15A8 16 AND 15A9 82 DUP3 15AA 01 ADD 15AB 90 SWAP1 15AC 92 SWAP3 15AD 52 MSTORE 15AE 61 PUSH2 0x15b9 15B1 91 SWAP2 15B2 81 DUP2 15B3 01 ADD 15B4 90 SWAP1 15B5 61 PUSH2 0x26fa 15B8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @15AD memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @15B1 stack[-1] = 0x15b9 // @15B4 stack[1] = memory[0x40:0x60] // @15B4 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x26fa 15B9 5B JUMPDEST 15BA 60 PUSH1 0x01 label_15BC: // Incoming jump from 0x1599, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @15C0 stack[-1] } 15BC 5B JUMPDEST 15BD 61 PUSH2 0x1668 15C0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1668, if stack[-1] label_15C1: // Incoming jump from 0x15C0, if not stack[-1] 15C1 61 PUSH2 0x15c8 15C4 61 PUSH2 0x2717 15C7 56 *JUMP // Stack delta = +1 // Outputs[1] { @15C1 stack[0] = 0x15c8 } // Block ends with call to 0x2717, returns to 0x15C8 label_15C8: // Incoming return from call to 0x2717 at 0x15C7 // Inputs[1] { @15C9 stack[-1] } 15C8 5B JUMPDEST 15C9 80 DUP1 15CA 63 PUSH4 0x08c379a0 15CF 03 SUB 15D0 61 PUSH2 0x1601 15D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1601, if 0x08c379a0 - stack[-1] label_15D4: // Incoming jump from 0x15D3, if not 0x08c379a0 - stack[-1] 15D4 50 POP 15D5 61 PUSH2 0x15dc 15D8 61 PUSH2 0x2733 15DB 56 *JUMP // Stack delta = +0 // Outputs[1] { @15D5 stack[-1] = 0x15dc } // Block ends with call to 0x2733, returns to 0x15DC label_15DC: // Incoming return from call to 0x2733 at 0x15DB // Incoming return from call to 0x2733 at 0x15DB // Inputs[1] { @15DD stack[-1] } 15DC 5B JUMPDEST 15DD 80 DUP1 15DE 61 PUSH2 0x15e7 15E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15e7, if stack[-1] label_15E2: // Incoming jump from 0x15E1, if not stack[-1] 15E2 50 POP 15E3 61 PUSH2 0x1603 15E6 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1603 label_15E7: // Incoming jump from 0x15E1, if stack[-1] // Inputs[2] // { // @15E8 stack[-1] // @15EB memory[0x40:0x60] // } 15E7 5B JUMPDEST 15E8 80 DUP1 15E9 60 PUSH1 0x40 15EB 51 MLOAD 15EC 62 PUSH3 0x461bcd 15F0 60 PUSH1 0xe5 15F2 1B SHL 15F3 81 DUP2 15F4 52 MSTORE 15F5 60 PUSH1 0x04 15F7 01 ADD 15F8 61 PUSH2 0x03f8 15FB 91 SWAP2 15FC 90 SWAP1 15FD 61 PUSH2 0x1d83 1600 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @15F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15FB stack[0] = 0x03f8 // @15FC stack[1] = stack[-1] // @15FC stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1d83 label_1601: // Incoming jump from 0x15D3, if 0x08c379a0 - stack[-1] // Inputs[1] { @1606 memory[0x40:0x60] } 1601 5B JUMPDEST 1602 50 POP 1603 5B JUMPDEST 1604 60 PUSH1 0x40 1606 51 MLOAD 1607 62 PUSH3 0x461bcd 160B 60 PUSH1 0xe5 160D 1B SHL 160E 81 DUP2 160F 52 MSTORE 1610 60 PUSH1 0x20 1612 60 PUSH1 0x04 1614 82 DUP3 1615 01 ADD 1616 52 MSTORE 1617 60 PUSH1 0x34 1619 60 PUSH1 0x24 161B 82 DUP3 161C 01 ADD 161D 52 MSTORE 161E 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 163F 60 PUSH1 0x44 1641 82 DUP3 1642 01 ADD 1643 52 MSTORE 1644 73 PUSH20 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 1659 60 PUSH1 0x61 165B 1B SHL 165C 60 PUSH1 0x64 165E 82 DUP3 165F 01 ADD 1660 52 MSTORE 1661 60 PUSH1 0x84 1663 01 ADD 1664 61 PUSH2 0x03f8 1667 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @160F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1616 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @161D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @1643 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @1660 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x61 // @1663 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f8 label_1668: // Incoming jump from 0x15C0, if stack[-1] // Inputs[1] { @1672 stack[-1] } 1668 5B JUMPDEST 1669 60 PUSH1 0x01 166B 60 PUSH1 0x01 166D 60 PUSH1 0xe0 166F 1B SHL 1670 03 SUB 1671 19 NOT 1672 81 DUP2 1673 16 AND 1674 63 PUSH4 0xbc197c81 1679 60 PUSH1 0xe0 167B 1B SHL 167C 14 EQ 167D 61 PUSH2 0x1534 1680 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1534, if 0xbc197c81 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1681: // Incoming jump from 0x1680, if not 0xbc197c81 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1683 memory[0x40:0x60] } 1681 60 PUSH1 0x40 1683 51 MLOAD 1684 62 PUSH3 0x461bcd 1688 60 PUSH1 0xe5 168A 1B SHL 168B 81 DUP2 168C 52 MSTORE 168D 60 PUSH1 0x04 168F 01 ADD 1690 61 PUSH2 0x03f8 1693 90 SWAP1 1694 61 PUSH2 0x27bc 1697 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @168C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1693 stack[0] = 0x03f8 // @1693 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x27bc, returns to 0x03F8 1698 5B JUMPDEST 1699 60 PUSH1 0x00 169B 80 DUP1 169C 82 DUP3 169D 51 MLOAD 169E 60 PUSH1 0x41 16A0 03 SUB 16A1 61 PUSH2 0x16ce 16A4 57 *JUMPI 16A5 60 PUSH1 0x20 16A7 83 DUP4 16A8 01 ADD 16A9 51 MLOAD 16AA 60 PUSH1 0x40 16AC 84 DUP5 16AD 01 ADD 16AE 51 MLOAD 16AF 60 PUSH1 0x60 16B1 85 DUP6 16B2 01 ADD 16B3 51 MLOAD 16B4 60 PUSH1 0x00 16B6 1A BYTE 16B7 61 PUSH2 0x16c2 16BA 87 DUP8 16BB 82 DUP3 16BC 85 DUP6 16BD 85 DUP6 16BE 61 PUSH2 0x1999 16C1 56 *JUMP 16C2 5B JUMPDEST 16C3 94 SWAP5 16C4 50 POP 16C5 94 SWAP5 16C6 50 POP 16C7 50 POP 16C8 50 POP 16C9 50 POP 16CA 61 PUSH2 0x16d6 16CD 56 *JUMP 16CE 5B JUMPDEST 16CF 50 POP 16D0 60 PUSH1 0x00 16D2 90 SWAP1 16D3 50 POP 16D4 60 PUSH1 0x02 16D6 5B JUMPDEST 16D7 92 SWAP3 16D8 50 POP 16D9 92 SWAP3 16DA 90 SWAP1 16DB 50 POP 16DC 56 *JUMP 16DD 5B JUMPDEST 16DE 60 PUSH1 0x00 16E0 81 DUP2 16E1 60 PUSH1 0x04 16E3 81 DUP2 16E4 11 GT 16E5 15 ISZERO 16E6 61 PUSH2 0x16f1 16E9 57 *JUMPI 16EA 61 PUSH2 0x16f1 16ED 61 PUSH2 0x2804 16F0 56 *JUMP 16F1 5B JUMPDEST 16F2 03 SUB 16F3 61 PUSH2 0x16f9 16F6 57 *JUMPI 16F7 50 POP 16F8 56 *JUMP 16F9 5B JUMPDEST 16FA 60 PUSH1 0x01 16FC 81 DUP2 16FD 60 PUSH1 0x04 16FF 81 DUP2 1700 11 GT 1701 15 ISZERO 1702 61 PUSH2 0x170d 1705 57 *JUMPI 1706 61 PUSH2 0x170d 1709 61 PUSH2 0x2804 170C 56 *JUMP 170D 5B JUMPDEST 170E 03 SUB 170F 61 PUSH2 0x175a 1712 57 *JUMPI 1713 60 PUSH1 0x40 1715 51 MLOAD 1716 62 PUSH3 0x461bcd 171A 60 PUSH1 0xe5 171C 1B SHL 171D 81 DUP2 171E 52 MSTORE 171F 60 PUSH1 0x20 1721 60 PUSH1 0x04 1723 82 DUP3 1724 01 ADD 1725 52 MSTORE 1726 60 PUSH1 0x18 1728 60 PUSH1 0x24 172A 82 DUP3 172B 01 ADD 172C 52 MSTORE 172D 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 174E 60 PUSH1 0x44 1750 82 DUP3 1751 01 ADD 1752 52 MSTORE 1753 60 PUSH1 0x64 1755 01 ADD 1756 61 PUSH2 0x03f8 1759 56 *JUMP 175A 5B JUMPDEST 175B 60 PUSH1 0x02 175D 81 DUP2 175E 60 PUSH1 0x04 1760 81 DUP2 1761 11 GT 1762 15 ISZERO 1763 61 PUSH2 0x176e 1766 57 *JUMPI 1767 61 PUSH2 0x176e 176A 61 PUSH2 0x2804 176D 56 *JUMP 176E 5B JUMPDEST 176F 03 SUB 1770 61 PUSH2 0x17bb 1773 57 *JUMPI 1774 60 PUSH1 0x40 1776 51 MLOAD 1777 62 PUSH3 0x461bcd 177B 60 PUSH1 0xe5 177D 1B SHL 177E 81 DUP2 177F 52 MSTORE 1780 60 PUSH1 0x20 1782 60 PUSH1 0x04 1784 82 DUP3 1785 01 ADD 1786 52 MSTORE 1787 60 PUSH1 0x1f 1789 60 PUSH1 0x24 178B 82 DUP3 178C 01 ADD 178D 52 MSTORE 178E 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 17AF 60 PUSH1 0x44 17B1 82 DUP3 17B2 01 ADD 17B3 52 MSTORE 17B4 60 PUSH1 0x64 17B6 01 ADD 17B7 61 PUSH2 0x03f8 17BA 56 *JUMP 17BB 5B JUMPDEST 17BC 60 PUSH1 0x03 17BE 81 DUP2 17BF 60 PUSH1 0x04 17C1 81 DUP2 17C2 11 GT 17C3 15 ISZERO 17C4 61 PUSH2 0x17cf 17C7 57 *JUMPI 17C8 61 PUSH2 0x17cf 17CB 61 PUSH2 0x2804 17CE 56 *JUMP 17CF 5B JUMPDEST 17D0 03 SUB 17D1 61 PUSH2 0x1827 17D4 57 *JUMPI 17D5 60 PUSH1 0x40 17D7 51 MLOAD 17D8 62 PUSH3 0x461bcd 17DC 60 PUSH1 0xe5 17DE 1B SHL 17DF 81 DUP2 17E0 52 MSTORE 17E1 60 PUSH1 0x20 17E3 60 PUSH1 0x04 17E5 82 DUP3 17E6 01 ADD 17E7 52 MSTORE 17E8 60 PUSH1 0x22 17EA 60 PUSH1 0x24 17EC 82 DUP3 17ED 01 ADD 17EE 52 MSTORE 17EF 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 1810 60 PUSH1 0x44 1812 82 DUP3 1813 01 ADD 1814 52 MSTORE 1815 61 PUSH2 0x7565 1818 60 PUSH1 0xf0 181A 1B SHL 181B 60 PUSH1 0x64 181D 82 DUP3 181E 01 ADD 181F 52 MSTORE 1820 60 PUSH1 0x84 1822 01 ADD 1823 61 PUSH2 0x03f8 1826 56 *JUMP 1827 5B JUMPDEST 1828 60 PUSH1 0x04 182A 81 DUP2 182B 60 PUSH1 0x04 182D 81 DUP2 182E 11 GT 182F 15 ISZERO 1830 61 PUSH2 0x183b 1833 57 *JUMPI 1834 61 PUSH2 0x183b 1837 61 PUSH2 0x2804 183A 56 *JUMP 183B 5B JUMPDEST 183C 03 SUB 183D 61 PUSH2 0x07be 1840 57 *JUMPI 1841 60 PUSH1 0x40 1843 51 MLOAD 1844 62 PUSH3 0x461bcd 1848 60 PUSH1 0xe5 184A 1B SHL 184B 81 DUP2 184C 52 MSTORE 184D 60 PUSH1 0x20 184F 60 PUSH1 0x04 1851 82 DUP3 1852 01 ADD 1853 52 MSTORE 1854 60 PUSH1 0x22 1856 60 PUSH1 0x24 1858 82 DUP3 1859 01 ADD 185A 52 MSTORE 185B 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 187C 60 PUSH1 0x44 187E 82 DUP3 187F 01 ADD 1880 52 MSTORE 1881 61 PUSH2 0x7565 1884 60 PUSH1 0xf0 1886 1B SHL 1887 60 PUSH1 0x64 1889 82 DUP3 188A 01 ADD 188B 52 MSTORE 188C 60 PUSH1 0x84 188E 01 ADD 188F 61 PUSH2 0x03f8 1892 56 *JUMP label_1893: // Incoming call from 0x1472, returns to 0x1473 // Incoming call from 0x1465, returns to 0x1466 // Inputs[5] // { // @1897 memory[0x40:0x60] // @18B1 msg.data.length // @18B3 msg.data[msg.data.length:msg.data.length + 0x20] // @18BA stack[-1] // @18BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1893 5B JUMPDEST 1894 60 PUSH1 0x40 1896 80 DUP1 1897 51 MLOAD 1898 60 PUSH1 0x01 189A 80 DUP1 189B 82 DUP3 189C 52 MSTORE 189D 81 DUP2 189E 83 DUP4 189F 01 ADD 18A0 90 SWAP1 18A1 92 SWAP3 18A2 52 MSTORE 18A3 60 PUSH1 0x60 18A5 91 SWAP2 18A6 60 PUSH1 0x00 18A8 91 SWAP2 18A9 90 SWAP1 18AA 60 PUSH1 0x20 18AC 80 DUP1 18AD 83 DUP4 18AE 01 ADD 18AF 90 SWAP1 18B0 80 DUP1 18B1 36 CALLDATASIZE 18B2 83 DUP4 18B3 37 CALLDATACOPY 18B4 01 ADD 18B5 90 SWAP1 18B6 50 POP 18B7 50 POP 18B8 90 SWAP1 18B9 50 POP 18BA 82 DUP3 18BB 81 DUP2 18BC 60 PUSH1 0x00 18BE 81 DUP2 18BF 51 MLOAD 18C0 81 DUP2 18C1 10 LT 18C2 61 PUSH2 0x18cd 18C5 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @189C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @18A2 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @18A5 stack[0] = 0x60 // @18B3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @18B8 stack[1] = memory[0x40:0x60] // @18BA stack[2] = stack[-1] // @18BB stack[3] = memory[0x40:0x60] // @18BC stack[4] = 0x00 // } // Block ends with conditional jump to 0x18cd, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_18C6: // Incoming jump from 0x18C5, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 18C6 61 PUSH2 0x18cd 18C9 61 PUSH2 0x230e 18CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @18C6 stack[0] = 0x18cd } // Block ends with unconditional jump to 0x230e label_18CD: // Incoming jump from 0x18C5, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @18D0 stack[-1] // @18D3 stack[-2] // @18D8 stack[-3] // @18D9 stack[-7] // @18D9 stack[-4] // @18DA stack[-6] // } 18CD 5B JUMPDEST 18CE 60 PUSH1 0x20 18D0 90 SWAP1 18D1 81 DUP2 18D2 02 MUL 18D3 91 SWAP2 18D4 90 SWAP1 18D5 91 SWAP2 18D6 01 ADD 18D7 01 ADD 18D8 52 MSTORE 18D9 92 SWAP3 18DA 91 SWAP2 18DB 50 POP 18DC 50 POP 18DD 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @18D8 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @18D9 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] 18DE 5B JUMPDEST 18DF 60 PUSH1 0x01 18E1 60 PUSH1 0x01 18E3 60 PUSH1 0xa0 18E5 1B SHL 18E6 03 SUB 18E7 84 DUP5 18E8 16 AND 18E9 3B EXTCODESIZE 18EA 15 ISZERO 18EB 61 PUSH2 0x0f08 18EE 57 *JUMPI 18EF 60 PUSH1 0x40 18F1 51 MLOAD 18F2 63 PUSH4 0xf23a6e61 18F7 60 PUSH1 0xe0 18F9 1B SHL 18FA 81 DUP2 18FB 52 MSTORE 18FC 60 PUSH1 0x01 18FE 60 PUSH1 0x01 1900 60 PUSH1 0xa0 1902 1B SHL 1903 03 SUB 1904 85 DUP6 1905 16 AND 1906 90 SWAP1 1907 63 PUSH4 0xf23a6e61 190C 90 SWAP1 190D 61 PUSH2 0x1922 1910 90 SWAP1 1911 89 DUP10 1912 90 SWAP1 1913 89 DUP10 1914 90 SWAP1 1915 88 DUP9 1916 90 SWAP1 1917 88 DUP9 1918 90 SWAP1 1919 88 DUP9 191A 90 SWAP1 191B 60 PUSH1 0x04 191D 01 ADD 191E 61 PUSH2 0x281a 1921 56 *JUMP 1922 5B JUMPDEST 1923 60 PUSH1 0x20 1925 60 PUSH1 0x40 1927 51 MLOAD 1928 80 DUP1 1929 83 DUP4 192A 03 SUB 192B 81 DUP2 192C 60 PUSH1 0x00 192E 87 DUP8 192F 5A GAS 1930 F1 CALL 1931 92 SWAP3 1932 50 POP 1933 50 POP 1934 50 POP 1935 80 DUP1 1936 15 ISZERO 1937 61 PUSH2 0x195d 193A 57 *JUMPI 193B 50 POP 193C 60 PUSH1 0x40 193E 80 DUP1 193F 51 MLOAD 1940 60 PUSH1 0x1f 1942 3D RETURNDATASIZE 1943 90 SWAP1 1944 81 DUP2 1945 01 ADD 1946 60 PUSH1 0x1f 1948 19 NOT 1949 16 AND 194A 82 DUP3 194B 01 ADD 194C 90 SWAP1 194D 92 SWAP3 194E 52 MSTORE 194F 61 PUSH2 0x195a 1952 91 SWAP2 1953 81 DUP2 1954 01 ADD 1955 90 SWAP1 1956 61 PUSH2 0x26fa 1959 56 *JUMP 195A 5B JUMPDEST 195B 60 PUSH1 0x01 195D 5B JUMPDEST 195E 61 PUSH2 0x1969 1961 57 *JUMPI 1962 61 PUSH2 0x15c8 1965 61 PUSH2 0x2717 1968 56 *JUMP 1969 5B JUMPDEST 196A 60 PUSH1 0x01 196C 60 PUSH1 0x01 196E 60 PUSH1 0xe0 1970 1B SHL 1971 03 SUB 1972 19 NOT 1973 81 DUP2 1974 16 AND 1975 63 PUSH4 0xf23a6e61 197A 60 PUSH1 0xe0 197C 1B SHL 197D 14 EQ 197E 61 PUSH2 0x1534 1981 57 *JUMPI 1982 60 PUSH1 0x40 1984 51 MLOAD 1985 62 PUSH3 0x461bcd 1989 60 PUSH1 0xe5 198B 1B SHL 198C 81 DUP2 198D 52 MSTORE 198E 60 PUSH1 0x04 1990 01 ADD 1991 61 PUSH2 0x03f8 1994 90 SWAP1 1995 61 PUSH2 0x27bc 1998 56 *JUMP 1999 5B JUMPDEST 199A 60 PUSH1 0x00 199C 80 DUP1 199D 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 19BE 83 DUP4 19BF 11 GT 19C0 15 ISZERO 19C1 61 PUSH2 0x19d0 19C4 57 *JUMPI 19C5 50 POP 19C6 60 PUSH1 0x00 19C8 90 SWAP1 19C9 50 POP 19CA 60 PUSH1 0x03 19CC 61 PUSH2 0x1a7d 19CF 56 *JUMP 19D0 5B JUMPDEST 19D1 84 DUP5 19D2 60 PUSH1 0xff 19D4 16 AND 19D5 60 PUSH1 0x1b 19D7 14 EQ 19D8 15 ISZERO 19D9 80 DUP1 19DA 15 ISZERO 19DB 61 PUSH2 0x19e8 19DE 57 *JUMPI 19DF 50 POP 19E0 84 DUP5 19E1 60 PUSH1 0xff 19E3 16 AND 19E4 60 PUSH1 0x1c 19E6 14 EQ 19E7 15 ISZERO 19E8 5B JUMPDEST 19E9 15 ISZERO 19EA 61 PUSH2 0x19f9 19ED 57 *JUMPI 19EE 50 POP 19EF 60 PUSH1 0x00 19F1 90 SWAP1 19F2 50 POP 19F3 60 PUSH1 0x04 19F5 61 PUSH2 0x1a7d 19F8 56 *JUMP 19F9 5B JUMPDEST 19FA 60 PUSH1 0x40 19FC 80 DUP1 19FD 51 MLOAD 19FE 60 PUSH1 0x00 1A00 80 DUP1 1A01 82 DUP3 1A02 52 MSTORE 1A03 60 PUSH1 0x20 1A05 82 DUP3 1A06 01 ADD 1A07 80 DUP1 1A08 84 DUP5 1A09 52 MSTORE 1A0A 89 DUP10 1A0B 90 SWAP1 1A0C 52 MSTORE 1A0D 60 PUSH1 0xff 1A0F 88 DUP9 1A10 16 AND 1A11 92 SWAP3 1A12 82 DUP3 1A13 01 ADD 1A14 92 SWAP3 1A15 90 SWAP1 1A16 92 SWAP3 1A17 52 MSTORE 1A18 60 PUSH1 0x60 1A1A 81 DUP2 1A1B 01 ADD 1A1C 86 DUP7 1A1D 90 SWAP1 1A1E 52 MSTORE 1A1F 60 PUSH1 0x80 1A21 81 DUP2 1A22 01 ADD 1A23 85 DUP6 1A24 90 SWAP1 1A25 52 MSTORE 1A26 60 PUSH1 0x01 1A28 90 SWAP1 1A29 60 PUSH1 0xa0 1A2B 01 ADD 1A2C 60 PUSH1 0x20 1A2E 60 PUSH1 0x40 1A30 51 MLOAD 1A31 60 PUSH1 0x20 1A33 81 DUP2 1A34 03 SUB 1A35 90 SWAP1 1A36 80 DUP1 1A37 84 DUP5 1A38 03 SUB 1A39 90 SWAP1 1A3A 85 DUP6 1A3B 5A GAS 1A3C FA STATICCALL 1A3D 15 ISZERO 1A3E 80 DUP1 1A3F 15 ISZERO 1A40 61 PUSH2 0x1a4d 1A43 57 *JUMPI 1A44 3D RETURNDATASIZE 1A45 60 PUSH1 0x00 1A47 80 DUP1 1A48 3E RETURNDATACOPY 1A49 3D RETURNDATASIZE 1A4A 60 PUSH1 0x00 1A4C FD *REVERT 1A4D 5B JUMPDEST 1A4E 50 POP 1A4F 50 POP 1A50 60 PUSH1 0x40 1A52 51 MLOAD 1A53 60 PUSH1 0x1f 1A55 19 NOT 1A56 01 ADD 1A57 51 MLOAD 1A58 91 SWAP2 1A59 50 POP 1A5A 50 POP 1A5B 60 PUSH1 0x01 1A5D 60 PUSH1 0x01 1A5F 60 PUSH1 0xa0 1A61 1B SHL 1A62 03 SUB 1A63 81 DUP2 1A64 16 AND 1A65 61 PUSH2 0x1a76 1A68 57 *JUMPI 1A69 60 PUSH1 0x00 1A6B 60 PUSH1 0x01 1A6D 92 SWAP3 1A6E 50 POP 1A6F 92 SWAP3 1A70 50 POP 1A71 50 POP 1A72 61 PUSH2 0x1a7d 1A75 56 *JUMP 1A76 5B JUMPDEST 1A77 91 SWAP2 1A78 50 POP 1A79 60 PUSH1 0x00 1A7B 90 SWAP1 1A7C 50 POP 1A7D 5B JUMPDEST 1A7E 94 SWAP5 1A7F 50 POP 1A80 94 SWAP5 1A81 92 SWAP3 1A82 50 POP 1A83 50 POP 1A84 50 POP 1A85 56 *JUMP label_1A86: // Incoming call from 0x225F, returns to 0x2260 // Incoming call from 0x2145, returns to 0x2146 // Incoming call from 0x22F8, returns to 0x22F9 // Incoming call from 0x1F49, returns to 0x1F4A // Incoming call from 0x1E41, returns to 0x1E42 // Incoming call from 0x20A9, returns to 0x1303 // Incoming call from 0x2039, returns to 0x203A // Incoming call from 0x2297, returns to 0x2298 // Incoming call from 0x1ABD, returns to 0x1ABE // Incoming call from 0x22A5, returns to 0x22A6 // Incoming call from 0x226D, returns to 0x226E // Incoming call from 0x1E33, returns to 0x1E34 // Incoming call from 0x21BB, returns to 0x21BC // Inputs[2] // { // @1A87 stack[-1] // @1A88 msg.data[stack[-1]:stack[-1] + 0x20] // } 1A86 5B JUMPDEST 1A87 80 DUP1 1A88 35 CALLDATALOAD 1A89 60 PUSH1 0x01 1A8B 60 PUSH1 0x01 1A8D 60 PUSH1 0xa0 1A8F 1B SHL 1A90 03 SUB 1A91 81 DUP2 1A92 16 AND 1A93 81 DUP2 1A94 14 EQ 1A95 61 PUSH2 0x1a9d 1A98 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A88 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1a9d, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1A99: // Incoming jump from 0x1A98, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A9C memory[0x00:0x00] } 1A99 60 PUSH1 0x00 1A9B 80 DUP1 1A9C FD *REVERT // Stack delta = +0 // Outputs[1] { @1A9C revert(memory[0x00:0x00]); } // Block terminates label_1A9D: // Incoming jump from 0x1A98, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1A9E stack[-3] // @1A9E stack[-1] // @1A9F stack[-2] // } 1A9D 5B JUMPDEST 1A9E 91 SWAP2 1A9F 90 SWAP1 1AA0 50 POP 1AA1 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A9E stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1AA2: // Incoming call from 0x0169, returns to 0x016A // Inputs[2] // { // @1AA8 stack[-1] // @1AA9 stack[-2] // } 1AA2 5B JUMPDEST 1AA3 60 PUSH1 0x00 1AA5 80 DUP1 1AA6 60 PUSH1 0x40 1AA8 83 DUP4 1AA9 85 DUP6 1AAA 03 SUB 1AAB 12 SLT 1AAC 15 ISZERO 1AAD 61 PUSH2 0x1ab5 1AB0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1AA3 stack[0] = 0x00 // @1AA5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ab5, if !(stack[-2] - stack[-1] i< 0x40) label_1AB1: // Incoming jump from 0x1AB0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1AB4 memory[0x00:0x00] } 1AB1 60 PUSH1 0x00 1AB3 80 DUP1 1AB4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AB4 revert(memory[0x00:0x00]); } // Block terminates label_1AB5: // Incoming jump from 0x1AB0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1AB9 stack[-3] } 1AB5 5B JUMPDEST 1AB6 61 PUSH2 0x1abe 1AB9 83 DUP4 1ABA 61 PUSH2 0x1a86 1ABD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AB6 stack[0] = 0x1abe // @1AB9 stack[1] = stack[-3] // } // Block ends with call to 0x1a86, returns to 0x1ABE label_1ABE: // Incoming return from call to 0x1A86 at 0x1ABD // Inputs[5] // { // @1ABF stack[-1] // @1ABF stack[-6] // @1AC2 stack[-4] // @1AC6 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1AC7 stack[-5] // } 1ABE 5B JUMPDEST 1ABF 94 SWAP5 1AC0 60 PUSH1 0x20 1AC2 93 SWAP4 1AC3 90 SWAP1 1AC4 93 SWAP4 1AC5 01 ADD 1AC6 35 CALLDATALOAD 1AC7 93 SWAP4 1AC8 50 POP 1AC9 50 POP 1ACA 50 POP 1ACB 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1ABF stack[-6] = stack[-1] // @1AC7 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1ACC: // Incoming call from 0x1AFE, returns to 0x1303 // Incoming call from 0x2716, returns to 0x1303 // Inputs[1] { @1AD6 stack[-1] } 1ACC 5B JUMPDEST 1ACD 60 PUSH1 0x01 1ACF 60 PUSH1 0x01 1AD1 60 PUSH1 0xe0 1AD3 1B SHL 1AD4 03 SUB 1AD5 19 NOT 1AD6 81 DUP2 1AD7 16 AND 1AD8 81 DUP2 1AD9 14 EQ 1ADA 61 PUSH2 0x07be 1ADD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07be, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1ADE: // Incoming jump from 0x1ADD, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1AE1 memory[0x00:0x00] } 1ADE 60 PUSH1 0x00 1AE0 80 DUP1 1AE1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AE1 revert(memory[0x00:0x00]); } // Block terminates label_1AE2: // Incoming call from 0x018F, returns to 0x0190 // Inputs[2] // { // @1AE7 stack[-1] // @1AE8 stack[-2] // } 1AE2 5B JUMPDEST 1AE3 60 PUSH1 0x00 1AE5 60 PUSH1 0x20 1AE7 82 DUP3 1AE8 84 DUP5 1AE9 03 SUB 1AEA 12 SLT 1AEB 15 ISZERO 1AEC 61 PUSH2 0x1af4 1AEF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AE3 stack[0] = 0x00 } // Block ends with conditional jump to 0x1af4, if !(stack[-2] - stack[-1] i< 0x20) label_1AF0: // Incoming jump from 0x1AEF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1AF3 memory[0x00:0x00] } 1AF0 60 PUSH1 0x00 1AF2 80 DUP1 1AF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AF3 revert(memory[0x00:0x00]); } // Block terminates label_1AF4: // Incoming jump from 0x1AEF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1AF5 stack[-2] // @1AF6 msg.data[stack[-2]:stack[-2] + 0x20] // } 1AF4 5B JUMPDEST 1AF5 81 DUP2 1AF6 35 CALLDATALOAD 1AF7 61 PUSH2 0x1303 1AFA 81 DUP2 1AFB 61 PUSH2 0x1acc 1AFE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AF6 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1AF7 stack[1] = 0x1303 // @1AFA stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1acc, returns to 0x1303 label_1AFF: // Incoming jump from 0x0703 // Incoming jump from 0x256E // Incoming jump from 0x1B39 // Incoming jump from 0x1DAE // Incoming jump from 0x1B59 // Inputs[1] { @1B14 memory[0x00:0x24] } 1AFF 5B JUMPDEST 1B00 63 PUSH4 0x4e487b71 1B05 60 PUSH1 0xe0 1B07 1B SHL 1B08 60 PUSH1 0x00 1B0A 52 MSTORE 1B0B 60 PUSH1 0x41 1B0D 60 PUSH1 0x04 1B0F 52 MSTORE 1B10 60 PUSH1 0x24 1B12 60 PUSH1 0x00 1B14 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1B0A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1B0F memory[0x04:0x24] = 0x41 // @1B14 revert(memory[0x00:0x24]); // } // Block terminates label_1B15: // Incoming call from 0x1B8E, returns to 0x1B8F // Incoming call from 0x1F13, returns to 0x1F14 // Incoming call from 0x27B0, returns to 0x27B1 // Incoming call from 0x1DC5, returns to 0x1DC6 // Incoming call from 0x1BFF, returns to 0x1C00 // Inputs[2] // { // @1B18 stack[-2] // @1B1E stack[-1] // } 1B15 5B JUMPDEST 1B16 60 PUSH1 0x1f 1B18 82 DUP3 1B19 01 ADD 1B1A 60 PUSH1 0x1f 1B1C 19 NOT 1B1D 16 AND 1B1E 81 DUP2 1B1F 01 ADD 1B20 60 PUSH1 0x01 1B22 60 PUSH1 0x01 1B24 60 PUSH1 0x40 1B26 1B SHL 1B27 03 SUB 1B28 81 DUP2 1B29 11 GT 1B2A 82 DUP3 1B2B 82 DUP3 1B2C 10 LT 1B2D 17 OR 1B2E 15 ISZERO 1B2F 61 PUSH2 0x1b3a 1B32 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B1F stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x1b3a, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) label_1B33: // Incoming jump from 0x1B32, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) 1B33 61 PUSH2 0x1b3a 1B36 61 PUSH2 0x1aff 1B39 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B33 stack[0] = 0x1b3a } // Block ends with unconditional jump to 0x1aff label_1B3A: // Incoming jump from 0x1B32, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) // Inputs[2] // { // @1B3D stack[-1] // @1B40 stack[-4] // } 1B3A 5B JUMPDEST 1B3B 60 PUSH1 0x40 1B3D 52 MSTORE 1B3E 50 POP 1B3F 50 POP 1B40 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B3D memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1B41: // Incoming call from 0x1BF2, returns to 0x1BF3 // Incoming call from 0x1B81, returns to 0x1B82 // Incoming call from 0x1F06, returns to 0x1F07 // Inputs[1] { @1B4C stack[-1] } 1B41 5B JUMPDEST 1B42 60 PUSH1 0x00 1B44 60 PUSH1 0x01 1B46 60 PUSH1 0x01 1B48 60 PUSH1 0x40 1B4A 1B SHL 1B4B 03 SUB 1B4C 82 DUP3 1B4D 11 GT 1B4E 15 ISZERO 1B4F 61 PUSH2 0x1b5a 1B52 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B42 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b5a, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_1B53: // Incoming jump from 0x1B52, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 1B53 61 PUSH2 0x1b5a 1B56 61 PUSH2 0x1aff 1B59 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B53 stack[0] = 0x1b5a } // Block ends with unconditional jump to 0x1aff label_1B5A: // Incoming jump from 0x1B52, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1B5E stack[-2] // @1B62 stack[-3] // } 1B5A 5B JUMPDEST 1B5B 50 POP 1B5C 60 PUSH1 0x05 1B5E 1B SHL 1B5F 60 PUSH1 0x20 1B61 01 ADD 1B62 90 SWAP1 1B63 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B62 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_1B64: // Incoming call from 0x1C50, returns to 0x1C51 // Incoming call from 0x21E3, returns to 0x21E4 // Incoming call from 0x2084, returns to 0x2085 // Incoming call from 0x1E69, returns to 0x1E6A // Incoming call from 0x2205, returns to 0x2206 // Incoming call from 0x1E8B, returns to 0x1E8C // Incoming call from 0x2061, returns to 0x2062 // Incoming call from 0x1F7B, returns to 0x1F7C // Incoming call from 0x2199, returns to 0x08C2 // Inputs[2] // { // @1B67 stack[-2] // @1B6A stack[-1] // } 1B64 5B JUMPDEST 1B65 60 PUSH1 0x00 1B67 82 DUP3 1B68 60 PUSH1 0x1f 1B6A 83 DUP4 1B6B 01 ADD 1B6C 12 SLT 1B6D 61 PUSH2 0x1b75 1B70 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B65 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b75, if stack[-1] + 0x1f i< stack[-2] label_1B71: // Incoming jump from 0x1B70, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1B74 memory[0x00:0x00] } 1B71 60 PUSH1 0x00 1B73 80 DUP1 1B74 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B74 revert(memory[0x00:0x00]); } // Block terminates label_1B75: // Incoming jump from 0x1B70, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1B76 stack[-2] // @1B77 msg.data[stack[-2]:stack[-2] + 0x20] // } 1B75 5B JUMPDEST 1B76 81 DUP2 1B77 35 CALLDATALOAD 1B78 60 PUSH1 0x20 1B7A 61 PUSH2 0x1b82 1B7D 82 DUP3 1B7E 61 PUSH2 0x1b41 1B81 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B77 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1B78 stack[1] = 0x20 // @1B7A stack[2] = 0x1b82 // @1B7D stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1b41, returns to 0x1B82 label_1B82: // Incoming return from call to 0x1B41 at 0x1B81 // Inputs[2] // { // @1B85 memory[0x40:0x60] // @1B89 stack[-1] // } 1B82 5B JUMPDEST 1B83 60 PUSH1 0x40 1B85 51 MLOAD 1B86 61 PUSH2 0x1b8f 1B89 82 DUP3 1B8A 82 DUP3 1B8B 61 PUSH2 0x1b15 1B8E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B85 stack[0] = memory[0x40:0x60] // @1B86 stack[1] = 0x1b8f // @1B89 stack[2] = stack[-1] // @1B8A stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1b15, returns to 0x1B8F label_1B8F: // Incoming return from call to 0x1B15 at 0x1B8E // Inputs[6] // { // @1B90 stack[-4] // @1B91 stack[-1] // @1B99 stack[-6] // @1B9B stack[-3] // @1BA1 stack[-2] // @1BA3 stack[-7] // } 1B8F 5B JUMPDEST 1B90 83 DUP4 1B91 81 DUP2 1B92 52 MSTORE 1B93 60 PUSH1 0x05 1B95 93 SWAP4 1B96 90 SWAP1 1B97 93 SWAP4 1B98 1B SHL 1B99 85 DUP6 1B9A 01 ADD 1B9B 82 DUP3 1B9C 01 ADD 1B9D 92 SWAP3 1B9E 82 DUP3 1B9F 81 DUP2 1BA0 01 ADD 1BA1 91 SWAP2 1BA2 50 POP 1BA3 86 DUP7 1BA4 84 DUP5 1BA5 11 GT 1BA6 15 ISZERO 1BA7 61 PUSH2 0x1baf 1BAA 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1B92 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1B9D stack[-1] = stack[-1] // @1B9D stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @1BA1 stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1baf, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) label_1BAB: // Incoming jump from 0x1BAA, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[1] { @1BAE memory[0x00:0x00] } 1BAB 60 PUSH1 0x00 1BAD 80 DUP1 1BAE FD *REVERT // Stack delta = +0 // Outputs[1] { @1BAE revert(memory[0x00:0x00]); } // Block terminates label_1BAF: // Incoming jump from 0x1BAA, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[3] // { // @1BB0 stack[-3] // @1BB1 stack[-6] // @1BB4 stack[-4] // } 1BAF 5B JUMPDEST 1BB0 82 DUP3 1BB1 86 DUP7 1BB2 01 ADD 1BB3 5B JUMPDEST 1BB4 84 DUP5 1BB5 81 DUP2 1BB6 10 LT 1BB7 15 ISZERO 1BB8 61 PUSH2 0x1bca 1BBB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BB2 stack[0] = stack[-6] + stack[-3] } // Block ends with conditional jump to 0x1bca, if !(stack[-6] + stack[-3] < stack[-4]) label_1BBC: // Incoming jump from 0x1BBB, if not !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x1BBB, if not !(stack[-1] < stack[-5]) // Inputs[4] // { // @1BBC stack[-1] // @1BBD msg.data[stack[-1]:stack[-1] + 0x20] // @1BBE stack[-3] // @1BC1 stack[-4] // } 1BBC 80 DUP1 1BBD 35 CALLDATALOAD 1BBE 83 DUP4 1BBF 52 MSTORE 1BC0 91 SWAP2 1BC1 83 DUP4 1BC2 01 ADD 1BC3 91 SWAP2 1BC4 83 DUP4 1BC5 01 ADD 1BC6 61 PUSH2 0x1bb3 1BC9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1BBF memory[stack[-3]:stack[-3] + 0x20] = msg.data[stack[-1]:stack[-1] + 0x20] // @1BC3 stack[-3] = stack[-4] + stack[-3] // @1BC5 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x1bb3 label_1BCA: // Incoming jump from 0x1BBB, if !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x1BBB, if !(stack[-1] < stack[-5]) // Incoming jump from 0x1C2C, if !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x1C2C, if !(stack[-1] < stack[-5]) // Inputs[3] // { // @1BCC stack[-9] // @1BCC stack[-2] // @1BCD stack[-8] // } 1BCA 5B JUMPDEST 1BCB 50 POP 1BCC 96 SWAP7 1BCD 95 SWAP6 1BCE 50 POP 1BCF 50 POP 1BD0 50 POP 1BD1 50 POP 1BD2 50 POP 1BD3 50 POP 1BD4 56 *JUMP // Stack delta = -8 // Outputs[1] { @1BCC stack[-9] = stack[-2] } // Block ends with unconditional jump to stack[-9] label_1BD5: // Incoming call from 0x1D0D, returns to 0x1D0E // Incoming call from 0x1CEA, returns to 0x1CEB // Inputs[2] // { // @1BD8 stack[-2] // @1BDB stack[-1] // } 1BD5 5B JUMPDEST 1BD6 60 PUSH1 0x00 1BD8 82 DUP3 1BD9 60 PUSH1 0x1f 1BDB 83 DUP4 1BDC 01 ADD 1BDD 12 SLT 1BDE 61 PUSH2 0x1be6 1BE1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BD6 stack[0] = 0x00 } // Block ends with conditional jump to 0x1be6, if stack[-1] + 0x1f i< stack[-2] label_1BE2: // Incoming jump from 0x1BE1, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1BE5 memory[0x00:0x00] } 1BE2 60 PUSH1 0x00 1BE4 80 DUP1 1BE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BE5 revert(memory[0x00:0x00]); } // Block terminates label_1BE6: // Incoming jump from 0x1BE1, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1BE7 stack[-2] // @1BE8 msg.data[stack[-2]:stack[-2] + 0x20] // } 1BE6 5B JUMPDEST 1BE7 81 DUP2 1BE8 35 CALLDATALOAD 1BE9 60 PUSH1 0x20 1BEB 61 PUSH2 0x1bf3 1BEE 82 DUP3 1BEF 61 PUSH2 0x1b41 1BF2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BE8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1BE9 stack[1] = 0x20 // @1BEB stack[2] = 0x1bf3 // @1BEE stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1b41, returns to 0x1BF3 label_1BF3: // Incoming return from call to 0x1B41 at 0x1BF2 // Inputs[2] // { // @1BF6 memory[0x40:0x60] // @1BFA stack[-1] // } 1BF3 5B JUMPDEST 1BF4 60 PUSH1 0x40 1BF6 51 MLOAD 1BF7 61 PUSH2 0x1c00 1BFA 82 DUP3 1BFB 82 DUP3 1BFC 61 PUSH2 0x1b15 1BFF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BF6 stack[0] = memory[0x40:0x60] // @1BF7 stack[1] = 0x1c00 // @1BFA stack[2] = stack[-1] // @1BFB stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1b15, returns to 0x1C00 label_1C00: // Incoming return from call to 0x1B15 at 0x1BFF // Inputs[6] // { // @1C01 stack[-4] // @1C02 stack[-1] // @1C0A stack[-6] // @1C0C stack[-3] // @1C12 stack[-2] // @1C14 stack[-7] // } 1C00 5B JUMPDEST 1C01 83 DUP4 1C02 81 DUP2 1C03 52 MSTORE 1C04 60 PUSH1 0x05 1C06 93 SWAP4 1C07 90 SWAP1 1C08 93 SWAP4 1C09 1B SHL 1C0A 85 DUP6 1C0B 01 ADD 1C0C 82 DUP3 1C0D 01 ADD 1C0E 92 SWAP3 1C0F 82 DUP3 1C10 81 DUP2 1C11 01 ADD 1C12 91 SWAP2 1C13 50 POP 1C14 86 DUP7 1C15 84 DUP5 1C16 11 GT 1C17 15 ISZERO 1C18 61 PUSH2 0x1c20 1C1B 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C03 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1C0E stack[-1] = stack[-1] // @1C0E stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @1C12 stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1c20, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) label_1C1C: // Incoming jump from 0x1C1B, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[1] { @1C1F memory[0x00:0x00] } 1C1C 60 PUSH1 0x00 1C1E 80 DUP1 1C1F FD *REVERT // Stack delta = +0 // Outputs[1] { @1C1F revert(memory[0x00:0x00]); } // Block terminates label_1C20: // Incoming jump from 0x1C1B, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-7]) // Inputs[3] // { // @1C21 stack[-3] // @1C22 stack[-6] // @1C25 stack[-4] // } 1C20 5B JUMPDEST 1C21 82 DUP3 1C22 86 DUP7 1C23 01 ADD 1C24 5B JUMPDEST 1C25 84 DUP5 1C26 81 DUP2 1C27 10 LT 1C28 15 ISZERO 1C29 61 PUSH2 0x1bca 1C2C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C23 stack[0] = stack[-6] + stack[-3] } // Block ends with conditional jump to 0x1bca, if !(stack[-6] + stack[-3] < stack[-4]) label_1C2D: // Incoming jump from 0x1C2C, if not !(stack[-6] + stack[-3] < stack[-4]) // Incoming jump from 0x1C2C, if not !(stack[-1] < stack[-5]) // Inputs[2] // { // @1C2D stack[-1] // @1C2E msg.data[stack[-1]:stack[-1] + 0x20] // } 1C2D 80 DUP1 1C2E 35 CALLDATALOAD 1C2F 60 PUSH1 0x01 1C31 60 PUSH1 0x01 1C33 60 PUSH1 0x40 1C35 1B SHL 1C36 03 SUB 1C37 81 DUP2 1C38 11 GT 1C39 15 ISZERO 1C3A 61 PUSH2 0x1c43 1C3D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C2E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1c43, if !(msg.data[stack[-1]:stack[-1] + 0x20] > (0x01 << 0x40) - 0x01) label_1C3E: // Incoming jump from 0x1C3D, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1C42 memory[0x00:0x00] } 1C3E 60 PUSH1 0x00 1C40 80 DUP1 1C41 81 DUP2 1C42 FD *REVERT // Stack delta = +1 // Outputs[2] // { // @1C3E stack[0] = 0x00 // @1C42 revert(memory[0x00:0x00]); // } // Block terminates label_1C43: // Incoming jump from 0x1C3D, if !(msg.data[stack[-1]:stack[-1] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[4] // { // @1C47 stack[-9] // @1C48 stack[-5] // @1C49 stack[-1] // @1C4A stack[-8] // } 1C43 5B JUMPDEST 1C44 61 PUSH2 0x1c51 1C47 89 DUP10 1C48 86 DUP7 1C49 83 DUP4 1C4A 8B DUP12 1C4B 01 ADD 1C4C 01 ADD 1C4D 61 PUSH2 0x1b64 1C50 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C44 stack[0] = 0x1c51 // @1C47 stack[1] = stack[-9] // @1C4C stack[2] = stack[-8] + stack[-1] + stack[-5] // } // Block ends with call to 0x1b64, returns to 0x1C51 label_1C51: // Incoming return from call to 0x1B64 at 0x1C50 // Inputs[4] // { // @1C52 stack[-5] // @1C53 stack[-1] // @1C55 stack[-3] // @1C56 stack[-6] // } 1C51 5B JUMPDEST 1C52 84 DUP5 1C53 52 MSTORE 1C54 50 POP 1C55 91 SWAP2 1C56 83 DUP4 1C57 01 ADD 1C58 91 SWAP2 1C59 83 DUP4 1C5A 01 ADD 1C5B 61 PUSH2 0x1c24 1C5E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1C53 memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @1C58 stack[-5] = stack[-6] + stack[-5] // @1C5A stack[-3] = stack[-6] + stack[-3] // } // Block ends with unconditional jump to 0x1c24 label_1C5F: // Incoming call from 0x01B2, returns to 0x01B3 // Inputs[2] // { // @1C68 stack[-1] // @1C69 stack[-2] // } 1C5F 5B JUMPDEST 1C60 60 PUSH1 0x00 1C62 80 DUP1 1C63 60 PUSH1 0x00 1C65 80 DUP1 1C66 60 PUSH1 0x60 1C68 85 DUP6 1C69 87 DUP8 1C6A 03 SUB 1C6B 12 SLT 1C6C 15 ISZERO 1C6D 61 PUSH2 0x1c75 1C70 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1C60 stack[0] = 0x00 // @1C62 stack[1] = 0x00 // @1C63 stack[2] = 0x00 // @1C65 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1c75, if !(stack[-2] - stack[-1] i< 0x60) label_1C71: // Incoming jump from 0x1C70, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1C74 memory[0x00:0x00] } 1C71 60 PUSH1 0x00 1C73 80 DUP1 1C74 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C74 revert(memory[0x00:0x00]); } // Block terminates label_1C75: // Incoming jump from 0x1C70, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1C76 stack[-5] // @1C77 msg.data[stack[-5]:stack[-5] + 0x20] // } 1C75 5B JUMPDEST 1C76 84 DUP5 1C77 35 CALLDATALOAD 1C78 60 PUSH1 0x01 1C7A 60 PUSH1 0x01 1C7C 60 PUSH1 0x40 1C7E 1B SHL 1C7F 03 SUB 1C80 80 DUP1 1C81 82 DUP3 1C82 11 GT 1C83 15 ISZERO 1C84 61 PUSH2 0x1c8c 1C87 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C77 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @1C7F stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1c8c, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) label_1C88: // Incoming jump from 0x1C87, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1C8B memory[0x00:0x00] } 1C88 60 PUSH1 0x00 1C8A 80 DUP1 1C8B FD *REVERT // Stack delta = +0 // Outputs[1] { @1C8B revert(memory[0x00:0x00]); } // Block terminates label_1C8C: // Incoming jump from 0x1C87, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1C8D stack[-2] // @1C8E stack[-7] // @1C92 stack[-8] // } 1C8C 5B JUMPDEST 1C8D 81 DUP2 1C8E 87 DUP8 1C8F 01 ADD 1C90 91 SWAP2 1C91 50 POP 1C92 87 DUP8 1C93 60 PUSH1 0x1f 1C95 83 DUP4 1C96 01 ADD 1C97 12 SLT 1C98 61 PUSH2 0x1ca0 1C9B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C90 stack[-2] = stack[-7] + stack[-2] } // Block ends with conditional jump to 0x1ca0, if stack[-7] + stack[-2] + 0x1f i< stack[-8] label_1C9C: // Incoming jump from 0x1C9B, if not stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[1] { @1C9F memory[0x00:0x00] } 1C9C 60 PUSH1 0x00 1C9E 80 DUP1 1C9F FD *REVERT // Stack delta = +0 // Outputs[1] { @1C9F revert(memory[0x00:0x00]); } // Block terminates label_1CA0: // Incoming jump from 0x1C9B, if stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[3] // { // @1CA1 stack[-2] // @1CA2 msg.data[stack[-2]:stack[-2] + 0x20] // @1CA3 stack[-1] // } 1CA0 5B JUMPDEST 1CA1 81 DUP2 1CA2 35 CALLDATALOAD 1CA3 81 DUP2 1CA4 81 DUP2 1CA5 11 GT 1CA6 15 ISZERO 1CA7 61 PUSH2 0x1caf 1CAA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CA2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1caf, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1CAB: // Incoming jump from 0x1CAA, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @1CAE memory[0x00:0x00] } 1CAB 60 PUSH1 0x00 1CAD 80 DUP1 1CAE FD *REVERT // Stack delta = +0 // Outputs[1] { @1CAE revert(memory[0x00:0x00]); } // Block terminates label_1CAF: // Incoming jump from 0x1CAA, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1CB0 stack[-9] // @1CB3 stack[-1] // @1CB7 stack[-3] // } 1CAF 5B JUMPDEST 1CB0 88 DUP9 1CB1 60 PUSH1 0x20 1CB3 82 DUP3 1CB4 60 PUSH1 0x05 1CB6 1B SHL 1CB7 85 DUP6 1CB8 01 ADD 1CB9 01 ADD 1CBA 11 GT 1CBB 15 ISZERO 1CBC 61 PUSH2 0x1cc4 1CBF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1cc4, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-9]) label_1CC0: // Incoming jump from 0x1CBF, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-9]) // Inputs[1] { @1CC3 memory[0x00:0x00] } 1CC0 60 PUSH1 0x00 1CC2 80 DUP1 1CC3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CC3 revert(memory[0x00:0x00]); } // Block terminates label_1CC4: // Incoming jump from 0x1CBF, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-9]) // Inputs[7] // { // @1CC7 stack[-3] // @1CCA stack[-7] // @1CCC stack[-6] // @1CCC stack[-1] // @1CCE stack[-2] // @1CCF stack[-8] // @1CD1 msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } 1CC4 5B JUMPDEST 1CC5 60 PUSH1 0x20 1CC7 92 SWAP3 1CC8 83 DUP4 1CC9 01 ADD 1CCA 96 SWAP7 1CCB 50 POP 1CCC 94 SWAP5 1CCD 50 POP 1CCE 90 SWAP1 1CCF 86 DUP7 1CD0 01 ADD 1CD1 35 CALLDATALOAD 1CD2 90 SWAP1 1CD3 80 DUP1 1CD4 82 DUP3 1CD5 11 GT 1CD6 15 ISZERO 1CD7 61 PUSH2 0x1cdf 1CDA 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @1CCA stack[-7] = 0x20 + stack[-3] // @1CCC stack[-6] = stack[-1] // @1CD2 stack[-3] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @1CD2 stack[-2] = stack[-2] // } // Block ends with conditional jump to 0x1cdf, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > stack[-2]) label_1CDB: // Incoming jump from 0x1CDA, if not !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > stack[-2]) // Inputs[1] { @1CDE memory[0x00:0x00] } 1CDB 60 PUSH1 0x00 1CDD 80 DUP1 1CDE FD *REVERT // Stack delta = +0 // Outputs[1] { @1CDE revert(memory[0x00:0x00]); } // Block terminates label_1CDF: // Incoming jump from 0x1CDA, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @1CE3 stack[-8] // @1CE4 stack[-2] // @1CE5 stack[-7] // } 1CDF 5B JUMPDEST 1CE0 61 PUSH2 0x1ceb 1CE3 88 DUP9 1CE4 83 DUP4 1CE5 89 DUP10 1CE6 01 ADD 1CE7 61 PUSH2 0x1bd5 1CEA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CE0 stack[0] = 0x1ceb // @1CE3 stack[1] = stack[-8] // @1CE6 stack[2] = stack[-7] + stack[-2] // } // Block ends with call to 0x1bd5, returns to 0x1CEB label_1CEB: // Incoming return from call to 0x1BD5 at 0x1CEA // Inputs[6] // { // @1CEC stack[-5] // @1CEC stack[-1] // @1CF0 stack[-8] // @1CF2 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @1CF3 stack[-3] // @1CF5 stack[-2] // } 1CEB 5B JUMPDEST 1CEC 93 SWAP4 1CED 50 POP 1CEE 60 PUSH1 0x40 1CF0 87 DUP8 1CF1 01 ADD 1CF2 35 CALLDATALOAD 1CF3 91 SWAP2 1CF4 50 POP 1CF5 80 DUP1 1CF6 82 DUP3 1CF7 11 GT 1CF8 15 ISZERO 1CF9 61 PUSH2 0x1d01 1CFC 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1CEC stack[-5] = stack[-1] // @1CF3 stack[-3] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x1d01, if !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > stack[-2]) label_1CFD: // Incoming jump from 0x1CFC, if not !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > stack[-2]) // Inputs[1] { @1D00 memory[0x00:0x00] } 1CFD 60 PUSH1 0x00 1CFF 80 DUP1 1D00 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D00 revert(memory[0x00:0x00]); } // Block terminates label_1D01: // Incoming jump from 0x1CFC, if !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > stack[-2]) // Inputs[3] // { // @1D06 stack[-8] // @1D07 stack[-2] // @1D08 stack[-7] // } 1D01 5B JUMPDEST 1D02 50 POP 1D03 61 PUSH2 0x1d0e 1D06 87 DUP8 1D07 82 DUP3 1D08 88 DUP9 1D09 01 ADD 1D0A 61 PUSH2 0x1bd5 1D0D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D03 stack[-1] = 0x1d0e // @1D06 stack[0] = stack[-8] // @1D09 stack[1] = stack[-7] + stack[-2] // } // Block ends with call to 0x1bd5, returns to 0x1D0E label_1D0E: // Incoming return from call to 0x1BD5 at 0x1D0D // Inputs[8] // { // @1D0F stack[-1] // @1D0F stack[-3] // @1D12 stack[-6] // @1D13 stack[-9] // @1D14 stack[-5] // @1D15 stack[-8] // @1D17 stack[-4] // @1D17 stack[-7] // } 1D0E 5B JUMPDEST 1D0F 91 SWAP2 1D10 50 POP 1D11 50 POP 1D12 92 SWAP3 1D13 95 SWAP6 1D14 91 SWAP2 1D15 94 SWAP5 1D16 50 POP 1D17 92 SWAP3 1D18 50 POP 1D19 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1D12 stack[-6] = stack[-1] // @1D13 stack[-9] = stack[-6] // @1D15 stack[-8] = stack[-5] // @1D17 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1D1A: // Incoming call from 0x02A6, returns to 0x02A7 // Incoming call from 0x01FA, returns to 0x01FB // Incoming call from 0x01C7, returns to 0x01C8 // Incoming call from 0x01E7, returns to 0x01E8 // Inputs[2] // { // @1D1F stack[-1] // @1D20 stack[-2] // } 1D1A 5B JUMPDEST 1D1B 60 PUSH1 0x00 1D1D 60 PUSH1 0x20 1D1F 82 DUP3 1D20 84 DUP5 1D21 03 SUB 1D22 12 SLT 1D23 15 ISZERO 1D24 61 PUSH2 0x1d2c 1D27 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D1B stack[0] = 0x00 } // Block ends with conditional jump to 0x1d2c, if !(stack[-2] - stack[-1] i< 0x20) label_1D28: // Incoming jump from 0x1D27, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1D2B memory[0x00:0x00] } 1D28 60 PUSH1 0x00 1D2A 80 DUP1 1D2B FD *REVERT // Stack delta = +0 // Outputs[1] { @1D2B revert(memory[0x00:0x00]); } // Block terminates label_1D2C: // Incoming jump from 0x1D27, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1D2E msg.data[stack[-2]:stack[-2] + 0x20] // @1D2E stack[-2] // @1D2F stack[-4] // @1D30 stack[-3] // } 1D2C 5B JUMPDEST 1D2D 50 POP 1D2E 35 CALLDATALOAD 1D2F 91 SWAP2 1D30 90 SWAP1 1D31 50 POP 1D32 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D2F stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1D33: // Incoming call from 0x1D6E, returns to 0x1D6F // Inputs[1] { @1D37 stack[-3] } 1D33 5B JUMPDEST 1D34 60 PUSH1 0x00 1D36 5B JUMPDEST 1D37 83 DUP4 1D38 81 DUP2 1D39 10 LT 1D3A 15 ISZERO 1D3B 61 PUSH2 0x1d4e 1D3E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D34 stack[0] = 0x00 } // Block ends with conditional jump to 0x1d4e, if !(0x00 < stack[-3]) label_1D3F: // Incoming jump from 0x1D3E, if not !(0x00 < stack[-3]) // Incoming jump from 0x1D3E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1D3F stack[-2] // @1D40 stack[-1] // @1D42 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D43 stack[-3] // } 1D3F 81 DUP2 1D40 81 DUP2 1D41 01 ADD 1D42 51 MLOAD 1D43 83 DUP4 1D44 82 DUP3 1D45 01 ADD 1D46 52 MSTORE 1D47 60 PUSH1 0x20 1D49 01 ADD 1D4A 61 PUSH2 0x1d36 1D4D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1D46 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D49 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1d36 label_1D4E: // Incoming jump from 0x1D3E, if !(0x00 < stack[-3]) // Incoming jump from 0x1D3E, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1D53 stack[-4] // @1D54 stack[-3] // @1D56 stack[-5] // } 1D4E 5B JUMPDEST 1D4F 50 POP 1D50 50 POP 1D51 60 PUSH1 0x00 1D53 91 SWAP2 1D54 01 ADD 1D55 52 MSTORE 1D56 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D55 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1D57: // Incoming call from 0x1D95, returns to 0x1303 // Incoming call from 0x26ED, returns to 0x26EE // Inputs[3] // { // @1D5A stack[-1] // @1D5B memory[stack[-1]:stack[-1] + 0x20] // @1D5D stack[-2] // } 1D57 5B JUMPDEST 1D58 60 PUSH1 0x00 1D5A 81 DUP2 1D5B 51 MLOAD 1D5C 80 DUP1 1D5D 84 DUP5 1D5E 52 MSTORE 1D5F 61 PUSH2 0x1d6f 1D62 81 DUP2 1D63 60 PUSH1 0x20 1D65 86 DUP7 1D66 01 ADD 1D67 60 PUSH1 0x20 1D69 86 DUP7 1D6A 01 ADD 1D6B 61 PUSH2 0x1d33 1D6E 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1D58 stack[0] = 0x00 // @1D5B stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1D5E memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1D5F stack[2] = 0x1d6f // @1D62 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1D66 stack[4] = stack[-2] + 0x20 // @1D6A stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1d33, returns to 0x1D6F label_1D6F: // Incoming return from call to 0x1D33 at 0x1D6E // Inputs[4] // { // @1D72 stack[-1] // @1D77 stack[-4] // @1D78 stack[-2] // @1D7E stack[-5] // } 1D6F 5B JUMPDEST 1D70 60 PUSH1 0x1f 1D72 01 ADD 1D73 60 PUSH1 0x1f 1D75 19 NOT 1D76 16 AND 1D77 92 SWAP3 1D78 90 SWAP1 1D79 92 SWAP3 1D7A 01 ADD 1D7B 60 PUSH1 0x20 1D7D 01 ADD 1D7E 92 SWAP3 1D7F 91 SWAP2 1D80 50 POP 1D81 50 POP 1D82 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D7E stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1D83: // Incoming jump from 0x01D9 // Incoming jump from 0x1600 // Inputs[2] // { // @1D86 stack[-1] // @1D91 stack[-2] // } 1D83 5B JUMPDEST 1D84 60 PUSH1 0x20 1D86 81 DUP2 1D87 52 MSTORE 1D88 60 PUSH1 0x00 1D8A 61 PUSH2 0x1303 1D8D 60 PUSH1 0x20 1D8F 83 DUP4 1D90 01 ADD 1D91 84 DUP5 1D92 61 PUSH2 0x1d57 1D95 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1D87 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1D88 stack[0] = 0x00 // @1D8A stack[1] = 0x1303 // @1D90 stack[2] = stack[-1] + 0x20 // @1D91 stack[3] = stack[-2] // } // Block ends with call to 0x1d57, returns to 0x1303 label_1D96: // Incoming call from 0x201B, returns to 0x08C2 // Incoming call from 0x1E12, returns to 0x1303 // Inputs[1] { @1DA1 stack[-2] } 1D96 5B JUMPDEST 1D97 60 PUSH1 0x00 1D99 60 PUSH1 0x01 1D9B 60 PUSH1 0x01 1D9D 60 PUSH1 0x40 1D9F 1B SHL 1DA0 03 SUB 1DA1 83 DUP4 1DA2 11 GT 1DA3 15 ISZERO 1DA4 61 PUSH2 0x1daf 1DA7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D97 stack[0] = 0x00 } // Block ends with conditional jump to 0x1daf, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_1DA8: // Incoming jump from 0x1DA7, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 1DA8 61 PUSH2 0x1daf 1DAB 61 PUSH2 0x1aff 1DAE 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DA8 stack[0] = 0x1daf } // Block ends with unconditional jump to 0x1aff label_1DAF: // Incoming jump from 0x1DA7, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @1DB2 memory[0x40:0x60] // @1DB8 stack[-3] // } 1DAF 5B JUMPDEST 1DB0 60 PUSH1 0x40 1DB2 51 MLOAD 1DB3 61 PUSH2 0x1dc6 1DB6 60 PUSH1 0x1f 1DB8 85 DUP6 1DB9 01 ADD 1DBA 60 PUSH1 0x1f 1DBC 19 NOT 1DBD 16 AND 1DBE 60 PUSH1 0x20 1DC0 01 ADD 1DC1 82 DUP3 1DC2 61 PUSH2 0x1b15 1DC5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DB2 stack[0] = memory[0x40:0x60] // @1DB3 stack[1] = 0x1dc6 // @1DC0 stack[2] = 0x20 + (~0x1f & stack[-3] + 0x1f) // @1DC1 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1b15, returns to 0x1DC6 label_1DC6: // Incoming return from call to 0x1B15 at 0x1DC5 // Inputs[5] // { // @1DC7 stack[-1] // @1DC8 stack[-2] // @1DCA stack[-4] // @1DCD stack[-5] // @1DCF stack[-3] // } 1DC6 5B JUMPDEST 1DC7 80 DUP1 1DC8 91 SWAP2 1DC9 50 POP 1DCA 83 DUP4 1DCB 81 DUP2 1DCC 52 MSTORE 1DCD 84 DUP5 1DCE 84 DUP5 1DCF 84 DUP5 1DD0 01 ADD 1DD1 11 GT 1DD2 15 ISZERO 1DD3 61 PUSH2 0x1ddb 1DD6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1DC8 stack[-2] = stack[-1] // @1DCC memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x1ddb, if !(stack[-3] + stack[-4] > stack[-5]) label_1DD7: // Incoming jump from 0x1DD6, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @1DDA memory[0x00:0x00] } 1DD7 60 PUSH1 0x00 1DD9 80 DUP1 1DDA FD *REVERT // Stack delta = +0 // Outputs[1] { @1DDA revert(memory[0x00:0x00]); } // Block terminates label_1DDB: // Incoming jump from 0x1DD6, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[7] // { // @1DDC stack[-4] // @1DDD stack[-3] // @1DE0 stack[-1] // @1DE2 msg.data[stack[-3]:stack[-3] + stack[-4]] // @1DED stack[-2] // @1DED stack[-6] // @1DEE stack[-5] // } 1DDB 5B JUMPDEST 1DDC 83 DUP4 1DDD 83 DUP4 1DDE 60 PUSH1 0x20 1DE0 83 DUP4 1DE1 01 ADD 1DE2 37 CALLDATACOPY 1DE3 60 PUSH1 0x00 1DE5 60 PUSH1 0x20 1DE7 85 DUP6 1DE8 83 DUP4 1DE9 01 ADD 1DEA 01 ADD 1DEB 52 MSTORE 1DEC 50 POP 1DED 93 SWAP4 1DEE 92 SWAP3 1DEF 50 POP 1DF0 50 POP 1DF1 50 POP 1DF2 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1DE2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-4]] = msg.data[stack[-3]:stack[-3] + stack[-4]] // @1DEB memory[stack[-1] + stack[-4] + 0x20:stack[-1] + stack[-4] + 0x20 + 0x20] = 0x00 // @1DED stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-6] label_1DF3: // Incoming jump from 0x211A // Incoming jump from 0x22DA // Incoming jump from 0x1EAE // Incoming jump from 0x20E5 // Incoming jump from 0x2236 // Inputs[2] // { // @1DF6 stack[-2] // @1DF9 stack[-1] // } 1DF3 5B JUMPDEST 1DF4 60 PUSH1 0x00 1DF6 82 DUP3 1DF7 60 PUSH1 0x1f 1DF9 83 DUP4 1DFA 01 ADD 1DFB 12 SLT 1DFC 61 PUSH2 0x1e04 1DFF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DF4 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e04, if stack[-1] + 0x1f i< stack[-2] label_1E00: // Incoming jump from 0x1DFF, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1E03 memory[0x00:0x00] } 1E00 60 PUSH1 0x00 1E02 80 DUP1 1E03 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E03 revert(memory[0x00:0x00]); } // Block terminates label_1E04: // Incoming jump from 0x1DFF, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1E08 stack[-3] // @1E09 stack[-2] // @1E0A msg.data[stack[-2]:stack[-2] + 0x20] // } 1E04 5B JUMPDEST 1E05 61 PUSH2 0x1303 1E08 83 DUP4 1E09 83 DUP4 1E0A 35 CALLDATALOAD 1E0B 60 PUSH1 0x20 1E0D 85 DUP6 1E0E 01 ADD 1E0F 61 PUSH2 0x1d96 1E12 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E05 stack[0] = 0x1303 // @1E08 stack[1] = stack[-3] // @1E0A stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @1E0E stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x1d96, returns to 0x1303 label_1E13: // Incoming jump from 0x020D // Inputs[2] // { // @1E1E stack[-1] // @1E1F stack[-2] // } 1E13 5B JUMPDEST 1E14 60 PUSH1 0x00 1E16 80 DUP1 1E17 60 PUSH1 0x00 1E19 80 DUP1 1E1A 60 PUSH1 0x00 1E1C 60 PUSH1 0xa0 1E1E 86 DUP7 1E1F 88 DUP9 1E20 03 SUB 1E21 12 SLT 1E22 15 ISZERO 1E23 61 PUSH2 0x1e2b 1E26 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1E14 stack[0] = 0x00 // @1E16 stack[1] = 0x00 // @1E17 stack[2] = 0x00 // @1E19 stack[3] = 0x00 // @1E1A stack[4] = 0x00 // } // Block ends with conditional jump to 0x1e2b, if !(stack[-2] - stack[-1] i< 0xa0) label_1E27: // Incoming jump from 0x1E26, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1E2A memory[0x00:0x00] } 1E27 60 PUSH1 0x00 1E29 80 DUP1 1E2A FD *REVERT // Stack delta = +0 // Outputs[1] { @1E2A revert(memory[0x00:0x00]); } // Block terminates label_1E2B: // Incoming jump from 0x1E26, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1E2F stack[-6] } 1E2B 5B JUMPDEST 1E2C 61 PUSH2 0x1e34 1E2F 86 DUP7 1E30 61 PUSH2 0x1a86 1E33 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E2C stack[0] = 0x1e34 // @1E2F stack[1] = stack[-6] // } // Block ends with call to 0x1a86, returns to 0x1E34 label_1E34: // Incoming return from call to 0x1A86 at 0x1E33 // Inputs[3] // { // @1E35 stack[-1] // @1E35 stack[-6] // @1E3C stack[-7] // } 1E34 5B JUMPDEST 1E35 94 SWAP5 1E36 50 POP 1E37 61 PUSH2 0x1e42 1E3A 60 PUSH1 0x20 1E3C 87 DUP8 1E3D 01 ADD 1E3E 61 PUSH2 0x1a86 1E41 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1E35 stack[-6] = stack[-1] // @1E37 stack[-1] = 0x1e42 // @1E3D stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1a86, returns to 0x1E42 label_1E42: // Incoming return from call to 0x1A86 at 0x1E41 // Inputs[4] // { // @1E43 stack[-1] // @1E43 stack[-5] // @1E47 stack[-7] // @1E49 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 1E42 5B JUMPDEST 1E43 93 SWAP4 1E44 50 POP 1E45 60 PUSH1 0x40 1E47 86 DUP7 1E48 01 ADD 1E49 35 CALLDATALOAD 1E4A 60 PUSH1 0x01 1E4C 60 PUSH1 0x01 1E4E 60 PUSH1 0x40 1E50 1B SHL 1E51 03 SUB 1E52 80 DUP1 1E53 82 DUP3 1E54 11 GT 1E55 15 ISZERO 1E56 61 PUSH2 0x1e5e 1E59 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1E43 stack[-5] = stack[-1] // @1E49 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1E51 stack[0] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1e5e, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) label_1E5A: // Incoming jump from 0x1E59, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1E5D memory[0x00:0x00] } 1E5A 60 PUSH1 0x00 1E5C 80 DUP1 1E5D FD *REVERT // Stack delta = +0 // Outputs[1] { @1E5D revert(memory[0x00:0x00]); } // Block terminates label_1E5E: // Incoming jump from 0x1E59, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1E62 stack[-9] // @1E63 stack[-2] // @1E64 stack[-8] // } 1E5E 5B JUMPDEST 1E5F 61 PUSH2 0x1e6a 1E62 89 DUP10 1E63 83 DUP4 1E64 8A DUP11 1E65 01 ADD 1E66 61 PUSH2 0x1b64 1E69 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E5F stack[0] = 0x1e6a // @1E62 stack[1] = stack[-9] // @1E65 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x1E6A label_1E6A: // Incoming return from call to 0x1B64 at 0x1E69 // Inputs[6] // { // @1E6B stack[-1] // @1E6B stack[-6] // @1E6F stack[-9] // @1E71 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @1E72 stack[-3] // @1E74 stack[-2] // } 1E6A 5B JUMPDEST 1E6B 94 SWAP5 1E6C 50 POP 1E6D 60 PUSH1 0x60 1E6F 88 DUP9 1E70 01 ADD 1E71 35 CALLDATALOAD 1E72 91 SWAP2 1E73 50 POP 1E74 80 DUP1 1E75 82 DUP3 1E76 11 GT 1E77 15 ISZERO 1E78 61 PUSH2 0x1e80 1E7B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1E6B stack[-6] = stack[-1] // @1E72 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1e80, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_1E7C: // Incoming jump from 0x1E7B, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @1E7F memory[0x00:0x00] } 1E7C 60 PUSH1 0x00 1E7E 80 DUP1 1E7F FD *REVERT // Stack delta = +0 // Outputs[1] { @1E7F revert(memory[0x00:0x00]); } // Block terminates label_1E80: // Incoming jump from 0x1E7B, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @1E84 stack[-9] // @1E85 stack[-2] // @1E86 stack[-8] // } 1E80 5B JUMPDEST 1E81 61 PUSH2 0x1e8c 1E84 89 DUP10 1E85 83 DUP4 1E86 8A DUP11 1E87 01 ADD 1E88 61 PUSH2 0x1b64 1E8B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E81 stack[0] = 0x1e8c // @1E84 stack[1] = stack[-9] // @1E87 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x1E8C label_1E8C: // Incoming return from call to 0x1B64 at 0x1E8B // Inputs[6] // { // @1E8D stack[-5] // @1E8D stack[-1] // @1E91 stack[-9] // @1E93 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @1E94 stack[-3] // @1E96 stack[-2] // } 1E8C 5B JUMPDEST 1E8D 93 SWAP4 1E8E 50 POP 1E8F 60 PUSH1 0x80 1E91 88 DUP9 1E92 01 ADD 1E93 35 CALLDATALOAD 1E94 91 SWAP2 1E95 50 POP 1E96 80 DUP1 1E97 82 DUP3 1E98 11 GT 1E99 15 ISZERO 1E9A 61 PUSH2 0x1ea2 1E9D 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1E8D stack[-5] = stack[-1] // @1E94 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1ea2, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_1E9E: // Incoming jump from 0x1E9D, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @1EA1 memory[0x00:0x00] } 1E9E 60 PUSH1 0x00 1EA0 80 DUP1 1EA1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EA1 revert(memory[0x00:0x00]); } // Block terminates label_1EA2: // Incoming jump from 0x1E9D, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @1EA7 stack[-9] // @1EA8 stack[-2] // @1EA9 stack[-8] // } 1EA2 5B JUMPDEST 1EA3 50 POP 1EA4 61 PUSH2 0x1eaf 1EA7 88 DUP9 1EA8 82 DUP3 1EA9 89 DUP10 1EAA 01 ADD 1EAB 61 PUSH2 0x1df3 1EAE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1EA4 stack[-1] = 0x1eaf // @1EA7 stack[0] = stack[-9] // @1EAA stack[1] = stack[-8] + stack[-2] // } // Block ends with unconditional jump to 0x1df3 1EAF 5B JUMPDEST 1EB0 91 SWAP2 1EB1 50 POP 1EB2 50 POP 1EB3 92 SWAP3 1EB4 95 SWAP6 1EB5 50 POP 1EB6 92 SWAP3 1EB7 95 SWAP6 1EB8 90 SWAP1 1EB9 93 SWAP4 1EBA 50 POP 1EBB 56 *JUMP label_1EBC: // Incoming call from 0x0220, returns to 0x0221 // Inputs[2] // { // @1EC2 stack[-1] // @1EC3 stack[-2] // } 1EBC 5B JUMPDEST 1EBD 60 PUSH1 0x00 1EBF 80 DUP1 1EC0 60 PUSH1 0x40 1EC2 83 DUP4 1EC3 85 DUP6 1EC4 03 SUB 1EC5 12 SLT 1EC6 15 ISZERO 1EC7 61 PUSH2 0x1ecf 1ECA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EBD stack[0] = 0x00 // @1EBF stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ecf, if !(stack[-2] - stack[-1] i< 0x40) label_1ECB: // Incoming jump from 0x1ECA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1ECE memory[0x00:0x00] } 1ECB 60 PUSH1 0x00 1ECD 80 DUP1 1ECE FD *REVERT // Stack delta = +0 // Outputs[1] { @1ECE revert(memory[0x00:0x00]); } // Block terminates label_1ECF: // Incoming jump from 0x1ECA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1ED0 stack[-3] // @1ED1 msg.data[stack[-3]:stack[-3] + 0x20] // } 1ECF 5B JUMPDEST 1ED0 82 DUP3 1ED1 35 CALLDATALOAD 1ED2 60 PUSH1 0x01 1ED4 60 PUSH1 0x01 1ED6 60 PUSH1 0x40 1ED8 1B SHL 1ED9 03 SUB 1EDA 80 DUP1 1EDB 82 DUP3 1EDC 11 GT 1EDD 15 ISZERO 1EDE 61 PUSH2 0x1ee6 1EE1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ED1 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1ED9 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1ee6, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_1EE2: // Incoming jump from 0x1EE1, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1EE5 memory[0x00:0x00] } 1EE2 60 PUSH1 0x00 1EE4 80 DUP1 1EE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EE5 revert(memory[0x00:0x00]); } // Block terminates label_1EE6: // Incoming jump from 0x1EE1, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1EE7 stack[-2] // @1EE8 stack[-5] // @1EEC stack[-6] // } 1EE6 5B JUMPDEST 1EE7 81 DUP2 1EE8 85 DUP6 1EE9 01 ADD 1EEA 91 SWAP2 1EEB 50 POP 1EEC 85 DUP6 1EED 60 PUSH1 0x1f 1EEF 83 DUP4 1EF0 01 ADD 1EF1 12 SLT 1EF2 61 PUSH2 0x1efa 1EF5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EEA stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1efa, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1EF6: // Incoming jump from 0x1EF5, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @1EF9 memory[0x00:0x00] } 1EF6 60 PUSH1 0x00 1EF8 80 DUP1 1EF9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF9 revert(memory[0x00:0x00]); } // Block terminates label_1EFA: // Incoming jump from 0x1EF5, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1EFB stack[-2] // @1EFC msg.data[stack[-2]:stack[-2] + 0x20] // } 1EFA 5B JUMPDEST 1EFB 81 DUP2 1EFC 35 CALLDATALOAD 1EFD 60 PUSH1 0x20 1EFF 61 PUSH2 0x1f07 1F02 82 DUP3 1F03 61 PUSH2 0x1b41 1F06 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EFC stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1EFD stack[1] = 0x20 // @1EFF stack[2] = 0x1f07 // @1F02 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1b41, returns to 0x1F07 label_1F07: // Incoming return from call to 0x1B41 at 0x1F06 // Inputs[2] // { // @1F0A memory[0x40:0x60] // @1F0E stack[-1] // } 1F07 5B JUMPDEST 1F08 60 PUSH1 0x40 1F0A 51 MLOAD 1F0B 61 PUSH2 0x1f14 1F0E 82 DUP3 1F0F 82 DUP3 1F10 61 PUSH2 0x1b15 1F13 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F0A stack[0] = memory[0x40:0x60] // @1F0B stack[1] = 0x1f14 // @1F0E stack[2] = stack[-1] // @1F0F stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1b15, returns to 0x1F14 label_1F14: // Incoming return from call to 0x1B15 at 0x1F13 // Inputs[6] // { // @1F15 stack[-4] // @1F16 stack[-1] // @1F1E stack[-6] // @1F20 stack[-3] // @1F26 stack[-2] // @1F28 stack[-10] // } 1F14 5B JUMPDEST 1F15 83 DUP4 1F16 81 DUP2 1F17 52 MSTORE 1F18 60 PUSH1 0x05 1F1A 93 SWAP4 1F1B 90 SWAP1 1F1C 93 SWAP4 1F1D 1B SHL 1F1E 85 DUP6 1F1F 01 ADD 1F20 82 DUP3 1F21 01 ADD 1F22 92 SWAP3 1F23 82 DUP3 1F24 81 DUP2 1F25 01 ADD 1F26 91 SWAP2 1F27 50 POP 1F28 89 DUP10 1F29 84 DUP5 1F2A 11 GT 1F2B 15 ISZERO 1F2C 61 PUSH2 0x1f34 1F2F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1F17 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1F22 stack[-1] = stack[-1] // @1F22 stack[-4] = stack[-3] + stack[-6] + (stack[-4] << 0x05) // @1F26 stack[-2] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1f34, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-10]) label_1F30: // Incoming jump from 0x1F2F, if not !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-10]) // Inputs[1] { @1F33 memory[0x00:0x00] } 1F30 60 PUSH1 0x00 1F32 80 DUP1 1F33 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F33 revert(memory[0x00:0x00]); } // Block terminates label_1F34: // Incoming jump from 0x1F2F, if !(stack[-3] + stack[-6] + (stack[-4] << 0x05) > stack[-10]) // Inputs[4] // { // @1F35 stack[-1] // @1F35 stack[-6] // @1F36 stack[-3] // @1F3A stack[-4] // } 1F34 5B JUMPDEST 1F35 94 SWAP5 1F36 82 DUP3 1F37 01 ADD 1F38 94 SWAP5 1F39 5B JUMPDEST 1F3A 83 DUP4 1F3B 86 DUP7 1F3C 10 LT 1F3D 15 ISZERO 1F3E 61 PUSH2 0x1f59 1F41 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1F38 stack[-1] = stack[-1] // @1F38 stack[-6] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1f59, if !(stack[-3] + stack[-6] < stack[-4]) label_1F42: // Incoming jump from 0x1F41, if not !(stack[-6] < stack[-4]) // Incoming jump from 0x1F41, if not !(stack[-3] + stack[-6] < stack[-4]) // Inputs[1] { @1F45 stack[-6] } 1F42 61 PUSH2 0x1f4a 1F45 86 DUP7 1F46 61 PUSH2 0x1a86 1F49 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F42 stack[0] = 0x1f4a // @1F45 stack[1] = stack[-6] // } // Block ends with call to 0x1a86, returns to 0x1F4A label_1F4A: // Incoming return from call to 0x1A86 at 0x1F49 // Inputs[5] // { // @1F4B stack[-3] // @1F4C stack[-1] // @1F4D stack[-7] // @1F4D stack[-2] // @1F4E stack[-4] // } 1F4A 5B JUMPDEST 1F4B 82 DUP3 1F4C 52 MSTORE 1F4D 94 SWAP5 1F4E 82 DUP3 1F4F 01 ADD 1F50 94 SWAP5 1F51 90 SWAP1 1F52 82 DUP3 1F53 01 ADD 1F54 90 SWAP1 1F55 61 PUSH2 0x1f39 1F58 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1F4C memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @1F50 stack[-7] = stack[-4] + stack[-7] // @1F54 stack[-2] = stack[-2] // @1F54 stack[-3] = stack[-4] + stack[-3] // } // Block ends with unconditional jump to 0x1f39 label_1F59: // Incoming jump from 0x1F41, if !(stack[-6] < stack[-4]) // Incoming jump from 0x1F41, if !(stack[-3] + stack[-6] < stack[-4]) // Inputs[7] // { // @1F5A stack[-1] // @1F5A stack[-8] // @1F5D stack[-9] // @1F5E stack[-3] // @1F5F msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] // @1F60 stack[-6] // @1F63 stack[-5] // } 1F59 5B JUMPDEST 1F5A 96 SWAP7 1F5B 50 POP 1F5C 50 POP 1F5D 86 DUP7 1F5E 01 ADD 1F5F 35 CALLDATALOAD 1F60 92 SWAP3 1F61 50 POP 1F62 50 POP 1F63 80 DUP1 1F64 82 DUP3 1F65 11 GT 1F66 15 ISZERO 1F67 61 PUSH2 0x1f6f 1F6A 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @1F5A stack[-8] = stack[-1] // @1F60 stack[-6] = msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x1f6f, if !(msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] > stack[-5]) label_1F6B: // Incoming jump from 0x1F6A, if not !(msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] > stack[-5]) // Inputs[1] { @1F6E memory[0x00:0x00] } 1F6B 60 PUSH1 0x00 1F6D 80 DUP1 1F6E FD *REVERT // Stack delta = +0 // Outputs[1] { @1F6E revert(memory[0x00:0x00]); } // Block terminates label_1F6F: // Incoming jump from 0x1F6A, if !(msg.data[stack[-9] + stack[-3]:stack[-9] + stack[-3] + 0x20] > stack[-5]) // Inputs[3] // { // @1F74 stack[-6] // @1F75 stack[-2] // @1F76 stack[-5] // } 1F6F 5B JUMPDEST 1F70 50 POP 1F71 61 PUSH2 0x1f7c 1F74 85 DUP6 1F75 82 DUP3 1F76 86 DUP7 1F77 01 ADD 1F78 61 PUSH2 0x1b64 1F7B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1F71 stack[-1] = 0x1f7c // @1F74 stack[0] = stack[-6] // @1F77 stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x1F7C label_1F7C: // Incoming return from call to 0x1B64 at 0x1F7B // Inputs[6] // { // @1F7D stack[-3] // @1F7D stack[-1] // @1F80 stack[-6] // @1F82 stack[-7] // @1F82 stack[-4] // @1F83 stack[-5] // } 1F7C 5B JUMPDEST 1F7D 91 SWAP2 1F7E 50 POP 1F7F 50 POP 1F80 92 SWAP3 1F81 50 POP 1F82 92 SWAP3 1F83 90 SWAP1 1F84 50 POP 1F85 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1F80 stack[-6] = stack[-1] // @1F82 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1F86: // Incoming call from 0x2477, returns to 0x2478 // Incoming call from 0x26D9, returns to 0x26DA // Incoming call from 0x1FD3, returns to 0x1303 // Incoming call from 0x26C7, returns to 0x26C8 // Incoming call from 0x2465, returns to 0x2466 // Inputs[3] // { // @1F89 stack[-1] // @1F8A memory[stack[-1]:stack[-1] + 0x20] // @1F8C stack[-2] // } 1F86 5B JUMPDEST 1F87 60 PUSH1 0x00 1F89 81 DUP2 1F8A 51 MLOAD 1F8B 80 DUP1 1F8C 84 DUP5 1F8D 52 MSTORE 1F8E 60 PUSH1 0x20 1F90 80 DUP1 1F91 85 DUP6 1F92 01 ADD 1F93 94 SWAP5 1F94 50 POP 1F95 80 DUP1 1F96 84 DUP5 1F97 01 ADD 1F98 60 PUSH1 0x00 1F9A 5B JUMPDEST 1F9B 83 DUP4 1F9C 81 DUP2 1F9D 10 LT 1F9E 15 ISZERO 1F9F 61 PUSH2 0x1fb6 1FA2 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @1F87 stack[0] = 0x00 // @1F8A stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1F8D memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1F8E stack[2] = 0x20 // @1F93 stack[-2] = stack[-2] + 0x20 // @1F97 stack[3] = stack[-1] + 0x20 // @1F98 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1fb6, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1FA3: // Incoming jump from 0x1FA2, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1FA2, if not !(stack[-1] < stack[-4]) // Inputs[5] // { // @1FA3 stack[-2] // @1FA4 memory[stack[-2]:stack[-2] + 0x20] // @1FA5 stack[-7] // @1FA7 stack[-1] // @1FA8 stack[-3] // } 1FA3 81 DUP2 1FA4 51 MLOAD 1FA5 87 DUP8 1FA6 52 MSTORE 1FA7 95 SWAP6 1FA8 82 DUP3 1FA9 01 ADD 1FAA 95 SWAP6 1FAB 90 SWAP1 1FAC 82 DUP3 1FAD 01 ADD 1FAE 90 SWAP1 1FAF 60 PUSH1 0x01 1FB1 01 ADD 1FB2 61 PUSH2 0x1f9a 1FB5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1FA6 memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1FAA stack[-7] = stack[-3] + stack[-7] // @1FAE stack[-2] = stack[-3] + stack[-2] // @1FB1 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f9a label_1FB6: // Incoming jump from 0x1FA2, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1FA2, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1FB8 stack[-7] // @1FB8 stack[-2] // @1FB9 stack[-8] // } 1FB6 5B JUMPDEST 1FB7 50 POP 1FB8 94 SWAP5 1FB9 95 SWAP6 1FBA 94 SWAP5 1FBB 50 POP 1FBC 50 POP 1FBD 50 POP 1FBE 50 POP 1FBF 50 POP 1FC0 56 *JUMP // Stack delta = -7 // Outputs[1] { @1FB9 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1FC1: // Incoming jump from 0x0232 // Inputs[2] // { // @1FC4 stack[-1] // @1FCF stack[-2] // } 1FC1 5B JUMPDEST 1FC2 60 PUSH1 0x20 1FC4 81 DUP2 1FC5 52 MSTORE 1FC6 60 PUSH1 0x00 1FC8 61 PUSH2 0x1303 1FCB 60 PUSH1 0x20 1FCD 83 DUP4 1FCE 01 ADD 1FCF 84 DUP5 1FD0 61 PUSH2 0x1f86 1FD3 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1FC5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1FC6 stack[0] = 0x00 // @1FC8 stack[1] = 0x1303 // @1FCE stack[2] = stack[-1] + 0x20 // @1FCF stack[3] = stack[-2] // } // Block ends with call to 0x1f86, returns to 0x1303 label_1FD4: // Incoming call from 0x0240, returns to 0x0241 // Inputs[2] // { // @1FD9 stack[-1] // @1FDA stack[-2] // } 1FD4 5B JUMPDEST 1FD5 60 PUSH1 0x00 1FD7 60 PUSH1 0x20 1FD9 82 DUP3 1FDA 84 DUP5 1FDB 03 SUB 1FDC 12 SLT 1FDD 15 ISZERO 1FDE 61 PUSH2 0x1fe6 1FE1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FD5 stack[0] = 0x00 } // Block ends with conditional jump to 0x1fe6, if !(stack[-2] - stack[-1] i< 0x20) label_1FE2: // Incoming jump from 0x1FE1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1FE5 memory[0x00:0x00] } 1FE2 60 PUSH1 0x00 1FE4 80 DUP1 1FE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FE5 revert(memory[0x00:0x00]); } // Block terminates label_1FE6: // Incoming jump from 0x1FE1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1FE7 stack[-2] // @1FE8 msg.data[stack[-2]:stack[-2] + 0x20] // } 1FE6 5B JUMPDEST 1FE7 81 DUP2 1FE8 35 CALLDATALOAD 1FE9 60 PUSH1 0x01 1FEB 60 PUSH1 0x01 1FED 60 PUSH1 0x40 1FEF 1B SHL 1FF0 03 SUB 1FF1 81 DUP2 1FF2 11 GT 1FF3 15 ISZERO 1FF4 61 PUSH2 0x1ffc 1FF7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FE8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1ffc, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_1FF8: // Incoming jump from 0x1FF7, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @1FFB memory[0x00:0x00] } 1FF8 60 PUSH1 0x00 1FFA 80 DUP1 1FFB FD *REVERT // Stack delta = +0 // Outputs[1] { @1FFB revert(memory[0x00:0x00]); } // Block terminates label_1FFC: // Incoming jump from 0x1FF7, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1FFD stack[-3] // @1FFE stack[-1] // @2003 stack[-4] // } 1FFC 5B JUMPDEST 1FFD 82 DUP3 1FFE 01 ADD 1FFF 60 PUSH1 0x1f 2001 81 DUP2 2002 01 ADD 2003 84 DUP5 2004 13 SGT 2005 61 PUSH2 0x200d 2008 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1FFE stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x200d, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2009: // Incoming jump from 0x2008, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @200C memory[0x00:0x00] } 2009 60 PUSH1 0x00 200B 80 DUP1 200C FD *REVERT // Stack delta = +0 // Outputs[1] { @200C revert(memory[0x00:0x00]); } // Block terminates label_200D: // Incoming jump from 0x2008, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2011 stack[-4] // @2012 stack[-1] // @2013 msg.data[stack[-1]:stack[-1] + 0x20] // } 200D 5B JUMPDEST 200E 61 PUSH2 0x08c2 2011 84 DUP5 2012 82 DUP3 2013 35 CALLDATALOAD 2014 60 PUSH1 0x20 2016 84 DUP5 2017 01 ADD 2018 61 PUSH2 0x1d96 201B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @200E stack[0] = 0x08c2 // @2011 stack[1] = stack[-4] // @2013 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2017 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1d96, returns to 0x08C2 label_201C: // Incoming call from 0x0253, returns to 0x0254 // Inputs[2] // { // @2024 stack[-1] // @2025 stack[-2] // } 201C 5B JUMPDEST 201D 60 PUSH1 0x00 201F 80 DUP1 2020 60 PUSH1 0x00 2022 60 PUSH1 0x60 2024 84 DUP5 2025 86 DUP7 2026 03 SUB 2027 12 SLT 2028 15 ISZERO 2029 61 PUSH2 0x2031 202C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @201D stack[0] = 0x00 // @201F stack[1] = 0x00 // @2020 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2031, if !(stack[-2] - stack[-1] i< 0x60) label_202D: // Incoming jump from 0x202C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2030 memory[0x00:0x00] } 202D 60 PUSH1 0x00 202F 80 DUP1 2030 FD *REVERT // Stack delta = +0 // Outputs[1] { @2030 revert(memory[0x00:0x00]); } // Block terminates label_2031: // Incoming jump from 0x202C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2035 stack[-4] } 2031 5B JUMPDEST 2032 61 PUSH2 0x203a 2035 84 DUP5 2036 61 PUSH2 0x1a86 2039 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2032 stack[0] = 0x203a // @2035 stack[1] = stack[-4] // } // Block ends with call to 0x1a86, returns to 0x203A label_203A: // Incoming return from call to 0x1A86 at 0x2039 // Inputs[4] // { // @203B stack[-1] // @203B stack[-4] // @203F stack[-5] // @2041 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 203A 5B JUMPDEST 203B 92 SWAP3 203C 50 POP 203D 60 PUSH1 0x20 203F 84 DUP5 2040 01 ADD 2041 35 CALLDATALOAD 2042 60 PUSH1 0x01 2044 60 PUSH1 0x01 2046 60 PUSH1 0x40 2048 1B SHL 2049 03 SUB 204A 80 DUP1 204B 82 DUP3 204C 11 GT 204D 15 ISZERO 204E 61 PUSH2 0x2056 2051 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @203B stack[-4] = stack[-1] // @2041 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2049 stack[0] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x2056, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_2052: // Incoming jump from 0x2051, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2055 memory[0x00:0x00] } 2052 60 PUSH1 0x00 2054 80 DUP1 2055 FD *REVERT // Stack delta = +0 // Outputs[1] { @2055 revert(memory[0x00:0x00]); } // Block terminates label_2056: // Incoming jump from 0x2051, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @205A stack[-7] // @205B stack[-2] // @205C stack[-6] // } 2056 5B JUMPDEST 2057 61 PUSH2 0x2062 205A 87 DUP8 205B 83 DUP4 205C 88 DUP9 205D 01 ADD 205E 61 PUSH2 0x1b64 2061 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2057 stack[0] = 0x2062 // @205A stack[1] = stack[-7] // @205D stack[2] = stack[-6] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x2062 label_2062: // Incoming return from call to 0x1B64 at 0x2061 // Inputs[6] // { // @2063 stack[-1] // @2063 stack[-5] // @2067 stack[-7] // @2069 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @206A stack[-3] // @206C stack[-2] // } 2062 5B JUMPDEST 2063 93 SWAP4 2064 50 POP 2065 60 PUSH1 0x40 2067 86 DUP7 2068 01 ADD 2069 35 CALLDATALOAD 206A 91 SWAP2 206B 50 POP 206C 80 DUP1 206D 82 DUP3 206E 11 GT 206F 15 ISZERO 2070 61 PUSH2 0x2078 2073 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2063 stack[-5] = stack[-1] // @206A stack[-3] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2078, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) label_2074: // Incoming jump from 0x2073, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) // Inputs[1] { @2077 memory[0x00:0x00] } 2074 60 PUSH1 0x00 2076 80 DUP1 2077 FD *REVERT // Stack delta = +0 // Outputs[1] { @2077 revert(memory[0x00:0x00]); } // Block terminates label_2078: // Incoming jump from 0x2073, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > stack[-2]) // Inputs[3] // { // @207D stack[-7] // @207E stack[-2] // @207F stack[-6] // } 2078 5B JUMPDEST 2079 50 POP 207A 61 PUSH2 0x2085 207D 86 DUP7 207E 82 DUP3 207F 87 DUP8 2080 01 ADD 2081 61 PUSH2 0x1b64 2084 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @207A stack[-1] = 0x2085 // @207D stack[0] = stack[-7] // @2080 stack[1] = stack[-6] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x2085 label_2085: // Incoming return from call to 0x1B64 at 0x2084 // Inputs[7] // { // @2086 stack[-3] // @2086 stack[-1] // @2089 stack[-6] // @208B stack[-4] // @208B stack[-7] // @208D stack[-8] // @208D stack[-5] // } 2085 5B JUMPDEST 2086 91 SWAP2 2087 50 POP 2088 50 POP 2089 92 SWAP3 208A 50 POP 208B 92 SWAP3 208C 50 POP 208D 92 SWAP3 208E 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2089 stack[-6] = stack[-1] // @208B stack[-7] = stack[-4] // @208D stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_208F: // Incoming call from 0x0367, returns to 0x0368 // Incoming call from 0x026E, returns to 0x026F // Incoming call from 0x04B6, returns to 0x04B7 // Inputs[2] // { // @2094 stack[-1] // @2095 stack[-2] // } 208F 5B JUMPDEST 2090 60 PUSH1 0x00 2092 60 PUSH1 0x20 2094 82 DUP3 2095 84 DUP5 2096 03 SUB 2097 12 SLT 2098 15 ISZERO 2099 61 PUSH2 0x20a1 209C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2090 stack[0] = 0x00 } // Block ends with conditional jump to 0x20a1, if !(stack[-2] - stack[-1] i< 0x20) label_209D: // Incoming jump from 0x209C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20A0 memory[0x00:0x00] } 209D 60 PUSH1 0x00 209F 80 DUP1 20A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @20A0 revert(memory[0x00:0x00]); } // Block terminates label_20A1: // Incoming jump from 0x209C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20A5 stack[-2] } 20A1 5B JUMPDEST 20A2 61 PUSH2 0x1303 20A5 82 DUP3 20A6 61 PUSH2 0x1a86 20A9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20A2 stack[0] = 0x1303 // @20A5 stack[1] = stack[-2] // } // Block ends with call to 0x1a86, returns to 0x1303 label_20AA: // Incoming jump from 0x02B9 // Inputs[2] // { // @20B0 stack[-1] // @20B1 stack[-2] // } 20AA 5B JUMPDEST 20AB 60 PUSH1 0x00 20AD 80 DUP1 20AE 60 PUSH1 0x40 20B0 83 DUP4 20B1 85 DUP6 20B2 03 SUB 20B3 12 SLT 20B4 15 ISZERO 20B5 61 PUSH2 0x20bd 20B8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20AB stack[0] = 0x00 // @20AD stack[1] = 0x00 // } // Block ends with conditional jump to 0x20bd, if !(stack[-2] - stack[-1] i< 0x40) label_20B9: // Incoming jump from 0x20B8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20BC memory[0x00:0x00] } 20B9 60 PUSH1 0x00 20BB 80 DUP1 20BC FD *REVERT // Stack delta = +0 // Outputs[1] { @20BC revert(memory[0x00:0x00]); } // Block terminates label_20BD: // Incoming jump from 0x20B8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @20BE stack[-3] // @20BF msg.data[stack[-3]:stack[-3] + 0x20] // @20C0 stack[-2] // @20C6 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 20BD 5B JUMPDEST 20BE 82 DUP3 20BF 35 CALLDATALOAD 20C0 91 SWAP2 20C1 50 POP 20C2 60 PUSH1 0x20 20C4 83 DUP4 20C5 01 ADD 20C6 35 CALLDATALOAD 20C7 60 PUSH1 0x01 20C9 60 PUSH1 0x01 20CB 60 PUSH1 0x40 20CD 1B SHL 20CE 03 SUB 20CF 81 DUP2 20D0 11 GT 20D1 15 ISZERO 20D2 61 PUSH2 0x20da 20D5 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @20C0 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @20C6 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x20da, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_20D6: // Incoming jump from 0x20D5, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @20D9 memory[0x00:0x00] } 20D6 60 PUSH1 0x00 20D8 80 DUP1 20D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @20D9 revert(memory[0x00:0x00]); } // Block terminates label_20DA: // Incoming jump from 0x20D5, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @20DE stack[-5] // @20DF stack[-1] // @20E0 stack[-4] // } 20DA 5B JUMPDEST 20DB 61 PUSH2 0x1f7c 20DE 85 DUP6 20DF 82 DUP3 20E0 86 DUP7 20E1 01 ADD 20E2 61 PUSH2 0x1df3 20E5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20DB stack[0] = 0x1f7c // @20DE stack[1] = stack[-5] // @20E1 stack[2] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x1df3 label_20E6: // Incoming jump from 0x02CC // Inputs[2] // { // @20EC stack[-1] // @20ED stack[-2] // } 20E6 5B JUMPDEST 20E7 60 PUSH1 0x00 20E9 80 DUP1 20EA 60 PUSH1 0x40 20EC 83 DUP4 20ED 85 DUP6 20EE 03 SUB 20EF 12 SLT 20F0 15 ISZERO 20F1 61 PUSH2 0x20f9 20F4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20E7 stack[0] = 0x00 // @20E9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x20f9, if !(stack[-2] - stack[-1] i< 0x40) label_20F5: // Incoming jump from 0x20F4, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20F8 memory[0x00:0x00] } 20F5 60 PUSH1 0x00 20F7 80 DUP1 20F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F8 revert(memory[0x00:0x00]); } // Block terminates label_20F9: // Incoming jump from 0x20F4, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @20FA stack[-3] // @20FB msg.data[stack[-3]:stack[-3] + 0x20] // } 20F9 5B JUMPDEST 20FA 82 DUP3 20FB 35 CALLDATALOAD 20FC 60 PUSH1 0x01 20FE 60 PUSH1 0x01 2100 60 PUSH1 0x40 2102 1B SHL 2103 03 SUB 2104 81 DUP2 2105 11 GT 2106 15 ISZERO 2107 61 PUSH2 0x210f 210A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20FB stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x210f, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_210B: // Incoming jump from 0x210A, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @210E memory[0x00:0x00] } 210B 60 PUSH1 0x00 210D 80 DUP1 210E FD *REVERT // Stack delta = +0 // Outputs[1] { @210E revert(memory[0x00:0x00]); } // Block terminates label_210F: // Incoming jump from 0x210A, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2113 stack[-5] // @2114 stack[-1] // @2115 stack[-4] // } 210F 5B JUMPDEST 2110 61 PUSH2 0x211b 2113 85 DUP6 2114 82 DUP3 2115 86 DUP7 2116 01 ADD 2117 61 PUSH2 0x1df3 211A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2110 stack[0] = 0x211b // @2113 stack[1] = stack[-5] // @2116 stack[2] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x1df3 211B 5B JUMPDEST 211C 95 SWAP6 211D 60 PUSH1 0x20 211F 94 SWAP5 2120 90 SWAP1 2121 94 SWAP5 2122 01 ADD 2123 35 CALLDATALOAD 2124 94 SWAP5 2125 50 POP 2126 50 POP 2127 50 POP 2128 50 POP 2129 56 *JUMP label_212A: // Incoming call from 0x02DF, returns to 0x02E0 // Inputs[2] // { // @2130 stack[-1] // @2131 stack[-2] // } 212A 5B JUMPDEST 212B 60 PUSH1 0x00 212D 80 DUP1 212E 60 PUSH1 0x40 2130 83 DUP4 2131 85 DUP6 2132 03 SUB 2133 12 SLT 2134 15 ISZERO 2135 61 PUSH2 0x213d 2138 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @212B stack[0] = 0x00 // @212D stack[1] = 0x00 // } // Block ends with conditional jump to 0x213d, if !(stack[-2] - stack[-1] i< 0x40) label_2139: // Incoming jump from 0x2138, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @213C memory[0x00:0x00] } 2139 60 PUSH1 0x00 213B 80 DUP1 213C FD *REVERT // Stack delta = +0 // Outputs[1] { @213C revert(memory[0x00:0x00]); } // Block terminates label_213D: // Incoming jump from 0x2138, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2141 stack[-3] } 213D 5B JUMPDEST 213E 61 PUSH2 0x2146 2141 83 DUP4 2142 61 PUSH2 0x1a86 2145 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @213E stack[0] = 0x2146 // @2141 stack[1] = stack[-3] // } // Block ends with call to 0x1a86, returns to 0x2146 label_2146: // Incoming return from call to 0x1A86 at 0x2145 // Inputs[4] // { // @2147 stack[-1] // @2147 stack[-3] // @214B stack[-4] // @214D msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2146 5B JUMPDEST 2147 91 SWAP2 2148 50 POP 2149 60 PUSH1 0x20 214B 83 DUP4 214C 01 ADD 214D 35 CALLDATALOAD 214E 80 DUP1 214F 15 ISZERO 2150 15 ISZERO 2151 81 DUP2 2152 14 EQ 2153 61 PUSH2 0x215b 2156 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2147 stack[-3] = stack[-1] // @214D stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x215b, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_2157: // Incoming jump from 0x2156, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @215A memory[0x00:0x00] } 2157 60 PUSH1 0x00 2159 80 DUP1 215A FD *REVERT // Stack delta = +0 // Outputs[1] { @215A revert(memory[0x00:0x00]); } // Block terminates label_215B: // Incoming jump from 0x2156, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @215C stack[-1] // @215D stack[-2] // @2160 stack[-5] // @2162 stack[-3] // @2162 stack[-6] // @2163 stack[-4] // } 215B 5B JUMPDEST 215C 80 DUP1 215D 91 SWAP2 215E 50 POP 215F 50 POP 2160 92 SWAP3 2161 50 POP 2162 92 SWAP3 2163 90 SWAP1 2164 50 POP 2165 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2160 stack[-5] = stack[-1] // @2162 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2166: // Incoming jump from 0x02F2 // Inputs[2] // { // @216B stack[-1] // @216C stack[-2] // } 2166 5B JUMPDEST 2167 60 PUSH1 0x00 2169 60 PUSH1 0x20 216B 82 DUP3 216C 84 DUP5 216D 03 SUB 216E 12 SLT 216F 15 ISZERO 2170 61 PUSH2 0x2178 2173 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2167 stack[0] = 0x00 } // Block ends with conditional jump to 0x2178, if !(stack[-2] - stack[-1] i< 0x20) label_2174: // Incoming jump from 0x2173, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2177 memory[0x00:0x00] } 2174 60 PUSH1 0x00 2176 80 DUP1 2177 FD *REVERT // Stack delta = +0 // Outputs[1] { @2177 revert(memory[0x00:0x00]); } // Block terminates label_2178: // Incoming jump from 0x2173, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2179 stack[-2] // @217A msg.data[stack[-2]:stack[-2] + 0x20] // } 2178 5B JUMPDEST 2179 81 DUP2 217A 35 CALLDATALOAD 217B 60 PUSH1 0x01 217D 60 PUSH1 0x01 217F 60 PUSH1 0x40 2181 1B SHL 2182 03 SUB 2183 81 DUP2 2184 11 GT 2185 15 ISZERO 2186 61 PUSH2 0x218e 2189 57 *JUMPI // Stack delta = +1 // Outputs[1] { @217A stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x218e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_218A: // Incoming jump from 0x2189, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @218D memory[0x00:0x00] } 218A 60 PUSH1 0x00 218C 80 DUP1 218D FD *REVERT // Stack delta = +0 // Outputs[1] { @218D revert(memory[0x00:0x00]); } // Block terminates label_218E: // Incoming jump from 0x2189, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2192 stack[-4] // @2193 stack[-1] // @2194 stack[-3] // } 218E 5B JUMPDEST 218F 61 PUSH2 0x08c2 2192 84 DUP5 2193 82 DUP3 2194 85 DUP6 2195 01 ADD 2196 61 PUSH2 0x1b64 2199 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @218F stack[0] = 0x08c2 // @2192 stack[1] = stack[-4] // @2195 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1b64, returns to 0x08C2 label_219A: // Incoming jump from 0x0305 // Inputs[2] // { // @21A6 stack[-1] // @21A7 stack[-2] // } 219A 5B JUMPDEST 219B 60 PUSH1 0x00 219D 80 DUP1 219E 60 PUSH1 0x00 21A0 80 DUP1 21A1 60 PUSH1 0x00 21A3 80 DUP1 21A4 60 PUSH1 0xc0 21A6 87 DUP8 21A7 89 DUP10 21A8 03 SUB 21A9 12 SLT 21AA 15 ISZERO 21AB 61 PUSH2 0x21b3 21AE 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @219B stack[0] = 0x00 // @219D stack[1] = 0x00 // @219E stack[2] = 0x00 // @21A0 stack[3] = 0x00 // @21A1 stack[4] = 0x00 // @21A3 stack[5] = 0x00 // } // Block ends with conditional jump to 0x21b3, if !(stack[-2] - stack[-1] i< 0xc0) label_21AF: // Incoming jump from 0x21AE, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @21B2 memory[0x00:0x00] } 21AF 60 PUSH1 0x00 21B1 80 DUP1 21B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @21B2 revert(memory[0x00:0x00]); } // Block terminates label_21B3: // Incoming jump from 0x21AE, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @21B7 stack[-7] } 21B3 5B JUMPDEST 21B4 61 PUSH2 0x21bc 21B7 87 DUP8 21B8 61 PUSH2 0x1a86 21BB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21B4 stack[0] = 0x21bc // @21B7 stack[1] = stack[-7] // } // Block ends with call to 0x1a86, returns to 0x21BC label_21BC: // Incoming return from call to 0x1A86 at 0x21BB // Inputs[4] // { // @21BD stack[-7] // @21BD stack[-1] // @21C1 stack[-8] // @21C3 msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } 21BC 5B JUMPDEST 21BD 95 SWAP6 21BE 50 POP 21BF 60 PUSH1 0x20 21C1 87 DUP8 21C2 01 ADD 21C3 35 CALLDATALOAD 21C4 60 PUSH1 0x01 21C6 60 PUSH1 0x01 21C8 60 PUSH1 0x40 21CA 1B SHL 21CB 03 SUB 21CC 80 DUP1 21CD 82 DUP3 21CE 11 GT 21CF 15 ISZERO 21D0 61 PUSH2 0x21d8 21D3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @21BD stack[-7] = stack[-1] // @21C3 stack[-1] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @21CB stack[0] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x21d8, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_21D4: // Incoming jump from 0x21D3, if not !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @21D7 memory[0x00:0x00] } 21D4 60 PUSH1 0x00 21D6 80 DUP1 21D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @21D7 revert(memory[0x00:0x00]); } // Block terminates label_21D8: // Incoming jump from 0x21D3, if !(msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @21DC stack[-10] // @21DD stack[-2] // @21DE stack[-9] // } 21D8 5B JUMPDEST 21D9 61 PUSH2 0x21e4 21DC 8A DUP11 21DD 83 DUP4 21DE 8B DUP12 21DF 01 ADD 21E0 61 PUSH2 0x1b64 21E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21D9 stack[0] = 0x21e4 // @21DC stack[1] = stack[-10] // @21DF stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x21E4 label_21E4: // Incoming return from call to 0x1B64 at 0x21E3 // Inputs[6] // { // @21E5 stack[-1] // @21E5 stack[-8] // @21E9 stack[-10] // @21EB msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] // @21EC stack[-3] // @21EE stack[-2] // } 21E4 5B JUMPDEST 21E5 96 SWAP7 21E6 50 POP 21E7 60 PUSH1 0x40 21E9 89 DUP10 21EA 01 ADD 21EB 35 CALLDATALOAD 21EC 91 SWAP2 21ED 50 POP 21EE 80 DUP1 21EF 82 DUP3 21F0 11 GT 21F1 15 ISZERO 21F2 61 PUSH2 0x21fa 21F5 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @21E5 stack[-8] = stack[-1] // @21EC stack[-3] = msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x21fa, if !(msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] > stack[-2]) label_21F6: // Incoming jump from 0x21F5, if not !(msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] > stack[-2]) // Inputs[1] { @21F9 memory[0x00:0x00] } 21F6 60 PUSH1 0x00 21F8 80 DUP1 21F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @21F9 revert(memory[0x00:0x00]); } // Block terminates label_21FA: // Incoming jump from 0x21F5, if !(msg.data[stack[-10] + 0x40:stack[-10] + 0x40 + 0x20] > stack[-2]) // Inputs[3] // { // @21FE stack[-10] // @21FF stack[-2] // @2200 stack[-9] // } 21FA 5B JUMPDEST 21FB 61 PUSH2 0x2206 21FE 8A DUP11 21FF 83 DUP4 2200 8B DUP12 2201 01 ADD 2202 61 PUSH2 0x1b64 2205 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21FB stack[0] = 0x2206 // @21FE stack[1] = stack[-10] // @2201 stack[2] = stack[-9] + stack[-2] // } // Block ends with call to 0x1b64, returns to 0x2206 label_2206: // Incoming return from call to 0x1B64 at 0x2205 // Inputs[10] // { // @2207 stack[-1] // @2207 stack[-7] // @220B stack[-10] // @220D msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @220E stack[-6] // @2214 msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @2215 stack[-5] // @221B msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // @221C stack[-3] // @221E stack[-2] // } 2206 5B JUMPDEST 2207 95 SWAP6 2208 50 POP 2209 60 PUSH1 0x60 220B 89 DUP10 220C 01 ADD 220D 35 CALLDATALOAD 220E 94 SWAP5 220F 50 POP 2210 60 PUSH1 0x80 2212 89 DUP10 2213 01 ADD 2214 35 CALLDATALOAD 2215 93 SWAP4 2216 50 POP 2217 60 PUSH1 0xa0 2219 89 DUP10 221A 01 ADD 221B 35 CALLDATALOAD 221C 91 SWAP2 221D 50 POP 221E 80 DUP1 221F 82 DUP3 2220 11 GT 2221 15 ISZERO 2222 61 PUSH2 0x222a 2225 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @2207 stack[-7] = stack[-1] // @220E stack[-6] = msg.data[stack[-10] + 0x60:stack[-10] + 0x60 + 0x20] // @2215 stack[-5] = msg.data[stack[-10] + 0x80:stack[-10] + 0x80 + 0x20] // @221C stack[-3] = msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] // } // Block ends with conditional jump to 0x222a, if !(msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] > stack[-2]) label_2226: // Incoming jump from 0x2225, if not !(msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] > stack[-2]) // Inputs[1] { @2229 memory[0x00:0x00] } 2226 60 PUSH1 0x00 2228 80 DUP1 2229 FD *REVERT // Stack delta = +0 // Outputs[1] { @2229 revert(memory[0x00:0x00]); } // Block terminates label_222A: // Incoming jump from 0x2225, if !(msg.data[stack[-10] + 0xa0:stack[-10] + 0xa0 + 0x20] > stack[-2]) // Inputs[3] // { // @222F stack[-10] // @2230 stack[-2] // @2231 stack[-9] // } 222A 5B JUMPDEST 222B 50 POP 222C 61 PUSH2 0x2237 222F 89 DUP10 2230 82 DUP3 2231 8A DUP11 2232 01 ADD 2233 61 PUSH2 0x1df3 2236 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @222C stack[-1] = 0x2237 // @222F stack[0] = stack[-10] // @2232 stack[1] = stack[-9] + stack[-2] // } // Block ends with unconditional jump to 0x1df3 2237 5B JUMPDEST 2238 91 SWAP2 2239 50 POP 223A 50 POP 223B 92 SWAP3 223C 95 SWAP6 223D 50 POP 223E 92 SWAP3 223F 95 SWAP6 2240 50 POP 2241 92 SWAP3 2242 95 SWAP6 2243 56 *JUMP label_2244: // Incoming call from 0x0318, returns to 0x0319 // Inputs[2] // { // @224A stack[-1] // @224B stack[-2] // } 2244 5B JUMPDEST 2245 60 PUSH1 0x00 2247 80 DUP1 2248 60 PUSH1 0x40 224A 83 DUP4 224B 85 DUP6 224C 03 SUB 224D 12 SLT 224E 15 ISZERO 224F 61 PUSH2 0x2257 2252 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2245 stack[0] = 0x00 // @2247 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2257, if !(stack[-2] - stack[-1] i< 0x40) label_2253: // Incoming jump from 0x2252, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2256 memory[0x00:0x00] } 2253 60 PUSH1 0x00 2255 80 DUP1 2256 FD *REVERT // Stack delta = +0 // Outputs[1] { @2256 revert(memory[0x00:0x00]); } // Block terminates label_2257: // Incoming jump from 0x2252, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @225B stack[-3] } 2257 5B JUMPDEST 2258 61 PUSH2 0x2260 225B 83 DUP4 225C 61 PUSH2 0x1a86 225F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2258 stack[0] = 0x2260 // @225B stack[1] = stack[-3] // } // Block ends with call to 0x1a86, returns to 0x2260 label_2260: // Incoming return from call to 0x1A86 at 0x225F // Inputs[3] // { // @2261 stack[-1] // @2261 stack[-3] // @2268 stack[-4] // } 2260 5B JUMPDEST 2261 91 SWAP2 2262 50 POP 2263 61 PUSH2 0x226e 2266 60 PUSH1 0x20 2268 84 DUP5 2269 01 ADD 226A 61 PUSH2 0x1a86 226D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2261 stack[-3] = stack[-1] // @2263 stack[-1] = 0x226e // @2269 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1a86, returns to 0x226E label_226E: // Incoming return from call to 0x1A86 at 0x226D // Inputs[6] // { // @226F stack[-1] // @226F stack[-2] // @2271 stack[-5] // @2273 stack[-3] // @2273 stack[-6] // @2274 stack[-4] // } 226E 5B JUMPDEST 226F 90 SWAP1 2270 50 POP 2271 92 SWAP3 2272 50 POP 2273 92 SWAP3 2274 90 SWAP1 2275 50 POP 2276 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2271 stack[-5] = stack[-1] // @2273 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2277: // Incoming jump from 0x0354 // Inputs[2] // { // @2282 stack[-1] // @2283 stack[-2] // } 2277 5B JUMPDEST 2278 60 PUSH1 0x00 227A 80 DUP1 227B 60 PUSH1 0x00 227D 80 DUP1 227E 60 PUSH1 0x00 2280 60 PUSH1 0xa0 2282 86 DUP7 2283 88 DUP9 2284 03 SUB 2285 12 SLT 2286 15 ISZERO 2287 61 PUSH2 0x228f 228A 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2278 stack[0] = 0x00 // @227A stack[1] = 0x00 // @227B stack[2] = 0x00 // @227D stack[3] = 0x00 // @227E stack[4] = 0x00 // } // Block ends with conditional jump to 0x228f, if !(stack[-2] - stack[-1] i< 0xa0) label_228B: // Incoming jump from 0x228A, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @228E memory[0x00:0x00] } 228B 60 PUSH1 0x00 228D 80 DUP1 228E FD *REVERT // Stack delta = +0 // Outputs[1] { @228E revert(memory[0x00:0x00]); } // Block terminates label_228F: // Incoming jump from 0x228A, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2293 stack[-6] } 228F 5B JUMPDEST 2290 61 PUSH2 0x2298 2293 86 DUP7 2294 61 PUSH2 0x1a86 2297 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2290 stack[0] = 0x2298 // @2293 stack[1] = stack[-6] // } // Block ends with call to 0x1a86, returns to 0x2298 label_2298: // Incoming return from call to 0x1A86 at 0x2297 // Inputs[3] // { // @2299 stack[-6] // @2299 stack[-1] // @22A0 stack[-7] // } 2298 5B JUMPDEST 2299 94 SWAP5 229A 50 POP 229B 61 PUSH2 0x22a6 229E 60 PUSH1 0x20 22A0 87 DUP8 22A1 01 ADD 22A2 61 PUSH2 0x1a86 22A5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2299 stack[-6] = stack[-1] // @229B stack[-1] = 0x22a6 // @22A1 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1a86, returns to 0x22A6 label_22A6: // Incoming return from call to 0x1A86 at 0x22A5 // Inputs[8] // { // @22A7 stack[-5] // @22A7 stack[-1] // @22AB stack[-7] // @22AD msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @22AE stack[-4] // @22B4 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @22B5 stack[-3] // @22BB msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 22A6 5B JUMPDEST 22A7 93 SWAP4 22A8 50 POP 22A9 60 PUSH1 0x40 22AB 86 DUP7 22AC 01 ADD 22AD 35 CALLDATALOAD 22AE 92 SWAP3 22AF 50 POP 22B0 60 PUSH1 0x60 22B2 86 DUP7 22B3 01 ADD 22B4 35 CALLDATALOAD 22B5 91 SWAP2 22B6 50 POP 22B7 60 PUSH1 0x80 22B9 86 DUP7 22BA 01 ADD 22BB 35 CALLDATALOAD 22BC 60 PUSH1 0x01 22BE 60 PUSH1 0x01 22C0 60 PUSH1 0x40 22C2 1B SHL 22C3 03 SUB 22C4 81 DUP2 22C5 11 GT 22C6 15 ISZERO 22C7 61 PUSH2 0x22cf 22CA 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @22A7 stack[-5] = stack[-1] // @22AE stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @22B5 stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @22BB stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x22cf, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) label_22CB: // Incoming jump from 0x22CA, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @22CE memory[0x00:0x00] } 22CB 60 PUSH1 0x00 22CD 80 DUP1 22CE FD *REVERT // Stack delta = +0 // Outputs[1] { @22CE revert(memory[0x00:0x00]); } // Block terminates label_22CF: // Incoming jump from 0x22CA, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @22D3 stack[-8] // @22D4 stack[-1] // @22D5 stack[-7] // } 22CF 5B JUMPDEST 22D0 61 PUSH2 0x1eaf 22D3 88 DUP9 22D4 82 DUP3 22D5 89 DUP10 22D6 01 ADD 22D7 61 PUSH2 0x1df3 22DA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22D0 stack[0] = 0x1eaf // @22D3 stack[1] = stack[-8] // @22D6 stack[2] = stack[-7] + stack[-1] // } // Block ends with unconditional jump to 0x1df3 label_22DB: // Incoming call from 0x037A, returns to 0x037B // Inputs[2] // { // @22E3 stack[-1] // @22E4 stack[-2] // } 22DB 5B JUMPDEST 22DC 60 PUSH1 0x00 22DE 80 DUP1 22DF 60 PUSH1 0x00 22E1 60 PUSH1 0x60 22E3 84 DUP5 22E4 86 DUP7 22E5 03 SUB 22E6 12 SLT 22E7 15 ISZERO 22E8 61 PUSH2 0x22f0 22EB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @22DC stack[0] = 0x00 // @22DE stack[1] = 0x00 // @22DF stack[2] = 0x00 // } // Block ends with conditional jump to 0x22f0, if !(stack[-2] - stack[-1] i< 0x60) label_22EC: // Incoming jump from 0x22EB, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @22EF memory[0x00:0x00] } 22EC 60 PUSH1 0x00 22EE 80 DUP1 22EF FD *REVERT // Stack delta = +0 // Outputs[1] { @22EF revert(memory[0x00:0x00]); } // Block terminates label_22F0: // Incoming jump from 0x22EB, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @22F4 stack[-4] } 22F0 5B JUMPDEST 22F1 61 PUSH2 0x22f9 22F4 84 DUP5 22F5 61 PUSH2 0x1a86 22F8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22F1 stack[0] = 0x22f9 // @22F4 stack[1] = stack[-4] // } // Block ends with call to 0x1a86, returns to 0x22F9 label_22F9: // Incoming return from call to 0x1A86 at 0x22F8 // Inputs[7] // { // @22FA stack[-1] // @22FA stack[-7] // @22FD stack[-5] // @22FF msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2300 stack[-6] // @2307 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2309 stack[-4] // } 22F9 5B JUMPDEST 22FA 95 SWAP6 22FB 60 PUSH1 0x20 22FD 85 DUP6 22FE 01 ADD 22FF 35 CALLDATALOAD 2300 95 SWAP6 2301 50 POP 2302 60 PUSH1 0x40 2304 90 SWAP1 2305 94 SWAP5 2306 01 ADD 2307 35 CALLDATALOAD 2308 93 SWAP4 2309 92 SWAP3 230A 50 POP 230B 50 POP 230C 50 POP 230D 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @22FA stack[-7] = stack[-1] // @2300 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2308 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_230E: // Incoming jump from 0x076A // Incoming jump from 0x0C8E // Incoming jump from 0x0CAB // Incoming jump from 0x05CF // Incoming jump from 0x18CC // Incoming jump from 0x0FB1 // Incoming jump from 0x04E2 // Incoming jump from 0x0789 // Incoming jump from 0x0F93 // Incoming jump from 0x04A1 // Incoming jump from 0x0750 // Incoming jump from 0x04C8 // Inputs[1] { @2323 memory[0x00:0x24] } 230E 5B JUMPDEST 230F 63 PUSH4 0x4e487b71 2314 60 PUSH1 0xe0 2316 1B SHL 2317 60 PUSH1 0x00 2319 52 MSTORE 231A 60 PUSH1 0x32 231C 60 PUSH1 0x04 231E 52 MSTORE 231F 60 PUSH1 0x24 2321 60 PUSH1 0x00 2323 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2319 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @231E memory[0x04:0x24] = 0x32 // @2323 revert(memory[0x00:0x24]); // } // Block terminates label_2324: // Incoming jump from 0x234B // Incoming jump from 0x2452 // Inputs[1] { @2339 memory[0x00:0x24] } 2324 5B JUMPDEST 2325 63 PUSH4 0x4e487b71 232A 60 PUSH1 0xe0 232C 1B SHL 232D 60 PUSH1 0x00 232F 52 MSTORE 2330 60 PUSH1 0x11 2332 60 PUSH1 0x04 2334 52 MSTORE 2335 60 PUSH1 0x24 2337 60 PUSH1 0x00 2339 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @232F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2334 memory[0x04:0x24] = 0x11 // @2339 revert(memory[0x00:0x24]); // } // Block terminates label_233A: // Incoming call from 0x05F2, returns to 0x05F3 // Incoming call from 0x079D, returns to 0x079E // Incoming call from 0x0D03, returns to 0x0D04 // Incoming call from 0x1030, returns to 0x1031 // Inputs[1] { @233F stack[-1] } 233A 5B JUMPDEST 233B 60 PUSH1 0x00 233D 60 PUSH1 0x01 233F 82 DUP3 2340 01 ADD 2341 61 PUSH2 0x234c 2344 57 *JUMPI // Stack delta = +1 // Outputs[1] { @233B stack[0] = 0x00 } // Block ends with conditional jump to 0x234c, if stack[-1] + 0x01 label_2345: // Incoming jump from 0x2344, if not stack[-1] + 0x01 2345 61 PUSH2 0x234c 2348 61 PUSH2 0x2324 234B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2345 stack[0] = 0x234c } // Block ends with unconditional jump to 0x2324 label_234C: // Incoming jump from 0x2344, if stack[-1] + 0x01 // Inputs[2] // { // @2350 stack[-2] // @2351 stack[-3] // } 234C 5B JUMPDEST 234D 50 POP 234E 60 PUSH1 0x01 2350 01 ADD 2351 90 SWAP1 2352 56 *JUMP // Stack delta = -2 // Outputs[1] { @2351 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2353: // Incoming call from 0x0527, returns to 0x0528 // Incoming call from 0x257C, returns to 0x257D // Incoming call from 0x0553, returns to 0x0554 // Inputs[1] { @2356 stack[-1] } 2353 5B JUMPDEST 2354 60 PUSH1 0x01 2356 81 DUP2 2357 81 DUP2 2358 1C SHR 2359 90 SWAP1 235A 82 DUP3 235B 16 AND 235C 80 DUP1 235D 61 PUSH2 0x2367 2360 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2359 stack[0] = stack[-1] >> 0x01 // @235B stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2367, if stack[-1] & 0x01 label_2361: // Incoming jump from 0x2360, if not stack[-1] & 0x01 // Inputs[2] // { // @2363 stack[-2] // @236C stack[-1] // } 2361 60 PUSH1 0x7f 2363 82 DUP3 2364 16 AND 2365 91 SWAP2 2366 50 POP 2367 5B JUMPDEST 2368 60 PUSH1 0x20 236A 82 DUP3 236B 10 LT 236C 81 DUP2 236D 03 SUB 236E 61 PUSH2 0x2387 2371 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2365 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2387, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_2372: // Incoming jump from 0x2371, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x2371, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @2386 memory[0x00:0x24] } 2372 63 PUSH4 0x4e487b71 2377 60 PUSH1 0xe0 2379 1B SHL 237A 60 PUSH1 0x00 237C 52 MSTORE 237D 60 PUSH1 0x22 237F 60 PUSH1 0x04 2381 52 MSTORE 2382 60 PUSH1 0x24 2384 60 PUSH1 0x00 2386 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @237C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2381 memory[0x04:0x24] = 0x22 // @2386 revert(memory[0x00:0x24]); // } // Block terminates label_2387: // Incoming jump from 0x2371, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x2371, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @2389 stack[-2] // @2389 stack[-4] // @238A stack[-3] // } 2387 5B JUMPDEST 2388 50 POP 2389 91 SWAP2 238A 90 SWAP1 238B 50 POP 238C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2389 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_238D: // Incoming call from 0x0B74, returns to 0x03F8 // Incoming call from 0x07F8, returns to 0x03F8 // Inputs[2] // { // @2391 stack[-1] // @23DA stack[-2] // } 238D 5B JUMPDEST 238E 60 PUSH1 0x20 2390 80 DUP1 2391 82 DUP3 2392 52 MSTORE 2393 60 PUSH1 0x2f 2395 90 SWAP1 2396 82 DUP3 2397 01 ADD 2398 52 MSTORE 2399 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f7420746f6b656e206f776e 23BA 60 PUSH1 0x40 23BC 82 DUP3 23BD 01 ADD 23BE 52 MSTORE 23BF 6E PUSH15 0x195c881b9bdc88185c1c1c9bdd9959 23CF 60 PUSH1 0x8a 23D1 1B SHL 23D2 60 PUSH1 0x60 23D4 82 DUP3 23D5 01 ADD 23D6 52 MSTORE 23D7 60 PUSH1 0x80 23D9 01 ADD 23DA 90 SWAP1 23DB 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2392 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2398 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2f // @23BE memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f7420746f6b656e206f776e // @23D6 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x195c881b9bdc88185c1c1c9bdd9959 << 0x8a // @23DA stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 23DC 5B JUMPDEST 23DD 60 PUSH1 0x00 23DF 82 DUP3 23E0 51 MLOAD 23E1 61 PUSH2 0x23ee 23E4 81 DUP2 23E5 84 DUP5 23E6 60 PUSH1 0x20 23E8 87 DUP8 23E9 01 ADD 23EA 61 PUSH2 0x1d33 23ED 56 *JUMP 23EE 5B JUMPDEST 23EF 91 SWAP2 23F0 90 SWAP1 23F1 91 SWAP2 23F2 01 ADD 23F3 92 SWAP3 23F4 91 SWAP2 23F5 50 POP 23F6 50 POP 23F7 56 *JUMP label_23F8: // Incoming call from 0x0F62, returns to 0x03F8 // Incoming call from 0x0C6F, returns to 0x03F8 // Inputs[2] // { // @23FC stack[-1] // @243E stack[-2] // } 23F8 5B JUMPDEST 23F9 60 PUSH1 0x20 23FB 80 DUP1 23FC 82 DUP3 23FD 52 MSTORE 23FE 60 PUSH1 0x28 2400 90 SWAP1 2401 82 DUP3 2402 01 ADD 2403 52 MSTORE 2404 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 2425 60 PUSH1 0x40 2427 82 DUP3 2428 01 ADD 2429 52 MSTORE 242A 67 PUSH8 0x0dad2e6dac2e8c6d 2433 60 PUSH1 0xc3 2435 1B SHL 2436 60 PUSH1 0x60 2438 82 DUP3 2439 01 ADD 243A 52 MSTORE 243B 60 PUSH1 0x80 243D 01 ADD 243E 90 SWAP1 243F 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @23FD memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2403 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @2429 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 // @243A memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x0dad2e6dac2e8c6d << 0xc3 // @243E stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2440: // Incoming call from 0x0CF3, returns to 0x0CF4 // Inputs[2] // { // @2441 stack[-1] // @2442 stack[-2] // } 2440 5B JUMPDEST 2441 80 DUP1 2442 82 DUP3 2443 01 ADD 2444 80 DUP1 2445 82 DUP3 2446 11 GT 2447 15 ISZERO 2448 61 PUSH2 0x0424 244B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2443 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0424, if !(stack[-1] > stack[-2] + stack[-1]) label_244C: // Incoming jump from 0x244B, if not !(stack[-1] > stack[-2] + stack[-1]) 244C 61 PUSH2 0x0424 244F 61 PUSH2 0x2324 2452 56 *JUMP // Stack delta = +1 // Outputs[1] { @244C stack[0] = 0x0424 } // Block ends with unconditional jump to 0x2324 label_2453: // Incoming call from 0x0D5C, returns to 0x0D5D // Incoming call from 0x1089, returns to 0x108A // Inputs[2] // { // @2456 stack[-1] // @2461 stack[-3] // } 2453 5B JUMPDEST 2454 60 PUSH1 0x40 2456 81 DUP2 2457 52 MSTORE 2458 60 PUSH1 0x00 245A 61 PUSH2 0x2466 245D 60 PUSH1 0x40 245F 83 DUP4 2460 01 ADD 2461 85 DUP6 2462 61 PUSH2 0x1f86 2465 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2457 memory[stack[-1]:stack[-1] + 0x20] = 0x40 // @2458 stack[0] = 0x00 // @245A stack[1] = 0x2466 // @2460 stack[2] = stack[-1] + 0x40 // @2461 stack[3] = stack[-3] // } // Block ends with call to 0x1f86, returns to 0x2466 label_2466: // Incoming return from call to 0x1F86 at 0x2465 // Inputs[3] // { // @2467 stack[-3] // @2468 stack[-1] // @2473 stack[-4] // } 2466 5B JUMPDEST 2467 82 DUP3 2468 81 DUP2 2469 03 SUB 246A 60 PUSH1 0x20 246C 84 DUP5 246D 01 ADD 246E 52 MSTORE 246F 61 PUSH2 0x2478 2472 81 DUP2 2473 85 DUP6 2474 61 PUSH2 0x1f86 2477 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @246E memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] - stack[-3] // @246F stack[0] = 0x2478 // @2472 stack[1] = stack[-1] // @2473 stack[2] = stack[-4] // } // Block ends with call to 0x1f86, returns to 0x2478 label_2478: // Incoming return from call to 0x1F86 at 0x2477 // Inputs[3] // { // @2479 stack[-7] // @2479 stack[-1] // @247A stack[-6] // } 2478 5B JUMPDEST 2479 95 SWAP6 247A 94 SWAP5 247B 50 POP 247C 50 POP 247D 50 POP 247E 50 POP 247F 50 POP 2480 56 *JUMP // Stack delta = -6 // Outputs[1] { @2479 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] 2481 5B JUMPDEST 2482 60 PUSH1 0x20 2484 80 DUP1 2485 82 DUP3 2486 52 MSTORE 2487 60 PUSH1 0x25 2489 90 SWAP1 248A 82 DUP3 248B 01 ADD 248C 52 MSTORE 248D 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 24AE 60 PUSH1 0x40 24B0 82 DUP3 24B1 01 ADD 24B2 52 MSTORE 24B3 64 PUSH5 0x6472657373 24B9 60 PUSH1 0xd8 24BB 1B SHL 24BC 60 PUSH1 0x60 24BE 82 DUP3 24BF 01 ADD 24C0 52 MSTORE 24C1 60 PUSH1 0x80 24C3 01 ADD 24C4 90 SWAP1 24C5 56 *JUMP 24C6 5B JUMPDEST 24C7 60 PUSH1 0x20 24C9 80 DUP1 24CA 82 DUP3 24CB 52 MSTORE 24CC 60 PUSH1 0x2a 24CE 90 SWAP1 24CF 82 DUP3 24D0 01 ADD 24D1 52 MSTORE 24D2 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 24F3 60 PUSH1 0x40 24F5 82 DUP3 24F6 01 ADD 24F7 52 MSTORE 24F8 69 PUSH10 0x39103a3930b739b332b9 2503 60 PUSH1 0xb1 2505 1B SHL 2506 60 PUSH1 0x60 2508 82 DUP3 2509 01 ADD 250A 52 MSTORE 250B 60 PUSH1 0x80 250D 01 ADD 250E 90 SWAP1 250F 56 *JUMP label_2510: // Incoming jump from 0x2582 // Inputs[1] { @2513 stack[-2] } 2510 5B JUMPDEST 2511 60 PUSH1 0x1f 2513 82 DUP3 2514 11 GT 2515 15 ISZERO 2516 61 PUSH2 0x0804 2519 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0804, if !(stack[-2] > 0x1f) label_251A: // Incoming jump from 0x2519, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @251C stack[-1] // @2522 memory[0x00:0x20] // @2525 stack[-3] // } 251A 60 PUSH1 0x00 251C 81 DUP2 251D 81 DUP2 251E 52 MSTORE 251F 60 PUSH1 0x20 2521 81 DUP2 2522 20 SHA3 2523 60 PUSH1 0x1f 2525 85 DUP6 2526 01 ADD 2527 60 PUSH1 0x05 2529 1C SHR 252A 81 DUP2 252B 01 ADD 252C 60 PUSH1 0x20 252E 86 DUP7 252F 10 LT 2530 15 ISZERO 2531 61 PUSH2 0x2537 2534 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @251A stack[0] = 0x00 // @251E memory[0x00:0x20] = stack[-1] // @2522 stack[1] = keccak256(memory[0x00:0x20]) // @252B stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x2537, if !(stack[-3] < 0x20) label_2535: // Incoming jump from 0x2534, if not !(stack[-3] < 0x20) // Inputs[2] // { // @2536 stack[-2] // @253A stack[-5] // } 2535 50 POP 2536 80 DUP1 2537 5B JUMPDEST 2538 60 PUSH1 0x1f 253A 85 DUP6 253B 01 ADD 253C 60 PUSH1 0x05 253E 1C SHR 253F 82 DUP3 2540 01 ADD 2541 91 SWAP2 2542 50 POP 2543 5B JUMPDEST 2544 81 DUP2 2545 81 DUP2 2546 10 LT 2547 15 ISZERO 2548 61 PUSH2 0x0f08 254B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2536 stack[-1] = stack[-2] // @2541 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x0f08, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_254C: // Incoming jump from 0x254B, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x254B, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x254B, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @254C stack[-3] // @254D stack[-1] // } 254C 82 DUP3 254D 81 DUP2 254E 55 SSTORE 254F 60 PUSH1 0x01 2551 01 ADD 2552 61 PUSH2 0x2543 2555 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @254E storage[stack[-1]] = stack[-3] // @2551 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2543 label_2556: // Incoming call from 0x0F1B, returns to 0x0915 // Inputs[2] // { // @2557 stack[-2] // @2558 memory[stack[-2]:stack[-2] + 0x20] // } 2556 5B JUMPDEST 2557 81 DUP2 2558 51 MLOAD 2559 60 PUSH1 0x01 255B 60 PUSH1 0x01 255D 60 PUSH1 0x40 255F 1B SHL 2560 03 SUB 2561 81 DUP2 2562 11 GT 2563 15 ISZERO 2564 61 PUSH2 0x256f 2567 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2558 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x256f, if !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_2568: // Incoming jump from 0x2567, if not !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) 2568 61 PUSH2 0x256f 256B 61 PUSH2 0x1aff 256E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2568 stack[0] = 0x256f } // Block ends with unconditional jump to 0x1aff label_256F: // Incoming jump from 0x2567, if !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2573 stack[-1] // @2577 stack[-2] // @2578 storage[stack[-2]] // } 256F 5B JUMPDEST 2570 61 PUSH2 0x2583 2573 81 DUP2 2574 61 PUSH2 0x257d 2577 84 DUP5 2578 54 SLOAD 2579 61 PUSH2 0x2353 257C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2570 stack[0] = 0x2583 // @2573 stack[1] = stack[-1] // @2574 stack[2] = 0x257d // @2578 stack[3] = storage[stack[-2]] // } // Block ends with call to 0x2353, returns to 0x257D label_257D: // Incoming return from call to 0x2353 at 0x257C // Inputs[1] { @257E stack[-5] } 257D 5B JUMPDEST 257E 84 DUP5 257F 61 PUSH2 0x2510 2582 56 *JUMP // Stack delta = +1 // Outputs[1] { @257E stack[0] = stack[-5] } // Block ends with unconditional jump to 0x2510 label_2583: // Incoming return from call to 0x257D at 0x257C // Inputs[1] { @2589 stack[-1] } 2583 5B JUMPDEST 2584 60 PUSH1 0x20 2586 80 DUP1 2587 60 PUSH1 0x1f 2589 83 DUP4 258A 11 GT 258B 60 PUSH1 0x01 258D 81 DUP2 258E 14 EQ 258F 61 PUSH2 0x25b8 2592 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2584 stack[0] = 0x20 // @2586 stack[1] = 0x20 // @258A stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x25b8, if (stack[-1] > 0x1f) == 0x01 label_2593: // Incoming jump from 0x2592, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @2595 stack[-4] } 2593 60 PUSH1 0x00 2595 84 DUP5 2596 15 ISZERO 2597 61 PUSH2 0x25a0 259A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2593 stack[0] = 0x00 } // Block ends with conditional jump to 0x25a0, if !stack[-4] label_259B: // Incoming jump from 0x259A, if not !stack[-4] // Inputs[5] // { // @259C stack[-7] // @259D stack[-4] // @259F memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @25A6 stack[-5] // @25B2 stack[-6] // } 259B 50 POP 259C 85 DUP6 259D 83 DUP4 259E 01 ADD 259F 51 MLOAD 25A0 5B JUMPDEST 25A1 60 PUSH1 0x00 25A3 19 NOT 25A4 60 PUSH1 0x03 25A6 86 DUP7 25A7 90 SWAP1 25A8 1B SHL 25A9 1C SHR 25AA 19 NOT 25AB 16 AND 25AC 60 PUSH1 0x01 25AE 85 DUP6 25AF 90 SWAP1 25B0 1B SHL 25B1 17 OR 25B2 85 DUP6 25B3 55 SSTORE 25B4 61 PUSH2 0x0f08 25B7 56 *JUMP // Stack delta = -1 // Outputs[1] { @25B3 storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x0f08 label_25B8: // Incoming jump from 0x2592, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @25BB stack[-5] // @25C1 memory[0x00:0x20] // @25C5 stack[-4] // } 25B8 5B JUMPDEST 25B9 60 PUSH1 0x00 25BB 85 DUP6 25BC 81 DUP2 25BD 52 MSTORE 25BE 60 PUSH1 0x20 25C0 81 DUP2 25C1 20 SHA3 25C2 60 PUSH1 0x1f 25C4 19 NOT 25C5 86 DUP7 25C6 16 AND 25C7 91 SWAP2 25C8 5B JUMPDEST 25C9 82 DUP3 25CA 81 DUP2 25CB 10 LT 25CC 15 ISZERO 25CD 61 PUSH2 0x25e7 25D0 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @25BD memory[0x00:0x20] = stack[-5] // @25C1 stack[1] = keccak256(memory[0x00:0x20]) // @25C7 stack[0] = stack[-4] & ~0x1f // @25C7 stack[2] = 0x00 // } // Block ends with conditional jump to 0x25e7, if !(0x00 < stack[-4] & ~0x1f) label_25D1: // Incoming jump from 0x25D0, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x25D0, if not !(0x00 < stack[-4] & ~0x1f) // Inputs[6] // { // @25D1 stack[-9] // @25D2 stack[-6] // @25D4 memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @25D5 stack[-2] // @25D7 stack[-1] // @25D8 stack[-5] // } 25D1 88 DUP9 25D2 86 DUP7 25D3 01 ADD 25D4 51 MLOAD 25D5 82 DUP3 25D6 55 SSTORE 25D7 94 SWAP5 25D8 84 DUP5 25D9 01 ADD 25DA 94 SWAP5 25DB 60 PUSH1 0x01 25DD 90 SWAP1 25DE 91 SWAP2 25DF 01 ADD 25E0 90 SWAP1 25E1 84 DUP5 25E2 01 ADD 25E3 61 PUSH2 0x25c8 25E6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @25D6 storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @25DA stack[-6] = stack[-5] + stack[-6] // @25E0 stack[-2] = stack[-2] + 0x01 // @25E2 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x25c8 label_25E7: // Incoming jump from 0x25D0, if !(stack[-1] < stack[-3]) // Incoming jump from 0x25D0, if !(0x00 < stack[-4] & ~0x1f) // Inputs[2] // { // @25E9 stack[-7] // @25EA stack[-3] // } 25E7 5B JUMPDEST 25E8 50 POP 25E9 85 DUP6 25EA 82 DUP3 25EB 10 LT 25EC 15 ISZERO 25ED 61 PUSH2 0x2605 25F0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2605, if !(stack[-3] < stack[-7]) label_25F1: // Incoming jump from 0x25F0, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @25F1 stack[-8] // @25F2 stack[-5] // @25F4 memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @25FA stack[-6] // @2603 stack[-1] // @2611 stack[-7] // @2614 stack[-9] // } 25F1 87 DUP8 25F2 85 DUP6 25F3 01 ADD 25F4 51 MLOAD 25F5 60 PUSH1 0x00 25F7 19 NOT 25F8 60 PUSH1 0x03 25FA 88 DUP9 25FB 90 SWAP1 25FC 1B SHL 25FD 60 PUSH1 0xf8 25FF 16 AND 2600 1C SHR 2601 19 NOT 2602 16 AND 2603 81 DUP2 2604 55 SSTORE 2605 5B JUMPDEST 2606 50 POP 2607 50 POP 2608 50 POP 2609 50 POP 260A 50 POP 260B 60 PUSH1 0x01 260D 90 SWAP1 260E 81 DUP2 260F 1B SHL 2610 01 ADD 2611 90 SWAP1 2612 55 SSTORE 2613 50 POP 2614 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @2604 storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @2612 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] label_2615: // Incoming call from 0x0F41, returns to 0x03F8 // Incoming call from 0x1459, returns to 0x03F8 // Inputs[2] // { // @2619 stack[-1] // @2656 stack[-2] // } 2615 5B JUMPDEST 2616 60 PUSH1 0x20 2618 80 DUP1 2619 82 DUP3 261A 52 MSTORE 261B 60 PUSH1 0x23 261D 90 SWAP1 261E 82 DUP3 261F 01 ADD 2620 52 MSTORE 2621 7F PUSH32 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 2642 60 PUSH1 0x40 2644 82 DUP3 2645 01 ADD 2646 52 MSTORE 2647 62 PUSH3 0x657373 264B 60 PUSH1 0xe8 264D 1B SHL 264E 60 PUSH1 0x60 2650 82 DUP3 2651 01 ADD 2652 52 MSTORE 2653 60 PUSH1 0x80 2655 01 ADD 2656 90 SWAP1 2657 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @261A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2620 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x23 // @2646 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 // @2652 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x657373 << 0xe8 // @2656 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2658: // Incoming call from 0x14BF, returns to 0x03F8 // Incoming call from 0x1001, returns to 0x03F8 // Inputs[2] // { // @265C stack[-1] // @269A stack[-2] // } 2658 5B JUMPDEST 2659 60 PUSH1 0x20 265B 80 DUP1 265C 82 DUP3 265D 52 MSTORE 265E 60 PUSH1 0x24 2660 90 SWAP1 2661 82 DUP3 2662 01 ADD 2663 52 MSTORE 2664 7F PUSH32 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c 2685 60 PUSH1 0x40 2687 82 DUP3 2688 01 ADD 2689 52 MSTORE 268A 63 PUSH4 0x616e6365 268F 60 PUSH1 0xe0 2691 1B SHL 2692 60 PUSH1 0x60 2694 82 DUP3 2695 01 ADD 2696 52 MSTORE 2697 60 PUSH1 0x80 2699 01 ADD 269A 90 SWAP1 269B 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @265D memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2663 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x24 // @2689 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c // @2696 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x616e6365 << 0xe0 // @269A stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_269C: // Incoming call from 0x1580, returns to 0x1581 // Inputs[4] // { // @26A5 stack[-6] // @26A8 stack[-1] // @26AA stack[-5] // @26C3 stack[-4] // } 269C 5B JUMPDEST 269D 60 PUSH1 0x01 269F 60 PUSH1 0x01 26A1 60 PUSH1 0xa0 26A3 1B SHL 26A4 03 SUB 26A5 86 DUP7 26A6 81 DUP2 26A7 16 AND 26A8 82 DUP3 26A9 52 MSTORE 26AA 85 DUP6 26AB 16 AND 26AC 60 PUSH1 0x20 26AE 82 DUP3 26AF 01 ADD 26B0 52 MSTORE 26B1 60 PUSH1 0xa0 26B3 60 PUSH1 0x40 26B5 82 DUP3 26B6 01 ADD 26B7 81 DUP2 26B8 90 SWAP1 26B9 52 MSTORE 26BA 60 PUSH1 0x00 26BC 90 SWAP1 26BD 61 PUSH2 0x26c8 26C0 90 SWAP1 26C1 83 DUP4 26C2 01 ADD 26C3 86 DUP7 26C4 61 PUSH2 0x1f86 26C7 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @26A9 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @26B0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @26B9 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0xa0 // @26BC stack[0] = 0x00 // @26C0 stack[1] = 0x26c8 // @26C2 stack[2] = stack[-1] + 0xa0 // @26C3 stack[3] = stack[-4] // } // Block ends with call to 0x1f86, returns to 0x26C8 label_26C8: // Incoming return from call to 0x1F86 at 0x26C7 // Inputs[3] // { // @26C9 stack[-3] // @26CA stack[-1] // @26D5 stack[-5] // } 26C8 5B JUMPDEST 26C9 82 DUP3 26CA 81 DUP2 26CB 03 SUB 26CC 60 PUSH1 0x60 26CE 84 DUP5 26CF 01 ADD 26D0 52 MSTORE 26D1 61 PUSH2 0x26da 26D4 81 DUP2 26D5 86 DUP7 26D6 61 PUSH2 0x1f86 26D9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @26D0 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = stack[-1] - stack[-3] // @26D1 stack[0] = 0x26da // @26D4 stack[1] = stack[-1] // @26D5 stack[2] = stack[-5] // } // Block ends with call to 0x1f86, returns to 0x26DA label_26DA: // Incoming return from call to 0x1F86 at 0x26D9 // Inputs[4] // { // @26DB stack[-1] // @26DB stack[-2] // @26DD stack[-4] // @26E9 stack[-5] // } 26DA 5B JUMPDEST 26DB 90 SWAP1 26DC 50 POP 26DD 82 DUP3 26DE 81 DUP2 26DF 03 SUB 26E0 60 PUSH1 0x80 26E2 84 DUP5 26E3 01 ADD 26E4 52 MSTORE 26E5 61 PUSH2 0x26ee 26E8 81 DUP2 26E9 85 DUP6 26EA 61 PUSH2 0x1d57 26ED 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @26DB stack[-2] = stack[-1] // @26E4 memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] = stack[-1] - stack[-4] // @26E5 stack[-1] = 0x26ee // @26E8 stack[0] = stack[-1] // @26E9 stack[1] = stack[-5] // } // Block ends with call to 0x1d57, returns to 0x26EE label_26EE: // Incoming return from call to 0x1D57 at 0x26ED // Inputs[3] // { // @26EF stack[-1] // @26EF stack[-10] // @26F0 stack[-9] // } 26EE 5B JUMPDEST 26EF 98 SWAP9 26F0 97 SWAP8 26F1 50 POP 26F2 50 POP 26F3 50 POP 26F4 50 POP 26F5 50 POP 26F6 50 POP 26F7 50 POP 26F8 50 POP 26F9 56 *JUMP // Stack delta = -9 // Outputs[1] { @26EF stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_26FA: // Incoming jump from 0x15B8 // Inputs[2] // { // @26FF stack[-1] // @2700 stack[-2] // } 26FA 5B JUMPDEST 26FB 60 PUSH1 0x00 26FD 60 PUSH1 0x20 26FF 82 DUP3 2700 84 DUP5 2701 03 SUB 2702 12 SLT 2703 15 ISZERO 2704 61 PUSH2 0x270c 2707 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26FB stack[0] = 0x00 } // Block ends with conditional jump to 0x270c, if !(stack[-2] - stack[-1] i< 0x20) label_2708: // Incoming jump from 0x2707, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @270B memory[0x00:0x00] } 2708 60 PUSH1 0x00 270A 80 DUP1 270B FD *REVERT // Stack delta = +0 // Outputs[1] { @270B revert(memory[0x00:0x00]); } // Block terminates label_270C: // Incoming jump from 0x2707, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @270D stack[-2] // @270E memory[stack[-2]:stack[-2] + 0x20] // } 270C 5B JUMPDEST 270D 81 DUP2 270E 51 MLOAD 270F 61 PUSH2 0x1303 2712 81 DUP2 2713 61 PUSH2 0x1acc 2716 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @270E stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @270F stack[1] = 0x1303 // @2712 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1acc, returns to 0x1303 label_2717: // Incoming call from 0x15C7, returns to 0x15C8 // Inputs[1] { @271C returndata.length } 2717 5B JUMPDEST 2718 60 PUSH1 0x00 271A 60 PUSH1 0x03 271C 3D RETURNDATASIZE 271D 11 GT 271E 15 ISZERO 271F 61 PUSH2 0x2730 2722 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2718 stack[0] = 0x00 } // Block ends with conditional jump to 0x2730, if !(returndata.length > 0x03) label_2723: // Incoming jump from 0x2722, if not !(returndata.length > 0x03) // Inputs[3] // { // @2728 returndata[0x00:0x04] // @272C memory[0x00:0x20] // @2731 stack[-2] // } 2723 60 PUSH1 0x04 2725 60 PUSH1 0x00 2727 80 DUP1 2728 3E RETURNDATACOPY 2729 50 POP 272A 60 PUSH1 0x00 272C 51 MLOAD 272D 60 PUSH1 0xe0 272F 1C SHR 2730 5B JUMPDEST 2731 90 SWAP1 2732 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2728 memory[0x00:0x04] = returndata[0x00:0x04] // @2731 stack[-2] = memory[0x00:0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_2733: // Incoming call from 0x15DB, returns to 0x15DC // Inputs[1] { @2738 returndata.length } 2733 5B JUMPDEST 2734 60 PUSH1 0x00 2736 60 PUSH1 0x44 2738 3D RETURNDATASIZE 2739 10 LT 273A 15 ISZERO 273B 61 PUSH2 0x2741 273E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2734 stack[0] = 0x00 } // Block ends with conditional jump to 0x2741, if !(returndata.length < 0x44) label_273F: // Incoming jump from 0x273E, if not !(returndata.length < 0x44) // Inputs[2] // { // @273F stack[-1] // @273F stack[-2] // } 273F 90 SWAP1 2740 56 *JUMP // Stack delta = -1 // Outputs[1] { @273F stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2741: // Incoming jump from 0x273E, if !(returndata.length < 0x44) // Inputs[5] // { // @2744 memory[0x40:0x60] // @2748 returndata.length // @274E returndata[0x04:0x04 + ~0x03 + returndata.length] // @2750 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2751 returndata.length // } 2741 5B JUMPDEST 2742 60 PUSH1 0x40 2744 51 MLOAD 2745 60 PUSH1 0x03 2747 19 NOT 2748 3D RETURNDATASIZE 2749 81 DUP2 274A 01 ADD 274B 60 PUSH1 0x04 274D 83 DUP4 274E 3E RETURNDATACOPY 274F 81 DUP2 2750 51 MLOAD 2751 3D RETURNDATASIZE 2752 60 PUSH1 0x01 2754 60 PUSH1 0x01 2756 60 PUSH1 0x40 2758 1B SHL 2759 03 SUB 275A 81 DUP2 275B 60 PUSH1 0x24 275D 84 DUP5 275E 01 ADD 275F 11 GT 2760 81 DUP2 2761 84 DUP5 2762 11 GT 2763 17 OR 2764 15 ISZERO 2765 61 PUSH2 0x2770 2768 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @2744 stack[0] = memory[0x40:0x60] // @2747 stack[1] = ~0x03 // @274E memory[memory[0x40:0x60]:memory[0x40:0x60] + ~0x03 + returndata.length] = returndata[0x04:0x04 + ~0x03 + returndata.length] // @2750 stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2751 stack[3] = returndata.length // @2759 stack[4] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x2770, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > (0x01 << 0x40) - 0x01) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_2769: // Incoming jump from 0x2768, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > (0x01 << 0x40) - 0x01) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[2] // { // @276E stack[-6] // @276E stack[-7] // } 2769 50 POP 276A 50 POP 276B 50 POP 276C 50 POP 276D 50 POP 276E 90 SWAP1 276F 56 *JUMP // Stack delta = -6 // Outputs[1] { @276E stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_2770: // Incoming jump from 0x2768, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > (0x01 << 0x40) - 0x01) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[5] // { // @2771 stack[-3] // @2772 stack[-5] // @2774 stack[-2] // @2777 memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @2778 stack[-1] // } 2770 5B JUMPDEST 2771 82 DUP3 2772 85 DUP6 2773 01 ADD 2774 91 SWAP2 2775 50 POP 2776 81 DUP2 2777 51 MLOAD 2778 81 DUP2 2779 81 DUP2 277A 11 GT 277B 15 ISZERO 277C 61 PUSH2 0x2788 277F 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2774 stack[-2] = stack[-5] + stack[-3] // @2777 stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x2788, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_2780: // Incoming jump from 0x277F, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @2786 stack[-8] // @2786 stack[-7] // } 2780 50 POP 2781 50 POP 2782 50 POP 2783 50 POP 2784 50 POP 2785 50 POP 2786 90 SWAP1 2787 56 *JUMP // Stack delta = -7 // Outputs[1] { @2786 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_2788: // Incoming jump from 0x277F, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @2789 stack[-5] // @278A returndata.length // @278B stack[-6] // @2790 stack[-1] // @2791 stack[-3] // } 2788 5B JUMPDEST 2789 84 DUP5 278A 3D RETURNDATASIZE 278B 87 DUP8 278C 01 ADD 278D 01 ADD 278E 60 PUSH1 0x20 2790 82 DUP3 2791 85 DUP6 2792 01 ADD 2793 01 ADD 2794 11 GT 2795 15 ISZERO 2796 61 PUSH2 0x27a2 2799 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x27a2, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_279A: // Incoming jump from 0x2799, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @27A0 stack[-7] // @27A0 stack[-8] // } 279A 50 POP 279B 50 POP 279C 50 POP 279D 50 POP 279E 50 POP 279F 50 POP 27A0 90 SWAP1 27A1 56 *JUMP // Stack delta = -7 // Outputs[1] { @27A0 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_27A2: // Incoming jump from 0x2799, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @27A8 stack[-1] // @27A9 stack[-4] // @27AC stack[-6] // } 27A2 5B JUMPDEST 27A3 61 PUSH2 0x27b1 27A6 60 PUSH1 0x20 27A8 82 DUP3 27A9 86 DUP7 27AA 01 ADD 27AB 01 ADD 27AC 87 DUP8 27AD 61 PUSH2 0x1b15 27B0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27A3 stack[0] = 0x27b1 // @27AB stack[1] = stack[-4] + stack[-1] + 0x20 // @27AC stack[2] = stack[-6] // } // Block ends with call to 0x1b15, returns to 0x27B1 label_27B1: // Incoming return from call to 0x1B15 at 0x27B0 // Inputs[4] // { // @27B3 stack[-3] // @27B3 stack[-2] // @27B4 stack[-8] // @27B5 stack[-7] // } 27B1 5B JUMPDEST 27B2 50 POP 27B3 90 SWAP1 27B4 95 SWAP6 27B5 94 SWAP5 27B6 50 POP 27B7 50 POP 27B8 50 POP 27B9 50 POP 27BA 50 POP 27BB 56 *JUMP // Stack delta = -7 // Outputs[1] { @27B4 stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_27BC: // Incoming call from 0x1697, returns to 0x03F8 // Inputs[2] // { // @27C0 stack[-1] // @2802 stack[-2] // } 27BC 5B JUMPDEST 27BD 60 PUSH1 0x20 27BF 80 DUP1 27C0 82 DUP3 27C1 52 MSTORE 27C2 60 PUSH1 0x28 27C4 90 SWAP1 27C5 82 DUP3 27C6 01 ADD 27C7 52 MSTORE 27C8 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 27E9 60 PUSH1 0x40 27EB 82 DUP3 27EC 01 ADD 27ED 52 MSTORE 27EE 67 PUSH8 0x6420746f6b656e73 27F7 60 PUSH1 0xc0 27F9 1B SHL 27FA 60 PUSH1 0x60 27FC 82 DUP3 27FD 01 ADD 27FE 52 MSTORE 27FF 60 PUSH1 0x80 2801 01 ADD 2802 90 SWAP1 2803 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @27C1 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @27C7 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @27ED memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @27FE memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6420746f6b656e73 << 0xc0 // @2802 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2804 5B JUMPDEST 2805 63 PUSH4 0x4e487b71 280A 60 PUSH1 0xe0 280C 1B SHL 280D 60 PUSH1 0x00 280F 52 MSTORE 2810 60 PUSH1 0x21 2812 60 PUSH1 0x04 2814 52 MSTORE 2815 60 PUSH1 0x24 2817 60 PUSH1 0x00 2819 FD *REVERT 281A 5B JUMPDEST 281B 60 PUSH1 0x01 281D 60 PUSH1 0x01 281F 60 PUSH1 0xa0 2821 1B SHL 2822 03 SUB 2823 86 DUP7 2824 81 DUP2 2825 16 AND 2826 82 DUP3 2827 52 MSTORE 2828 85 DUP6 2829 16 AND 282A 60 PUSH1 0x20 282C 82 DUP3 282D 01 ADD 282E 52 MSTORE 282F 60 PUSH1 0x40 2831 81 DUP2 2832 01 ADD 2833 84 DUP5 2834 90 SWAP1 2835 52 MSTORE 2836 60 PUSH1 0x60 2838 81 DUP2 2839 01 ADD 283A 83 DUP4 283B 90 SWAP1 283C 52 MSTORE 283D 60 PUSH1 0xa0 283F 60 PUSH1 0x80 2841 82 DUP3 2842 01 ADD 2843 81 DUP2 2844 90 SWAP1 2845 52 MSTORE 2846 60 PUSH1 0x00 2848 90 SWAP1 2849 61 PUSH2 0x2854 284C 90 SWAP1 284D 83 DUP4 284E 01 ADD 284F 84 DUP5 2850 61 PUSH2 0x1d57 2853 56 *JUMP 2854 5B JUMPDEST 2855 97 SWAP8 2856 96 SWAP7 2857 50 POP 2858 50 POP 2859 50 POP 285A 50 POP 285B 50 POP 285C 50 POP 285D 50 POP 285E 56 *JUMP 285F FE *ASSERT 2860 A2 LOG2 2861 64 PUSH5 0x6970667358 2867 22 22 2868 12 SLT 2869 20 SHA3 286A C3 C3 286B 08 ADDMOD 286C C2 C2 286D E7 E7 286E 73 PUSH20 0x3f6c2c729d01d386b27b10908514e78762b4729e 2883 30 ADDRESS 2884 CE CE 2885 0B SIGNEXTEND 2886 4B 4B 2887 F9 F9 2888 4C 4C 2889 42 TIMESTAMP 288A 64 PUSH5 0x736f6c6343 2890 00 *STOP 2891 08 ADDMOD 2892 11 GT 2893 00 *STOP 2894 33 CALLER