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 0x0225 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0225, 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 0x67db3b8f 0026 11 GT 0027 61 PUSH2 0x0130 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0130, if 0x67db3b8f > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x67db3b8f > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa22cb465 0031 11 GT 0032 61 PUSH2 0x00b8 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b8, if 0xa22cb465 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd7423031 003C 11 GT 003D 61 PUSH2 0x007c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xd7423031 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd7423031 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd7423031 0047 14 EQ 0048 61 PUSH2 0x0488 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0488, if 0xd7423031 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd7423031 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x04ab 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ab, if 0xe985e9c5 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf242432a 005D 14 EQ 005E 61 PUSH2 0x04e7 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e7, if 0xf242432a == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf242432a == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x04fa 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fa, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf86f3b39 0073 14 EQ 0074 61 PUSH2 0x050d 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050d, if 0xf86f3b39 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf86f3b39 == stack[-1] // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x0040, if 0xd7423031 > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xa22cb465 0083 14 EQ 0084 61 PUSH2 0x040c 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040c, if 0xa22cb465 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xbd85b039 008E 14 EQ 008F 61 PUSH2 0x041f 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041f, if 0xbd85b039 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xbd85b039 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xc15d0e21 0099 14 EQ 009A 61 PUSH2 0x043f 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043f, if 0xc15d0e21 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xc15d0e21 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x0452 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0452, if 0xc87b56dd == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0xc94ccfc7 00AF 14 EQ 00B0 61 PUSH2 0x0465 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0465, if 0xc94ccfc7 == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xc94ccfc7 == stack[-1] // Inputs[1] { @00B7 memory[0x00:0x00] } 00B4 60 PUSH1 0x00 00B6 80 DUP1 00B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B7 revert(memory[0x00:0x00]); } // Block terminates label_00B8: // Incoming jump from 0x0035, if 0xa22cb465 > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B8 5B JUMPDEST 00B9 80 DUP1 00BA 63 PUSH4 0x8456cb59 00BF 11 GT 00C0 61 PUSH2 0x00ff 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ff, if 0x8456cb59 > stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x8456cb59 > stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x8456cb59 00CA 14 EQ 00CB 61 PUSH2 0x03bb 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bb, if 0x8456cb59 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x8456cb59 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x87e2ba65 00D5 14 EQ 00D6 61 PUSH2 0x03c3 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c3, if 0x87e2ba65 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x87e2ba65 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x8da5cb5b 00E0 14 EQ 00E1 61 PUSH2 0x03d6 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d6, if 0x8da5cb5b == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x9293a5c7 00EB 14 EQ 00EC 61 PUSH2 0x03f1 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f1, if 0x9293a5c7 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x9293a5c7 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x95d89b41 00F6 14 EQ 00F7 61 PUSH2 0x0404 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0404, if 0x95d89b41 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00FE memory[0x00:0x00] } 00FB 60 PUSH1 0x00 00FD 80 DUP1 00FE FD *REVERT // Stack delta = +0 // Outputs[1] { @00FE revert(memory[0x00:0x00]); } // Block terminates label_00FF: // Incoming jump from 0x00C3, if 0x8456cb59 > stack[-1] // Inputs[1] { @0100 stack[-1] } 00FF 5B JUMPDEST 0100 80 DUP1 0101 63 PUSH4 0x67db3b8f 0106 14 EQ 0107 61 PUSH2 0x0390 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0390, if 0x67db3b8f == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x67db3b8f == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x67dde6d5 0111 14 EQ 0112 61 PUSH2 0x03a3 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a3, if 0x67dde6d5 == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x67dde6d5 == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x6ad9e4b5 011C 14 EQ 011D 61 PUSH2 0x03ab 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ab, if 0x6ad9e4b5 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x6ad9e4b5 == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x715018a6 0127 14 EQ 0128 61 PUSH2 0x03b3 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b3, if 0x715018a6 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x715018a6 == stack[-1] // Inputs[1] { @012F memory[0x00:0x00] } 012C 60 PUSH1 0x00 012E 80 DUP1 012F FD *REVERT // Stack delta = +0 // Outputs[1] { @012F revert(memory[0x00:0x00]); } // Block terminates label_0130: // Incoming jump from 0x002A, if 0x67db3b8f > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0131 stack[-1] } 0130 5B JUMPDEST 0131 80 DUP1 0132 63 PUSH4 0x1f0234d8 0137 11 GT 0138 61 PUSH2 0x01b3 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b3, if 0x1f0234d8 > stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x1f0234d8 > stack[-1] // Inputs[1] { @013C stack[-1] } 013C 80 DUP1 013D 63 PUSH4 0x3f4ba83a 0142 11 GT 0143 61 PUSH2 0x0182 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0182, if 0x3f4ba83a > stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x3f4ba83a > stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x3f4ba83a 014D 14 EQ 014E 61 PUSH2 0x0321 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0321, if 0x3f4ba83a == stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x4e1273f4 0158 14 EQ 0159 61 PUSH2 0x0329 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0329, if 0x4e1273f4 == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x4f558e79 0163 14 EQ 0164 61 PUSH2 0x0349 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0349, if 0x4f558e79 == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x4f558e79 == stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x52862de8 016E 14 EQ 016F 61 PUSH2 0x036b 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036b, if 0x52862de8 == stack[-1] label_0173: // Incoming jump from 0x0172, if not 0x52862de8 == stack[-1] // Inputs[1] { @0173 stack[-1] } 0173 80 DUP1 0174 63 PUSH4 0x5c975abb 0179 14 EQ 017A 61 PUSH2 0x037e 017D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037e, if 0x5c975abb == stack[-1] label_017E: // Incoming jump from 0x017D, if not 0x5c975abb == stack[-1] // Inputs[1] { @0181 memory[0x00:0x00] } 017E 60 PUSH1 0x00 0180 80 DUP1 0181 FD *REVERT // Stack delta = +0 // Outputs[1] { @0181 revert(memory[0x00:0x00]); } // Block terminates label_0182: // Incoming jump from 0x0146, if 0x3f4ba83a > stack[-1] // Inputs[1] { @0183 stack[-1] } 0182 5B JUMPDEST 0183 80 DUP1 0184 63 PUSH4 0x1f0234d8 0189 14 EQ 018A 61 PUSH2 0x02e5 018D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e5, if 0x1f0234d8 == stack[-1] label_018E: // Incoming jump from 0x018D, if not 0x1f0234d8 == stack[-1] // Inputs[1] { @018E stack[-1] } 018E 80 DUP1 018F 63 PUSH4 0x2eb2c2d6 0194 14 EQ 0195 61 PUSH2 0x02f2 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f2, if 0x2eb2c2d6 == stack[-1] label_0199: // Incoming jump from 0x0198, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0199 stack[-1] } 0199 80 DUP1 019A 63 PUSH4 0x32cb6b0c 019F 14 EQ 01A0 61 PUSH2 0x0305 01A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0305, if 0x32cb6b0c == stack[-1] label_01A4: // Incoming jump from 0x01A3, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @01A4 stack[-1] } 01A4 80 DUP1 01A5 63 PUSH4 0x3ca6fb8c 01AA 14 EQ 01AB 61 PUSH2 0x030e 01AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030e, if 0x3ca6fb8c == stack[-1] label_01AF: // Incoming jump from 0x01AE, if not 0x3ca6fb8c == stack[-1] // Inputs[1] { @01B2 memory[0x00:0x00] } 01AF 60 PUSH1 0x00 01B1 80 DUP1 01B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B2 revert(memory[0x00:0x00]); } // Block terminates label_01B3: // Incoming jump from 0x013B, if 0x1f0234d8 > stack[-1] // Inputs[1] { @01B4 stack[-1] } 01B3 5B JUMPDEST 01B4 80 DUP1 01B5 63 PUSH4 0x06fdde03 01BA 11 GT 01BB 61 PUSH2 0x01fa 01BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fa, if 0x06fdde03 > stack[-1] label_01BF: // Incoming jump from 0x01BE, if not 0x06fdde03 > stack[-1] // Inputs[1] { @01BF stack[-1] } 01BF 80 DUP1 01C0 63 PUSH4 0x06fdde03 01C5 14 EQ 01C6 61 PUSH2 0x029b 01C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029b, if 0x06fdde03 == stack[-1] label_01CA: // Incoming jump from 0x01C9, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01CA stack[-1] } 01CA 80 DUP1 01CB 63 PUSH4 0x0e89341c 01D0 14 EQ 01D1 61 PUSH2 0x02b0 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b0, if 0x0e89341c == stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x0e89341c == stack[-1] // Inputs[1] { @01D5 stack[-1] } 01D5 80 DUP1 01D6 63 PUSH4 0x0f73bcce 01DB 14 EQ 01DC 61 PUSH2 0x02c3 01DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c3, if 0x0f73bcce == stack[-1] label_01E0: // Incoming jump from 0x01DF, if not 0x0f73bcce == stack[-1] // Inputs[1] { @01E0 stack[-1] } 01E0 80 DUP1 01E1 63 PUSH4 0x0fcf2e75 01E6 14 EQ 01E7 61 PUSH2 0x02cb 01EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cb, if 0x0fcf2e75 == stack[-1] label_01EB: // Incoming jump from 0x01EA, if not 0x0fcf2e75 == stack[-1] // Inputs[1] { @01EB stack[-1] } 01EB 80 DUP1 01EC 63 PUSH4 0x1249c58b 01F1 14 EQ 01F2 61 PUSH2 0x02dd 01F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02dd, if 0x1249c58b == stack[-1] label_01F6: // Incoming jump from 0x01F5, if not 0x1249c58b == stack[-1] // Inputs[1] { @01F9 memory[0x00:0x00] } 01F6 60 PUSH1 0x00 01F8 80 DUP1 01F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F9 revert(memory[0x00:0x00]); } // Block terminates label_01FA: // Incoming jump from 0x01BE, if 0x06fdde03 > stack[-1] // Inputs[1] { @01FB stack[-1] } 01FA 5B JUMPDEST 01FB 80 DUP1 01FC 62 PUSH3 0x4a84cb 0200 14 EQ 0201 61 PUSH2 0x022a 0204 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022a, if 0x4a84cb == stack[-1] label_0205: // Incoming jump from 0x0204, if not 0x4a84cb == stack[-1] // Inputs[1] { @0205 stack[-1] } 0205 80 DUP1 0206 62 PUSH3 0xfdd58e 020A 14 EQ 020B 61 PUSH2 0x023f 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0xfdd58e == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0xfdd58e == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x01ffc9a7 0215 14 EQ 0216 61 PUSH2 0x0265 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0265, if 0x01ffc9a7 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x046dc166 0220 14 EQ 0221 61 PUSH2 0x0288 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0288, if 0x046dc166 == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x046dc166 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @0229 memory[0x00:0x00] } 0225 5B JUMPDEST 0226 60 PUSH1 0x00 0228 80 DUP1 0229 FD *REVERT // Stack delta = +0 // Outputs[1] { @0229 revert(memory[0x00:0x00]); } // Block terminates label_022A: // Incoming jump from 0x0204, if 0x4a84cb == stack[-1] // Inputs[1] { @0231 msg.data.length } 022A 5B JUMPDEST 022B 61 PUSH2 0x023d 022E 61 PUSH2 0x0238 0231 36 CALLDATASIZE 0232 60 PUSH1 0x04 0234 61 PUSH2 0x28c6 0237 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @022B stack[0] = 0x023d // @022E stack[1] = 0x0238 // @0231 stack[2] = msg.data.length // @0232 stack[3] = 0x04 // } // Block ends with call to 0x28c6, returns to 0x0238 label_0238: // Incoming return from call to 0x28C6 at 0x0237 0238 5B JUMPDEST 0239 61 PUSH2 0x0520 023C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0520 label_023D: // Incoming return from call to 0x0F19 at 0x03BA // Incoming return from call to 0x0BEE at 0x0328 // Incoming return from call to 0x0508 at 0x0507 // Incoming return from call to 0x041A at 0x0419 // Incoming return from call to 0x0F4D at 0x03C2 // Incoming return from call to 0x03D1 at 0x03D0 // Incoming return from call to 0x0296 at 0x0295 // Incoming return from call to 0x03FF at 0x03FE // Incoming return from call to 0x0379 at 0x0378 // Incoming return from call to 0x031C at 0x031B 023D 5B JUMPDEST 023E 00 *STOP // Stack delta = +0 // Outputs[1] { @023E stop(); } // Block terminates label_023F: // Incoming jump from 0x020E, if 0xfdd58e == stack[-1] // Inputs[1] { @0246 msg.data.length } 023F 5B JUMPDEST 0240 61 PUSH2 0x0252 0243 61 PUSH2 0x024d 0246 36 CALLDATASIZE 0247 60 PUSH1 0x04 0249 61 PUSH2 0x289c 024C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0240 stack[0] = 0x0252 // @0243 stack[1] = 0x024d // @0246 stack[2] = msg.data.length // @0247 stack[3] = 0x04 // } // Block ends with call to 0x289c, returns to 0x024D label_024D: // Incoming return from call to 0x289C at 0x024C 024D 5B JUMPDEST 024E 61 PUSH2 0x0657 0251 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0657 label_0252: // Incoming return from call to 0x042D at 0x042C // Incoming return from call to 0x024D at 0x024C // Incoming jump from 0x030D // Incoming jump from 0x02CA // Incoming jump from 0x03AA // Incoming jump from 0x03B2 // Inputs[4] // { // @0255 memory[0x40:0x60] // @0256 stack[-1] // @025F memory[0x40:0x60] // @0264 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0252 5B JUMPDEST 0253 60 PUSH1 0x40 0255 51 MLOAD 0256 90 SWAP1 0257 81 DUP2 0258 52 MSTORE 0259 60 PUSH1 0x20 025B 01 ADD 025C 5B JUMPDEST 025D 60 PUSH1 0x40 025F 51 MLOAD 0260 80 DUP1 0261 91 SWAP2 0262 03 SUB 0263 90 SWAP1 0264 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0258 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0264 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0265: // Incoming jump from 0x0219, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @026C msg.data.length } 0265 5B JUMPDEST 0266 61 PUSH2 0x0278 0269 61 PUSH2 0x0273 026C 36 CALLDATASIZE 026D 60 PUSH1 0x04 026F 61 PUSH2 0x2af0 0272 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0266 stack[0] = 0x0278 // @0269 stack[1] = 0x0273 // @026C stack[2] = msg.data.length // @026D stack[3] = 0x04 // } // Block ends with call to 0x2af0, returns to 0x0273 label_0273: // Incoming return from call to 0x2AF0 at 0x0272 0273 5B JUMPDEST 0274 61 PUSH2 0x06e9 0277 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06e9 label_0278: // Incoming return from call to 0x04B9 at 0x04B8 // Incoming return from call to 0x0357 at 0x0356 // Incoming return from call to 0x0473 at 0x0472 // Incoming return from call to 0x0496 at 0x0495 // Incoming jump from 0x038F // Incoming return from call to 0x0273 at 0x0272 // Incoming jump from 0x02DC // Incoming jump from 0x02F1 // Inputs[2] // { // @027B memory[0x40:0x60] // @027C stack[-1] // } 0278 5B JUMPDEST 0279 60 PUSH1 0x40 027B 51 MLOAD 027C 90 SWAP1 027D 15 ISZERO 027E 15 ISZERO 027F 81 DUP2 0280 52 MSTORE 0281 60 PUSH1 0x20 0283 01 ADD 0284 61 PUSH2 0x025c 0287 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0280 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0283 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x025c label_0288: // Incoming jump from 0x0224, if 0x046dc166 == stack[-1] // Inputs[1] { @028F msg.data.length } 0288 5B JUMPDEST 0289 61 PUSH2 0x023d 028C 61 PUSH2 0x0296 028F 36 CALLDATASIZE 0290 60 PUSH1 0x04 0292 61 PUSH2 0x2710 0295 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0289 stack[0] = 0x023d // @028C stack[1] = 0x0296 // @028F stack[2] = msg.data.length // @0290 stack[3] = 0x04 // } // Block ends with call to 0x2710, returns to 0x0296 label_0296: // Incoming return from call to 0x2710 at 0x0295 0296 5B JUMPDEST 0297 61 PUSH2 0x073b 029A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x073b label_029B: // Incoming jump from 0x01C9, if 0x06fdde03 == stack[-1] 029B 5B JUMPDEST 029C 61 PUSH2 0x02a3 029F 61 PUSH2 0x07a2 02A2 56 *JUMP // Stack delta = +1 // Outputs[1] { @029C stack[0] = 0x02a3 } // Block ends with call to 0x07a2, returns to 0x02A3 label_02A3: // Incoming return from call to 0x0460 at 0x045F // Incoming return from call to 0x113B at 0x040B // Incoming return from call to 0x02BE at 0x02BD // Incoming return from call to 0x07A2 at 0x02A2 // Inputs[2] // { // @02A6 memory[0x40:0x60] // @02AA stack[-1] // } 02A3 5B JUMPDEST 02A4 60 PUSH1 0x40 02A6 51 MLOAD 02A7 61 PUSH2 0x025c 02AA 91 SWAP2 02AB 90 SWAP1 02AC 61 PUSH2 0x2d2f 02AF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02AA stack[-1] = 0x025c // @02AB stack[1] = memory[0x40:0x60] // @02AB stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2d2f label_02B0: // Incoming jump from 0x01D4, if 0x0e89341c == stack[-1] // Inputs[1] { @02B7 msg.data.length } 02B0 5B JUMPDEST 02B1 61 PUSH2 0x02a3 02B4 61 PUSH2 0x02be 02B7 36 CALLDATASIZE 02B8 60 PUSH1 0x04 02BA 61 PUSH2 0x2baa 02BD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B1 stack[0] = 0x02a3 // @02B4 stack[1] = 0x02be // @02B7 stack[2] = msg.data.length // @02B8 stack[3] = 0x04 // } // Block ends with call to 0x2baa, returns to 0x02BE label_02BE: // Incoming return from call to 0x2BAA at 0x02BD 02BE 5B JUMPDEST 02BF 61 PUSH2 0x0830 02C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0830 label_02C3: // Incoming jump from 0x01DF, if 0x0f73bcce == stack[-1] 02C3 5B JUMPDEST 02C4 61 PUSH2 0x0252 02C7 60 PUSH1 0x03 02C9 81 DUP2 02CA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02C4 stack[0] = 0x0252 // @02C7 stack[1] = 0x03 // } // Block ends with unconditional jump to 0x0252 label_02CB: // Incoming jump from 0x01EA, if 0x0fcf2e75 == stack[-1] // Inputs[1] { @02CE storage[0x07] } 02CB 5B JUMPDEST 02CC 60 PUSH1 0x07 02CE 54 SLOAD 02CF 61 PUSH2 0x0278 02D2 90 SWAP1 02D3 61 PUSH2 0x0100 02D6 90 SWAP1 02D7 04 DIV 02D8 60 PUSH1 0xff 02DA 16 AND 02DB 81 DUP2 02DC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02D2 stack[0] = 0x0278 // @02DA stack[1] = 0xff & storage[0x07] / 0x0100 // } // Block ends with unconditional jump to 0x0278 label_02DD: // Incoming jump from 0x01F5, if 0x1249c58b == stack[-1] 02DD 5B JUMPDEST 02DE 61 PUSH2 0x023d 02E1 61 PUSH2 0x08fc 02E4 56 *JUMP // Stack delta = +1 // Outputs[1] { @02DE stack[0] = 0x023d } // Block ends with unconditional jump to 0x08fc label_02E5: // Incoming jump from 0x018D, if 0x1f0234d8 == stack[-1] // Inputs[1] { @02E8 storage[0x07] } 02E5 5B JUMPDEST 02E6 60 PUSH1 0x07 02E8 54 SLOAD 02E9 61 PUSH2 0x0278 02EC 90 SWAP1 02ED 60 PUSH1 0xff 02EF 16 AND 02F0 81 DUP2 02F1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02EC stack[0] = 0x0278 // @02EF stack[1] = 0xff & storage[0x07] // } // Block ends with unconditional jump to 0x0278 label_02F2: // Incoming jump from 0x0198, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @02F9 msg.data.length } 02F2 5B JUMPDEST 02F3 61 PUSH2 0x023d 02F6 61 PUSH2 0x0300 02F9 36 CALLDATASIZE 02FA 60 PUSH1 0x04 02FC 61 PUSH2 0x2765 02FF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F3 stack[0] = 0x023d // @02F6 stack[1] = 0x0300 // @02F9 stack[2] = msg.data.length // @02FA stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2765 0300 5B JUMPDEST 0301 61 PUSH2 0x0ac1 0304 56 *JUMP label_0305: // Incoming jump from 0x01A3, if 0x32cb6b0c == stack[-1] 0305 5B JUMPDEST 0306 61 PUSH2 0x0252 0309 61 PUSH2 0x1388 030C 81 DUP2 030D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0306 stack[0] = 0x0252 // @0309 stack[1] = 0x1388 // } // Block ends with unconditional jump to 0x0252 label_030E: // Incoming jump from 0x01AE, if 0x3ca6fb8c == stack[-1] // Inputs[1] { @0315 msg.data.length } 030E 5B JUMPDEST 030F 61 PUSH2 0x023d 0312 61 PUSH2 0x031c 0315 36 CALLDATASIZE 0316 60 PUSH1 0x04 0318 61 PUSH2 0x2a5a 031B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @030F stack[0] = 0x023d // @0312 stack[1] = 0x031c // @0315 stack[2] = msg.data.length // @0316 stack[3] = 0x04 // } // Block ends with call to 0x2a5a, returns to 0x031C label_031C: // Incoming return from call to 0x2A5A at 0x031B 031C 5B JUMPDEST 031D 61 PUSH2 0x0b58 0320 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b58 label_0321: // Incoming jump from 0x0151, if 0x3f4ba83a == stack[-1] 0321 5B JUMPDEST 0322 61 PUSH2 0x023d 0325 61 PUSH2 0x0bee 0328 56 *JUMP // Stack delta = +1 // Outputs[1] { @0322 stack[0] = 0x023d } // Block ends with call to 0x0bee, returns to 0x023D label_0329: // Incoming jump from 0x015C, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0330 msg.data.length } 0329 5B JUMPDEST 032A 61 PUSH2 0x033c 032D 61 PUSH2 0x0337 0330 36 CALLDATASIZE 0331 60 PUSH1 0x04 0333 61 PUSH2 0x298a 0336 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @032A stack[0] = 0x033c // @032D stack[1] = 0x0337 // @0330 stack[2] = msg.data.length // @0331 stack[3] = 0x04 // } // Block ends with call to 0x298a, returns to 0x0337 label_0337: // Incoming return from call to 0x298A at 0x0336 0337 5B JUMPDEST 0338 61 PUSH2 0x0c22 033B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c22 label_033C: // Incoming return from call to 0x0337 at 0x0336 // Inputs[2] // { // @033F memory[0x40:0x60] // @0343 stack[-1] // } 033C 5B JUMPDEST 033D 60 PUSH1 0x40 033F 51 MLOAD 0340 61 PUSH2 0x025c 0343 91 SWAP2 0344 90 SWAP1 0345 61 PUSH2 0x2cee 0348 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0343 stack[-1] = 0x025c // @0344 stack[1] = memory[0x40:0x60] // @0344 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2cee label_0349: // Incoming jump from 0x0167, if 0x4f558e79 == stack[-1] // Inputs[1] { @0350 msg.data.length } 0349 5B JUMPDEST 034A 61 PUSH2 0x0278 034D 61 PUSH2 0x0357 0350 36 CALLDATASIZE 0351 60 PUSH1 0x04 0353 61 PUSH2 0x2baa 0356 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @034A stack[0] = 0x0278 // @034D stack[1] = 0x0357 // @0350 stack[2] = msg.data.length // @0351 stack[3] = 0x04 // } // Block ends with call to 0x2baa, returns to 0x0357 label_0357: // Incoming return from call to 0x2BAA at 0x0356 // Inputs[4] // { // @035A stack[-1] // @0365 memory[0x00:0x40] // @0366 storage[keccak256(memory[0x00:0x40])] // @0369 stack[-2] // } 0357 5B JUMPDEST 0358 60 PUSH1 0x00 035A 90 SWAP1 035B 81 DUP2 035C 52 MSTORE 035D 60 PUSH1 0x03 035F 60 PUSH1 0x20 0361 52 MSTORE 0362 60 PUSH1 0x40 0364 90 SWAP1 0365 20 SHA3 0366 54 SLOAD 0367 15 ISZERO 0368 15 ISZERO 0369 90 SWAP1 036A 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @035C memory[0x00:0x20] = stack[-1] // @0361 memory[0x20:0x40] = 0x03 // @0369 stack[-2] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_036B: // Incoming jump from 0x0172, if 0x52862de8 == stack[-1] // Inputs[1] { @0372 msg.data.length } 036B 5B JUMPDEST 036C 61 PUSH2 0x023d 036F 61 PUSH2 0x0379 0372 36 CALLDATASIZE 0373 60 PUSH1 0x04 0375 61 PUSH2 0x293a 0378 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036C stack[0] = 0x023d // @036F stack[1] = 0x0379 // @0372 stack[2] = msg.data.length // @0373 stack[3] = 0x04 // } // Block ends with call to 0x293a, returns to 0x0379 label_0379: // Incoming return from call to 0x293A at 0x0378 0379 5B JUMPDEST 037A 61 PUSH2 0x0d4b 037D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d4b label_037E: // Incoming jump from 0x017D, if 0x5c975abb == stack[-1] // Inputs[1] { @0381 storage[0x04] } 037E 5B JUMPDEST 037F 60 PUSH1 0x04 0381 54 SLOAD 0382 60 PUSH1 0x01 0384 60 PUSH1 0xa0 0386 1B SHL 0387 90 SWAP1 0388 04 DIV 0389 60 PUSH1 0xff 038B 16 AND 038C 61 PUSH2 0x0278 038F 56 *JUMP // Stack delta = +1 // Outputs[1] { @038B stack[0] = 0xff & storage[0x04] / (0x01 << 0xa0) } // Block ends with unconditional jump to 0x0278 label_0390: // Incoming jump from 0x010A, if 0x67db3b8f == stack[-1] // Inputs[1] { @0397 msg.data.length } 0390 5B JUMPDEST 0391 61 PUSH2 0x023d 0394 61 PUSH2 0x039e 0397 36 CALLDATASIZE 0398 60 PUSH1 0x04 039A 61 PUSH2 0x2b66 039D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0391 stack[0] = 0x023d // @0394 stack[1] = 0x039e // @0397 stack[2] = msg.data.length // @0398 stack[3] = 0x04 // } // Block ends with call to 0x2b66, returns to 0x039E label_039E: // Incoming return from call to 0x2B66 at 0x039D 039E 5B JUMPDEST 039F 61 PUSH2 0x0ed0 03A2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ed0 label_03A3: // Incoming jump from 0x0115, if 0x67dde6d5 == stack[-1] 03A3 5B JUMPDEST 03A4 61 PUSH2 0x0252 03A7 60 PUSH1 0x02 03A9 81 DUP2 03AA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03A4 stack[0] = 0x0252 // @03A7 stack[1] = 0x02 // } // Block ends with unconditional jump to 0x0252 label_03AB: // Incoming jump from 0x0120, if 0x6ad9e4b5 == stack[-1] 03AB 5B JUMPDEST 03AC 61 PUSH2 0x0252 03AF 60 PUSH1 0x01 03B1 81 DUP2 03B2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03AC stack[0] = 0x0252 // @03AF stack[1] = 0x01 // } // Block ends with unconditional jump to 0x0252 label_03B3: // Incoming jump from 0x012B, if 0x715018a6 == stack[-1] 03B3 5B JUMPDEST 03B4 61 PUSH2 0x023d 03B7 61 PUSH2 0x0f19 03BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @03B4 stack[0] = 0x023d } // Block ends with call to 0x0f19, returns to 0x023D label_03BB: // Incoming jump from 0x00CE, if 0x8456cb59 == stack[-1] 03BB 5B JUMPDEST 03BC 61 PUSH2 0x023d 03BF 61 PUSH2 0x0f4d 03C2 56 *JUMP // Stack delta = +1 // Outputs[1] { @03BC stack[0] = 0x023d } // Block ends with call to 0x0f4d, returns to 0x023D label_03C3: // Incoming jump from 0x00D9, if 0x87e2ba65 == stack[-1] // Inputs[1] { @03CA msg.data.length } 03C3 5B JUMPDEST 03C4 61 PUSH2 0x023d 03C7 61 PUSH2 0x03d1 03CA 36 CALLDATASIZE 03CB 60 PUSH1 0x04 03CD 61 PUSH2 0x28f9 03D0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C4 stack[0] = 0x023d // @03C7 stack[1] = 0x03d1 // @03CA stack[2] = msg.data.length // @03CB stack[3] = 0x04 // } // Block ends with call to 0x28f9, returns to 0x03D1 label_03D1: // Incoming return from call to 0x28F9 at 0x03D0 03D1 5B JUMPDEST 03D2 61 PUSH2 0x0f7f 03D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f7f label_03D6: // Incoming jump from 0x00E4, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @03D9 storage[0x04] // @03DC memory[0x40:0x60] // } 03D6 5B JUMPDEST 03D7 60 PUSH1 0x04 03D9 54 SLOAD 03DA 60 PUSH1 0x40 03DC 51 MLOAD 03DD 60 PUSH1 0x01 03DF 60 PUSH1 0x01 03E1 60 PUSH1 0xa0 03E3 1B SHL 03E4 03 SUB 03E5 90 SWAP1 03E6 91 SWAP2 03E7 16 AND 03E8 81 DUP2 03E9 52 MSTORE 03EA 60 PUSH1 0x20 03EC 01 ADD 03ED 61 PUSH2 0x025c 03F0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x04] & (0x01 << 0xa0) - 0x01 // @03EC stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x025c label_03F1: // Incoming jump from 0x00EF, if 0x9293a5c7 == stack[-1] // Inputs[1] { @03F8 msg.data.length } 03F1 5B JUMPDEST 03F2 61 PUSH2 0x023d 03F5 61 PUSH2 0x03ff 03F8 36 CALLDATASIZE 03F9 60 PUSH1 0x04 03FB 61 PUSH2 0x2a5a 03FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03F2 stack[0] = 0x023d // @03F5 stack[1] = 0x03ff // @03F8 stack[2] = msg.data.length // @03F9 stack[3] = 0x04 // } // Block ends with call to 0x2a5a, returns to 0x03FF label_03FF: // Incoming return from call to 0x2A5A at 0x03FE 03FF 5B JUMPDEST 0400 61 PUSH2 0x1098 0403 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1098 label_0404: // Incoming jump from 0x00FA, if 0x95d89b41 == stack[-1] 0404 5B JUMPDEST 0405 61 PUSH2 0x02a3 0408 61 PUSH2 0x113b 040B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0405 stack[0] = 0x02a3 } // Block ends with call to 0x113b, returns to 0x02A3 label_040C: // Incoming jump from 0x0087, if 0xa22cb465 == stack[-1] // Inputs[1] { @0413 msg.data.length } 040C 5B JUMPDEST 040D 61 PUSH2 0x023d 0410 61 PUSH2 0x041a 0413 36 CALLDATASIZE 0414 60 PUSH1 0x04 0416 61 PUSH2 0x2872 0419 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @040D stack[0] = 0x023d // @0410 stack[1] = 0x041a // @0413 stack[2] = msg.data.length // @0414 stack[3] = 0x04 // } // Block ends with call to 0x2872, returns to 0x041A label_041A: // Incoming return from call to 0x2872 at 0x0419 041A 5B JUMPDEST 041B 61 PUSH2 0x1148 041E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1148 label_041F: // Incoming jump from 0x0092, if 0xbd85b039 == stack[-1] // Inputs[1] { @0426 msg.data.length } 041F 5B JUMPDEST 0420 61 PUSH2 0x0252 0423 61 PUSH2 0x042d 0426 36 CALLDATASIZE 0427 60 PUSH1 0x04 0429 61 PUSH2 0x2baa 042C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0420 stack[0] = 0x0252 // @0423 stack[1] = 0x042d // @0426 stack[2] = msg.data.length // @0427 stack[3] = 0x04 // } // Block ends with call to 0x2baa, returns to 0x042D label_042D: // Incoming return from call to 0x2BAA at 0x042C // Inputs[4] // { // @0430 stack[-1] // @043B memory[0x00:0x40] // @043C storage[keccak256(memory[0x00:0x40])] // @043D stack[-2] // } 042D 5B JUMPDEST 042E 60 PUSH1 0x00 0430 90 SWAP1 0431 81 DUP2 0432 52 MSTORE 0433 60 PUSH1 0x03 0435 60 PUSH1 0x20 0437 52 MSTORE 0438 60 PUSH1 0x40 043A 90 SWAP1 043B 20 SHA3 043C 54 SLOAD 043D 90 SWAP1 043E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0432 memory[0x00:0x20] = stack[-1] // @0437 memory[0x20:0x40] = 0x03 // @043D stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_043F: // Incoming jump from 0x009D, if 0xc15d0e21 == stack[-1] // Inputs[1] { @0446 msg.data.length } 043F 5B JUMPDEST 0440 61 PUSH2 0x023d 0443 61 PUSH2 0x044d 0446 36 CALLDATASIZE 0447 60 PUSH1 0x04 0449 61 PUSH2 0x2b2a 044C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0440 stack[0] = 0x023d // @0443 stack[1] = 0x044d // @0446 stack[2] = msg.data.length // @0447 stack[3] = 0x04 // } // Block ends with call to 0x2b2a, returns to 0x044D label_044D: // Incoming return from call to 0x2B2A at 0x044C 044D 5B JUMPDEST 044E 61 PUSH2 0x1157 0451 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1157 label_0452: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @0459 msg.data.length } 0452 5B JUMPDEST 0453 61 PUSH2 0x02a3 0456 61 PUSH2 0x0460 0459 36 CALLDATASIZE 045A 60 PUSH1 0x04 045C 61 PUSH2 0x2baa 045F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0453 stack[0] = 0x02a3 // @0456 stack[1] = 0x0460 // @0459 stack[2] = msg.data.length // @045A stack[3] = 0x04 // } // Block ends with call to 0x2baa, returns to 0x0460 label_0460: // Incoming return from call to 0x2BAA at 0x045F 0460 5B JUMPDEST 0461 61 PUSH2 0x118a 0464 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x118a label_0465: // Incoming jump from 0x00B3, if 0xc94ccfc7 == stack[-1] // Inputs[1] { @046C msg.data.length } 0465 5B JUMPDEST 0466 61 PUSH2 0x0278 0469 61 PUSH2 0x0473 046C 36 CALLDATASIZE 046D 60 PUSH1 0x04 046F 61 PUSH2 0x2710 0472 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0466 stack[0] = 0x0278 // @0469 stack[1] = 0x0473 // @046C stack[2] = msg.data.length // @046D stack[3] = 0x04 // } // Block ends with call to 0x2710, returns to 0x0473 label_0473: // Incoming return from call to 0x2710 at 0x0472 // Inputs[4] // { // @047B stack[-1] // @0481 memory[0x00:0x40] // @0482 storage[keccak256(memory[0x00:0x40])] // @0486 stack[-2] // } 0473 5B JUMPDEST 0474 60 PUSH1 0x0a 0476 60 PUSH1 0x20 0478 52 MSTORE 0479 60 PUSH1 0x00 047B 90 SWAP1 047C 81 DUP2 047D 52 MSTORE 047E 60 PUSH1 0x40 0480 90 SWAP1 0481 20 SHA3 0482 54 SLOAD 0483 60 PUSH1 0xff 0485 16 AND 0486 81 DUP2 0487 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0478 memory[0x20:0x40] = 0x0a // @047D memory[0x00:0x20] = stack[-1] // @0485 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0488: // Incoming jump from 0x004B, if 0xd7423031 == stack[-1] // Inputs[1] { @048F msg.data.length } 0488 5B JUMPDEST 0489 61 PUSH2 0x0278 048C 61 PUSH2 0x0496 048F 36 CALLDATASIZE 0490 60 PUSH1 0x04 0492 61 PUSH2 0x2baa 0495 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0489 stack[0] = 0x0278 // @048C stack[1] = 0x0496 // @048F stack[2] = msg.data.length // @0490 stack[3] = 0x04 // } // Block ends with call to 0x2baa, returns to 0x0496 label_0496: // Incoming return from call to 0x2BAA at 0x0495 // Inputs[4] // { // @049E stack[-1] // @04A4 memory[0x00:0x40] // @04A5 storage[keccak256(memory[0x00:0x40])] // @04A9 stack[-2] // } 0496 5B JUMPDEST 0497 60 PUSH1 0x08 0499 60 PUSH1 0x20 049B 52 MSTORE 049C 60 PUSH1 0x00 049E 90 SWAP1 049F 81 DUP2 04A0 52 MSTORE 04A1 60 PUSH1 0x40 04A3 90 SWAP1 04A4 20 SHA3 04A5 54 SLOAD 04A6 60 PUSH1 0xff 04A8 16 AND 04A9 81 DUP2 04AA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @049B memory[0x20:0x40] = 0x08 // @04A0 memory[0x00:0x20] = stack[-1] // @04A8 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_04AB: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @04B2 msg.data.length } 04AB 5B JUMPDEST 04AC 61 PUSH2 0x0278 04AF 61 PUSH2 0x04b9 04B2 36 CALLDATASIZE 04B3 60 PUSH1 0x04 04B5 61 PUSH2 0x2732 04B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04AC stack[0] = 0x0278 // @04AF stack[1] = 0x04b9 // @04B2 stack[2] = msg.data.length // @04B3 stack[3] = 0x04 // } // Block ends with call to 0x2732, returns to 0x04B9 label_04B9: // Incoming call from 0x1B14, returns to 0x1B15 // Incoming return from call to 0x2732 at 0x04B8 // Inputs[6] // { // @04C2 stack[-2] // @04D5 memory[0x00:0x40] // @04D6 stack[-1] // @04E0 memory[0x00:0x40] // @04E1 storage[keccak256(memory[0x00:0x40])] // @04E5 stack[-3] // } 04B9 5B JUMPDEST 04BA 60 PUSH1 0x01 04BC 60 PUSH1 0x01 04BE 60 PUSH1 0xa0 04C0 1B SHL 04C1 03 SUB 04C2 91 SWAP2 04C3 82 DUP3 04C4 16 AND 04C5 60 PUSH1 0x00 04C7 90 SWAP1 04C8 81 DUP2 04C9 52 MSTORE 04CA 60 PUSH1 0x01 04CC 60 PUSH1 0x20 04CE 90 SWAP1 04CF 81 DUP2 04D0 52 MSTORE 04D1 60 PUSH1 0x40 04D3 80 DUP1 04D4 83 DUP4 04D5 20 SHA3 04D6 93 SWAP4 04D7 90 SWAP1 04D8 94 SWAP5 04D9 16 AND 04DA 82 DUP3 04DB 52 MSTORE 04DC 91 SWAP2 04DD 90 SWAP1 04DE 91 SWAP2 04DF 52 MSTORE 04E0 20 SHA3 04E1 54 SLOAD 04E2 60 PUSH1 0xff 04E4 16 AND 04E5 90 SWAP1 04E6 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @04C9 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @04D0 memory[0x20:0x40] = 0x01 // @04DB memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @04DF memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @04E5 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_04E7: // Incoming jump from 0x0061, if 0xf242432a == stack[-1] // Inputs[1] { @04EE msg.data.length } 04E7 5B JUMPDEST 04E8 61 PUSH2 0x023d 04EB 61 PUSH2 0x04f5 04EE 36 CALLDATASIZE 04EF 60 PUSH1 0x04 04F1 61 PUSH2 0x280e 04F4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04E8 stack[0] = 0x023d // @04EB stack[1] = 0x04f5 // @04EE stack[2] = msg.data.length // @04EF stack[3] = 0x04 // } // Block ends with call to 0x280e, returns to 0x04F5 label_04F5: // Incoming return from call to 0x280E at 0x04F4 04F5 5B JUMPDEST 04F6 61 PUSH2 0x11a3 04F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11a3 label_04FA: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @0501 msg.data.length } 04FA 5B JUMPDEST 04FB 61 PUSH2 0x023d 04FE 61 PUSH2 0x0508 0501 36 CALLDATASIZE 0502 60 PUSH1 0x04 0504 61 PUSH2 0x2710 0507 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04FB stack[0] = 0x023d // @04FE stack[1] = 0x0508 // @0501 stack[2] = msg.data.length // @0502 stack[3] = 0x04 // } // Block ends with call to 0x2710, returns to 0x0508 label_0508: // Incoming return from call to 0x2710 at 0x0507 0508 5B JUMPDEST 0509 61 PUSH2 0x11f8 050C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11f8 label_050D: // Incoming jump from 0x0077, if 0xf86f3b39 == stack[-1] // Inputs[1] { @0514 msg.data.length } 050D 5B JUMPDEST 050E 61 PUSH2 0x023d 0511 61 PUSH2 0x051b 0514 36 CALLDATASIZE 0515 60 PUSH1 0x04 0517 61 PUSH2 0x2a75 051A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @050E stack[0] = 0x023d // @0511 stack[1] = 0x051b // @0514 stack[2] = msg.data.length // @0515 stack[3] = 0x04 // } // Block ends with call to 0x2a75, returns to 0x051B label_051B: // Incoming return from call to 0x2A75 at 0x051A 051B 5B JUMPDEST 051C 61 PUSH2 0x1290 051F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1290 label_0520: // Incoming jump from 0x023C // Inputs[2] // { // @0523 storage[0x04] // @052D msg.sender // } 0520 5B JUMPDEST 0521 60 PUSH1 0x04 0523 54 SLOAD 0524 60 PUSH1 0x01 0526 60 PUSH1 0x01 0528 60 PUSH1 0xa0 052A 1B SHL 052B 03 SUB 052C 16 AND 052D 33 CALLER 052E 14 EQ 052F 61 PUSH2 0x0553 0532 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0553, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0533: // Incoming jump from 0x0532, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0535 memory[0x40:0x60] } 0533 60 PUSH1 0x40 0535 51 MLOAD 0536 62 PUSH3 0x461bcd 053A 60 PUSH1 0xe5 053C 1B SHL 053D 81 DUP2 053E 52 MSTORE 053F 60 PUSH1 0x04 0541 01 ADD 0542 61 PUSH2 0x054a 0545 90 SWAP1 0546 61 PUSH2 0x2e5e 0549 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @053E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0545 stack[0] = 0x054a // @0545 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_054A: // Incoming jump from 0x0C86 // Incoming return from call to 0x2E5E at 0x1180 // Incoming jump from 0x1047 // Incoming jump from 0x18DD // Incoming jump from 0x06C2 // Incoming jump from 0x1551 // Incoming jump from 0x1286 // Incoming jump from 0x0BDA // Incoming return from call to 0x2E5E at 0x0D74 // Incoming jump from 0x09C3 // Incoming jump from 0x22BA // Incoming return from call to 0x2E5E at 0x0EF9 // Incoming jump from 0x11EA // Incoming return from call to 0x2E5E at 0x0B81 // Incoming return from call to 0x2E5E at 0x0F76 // Incoming jump from 0x21A8 // Incoming jump from 0x12F2 // Incoming jump from 0x0A5C // Incoming return from call to 0x2E5E at 0x10C1 // Incoming return from call to 0x2E5E at 0x1221 // Incoming return from call to 0x2E5E at 0x0FA8 // Incoming jump from 0x14C0 // Incoming jump from 0x061C // Incoming jump from 0x231C // Incoming jump from 0x2389 // Incoming jump from 0x0E71 // Incoming jump from 0x13EB // Incoming return from call to 0x2DCF at 0x1EE9 // Incoming jump from 0x1434 // Incoming return from call to 0x2E5E at 0x0C17 // Incoming jump from 0x1B72 // Incoming return from call to 0x2E5E at 0x0F42 // Incoming return from call to 0x2D8A at 0x091A // Incoming jump from 0x05B1 // Incoming jump from 0x1352 // Incoming return from call to 0x2D8A at 0x12AE // Incoming return from call to 0x2E5E at 0x0764 // Incoming return from call to 0x2E5E at 0x0549 // Incoming jump from 0x0DCD // Incoming jump from 0x19C9 // Incoming jump from 0x1C80 // Incoming jump from 0x23F6 // Incoming jump from 0x1A78 // Incoming jump from 0x1120 // Incoming jump from 0x0963 // Inputs[3] // { // @054D memory[0x40:0x60] // @054F stack[-1] // @0552 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 054A 5B JUMPDEST 054B 60 PUSH1 0x40 054D 51 MLOAD 054E 80 DUP1 054F 91 SWAP2 0550 03 SUB 0551 90 SWAP1 0552 FD *REVERT // Stack delta = -1 // Outputs[1] { @0552 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0553: // Incoming jump from 0x0532, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[3] // { // @0556 stack[-2] // @0561 memory[0x00:0x40] // @0562 storage[keccak256(memory[0x00:0x40])] // } 0553 5B JUMPDEST 0554 60 PUSH1 0x00 0556 82 DUP3 0557 81 DUP2 0558 52 MSTORE 0559 60 PUSH1 0x08 055B 60 PUSH1 0x20 055D 52 MSTORE 055E 60 PUSH1 0x40 0560 90 SWAP1 0561 20 SHA3 0562 54 SLOAD 0563 60 PUSH1 0xff 0565 16 AND 0566 15 ISZERO 0567 61 PUSH2 0x05b2 056A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0558 memory[0x00:0x20] = stack[-2] // @055D memory[0x20:0x40] = 0x08 // } // Block ends with conditional jump to 0x05b2, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_056B: // Incoming jump from 0x056A, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @056D memory[0x40:0x60] } 056B 60 PUSH1 0x40 056D 51 MLOAD 056E 62 PUSH3 0x461bcd 0572 60 PUSH1 0xe5 0574 1B SHL 0575 81 DUP2 0576 52 MSTORE 0577 60 PUSH1 0x20 0579 60 PUSH1 0x04 057B 82 DUP3 057C 01 ADD 057D 52 MSTORE 057E 60 PUSH1 0x1d 0580 60 PUSH1 0x24 0582 82 DUP3 0583 01 ADD 0584 52 MSTORE 0585 7F PUSH32 0x43414e4e4f545f4d494e545f4558495354494e475f544f4b454e5f4944000000 05A6 60 PUSH1 0x44 05A8 82 DUP3 05A9 01 ADD 05AA 52 MSTORE 05AB 60 PUSH1 0x64 05AD 01 ADD 05AE 61 PUSH2 0x054a 05B1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0576 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @057D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0584 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @05AA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43414e4e4f545f4d494e545f4558495354494e475f544f4b454e5f4944000000 // @05AD stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_05B2: // Incoming jump from 0x056A, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @05B5 stack[-2] } 05B2 5B JUMPDEST 05B3 60 PUSH1 0x01 05B5 82 DUP3 05B6 14 EQ 05B7 15 ISZERO 05B8 80 DUP1 05B9 15 ISZERO 05BA 61 PUSH2 0x05c4 05BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B7 stack[0] = !(stack[-2] == 0x01) } // Block ends with conditional jump to 0x05c4, if !!(stack[-2] == 0x01) label_05BE: // Incoming jump from 0x05BD, if not !!(stack[-2] == 0x01) // Inputs[1] { @05C1 stack[-3] } 05BE 50 POP 05BF 60 PUSH1 0x02 05C1 82 DUP3 05C2 14 EQ 05C3 15 ISZERO 05C4 5B JUMPDEST 05C5 80 DUP1 05C6 15 ISZERO 05C7 61 PUSH2 0x05d1 05CA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @05C3 stack[-1] = !(stack[-3] == 0x02) } // Block ends with conditional jump to 0x05d1, if !!(stack[-3] == 0x02) label_05CB: // Incoming jump from 0x05CA, if not !!(stack[-3] == 0x02) // Incoming jump from 0x05CA, if not !stack[-1] // Inputs[1] { @05CE stack[-3] } 05CB 50 POP 05CC 60 PUSH1 0x03 05CE 82 DUP3 05CF 14 EQ 05D0 15 ISZERO 05D1 5B JUMPDEST 05D2 61 PUSH2 0x061d 05D5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x061d, if !(stack[-3] == 0x03) label_05D6: // Incoming jump from 0x05D5, if not stack[-1] // Incoming jump from 0x05D5, if not !(stack[-3] == 0x03) // Inputs[1] { @05D8 memory[0x40:0x60] } 05D6 60 PUSH1 0x40 05D8 51 MLOAD 05D9 62 PUSH3 0x461bcd 05DD 60 PUSH1 0xe5 05DF 1B SHL 05E0 81 DUP2 05E1 52 MSTORE 05E2 60 PUSH1 0x20 05E4 60 PUSH1 0x04 05E6 82 DUP3 05E7 01 ADD 05E8 52 MSTORE 05E9 60 PUSH1 0x1d 05EB 60 PUSH1 0x24 05ED 82 DUP3 05EE 01 ADD 05EF 52 MSTORE 05F0 7F PUSH32 0x43414e4e4f545f4d494e545f4558495354494e475f544f4b454e5f4944000000 0611 60 PUSH1 0x44 0613 82 DUP3 0614 01 ADD 0615 52 MSTORE 0616 60 PUSH1 0x64 0618 01 ADD 0619 61 PUSH2 0x054a 061C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @05E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05E8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05EF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @0615 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43414e4e4f545f4d494e545f4558495354494e475f544f4b454e5f4944000000 // @0618 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_061D: // Incoming jump from 0x05D5, if stack[-1] // Incoming jump from 0x05D5, if !(stack[-3] == 0x03) // Inputs[6] // { // @0620 stack[-2] // @062E memory[0x00:0x40] // @0630 storage[keccak256(memory[0x00:0x40])] // @063B memory[0x40:0x60] // @0648 stack[-3] // @064C stack[-1] // } 061D 5B JUMPDEST 061E 60 PUSH1 0x00 0620 82 DUP3 0621 81 DUP2 0622 52 MSTORE 0623 60 PUSH1 0x08 0625 60 PUSH1 0x20 0627 90 SWAP1 0628 81 DUP2 0629 52 MSTORE 062A 60 PUSH1 0x40 062C 80 DUP1 062D 83 DUP4 062E 20 SHA3 062F 80 DUP1 0630 54 SLOAD 0631 60 PUSH1 0xff 0633 19 NOT 0634 16 AND 0635 60 PUSH1 0x01 0637 17 OR 0638 90 SWAP1 0639 55 SSTORE 063A 80 DUP1 063B 51 MLOAD 063C 91 SWAP2 063D 82 DUP3 063E 01 ADD 063F 90 SWAP1 0640 52 MSTORE 0641 90 SWAP1 0642 81 DUP2 0643 52 MSTORE 0644 61 PUSH2 0x0652 0647 90 SWAP1 0648 84 DUP5 0649 90 SWAP1 064A 84 DUP5 064B 90 SWAP1 064C 84 DUP5 064D 90 SWAP1 064E 61 PUSH2 0x14f2 0651 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @0622 memory[0x00:0x20] = stack[-2] // @0629 memory[0x20:0x40] = 0x08 // @0639 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0640 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0643 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0647 stack[0] = 0x0652 // @0649 stack[1] = stack[-3] // @064B stack[2] = stack[-2] // @064D stack[3] = stack[-1] // @064D stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x14f2 label_0652: // Incoming jump from 0x1053, if !(0x00 < stack[-1]) // Inputs[1] { @0656 stack[-4] } 0652 5B JUMPDEST 0653 50 POP 0654 50 POP 0655 50 POP 0656 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0657: // Incoming jump from 0x0D15 // Incoming jump from 0x0251 // Inputs[1] { @0662 stack[-2] } 0657 5B JUMPDEST 0658 60 PUSH1 0x00 065A 60 PUSH1 0x01 065C 60 PUSH1 0x01 065E 60 PUSH1 0xa0 0660 1B SHL 0661 03 SUB 0662 83 DUP4 0663 16 AND 0664 61 PUSH2 0x06c3 0667 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0658 stack[0] = 0x00 } // Block ends with conditional jump to 0x06c3, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0668: // Incoming jump from 0x0667, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @066A memory[0x40:0x60] } 0668 60 PUSH1 0x40 066A 51 MLOAD 066B 62 PUSH3 0x461bcd 066F 60 PUSH1 0xe5 0671 1B SHL 0672 81 DUP2 0673 52 MSTORE 0674 60 PUSH1 0x20 0676 60 PUSH1 0x04 0678 82 DUP3 0679 01 ADD 067A 52 MSTORE 067B 60 PUSH1 0x2b 067D 60 PUSH1 0x24 067F 82 DUP3 0680 01 ADD 0681 52 MSTORE 0682 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 06A3 60 PUSH1 0x44 06A5 82 DUP3 06A6 01 ADD 06A7 52 MSTORE 06A8 6A PUSH11 0x65726f2061646472657373 06B4 60 PUSH1 0xa8 06B6 1B SHL 06B7 60 PUSH1 0x64 06B9 82 DUP3 06BA 01 ADD 06BB 52 MSTORE 06BC 60 PUSH1 0x84 06BE 01 ADD 06BF 61 PUSH2 0x054a 06C2 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0673 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @067A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0681 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @06A7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @06BB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373 << 0xa8 // @06BE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_06C3: // Incoming jump from 0x0667, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @06C7 stack[-2] // @06D3 memory[0x00:0x40] // @06DC stack[-3] // @06E5 memory[0x00:0x40] // @06E6 storage[keccak256(memory[0x00:0x40])] // @06E7 stack[-4] // } 06C3 5B JUMPDEST 06C4 50 POP 06C5 60 PUSH1 0x00 06C7 90 SWAP1 06C8 81 DUP2 06C9 52 MSTORE 06CA 60 PUSH1 0x20 06CC 81 DUP2 06CD 81 DUP2 06CE 52 MSTORE 06CF 60 PUSH1 0x40 06D1 80 DUP1 06D2 83 DUP4 06D3 20 SHA3 06D4 60 PUSH1 0x01 06D6 60 PUSH1 0x01 06D8 60 PUSH1 0xa0 06DA 1B SHL 06DB 03 SUB 06DC 94 SWAP5 06DD 90 SWAP1 06DE 94 SWAP5 06DF 16 AND 06E0 83 DUP4 06E1 52 MSTORE 06E2 92 SWAP3 06E3 90 SWAP1 06E4 52 MSTORE 06E5 20 SHA3 06E6 54 SLOAD 06E7 90 SWAP1 06E8 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @06C9 memory[0x00:0x20] = stack[-2] // @06CE memory[0x20:0x40] = 0x00 // @06E1 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @06E4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06E7 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_06E9: // Incoming jump from 0x0277 // Inputs[1] { @06F5 stack[-1] } 06E9 5B JUMPDEST 06EA 60 PUSH1 0x00 06EC 60 PUSH1 0x01 06EE 60 PUSH1 0x01 06F0 60 PUSH1 0xe0 06F2 1B SHL 06F3 03 SUB 06F4 19 NOT 06F5 82 DUP3 06F6 16 AND 06F7 63 PUSH4 0x6cdb3d13 06FC 60 PUSH1 0xe1 06FE 1B SHL 06FF 14 EQ 0700 80 DUP1 0701 61 PUSH2 0x071a 0704 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @06EA stack[0] = 0x00 // @06FF stack[1] = 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x071a, if 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0705: // Incoming jump from 0x0704, if not 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @070F stack[-3] } 0705 50 POP 0706 60 PUSH1 0x01 0708 60 PUSH1 0x01 070A 60 PUSH1 0xe0 070C 1B SHL 070D 03 SUB 070E 19 NOT 070F 82 DUP3 0710 16 AND 0711 63 PUSH4 0x03a24d07 0716 60 PUSH1 0xe2 0718 1B SHL 0719 14 EQ 071A 5B JUMPDEST 071B 80 DUP1 071C 61 PUSH2 0x0735 071F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0719 stack[-1] = 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0735, if 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0720: // Incoming jump from 0x071F, if not 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x071F, if not stack[-1] // Inputs[2] // { // @0732 stack[-3] // @0736 stack[-4] // } 0720 50 POP 0721 63 PUSH4 0x01ffc9a7 0726 60 PUSH1 0xe0 0728 1B SHL 0729 60 PUSH1 0x01 072B 60 PUSH1 0x01 072D 60 PUSH1 0xe0 072F 1B SHL 0730 03 SUB 0731 19 NOT 0732 83 DUP4 0733 16 AND 0734 14 EQ 0735 5B JUMPDEST 0736 92 SWAP3 0737 91 SWAP2 0738 50 POP 0739 50 POP 073A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0736 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to stack[-4] label_073B: // Incoming jump from 0x029A // Inputs[2] // { // @073E storage[0x04] // @0748 msg.sender // } 073B 5B JUMPDEST 073C 60 PUSH1 0x04 073E 54 SLOAD 073F 60 PUSH1 0x01 0741 60 PUSH1 0x01 0743 60 PUSH1 0xa0 0745 1B SHL 0746 03 SUB 0747 16 AND 0748 33 CALLER 0749 14 EQ 074A 61 PUSH2 0x0765 074D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0765, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_074E: // Incoming jump from 0x074D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0750 memory[0x40:0x60] } 074E 60 PUSH1 0x40 0750 51 MLOAD 0751 62 PUSH3 0x461bcd 0755 60 PUSH1 0xe5 0757 1B SHL 0758 81 DUP2 0759 52 MSTORE 075A 60 PUSH1 0x04 075C 01 ADD 075D 61 PUSH2 0x054a 0760 90 SWAP1 0761 61 PUSH2 0x2e5e 0764 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0759 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0760 stack[0] = 0x054a // @0760 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0765: // Incoming jump from 0x074D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @076E stack[-1] } 0765 5B JUMPDEST 0766 60 PUSH1 0x01 0768 60 PUSH1 0x01 076A 60 PUSH1 0xa0 076C 1B SHL 076D 03 SUB 076E 81 DUP2 076F 16 AND 0770 61 PUSH2 0x0778 0773 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0778, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0774: // Incoming jump from 0x0773, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0777 memory[0x00:0x00] } 0774 60 PUSH1 0x00 0776 80 DUP1 0777 FD *REVERT // Stack delta = +0 // Outputs[1] { @0777 revert(memory[0x00:0x00]); } // Block terminates label_0778: // Incoming jump from 0x0773, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @077C storage[0x07] // @0786 stack[-1] // @07A1 stack[-2] // } 0778 5B JUMPDEST 0779 60 PUSH1 0x07 077B 80 DUP1 077C 54 SLOAD 077D 60 PUSH1 0x01 077F 60 PUSH1 0x01 0781 60 PUSH1 0xa0 0783 1B SHL 0784 03 SUB 0785 90 SWAP1 0786 92 SWAP3 0787 16 AND 0788 62 PUSH3 0x010000 078C 02 MUL 078D 62 PUSH3 0x010000 0791 60 PUSH1 0x01 0793 60 PUSH1 0xb0 0795 1B SHL 0796 03 SUB 0797 19 NOT 0798 90 SWAP1 0799 92 SWAP3 079A 16 AND 079B 91 SWAP2 079C 90 SWAP1 079D 91 SWAP2 079E 17 OR 079F 90 SWAP1 07A0 55 SSTORE 07A1 56 *JUMP // Stack delta = -2 // Outputs[1] { @07A0 storage[0x07] = (storage[0x07] & ~((0x01 << 0xb0) - 0x010000)) | 0x010000 * (stack[-1] & (0x01 << 0xa0) - 0x01) } // Block ends with unconditional jump to stack[-2] label_07A2: // Incoming call from 0x02A2, returns to 0x02A3 // Inputs[1] { @07A6 storage[0x05] } 07A2 5B JUMPDEST 07A3 60 PUSH1 0x05 07A5 80 DUP1 07A6 54 SLOAD 07A7 61 PUSH2 0x07af 07AA 90 SWAP1 07AB 61 PUSH2 0x2f04 07AE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07A3 stack[0] = 0x05 // @07AA stack[1] = 0x07af // @07AA stack[2] = storage[0x05] // } // Block ends with call to 0x2f04, returns to 0x07AF label_07AF: // Incoming return from call to 0x2F04 at 0x11A2 // Incoming return from call to 0x2F04 at 0x1147 // Incoming return from call to 0x2F04 at 0x07AE // Inputs[4] // { // @07B0 stack[-1] // @07BF memory[0x40:0x60] // @07C7 stack[-2] // @07D2 storage[stack[-2]] // } 07AF 5B JUMPDEST 07B0 80 DUP1 07B1 60 PUSH1 0x1f 07B3 01 ADD 07B4 60 PUSH1 0x20 07B6 80 DUP1 07B7 91 SWAP2 07B8 04 DIV 07B9 02 MUL 07BA 60 PUSH1 0x20 07BC 01 ADD 07BD 60 PUSH1 0x40 07BF 51 MLOAD 07C0 90 SWAP1 07C1 81 DUP2 07C2 01 ADD 07C3 60 PUSH1 0x40 07C5 52 MSTORE 07C6 80 DUP1 07C7 92 SWAP3 07C8 91 SWAP2 07C9 90 SWAP1 07CA 81 DUP2 07CB 81 DUP2 07CC 52 MSTORE 07CD 60 PUSH1 0x20 07CF 01 ADD 07D0 82 DUP3 07D1 80 DUP1 07D2 54 SLOAD 07D3 61 PUSH2 0x07db 07D6 90 SWAP1 07D7 61 PUSH2 0x2f04 07DA 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @07C5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @07C7 stack[-2] = memory[0x40:0x60] // @07C8 stack[-1] = stack[-2] // @07C9 stack[0] = stack[-1] // @07CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @07CF stack[1] = 0x20 + memory[0x40:0x60] // @07D0 stack[2] = stack[-2] // @07D6 stack[4] = storage[stack[-2]] // @07D6 stack[3] = 0x07db // } // Block ends with call to 0x2f04, returns to 0x07DB label_07DB: // Incoming return from call to 0x2F04 at 0x07DA // Inputs[1] { @07DC stack[-1] } 07DB 5B JUMPDEST 07DC 80 DUP1 07DD 15 ISZERO 07DE 61 PUSH2 0x0828 07E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0828, if !stack[-1] label_07E2: // Incoming jump from 0x07E1, if not !stack[-1] // Inputs[1] { @07E2 stack[-1] } 07E2 80 DUP1 07E3 60 PUSH1 0x1f 07E5 10 LT 07E6 61 PUSH2 0x07fd 07E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07fd, if 0x1f < stack[-1] label_07EA: // Incoming jump from 0x07E9, if not 0x1f < stack[-1] // Inputs[4] // { // @07EE stack[-2] // @07EF storage[stack[-2]] // @07F2 stack[-3] // @07F4 stack[-1] // } 07EA 61 PUSH2 0x0100 07ED 80 DUP1 07EE 83 DUP4 07EF 54 SLOAD 07F0 04 DIV 07F1 02 MUL 07F2 83 DUP4 07F3 52 MSTORE 07F4 91 SWAP2 07F5 60 PUSH1 0x20 07F7 01 ADD 07F8 91 SWAP2 07F9 61 PUSH2 0x0828 07FC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07F3 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @07F8 stack[-1] = stack[-1] // @07F8 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0828 label_07FD: // Incoming jump from 0x07E9, if 0x1f < stack[-1] // Inputs[5] // { // @07FE stack[-3] // @07FF stack[-1] // @0801 stack[-2] // @0809 memory[0x00:0x20] // @080D storage[keccak256(memory[0x00:0x20])] // } 07FD 5B JUMPDEST 07FE 82 DUP3 07FF 01 ADD 0800 91 SWAP2 0801 90 SWAP1 0802 60 PUSH1 0x00 0804 52 MSTORE 0805 60 PUSH1 0x20 0807 60 PUSH1 0x00 0809 20 SHA3 080A 90 SWAP1 080B 5B JUMPDEST 080C 81 DUP2 080D 54 SLOAD 080E 81 DUP2 080F 52 MSTORE 0810 90 SWAP1 0811 60 PUSH1 0x01 0813 01 ADD 0814 90 SWAP1 0815 60 PUSH1 0x20 0817 01 ADD 0818 80 DUP1 0819 83 DUP4 081A 11 GT 081B 61 PUSH2 0x080b 081E 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0800 stack[-3] = stack[-3] + stack[-1] // @0804 memory[0x00:0x20] = stack[-2] // @080F memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0814 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0817 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x080b, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_081F: // Incoming jump from 0x081E, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x081E, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @081F stack[-3] // @0820 stack[-1] // } 081F 82 DUP3 0820 90 SWAP1 0821 03 SUB 0822 60 PUSH1 0x1f 0824 16 AND 0825 82 DUP3 0826 01 ADD 0827 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0827 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0827 stack[-1] = stack[-3] // } // Block continues label_0828: // Incoming jump from 0x07FC // Incoming jump from 0x0827 // Incoming jump from 0x07E1, if !stack[-1] // Inputs[1] { @082E stack[-7] } 0828 5B JUMPDEST 0829 50 POP 082A 50 POP 082B 50 POP 082C 50 POP 082D 50 POP 082E 81 DUP2 082F 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0830: // Incoming jump from 0x02C2 // Inputs[3] // { // @0833 stack[-1] // @083E memory[0x00:0x40] // @0840 storage[keccak256(memory[0x00:0x40])] // } 0830 5B JUMPDEST 0831 60 PUSH1 0x00 0833 81 DUP2 0834 81 DUP2 0835 52 MSTORE 0836 60 PUSH1 0x09 0838 60 PUSH1 0x20 083A 52 MSTORE 083B 60 PUSH1 0x40 083D 90 SWAP1 083E 20 SHA3 083F 80 DUP1 0840 54 SLOAD 0841 60 PUSH1 0x60 0843 91 SWAP2 0844 90 SWAP1 0845 61 PUSH2 0x084d 0848 90 SWAP1 0849 61 PUSH2 0x2f04 084C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0835 memory[0x00:0x20] = stack[-1] // @083A memory[0x20:0x40] = 0x09 // @0843 stack[0] = 0x60 // @0844 stack[1] = keccak256(memory[0x00:0x40]) // @0848 stack[2] = 0x084d // @0848 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2f04, returns to 0x084D label_084D: // Incoming return from call to 0x2F04 at 0x084C // Inputs[2] // { // @084E stack[-1] // @0850 stack[-2] // } 084D 5B JUMPDEST 084E 15 ISZERO 084F 15 ISZERO 0850 90 SWAP1 0851 50 POP 0852 61 PUSH2 0x085e 0855 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x085e, if !!stack[-1] label_0856: // Incoming jump from 0x0855, if not !!stack[-1] // Inputs[1] { @0859 stack[-2] } 0856 61 PUSH2 0x0735 0859 82 DUP3 085A 61 PUSH2 0x1615 085D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0856 stack[0] = 0x0735 // @0859 stack[1] = stack[-2] // } // Block ends with call to 0x1615, returns to 0x0735 label_085E: // Incoming jump from 0x0855, if !!stack[-1] // Inputs[3] // { // @0861 stack[-2] // @086C memory[0x00:0x40] // @086E storage[keccak256(memory[0x00:0x40])] // } 085E 5B JUMPDEST 085F 60 PUSH1 0x00 0861 82 DUP3 0862 81 DUP2 0863 52 MSTORE 0864 60 PUSH1 0x09 0866 60 PUSH1 0x20 0868 52 MSTORE 0869 60 PUSH1 0x40 086B 90 SWAP1 086C 20 SHA3 086D 80 DUP1 086E 54 SLOAD 086F 61 PUSH2 0x0877 0872 90 SWAP1 0873 61 PUSH2 0x2f04 0876 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0863 memory[0x00:0x20] = stack[-2] // @0868 memory[0x20:0x40] = 0x09 // @086C stack[0] = keccak256(memory[0x00:0x40]) // @0872 stack[1] = 0x0877 // @0872 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2f04, returns to 0x0877 label_0877: // Incoming return from call to 0x2F04 at 0x1623 // Incoming return from call to 0x2F04 at 0x0876 // Inputs[4] // { // @0878 stack[-1] // @0887 memory[0x40:0x60] // @088F stack[-2] // @089A storage[stack[-2]] // } 0877 5B JUMPDEST 0878 80 DUP1 0879 60 PUSH1 0x1f 087B 01 ADD 087C 60 PUSH1 0x20 087E 80 DUP1 087F 91 SWAP2 0880 04 DIV 0881 02 MUL 0882 60 PUSH1 0x20 0884 01 ADD 0885 60 PUSH1 0x40 0887 51 MLOAD 0888 90 SWAP1 0889 81 DUP2 088A 01 ADD 088B 60 PUSH1 0x40 088D 52 MSTORE 088E 80 DUP1 088F 92 SWAP3 0890 91 SWAP2 0891 90 SWAP1 0892 81 DUP2 0893 81 DUP2 0894 52 MSTORE 0895 60 PUSH1 0x20 0897 01 ADD 0898 82 DUP3 0899 80 DUP1 089A 54 SLOAD 089B 61 PUSH2 0x08a3 089E 90 SWAP1 089F 61 PUSH2 0x2f04 08A2 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @088D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @088F stack[-2] = memory[0x40:0x60] // @0890 stack[-1] = stack[-2] // @0891 stack[0] = stack[-1] // @0894 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0897 stack[1] = 0x20 + memory[0x40:0x60] // @0898 stack[2] = stack[-2] // @089E stack[4] = storage[stack[-2]] // @089E stack[3] = 0x08a3 // } // Block ends with call to 0x2f04, returns to 0x08A3 label_08A3: // Incoming return from call to 0x2F04 at 0x08A2 // Inputs[1] { @08A4 stack[-1] } 08A3 5B JUMPDEST 08A4 80 DUP1 08A5 15 ISZERO 08A6 61 PUSH2 0x08f0 08A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08f0, if !stack[-1] label_08AA: // Incoming jump from 0x08A9, if not !stack[-1] // Inputs[1] { @08AA stack[-1] } 08AA 80 DUP1 08AB 60 PUSH1 0x1f 08AD 10 LT 08AE 61 PUSH2 0x08c5 08B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08c5, if 0x1f < stack[-1] label_08B2: // Incoming jump from 0x08B1, if not 0x1f < stack[-1] // Inputs[4] // { // @08B6 stack[-2] // @08B7 storage[stack[-2]] // @08BA stack[-3] // @08BC stack[-1] // } 08B2 61 PUSH2 0x0100 08B5 80 DUP1 08B6 83 DUP4 08B7 54 SLOAD 08B8 04 DIV 08B9 02 MUL 08BA 83 DUP4 08BB 52 MSTORE 08BC 91 SWAP2 08BD 60 PUSH1 0x20 08BF 01 ADD 08C0 91 SWAP2 08C1 61 PUSH2 0x08f0 08C4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @08BB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @08C0 stack[-1] = stack[-1] // @08C0 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08f0 label_08C5: // Incoming jump from 0x08B1, if 0x1f < stack[-1] // Inputs[5] // { // @08C6 stack[-3] // @08C7 stack[-1] // @08C9 stack[-2] // @08D1 memory[0x00:0x20] // @08D5 storage[keccak256(memory[0x00:0x20])] // } 08C5 5B JUMPDEST 08C6 82 DUP3 08C7 01 ADD 08C8 91 SWAP2 08C9 90 SWAP1 08CA 60 PUSH1 0x00 08CC 52 MSTORE 08CD 60 PUSH1 0x20 08CF 60 PUSH1 0x00 08D1 20 SHA3 08D2 90 SWAP1 08D3 5B JUMPDEST 08D4 81 DUP2 08D5 54 SLOAD 08D6 81 DUP2 08D7 52 MSTORE 08D8 90 SWAP1 08D9 60 PUSH1 0x01 08DB 01 ADD 08DC 90 SWAP1 08DD 60 PUSH1 0x20 08DF 01 ADD 08E0 80 DUP1 08E1 83 DUP4 08E2 11 GT 08E3 61 PUSH2 0x08d3 08E6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @08C8 stack[-3] = stack[-3] + stack[-1] // @08CC memory[0x00:0x20] = stack[-2] // @08D7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @08DC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @08DF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x08d3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_08E7: // Incoming jump from 0x08E6, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x08E6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @08E7 stack[-3] // @08E8 stack[-1] // } 08E7 82 DUP3 08E8 90 SWAP1 08E9 03 SUB 08EA 60 PUSH1 0x1f 08EC 16 AND 08ED 82 DUP3 08EE 01 ADD 08EF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @08EF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @08EF stack[-1] = stack[-3] // } // Block continues label_08F0: // Incoming jump from 0x08EF // Incoming jump from 0x08C4 // Incoming jump from 0x08A9, if !stack[-1] // Inputs[4] // { // @08F6 stack[-7] // @08F6 stack[-6] // @08F8 stack[-9] // @08F9 stack[-8] // } 08F0 5B JUMPDEST 08F1 50 POP 08F2 50 POP 08F3 50 POP 08F4 50 POP 08F5 50 POP 08F6 90 SWAP1 08F7 50 POP 08F8 91 SWAP2 08F9 90 SWAP1 08FA 50 POP 08FB 56 *JUMP // Stack delta = -8 // Outputs[1] { @08F8 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_08FC: // Incoming jump from 0x02E4 // Inputs[2] // { // @08FD msg.sender // @08FE tx.origin // } 08FC 5B JUMPDEST 08FD 33 CALLER 08FE 32 ORIGIN 08FF 14 EQ 0900 61 PUSH2 0x091b 0903 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x091b, if tx.origin == msg.sender label_0904: // Incoming jump from 0x0903, if not tx.origin == msg.sender // Inputs[1] { @0906 memory[0x40:0x60] } 0904 60 PUSH1 0x40 0906 51 MLOAD 0907 62 PUSH3 0x461bcd 090B 60 PUSH1 0xe5 090D 1B SHL 090E 81 DUP2 090F 52 MSTORE 0910 60 PUSH1 0x04 0912 01 ADD 0913 61 PUSH2 0x054a 0916 90 SWAP1 0917 61 PUSH2 0x2d8a 091A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @090F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0916 stack[0] = 0x054a // @0916 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2d8a, returns to 0x054A label_091B: // Incoming jump from 0x0903, if tx.origin == msg.sender // Inputs[1] { @091E storage[0x07] } 091B 5B JUMPDEST 091C 60 PUSH1 0x07 091E 54 SLOAD 091F 61 PUSH2 0x0100 0922 90 SWAP1 0923 04 DIV 0924 60 PUSH1 0xff 0926 16 AND 0927 61 PUSH2 0x0964 092A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0964, if 0xff & storage[0x07] / 0x0100 label_092B: // Incoming jump from 0x092A, if not 0xff & storage[0x07] / 0x0100 // Inputs[1] { @092D memory[0x40:0x60] } 092B 60 PUSH1 0x40 092D 51 MLOAD 092E 62 PUSH3 0x461bcd 0932 60 PUSH1 0xe5 0934 1B SHL 0935 81 DUP2 0936 52 MSTORE 0937 60 PUSH1 0x20 0939 60 PUSH1 0x04 093B 82 DUP3 093C 01 ADD 093D 52 MSTORE 093E 60 PUSH1 0x0f 0940 60 PUSH1 0x24 0942 82 DUP3 0943 01 ADD 0944 52 MSTORE 0945 6E PUSH15 0x53414c455f4e4f545f414354495645 0955 60 PUSH1 0x88 0957 1B SHL 0958 60 PUSH1 0x44 095A 82 DUP3 095B 01 ADD 095C 52 MSTORE 095D 60 PUSH1 0x64 095F 01 ADD 0960 61 PUSH2 0x054a 0963 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0936 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @093D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0944 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @095C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53414c455f4e4f545f414354495645 << 0x88 // @095F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_0964: // Incoming jump from 0x092A, if 0xff & storage[0x07] / 0x0100 // Inputs[3] // { // @0965 msg.sender // @0973 memory[0x00:0x40] // @0974 storage[keccak256(memory[0x00:0x40])] // } 0964 5B JUMPDEST 0965 33 CALLER 0966 60 PUSH1 0x00 0968 90 SWAP1 0969 81 DUP2 096A 52 MSTORE 096B 60 PUSH1 0x0a 096D 60 PUSH1 0x20 096F 52 MSTORE 0970 60 PUSH1 0x40 0972 90 SWAP1 0973 20 SHA3 0974 54 SLOAD 0975 60 PUSH1 0xff 0977 16 AND 0978 15 ISZERO 0979 61 PUSH2 0x09c4 097C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @096A memory[0x00:0x20] = msg.sender // @096F memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x09c4, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_097D: // Incoming jump from 0x097C, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @097F memory[0x40:0x60] } 097D 60 PUSH1 0x40 097F 51 MLOAD 0980 62 PUSH3 0x461bcd 0984 60 PUSH1 0xe5 0986 1B SHL 0987 81 DUP2 0988 52 MSTORE 0989 60 PUSH1 0x20 098B 60 PUSH1 0x04 098D 82 DUP3 098E 01 ADD 098F 52 MSTORE 0990 60 PUSH1 0x1a 0992 60 PUSH1 0x24 0994 82 DUP3 0995 01 ADD 0996 52 MSTORE 0997 7F PUSH32 0x414444524553535f4841535f414c52454144595f4d494e544544000000000000 09B8 60 PUSH1 0x44 09BA 82 DUP3 09BB 01 ADD 09BC 52 MSTORE 09BD 60 PUSH1 0x64 09BF 01 ADD 09C0 61 PUSH2 0x054a 09C3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0988 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @098F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0996 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @09BC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x414444524553535f4841535f414c52454144595f4d494e544544000000000000 // @09BF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_09C4: // Incoming jump from 0x097C, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @09CD memory[0x00:0x20] // @09D6 memory[0x00:0x20] // @09D9 storage[memory[0x00:0x20]] // @09DD memory[0x00:0x20] // @09E6 memory[0x00:0x20] // @09E9 storage[memory[0x00:0x20]] // @09F4 memory[0x00:0x20] // @09FD memory[0x00:0x20] // @0A00 storage[memory[0x00:0x20]] // } 09C4 5B JUMPDEST 09C5 60 PUSH1 0x03 09C7 60 PUSH1 0x20 09C9 52 MSTORE 09CA 60 PUSH1 0x00 09CC 80 DUP1 09CD 51 MLOAD 09CE 60 PUSH1 0x20 09D0 61 PUSH2 0x30d4 09D3 83 DUP4 09D4 39 CODECOPY 09D5 81 DUP2 09D6 51 MLOAD 09D7 91 SWAP2 09D8 52 MSTORE 09D9 54 SLOAD 09DA 60 PUSH1 0x00 09DC 80 DUP1 09DD 51 MLOAD 09DE 60 PUSH1 0x20 09E0 61 PUSH2 0x3094 09E3 83 DUP4 09E4 39 CODECOPY 09E5 81 DUP2 09E6 51 MLOAD 09E7 91 SWAP2 09E8 52 MSTORE 09E9 54 SLOAD 09EA 60 PUSH1 0x01 09EC 60 PUSH1 0x00 09EE 90 SWAP1 09EF 81 DUP2 09F0 52 MSTORE 09F1 60 PUSH1 0x00 09F3 80 DUP1 09F4 51 MLOAD 09F5 60 PUSH1 0x20 09F7 61 PUSH2 0x30b4 09FA 83 DUP4 09FB 39 CODECOPY 09FC 81 DUP2 09FD 51 MLOAD 09FE 91 SWAP2 09FF 52 MSTORE 0A00 54 SLOAD 0A01 90 SWAP1 0A02 92 SWAP3 0A03 91 SWAP2 0A04 61 PUSH2 0x0a0c 0A07 91 SWAP2 0A08 61 PUSH2 0x2eb6 0A0B 56 *JUMP // Stack delta = +5 // Outputs[13] // { // @09C9 memory[0x20:0x40] = 0x03 // @09D4 memory[0x00:0x20] = code[0x30d4:0x30f4] // @09D8 memory[0x00:0x20] = memory[0x00:0x20] // @09E4 memory[0x00:0x20] = code[0x3094:0x30b4] // @09E8 memory[0x00:0x20] = memory[0x00:0x20] // @09F0 memory[0x00:0x20] = 0x01 // @09FB memory[0x00:0x20] = code[0x30b4:0x30d4] // @09FF memory[0x00:0x20] = memory[0x00:0x20] // @0A02 stack[0] = 0x00 // @0A03 stack[3] = storage[memory[0x00:0x20]] // @0A03 stack[1] = storage[memory[0x00:0x20]] // @0A07 stack[2] = 0x0a0c // @0A07 stack[4] = storage[memory[0x00:0x20]] // } // Block ends with call to 0x2eb6, returns to 0x0A0C label_0A0C: // Incoming return from call to 0x2EB6 at 0x0A0B // Inputs[2] // { // @0A10 stack[-2] // @0A11 stack[-1] // } 0A0C 5B JUMPDEST 0A0D 61 PUSH2 0x0a16 0A10 91 SWAP2 0A11 90 SWAP1 0A12 61 PUSH2 0x2eb6 0A15 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0A10 stack[-2] = 0x0a16 // @0A11 stack[-1] = stack[-2] // @0A11 stack[0] = stack[-1] // } // Block ends with call to 0x2eb6, returns to 0x0A16 label_0A16: // Incoming return from call to 0x2EB6 at 0x0A15 // Inputs[2] // { // @0A17 stack[-1] // @0A17 stack[-2] // } 0A16 5B JUMPDEST 0A17 90 SWAP1 0A18 50 POP 0A19 61 PUSH2 0x1388 0A1C 81 DUP2 0A1D 10 LT 0A1E 61 PUSH2 0x0a5d 0A21 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0A17 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0a5d, if stack[-1] < 0x1388 label_0A22: // Incoming jump from 0x0A21, if not stack[-1] < 0x1388 // Inputs[1] { @0A24 memory[0x40:0x60] } 0A22 60 PUSH1 0x40 0A24 51 MLOAD 0A25 62 PUSH3 0x461bcd 0A29 60 PUSH1 0xe5 0A2B 1B SHL 0A2C 81 DUP2 0A2D 52 MSTORE 0A2E 60 PUSH1 0x20 0A30 60 PUSH1 0x04 0A32 82 DUP3 0A33 01 ADD 0A34 52 MSTORE 0A35 60 PUSH1 0x11 0A37 60 PUSH1 0x24 0A39 82 DUP3 0A3A 01 ADD 0A3B 52 MSTORE 0A3C 70 PUSH17 0x13505617d513d2d15394d7d35253951151 0A4E 60 PUSH1 0x7a 0A50 1B SHL 0A51 60 PUSH1 0x44 0A53 82 DUP3 0A54 01 ADD 0A55 52 MSTORE 0A56 60 PUSH1 0x64 0A58 01 ADD 0A59 61 PUSH2 0x054a 0A5C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A34 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A3B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @0A55 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13505617d513d2d15394d7d35253951151 << 0x7a // @0A58 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_0A5D: // Incoming jump from 0x0A21, if stack[-1] < 0x1388 // Inputs[3] // { // @0A5E msg.sender // @0A6C memory[0x00:0x40] // @0A6E storage[keccak256(memory[0x00:0x40])] // } 0A5D 5B JUMPDEST 0A5E 33 CALLER 0A5F 60 PUSH1 0x00 0A61 81 DUP2 0A62 81 DUP2 0A63 52 MSTORE 0A64 60 PUSH1 0x0a 0A66 60 PUSH1 0x20 0A68 52 MSTORE 0A69 60 PUSH1 0x40 0A6B 90 SWAP1 0A6C 20 SHA3 0A6D 80 DUP1 0A6E 54 SLOAD 0A6F 60 PUSH1 0xff 0A71 19 NOT 0A72 16 AND 0A73 60 PUSH1 0x01 0A75 90 SWAP1 0A76 81 DUP2 0A77 17 OR 0A78 90 SWAP1 0A79 91 SWAP2 0A7A 55 SSTORE 0A7B 61 PUSH2 0x0a9f 0A7E 91 SWAP2 0A7F 90 SWAP1 0A80 61 PUSH2 0x0a88 0A83 90 SWAP1 0A84 61 PUSH2 0x1624 0A87 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @0A63 memory[0x00:0x20] = msg.sender // @0A68 memory[0x20:0x40] = 0x0a // @0A7A storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0A7E stack[0] = 0x0a9f // @0A7F stack[1] = msg.sender // @0A83 stack[2] = 0x0a88 // @0A83 stack[3] = 0x01 // } // Block ends with call to 0x1624, returns to 0x0A88 label_0A88: // Incoming return from call to 0x1624 at 0x0A87 // Incoming return from call to 0x1624 at 0x14EB // Incoming return from call to 0x1624 at 0x1085 // Inputs[1] { @0A8D memory[0x40:0x60] } 0A88 5B JUMPDEST 0A89 60 PUSH1 0x01 0A8B 60 PUSH1 0x40 0A8D 51 MLOAD 0A8E 80 DUP1 0A8F 60 PUSH1 0x20 0A91 01 ADD 0A92 60 PUSH1 0x40 0A94 52 MSTORE 0A95 80 DUP1 0A96 60 PUSH1 0x00 0A98 81 DUP2 0A99 52 MSTORE 0A9A 50 POP 0A9B 61 PUSH2 0x14f2 0A9E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0A89 stack[0] = 0x01 // @0A8D stack[1] = memory[0x40:0x60] // @0A94 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0A99 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x14f2 0A9F 5B JUMPDEST 0AA0 61 PUSH2 0x1388 0AA3 61 PUSH2 0x0aad 0AA6 82 DUP3 0AA7 60 PUSH1 0x01 0AA9 61 PUSH2 0x2eb6 0AAC 56 *JUMP 0AAD 5B JUMPDEST 0AAE 10 LT 0AAF 61 PUSH2 0x0abe 0AB2 57 *JUMPI 0AB3 60 PUSH1 0x07 0AB5 80 DUP1 0AB6 54 SLOAD 0AB7 61 PUSH2 0xff00 0ABA 19 NOT 0ABB 16 AND 0ABC 90 SWAP1 0ABD 55 SSTORE label_0ABE: // Incoming jump from 0x308E, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x23A4, if !(stack[-1] == stack[-2]) // Incoming return from call to 0x192B at 0x128F // Inputs[1] { @0AC0 stack[-2] } 0ABE 5B JUMPDEST 0ABF 50 POP 0AC0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 0AC1 5B JUMPDEST 0AC2 60 PUSH1 0x01 0AC4 60 PUSH1 0x01 0AC6 60 PUSH1 0xa0 0AC8 1B SHL 0AC9 03 SUB 0ACA 85 DUP6 0ACB 16 AND 0ACC 33 CALLER 0ACD 14 EQ 0ACE 80 DUP1 0ACF 61 PUSH2 0x0add 0AD2 57 *JUMPI 0AD3 50 POP 0AD4 61 PUSH2 0x0add 0AD7 85 DUP6 0AD8 33 CALLER 0AD9 61 PUSH2 0x04b9 0ADC 56 *JUMP 0ADD 5B JUMPDEST 0ADE 61 PUSH2 0x0b44 0AE1 57 *JUMPI 0AE2 60 PUSH1 0x40 0AE4 51 MLOAD 0AE5 62 PUSH3 0x461bcd 0AE9 60 PUSH1 0xe5 0AEB 1B SHL 0AEC 81 DUP2 0AED 52 MSTORE 0AEE 60 PUSH1 0x20 0AF0 60 PUSH1 0x04 0AF2 82 DUP3 0AF3 01 ADD 0AF4 52 MSTORE 0AF5 60 PUSH1 0x32 0AF7 60 PUSH1 0x24 0AF9 82 DUP3 0AFA 01 ADD 0AFB 52 MSTORE 0AFC 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 0B1D 60 PUSH1 0x44 0B1F 82 DUP3 0B20 01 ADD 0B21 52 MSTORE 0B22 71 PUSH18 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 0B35 60 PUSH1 0x72 0B37 1B SHL 0B38 60 PUSH1 0x64 0B3A 82 DUP3 0B3B 01 ADD 0B3C 52 MSTORE 0B3D 60 PUSH1 0x84 0B3F 01 ADD 0B40 61 PUSH2 0x054a 0B43 56 *JUMP 0B44 5B JUMPDEST 0B45 61 PUSH2 0x0b51 0B48 85 DUP6 0B49 85 DUP6 0B4A 85 DUP6 0B4B 85 DUP6 0B4C 85 DUP6 0B4D 61 PUSH2 0x16a3 0B50 56 *JUMP label_0B51: // Incoming jump from 0x0E7D, if !(0x00 < stack[-3]) // Inputs[1] { @0B57 stack[-6] } 0B51 5B JUMPDEST 0B52 50 POP 0B53 50 POP 0B54 50 POP 0B55 50 POP 0B56 50 POP 0B57 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0B58: // Incoming jump from 0x0320 // Inputs[2] // { // @0B5B storage[0x04] // @0B65 msg.sender // } 0B58 5B JUMPDEST 0B59 60 PUSH1 0x04 0B5B 54 SLOAD 0B5C 60 PUSH1 0x01 0B5E 60 PUSH1 0x01 0B60 60 PUSH1 0xa0 0B62 1B SHL 0B63 03 SUB 0B64 16 AND 0B65 33 CALLER 0B66 14 EQ 0B67 61 PUSH2 0x0b82 0B6A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b82, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0B6B: // Incoming jump from 0x0B6A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0B6D memory[0x40:0x60] } 0B6B 60 PUSH1 0x40 0B6D 51 MLOAD 0B6E 62 PUSH3 0x461bcd 0B72 60 PUSH1 0xe5 0B74 1B SHL 0B75 81 DUP2 0B76 52 MSTORE 0B77 60 PUSH1 0x04 0B79 01 ADD 0B7A 61 PUSH2 0x054a 0B7D 90 SWAP1 0B7E 61 PUSH2 0x2e5e 0B81 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B76 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B7D stack[0] = 0x054a // @0B7D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0B82: // Incoming jump from 0x0B6A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[2] // { // @0B85 storage[0x07] // @0B8B stack[-1] // } 0B82 5B JUMPDEST 0B83 60 PUSH1 0x07 0B85 54 SLOAD 0B86 60 PUSH1 0xff 0B88 16 AND 0B89 15 ISZERO 0B8A 15 ISZERO 0B8B 81 DUP2 0B8C 15 ISZERO 0B8D 15 ISZERO 0B8E 14 EQ 0B8F 15 ISZERO 0B90 61 PUSH2 0x0bdb 0B93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bdb, if !(!!stack[-1] == !!(0xff & storage[0x07])) label_0B94: // Incoming jump from 0x0B93, if not !(!!stack[-1] == !!(0xff & storage[0x07])) // Inputs[1] { @0B96 memory[0x40:0x60] } 0B94 60 PUSH1 0x40 0B96 51 MLOAD 0B97 62 PUSH3 0x461bcd 0B9B 60 PUSH1 0xe5 0B9D 1B SHL 0B9E 81 DUP2 0B9F 52 MSTORE 0BA0 60 PUSH1 0x20 0BA2 60 PUSH1 0x04 0BA4 82 DUP3 0BA5 01 ADD 0BA6 81 DUP2 0BA7 90 SWAP1 0BA8 52 MSTORE 0BA9 60 PUSH1 0x24 0BAB 82 DUP3 0BAC 01 ADD 0BAD 52 MSTORE 0BAE 7F PUSH32 0x4e45575f53544154455f4944454e544943414c5f544f5f4f4c445f5354415445 0BCF 60 PUSH1 0x44 0BD1 82 DUP3 0BD2 01 ADD 0BD3 52 MSTORE 0BD4 60 PUSH1 0x64 0BD6 01 ADD 0BD7 61 PUSH2 0x054a 0BDA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BA8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BAD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0BD3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e45575f53544154455f4944454e544943414c5f544f5f4f4c445f5354415445 // @0BD6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_0BDB: // Incoming jump from 0x0B93, if !(!!stack[-1] == !!(0xff & storage[0x07])) // Inputs[3] // { // @0BDF storage[0x07] // @0BE4 stack[-1] // @0BED stack[-2] // } 0BDB 5B JUMPDEST 0BDC 60 PUSH1 0x07 0BDE 80 DUP1 0BDF 54 SLOAD 0BE0 60 PUSH1 0xff 0BE2 19 NOT 0BE3 16 AND 0BE4 91 SWAP2 0BE5 15 ISZERO 0BE6 15 ISZERO 0BE7 91 SWAP2 0BE8 90 SWAP1 0BE9 91 SWAP2 0BEA 17 OR 0BEB 90 SWAP1 0BEC 55 SSTORE 0BED 56 *JUMP // Stack delta = -2 // Outputs[1] { @0BEC storage[0x07] = !!stack[-1] | (~0xff & storage[0x07]) } // Block ends with unconditional jump to stack[-2] label_0BEE: // Incoming call from 0x0328, returns to 0x023D // Inputs[2] // { // @0BF1 storage[0x04] // @0BFB msg.sender // } 0BEE 5B JUMPDEST 0BEF 60 PUSH1 0x04 0BF1 54 SLOAD 0BF2 60 PUSH1 0x01 0BF4 60 PUSH1 0x01 0BF6 60 PUSH1 0xa0 0BF8 1B SHL 0BF9 03 SUB 0BFA 16 AND 0BFB 33 CALLER 0BFC 14 EQ 0BFD 61 PUSH2 0x0c18 0C00 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c18, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0C01: // Incoming jump from 0x0C00, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0C03 memory[0x40:0x60] } 0C01 60 PUSH1 0x40 0C03 51 MLOAD 0C04 62 PUSH3 0x461bcd 0C08 60 PUSH1 0xe5 0C0A 1B SHL 0C0B 81 DUP2 0C0C 52 MSTORE 0C0D 60 PUSH1 0x04 0C0F 01 ADD 0C10 61 PUSH2 0x054a 0C13 90 SWAP1 0C14 61 PUSH2 0x2e5e 0C17 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C0C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C13 stack[0] = 0x054a // @0C13 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0C18: // Incoming jump from 0x0C00, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] 0C18 5B JUMPDEST 0C19 61 PUSH2 0x0c20 0C1C 61 PUSH2 0x188e 0C1F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C19 stack[0] = 0x0c20 } // Block ends with call to 0x188e, returns to 0x0C20 label_0C20: // Incoming return from call to 0x188E at 0x0C1F // Incoming return from call to 0x192B at 0x0F4C // Incoming return from call to 0x197D at 0x0F7E // Inputs[1] { @0C21 stack[-1] } 0C20 5B JUMPDEST 0C21 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0C22: // Incoming jump from 0x033B // Inputs[4] // { // @0C25 stack[-1] // @0C26 memory[stack[-1]:stack[-1] + 0x20] // @0C27 stack[-2] // @0C28 memory[stack[-2]:stack[-2] + 0x20] // } 0C22 5B JUMPDEST 0C23 60 PUSH1 0x60 0C25 81 DUP2 0C26 51 MLOAD 0C27 83 DUP4 0C28 51 MLOAD 0C29 14 EQ 0C2A 61 PUSH2 0x0c87 0C2D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C23 stack[0] = 0x60 } // Block ends with conditional jump to 0x0c87, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_0C2E: // Incoming jump from 0x0C2D, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0C30 memory[0x40:0x60] } 0C2E 60 PUSH1 0x40 0C30 51 MLOAD 0C31 62 PUSH3 0x461bcd 0C35 60 PUSH1 0xe5 0C37 1B SHL 0C38 81 DUP2 0C39 52 MSTORE 0C3A 60 PUSH1 0x20 0C3C 60 PUSH1 0x04 0C3E 82 DUP3 0C3F 01 ADD 0C40 52 MSTORE 0C41 60 PUSH1 0x29 0C43 60 PUSH1 0x24 0C45 82 DUP3 0C46 01 ADD 0C47 52 MSTORE 0C48 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 0C69 60 PUSH1 0x44 0C6B 82 DUP3 0C6C 01 ADD 0C6D 52 MSTORE 0C6E 68 PUSH9 0x040dad2e6dac2e8c6d 0C78 60 PUSH1 0xbb 0C7A 1B SHL 0C7B 60 PUSH1 0x64 0C7D 82 DUP3 0C7E 01 ADD 0C7F 52 MSTORE 0C80 60 PUSH1 0x84 0C82 01 ADD 0C83 61 PUSH2 0x054a 0C86 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C39 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C40 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C47 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0C6D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @0C7F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x040dad2e6dac2e8c6d << 0xbb // @0C82 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_0C87: // Incoming jump from 0x0C2D, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @0C8A stack[-3] // @0C8B memory[stack[-3]:stack[-3] + 0x20] // } 0C87 5B JUMPDEST 0C88 60 PUSH1 0x00 0C8A 83 DUP4 0C8B 51 MLOAD 0C8C 60 PUSH1 0x01 0C8E 60 PUSH1 0x01 0C90 60 PUSH1 0x40 0C92 1B SHL 0C93 03 SUB 0C94 81 DUP2 0C95 11 GT 0C96 15 ISZERO 0C97 61 PUSH2 0x0ca2 0C9A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C88 stack[0] = 0x00 // @0C8B stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x0ca2, if !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_0C9B: // Incoming jump from 0x0C9A, if not !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) 0C9B 61 PUSH2 0x0ca2 0C9E 61 PUSH2 0x2fc2 0CA1 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C9B stack[0] = 0x0ca2 } // Block ends with unconditional jump to 0x2fc2 label_0CA2: // Incoming jump from 0x0C9A, if !(memory[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0CA5 memory[0x40:0x60] // @0CA6 stack[-1] // } 0CA2 5B JUMPDEST 0CA3 60 PUSH1 0x40 0CA5 51 MLOAD 0CA6 90 SWAP1 0CA7 80 DUP1 0CA8 82 DUP3 0CA9 52 MSTORE 0CAA 80 DUP1 0CAB 60 PUSH1 0x20 0CAD 02 MUL 0CAE 60 PUSH1 0x20 0CB0 01 ADD 0CB1 82 DUP3 0CB2 01 ADD 0CB3 60 PUSH1 0x40 0CB5 52 MSTORE 0CB6 80 DUP1 0CB7 15 ISZERO 0CB8 61 PUSH2 0x0ccb 0CBB 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0CA6 stack[-1] = memory[0x40:0x60] // @0CA6 stack[0] = stack[-1] // @0CA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0CB5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0ccb, if !stack[-1] label_0CBC: // Incoming jump from 0x0CBB, if not !stack[-1] // Inputs[7] // { // @0CBC stack[-2] // @0CC2 stack[-1] // @0CC5 msg.data.length // @0CC7 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0CCD stack[-3] // @0CD2 stack[-6] // @0CD3 memory[stack[-6]:stack[-6] + 0x20] // } 0CBC 81 DUP2 0CBD 60 PUSH1 0x20 0CBF 01 ADD 0CC0 60 PUSH1 0x20 0CC2 82 DUP3 0CC3 02 MUL 0CC4 80 DUP1 0CC5 36 CALLDATASIZE 0CC6 83 DUP4 0CC7 37 CALLDATACOPY 0CC8 01 ADD 0CC9 90 SWAP1 0CCA 50 POP 0CCB 5B JUMPDEST 0CCC 50 POP 0CCD 90 SWAP1 0CCE 50 POP 0CCF 60 PUSH1 0x00 0CD1 5B JUMPDEST 0CD2 84 DUP5 0CD3 51 MLOAD 0CD4 81 DUP2 0CD5 10 LT 0CD6 15 ISZERO 0CD7 61 PUSH2 0x0d43 0CDA 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0CC7 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0CCD stack[-3] = stack[-2] // @0CCF stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0d43, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_0CDB: // Incoming jump from 0x0CDA, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x0CDA, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x0CDA, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @0CDE stack[-5] // @0CDF stack[-1] // @0CE1 memory[stack[-5]:stack[-5] + 0x20] // } 0CDB 61 PUSH2 0x0d16 0CDE 85 DUP6 0CDF 82 DUP3 0CE0 81 DUP2 0CE1 51 MLOAD 0CE2 81 DUP2 0CE3 10 LT 0CE4 61 PUSH2 0x0cef 0CE7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0CDB stack[0] = 0x0d16 // @0CDE stack[1] = stack[-5] // @0CDF stack[2] = stack[-1] // } // Block ends with conditional call to 0x0cef, returns to 0x0D16, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_0CE8: // Incoming jump from 0x0CE7, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 0CE8 61 PUSH2 0x0cef 0CEB 61 PUSH2 0x2fac 0CEE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CE8 stack[0] = 0x0cef } // Block ends with unconditional jump to 0x2fac label_0CEF: // Incoming call from 0x0CE7, returns to 0x0D16, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @0CF2 stack[-1] // @0CF6 stack[-2] // @0CF7 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CF8 stack[-7] // @0CF9 stack[-4] // @0CFB memory[stack[-7]:stack[-7] + 0x20] // } 0CEF 5B JUMPDEST 0CF0 60 PUSH1 0x20 0CF2 02 MUL 0CF3 60 PUSH1 0x20 0CF5 01 ADD 0CF6 01 ADD 0CF7 51 MLOAD 0CF8 85 DUP6 0CF9 83 DUP4 0CFA 81 DUP2 0CFB 51 MLOAD 0CFC 81 DUP2 0CFD 10 LT 0CFE 61 PUSH2 0x0d09 0D01 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CF7 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CF8 stack[-1] = stack[-7] // @0CF9 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0d09, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_0D02: // Incoming jump from 0x0D01, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] 0D02 61 PUSH2 0x0d09 0D05 61 PUSH2 0x2fac 0D08 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D02 stack[0] = 0x0d09 } // Block ends with unconditional jump to 0x2fac label_0D09: // Incoming jump from 0x0D01, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @0D0C stack[-1] // @0D10 stack[-2] // @0D11 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0D09 5B JUMPDEST 0D0A 60 PUSH1 0x20 0D0C 02 MUL 0D0D 60 PUSH1 0x20 0D0F 01 ADD 0D10 01 ADD 0D11 51 MLOAD 0D12 61 PUSH2 0x0657 0D15 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D11 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0657 label_0D16: // Incoming return from call to 0x0CEF at 0x0CE7 // Inputs[3] // { // @0D17 stack[-3] // @0D18 stack[-2] // @0D1A memory[stack[-3]:stack[-3] + 0x20] // } 0D16 5B JUMPDEST 0D17 82 DUP3 0D18 82 DUP3 0D19 81 DUP2 0D1A 51 MLOAD 0D1B 81 DUP2 0D1C 10 LT 0D1D 61 PUSH2 0x0d28 0D20 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D17 stack[0] = stack[-3] // @0D18 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0d28, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0D21: // Incoming jump from 0x0D20, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 0D21 61 PUSH2 0x0d28 0D24 61 PUSH2 0x2fac 0D27 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D21 stack[0] = 0x0d28 } // Block ends with unconditional jump to 0x2fac label_0D28: // Incoming jump from 0x0D20, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0D2B stack[-1] // @0D2E stack[-2] // @0D33 stack[-3] // @0D37 stack[-4] // } 0D28 5B JUMPDEST 0D29 60 PUSH1 0x20 0D2B 90 SWAP1 0D2C 81 DUP2 0D2D 02 MUL 0D2E 91 SWAP2 0D2F 90 SWAP1 0D30 91 SWAP2 0D31 01 ADD 0D32 01 ADD 0D33 52 MSTORE 0D34 61 PUSH2 0x0d3c 0D37 81 DUP2 0D38 61 PUSH2 0x2f65 0D3B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0D33 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0D34 stack[-3] = 0x0d3c // @0D37 stack[-2] = stack[-4] // } // Block ends with call to 0x2f65, returns to 0x0D3C label_0D3C: // Incoming return from call to 0x2F65 at 0x0D3B // Inputs[2] // { // @0D3D stack[-2] // @0D3D stack[-1] // } 0D3C 5B JUMPDEST 0D3D 90 SWAP1 0D3E 50 POP 0D3F 61 PUSH2 0x0cd1 0D42 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D3D stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0cd1 label_0D43: // Incoming jump from 0x0CDA, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0CDA, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x0CDA, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming return from call to 0x223C at 0x2052 // Inputs[3] // { // @0D45 stack[-2] // @0D45 stack[-6] // @0D46 stack[-5] // } 0D43 5B JUMPDEST 0D44 50 POP 0D45 93 SWAP4 0D46 92 SWAP3 0D47 50 POP 0D48 50 POP 0D49 50 POP 0D4A 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D45 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0D4B: // Incoming jump from 0x037D // Inputs[2] // { // @0D4E storage[0x04] // @0D58 msg.sender // } 0D4B 5B JUMPDEST 0D4C 60 PUSH1 0x04 0D4E 54 SLOAD 0D4F 60 PUSH1 0x01 0D51 60 PUSH1 0x01 0D53 60 PUSH1 0xa0 0D55 1B SHL 0D56 03 SUB 0D57 16 AND 0D58 33 CALLER 0D59 14 EQ 0D5A 61 PUSH2 0x0d75 0D5D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d75, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0D5E: // Incoming jump from 0x0D5D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0D60 memory[0x40:0x60] } 0D5E 60 PUSH1 0x40 0D60 51 MLOAD 0D61 62 PUSH3 0x461bcd 0D65 60 PUSH1 0xe5 0D67 1B SHL 0D68 81 DUP2 0D69 52 MSTORE 0D6A 60 PUSH1 0x04 0D6C 01 ADD 0D6D 61 PUSH2 0x054a 0D70 90 SWAP1 0D71 61 PUSH2 0x2e5e 0D74 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D69 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D70 stack[0] = 0x054a // @0D70 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0D75: // Incoming jump from 0x0D5D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0D78 stack[-1] } 0D75 5B JUMPDEST 0D76 60 PUSH1 0x01 0D78 81 DUP2 0D79 14 EQ 0D7A 80 DUP1 0D7B 61 PUSH2 0x0d84 0D7E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D79 stack[0] = stack[-1] == 0x01 } // Block ends with conditional jump to 0x0d84, if stack[-1] == 0x01 label_0D7F: // Incoming jump from 0x0D7E, if not stack[-1] == 0x01 // Inputs[1] { @0D82 stack[-2] } 0D7F 50 POP 0D80 60 PUSH1 0x02 0D82 81 DUP2 0D83 14 EQ 0D84 5B JUMPDEST 0D85 80 DUP1 0D86 61 PUSH2 0x0d8f 0D89 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D83 stack[-1] = stack[-2] == 0x02 } // Block ends with conditional jump to 0x0d8f, if stack[-2] == 0x02 label_0D8A: // Incoming jump from 0x0D89, if not stack[-1] // Incoming jump from 0x0D89, if not stack[-2] == 0x02 // Inputs[1] { @0D8D stack[-2] } 0D8A 50 POP 0D8B 60 PUSH1 0x03 0D8D 81 DUP2 0D8E 14 EQ 0D8F 5B JUMPDEST 0D90 61 PUSH2 0x0dce 0D93 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dce, if stack[-2] == 0x03 label_0D94: // Incoming jump from 0x0D93, if not stack[-1] // Incoming jump from 0x0D93, if not stack[-2] == 0x03 // Inputs[1] { @0D96 memory[0x40:0x60] } 0D94 60 PUSH1 0x40 0D96 51 MLOAD 0D97 62 PUSH3 0x461bcd 0D9B 60 PUSH1 0xe5 0D9D 1B SHL 0D9E 81 DUP2 0D9F 52 MSTORE 0DA0 60 PUSH1 0x20 0DA2 60 PUSH1 0x04 0DA4 82 DUP3 0DA5 01 ADD 0DA6 52 MSTORE 0DA7 60 PUSH1 0x10 0DA9 60 PUSH1 0x24 0DAB 82 DUP3 0DAC 01 ADD 0DAD 52 MSTORE 0DAE 6F PUSH16 0x1253959053125117d513d2d15397d251 0DBF 60 PUSH1 0x82 0DC1 1B SHL 0DC2 60 PUSH1 0x44 0DC4 82 DUP3 0DC5 01 ADD 0DC6 52 MSTORE 0DC7 60 PUSH1 0x64 0DC9 01 ADD 0DCA 61 PUSH2 0x054a 0DCD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0D9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DA6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DAD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0DC6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1253959053125117d513d2d15397d251 << 0x82 // @0DC9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_0DCE: // Incoming jump from 0x0D93, if stack[-1] // Incoming jump from 0x0D93, if stack[-2] == 0x03 // Inputs[2] // { // @0DD5 stack[-2] // @0DD6 stack[-3] // } 0DCE 5B JUMPDEST 0DCF 61 PUSH2 0x1388 0DD2 61 PUSH2 0x0ddb 0DD5 83 DUP4 0DD6 85 DUP6 0DD7 61 PUSH2 0x2ece 0DDA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DCF stack[0] = 0x1388 // @0DD2 stack[1] = 0x0ddb // @0DD5 stack[2] = stack[-2] // @0DD6 stack[3] = stack[-3] // } // Block ends with call to 0x2ece, returns to 0x0DDB label_0DDB: // Incoming return from call to 0x2ECE at 0x0DDA // Inputs[9] // { // @0DE4 memory[0x00:0x20] // @0DED memory[0x00:0x20] // @0DF0 storage[memory[0x00:0x20]] // @0DF4 memory[0x00:0x20] // @0DFD memory[0x00:0x20] // @0E00 storage[memory[0x00:0x20]] // @0E09 memory[0x00:0x20] // @0E12 memory[0x00:0x20] // @0E15 storage[memory[0x00:0x20]] // } 0DDB 5B JUMPDEST 0DDC 60 PUSH1 0x03 0DDE 60 PUSH1 0x20 0DE0 52 MSTORE 0DE1 60 PUSH1 0x00 0DE3 80 DUP1 0DE4 51 MLOAD 0DE5 60 PUSH1 0x20 0DE7 61 PUSH2 0x30d4 0DEA 83 DUP4 0DEB 39 CODECOPY 0DEC 81 DUP2 0DED 51 MLOAD 0DEE 91 SWAP2 0DEF 52 MSTORE 0DF0 54 SLOAD 0DF1 60 PUSH1 0x00 0DF3 80 DUP1 0DF4 51 MLOAD 0DF5 60 PUSH1 0x20 0DF7 61 PUSH2 0x3094 0DFA 83 DUP4 0DFB 39 CODECOPY 0DFC 81 DUP2 0DFD 51 MLOAD 0DFE 91 SWAP2 0DFF 52 MSTORE 0E00 54 SLOAD 0E01 60 PUSH1 0x01 0E03 60 PUSH1 0x00 0E05 52 MSTORE 0E06 60 PUSH1 0x00 0E08 80 DUP1 0E09 51 MLOAD 0E0A 60 PUSH1 0x20 0E0C 61 PUSH2 0x30b4 0E0F 83 DUP4 0E10 39 CODECOPY 0E11 81 DUP2 0E12 51 MLOAD 0E13 91 SWAP2 0E14 52 MSTORE 0E15 54 SLOAD 0E16 61 PUSH2 0x0e1f 0E19 91 SWAP2 0E1A 90 SWAP1 0E1B 61 PUSH2 0x2eb6 0E1E 56 *JUMP // Stack delta = +4 // Outputs[12] // { // @0DE0 memory[0x20:0x40] = 0x03 // @0DEB memory[0x00:0x20] = code[0x30d4:0x30f4] // @0DEF memory[0x00:0x20] = memory[0x00:0x20] // @0DF0 stack[0] = storage[memory[0x00:0x20]] // @0DFB memory[0x00:0x20] = code[0x3094:0x30b4] // @0DFF memory[0x00:0x20] = memory[0x00:0x20] // @0E05 memory[0x00:0x20] = 0x01 // @0E10 memory[0x00:0x20] = code[0x30b4:0x30d4] // @0E14 memory[0x00:0x20] = memory[0x00:0x20] // @0E19 stack[1] = 0x0e1f // @0E1A stack[2] = storage[memory[0x00:0x20]] // @0E1A stack[3] = storage[memory[0x00:0x20]] // } // Block ends with call to 0x2eb6, returns to 0x0E1F label_0E1F: // Incoming return from call to 0x2EB6 at 0x0E1E // Inputs[2] // { // @0E23 stack[-2] // @0E24 stack[-1] // } 0E1F 5B JUMPDEST 0E20 61 PUSH2 0x0e29 0E23 91 SWAP2 0E24 90 SWAP1 0E25 61 PUSH2 0x2eb6 0E28 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E23 stack[-2] = 0x0e29 // @0E24 stack[-1] = stack[-2] // @0E24 stack[0] = stack[-1] // } // Block ends with call to 0x2eb6, returns to 0x0E29 label_0E29: // Incoming return from call to 0x2EB6 at 0x0E28 // Inputs[2] // { // @0E2D stack[-2] // @0E2E stack[-1] // } 0E29 5B JUMPDEST 0E2A 61 PUSH2 0x0e33 0E2D 91 SWAP2 0E2E 90 SWAP1 0E2F 61 PUSH2 0x2eb6 0E32 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E2D stack[-2] = 0x0e33 // @0E2E stack[-1] = stack[-2] // @0E2E stack[0] = stack[-1] // } // Block ends with call to 0x2eb6, returns to 0x0E33 label_0E33: // Incoming return from call to 0x2EB6 at 0x0E32 // Inputs[2] // { // @0E34 stack[-1] // @0E34 stack[-2] // } 0E33 5B JUMPDEST 0E34 11 GT 0E35 15 ISZERO 0E36 61 PUSH2 0x0e72 0E39 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e72, if !(stack[-1] > stack[-2]) label_0E3A: // Incoming jump from 0x0E39, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0E3C memory[0x40:0x60] } 0E3A 60 PUSH1 0x40 0E3C 51 MLOAD 0E3D 62 PUSH3 0x461bcd 0E41 60 PUSH1 0xe5 0E43 1B SHL 0E44 81 DUP2 0E45 52 MSTORE 0E46 60 PUSH1 0x20 0E48 60 PUSH1 0x04 0E4A 82 DUP3 0E4B 01 ADD 0E4C 52 MSTORE 0E4D 60 PUSH1 0x0e 0E4F 60 PUSH1 0x24 0E51 82 DUP3 0E52 01 ADD 0E53 52 MSTORE 0E54 6D PUSH14 0x4d494e545f544f4f5f4c41524745 0E63 60 PUSH1 0x90 0E65 1B SHL 0E66 60 PUSH1 0x44 0E68 82 DUP3 0E69 01 ADD 0E6A 52 MSTORE 0E6B 60 PUSH1 0x64 0E6D 01 ADD 0E6E 61 PUSH2 0x054a 0E71 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E4C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E53 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @0E6A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d494e545f544f4f5f4c41524745 << 0x90 // @0E6D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_0E72: // Incoming jump from 0x0E39, if !(stack[-1] > stack[-2]) // Inputs[1] { @0E76 stack[-3] } 0E72 5B JUMPDEST 0E73 60 PUSH1 0x00 0E75 5B JUMPDEST 0E76 83 DUP4 0E77 81 DUP2 0E78 10 LT 0E79 15 ISZERO 0E7A 61 PUSH2 0x0b51 0E7D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E73 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b51, if !(0x00 < stack[-3]) label_0E7E: // Incoming jump from 0x0E7D, if not !(0x00 < stack[-3]) // Inputs[3] // { // @0E81 stack[-5] // @0E82 stack[-4] // @0E83 stack[-1] // } 0E7E 61 PUSH2 0x0ebe 0E81 85 DUP6 0E82 85 DUP6 0E83 83 DUP4 0E84 81 DUP2 0E85 81 DUP2 0E86 10 LT 0E87 61 PUSH2 0x0e92 0E8A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0E7E stack[0] = 0x0ebe // @0E81 stack[1] = stack[-5] // @0E82 stack[2] = stack[-4] // @0E83 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0e92, if stack[-1] < stack[-4] label_0E8B: // Incoming jump from 0x0E8A, if not stack[-1] < stack[-4] 0E8B 61 PUSH2 0x0e92 0E8E 61 PUSH2 0x2fac 0E91 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E8B stack[0] = 0x0e92 } // Block ends with unconditional jump to 0x2fac label_0E92: // Incoming jump from 0x0E8A, if stack[-1] < stack[-4] // Inputs[3] // { // @0E93 stack[-1] // @0E93 stack[-2] // @0E98 stack[-3] // } 0E92 5B JUMPDEST 0E93 90 SWAP1 0E94 50 POP 0E95 60 PUSH1 0x20 0E97 02 MUL 0E98 01 ADD 0E99 60 PUSH1 0x20 0E9B 81 DUP2 0E9C 01 ADD 0E9D 90 SWAP1 0E9E 61 PUSH2 0x0ea7 0EA1 91 SWAP2 0EA2 90 SWAP1 0EA3 61 PUSH2 0x2710 0EA6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0EA1 stack[-3] = 0x0ea7 // @0EA2 stack[-1] = 0x20 * stack[-1] + stack[-3] // @0EA2 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x2710, returns to 0x0EA7 label_0EA7: // Incoming return from call to 0x2710 at 0x0EA6 // Inputs[3] // { // @0EA8 stack[-4] // @0EA9 stack[-5] // @0EAC memory[0x40:0x60] // } 0EA7 5B JUMPDEST 0EA8 83 DUP4 0EA9 85 DUP6 0EAA 60 PUSH1 0x40 0EAC 51 MLOAD 0EAD 80 DUP1 0EAE 60 PUSH1 0x20 0EB0 01 ADD 0EB1 60 PUSH1 0x40 0EB3 52 MSTORE 0EB4 80 DUP1 0EB5 60 PUSH1 0x00 0EB7 81 DUP2 0EB8 52 MSTORE 0EB9 50 POP 0EBA 61 PUSH2 0x14f2 0EBD 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0EA8 stack[0] = stack[-4] // @0EA9 stack[1] = stack[-5] // @0EAC stack[2] = memory[0x40:0x60] // @0EB3 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0EB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x14f2 0EBE 5B JUMPDEST 0EBF 80 DUP1 0EC0 61 PUSH2 0x0ec8 0EC3 81 DUP2 0EC4 61 PUSH2 0x2f65 0EC7 56 *JUMP 0EC8 5B JUMPDEST 0EC9 91 SWAP2 0ECA 50 POP 0ECB 50 POP 0ECC 61 PUSH2 0x0e75 0ECF 56 *JUMP label_0ED0: // Incoming jump from 0x03A2 // Inputs[2] // { // @0ED3 storage[0x04] // @0EDD msg.sender // } 0ED0 5B JUMPDEST 0ED1 60 PUSH1 0x04 0ED3 54 SLOAD 0ED4 60 PUSH1 0x01 0ED6 60 PUSH1 0x01 0ED8 60 PUSH1 0xa0 0EDA 1B SHL 0EDB 03 SUB 0EDC 16 AND 0EDD 33 CALLER 0EDE 14 EQ 0EDF 61 PUSH2 0x0efa 0EE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0efa, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0EE3: // Incoming jump from 0x0EE2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0EE5 memory[0x40:0x60] } 0EE3 60 PUSH1 0x40 0EE5 51 MLOAD 0EE6 62 PUSH3 0x461bcd 0EEA 60 PUSH1 0xe5 0EEC 1B SHL 0EED 81 DUP2 0EEE 52 MSTORE 0EEF 60 PUSH1 0x04 0EF1 01 ADD 0EF2 61 PUSH2 0x054a 0EF5 90 SWAP1 0EF6 61 PUSH2 0x2e5e 0EF9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EF5 stack[0] = 0x054a // @0EF5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0EFA: // Incoming jump from 0x0EE2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[4] // { // @0EFD stack[-1] // @0F0B memory[0x00:0x40] // @0F0C stack[-2] // @0F0D memory[stack[-2]:stack[-2] + 0x20] // } 0EFA 5B JUMPDEST 0EFB 60 PUSH1 0x00 0EFD 81 DUP2 0EFE 81 DUP2 0EFF 52 MSTORE 0F00 60 PUSH1 0x09 0F02 60 PUSH1 0x20 0F04 90 SWAP1 0F05 81 DUP2 0F06 52 MSTORE 0F07 60 PUSH1 0x40 0F09 90 SWAP1 0F0A 91 SWAP2 0F0B 20 SHA3 0F0C 83 DUP4 0F0D 51 MLOAD 0F0E 61 PUSH2 0x0652 0F11 92 SWAP3 0F12 85 DUP6 0F13 01 ADD 0F14 90 SWAP1 0F15 61 PUSH2 0x251d 0F18 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0EFF memory[0x00:0x20] = stack[-1] // @0F06 memory[0x20:0x40] = 0x09 // @0F0B stack[1] = keccak256(memory[0x00:0x40]) // @0F11 stack[0] = 0x0652 // @0F14 stack[2] = stack[-2] + 0x20 // @0F14 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x251d label_0F19: // Incoming call from 0x03BA, returns to 0x023D // Inputs[2] // { // @0F1C storage[0x04] // @0F26 msg.sender // } 0F19 5B JUMPDEST 0F1A 60 PUSH1 0x04 0F1C 54 SLOAD 0F1D 60 PUSH1 0x01 0F1F 60 PUSH1 0x01 0F21 60 PUSH1 0xa0 0F23 1B SHL 0F24 03 SUB 0F25 16 AND 0F26 33 CALLER 0F27 14 EQ 0F28 61 PUSH2 0x0f43 0F2B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f43, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0F2C: // Incoming jump from 0x0F2B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0F2E memory[0x40:0x60] } 0F2C 60 PUSH1 0x40 0F2E 51 MLOAD 0F2F 62 PUSH3 0x461bcd 0F33 60 PUSH1 0xe5 0F35 1B SHL 0F36 81 DUP2 0F37 52 MSTORE 0F38 60 PUSH1 0x04 0F3A 01 ADD 0F3B 61 PUSH2 0x054a 0F3E 90 SWAP1 0F3F 61 PUSH2 0x2e5e 0F42 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F37 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F3E stack[0] = 0x054a // @0F3E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0F43: // Incoming jump from 0x0F2B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] 0F43 5B JUMPDEST 0F44 61 PUSH2 0x0c20 0F47 60 PUSH1 0x00 0F49 61 PUSH2 0x192b 0F4C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F44 stack[0] = 0x0c20 // @0F47 stack[1] = 0x00 // } // Block ends with call to 0x192b, returns to 0x0C20 label_0F4D: // Incoming call from 0x03C2, returns to 0x023D // Inputs[2] // { // @0F50 storage[0x04] // @0F5A msg.sender // } 0F4D 5B JUMPDEST 0F4E 60 PUSH1 0x04 0F50 54 SLOAD 0F51 60 PUSH1 0x01 0F53 60 PUSH1 0x01 0F55 60 PUSH1 0xa0 0F57 1B SHL 0F58 03 SUB 0F59 16 AND 0F5A 33 CALLER 0F5B 14 EQ 0F5C 61 PUSH2 0x0f77 0F5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f77, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0F60: // Incoming jump from 0x0F5F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0F62 memory[0x40:0x60] } 0F60 60 PUSH1 0x40 0F62 51 MLOAD 0F63 62 PUSH3 0x461bcd 0F67 60 PUSH1 0xe5 0F69 1B SHL 0F6A 81 DUP2 0F6B 52 MSTORE 0F6C 60 PUSH1 0x04 0F6E 01 ADD 0F6F 61 PUSH2 0x054a 0F72 90 SWAP1 0F73 61 PUSH2 0x2e5e 0F76 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F72 stack[0] = 0x054a // @0F72 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0F77: // Incoming jump from 0x0F5F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] 0F77 5B JUMPDEST 0F78 61 PUSH2 0x0c20 0F7B 61 PUSH2 0x197d 0F7E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F78 stack[0] = 0x0c20 } // Block ends with call to 0x197d, returns to 0x0C20 label_0F7F: // Incoming jump from 0x03D5 // Inputs[2] // { // @0F82 storage[0x04] // @0F8C msg.sender // } 0F7F 5B JUMPDEST 0F80 60 PUSH1 0x04 0F82 54 SLOAD 0F83 60 PUSH1 0x01 0F85 60 PUSH1 0x01 0F87 60 PUSH1 0xa0 0F89 1B SHL 0F8A 03 SUB 0F8B 16 AND 0F8C 33 CALLER 0F8D 14 EQ 0F8E 61 PUSH2 0x0fa9 0F91 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fa9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_0F92: // Incoming jump from 0x0F91, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @0F94 memory[0x40:0x60] } 0F92 60 PUSH1 0x40 0F94 51 MLOAD 0F95 62 PUSH3 0x461bcd 0F99 60 PUSH1 0xe5 0F9B 1B SHL 0F9C 81 DUP2 0F9D 52 MSTORE 0F9E 60 PUSH1 0x04 0FA0 01 ADD 0FA1 61 PUSH2 0x054a 0FA4 90 SWAP1 0FA5 61 PUSH2 0x2e5e 0FA8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FA4 stack[0] = 0x054a // @0FA4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_0FA9: // Incoming jump from 0x0F91, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[10] // { // @0FB2 memory[0x00:0x20] // @0FBB memory[0x00:0x20] // @0FBE storage[memory[0x00:0x20]] // @0FC2 memory[0x00:0x20] // @0FCB memory[0x00:0x20] // @0FCE storage[memory[0x00:0x20]] // @0FD7 memory[0x00:0x20] // @0FE0 memory[0x00:0x20] // @0FE3 storage[memory[0x00:0x20]] // @0FE8 stack[-1] // } 0FA9 5B JUMPDEST 0FAA 60 PUSH1 0x03 0FAC 60 PUSH1 0x20 0FAE 52 MSTORE 0FAF 60 PUSH1 0x00 0FB1 80 DUP1 0FB2 51 MLOAD 0FB3 60 PUSH1 0x20 0FB5 61 PUSH2 0x30d4 0FB8 83 DUP4 0FB9 39 CODECOPY 0FBA 81 DUP2 0FBB 51 MLOAD 0FBC 91 SWAP2 0FBD 52 MSTORE 0FBE 54 SLOAD 0FBF 60 PUSH1 0x00 0FC1 80 DUP1 0FC2 51 MLOAD 0FC3 60 PUSH1 0x20 0FC5 61 PUSH2 0x3094 0FC8 83 DUP4 0FC9 39 CODECOPY 0FCA 81 DUP2 0FCB 51 MLOAD 0FCC 91 SWAP2 0FCD 52 MSTORE 0FCE 54 SLOAD 0FCF 60 PUSH1 0x01 0FD1 60 PUSH1 0x00 0FD3 52 MSTORE 0FD4 60 PUSH1 0x00 0FD6 80 DUP1 0FD7 51 MLOAD 0FD8 60 PUSH1 0x20 0FDA 61 PUSH2 0x30b4 0FDD 83 DUP4 0FDE 39 CODECOPY 0FDF 81 DUP2 0FE0 51 MLOAD 0FE1 91 SWAP2 0FE2 52 MSTORE 0FE3 54 SLOAD 0FE4 61 PUSH2 0x1388 0FE7 92 SWAP3 0FE8 84 DUP5 0FE9 92 SWAP3 0FEA 90 SWAP1 0FEB 91 SWAP2 0FEC 61 PUSH2 0x0ff5 0FEF 91 SWAP2 0FF0 90 SWAP1 0FF1 61 PUSH2 0x2eb6 0FF4 56 *JUMP // Stack delta = +6 // Outputs[14] // { // @0FAE memory[0x20:0x40] = 0x03 // @0FB9 memory[0x00:0x20] = code[0x30d4:0x30f4] // @0FBD memory[0x00:0x20] = memory[0x00:0x20] // @0FC9 memory[0x00:0x20] = code[0x3094:0x30b4] // @0FCD memory[0x00:0x20] = memory[0x00:0x20] // @0FD3 memory[0x00:0x20] = 0x01 // @0FDE memory[0x00:0x20] = code[0x30b4:0x30d4] // @0FE2 memory[0x00:0x20] = memory[0x00:0x20] // @0FE7 stack[0] = 0x1388 // @0FE9 stack[1] = stack[-1] // @0FEB stack[2] = storage[memory[0x00:0x20]] // @0FEF stack[3] = 0x0ff5 // @0FF0 stack[4] = storage[memory[0x00:0x20]] // @0FF0 stack[5] = storage[memory[0x00:0x20]] // } // Block ends with call to 0x2eb6, returns to 0x0FF5 label_0FF5: // Incoming return from call to 0x2EB6 at 0x0FF4 // Inputs[2] // { // @0FF9 stack[-2] // @0FFA stack[-1] // } 0FF5 5B JUMPDEST 0FF6 61 PUSH2 0x0fff 0FF9 91 SWAP2 0FFA 90 SWAP1 0FFB 61 PUSH2 0x2eb6 0FFE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0FF9 stack[-2] = 0x0fff // @0FFA stack[-1] = stack[-2] // @0FFA stack[0] = stack[-1] // } // Block ends with call to 0x2eb6, returns to 0x0FFF label_0FFF: // Incoming return from call to 0x2EB6 at 0x0FFE // Inputs[2] // { // @1003 stack[-2] // @1004 stack[-1] // } 0FFF 5B JUMPDEST 1000 61 PUSH2 0x1009 1003 91 SWAP2 1004 90 SWAP1 1005 61 PUSH2 0x2eb6 1008 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1003 stack[-2] = 0x1009 // @1004 stack[-1] = stack[-2] // @1004 stack[0] = stack[-1] // } // Block ends with call to 0x2eb6, returns to 0x1009 label_1009: // Incoming return from call to 0x2EB6 at 0x1008 // Inputs[2] // { // @100A stack[-1] // @100A stack[-2] // } 1009 5B JUMPDEST 100A 11 GT 100B 15 ISZERO 100C 61 PUSH2 0x1048 100F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1048, if !(stack[-1] > stack[-2]) label_1010: // Incoming jump from 0x100F, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1012 memory[0x40:0x60] } 1010 60 PUSH1 0x40 1012 51 MLOAD 1013 62 PUSH3 0x461bcd 1017 60 PUSH1 0xe5 1019 1B SHL 101A 81 DUP2 101B 52 MSTORE 101C 60 PUSH1 0x20 101E 60 PUSH1 0x04 1020 82 DUP3 1021 01 ADD 1022 52 MSTORE 1023 60 PUSH1 0x0e 1025 60 PUSH1 0x24 1027 82 DUP3 1028 01 ADD 1029 52 MSTORE 102A 6D PUSH14 0x4d494e545f544f4f5f4c41524745 1039 60 PUSH1 0x90 103B 1B SHL 103C 60 PUSH1 0x44 103E 82 DUP3 103F 01 ADD 1040 52 MSTORE 1041 60 PUSH1 0x64 1043 01 ADD 1044 61 PUSH2 0x054a 1047 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @101B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1022 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1029 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @1040 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d494e545f544f4f5f4c41524745 << 0x90 // @1043 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1048: // Incoming jump from 0x100F, if !(stack[-1] > stack[-2]) // Inputs[1] { @104C stack[-1] } 1048 5B JUMPDEST 1049 60 PUSH1 0x00 104B 5B JUMPDEST 104C 81 DUP2 104D 81 DUP2 104E 10 LT 104F 15 ISZERO 1050 61 PUSH2 0x0652 1053 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1049 stack[0] = 0x00 } // Block ends with conditional jump to 0x0652, if !(0x00 < stack[-1]) label_1054: // Incoming jump from 0x1053, if not !(0x00 < stack[-1]) // Inputs[3] // { // @1057 stack[-3] // @1058 stack[-2] // @1059 stack[-1] // } 1054 61 PUSH2 0x1086 1057 83 DUP4 1058 83 DUP4 1059 83 DUP4 105A 81 DUP2 105B 81 DUP2 105C 10 LT 105D 61 PUSH2 0x1068 1060 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1054 stack[0] = 0x1086 // @1057 stack[1] = stack[-3] // @1058 stack[2] = stack[-2] // @1059 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x1068, if stack[-1] < stack[-2] label_1061: // Incoming jump from 0x1060, if not stack[-1] < stack[-2] 1061 61 PUSH2 0x1068 1064 61 PUSH2 0x2fac 1067 56 *JUMP // Stack delta = +1 // Outputs[1] { @1061 stack[0] = 0x1068 } // Block ends with unconditional jump to 0x2fac label_1068: // Incoming jump from 0x1060, if stack[-1] < stack[-2] // Inputs[3] // { // @1069 stack[-2] // @1069 stack[-1] // @106E stack[-3] // } 1068 5B JUMPDEST 1069 90 SWAP1 106A 50 POP 106B 60 PUSH1 0x20 106D 02 MUL 106E 01 ADD 106F 60 PUSH1 0x20 1071 81 DUP2 1072 01 ADD 1073 90 SWAP1 1074 61 PUSH2 0x107d 1077 91 SWAP2 1078 90 SWAP1 1079 61 PUSH2 0x2710 107C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1077 stack[-3] = 0x107d // @1078 stack[-1] = 0x20 * stack[-1] + stack[-3] // @1078 stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x2710, returns to 0x107D label_107D: // Incoming return from call to 0x2710 at 0x107C // Inputs[1] { @1081 stack[-3] } 107D 5B JUMPDEST 107E 61 PUSH2 0x0a88 1081 83 DUP4 1082 61 PUSH2 0x1624 1085 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @107E stack[0] = 0x0a88 // @1081 stack[1] = stack[-3] // } // Block ends with call to 0x1624, returns to 0x0A88 1086 5B JUMPDEST 1087 80 DUP1 1088 61 PUSH2 0x1090 108B 81 DUP2 108C 61 PUSH2 0x2f65 108F 56 *JUMP 1090 5B JUMPDEST 1091 91 SWAP2 1092 50 POP 1093 50 POP 1094 61 PUSH2 0x104b 1097 56 *JUMP label_1098: // Incoming jump from 0x0403 // Inputs[2] // { // @109B storage[0x04] // @10A5 msg.sender // } 1098 5B JUMPDEST 1099 60 PUSH1 0x04 109B 54 SLOAD 109C 60 PUSH1 0x01 109E 60 PUSH1 0x01 10A0 60 PUSH1 0xa0 10A2 1B SHL 10A3 03 SUB 10A4 16 AND 10A5 33 CALLER 10A6 14 EQ 10A7 61 PUSH2 0x10c2 10AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10c2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_10AB: // Incoming jump from 0x10AA, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @10AD memory[0x40:0x60] } 10AB 60 PUSH1 0x40 10AD 51 MLOAD 10AE 62 PUSH3 0x461bcd 10B2 60 PUSH1 0xe5 10B4 1B SHL 10B5 81 DUP2 10B6 52 MSTORE 10B7 60 PUSH1 0x04 10B9 01 ADD 10BA 61 PUSH2 0x054a 10BD 90 SWAP1 10BE 61 PUSH2 0x2e5e 10C1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10BD stack[0] = 0x054a // @10BD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_10C2: // Incoming jump from 0x10AA, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[2] // { // @10C5 storage[0x07] // @10D1 stack[-1] // } 10C2 5B JUMPDEST 10C3 60 PUSH1 0x07 10C5 54 SLOAD 10C6 60 PUSH1 0xff 10C8 61 PUSH2 0x0100 10CB 90 SWAP1 10CC 91 SWAP2 10CD 04 DIV 10CE 16 AND 10CF 15 ISZERO 10D0 15 ISZERO 10D1 81 DUP2 10D2 15 ISZERO 10D3 15 ISZERO 10D4 14 EQ 10D5 15 ISZERO 10D6 61 PUSH2 0x1121 10D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1121, if !(!!stack[-1] == !!(storage[0x07] / 0x0100 & 0xff)) label_10DA: // Incoming jump from 0x10D9, if not !(!!stack[-1] == !!(storage[0x07] / 0x0100 & 0xff)) // Inputs[1] { @10DC memory[0x40:0x60] } 10DA 60 PUSH1 0x40 10DC 51 MLOAD 10DD 62 PUSH3 0x461bcd 10E1 60 PUSH1 0xe5 10E3 1B SHL 10E4 81 DUP2 10E5 52 MSTORE 10E6 60 PUSH1 0x20 10E8 60 PUSH1 0x04 10EA 82 DUP3 10EB 01 ADD 10EC 81 DUP2 10ED 90 SWAP1 10EE 52 MSTORE 10EF 60 PUSH1 0x24 10F1 82 DUP3 10F2 01 ADD 10F3 52 MSTORE 10F4 7F PUSH32 0x4e45575f53544154455f4944454e544943414c5f544f5f4f4c445f5354415445 1115 60 PUSH1 0x44 1117 82 DUP3 1118 01 ADD 1119 52 MSTORE 111A 60 PUSH1 0x64 111C 01 ADD 111D 61 PUSH2 0x054a 1120 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10EE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10F3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1119 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e45575f53544154455f4944454e544943414c5f544f5f4f4c445f5354415445 // @111C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1121: // Incoming jump from 0x10D9, if !(!!stack[-1] == !!(storage[0x07] / 0x0100 & 0xff)) // Inputs[3] // { // @1125 storage[0x07] // @1126 stack[-1] // @113A stack[-2] // } 1121 5B JUMPDEST 1122 60 PUSH1 0x07 1124 80 DUP1 1125 54 SLOAD 1126 91 SWAP2 1127 15 ISZERO 1128 15 ISZERO 1129 61 PUSH2 0x0100 112C 02 MUL 112D 61 PUSH2 0xff00 1130 19 NOT 1131 90 SWAP1 1132 92 SWAP3 1133 16 AND 1134 91 SWAP2 1135 90 SWAP1 1136 91 SWAP2 1137 17 OR 1138 90 SWAP1 1139 55 SSTORE 113A 56 *JUMP // Stack delta = -2 // Outputs[1] { @1139 storage[0x07] = (storage[0x07] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_113B: // Incoming call from 0x040B, returns to 0x02A3 // Inputs[1] { @113F storage[0x06] } 113B 5B JUMPDEST 113C 60 PUSH1 0x06 113E 80 DUP1 113F 54 SLOAD 1140 61 PUSH2 0x07af 1143 90 SWAP1 1144 61 PUSH2 0x2f04 1147 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @113C stack[0] = 0x06 // @1143 stack[1] = 0x07af // @1143 stack[2] = storage[0x06] // } // Block ends with call to 0x2f04, returns to 0x07AF label_1148: // Incoming jump from 0x041E // Inputs[3] // { // @114C msg.sender // @114D stack[-2] // @114E stack[-1] // } 1148 5B JUMPDEST 1149 61 PUSH2 0x1153 114C 33 CALLER 114D 83 DUP4 114E 83 DUP4 114F 61 PUSH2 0x1a05 1152 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1149 stack[0] = 0x1153 // @114C stack[1] = msg.sender // @114D stack[2] = stack[-2] // @114E stack[3] = stack[-1] // } // Block ends with call to 0x1a05, returns to 0x1153 label_1153: // Incoming return from call to 0x1A05 at 0x1152 // Inputs[1] { @1156 stack[-3] } 1153 5B JUMPDEST 1154 50 POP 1155 50 POP 1156 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1157: // Incoming jump from 0x0451 // Inputs[2] // { // @115A storage[0x04] // @1164 msg.sender // } 1157 5B JUMPDEST 1158 60 PUSH1 0x04 115A 54 SLOAD 115B 60 PUSH1 0x01 115D 60 PUSH1 0x01 115F 60 PUSH1 0xa0 1161 1B SHL 1162 03 SUB 1163 16 AND 1164 33 CALLER 1165 14 EQ 1166 61 PUSH2 0x1181 1169 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1181, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_116A: // Incoming jump from 0x1169, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @116C memory[0x40:0x60] } 116A 60 PUSH1 0x40 116C 51 MLOAD 116D 62 PUSH3 0x461bcd 1171 60 PUSH1 0xe5 1173 1B SHL 1174 81 DUP2 1175 52 MSTORE 1176 60 PUSH1 0x04 1178 01 ADD 1179 61 PUSH2 0x054a 117C 90 SWAP1 117D 61 PUSH2 0x2e5e 1180 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1175 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @117C stack[0] = 0x054a // @117C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_1181: // Incoming jump from 0x1169, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @1185 stack[-1] } 1181 5B JUMPDEST 1182 61 PUSH2 0x0abe 1185 81 DUP2 1186 61 PUSH2 0x1ae6 1189 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1182 stack[0] = 0x0abe // @1185 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1ae6 label_118A: // Incoming jump from 0x0464 // Inputs[3] // { // @1192 stack[-1] // @1198 memory[0x00:0x40] // @119A storage[keccak256(memory[0x00:0x40])] // } 118A 5B JUMPDEST 118B 60 PUSH1 0x09 118D 60 PUSH1 0x20 118F 52 MSTORE 1190 60 PUSH1 0x00 1192 90 SWAP1 1193 81 DUP2 1194 52 MSTORE 1195 60 PUSH1 0x40 1197 90 SWAP1 1198 20 SHA3 1199 80 DUP1 119A 54 SLOAD 119B 61 PUSH2 0x07af 119E 90 SWAP1 119F 61 PUSH2 0x2f04 11A2 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @118F memory[0x20:0x40] = 0x09 // @1194 memory[0x00:0x20] = stack[-1] // @1198 stack[-1] = keccak256(memory[0x00:0x40]) // @119E stack[1] = storage[keccak256(memory[0x00:0x40])] // @119E stack[0] = 0x07af // } // Block ends with call to 0x2f04, returns to 0x07AF label_11A3: // Incoming jump from 0x04F9 // Inputs[1] { @11A6 stack[-2] } 11A3 5B JUMPDEST 11A4 60 PUSH1 0x00 11A6 82 DUP3 11A7 11 GT 11A8 61 PUSH2 0x11eb 11AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11eb, if stack[-2] > 0x00 label_11AC: // Incoming jump from 0x11AB, if not stack[-2] > 0x00 // Inputs[1] { @11AE memory[0x40:0x60] } 11AC 60 PUSH1 0x40 11AE 51 MLOAD 11AF 62 PUSH3 0x461bcd 11B3 60 PUSH1 0xe5 11B5 1B SHL 11B6 81 DUP2 11B7 52 MSTORE 11B8 60 PUSH1 0x20 11BA 60 PUSH1 0x04 11BC 82 DUP3 11BD 01 ADD 11BE 52 MSTORE 11BF 60 PUSH1 0x15 11C1 60 PUSH1 0x24 11C3 82 DUP3 11C4 01 ADD 11C5 52 MSTORE 11C6 74 PUSH21 0x414d4f554e545f43414e4e4f545f42455f5a45524f 11DC 60 PUSH1 0x58 11DE 1B SHL 11DF 60 PUSH1 0x44 11E1 82 DUP3 11E2 01 ADD 11E3 52 MSTORE 11E4 60 PUSH1 0x64 11E6 01 ADD 11E7 61 PUSH2 0x054a 11EA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11BE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11C5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @11E3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x414d4f554e545f43414e4e4f545f42455f5a45524f << 0x58 // @11E6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_11EB: // Incoming jump from 0x11AB, if stack[-2] > 0x00 // Inputs[5] // { // @11EF stack[-5] // @11F0 stack[-4] // @11F1 stack[-3] // @11F2 stack[-2] // @11F3 stack[-1] // } 11EB 5B JUMPDEST 11EC 61 PUSH2 0x0b51 11EF 85 DUP6 11F0 85 DUP6 11F1 85 DUP6 11F2 85 DUP6 11F3 85 DUP6 11F4 61 PUSH2 0x1af9 11F7 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @11EC stack[0] = 0x0b51 // @11EF stack[1] = stack[-5] // @11F0 stack[2] = stack[-4] // @11F1 stack[3] = stack[-3] // @11F2 stack[4] = stack[-2] // @11F3 stack[5] = stack[-1] // } // Block ends with unconditional jump to 0x1af9 label_11F8: // Incoming jump from 0x050C // Inputs[2] // { // @11FB storage[0x04] // @1205 msg.sender // } 11F8 5B JUMPDEST 11F9 60 PUSH1 0x04 11FB 54 SLOAD 11FC 60 PUSH1 0x01 11FE 60 PUSH1 0x01 1200 60 PUSH1 0xa0 1202 1B SHL 1203 03 SUB 1204 16 AND 1205 33 CALLER 1206 14 EQ 1207 61 PUSH2 0x1222 120A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1222, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] label_120B: // Incoming jump from 0x120A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @120D memory[0x40:0x60] } 120B 60 PUSH1 0x40 120D 51 MLOAD 120E 62 PUSH3 0x461bcd 1212 60 PUSH1 0xe5 1214 1B SHL 1215 81 DUP2 1216 52 MSTORE 1217 60 PUSH1 0x04 1219 01 ADD 121A 61 PUSH2 0x054a 121D 90 SWAP1 121E 61 PUSH2 0x2e5e 1221 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1216 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @121D stack[0] = 0x054a // @121D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2e5e, returns to 0x054A label_1222: // Incoming jump from 0x120A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x04] // Inputs[1] { @122B stack[-1] } 1222 5B JUMPDEST 1223 60 PUSH1 0x01 1225 60 PUSH1 0x01 1227 60 PUSH1 0xa0 1229 1B SHL 122A 03 SUB 122B 81 DUP2 122C 16 AND 122D 61 PUSH2 0x1287 1230 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1287, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1231: // Incoming jump from 0x1230, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1233 memory[0x40:0x60] } 1231 60 PUSH1 0x40 1233 51 MLOAD 1234 62 PUSH3 0x461bcd 1238 60 PUSH1 0xe5 123A 1B SHL 123B 81 DUP2 123C 52 MSTORE 123D 60 PUSH1 0x20 123F 60 PUSH1 0x04 1241 82 DUP3 1242 01 ADD 1243 52 MSTORE 1244 60 PUSH1 0x26 1246 60 PUSH1 0x24 1248 82 DUP3 1249 01 ADD 124A 52 MSTORE 124B 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 126C 60 PUSH1 0x44 126E 82 DUP3 126F 01 ADD 1270 52 MSTORE 1271 65 PUSH6 0x646472657373 1278 60 PUSH1 0xd0 127A 1B SHL 127B 60 PUSH1 0x64 127D 82 DUP3 127E 01 ADD 127F 52 MSTORE 1280 60 PUSH1 0x84 1282 01 ADD 1283 61 PUSH2 0x054a 1286 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @123C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1243 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @124A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1270 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @127F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1282 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1287: // Incoming jump from 0x1230, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @128B stack[-1] } 1287 5B JUMPDEST 1288 61 PUSH2 0x0abe 128B 81 DUP2 128C 61 PUSH2 0x192b 128F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1288 stack[0] = 0x0abe // @128B stack[1] = stack[-1] // } // Block ends with call to 0x192b, returns to 0x0ABE label_1290: // Incoming jump from 0x051F // Inputs[2] // { // @1291 msg.sender // @1292 tx.origin // } 1290 5B JUMPDEST 1291 33 CALLER 1292 32 ORIGIN 1293 14 EQ 1294 61 PUSH2 0x12af 1297 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12af, if tx.origin == msg.sender label_1298: // Incoming jump from 0x1297, if not tx.origin == msg.sender // Inputs[1] { @129A memory[0x40:0x60] } 1298 60 PUSH1 0x40 129A 51 MLOAD 129B 62 PUSH3 0x461bcd 129F 60 PUSH1 0xe5 12A1 1B SHL 12A2 81 DUP2 12A3 52 MSTORE 12A4 60 PUSH1 0x04 12A6 01 ADD 12A7 61 PUSH2 0x054a 12AA 90 SWAP1 12AB 61 PUSH2 0x2d8a 12AE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12AA stack[0] = 0x054a // @12AA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2d8a, returns to 0x054A label_12AF: // Incoming jump from 0x1297, if tx.origin == msg.sender // Inputs[1] { @12B2 storage[0x07] } 12AF 5B JUMPDEST 12B0 60 PUSH1 0x07 12B2 54 SLOAD 12B3 60 PUSH1 0xff 12B5 16 AND 12B6 61 PUSH2 0x12f3 12B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12f3, if 0xff & storage[0x07] label_12BA: // Incoming jump from 0x12B9, if not 0xff & storage[0x07] // Inputs[1] { @12BC memory[0x40:0x60] } 12BA 60 PUSH1 0x40 12BC 51 MLOAD 12BD 62 PUSH3 0x461bcd 12C1 60 PUSH1 0xe5 12C3 1B SHL 12C4 81 DUP2 12C5 52 MSTORE 12C6 60 PUSH1 0x20 12C8 60 PUSH1 0x04 12CA 82 DUP3 12CB 01 ADD 12CC 52 MSTORE 12CD 60 PUSH1 0x0f 12CF 60 PUSH1 0x24 12D1 82 DUP3 12D2 01 ADD 12D3 52 MSTORE 12D4 6E PUSH15 0x53414c455f4e4f545f414354495645 12E4 60 PUSH1 0x88 12E6 1B SHL 12E7 60 PUSH1 0x44 12E9 82 DUP3 12EA 01 ADD 12EB 52 MSTORE 12EC 60 PUSH1 0x64 12EE 01 ADD 12EF 61 PUSH2 0x054a 12F2 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @12C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12CC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12D3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @12EB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53414c455f4e4f545f414354495645 << 0x88 // @12EE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_12F3: // Incoming jump from 0x12B9, if 0xff & storage[0x07] // Inputs[3] // { // @12F4 msg.sender // @1302 memory[0x00:0x40] // @1303 storage[keccak256(memory[0x00:0x40])] // } 12F3 5B JUMPDEST 12F4 33 CALLER 12F5 60 PUSH1 0x00 12F7 90 SWAP1 12F8 81 DUP2 12F9 52 MSTORE 12FA 60 PUSH1 0x0a 12FC 60 PUSH1 0x20 12FE 52 MSTORE 12FF 60 PUSH1 0x40 1301 90 SWAP1 1302 20 SHA3 1303 54 SLOAD 1304 60 PUSH1 0xff 1306 16 AND 1307 15 ISZERO 1308 61 PUSH2 0x1353 130B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @12F9 memory[0x00:0x20] = msg.sender // @12FE memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x1353, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_130C: // Incoming jump from 0x130B, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @130E memory[0x40:0x60] } 130C 60 PUSH1 0x40 130E 51 MLOAD 130F 62 PUSH3 0x461bcd 1313 60 PUSH1 0xe5 1315 1B SHL 1316 81 DUP2 1317 52 MSTORE 1318 60 PUSH1 0x20 131A 60 PUSH1 0x04 131C 82 DUP3 131D 01 ADD 131E 52 MSTORE 131F 60 PUSH1 0x1a 1321 60 PUSH1 0x24 1323 82 DUP3 1324 01 ADD 1325 52 MSTORE 1326 7F PUSH32 0x414444524553535f4841535f414c52454144595f4d494e544544000000000000 1347 60 PUSH1 0x44 1349 82 DUP3 134A 01 ADD 134B 52 MSTORE 134C 60 PUSH1 0x64 134E 01 ADD 134F 61 PUSH2 0x054a 1352 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1317 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @131E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1325 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @134B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x414444524553535f4841535f414c52454144595f4d494e544544000000000000 // @134E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1353: // Incoming jump from 0x130B, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @135C memory[0x00:0x20] // @1365 memory[0x00:0x20] // @1368 storage[memory[0x00:0x20]] // @136C memory[0x00:0x20] // @1375 memory[0x00:0x20] // @1378 storage[memory[0x00:0x20]] // @1383 memory[0x00:0x20] // @138C memory[0x00:0x20] // @138F storage[memory[0x00:0x20]] // } 1353 5B JUMPDEST 1354 60 PUSH1 0x03 1356 60 PUSH1 0x20 1358 52 MSTORE 1359 60 PUSH1 0x00 135B 80 DUP1 135C 51 MLOAD 135D 60 PUSH1 0x20 135F 61 PUSH2 0x30d4 1362 83 DUP4 1363 39 CODECOPY 1364 81 DUP2 1365 51 MLOAD 1366 91 SWAP2 1367 52 MSTORE 1368 54 SLOAD 1369 60 PUSH1 0x00 136B 80 DUP1 136C 51 MLOAD 136D 60 PUSH1 0x20 136F 61 PUSH2 0x3094 1372 83 DUP4 1373 39 CODECOPY 1374 81 DUP2 1375 51 MLOAD 1376 91 SWAP2 1377 52 MSTORE 1378 54 SLOAD 1379 60 PUSH1 0x01 137B 60 PUSH1 0x00 137D 90 SWAP1 137E 81 DUP2 137F 52 MSTORE 1380 60 PUSH1 0x00 1382 80 DUP1 1383 51 MLOAD 1384 60 PUSH1 0x20 1386 61 PUSH2 0x30b4 1389 83 DUP4 138A 39 CODECOPY 138B 81 DUP2 138C 51 MLOAD 138D 91 SWAP2 138E 52 MSTORE 138F 54 SLOAD 1390 90 SWAP1 1391 92 SWAP3 1392 91 SWAP2 1393 61 PUSH2 0x139b 1396 91 SWAP2 1397 61 PUSH2 0x2eb6 139A 56 *JUMP // Stack delta = +5 // Outputs[13] // { // @1358 memory[0x20:0x40] = 0x03 // @1363 memory[0x00:0x20] = code[0x30d4:0x30f4] // @1367 memory[0x00:0x20] = memory[0x00:0x20] // @1373 memory[0x00:0x20] = code[0x3094:0x30b4] // @1377 memory[0x00:0x20] = memory[0x00:0x20] // @137F memory[0x00:0x20] = 0x01 // @138A memory[0x00:0x20] = code[0x30b4:0x30d4] // @138E memory[0x00:0x20] = memory[0x00:0x20] // @1391 stack[0] = 0x00 // @1392 stack[3] = storage[memory[0x00:0x20]] // @1392 stack[1] = storage[memory[0x00:0x20]] // @1396 stack[2] = 0x139b // @1396 stack[4] = storage[memory[0x00:0x20]] // } // Block ends with call to 0x2eb6, returns to 0x139B label_139B: // Incoming return from call to 0x2EB6 at 0x139A // Inputs[2] // { // @139F stack[-2] // @13A0 stack[-1] // } 139B 5B JUMPDEST 139C 61 PUSH2 0x13a5 139F 91 SWAP2 13A0 90 SWAP1 13A1 61 PUSH2 0x2eb6 13A4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @139F stack[-2] = 0x13a5 // @13A0 stack[-1] = stack[-2] // @13A0 stack[0] = stack[-1] // } // Block ends with call to 0x2eb6, returns to 0x13A5 label_13A5: // Incoming return from call to 0x2EB6 at 0x13A4 // Inputs[2] // { // @13A6 stack[-2] // @13A6 stack[-1] // } 13A5 5B JUMPDEST 13A6 90 SWAP1 13A7 50 POP 13A8 61 PUSH2 0x1388 13AB 81 DUP2 13AC 10 LT 13AD 61 PUSH2 0x13ec 13B0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @13A6 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x13ec, if stack[-1] < 0x1388 label_13B1: // Incoming jump from 0x13B0, if not stack[-1] < 0x1388 // Inputs[1] { @13B3 memory[0x40:0x60] } 13B1 60 PUSH1 0x40 13B3 51 MLOAD 13B4 62 PUSH3 0x461bcd 13B8 60 PUSH1 0xe5 13BA 1B SHL 13BB 81 DUP2 13BC 52 MSTORE 13BD 60 PUSH1 0x20 13BF 60 PUSH1 0x04 13C1 82 DUP3 13C2 01 ADD 13C3 52 MSTORE 13C4 60 PUSH1 0x11 13C6 60 PUSH1 0x24 13C8 82 DUP3 13C9 01 ADD 13CA 52 MSTORE 13CB 70 PUSH17 0x13505617d513d2d15394d7d35253951151 13DD 60 PUSH1 0x7a 13DF 1B SHL 13E0 60 PUSH1 0x44 13E2 82 DUP3 13E3 01 ADD 13E4 52 MSTORE 13E5 60 PUSH1 0x64 13E7 01 ADD 13E8 61 PUSH2 0x054a 13EB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @13BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @13E4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13505617d513d2d15394d7d35253951151 << 0x7a // @13E7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_13EC: // Incoming jump from 0x13B0, if stack[-1] < 0x1388 // Inputs[2] // { // @13ED stack[-4] // @13F1 msg.sender // } 13EC 5B JUMPDEST 13ED 83 DUP4 13EE 61 PUSH2 0x13f6 13F1 33 CALLER 13F2 61 PUSH2 0x1b80 13F5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13ED stack[0] = stack[-4] // @13EE stack[1] = 0x13f6 // @13F1 stack[2] = msg.sender // } // Block ends with call to 0x1b80, returns to 0x13F6 label_13F6: // Incoming return from call to 0x1B80 at 0x13F5 // Inputs[2] // { // @13F7 stack[-2] // @13F7 stack[-1] // } 13F6 5B JUMPDEST 13F7 14 EQ 13F8 61 PUSH2 0x1435 13FB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1435, if stack[-1] == stack[-2] label_13FC: // Incoming jump from 0x13FB, if not stack[-1] == stack[-2] // Inputs[1] { @13FE memory[0x40:0x60] } 13FC 60 PUSH1 0x40 13FE 51 MLOAD 13FF 62 PUSH3 0x461bcd 1403 60 PUSH1 0xe5 1405 1B SHL 1406 81 DUP2 1407 52 MSTORE 1408 60 PUSH1 0x20 140A 60 PUSH1 0x04 140C 82 DUP3 140D 01 ADD 140E 52 MSTORE 140F 60 PUSH1 0x0f 1411 60 PUSH1 0x24 1413 82 DUP3 1414 01 ADD 1415 52 MSTORE 1416 6E PUSH15 0x135154d4d051d157d2539590531251 1426 60 PUSH1 0x8a 1428 1B SHL 1429 60 PUSH1 0x44 142B 82 DUP3 142C 01 ADD 142D 52 MSTORE 142E 60 PUSH1 0x64 1430 01 ADD 1431 61 PUSH2 0x054a 1434 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1407 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @140E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1415 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @142D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x135154d4d051d157d2539590531251 << 0x8a // @1430 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1435: // Incoming jump from 0x13FB, if stack[-1] == stack[-2] // Inputs[5] // { // @1439 stack[-4] // @143A stack[-3] // @143B stack[-2] // @144C memory[0x40:0x60] // @1463 msg.data[stack[-3]:stack[-3] + stack[-2]] // } 1435 5B JUMPDEST 1436 61 PUSH2 0x1475 1439 84 DUP5 143A 84 DUP5 143B 84 DUP5 143C 80 DUP1 143D 80 DUP1 143E 60 PUSH1 0x1f 1440 01 ADD 1441 60 PUSH1 0x20 1443 80 DUP1 1444 91 SWAP2 1445 04 DIV 1446 02 MUL 1447 60 PUSH1 0x20 1449 01 ADD 144A 60 PUSH1 0x40 144C 51 MLOAD 144D 90 SWAP1 144E 81 DUP2 144F 01 ADD 1450 60 PUSH1 0x40 1452 52 MSTORE 1453 80 DUP1 1454 93 SWAP4 1455 92 SWAP3 1456 91 SWAP2 1457 90 SWAP1 1458 81 DUP2 1459 81 DUP2 145A 52 MSTORE 145B 60 PUSH1 0x20 145D 01 ADD 145E 83 DUP4 145F 83 DUP4 1460 80 DUP1 1461 82 DUP3 1462 84 DUP5 1463 37 CALLDATACOPY 1464 60 PUSH1 0x00 1466 92 SWAP3 1467 01 ADD 1468 91 SWAP2 1469 90 SWAP1 146A 91 SWAP2 146B 52 MSTORE 146C 50 POP 146D 61 PUSH2 0x1bb5 1470 92 SWAP3 1471 50 POP 1472 50 POP 1473 50 POP 1474 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @1436 stack[0] = 0x1475 // @1439 stack[1] = stack[-4] // @1452 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @1454 stack[2] = memory[0x40:0x60] // @145A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1463 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @146B memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // } // Block ends with call to 0x1bb5, returns to 0x1475 label_1475: // Incoming return from call to 0x1BB5 at 0x1474 // Inputs[1] { @1479 stack[-1] } 1475 5B JUMPDEST 1476 61 PUSH2 0x14c1 1479 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14c1, if stack[-1] label_147A: // Incoming jump from 0x1479, if not stack[-1] // Inputs[1] { @147C memory[0x40:0x60] } 147A 60 PUSH1 0x40 147C 51 MLOAD 147D 62 PUSH3 0x461bcd 1481 60 PUSH1 0xe5 1483 1B SHL 1484 81 DUP2 1485 52 MSTORE 1486 60 PUSH1 0x20 1488 60 PUSH1 0x04 148A 82 DUP3 148B 01 ADD 148C 52 MSTORE 148D 60 PUSH1 0x1b 148F 60 PUSH1 0x24 1491 82 DUP3 1492 01 ADD 1493 52 MSTORE 1494 7F PUSH32 0x5349474e41545552455f56414c49444154494f4e5f4641494c45440000000000 14B5 60 PUSH1 0x44 14B7 82 DUP3 14B8 01 ADD 14B9 52 MSTORE 14BA 60 PUSH1 0x64 14BC 01 ADD 14BD 61 PUSH2 0x054a 14C0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1485 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @148C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1493 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @14B9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5349474e41545552455f56414c49444154494f4e5f4641494c45440000000000 // @14BC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_14C1: // Incoming jump from 0x1479, if stack[-1] // Inputs[3] // { // @14C2 msg.sender // @14D0 memory[0x00:0x40] // @14D2 storage[keccak256(memory[0x00:0x40])] // } 14C1 5B JUMPDEST 14C2 33 CALLER 14C3 60 PUSH1 0x00 14C5 81 DUP2 14C6 81 DUP2 14C7 52 MSTORE 14C8 60 PUSH1 0x0a 14CA 60 PUSH1 0x20 14CC 52 MSTORE 14CD 60 PUSH1 0x40 14CF 90 SWAP1 14D0 20 SHA3 14D1 80 DUP1 14D2 54 SLOAD 14D3 60 PUSH1 0xff 14D5 19 NOT 14D6 16 AND 14D7 60 PUSH1 0x01 14D9 90 SWAP1 14DA 81 DUP2 14DB 17 OR 14DC 90 SWAP1 14DD 91 SWAP2 14DE 55 SSTORE 14DF 61 PUSH2 0x14ec 14E2 91 SWAP2 14E3 90 SWAP1 14E4 61 PUSH2 0x0a88 14E7 90 SWAP1 14E8 61 PUSH2 0x1624 14EB 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @14C7 memory[0x00:0x20] = msg.sender // @14CC memory[0x20:0x40] = 0x0a // @14DE storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @14E2 stack[0] = 0x14ec // @14E3 stack[1] = msg.sender // @14E7 stack[2] = 0x0a88 // @14E7 stack[3] = 0x01 // } // Block ends with call to 0x1624, returns to 0x0A88 14EC 5B JUMPDEST 14ED 50 POP 14EE 50 POP 14EF 50 POP 14F0 50 POP 14F1 56 *JUMP label_14F2: // Incoming jump from 0x0EBD // Incoming jump from 0x0651 // Incoming jump from 0x0A9E // Inputs[1] { @14FB stack[-4] } 14F2 5B JUMPDEST 14F3 60 PUSH1 0x01 14F5 60 PUSH1 0x01 14F7 60 PUSH1 0xa0 14F9 1B SHL 14FA 03 SUB 14FB 84 DUP5 14FC 16 AND 14FD 61 PUSH2 0x1552 1500 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1552, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1501: // Incoming jump from 0x1500, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1503 memory[0x40:0x60] } 1501 60 PUSH1 0x40 1503 51 MLOAD 1504 62 PUSH3 0x461bcd 1508 60 PUSH1 0xe5 150A 1B SHL 150B 81 DUP2 150C 52 MSTORE 150D 60 PUSH1 0x20 150F 60 PUSH1 0x04 1511 82 DUP3 1512 01 ADD 1513 52 MSTORE 1514 60 PUSH1 0x21 1516 60 PUSH1 0x24 1518 82 DUP3 1519 01 ADD 151A 52 MSTORE 151B 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 153C 60 PUSH1 0x44 153E 82 DUP3 153F 01 ADD 1540 52 MSTORE 1541 60 PUSH1 0x73 1543 60 PUSH1 0xf8 1545 1B SHL 1546 60 PUSH1 0x64 1548 82 DUP3 1549 01 ADD 154A 52 MSTORE 154B 60 PUSH1 0x84 154D 01 ADD 154E 61 PUSH2 0x054a 1551 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @150C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1513 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @151A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @1540 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @154A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73 << 0xf8 // @154D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1552: // Incoming jump from 0x1500, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1553 msg.sender // @1559 stack[-3] // } 1552 5B JUMPDEST 1553 33 CALLER 1554 60 PUSH1 0x00 1556 61 PUSH2 0x155e 1559 85 DUP6 155A 61 PUSH2 0x1be9 155D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1553 stack[0] = msg.sender // @1554 stack[1] = 0x00 // @1556 stack[2] = 0x155e // @1559 stack[3] = stack[-3] // } // Block ends with call to 0x1be9, returns to 0x155E label_155E: // Incoming return from call to 0x1BE9 at 0x155D // Inputs[3] // { // @155F stack[-1] // @155F stack[-2] // @1566 stack[-5] // } 155E 5B JUMPDEST 155F 90 SWAP1 1560 50 POP 1561 60 PUSH1 0x00 1563 61 PUSH2 0x156b 1566 85 DUP6 1567 61 PUSH2 0x1be9 156A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @155F stack[-2] = stack[-1] // @1561 stack[-1] = 0x00 // @1563 stack[0] = 0x156b // @1566 stack[1] = stack[-5] // } // Block ends with call to 0x1be9, returns to 0x156B label_156B: // Incoming return from call to 0x1BE9 at 0x156A // Inputs[6] // { // @156C stack[-1] // @156C stack[-2] // @1571 stack[-4] // @1574 stack[-8] // @1575 stack[-3] // @1577 stack[-5] // } 156B 5B JUMPDEST 156C 90 SWAP1 156D 50 POP 156E 61 PUSH2 0x157c 1571 83 DUP4 1572 60 PUSH1 0x00 1574 89 DUP10 1575 85 DUP6 1576 85 DUP6 1577 89 DUP10 1578 61 PUSH2 0x1c34 157B 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @156C stack[-2] = stack[-1] // @156E stack[-1] = 0x157c // @1571 stack[0] = stack[-4] // @1572 stack[1] = 0x00 // @1574 stack[2] = stack[-8] // @1575 stack[3] = stack[-3] // @1576 stack[4] = stack[-1] // @1577 stack[5] = stack[-5] // } // Block ends with unconditional jump to 0x1c34 157C 5B JUMPDEST 157D 60 PUSH1 0x00 157F 86 DUP7 1580 81 DUP2 1581 52 MSTORE 1582 60 PUSH1 0x20 1584 81 DUP2 1585 81 DUP2 1586 52 MSTORE 1587 60 PUSH1 0x40 1589 80 DUP1 158A 83 DUP4 158B 20 SHA3 158C 60 PUSH1 0x01 158E 60 PUSH1 0x01 1590 60 PUSH1 0xa0 1592 1B SHL 1593 03 SUB 1594 8B DUP12 1595 16 AND 1596 84 DUP5 1597 52 MSTORE 1598 90 SWAP1 1599 91 SWAP2 159A 52 MSTORE 159B 81 DUP2 159C 20 SHA3 159D 80 DUP1 159E 54 SLOAD 159F 87 DUP8 15A0 92 SWAP3 15A1 90 SWAP1 15A2 61 PUSH2 0x15ac 15A5 90 SWAP1 15A6 84 DUP5 15A7 90 SWAP1 15A8 61 PUSH2 0x2eb6 15AB 56 *JUMP 15AC 5B JUMPDEST 15AD 90 SWAP1 15AE 91 SWAP2 15AF 55 SSTORE 15B0 50 POP 15B1 50 POP 15B2 60 PUSH1 0x40 15B4 80 DUP1 15B5 51 MLOAD 15B6 87 DUP8 15B7 81 DUP2 15B8 52 MSTORE 15B9 60 PUSH1 0x20 15BB 81 DUP2 15BC 01 ADD 15BD 87 DUP8 15BE 90 SWAP1 15BF 52 MSTORE 15C0 60 PUSH1 0x01 15C2 60 PUSH1 0x01 15C4 60 PUSH1 0xa0 15C6 1B SHL 15C7 03 SUB 15C8 80 DUP1 15C9 8A DUP11 15CA 16 AND 15CB 92 SWAP3 15CC 60 PUSH1 0x00 15CE 92 SWAP3 15CF 91 SWAP2 15D0 87 DUP8 15D1 16 AND 15D2 91 SWAP2 15D3 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 15F4 91 SWAP2 15F5 01 ADD 15F6 60 PUSH1 0x40 15F8 51 MLOAD 15F9 80 DUP1 15FA 91 SWAP2 15FB 03 SUB 15FC 90 SWAP1 15FD A4 LOG4 15FE 61 PUSH2 0x160c 1601 83 DUP4 1602 60 PUSH1 0x00 1604 89 DUP10 1605 89 DUP10 1606 89 DUP10 1607 89 DUP10 1608 61 PUSH2 0x1c8f 160B 56 *JUMP label_160C: // Incoming jump from 0x20F4, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x20F4, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[1] { @1614 stack[-8] } 160C 5B JUMPDEST 160D 50 POP 160E 50 POP 160F 50 POP 1610 50 POP 1611 50 POP 1612 50 POP 1613 50 POP 1614 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1615: // Incoming call from 0x085D, returns to 0x0735 // Inputs[1] { @161B storage[0x02] } 1615 5B JUMPDEST 1616 60 PUSH1 0x60 1618 60 PUSH1 0x02 161A 80 DUP1 161B 54 SLOAD 161C 61 PUSH2 0x0877 161F 90 SWAP1 1620 61 PUSH2 0x2f04 1623 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1616 stack[0] = 0x60 // @1618 stack[1] = 0x02 // @161F stack[2] = 0x0877 // @161F stack[3] = storage[0x02] // } // Block ends with call to 0x2f04, returns to 0x0877 label_1624: // Incoming call from 0x0A87, returns to 0x0A88 // Incoming call from 0x14EB, returns to 0x0A88 // Incoming call from 0x1085, returns to 0x0A88 // Inputs[3] // { // @1628 block.timestamp // @1629 block.difficulty // @162F block.number // } 1624 5B JUMPDEST 1625 60 PUSH1 0x00 1627 80 DUP1 1628 42 TIMESTAMP 1629 44 DIFFICULTY 162A 61 PUSH2 0x1634 162D 60 PUSH1 0x01 162F 43 NUMBER 1630 61 PUSH2 0x2eed 1633 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1625 stack[0] = 0x00 // @1627 stack[1] = 0x00 // @1628 stack[2] = block.timestamp // @1629 stack[3] = block.difficulty // @162A stack[4] = 0x1634 // @162D stack[5] = 0x01 // @162F stack[6] = block.number // } // Block ends with call to 0x2eed, returns to 0x1634 label_1634: // Incoming return from call to 0x2EED at 0x1633 // Inputs[10] // { // @1638 memory[0x40:0x60] // @163D stack[-3] // @1643 stack[-2] // @1644 stack[-1] // @1647 block.blockHash(stack[-1]) // @1651 stack[-6] // @165A memory[0x40:0x60] // @1668 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @166E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @166F stack[-4] // } 1634 5B JUMPDEST 1635 60 PUSH1 0x40 1637 80 DUP1 1638 51 MLOAD 1639 60 PUSH1 0x20 163B 81 DUP2 163C 01 ADD 163D 94 SWAP5 163E 90 SWAP1 163F 94 SWAP5 1640 52 MSTORE 1641 83 DUP4 1642 01 ADD 1643 91 SWAP2 1644 90 SWAP1 1645 91 SWAP2 1646 52 MSTORE 1647 40 BLOCKHASH 1648 60 PUSH1 0x60 164A 82 DUP3 164B 01 ADD 164C 52 MSTORE 164D 60 PUSH1 0x80 164F 81 DUP2 1650 01 ADD 1651 84 DUP5 1652 90 SWAP1 1653 52 MSTORE 1654 60 PUSH1 0xa0 1656 01 ADD 1657 60 PUSH1 0x40 1659 80 DUP1 165A 51 MLOAD 165B 60 PUSH1 0x1f 165D 19 NOT 165E 81 DUP2 165F 84 DUP5 1660 03 SUB 1661 01 ADD 1662 81 DUP2 1663 52 MSTORE 1664 91 SWAP2 1665 90 SWAP1 1666 52 MSTORE 1667 80 DUP1 1668 51 MLOAD 1669 60 PUSH1 0x20 166B 90 SWAP1 166C 91 SWAP2 166D 01 ADD 166E 20 SHA3 166F 90 SWAP1 1670 50 POP 1671 60 PUSH1 0xf9 1673 60 PUSH1 0xf8 1675 1B SHL 1676 81 DUP2 1677 60 PUSH1 0x00 1679 1A BYTE 167A 60 PUSH1 0xf8 167C 1B SHL 167D 60 PUSH1 0x01 167F 60 PUSH1 0x01 1681 60 PUSH1 0xf8 1683 1B SHL 1684 03 SUB 1685 19 NOT 1686 16 AND 1687 10 LT 1688 61 PUSH2 0x1694 168B 57 *JUMPI // Stack delta = -3 // Outputs[7] // { // @1640 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @1646 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-2] // @164C memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = block.blockHash(stack[-1]) // @1653 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-6] // @1663 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60] + ~0x1f // @1666 memory[0x40:0x60] = 0xa0 + memory[0x40:0x60] // @166F stack[-4] = keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with conditional jump to 0x1694, if ~((0x01 << 0xf8) - 0x01) & (byte(keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]), 0x00) << 0xf8) < 0xf9 << 0xf8 label_168C: // Incoming jump from 0x168B, if not ~((0x01 << 0xf8) - 0x01) & (byte(keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]), 0x00) << 0xf8) < 0xf9 << 0xf8 // Inputs[2] // { // @168F stack[-4] // @1690 stack[-3] // } 168C 50 POP 168D 60 PUSH1 0x02 168F 92 SWAP3 1690 91 SWAP2 1691 50 POP 1692 50 POP 1693 56 *JUMP // Stack delta = -3 // Outputs[1] { @168F stack[-4] = 0x02 } // Block ends with unconditional jump to stack[-4] label_1694: // Incoming jump from 0x168B, if ~((0x01 << 0xf8) - 0x01) & (byte(keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]), 0x00) << 0xf8) < 0xf9 << 0xf8 // Inputs[2] // { // @1698 stack[-4] // @1699 stack[-3] // } 1694 5B JUMPDEST 1695 50 POP 1696 60 PUSH1 0x01 1698 92 SWAP3 1699 91 SWAP2 169A 50 POP 169B 50 POP 169C 56 *JUMP // Stack delta = -3 // Outputs[1] { @1698 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_169D: // Incoming jump from 0x2F23, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2F23, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @169F stack[-4] // @169F stack[-2] // @16A0 stack[-3] // } 169D 5B JUMPDEST 169E 50 POP 169F 91 SWAP2 16A0 90 SWAP1 16A1 50 POP 16A2 56 *JUMP // Stack delta = -3 // Outputs[1] { @169F stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] 16A3 5B JUMPDEST 16A4 81 DUP2 16A5 51 MLOAD 16A6 83 DUP4 16A7 51 MLOAD 16A8 14 EQ 16A9 61 PUSH2 0x1705 16AC 57 *JUMPI 16AD 60 PUSH1 0x40 16AF 51 MLOAD 16B0 62 PUSH3 0x461bcd 16B4 60 PUSH1 0xe5 16B6 1B SHL 16B7 81 DUP2 16B8 52 MSTORE 16B9 60 PUSH1 0x20 16BB 60 PUSH1 0x04 16BD 82 DUP3 16BE 01 ADD 16BF 52 MSTORE 16C0 60 PUSH1 0x28 16C2 60 PUSH1 0x24 16C4 82 DUP3 16C5 01 ADD 16C6 52 MSTORE 16C7 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 16E8 60 PUSH1 0x44 16EA 82 DUP3 16EB 01 ADD 16EC 52 MSTORE 16ED 67 PUSH8 0x0dad2e6dac2e8c6d 16F6 60 PUSH1 0xc3 16F8 1B SHL 16F9 60 PUSH1 0x64 16FB 82 DUP3 16FC 01 ADD 16FD 52 MSTORE 16FE 60 PUSH1 0x84 1700 01 ADD 1701 61 PUSH2 0x054a 1704 56 *JUMP 1705 5B JUMPDEST 1706 60 PUSH1 0x01 1708 60 PUSH1 0x01 170A 60 PUSH1 0xa0 170C 1B SHL 170D 03 SUB 170E 84 DUP5 170F 16 AND 1710 61 PUSH2 0x172b 1713 57 *JUMPI 1714 60 PUSH1 0x40 1716 51 MLOAD 1717 62 PUSH3 0x461bcd 171B 60 PUSH1 0xe5 171D 1B SHL 171E 81 DUP2 171F 52 MSTORE 1720 60 PUSH1 0x04 1722 01 ADD 1723 61 PUSH2 0x054a 1726 90 SWAP1 1727 61 PUSH2 0x2dcf 172A 56 *JUMP 172B 5B JUMPDEST 172C 33 CALLER 172D 61 PUSH2 0x173a 1730 81 DUP2 1731 87 DUP8 1732 87 DUP8 1733 87 DUP8 1734 87 DUP8 1735 87 DUP8 1736 61 PUSH2 0x1c34 1739 56 *JUMP 173A 5B JUMPDEST 173B 60 PUSH1 0x00 173D 5B JUMPDEST 173E 84 DUP5 173F 51 MLOAD 1740 81 DUP2 1741 10 LT 1742 15 ISZERO 1743 61 PUSH2 0x1820 1746 57 *JUMPI 1747 60 PUSH1 0x00 1749 85 DUP6 174A 82 DUP3 174B 81 DUP2 174C 51 MLOAD 174D 81 DUP2 174E 10 LT 174F 61 PUSH2 0x175a 1752 57 *JUMPI 1753 61 PUSH2 0x175a 1756 61 PUSH2 0x2fac 1759 56 *JUMP 175A 5B JUMPDEST 175B 60 PUSH1 0x20 175D 02 MUL 175E 60 PUSH1 0x20 1760 01 ADD 1761 01 ADD 1762 51 MLOAD 1763 90 SWAP1 1764 50 POP 1765 60 PUSH1 0x00 1767 85 DUP6 1768 83 DUP4 1769 81 DUP2 176A 51 MLOAD 176B 81 DUP2 176C 10 LT 176D 61 PUSH2 0x1778 1770 57 *JUMPI 1771 61 PUSH2 0x1778 1774 61 PUSH2 0x2fac 1777 56 *JUMP 1778 5B JUMPDEST 1779 60 PUSH1 0x20 177B 90 SWAP1 177C 81 DUP2 177D 02 MUL 177E 91 SWAP2 177F 90 SWAP1 1780 91 SWAP2 1781 01 ADD 1782 81 DUP2 1783 01 ADD 1784 51 MLOAD 1785 60 PUSH1 0x00 1787 84 DUP5 1788 81 DUP2 1789 52 MSTORE 178A 80 DUP1 178B 83 DUP4 178C 52 MSTORE 178D 60 PUSH1 0x40 178F 80 DUP1 1790 82 DUP3 1791 20 SHA3 1792 60 PUSH1 0x01 1794 60 PUSH1 0x01 1796 60 PUSH1 0xa0 1798 1B SHL 1799 03 SUB 179A 8E DUP15 179B 16 AND 179C 83 DUP4 179D 52 MSTORE 179E 90 SWAP1 179F 93 SWAP4 17A0 52 MSTORE 17A1 91 SWAP2 17A2 90 SWAP1 17A3 91 SWAP2 17A4 20 SHA3 17A5 54 SLOAD 17A6 90 SWAP1 17A7 91 SWAP2 17A8 50 POP 17A9 81 DUP2 17AA 81 DUP2 17AB 10 LT 17AC 15 ISZERO 17AD 61 PUSH2 0x17c8 17B0 57 *JUMPI 17B1 60 PUSH1 0x40 17B3 51 MLOAD 17B4 62 PUSH3 0x461bcd 17B8 60 PUSH1 0xe5 17BA 1B SHL 17BB 81 DUP2 17BC 52 MSTORE 17BD 60 PUSH1 0x04 17BF 01 ADD 17C0 61 PUSH2 0x054a 17C3 90 SWAP1 17C4 61 PUSH2 0x2e14 17C7 56 *JUMP 17C8 5B JUMPDEST 17C9 60 PUSH1 0x00 17CB 83 DUP4 17CC 81 DUP2 17CD 52 MSTORE 17CE 60 PUSH1 0x20 17D0 81 DUP2 17D1 81 DUP2 17D2 52 MSTORE 17D3 60 PUSH1 0x40 17D5 80 DUP1 17D6 83 DUP4 17D7 20 SHA3 17D8 60 PUSH1 0x01 17DA 60 PUSH1 0x01 17DC 60 PUSH1 0xa0 17DE 1B SHL 17DF 03 SUB 17E0 8E DUP15 17E1 81 DUP2 17E2 16 AND 17E3 85 DUP6 17E4 52 MSTORE 17E5 92 SWAP3 17E6 52 MSTORE 17E7 80 DUP1 17E8 83 DUP4 17E9 20 SHA3 17EA 85 DUP6 17EB 85 DUP6 17EC 03 SUB 17ED 90 SWAP1 17EE 55 SSTORE 17EF 90 SWAP1 17F0 8B DUP12 17F1 16 AND 17F2 82 DUP3 17F3 52 MSTORE 17F4 81 DUP2 17F5 20 SHA3 17F6 80 DUP1 17F7 54 SLOAD 17F8 84 DUP5 17F9 92 SWAP3 17FA 90 SWAP1 17FB 61 PUSH2 0x1805 17FE 90 SWAP1 17FF 84 DUP5 1800 90 SWAP1 1801 61 PUSH2 0x2eb6 1804 56 *JUMP 1805 5B JUMPDEST 1806 92 SWAP3 1807 50 POP 1808 50 POP 1809 81 DUP2 180A 90 SWAP1 180B 55 SSTORE 180C 50 POP 180D 50 POP 180E 50 POP 180F 50 POP 1810 80 DUP1 1811 61 PUSH2 0x1819 1814 90 SWAP1 1815 61 PUSH2 0x2f65 1818 56 *JUMP 1819 5B JUMPDEST 181A 90 SWAP1 181B 50 POP 181C 61 PUSH2 0x173d 181F 56 *JUMP 1820 5B JUMPDEST 1821 50 POP 1822 84 DUP5 1823 60 PUSH1 0x01 1825 60 PUSH1 0x01 1827 60 PUSH1 0xa0 1829 1B SHL 182A 03 SUB 182B 16 AND 182C 86 DUP7 182D 60 PUSH1 0x01 182F 60 PUSH1 0x01 1831 60 PUSH1 0xa0 1833 1B SHL 1834 03 SUB 1835 16 AND 1836 82 DUP3 1837 60 PUSH1 0x01 1839 60 PUSH1 0x01 183B 60 PUSH1 0xa0 183D 1B SHL 183E 03 SUB 183F 16 AND 1840 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1861 87 DUP8 1862 87 DUP8 1863 60 PUSH1 0x40 1865 51 MLOAD 1866 61 PUSH2 0x1870 1869 92 SWAP3 186A 91 SWAP2 186B 90 SWAP1 186C 61 PUSH2 0x2d01 186F 56 *JUMP 1870 5B JUMPDEST 1871 60 PUSH1 0x40 1873 51 MLOAD 1874 80 DUP1 1875 91 SWAP2 1876 03 SUB 1877 90 SWAP1 1878 A4 LOG4 1879 61 PUSH2 0x1886 187C 81 DUP2 187D 87 DUP8 187E 87 DUP8 187F 87 DUP8 1880 87 DUP8 1881 87 DUP8 1882 61 PUSH2 0x1dfa 1885 56 *JUMP label_1886: // Incoming return from call to 0x2053 at 0x1C8E // Incoming jump from 0x20E8, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @188D stack[-7] } 1886 5B JUMPDEST 1887 50 POP 1888 50 POP 1889 50 POP 188A 50 POP 188B 50 POP 188C 50 POP 188D 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_188E: // Incoming call from 0x0C1F, returns to 0x0C20 // Inputs[1] { @1891 storage[0x04] } 188E 5B JUMPDEST 188F 60 PUSH1 0x04 1891 54 SLOAD 1892 60 PUSH1 0x01 1894 60 PUSH1 0xa0 1896 1B SHL 1897 90 SWAP1 1898 04 DIV 1899 60 PUSH1 0xff 189B 16 AND 189C 61 PUSH2 0x18de 189F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18de, if 0xff & storage[0x04] / (0x01 << 0xa0) label_18A0: // Incoming jump from 0x189F, if not 0xff & storage[0x04] / (0x01 << 0xa0) // Inputs[1] { @18A2 memory[0x40:0x60] } 18A0 60 PUSH1 0x40 18A2 51 MLOAD 18A3 62 PUSH3 0x461bcd 18A7 60 PUSH1 0xe5 18A9 1B SHL 18AA 81 DUP2 18AB 52 MSTORE 18AC 60 PUSH1 0x20 18AE 60 PUSH1 0x04 18B0 82 DUP3 18B1 01 ADD 18B2 52 MSTORE 18B3 60 PUSH1 0x14 18B5 60 PUSH1 0x24 18B7 82 DUP3 18B8 01 ADD 18B9 52 MSTORE 18BA 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 18CF 60 PUSH1 0x62 18D1 1B SHL 18D2 60 PUSH1 0x44 18D4 82 DUP3 18D5 01 ADD 18D6 52 MSTORE 18D7 60 PUSH1 0x64 18D9 01 ADD 18DA 61 PUSH2 0x054a 18DD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @18AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @18B2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @18D6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @18D9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_18DE: // Incoming jump from 0x189F, if 0xff & storage[0x04] / (0x01 << 0xa0) // Inputs[2] // { // @18E2 storage[0x04] // @190D msg.sender // } 18DE 5B JUMPDEST 18DF 60 PUSH1 0x04 18E1 80 DUP1 18E2 54 SLOAD 18E3 60 PUSH1 0xff 18E5 60 PUSH1 0xa0 18E7 1B SHL 18E8 19 NOT 18E9 16 AND 18EA 90 SWAP1 18EB 55 SSTORE 18EC 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 190D 33 CALLER // Stack delta = +2 // Outputs[3] // { // @18EB storage[0x04] = ~(0xff << 0xa0) & storage[0x04] // @18EC stack[0] = 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa // @190D stack[1] = msg.sender // } // Block continues label_190E: // Incoming jump from 0x190D // Incoming jump from 0x1A04 // Inputs[6] // { // @1911 memory[0x40:0x60] // @191B stack[-1] // @1924 memory[0x40:0x60] // @1929 stack[-2] // @1929 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @192A stack[-3] // } 190E 5B JUMPDEST 190F 60 PUSH1 0x40 1911 51 MLOAD 1912 60 PUSH1 0x01 1914 60 PUSH1 0x01 1916 60 PUSH1 0xa0 1918 1B SHL 1919 03 SUB 191A 90 SWAP1 191B 91 SWAP2 191C 16 AND 191D 81 DUP2 191E 52 MSTORE 191F 60 PUSH1 0x20 1921 01 ADD 1922 60 PUSH1 0x40 1924 51 MLOAD 1925 80 DUP1 1926 91 SWAP2 1927 03 SUB 1928 90 SWAP1 1929 A1 LOG1 192A 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @191E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1929 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // } // Block ends with unconditional jump to stack[-3] label_192B: // Incoming call from 0x0F4C, returns to 0x0C20 // Incoming call from 0x128F, returns to 0x0ABE // Inputs[5] // { // @192F storage[0x04] // @1938 stack[-1] // @194D memory[0x40:0x60] // @1979 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @197C stack[-2] // } 192B 5B JUMPDEST 192C 60 PUSH1 0x04 192E 80 DUP1 192F 54 SLOAD 1930 60 PUSH1 0x01 1932 60 PUSH1 0x01 1934 60 PUSH1 0xa0 1936 1B SHL 1937 03 SUB 1938 83 DUP4 1939 81 DUP2 193A 16 AND 193B 60 PUSH1 0x01 193D 60 PUSH1 0x01 193F 60 PUSH1 0xa0 1941 1B SHL 1942 03 SUB 1943 19 NOT 1944 83 DUP4 1945 16 AND 1946 81 DUP2 1947 17 OR 1948 90 SWAP1 1949 93 SWAP4 194A 55 SSTORE 194B 60 PUSH1 0x40 194D 51 MLOAD 194E 91 SWAP2 194F 16 AND 1950 91 SWAP2 1951 90 SWAP1 1952 82 DUP3 1953 90 SWAP1 1954 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1975 90 SWAP1 1976 60 PUSH1 0x00 1978 90 SWAP1 1979 A3 LOG3 197A 50 POP 197B 50 POP 197C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @194A storage[0x04] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x04] & ~((0x01 << 0xa0) - 0x01)) // @1979 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x04] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_197D: // Incoming call from 0x0F7E, returns to 0x0C20 // Inputs[1] { @1980 storage[0x04] } 197D 5B JUMPDEST 197E 60 PUSH1 0x04 1980 54 SLOAD 1981 60 PUSH1 0x01 1983 60 PUSH1 0xa0 1985 1B SHL 1986 90 SWAP1 1987 04 DIV 1988 60 PUSH1 0xff 198A 16 AND 198B 15 ISZERO 198C 61 PUSH2 0x19ca 198F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19ca, if !(0xff & storage[0x04] / (0x01 << 0xa0)) label_1990: // Incoming jump from 0x198F, if not !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[1] { @1992 memory[0x40:0x60] } 1990 60 PUSH1 0x40 1992 51 MLOAD 1993 62 PUSH3 0x461bcd 1997 60 PUSH1 0xe5 1999 1B SHL 199A 81 DUP2 199B 52 MSTORE 199C 60 PUSH1 0x20 199E 60 PUSH1 0x04 19A0 82 DUP3 19A1 01 ADD 19A2 52 MSTORE 19A3 60 PUSH1 0x10 19A5 60 PUSH1 0x24 19A7 82 DUP3 19A8 01 ADD 19A9 52 MSTORE 19AA 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 19BB 60 PUSH1 0x82 19BD 1B SHL 19BE 60 PUSH1 0x44 19C0 82 DUP3 19C1 01 ADD 19C2 52 MSTORE 19C3 60 PUSH1 0x64 19C5 01 ADD 19C6 61 PUSH2 0x054a 19C9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @199B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19A2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19A9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @19C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @19C5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_19CA: // Incoming jump from 0x198F, if !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[2] // { // @19CE storage[0x04] // @1A02 msg.sender // } 19CA 5B JUMPDEST 19CB 60 PUSH1 0x04 19CD 80 DUP1 19CE 54 SLOAD 19CF 60 PUSH1 0xff 19D1 60 PUSH1 0xa0 19D3 1B SHL 19D4 19 NOT 19D5 16 AND 19D6 60 PUSH1 0x01 19D8 60 PUSH1 0xa0 19DA 1B SHL 19DB 17 OR 19DC 90 SWAP1 19DD 55 SSTORE 19DE 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 19FF 61 PUSH2 0x190e 1A02 33 CALLER 1A03 90 SWAP1 1A04 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19DD storage[0x04] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x04]) // @19DE stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @1A03 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x190e label_1A05: // Incoming call from 0x1152, returns to 0x1153 // Inputs[2] // { // @1A06 stack[-2] // @1A10 stack[-3] // } 1A05 5B JUMPDEST 1A06 81 DUP2 1A07 60 PUSH1 0x01 1A09 60 PUSH1 0x01 1A0B 60 PUSH1 0xa0 1A0D 1B SHL 1A0E 03 SUB 1A0F 16 AND 1A10 83 DUP4 1A11 60 PUSH1 0x01 1A13 60 PUSH1 0x01 1A15 60 PUSH1 0xa0 1A17 1B SHL 1A18 03 SUB 1A19 16 AND 1A1A 14 EQ 1A1B 15 ISZERO 1A1C 61 PUSH2 0x1a79 1A1F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a79, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) label_1A20: // Incoming jump from 0x1A1F, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[1] { @1A22 memory[0x40:0x60] } 1A20 60 PUSH1 0x40 1A22 51 MLOAD 1A23 62 PUSH3 0x461bcd 1A27 60 PUSH1 0xe5 1A29 1B SHL 1A2A 81 DUP2 1A2B 52 MSTORE 1A2C 60 PUSH1 0x20 1A2E 60 PUSH1 0x04 1A30 82 DUP3 1A31 01 ADD 1A32 52 MSTORE 1A33 60 PUSH1 0x29 1A35 60 PUSH1 0x24 1A37 82 DUP3 1A38 01 ADD 1A39 52 MSTORE 1A3A 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 1A5B 60 PUSH1 0x44 1A5D 82 DUP3 1A5E 01 ADD 1A5F 52 MSTORE 1A60 68 PUSH9 0x103337b91039b2b633 1A6A 60 PUSH1 0xb9 1A6C 1B SHL 1A6D 60 PUSH1 0x64 1A6F 82 DUP3 1A70 01 ADD 1A71 52 MSTORE 1A72 60 PUSH1 0x84 1A74 01 ADD 1A75 61 PUSH2 0x054a 1A78 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1A2B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A32 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A39 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @1A5F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @1A71 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103337b91039b2b633 << 0xb9 // @1A74 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1A79: // Incoming jump from 0x1A1F, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[10] // { // @1A82 stack[-3] // @1A95 memory[0x00:0x40] // @1A97 stack[-2] // @1AA2 memory[0x00:0x40] // @1AA4 storage[keccak256(memory[0x00:0x40])] // @1AA9 stack[-1] // @1AB3 memory[0x40:0x60] // @1ADC memory[0x40:0x60] // @1AE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]] // @1AE5 stack[-4] // } 1A79 5B JUMPDEST 1A7A 60 PUSH1 0x01 1A7C 60 PUSH1 0x01 1A7E 60 PUSH1 0xa0 1A80 1B SHL 1A81 03 SUB 1A82 83 DUP4 1A83 81 DUP2 1A84 16 AND 1A85 60 PUSH1 0x00 1A87 81 DUP2 1A88 81 DUP2 1A89 52 MSTORE 1A8A 60 PUSH1 0x01 1A8C 60 PUSH1 0x20 1A8E 90 SWAP1 1A8F 81 DUP2 1A90 52 MSTORE 1A91 60 PUSH1 0x40 1A93 80 DUP1 1A94 83 DUP4 1A95 20 SHA3 1A96 94 SWAP5 1A97 87 DUP8 1A98 16 AND 1A99 80 DUP1 1A9A 84 DUP5 1A9B 52 MSTORE 1A9C 94 SWAP5 1A9D 82 DUP3 1A9E 52 MSTORE 1A9F 91 SWAP2 1AA0 82 DUP3 1AA1 90 SWAP1 1AA2 20 SHA3 1AA3 80 DUP1 1AA4 54 SLOAD 1AA5 60 PUSH1 0xff 1AA7 19 NOT 1AA8 16 AND 1AA9 86 DUP7 1AAA 15 ISZERO 1AAB 15 ISZERO 1AAC 90 SWAP1 1AAD 81 DUP2 1AAE 17 OR 1AAF 90 SWAP1 1AB0 91 SWAP2 1AB1 55 SSTORE 1AB2 91 SWAP2 1AB3 51 MLOAD 1AB4 91 SWAP2 1AB5 82 DUP3 1AB6 52 MSTORE 1AB7 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1AD8 91 SWAP2 1AD9 01 ADD 1ADA 60 PUSH1 0x40 1ADC 51 MLOAD 1ADD 80 DUP1 1ADE 91 SWAP2 1ADF 03 SUB 1AE0 90 SWAP1 1AE1 A3 LOG3 1AE2 50 POP 1AE3 50 POP 1AE4 50 POP 1AE5 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1A89 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1A90 memory[0x20:0x40] = 0x01 // @1A9B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1A9E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1AB1 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1AB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1AE1 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] label_1AE6: // Incoming jump from 0x1189 // Inputs[2] // { // @1AE7 stack[-1] // @1AE8 memory[stack[-1]:stack[-1] + 0x20] // } 1AE6 5B JUMPDEST 1AE7 80 DUP1 1AE8 51 MLOAD 1AE9 61 PUSH2 0x1153 1AEC 90 SWAP1 1AED 60 PUSH1 0x02 1AEF 90 SWAP1 1AF0 60 PUSH1 0x20 1AF2 84 DUP5 1AF3 01 ADD 1AF4 90 SWAP1 1AF5 61 PUSH2 0x251d 1AF8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AEC stack[0] = 0x1153 // @1AEF stack[1] = 0x02 // @1AF4 stack[2] = stack[-1] + 0x20 // @1AF4 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x251d label_1AF9: // Incoming jump from 0x11F7 // Inputs[2] // { // @1B02 stack[-5] // @1B04 msg.sender // } 1AF9 5B JUMPDEST 1AFA 60 PUSH1 0x01 1AFC 60 PUSH1 0x01 1AFE 60 PUSH1 0xa0 1B00 1B SHL 1B01 03 SUB 1B02 85 DUP6 1B03 16 AND 1B04 33 CALLER 1B05 14 EQ 1B06 80 DUP1 1B07 61 PUSH2 0x1b15 1B0A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B05 stack[0] = msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x1b15, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 label_1B0B: // Incoming jump from 0x1B0A, if not msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1B0F stack[-6] // @1B10 msg.sender // } 1B0B 50 POP 1B0C 61 PUSH2 0x1b15 1B0F 85 DUP6 1B10 33 CALLER 1B11 61 PUSH2 0x04b9 1B14 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B0C stack[-1] = 0x1b15 // @1B0F stack[0] = stack[-6] // @1B10 stack[1] = msg.sender // } // Block ends with call to 0x04b9, returns to 0x1B15 label_1B15: // Incoming jump from 0x1B0A, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x04B9 at 0x1B14 // Inputs[1] { @1B19 stack[-1] } 1B15 5B JUMPDEST 1B16 61 PUSH2 0x1b73 1B19 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b73, if stack[-1] label_1B1A: // Incoming jump from 0x1B19, if not stack[-1] // Inputs[1] { @1B1C memory[0x40:0x60] } 1B1A 60 PUSH1 0x40 1B1C 51 MLOAD 1B1D 62 PUSH3 0x461bcd 1B21 60 PUSH1 0xe5 1B23 1B SHL 1B24 81 DUP2 1B25 52 MSTORE 1B26 60 PUSH1 0x20 1B28 60 PUSH1 0x04 1B2A 82 DUP3 1B2B 01 ADD 1B2C 52 MSTORE 1B2D 60 PUSH1 0x29 1B2F 60 PUSH1 0x24 1B31 82 DUP3 1B32 01 ADD 1B33 52 MSTORE 1B34 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 1B55 60 PUSH1 0x44 1B57 82 DUP3 1B58 01 ADD 1B59 52 MSTORE 1B5A 68 PUSH9 0x08185c1c1c9bdd9959 1B64 60 PUSH1 0xba 1B66 1B SHL 1B67 60 PUSH1 0x64 1B69 82 DUP3 1B6A 01 ADD 1B6B 52 MSTORE 1B6C 60 PUSH1 0x84 1B6E 01 ADD 1B6F 61 PUSH2 0x054a 1B72 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1B25 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B2C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B33 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @1B59 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 // @1B6B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x08185c1c1c9bdd9959 << 0xba // @1B6E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1B73: // Incoming jump from 0x1B19, if stack[-1] // Inputs[5] // { // @1B77 stack[-5] // @1B78 stack[-4] // @1B79 stack[-3] // @1B7A stack[-2] // @1B7B stack[-1] // } 1B73 5B JUMPDEST 1B74 61 PUSH2 0x0b51 1B77 85 DUP6 1B78 85 DUP6 1B79 85 DUP6 1B7A 85 DUP6 1B7B 85 DUP6 1B7C 61 PUSH2 0x1ec4 1B7F 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1B74 stack[0] = 0x0b51 // @1B77 stack[1] = stack[-5] // @1B78 stack[2] = stack[-4] // @1B79 stack[3] = stack[-3] // @1B7A stack[4] = stack[-2] // @1B7B stack[5] = stack[-1] // } // Block ends with unconditional jump to 0x1ec4 label_1B80: // Incoming call from 0x13F5, returns to 0x13F6 // Inputs[6] // { // @1B84 memory[0x40:0x60] // @1B8D stack[-1] // @1B9B memory[0x40:0x60] // @1BA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1BAE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1BB1 stack[-2] // } 1B80 5B JUMPDEST 1B81 60 PUSH1 0x40 1B83 80 DUP1 1B84 51 MLOAD 1B85 60 PUSH1 0x01 1B87 60 PUSH1 0x01 1B89 60 PUSH1 0xa0 1B8B 1B SHL 1B8C 03 SUB 1B8D 83 DUP4 1B8E 16 AND 1B8F 60 PUSH1 0x20 1B91 82 DUP3 1B92 01 ADD 1B93 52 MSTORE 1B94 60 PUSH1 0x00 1B96 91 SWAP2 1B97 01 ADD 1B98 5B JUMPDEST 1B99 60 PUSH1 0x40 1B9B 51 MLOAD 1B9C 60 PUSH1 0x20 1B9E 81 DUP2 1B9F 83 DUP4 1BA0 03 SUB 1BA1 03 SUB 1BA2 81 DUP2 1BA3 52 MSTORE 1BA4 90 SWAP1 1BA5 60 PUSH1 0x40 1BA7 52 MSTORE 1BA8 80 DUP1 1BA9 51 MLOAD 1BAA 90 SWAP1 1BAB 60 PUSH1 0x20 1BAD 01 ADD 1BAE 20 SHA3 1BAF 90 SWAP1 1BB0 50 POP 1BB1 91 SWAP2 1BB2 90 SWAP1 1BB3 50 POP 1BB4 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1B93 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1BA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x40 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1BA7 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1BB1 stack[-2] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to stack[-2] label_1BB5: // Incoming call from 0x1474, returns to 0x1475 // Inputs[2] // { // @1BBB stack[-1] // @1BBF stack[-2] // } 1BB5 5B JUMPDEST 1BB6 60 PUSH1 0x00 1BB8 61 PUSH2 0x1bca 1BBB 82 DUP3 1BBC 61 PUSH2 0x1bc4 1BBF 85 DUP6 1BC0 61 PUSH2 0x1ffc 1BC3 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1BB6 stack[0] = 0x00 // @1BB8 stack[1] = 0x1bca // @1BBB stack[2] = stack[-1] // @1BBC stack[3] = 0x1bc4 // @1BBF stack[4] = stack[-2] // } // Block ends with call to 0x1ffc, returns to 0x1BC4 label_1BC4: // Incoming return from call to 0x1FFC at 0x1BC3 // Inputs[2] // { // @1BC5 stack[-1] // @1BC5 stack[-2] // } 1BC4 5B JUMPDEST 1BC5 90 SWAP1 1BC6 61 PUSH2 0x2037 1BC9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1BC5 stack[-1] = stack[-2] // @1BC5 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x2037 label_1BCA: // Incoming return from call to 0x1BC4 at 0x1BC3 // Inputs[5] // { // @1BCD storage[0x07] // @1BDF stack[-1] // @1BE2 stack[-2] // @1BE4 stack[-5] // @1BE5 stack[-4] // } 1BCA 5B JUMPDEST 1BCB 60 PUSH1 0x07 1BCD 54 SLOAD 1BCE 62 PUSH3 0x010000 1BD2 90 SWAP1 1BD3 04 DIV 1BD4 60 PUSH1 0x01 1BD6 60 PUSH1 0x01 1BD8 60 PUSH1 0xa0 1BDA 1B SHL 1BDB 03 SUB 1BDC 90 SWAP1 1BDD 81 DUP2 1BDE 16 AND 1BDF 91 SWAP2 1BE0 16 AND 1BE1 14 EQ 1BE2 90 SWAP1 1BE3 50 POP 1BE4 92 SWAP3 1BE5 91 SWAP2 1BE6 50 POP 1BE7 50 POP 1BE8 56 *JUMP // Stack delta = -4 // Outputs[1] { @1BE4 stack[-5] = stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x07] / 0x010000 } // Block ends with unconditional jump to stack[-5] label_1BE9: // Incoming call from 0x155D, returns to 0x155E // Incoming call from 0x1F02, returns to 0x1F03 // Incoming call from 0x156A, returns to 0x156B // Incoming call from 0x1EF5, returns to 0x1EF6 // Inputs[5] // { // @1BED memory[0x40:0x60] // @1C07 msg.data.length // @1C09 msg.data[msg.data.length:msg.data.length + 0x20] // @1C10 stack[-1] // @1C15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1BE9 5B JUMPDEST 1BEA 60 PUSH1 0x40 1BEC 80 DUP1 1BED 51 MLOAD 1BEE 60 PUSH1 0x01 1BF0 80 DUP1 1BF1 82 DUP3 1BF2 52 MSTORE 1BF3 81 DUP2 1BF4 83 DUP4 1BF5 01 ADD 1BF6 90 SWAP1 1BF7 92 SWAP3 1BF8 52 MSTORE 1BF9 60 PUSH1 0x60 1BFB 91 SWAP2 1BFC 60 PUSH1 0x00 1BFE 91 SWAP2 1BFF 90 SWAP1 1C00 60 PUSH1 0x20 1C02 80 DUP1 1C03 83 DUP4 1C04 01 ADD 1C05 90 SWAP1 1C06 80 DUP1 1C07 36 CALLDATASIZE 1C08 83 DUP4 1C09 37 CALLDATACOPY 1C0A 01 ADD 1C0B 90 SWAP1 1C0C 50 POP 1C0D 50 POP 1C0E 90 SWAP1 1C0F 50 POP 1C10 82 DUP3 1C11 81 DUP2 1C12 60 PUSH1 0x00 1C14 81 DUP2 1C15 51 MLOAD 1C16 81 DUP2 1C17 10 LT 1C18 61 PUSH2 0x1c23 1C1B 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @1BF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1BF8 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1BFB stack[0] = 0x60 // @1C09 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @1C0E stack[1] = memory[0x40:0x60] // @1C10 stack[2] = stack[-1] // @1C11 stack[3] = memory[0x40:0x60] // @1C12 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1c23, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_1C1C: // Incoming jump from 0x1C1B, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 1C1C 61 PUSH2 0x1c23 1C1F 61 PUSH2 0x2fac 1C22 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C1C stack[0] = 0x1c23 } // Block ends with unconditional jump to 0x2fac label_1C23: // Incoming jump from 0x1C1B, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @1C26 stack[-1] // @1C29 stack[-2] // @1C2E stack[-3] // @1C2F stack[-4] // @1C2F stack[-7] // @1C30 stack[-6] // } 1C23 5B JUMPDEST 1C24 60 PUSH1 0x20 1C26 90 SWAP1 1C27 81 DUP2 1C28 02 MUL 1C29 91 SWAP2 1C2A 90 SWAP1 1C2B 91 SWAP2 1C2C 01 ADD 1C2D 01 ADD 1C2E 52 MSTORE 1C2F 92 SWAP3 1C30 91 SWAP2 1C31 50 POP 1C32 50 POP 1C33 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1C2E memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @1C2F stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1C34: // Incoming jump from 0x157B // Incoming jump from 0x1F12 // Inputs[1] { @1C37 storage[0x04] } 1C34 5B JUMPDEST 1C35 60 PUSH1 0x04 1C37 54 SLOAD 1C38 60 PUSH1 0x01 1C3A 60 PUSH1 0xa0 1C3C 1B SHL 1C3D 90 SWAP1 1C3E 04 DIV 1C3F 60 PUSH1 0xff 1C41 16 AND 1C42 15 ISZERO 1C43 61 PUSH2 0x1c81 1C46 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c81, if !(0xff & storage[0x04] / (0x01 << 0xa0)) label_1C47: // Incoming jump from 0x1C46, if not !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[1] { @1C49 memory[0x40:0x60] } 1C47 60 PUSH1 0x40 1C49 51 MLOAD 1C4A 62 PUSH3 0x461bcd 1C4E 60 PUSH1 0xe5 1C50 1B SHL 1C51 81 DUP2 1C52 52 MSTORE 1C53 60 PUSH1 0x20 1C55 60 PUSH1 0x04 1C57 82 DUP3 1C58 01 ADD 1C59 52 MSTORE 1C5A 60 PUSH1 0x10 1C5C 60 PUSH1 0x24 1C5E 82 DUP3 1C5F 01 ADD 1C60 52 MSTORE 1C61 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 1C72 60 PUSH1 0x82 1C74 1B SHL 1C75 60 PUSH1 0x44 1C77 82 DUP3 1C78 01 ADD 1C79 52 MSTORE 1C7A 60 PUSH1 0x64 1C7C 01 ADD 1C7D 61 PUSH2 0x054a 1C80 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1C52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1C59 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C60 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1C79 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @1C7C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_1C81: // Incoming jump from 0x1C46, if !(0xff & storage[0x04] / (0x01 << 0xa0)) // Inputs[6] // { // @1C85 stack[-6] // @1C86 stack[-5] // @1C87 stack[-4] // @1C88 stack[-3] // @1C89 stack[-2] // @1C8A stack[-1] // } 1C81 5B JUMPDEST 1C82 61 PUSH2 0x1886 1C85 86 DUP7 1C86 86 DUP7 1C87 86 DUP7 1C88 86 DUP7 1C89 86 DUP7 1C8A 86 DUP7 1C8B 61 PUSH2 0x2053 1C8E 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1C82 stack[0] = 0x1886 // @1C85 stack[1] = stack[-6] // @1C86 stack[2] = stack[-5] // @1C87 stack[3] = stack[-4] // @1C88 stack[4] = stack[-3] // @1C89 stack[5] = stack[-2] // @1C8A stack[6] = stack[-1] // } // Block ends with call to 0x2053, returns to 0x1886 1C8F 5B JUMPDEST 1C90 60 PUSH1 0x01 1C92 60 PUSH1 0x01 1C94 60 PUSH1 0xa0 1C96 1B SHL 1C97 03 SUB 1C98 84 DUP5 1C99 16 AND 1C9A 3B EXTCODESIZE 1C9B 15 ISZERO 1C9C 61 PUSH2 0x1886 1C9F 57 *JUMPI 1CA0 60 PUSH1 0x40 1CA2 51 MLOAD 1CA3 63 PUSH4 0xf23a6e61 1CA8 60 PUSH1 0xe0 1CAA 1B SHL 1CAB 81 DUP2 1CAC 52 MSTORE 1CAD 60 PUSH1 0x01 1CAF 60 PUSH1 0x01 1CB1 60 PUSH1 0xa0 1CB3 1B SHL 1CB4 03 SUB 1CB5 85 DUP6 1CB6 16 AND 1CB7 90 SWAP1 1CB8 63 PUSH4 0xf23a6e61 1CBD 90 SWAP1 1CBE 61 PUSH2 0x1cd3 1CC1 90 SWAP1 1CC2 89 DUP10 1CC3 90 SWAP1 1CC4 89 DUP10 1CC5 90 SWAP1 1CC6 88 DUP9 1CC7 90 SWAP1 1CC8 88 DUP9 1CC9 90 SWAP1 1CCA 88 DUP9 1CCB 90 SWAP1 1CCC 60 PUSH1 0x04 1CCE 01 ADD 1CCF 61 PUSH2 0x2ca9 1CD2 56 *JUMP 1CD3 5B JUMPDEST 1CD4 60 PUSH1 0x20 1CD6 60 PUSH1 0x40 1CD8 51 MLOAD 1CD9 80 DUP1 1CDA 83 DUP4 1CDB 03 SUB 1CDC 81 DUP2 1CDD 60 PUSH1 0x00 1CDF 87 DUP8 1CE0 80 DUP1 1CE1 3B EXTCODESIZE 1CE2 15 ISZERO 1CE3 80 DUP1 1CE4 15 ISZERO 1CE5 61 PUSH2 0x1ced 1CE8 57 *JUMPI 1CE9 60 PUSH1 0x00 1CEB 80 DUP1 1CEC FD *REVERT 1CED 5B JUMPDEST 1CEE 50 POP 1CEF 5A GAS 1CF0 F1 CALL 1CF1 92 SWAP3 1CF2 50 POP 1CF3 50 POP 1CF4 50 POP 1CF5 80 DUP1 1CF6 15 ISZERO 1CF7 61 PUSH2 0x1d1d 1CFA 57 *JUMPI 1CFB 50 POP 1CFC 60 PUSH1 0x40 1CFE 80 DUP1 1CFF 51 MLOAD 1D00 60 PUSH1 0x1f 1D02 3D RETURNDATASIZE 1D03 90 SWAP1 1D04 81 DUP2 1D05 01 ADD 1D06 60 PUSH1 0x1f 1D08 19 NOT 1D09 16 AND 1D0A 82 DUP3 1D0B 01 ADD 1D0C 90 SWAP1 1D0D 92 SWAP3 1D0E 52 MSTORE 1D0F 61 PUSH2 0x1d1a 1D12 91 SWAP2 1D13 81 DUP2 1D14 01 ADD 1D15 90 SWAP1 1D16 61 PUSH2 0x2b0d 1D19 56 *JUMP 1D1A 5B JUMPDEST 1D1B 60 PUSH1 0x01 1D1D 5B JUMPDEST 1D1E 61 PUSH2 0x1dca 1D21 57 *JUMPI 1D22 61 PUSH2 0x1d29 1D25 61 PUSH2 0x2fd8 1D28 56 *JUMP 1D29 5B JUMPDEST 1D2A 80 DUP1 1D2B 63 PUSH4 0x08c379a0 1D30 14 EQ 1D31 15 ISZERO 1D32 61 PUSH2 0x1d63 1D35 57 *JUMPI 1D36 50 POP 1D37 61 PUSH2 0x1d3e 1D3A 61 PUSH2 0x2ff4 1D3D 56 *JUMP 1D3E 5B JUMPDEST 1D3F 80 DUP1 1D40 61 PUSH2 0x1d49 1D43 57 *JUMPI 1D44 50 POP 1D45 61 PUSH2 0x1d65 1D48 56 *JUMP 1D49 5B JUMPDEST 1D4A 80 DUP1 1D4B 60 PUSH1 0x40 1D4D 51 MLOAD 1D4E 62 PUSH3 0x461bcd 1D52 60 PUSH1 0xe5 1D54 1B SHL 1D55 81 DUP2 1D56 52 MSTORE 1D57 60 PUSH1 0x04 1D59 01 ADD 1D5A 61 PUSH2 0x054a 1D5D 91 SWAP2 1D5E 90 SWAP1 1D5F 61 PUSH2 0x2d2f 1D62 56 *JUMP 1D63 5B JUMPDEST 1D64 50 POP 1D65 5B JUMPDEST 1D66 60 PUSH1 0x40 1D68 51 MLOAD 1D69 62 PUSH3 0x461bcd 1D6D 60 PUSH1 0xe5 1D6F 1B SHL 1D70 81 DUP2 1D71 52 MSTORE 1D72 60 PUSH1 0x20 1D74 60 PUSH1 0x04 1D76 82 DUP3 1D77 01 ADD 1D78 52 MSTORE 1D79 60 PUSH1 0x34 1D7B 60 PUSH1 0x24 1D7D 82 DUP3 1D7E 01 ADD 1D7F 52 MSTORE 1D80 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 1DA1 60 PUSH1 0x44 1DA3 82 DUP3 1DA4 01 ADD 1DA5 52 MSTORE 1DA6 73 PUSH20 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 1DBB 60 PUSH1 0x61 1DBD 1B SHL 1DBE 60 PUSH1 0x64 1DC0 82 DUP3 1DC1 01 ADD 1DC2 52 MSTORE 1DC3 60 PUSH1 0x84 1DC5 01 ADD 1DC6 61 PUSH2 0x054a 1DC9 56 *JUMP 1DCA 5B JUMPDEST 1DCB 60 PUSH1 0x01 1DCD 60 PUSH1 0x01 1DCF 60 PUSH1 0xe0 1DD1 1B SHL 1DD2 03 SUB 1DD3 19 NOT 1DD4 81 DUP2 1DD5 16 AND 1DD6 63 PUSH4 0xf23a6e61 1DDB 60 PUSH1 0xe0 1DDD 1B SHL 1DDE 14 EQ 1DDF 61 PUSH2 0x160c 1DE2 57 *JUMPI 1DE3 60 PUSH1 0x40 1DE5 51 MLOAD 1DE6 62 PUSH3 0x461bcd 1DEA 60 PUSH1 0xe5 1DEC 1B SHL 1DED 81 DUP2 1DEE 52 MSTORE 1DEF 60 PUSH1 0x04 1DF1 01 ADD 1DF2 61 PUSH2 0x054a 1DF5 90 SWAP1 1DF6 61 PUSH2 0x2d42 1DF9 56 *JUMP 1DFA 5B JUMPDEST 1DFB 60 PUSH1 0x01 1DFD 60 PUSH1 0x01 1DFF 60 PUSH1 0xa0 1E01 1B SHL 1E02 03 SUB 1E03 84 DUP5 1E04 16 AND 1E05 3B EXTCODESIZE 1E06 15 ISZERO 1E07 61 PUSH2 0x1886 1E0A 57 *JUMPI 1E0B 60 PUSH1 0x40 1E0D 51 MLOAD 1E0E 63 PUSH4 0xbc197c81 1E13 60 PUSH1 0xe0 1E15 1B SHL 1E16 81 DUP2 1E17 52 MSTORE 1E18 60 PUSH1 0x01 1E1A 60 PUSH1 0x01 1E1C 60 PUSH1 0xa0 1E1E 1B SHL 1E1F 03 SUB 1E20 85 DUP6 1E21 16 AND 1E22 90 SWAP1 1E23 63 PUSH4 0xbc197c81 1E28 90 SWAP1 1E29 61 PUSH2 0x1e3e 1E2C 90 SWAP1 1E2D 89 DUP10 1E2E 90 SWAP1 1E2F 89 DUP10 1E30 90 SWAP1 1E31 88 DUP9 1E32 90 SWAP1 1E33 88 DUP9 1E34 90 SWAP1 1E35 88 DUP9 1E36 90 SWAP1 1E37 60 PUSH1 0x04 1E39 01 ADD 1E3A 61 PUSH2 0x2c4b 1E3D 56 *JUMP 1E3E 5B JUMPDEST 1E3F 60 PUSH1 0x20 1E41 60 PUSH1 0x40 1E43 51 MLOAD 1E44 80 DUP1 1E45 83 DUP4 1E46 03 SUB 1E47 81 DUP2 1E48 60 PUSH1 0x00 1E4A 87 DUP8 1E4B 80 DUP1 1E4C 3B EXTCODESIZE 1E4D 15 ISZERO 1E4E 80 DUP1 1E4F 15 ISZERO 1E50 61 PUSH2 0x1e58 1E53 57 *JUMPI 1E54 60 PUSH1 0x00 1E56 80 DUP1 1E57 FD *REVERT 1E58 5B JUMPDEST 1E59 50 POP 1E5A 5A GAS 1E5B F1 CALL 1E5C 92 SWAP3 1E5D 50 POP 1E5E 50 POP 1E5F 50 POP 1E60 80 DUP1 1E61 15 ISZERO 1E62 61 PUSH2 0x1e88 1E65 57 *JUMPI 1E66 50 POP 1E67 60 PUSH1 0x40 1E69 80 DUP1 1E6A 51 MLOAD 1E6B 60 PUSH1 0x1f 1E6D 3D RETURNDATASIZE 1E6E 90 SWAP1 1E6F 81 DUP2 1E70 01 ADD 1E71 60 PUSH1 0x1f 1E73 19 NOT 1E74 16 AND 1E75 82 DUP3 1E76 01 ADD 1E77 90 SWAP1 1E78 92 SWAP3 1E79 52 MSTORE 1E7A 61 PUSH2 0x1e85 1E7D 91 SWAP2 1E7E 81 DUP2 1E7F 01 ADD 1E80 90 SWAP1 1E81 61 PUSH2 0x2b0d 1E84 56 *JUMP 1E85 5B JUMPDEST 1E86 60 PUSH1 0x01 1E88 5B JUMPDEST 1E89 61 PUSH2 0x1e94 1E8C 57 *JUMPI 1E8D 61 PUSH2 0x1d29 1E90 61 PUSH2 0x2fd8 1E93 56 *JUMP 1E94 5B JUMPDEST 1E95 60 PUSH1 0x01 1E97 60 PUSH1 0x01 1E99 60 PUSH1 0xe0 1E9B 1B SHL 1E9C 03 SUB 1E9D 19 NOT 1E9E 81 DUP2 1E9F 16 AND 1EA0 63 PUSH4 0xbc197c81 1EA5 60 PUSH1 0xe0 1EA7 1B SHL 1EA8 14 EQ 1EA9 61 PUSH2 0x160c 1EAC 57 *JUMPI 1EAD 60 PUSH1 0x40 1EAF 51 MLOAD 1EB0 62 PUSH3 0x461bcd 1EB4 60 PUSH1 0xe5 1EB6 1B SHL 1EB7 81 DUP2 1EB8 52 MSTORE 1EB9 60 PUSH1 0x04 1EBB 01 ADD 1EBC 61 PUSH2 0x054a 1EBF 90 SWAP1 1EC0 61 PUSH2 0x2d42 1EC3 56 *JUMP label_1EC4: // Incoming jump from 0x1B7F // Inputs[1] { @1ECD stack[-4] } 1EC4 5B JUMPDEST 1EC5 60 PUSH1 0x01 1EC7 60 PUSH1 0x01 1EC9 60 PUSH1 0xa0 1ECB 1B SHL 1ECC 03 SUB 1ECD 84 DUP5 1ECE 16 AND 1ECF 61 PUSH2 0x1eea 1ED2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1eea, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1ED3: // Incoming jump from 0x1ED2, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1ED5 memory[0x40:0x60] } 1ED3 60 PUSH1 0x40 1ED5 51 MLOAD 1ED6 62 PUSH3 0x461bcd 1EDA 60 PUSH1 0xe5 1EDC 1B SHL 1EDD 81 DUP2 1EDE 52 MSTORE 1EDF 60 PUSH1 0x04 1EE1 01 ADD 1EE2 61 PUSH2 0x054a 1EE5 90 SWAP1 1EE6 61 PUSH2 0x2dcf 1EE9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1EDE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1EE5 stack[0] = 0x054a // @1EE5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2dcf, returns to 0x054A label_1EEA: // Incoming jump from 0x1ED2, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1EEB msg.sender // @1EF1 stack[-3] // } 1EEA 5B JUMPDEST 1EEB 33 CALLER 1EEC 60 PUSH1 0x00 1EEE 61 PUSH2 0x1ef6 1EF1 85 DUP6 1EF2 61 PUSH2 0x1be9 1EF5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EEB stack[0] = msg.sender // @1EEC stack[1] = 0x00 // @1EEE stack[2] = 0x1ef6 // @1EF1 stack[3] = stack[-3] // } // Block ends with call to 0x1be9, returns to 0x1EF6 label_1EF6: // Incoming return from call to 0x1BE9 at 0x1EF5 // Inputs[3] // { // @1EF7 stack[-2] // @1EF7 stack[-1] // @1EFE stack[-5] // } 1EF6 5B JUMPDEST 1EF7 90 SWAP1 1EF8 50 POP 1EF9 60 PUSH1 0x00 1EFB 61 PUSH2 0x1f03 1EFE 85 DUP6 1EFF 61 PUSH2 0x1be9 1F02 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1EF7 stack[-2] = stack[-1] // @1EF9 stack[-1] = 0x00 // @1EFB stack[0] = 0x1f03 // @1EFE stack[1] = stack[-5] // } // Block ends with call to 0x1be9, returns to 0x1F03 label_1F03: // Incoming return from call to 0x1BE9 at 0x1F02 // Inputs[7] // { // @1F04 stack[-1] // @1F04 stack[-2] // @1F09 stack[-4] // @1F0A stack[-9] // @1F0B stack[-8] // @1F0C stack[-3] // @1F0E stack[-5] // } 1F03 5B JUMPDEST 1F04 90 SWAP1 1F05 50 POP 1F06 61 PUSH2 0x1f13 1F09 83 DUP4 1F0A 89 DUP10 1F0B 89 DUP10 1F0C 85 DUP6 1F0D 85 DUP6 1F0E 89 DUP10 1F0F 61 PUSH2 0x1c34 1F12 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1F04 stack[-2] = stack[-1] // @1F06 stack[-1] = 0x1f13 // @1F09 stack[0] = stack[-4] // @1F0A stack[1] = stack[-9] // @1F0B stack[2] = stack[-8] // @1F0C stack[3] = stack[-3] // @1F0D stack[4] = stack[-1] // @1F0E stack[5] = stack[-5] // } // Block ends with unconditional jump to 0x1c34 1F13 5B JUMPDEST 1F14 60 PUSH1 0x00 1F16 86 DUP7 1F17 81 DUP2 1F18 52 MSTORE 1F19 60 PUSH1 0x20 1F1B 81 DUP2 1F1C 81 DUP2 1F1D 52 MSTORE 1F1E 60 PUSH1 0x40 1F20 80 DUP1 1F21 83 DUP4 1F22 20 SHA3 1F23 60 PUSH1 0x01 1F25 60 PUSH1 0x01 1F27 60 PUSH1 0xa0 1F29 1B SHL 1F2A 03 SUB 1F2B 8C DUP13 1F2C 16 AND 1F2D 84 DUP5 1F2E 52 MSTORE 1F2F 90 SWAP1 1F30 91 SWAP2 1F31 52 MSTORE 1F32 90 SWAP1 1F33 20 SHA3 1F34 54 SLOAD 1F35 85 DUP6 1F36 81 DUP2 1F37 10 LT 1F38 15 ISZERO 1F39 61 PUSH2 0x1f54 1F3C 57 *JUMPI 1F3D 60 PUSH1 0x40 1F3F 51 MLOAD 1F40 62 PUSH3 0x461bcd 1F44 60 PUSH1 0xe5 1F46 1B SHL 1F47 81 DUP2 1F48 52 MSTORE 1F49 60 PUSH1 0x04 1F4B 01 ADD 1F4C 61 PUSH2 0x054a 1F4F 90 SWAP1 1F50 61 PUSH2 0x2e14 1F53 56 *JUMP 1F54 5B JUMPDEST 1F55 60 PUSH1 0x00 1F57 87 DUP8 1F58 81 DUP2 1F59 52 MSTORE 1F5A 60 PUSH1 0x20 1F5C 81 DUP2 1F5D 81 DUP2 1F5E 52 MSTORE 1F5F 60 PUSH1 0x40 1F61 80 DUP1 1F62 83 DUP4 1F63 20 SHA3 1F64 60 PUSH1 0x01 1F66 60 PUSH1 0x01 1F68 60 PUSH1 0xa0 1F6A 1B SHL 1F6B 03 SUB 1F6C 8D DUP14 1F6D 81 DUP2 1F6E 16 AND 1F6F 85 DUP6 1F70 52 MSTORE 1F71 92 SWAP3 1F72 52 MSTORE 1F73 80 DUP1 1F74 83 DUP4 1F75 20 SHA3 1F76 89 DUP10 1F77 85 DUP6 1F78 03 SUB 1F79 90 SWAP1 1F7A 55 SSTORE 1F7B 90 SWAP1 1F7C 8A DUP11 1F7D 16 AND 1F7E 82 DUP3 1F7F 52 MSTORE 1F80 81 DUP2 1F81 20 SHA3 1F82 80 DUP1 1F83 54 SLOAD 1F84 88 DUP9 1F85 92 SWAP3 1F86 90 SWAP1 1F87 61 PUSH2 0x1f91 1F8A 90 SWAP1 1F8B 84 DUP5 1F8C 90 SWAP1 1F8D 61 PUSH2 0x2eb6 1F90 56 *JUMP 1F91 5B JUMPDEST 1F92 90 SWAP1 1F93 91 SWAP2 1F94 55 SSTORE 1F95 50 POP 1F96 50 POP 1F97 60 PUSH1 0x40 1F99 80 DUP1 1F9A 51 MLOAD 1F9B 88 DUP9 1F9C 81 DUP2 1F9D 52 MSTORE 1F9E 60 PUSH1 0x20 1FA0 81 DUP2 1FA1 01 ADD 1FA2 88 DUP9 1FA3 90 SWAP1 1FA4 52 MSTORE 1FA5 60 PUSH1 0x01 1FA7 60 PUSH1 0x01 1FA9 60 PUSH1 0xa0 1FAB 1B SHL 1FAC 03 SUB 1FAD 80 DUP1 1FAE 8B DUP12 1FAF 16 AND 1FB0 92 SWAP3 1FB1 8C DUP13 1FB2 82 DUP3 1FB3 16 AND 1FB4 92 SWAP3 1FB5 91 SWAP2 1FB6 88 DUP9 1FB7 16 AND 1FB8 91 SWAP2 1FB9 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1FDA 91 SWAP2 1FDB 01 ADD 1FDC 60 PUSH1 0x40 1FDE 51 MLOAD 1FDF 80 DUP1 1FE0 91 SWAP2 1FE1 03 SUB 1FE2 90 SWAP1 1FE3 A4 LOG4 1FE4 61 PUSH2 0x1ff1 1FE7 84 DUP5 1FE8 8A DUP11 1FE9 8A DUP11 1FEA 8A DUP11 1FEB 8A DUP11 1FEC 8A DUP11 1FED 61 PUSH2 0x1c8f 1FF0 56 *JUMP 1FF1 5B JUMPDEST 1FF2 50 POP 1FF3 50 POP 1FF4 50 POP 1FF5 50 POP 1FF6 50 POP 1FF7 50 POP 1FF8 50 POP 1FF9 50 POP 1FFA 50 POP 1FFB 56 *JUMP label_1FFC: // Incoming call from 0x1BC3, returns to 0x1BC4 // Inputs[2] // { // @1FFF memory[0x40:0x60] // @202A stack[-1] // } 1FFC 5B JUMPDEST 1FFD 60 PUSH1 0x40 1FFF 51 MLOAD 2000 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 2021 60 PUSH1 0x20 2023 82 DUP3 2024 01 ADD 2025 52 MSTORE 2026 60 PUSH1 0x3c 2028 81 DUP2 2029 01 ADD 202A 82 DUP3 202B 90 SWAP1 202C 52 MSTORE 202D 60 PUSH1 0x00 202F 90 SWAP1 2030 60 PUSH1 0x5c 2032 01 ADD 2033 61 PUSH2 0x1b98 2036 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2025 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 // @202C memory[memory[0x40:0x60] + 0x3c:memory[0x40:0x60] + 0x3c + 0x20] = stack[-1] // @202F stack[0] = 0x00 // @2032 stack[1] = 0x5c + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1b98 label_2037: // Incoming jump from 0x1BC9 // Inputs[2] // { // @2040 stack[-2] // @2041 stack[-1] // } 2037 5B JUMPDEST 2038 60 PUSH1 0x00 203A 80 DUP1 203B 60 PUSH1 0x00 203D 61 PUSH2 0x2046 2040 85 DUP6 2041 85 DUP6 2042 61 PUSH2 0x21cc 2045 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2038 stack[0] = 0x00 // @203A stack[1] = 0x00 // @203B stack[2] = 0x00 // @203D stack[3] = 0x2046 // @2040 stack[4] = stack[-2] // @2041 stack[5] = stack[-1] // } // Block ends with call to 0x21cc, returns to 0x2046 label_2046: // Incoming return from call to 0x21CC at 0x2045 // Inputs[4] // { // @2047 stack[-3] // @2047 stack[-1] // @2049 stack[-2] // @2049 stack[-4] // } 2046 5B JUMPDEST 2047 91 SWAP2 2048 50 POP 2049 91 SWAP2 204A 50 POP 204B 61 PUSH2 0x0d43 204E 81 DUP2 204F 61 PUSH2 0x223c 2052 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2047 stack[-3] = stack[-1] // @2049 stack[-4] = stack[-2] // @204B stack[-2] = 0x0d43 // @204E stack[-1] = stack[-1] // } // Block ends with call to 0x223c, returns to 0x0D43 label_2053: // Incoming call from 0x1C8E, returns to 0x1886 // Inputs[1] { @205C stack[-5] } 2053 5B JUMPDEST 2054 60 PUSH1 0x01 2056 60 PUSH1 0x01 2058 60 PUSH1 0xa0 205A 1B SHL 205B 03 SUB 205C 85 DUP6 205D 16 AND 205E 61 PUSH2 0x20da 2061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20da, if stack[-5] & (0x01 << 0xa0) - 0x01 label_2062: // Incoming jump from 0x2061, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @2065 stack[-3] // @2066 memory[stack[-3]:stack[-3] + 0x20] // } 2062 60 PUSH1 0x00 2064 5B JUMPDEST 2065 83 DUP4 2066 51 MLOAD 2067 81 DUP2 2068 10 LT 2069 15 ISZERO 206A 61 PUSH2 0x20d8 206D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2062 stack[0] = 0x00 } // Block ends with conditional jump to 0x20d8, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_206E: // Incoming jump from 0x206D, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x206D, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @206E stack[-3] // @206F stack[-1] // @2071 memory[stack[-3]:stack[-3] + 0x20] // } 206E 82 DUP3 206F 81 DUP2 2070 81 DUP2 2071 51 MLOAD 2072 81 DUP2 2073 10 LT 2074 61 PUSH2 0x207f 2077 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @206E stack[0] = stack[-3] // @206F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x207f, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_2078: // Incoming jump from 0x2077, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 2078 61 PUSH2 0x207f 207B 61 PUSH2 0x2fac 207E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2078 stack[0] = 0x207f } // Block ends with unconditional jump to 0x2fac label_207F: // Incoming jump from 0x2077, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @2082 stack[-1] // @2086 stack[-2] // @2087 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @208C stack[-6] // @208D stack[-3] // @208F memory[stack[-6]:stack[-6] + 0x20] // } 207F 5B JUMPDEST 2080 60 PUSH1 0x20 2082 02 MUL 2083 60 PUSH1 0x20 2085 01 ADD 2086 01 ADD 2087 51 MLOAD 2088 60 PUSH1 0x03 208A 60 PUSH1 0x00 208C 86 DUP7 208D 84 DUP5 208E 81 DUP2 208F 51 MLOAD 2090 81 DUP2 2091 10 LT 2092 61 PUSH2 0x209d 2095 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2087 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2088 stack[-1] = 0x03 // @208A stack[0] = 0x00 // @208C stack[1] = stack[-6] // @208D stack[2] = stack[-3] // } // Block ends with conditional jump to 0x209d, if stack[-3] < memory[stack[-6]:stack[-6] + 0x20] label_2096: // Incoming jump from 0x2095, if not stack[-3] < memory[stack[-6]:stack[-6] + 0x20] 2096 61 PUSH2 0x209d 2099 61 PUSH2 0x2fac 209C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2096 stack[0] = 0x209d } // Block ends with unconditional jump to 0x2fac label_209D: // Incoming jump from 0x2095, if stack[-3] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[8] // { // @20A0 stack[-1] // @20A4 stack[-2] // @20A5 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @20A6 stack[-3] // @20AB stack[-4] // @20B3 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @20B6 stack[-5] // @20B8 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // } 209D 5B JUMPDEST 209E 60 PUSH1 0x20 20A0 02 MUL 20A1 60 PUSH1 0x20 20A3 01 ADD 20A4 01 ADD 20A5 51 MLOAD 20A6 81 DUP2 20A7 52 MSTORE 20A8 60 PUSH1 0x20 20AA 01 ADD 20AB 90 SWAP1 20AC 81 DUP2 20AD 52 MSTORE 20AE 60 PUSH1 0x20 20B0 01 ADD 20B1 60 PUSH1 0x00 20B3 20 SHA3 20B4 60 PUSH1 0x00 20B6 82 DUP3 20B7 82 DUP3 20B8 54 SLOAD 20B9 61 PUSH2 0x20c2 20BC 91 SWAP2 20BD 90 SWAP1 20BE 61 PUSH2 0x2eb6 20C1 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @20A7 memory[stack[-3]:stack[-3] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @20AD memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @20B3 stack[-4] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @20B4 stack[-3] = 0x00 // @20BC stack[-2] = 0x20c2 // @20BD stack[0] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @20BD stack[-1] = stack[-5] // } // Block ends with call to 0x2eb6, returns to 0x20C2 label_20C2: // Incoming return from call to 0x2EB6 at 0x20C1 // Inputs[5] // { // @20C3 stack[-2] // @20C3 stack[-1] // @20C4 stack[-3] // @20CA stack[-4] // @20CC stack[-5] // } 20C2 5B JUMPDEST 20C3 90 SWAP1 20C4 91 SWAP2 20C5 55 SSTORE 20C6 50 POP 20C7 61 PUSH2 0x20d1 20CA 90 SWAP1 20CB 50 POP 20CC 81 DUP2 20CD 61 PUSH2 0x2f65 20D0 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @20C5 storage[stack[-3]] = stack[-1] // @20CA stack[-4] = 0x20d1 // @20CC stack[-3] = stack[-5] // } // Block ends with call to 0x2f65, returns to 0x20D1 label_20D1: // Incoming return from call to 0x2F65 at 0x20D0 // Inputs[2] // { // @20D2 stack[-2] // @20D2 stack[-1] // } 20D1 5B JUMPDEST 20D2 90 SWAP1 20D3 50 POP 20D4 61 PUSH2 0x2064 20D7 56 *JUMP // Stack delta = -1 // Outputs[1] { @20D2 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x2064 label_20D8: // Incoming jump from 0x206D, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x206D, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) 20D8 5B JUMPDEST 20D9 50 POP // Stack delta = -1 // Block continues label_20DA: // Incoming jump from 0x20D9 // Incoming jump from 0x2061, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @20E3 stack[-4] } 20DA 5B JUMPDEST 20DB 60 PUSH1 0x01 20DD 60 PUSH1 0x01 20DF 60 PUSH1 0xa0 20E1 1B SHL 20E2 03 SUB 20E3 84 DUP5 20E4 16 AND 20E5 61 PUSH2 0x1886 20E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1886, if stack[-4] & (0x01 << 0xa0) - 0x01 label_20E9: // Incoming jump from 0x20E8, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @20EC stack[-3] // @20ED memory[stack[-3]:stack[-3] + 0x20] // } 20E9 60 PUSH1 0x00 20EB 5B JUMPDEST 20EC 83 DUP4 20ED 51 MLOAD 20EE 81 DUP2 20EF 10 LT 20F0 15 ISZERO 20F1 61 PUSH2 0x160c 20F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E9 stack[0] = 0x00 } // Block ends with conditional jump to 0x160c, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_20F5: // Incoming jump from 0x20F4, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x20F4, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @20F7 stack[-4] // @20F8 stack[-1] // @20FA memory[stack[-4]:stack[-4] + 0x20] // } 20F5 60 PUSH1 0x00 20F7 84 DUP5 20F8 82 DUP3 20F9 81 DUP2 20FA 51 MLOAD 20FB 81 DUP2 20FC 10 LT 20FD 61 PUSH2 0x2108 2100 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @20F5 stack[0] = 0x00 // @20F7 stack[1] = stack[-4] // @20F8 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2108, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_2101: // Incoming jump from 0x2100, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 2101 61 PUSH2 0x2108 2104 61 PUSH2 0x2fac 2107 56 *JUMP // Stack delta = +1 // Outputs[1] { @2101 stack[0] = 0x2108 } // Block ends with unconditional jump to 0x2fac label_2108: // Incoming jump from 0x2100, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @210B stack[-1] // @210F stack[-2] // @2110 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2111 stack[-3] // @2115 stack[-6] // @2116 stack[-4] // @2118 memory[stack[-6]:stack[-6] + 0x20] // } 2108 5B JUMPDEST 2109 60 PUSH1 0x20 210B 02 MUL 210C 60 PUSH1 0x20 210E 01 ADD 210F 01 ADD 2110 51 MLOAD 2111 90 SWAP1 2112 50 POP 2113 60 PUSH1 0x00 2115 84 DUP5 2116 83 DUP4 2117 81 DUP2 2118 51 MLOAD 2119 81 DUP2 211A 10 LT 211B 61 PUSH2 0x2126 211E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2111 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2113 stack[-2] = 0x00 // @2115 stack[-1] = stack[-6] // @2116 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x2126, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] label_211F: // Incoming jump from 0x211E, if not stack[-4] < memory[stack[-6]:stack[-6] + 0x20] 211F 61 PUSH2 0x2126 2122 61 PUSH2 0x2fac 2125 56 *JUMP // Stack delta = +1 // Outputs[1] { @211F stack[0] = 0x2126 } // Block ends with unconditional jump to 0x2fac label_2126: // Incoming jump from 0x211E, if stack[-4] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[7] // { // @2129 stack[-1] // @212D stack[-2] // @212E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @212F stack[-3] // @2137 stack[-4] // @2145 memory[0x00:0x40] // @2146 storage[keccak256(memory[0x00:0x40])] // } 2126 5B JUMPDEST 2127 60 PUSH1 0x20 2129 02 MUL 212A 60 PUSH1 0x20 212C 01 ADD 212D 01 ADD 212E 51 MLOAD 212F 90 SWAP1 2130 50 POP 2131 60 PUSH1 0x00 2133 60 PUSH1 0x03 2135 60 PUSH1 0x00 2137 84 DUP5 2138 81 DUP2 2139 52 MSTORE 213A 60 PUSH1 0x20 213C 01 ADD 213D 90 SWAP1 213E 81 DUP2 213F 52 MSTORE 2140 60 PUSH1 0x20 2142 01 ADD 2143 60 PUSH1 0x00 2145 20 SHA3 2146 54 SLOAD 2147 90 SWAP1 2148 50 POP 2149 81 DUP2 214A 81 DUP2 214B 10 LT 214C 15 ISZERO 214D 61 PUSH2 0x21a9 2150 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @212F stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2139 memory[0x00:0x20] = stack[-4] // @213F memory[0x20:0x40] = 0x03 // @2147 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x21a9, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) label_2151: // Incoming jump from 0x2150, if not !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[1] { @2153 memory[0x40:0x60] } 2151 60 PUSH1 0x40 2153 51 MLOAD 2154 62 PUSH3 0x461bcd 2158 60 PUSH1 0xe5 215A 1B SHL 215B 81 DUP2 215C 52 MSTORE 215D 60 PUSH1 0x20 215F 60 PUSH1 0x04 2161 82 DUP3 2162 01 ADD 2163 52 MSTORE 2164 60 PUSH1 0x28 2166 60 PUSH1 0x24 2168 82 DUP3 2169 01 ADD 216A 52 MSTORE 216B 7F PUSH32 0x455243313135353a206275726e20616d6f756e74206578636565647320746f74 218C 60 PUSH1 0x44 218E 82 DUP3 218F 01 ADD 2190 52 MSTORE 2191 67 PUSH8 0x616c537570706c79 219A 60 PUSH1 0xc0 219C 1B SHL 219D 60 PUSH1 0x64 219F 82 DUP3 21A0 01 ADD 21A1 52 MSTORE 21A2 60 PUSH1 0x84 21A4 01 ADD 21A5 61 PUSH2 0x054a 21A8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @215C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2163 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @216A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @2190 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e20616d6f756e74206578636565647320746f74 // @21A1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616c537570706c79 << 0xc0 // @21A4 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_21A9: // Incoming jump from 0x2150, if !(storage[keccak256(memory[0x00:0x40])] < memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]) // Inputs[5] // { // @21AC stack[-3] // @21B6 stack[-1] // @21B8 memory[0x00:0x40] // @21BA stack[-2] // @21C0 stack[-4] // } 21A9 5B JUMPDEST 21AA 60 PUSH1 0x00 21AC 92 SWAP3 21AD 83 DUP4 21AE 52 MSTORE 21AF 60 PUSH1 0x03 21B1 60 PUSH1 0x20 21B3 52 MSTORE 21B4 60 PUSH1 0x40 21B6 90 SWAP1 21B7 92 SWAP3 21B8 20 SHA3 21B9 91 SWAP2 21BA 03 SUB 21BB 90 SWAP1 21BC 55 SSTORE 21BD 61 PUSH2 0x21c5 21C0 81 DUP2 21C1 61 PUSH2 0x2f65 21C4 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @21AE memory[0x00:0x20] = stack[-3] // @21B3 memory[0x20:0x40] = 0x03 // @21BC storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @21BD stack[-3] = 0x21c5 // @21C0 stack[-2] = stack[-4] // } // Block ends with call to 0x2f65, returns to 0x21C5 label_21C5: // Incoming return from call to 0x2F65 at 0x21C4 // Inputs[2] // { // @21C6 stack[-1] // @21C6 stack[-2] // } 21C5 5B JUMPDEST 21C6 90 SWAP1 21C7 50 POP 21C8 61 PUSH2 0x20eb 21CB 56 *JUMP // Stack delta = -1 // Outputs[1] { @21C6 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x20eb label_21CC: // Incoming call from 0x2045, returns to 0x2046 // Inputs[2] // { // @21D0 stack[-1] // @21D1 memory[stack[-1]:stack[-1] + 0x20] // } 21CC 5B JUMPDEST 21CD 60 PUSH1 0x00 21CF 80 DUP1 21D0 82 DUP3 21D1 51 MLOAD 21D2 60 PUSH1 0x41 21D4 14 EQ 21D5 15 ISZERO 21D6 61 PUSH2 0x2203 21D9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21CD stack[0] = 0x00 // @21CF stack[1] = 0x00 // } // Block ends with conditional jump to 0x2203, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) label_21DA: // Incoming jump from 0x21D9, if not !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @21DC stack[-3] // @21DE memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @21E3 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @21E8 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @21EF stack[-4] // } 21DA 60 PUSH1 0x20 21DC 83 DUP4 21DD 01 ADD 21DE 51 MLOAD 21DF 60 PUSH1 0x40 21E1 84 DUP5 21E2 01 ADD 21E3 51 MLOAD 21E4 60 PUSH1 0x60 21E6 85 DUP6 21E7 01 ADD 21E8 51 MLOAD 21E9 60 PUSH1 0x00 21EB 1A BYTE 21EC 61 PUSH2 0x21f7 21EF 87 DUP8 21F0 82 DUP3 21F1 85 DUP6 21F2 85 DUP6 21F3 61 PUSH2 0x23f7 21F6 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @21DE stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @21E3 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @21EB stack[2] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @21EC stack[3] = 0x21f7 // @21EF stack[4] = stack[-4] // @21F0 stack[5] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @21F1 stack[6] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @21F2 stack[7] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x23f7, returns to 0x21F7 label_21F7: // Incoming return from call to 0x23F7 at 0x21F6 // Inputs[4] // { // @21F8 stack[-1] // @21F8 stack[-6] // @21FA stack[-2] // @21FA stack[-7] // } 21F7 5B JUMPDEST 21F8 94 SWAP5 21F9 50 POP 21FA 94 SWAP5 21FB 50 POP 21FC 50 POP 21FD 50 POP 21FE 50 POP 21FF 61 PUSH2 0x2235 2202 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @21F8 stack[-6] = stack[-1] // @21FA stack[-7] = stack[-2] // } // Block ends with unconditional jump to 0x2235 label_2203: // Incoming jump from 0x21D9, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @2204 stack[-3] // @2205 memory[stack[-3]:stack[-3] + 0x20] // } 2203 5B JUMPDEST 2204 82 DUP3 2205 51 MLOAD 2206 60 PUSH1 0x40 2208 14 EQ 2209 15 ISZERO 220A 61 PUSH2 0x222d 220D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x222d, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) label_220E: // Incoming jump from 0x220D, if not !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @2210 stack[-3] // @2212 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2217 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @221B stack[-4] // } 220E 60 PUSH1 0x20 2210 83 DUP4 2211 01 ADD 2212 51 MLOAD 2213 60 PUSH1 0x40 2215 84 DUP5 2216 01 ADD 2217 51 MLOAD 2218 61 PUSH2 0x2222 221B 86 DUP7 221C 83 DUP4 221D 83 DUP4 221E 61 PUSH2 0x24e4 2221 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2212 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2217 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @2218 stack[2] = 0x2222 // @221B stack[3] = stack[-4] // @221C stack[4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @221D stack[5] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x24e4, returns to 0x2222 label_2222: // Incoming return from call to 0x24E4 at 0x2221 // Inputs[4] // { // @2223 stack[-5] // @2223 stack[-1] // @2225 stack[-2] // @2225 stack[-6] // } 2222 5B JUMPDEST 2223 93 SWAP4 2224 50 POP 2225 93 SWAP4 2226 50 POP 2227 50 POP 2228 50 POP 2229 61 PUSH2 0x2235 222C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2223 stack[-5] = stack[-1] // @2225 stack[-6] = stack[-2] // } // Block ends with unconditional jump to 0x2235 label_222D: // Incoming jump from 0x220D, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[1] { @2231 stack[-2] } 222D 5B JUMPDEST 222E 50 POP 222F 60 PUSH1 0x00 2231 90 SWAP1 2232 50 POP 2233 60 PUSH1 0x02 // Stack delta = +0 // Outputs[2] // { // @2231 stack[-2] = 0x00 // @2233 stack[-1] = 0x02 // } // Block continues label_2235: // Incoming jump from 0x222C // Incoming jump from 0x2202 // Incoming jump from 0x2611, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Incoming jump from 0x2233 // Inputs[5] // { // @2236 stack[-1] // @2236 stack[-4] // @2238 stack[-2] // @2238 stack[-5] // @2239 stack[-3] // } 2235 5B JUMPDEST 2236 92 SWAP3 2237 50 POP 2238 92 SWAP3 2239 90 SWAP1 223A 50 POP 223B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2236 stack[-4] = stack[-1] // @2238 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_223C: // Incoming call from 0x2052, returns to 0x0D43 // Inputs[1] { @223F stack[-1] } 223C 5B JUMPDEST 223D 60 PUSH1 0x00 223F 81 DUP2 2240 60 PUSH1 0x04 2242 81 DUP2 2243 11 GT 2244 15 ISZERO 2245 61 PUSH2 0x2250 2248 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @223D stack[0] = 0x00 // @223F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2250, if !(stack[-1] > 0x04) label_2249: // Incoming jump from 0x2248, if not !(stack[-1] > 0x04) 2249 61 PUSH2 0x2250 224C 61 PUSH2 0x2f96 224F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2249 stack[0] = 0x2250 } // Block ends with unconditional jump to 0x2f96 label_2250: // Incoming jump from 0x2248, if !(stack[-1] > 0x04) // Inputs[2] // { // @2251 stack[-1] // @2251 stack[-2] // } 2250 5B JUMPDEST 2251 14 EQ 2252 15 ISZERO 2253 61 PUSH2 0x2259 2256 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2259, if !(stack[-1] == stack[-2]) label_2257: // Incoming jump from 0x2256, if not !(stack[-1] == stack[-2]) // Inputs[1] { @2258 stack[-2] } 2257 50 POP 2258 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2259: // Incoming jump from 0x2256, if !(stack[-1] == stack[-2]) // Inputs[1] { @225C stack[-1] } 2259 5B JUMPDEST 225A 60 PUSH1 0x01 225C 81 DUP2 225D 60 PUSH1 0x04 225F 81 DUP2 2260 11 GT 2261 15 ISZERO 2262 61 PUSH2 0x226d 2265 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @225A stack[0] = 0x01 // @225C stack[1] = stack[-1] // } // Block ends with conditional jump to 0x226d, if !(stack[-1] > 0x04) label_2266: // Incoming jump from 0x2265, if not !(stack[-1] > 0x04) 2266 61 PUSH2 0x226d 2269 61 PUSH2 0x2f96 226C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2266 stack[0] = 0x226d } // Block ends with unconditional jump to 0x2f96 label_226D: // Incoming jump from 0x2265, if !(stack[-1] > 0x04) // Inputs[2] // { // @226E stack[-1] // @226E stack[-2] // } 226D 5B JUMPDEST 226E 14 EQ 226F 15 ISZERO 2270 61 PUSH2 0x22bb 2273 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x22bb, if !(stack[-1] == stack[-2]) label_2274: // Incoming jump from 0x2273, if not !(stack[-1] == stack[-2]) // Inputs[1] { @2276 memory[0x40:0x60] } 2274 60 PUSH1 0x40 2276 51 MLOAD 2277 62 PUSH3 0x461bcd 227B 60 PUSH1 0xe5 227D 1B SHL 227E 81 DUP2 227F 52 MSTORE 2280 60 PUSH1 0x20 2282 60 PUSH1 0x04 2284 82 DUP3 2285 01 ADD 2286 52 MSTORE 2287 60 PUSH1 0x18 2289 60 PUSH1 0x24 228B 82 DUP3 228C 01 ADD 228D 52 MSTORE 228E 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 22AF 60 PUSH1 0x44 22B1 82 DUP3 22B2 01 ADD 22B3 52 MSTORE 22B4 60 PUSH1 0x64 22B6 01 ADD 22B7 61 PUSH2 0x054a 22BA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @227F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2286 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @228D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @22B3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 // @22B6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_22BB: // Incoming jump from 0x2273, if !(stack[-1] == stack[-2]) // Inputs[1] { @22BE stack[-1] } 22BB 5B JUMPDEST 22BC 60 PUSH1 0x02 22BE 81 DUP2 22BF 60 PUSH1 0x04 22C1 81 DUP2 22C2 11 GT 22C3 15 ISZERO 22C4 61 PUSH2 0x22cf 22C7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22BC stack[0] = 0x02 // @22BE stack[1] = stack[-1] // } // Block ends with conditional jump to 0x22cf, if !(stack[-1] > 0x04) label_22C8: // Incoming jump from 0x22C7, if not !(stack[-1] > 0x04) 22C8 61 PUSH2 0x22cf 22CB 61 PUSH2 0x2f96 22CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @22C8 stack[0] = 0x22cf } // Block ends with unconditional jump to 0x2f96 label_22CF: // Incoming jump from 0x22C7, if !(stack[-1] > 0x04) // Inputs[2] // { // @22D0 stack[-2] // @22D0 stack[-1] // } 22CF 5B JUMPDEST 22D0 14 EQ 22D1 15 ISZERO 22D2 61 PUSH2 0x231d 22D5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x231d, if !(stack[-1] == stack[-2]) label_22D6: // Incoming jump from 0x22D5, if not !(stack[-1] == stack[-2]) // Inputs[1] { @22D8 memory[0x40:0x60] } 22D6 60 PUSH1 0x40 22D8 51 MLOAD 22D9 62 PUSH3 0x461bcd 22DD 60 PUSH1 0xe5 22DF 1B SHL 22E0 81 DUP2 22E1 52 MSTORE 22E2 60 PUSH1 0x20 22E4 60 PUSH1 0x04 22E6 82 DUP3 22E7 01 ADD 22E8 52 MSTORE 22E9 60 PUSH1 0x1f 22EB 60 PUSH1 0x24 22ED 82 DUP3 22EE 01 ADD 22EF 52 MSTORE 22F0 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 2311 60 PUSH1 0x44 2313 82 DUP3 2314 01 ADD 2315 52 MSTORE 2316 60 PUSH1 0x64 2318 01 ADD 2319 61 PUSH2 0x054a 231C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @22E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @22E8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @22EF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @2315 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @2318 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_231D: // Incoming jump from 0x22D5, if !(stack[-1] == stack[-2]) // Inputs[1] { @2320 stack[-1] } 231D 5B JUMPDEST 231E 60 PUSH1 0x03 2320 81 DUP2 2321 60 PUSH1 0x04 2323 81 DUP2 2324 11 GT 2325 15 ISZERO 2326 61 PUSH2 0x2331 2329 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @231E stack[0] = 0x03 // @2320 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2331, if !(stack[-1] > 0x04) label_232A: // Incoming jump from 0x2329, if not !(stack[-1] > 0x04) 232A 61 PUSH2 0x2331 232D 61 PUSH2 0x2f96 2330 56 *JUMP // Stack delta = +1 // Outputs[1] { @232A stack[0] = 0x2331 } // Block ends with unconditional jump to 0x2f96 label_2331: // Incoming jump from 0x2329, if !(stack[-1] > 0x04) // Inputs[2] // { // @2332 stack[-1] // @2332 stack[-2] // } 2331 5B JUMPDEST 2332 14 EQ 2333 15 ISZERO 2334 61 PUSH2 0x238a 2337 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x238a, if !(stack[-1] == stack[-2]) label_2338: // Incoming jump from 0x2337, if not !(stack[-1] == stack[-2]) // Inputs[1] { @233A memory[0x40:0x60] } 2338 60 PUSH1 0x40 233A 51 MLOAD 233B 62 PUSH3 0x461bcd 233F 60 PUSH1 0xe5 2341 1B SHL 2342 81 DUP2 2343 52 MSTORE 2344 60 PUSH1 0x20 2346 60 PUSH1 0x04 2348 82 DUP3 2349 01 ADD 234A 52 MSTORE 234B 60 PUSH1 0x22 234D 60 PUSH1 0x24 234F 82 DUP3 2350 01 ADD 2351 52 MSTORE 2352 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 2373 60 PUSH1 0x44 2375 82 DUP3 2376 01 ADD 2377 52 MSTORE 2378 61 PUSH2 0x7565 237B 60 PUSH1 0xf0 237D 1B SHL 237E 60 PUSH1 0x64 2380 82 DUP3 2381 01 ADD 2382 52 MSTORE 2383 60 PUSH1 0x84 2385 01 ADD 2386 61 PUSH2 0x054a 2389 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2343 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @234A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2351 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @2377 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @2382 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @2385 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_238A: // Incoming jump from 0x2337, if !(stack[-1] == stack[-2]) // Inputs[1] { @238D stack[-1] } 238A 5B JUMPDEST 238B 60 PUSH1 0x04 238D 81 DUP2 238E 60 PUSH1 0x04 2390 81 DUP2 2391 11 GT 2392 15 ISZERO 2393 61 PUSH2 0x239e 2396 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @238B stack[0] = 0x04 // @238D stack[1] = stack[-1] // } // Block ends with conditional jump to 0x239e, if !(stack[-1] > 0x04) label_2397: // Incoming jump from 0x2396, if not !(stack[-1] > 0x04) 2397 61 PUSH2 0x239e 239A 61 PUSH2 0x2f96 239D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2397 stack[0] = 0x239e } // Block ends with unconditional jump to 0x2f96 label_239E: // Incoming jump from 0x2396, if !(stack[-1] > 0x04) // Inputs[2] // { // @239F stack[-1] // @239F stack[-2] // } 239E 5B JUMPDEST 239F 14 EQ 23A0 15 ISZERO 23A1 61 PUSH2 0x0abe 23A4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0abe, if !(stack[-1] == stack[-2]) label_23A5: // Incoming jump from 0x23A4, if not !(stack[-1] == stack[-2]) // Inputs[1] { @23A7 memory[0x40:0x60] } 23A5 60 PUSH1 0x40 23A7 51 MLOAD 23A8 62 PUSH3 0x461bcd 23AC 60 PUSH1 0xe5 23AE 1B SHL 23AF 81 DUP2 23B0 52 MSTORE 23B1 60 PUSH1 0x20 23B3 60 PUSH1 0x04 23B5 82 DUP3 23B6 01 ADD 23B7 52 MSTORE 23B8 60 PUSH1 0x22 23BA 60 PUSH1 0x24 23BC 82 DUP3 23BD 01 ADD 23BE 52 MSTORE 23BF 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 23E0 60 PUSH1 0x44 23E2 82 DUP3 23E3 01 ADD 23E4 52 MSTORE 23E5 61 PUSH2 0x7565 23E8 60 PUSH1 0xf0 23EA 1B SHL 23EB 60 PUSH1 0x64 23ED 82 DUP3 23EE 01 ADD 23EF 52 MSTORE 23F0 60 PUSH1 0x84 23F2 01 ADD 23F3 61 PUSH2 0x054a 23F6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @23B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @23B7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @23BE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @23E4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @23EF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @23F2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x054a label_23F7: // Incoming call from 0x21F6, returns to 0x21F7 // Incoming call from 0x250E, returns to 0x250F // Inputs[1] { @241C stack[-1] } 23F7 5B JUMPDEST 23F8 60 PUSH1 0x00 23FA 80 DUP1 23FB 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 241C 83 DUP4 241D 11 GT 241E 15 ISZERO 241F 61 PUSH2 0x242e 2422 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23F8 stack[0] = 0x00 // @23FA stack[1] = 0x00 // } // Block ends with conditional jump to 0x242e, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_2423: // Incoming jump from 0x2422, if not !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @2426 stack[-2] } 2423 50 POP 2424 60 PUSH1 0x00 2426 90 SWAP1 2427 50 POP 2428 60 PUSH1 0x03 242A 61 PUSH2 0x24db 242D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2426 stack[-2] = 0x00 // @2428 stack[-1] = 0x03 // } // Block ends with unconditional jump to 0x24db label_242E: // Incoming jump from 0x2422, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @242F stack[-5] } 242E 5B JUMPDEST 242F 84 DUP5 2430 60 PUSH1 0xff 2432 16 AND 2433 60 PUSH1 0x1b 2435 14 EQ 2436 15 ISZERO 2437 80 DUP1 2438 15 ISZERO 2439 61 PUSH2 0x2446 243C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2436 stack[0] = !(0x1b == 0xff & stack[-5]) } // Block ends with conditional jump to 0x2446, if !!(0x1b == 0xff & stack[-5]) label_243D: // Incoming jump from 0x243C, if not !!(0x1b == 0xff & stack[-5]) // Inputs[1] { @243E stack[-6] } 243D 50 POP 243E 84 DUP5 243F 60 PUSH1 0xff 2441 16 AND 2442 60 PUSH1 0x1c 2444 14 EQ 2445 15 ISZERO 2446 5B JUMPDEST 2447 15 ISZERO 2448 61 PUSH2 0x2457 244B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2457, if !!(0x1c == 0xff & stack[-6]) label_244C: // Incoming jump from 0x244B, if not !!(0x1c == 0xff & stack[-6]) // Incoming jump from 0x244B, if not !stack[-1] // Inputs[1] { @244F stack[-2] } 244C 50 POP 244D 60 PUSH1 0x00 244F 90 SWAP1 2450 50 POP 2451 60 PUSH1 0x04 2453 61 PUSH2 0x24db 2456 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @244F stack[-2] = 0x00 // @2451 stack[-1] = 0x04 // } // Block ends with unconditional jump to 0x24db label_2457: // Incoming jump from 0x244B, if !!(0x1c == 0xff & stack[-6]) // Incoming jump from 0x244B, if !stack[-1] // Inputs[9] // { // @245B memory[0x40:0x60] // @2468 stack[-6] // @246D stack[-5] // @247A stack[-4] // @2481 stack[-3] // @248E memory[0x40:0x60] // @2499 msg.gas // @249A address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @249A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2457 5B JUMPDEST 2458 60 PUSH1 0x40 245A 80 DUP1 245B 51 MLOAD 245C 60 PUSH1 0x00 245E 80 DUP1 245F 82 DUP3 2460 52 MSTORE 2461 60 PUSH1 0x20 2463 82 DUP3 2464 01 ADD 2465 80 DUP1 2466 84 DUP5 2467 52 MSTORE 2468 89 DUP10 2469 90 SWAP1 246A 52 MSTORE 246B 60 PUSH1 0xff 246D 88 DUP9 246E 16 AND 246F 92 SWAP3 2470 82 DUP3 2471 01 ADD 2472 92 SWAP3 2473 90 SWAP1 2474 92 SWAP3 2475 52 MSTORE 2476 60 PUSH1 0x60 2478 81 DUP2 2479 01 ADD 247A 86 DUP7 247B 90 SWAP1 247C 52 MSTORE 247D 60 PUSH1 0x80 247F 81 DUP2 2480 01 ADD 2481 85 DUP6 2482 90 SWAP1 2483 52 MSTORE 2484 60 PUSH1 0x01 2486 90 SWAP1 2487 60 PUSH1 0xa0 2489 01 ADD 248A 60 PUSH1 0x20 248C 60 PUSH1 0x40 248E 51 MLOAD 248F 60 PUSH1 0x20 2491 81 DUP2 2492 03 SUB 2493 90 SWAP1 2494 80 DUP1 2495 84 DUP5 2496 03 SUB 2497 90 SWAP1 2498 85 DUP6 2499 5A GAS 249A FA STATICCALL 249B 15 ISZERO 249C 80 DUP1 249D 15 ISZERO 249E 61 PUSH2 0x24ab 24A1 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @2460 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @2467 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @246A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @2474 stack[0] = 0x00 // @2475 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] & 0xff // @247C memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-4] // @2483 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-3] // @2486 stack[1] = 0x01 // @2489 stack[2] = 0xa0 + memory[0x40:0x60] // @249A memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @249B stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x24ab, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_24A2: // Incoming jump from 0x24A1, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @24A2 returndata.length // @24A6 returndata[0x00:0x00 + returndata.length] // @24A7 returndata.length // @24AA memory[0x00:0x00 + returndata.length] // } 24A2 3D RETURNDATASIZE 24A3 60 PUSH1 0x00 24A5 80 DUP1 24A6 3E RETURNDATACOPY 24A7 3D RETURNDATASIZE 24A8 60 PUSH1 0x00 24AA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @24A6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @24AA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_24AB: // Incoming jump from 0x24A1, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @24B0 memory[0x40:0x60] // @24B5 memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @24B6 stack[-4] // } 24AB 5B JUMPDEST 24AC 50 POP 24AD 50 POP 24AE 60 PUSH1 0x40 24B0 51 MLOAD 24B1 60 PUSH1 0x1f 24B3 19 NOT 24B4 01 ADD 24B5 51 MLOAD 24B6 91 SWAP2 24B7 50 POP 24B8 50 POP 24B9 60 PUSH1 0x01 24BB 60 PUSH1 0x01 24BD 60 PUSH1 0xa0 24BF 1B SHL 24C0 03 SUB 24C1 81 DUP2 24C2 16 AND 24C3 61 PUSH2 0x24d4 24C6 57 *JUMPI // Stack delta = -3 // Outputs[1] { @24B6 stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x24d4, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_24C7: // Incoming jump from 0x24C6, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @24CB stack[-2] // @24CD stack[-3] // } 24C7 60 PUSH1 0x00 24C9 60 PUSH1 0x01 24CB 92 SWAP3 24CC 50 POP 24CD 92 SWAP3 24CE 50 POP 24CF 50 POP 24D0 61 PUSH2 0x24db 24D3 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @24CB stack[-2] = 0x01 // @24CD stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x24db label_24D4: // Incoming jump from 0x24C6, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @24D5 stack[-3] // @24D5 stack[-1] // @24D9 stack[-2] // } 24D4 5B JUMPDEST 24D5 91 SWAP2 24D6 50 POP 24D7 60 PUSH1 0x00 24D9 90 SWAP1 24DA 50 POP // Stack delta = -1 // Outputs[2] // { // @24D5 stack[-3] = stack[-1] // @24D9 stack[-2] = 0x00 // } // Block continues label_24DB: // Incoming jump from 0x2456 // Incoming jump from 0x24DA // Incoming jump from 0x242D // Incoming jump from 0x24D3 // Inputs[5] // { // @24DC stack[-6] // @24DC stack[-1] // @24DE stack[-7] // @24DE stack[-2] // @24DF stack[-5] // } 24DB 5B JUMPDEST 24DC 94 SWAP5 24DD 50 POP 24DE 94 SWAP5 24DF 92 SWAP3 24E0 50 POP 24E1 50 POP 24E2 50 POP 24E3 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @24DC stack[-6] = stack[-1] // @24DE stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_24E4: // Incoming call from 0x2221, returns to 0x2222 // Inputs[1] { @24F0 stack[-1] } 24E4 5B JUMPDEST 24E5 60 PUSH1 0x00 24E7 80 DUP1 24E8 60 PUSH1 0x01 24EA 60 PUSH1 0x01 24EC 60 PUSH1 0xff 24EE 1B SHL 24EF 03 SUB 24F0 83 DUP4 24F1 16 AND 24F2 81 DUP2 24F3 61 PUSH2 0x2501 24F6 60 PUSH1 0xff 24F8 86 DUP7 24F9 90 SWAP1 24FA 1C SHR 24FB 60 PUSH1 0x1b 24FD 61 PUSH2 0x2eb6 2500 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @24E5 stack[0] = 0x00 // @24E7 stack[1] = 0x00 // @24F1 stack[2] = stack[-1] & (0x01 << 0xff) - 0x01 // @24F2 stack[3] = 0x00 // @24F3 stack[4] = 0x2501 // @24FA stack[5] = stack[-1] >> 0xff // @24FB stack[6] = 0x1b // } // Block ends with call to 0x2eb6, returns to 0x2501 label_2501: // Incoming return from call to 0x2EB6 at 0x2500 // Inputs[5] // { // @2502 stack[-2] // @2502 stack[-1] // @2507 stack[-8] // @2509 stack[-7] // @250A stack[-3] // } 2501 5B JUMPDEST 2502 90 SWAP1 2503 50 POP 2504 61 PUSH2 0x250f 2507 87 DUP8 2508 82 DUP3 2509 88 DUP9 250A 85 DUP6 250B 61 PUSH2 0x23f7 250E 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2502 stack[-2] = stack[-1] // @2504 stack[-1] = 0x250f // @2507 stack[0] = stack[-8] // @2508 stack[1] = stack[-1] // @2509 stack[2] = stack[-7] // @250A stack[3] = stack[-3] // } // Block ends with call to 0x23f7, returns to 0x250F label_250F: // Incoming return from call to 0x23F7 at 0x250E // Inputs[7] // { // @2510 stack[-1] // @2510 stack[-5] // @2512 stack[-6] // @2512 stack[-2] // @2516 stack[-9] // @2518 stack[-10] // @2519 stack[-8] // } 250F 5B JUMPDEST 2510 93 SWAP4 2511 50 POP 2512 93 SWAP4 2513 50 POP 2514 50 POP 2515 50 POP 2516 93 SWAP4 2517 50 POP 2518 93 SWAP4 2519 91 SWAP2 251A 50 POP 251B 50 POP 251C 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @2516 stack[-9] = stack[-1] // @2518 stack[-10] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_251D: // Incoming jump from 0x1AF8 // Incoming jump from 0x0F18 // Inputs[2] // { // @251E stack[-3] // @2520 storage[stack[-3]] // } 251D 5B JUMPDEST 251E 82 DUP3 251F 80 DUP1 2520 54 SLOAD 2521 61 PUSH2 0x2529 2524 90 SWAP1 2525 61 PUSH2 0x2f04 2528 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @251E stack[0] = stack[-3] // @2524 stack[1] = 0x2529 // @2524 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2f04, returns to 0x2529 label_2529: // Incoming return from call to 0x2F04 at 0x2528 // Inputs[5] // { // @252A stack[-1] // @252A stack[-2] // @2532 memory[0x00:0x20] // @253D stack[-4] // @253E stack[-3] // } 2529 5B JUMPDEST 252A 90 SWAP1 252B 60 PUSH1 0x00 252D 52 MSTORE 252E 60 PUSH1 0x20 2530 60 PUSH1 0x00 2532 20 SHA3 2533 90 SWAP1 2534 60 PUSH1 0x1f 2536 01 ADD 2537 60 PUSH1 0x20 2539 90 SWAP1 253A 04 DIV 253B 81 DUP2 253C 01 ADD 253D 92 SWAP3 253E 82 DUP3 253F 61 PUSH2 0x254b 2542 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @252D memory[0x00:0x20] = stack[-2] // @2533 stack[-2] = keccak256(memory[0x00:0x20]) // @253D stack[-1] = stack[-4] // @253D stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x254b, if stack[-3] label_2543: // Incoming jump from 0x2542, if not stack[-3] // Inputs[1] { @2545 stack[-5] } 2543 60 PUSH1 0x00 2545 85 DUP6 2546 55 SSTORE 2547 61 PUSH2 0x2591 254A 56 *JUMP // Stack delta = +0 // Outputs[1] { @2546 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2591 label_254B: // Incoming jump from 0x2542, if stack[-3] // Inputs[1] { @254C stack[-3] } 254B 5B JUMPDEST 254C 82 DUP3 254D 60 PUSH1 0x1f 254F 10 LT 2550 61 PUSH2 0x2564 2553 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2564, if 0x1f < stack[-3] label_2554: // Incoming jump from 0x2553, if not 0x1f < stack[-3] // Inputs[4] // { // @2554 stack[-1] // @2555 memory[stack[-1]:stack[-1] + 0x20] // @255A stack[-3] // @255E stack[-5] // } 2554 80 DUP1 2555 51 MLOAD 2556 60 PUSH1 0xff 2558 19 NOT 2559 16 AND 255A 83 DUP4 255B 80 DUP1 255C 01 ADD 255D 17 OR 255E 85 DUP6 255F 55 SSTORE 2560 61 PUSH2 0x2591 2563 56 *JUMP // Stack delta = +0 // Outputs[1] { @255F storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2591 label_2564: // Incoming jump from 0x2553, if 0x1f < stack[-3] // Inputs[2] // { // @2565 stack[-3] // @256B stack[-5] // } 2564 5B JUMPDEST 2565 82 DUP3 2566 80 DUP1 2567 01 ADD 2568 60 PUSH1 0x01 256A 01 ADD 256B 85 DUP6 256C 55 SSTORE 256D 82 DUP3 256E 15 ISZERO 256F 61 PUSH2 0x2591 2572 57 *JUMPI // Stack delta = +0 // Outputs[1] { @256C storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2591, if !stack[-3] label_2573: // Incoming jump from 0x2572, if not !stack[-3] // Inputs[2] // { // @2573 stack[-3] // @2573 stack[-1] // } 2573 91 SWAP2 2574 82 DUP3 2575 01 ADD 2576 5B JUMPDEST 2577 82 DUP3 2578 81 DUP2 2579 11 GT 257A 15 ISZERO 257B 61 PUSH2 0x2591 257E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2573 stack[-3] = stack[-1] // @2575 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2591, if !(stack[-1] + stack[-3] > stack[-1]) label_257F: // Incoming jump from 0x257E, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x257E, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @257F stack[-3] // @2580 memory[stack[-3]:stack[-3] + 0x20] // @2581 stack[-2] // @2583 stack[-1] // } 257F 82 DUP3 2580 51 MLOAD 2581 82 DUP3 2582 55 SSTORE 2583 91 SWAP2 2584 60 PUSH1 0x20 2586 01 ADD 2587 91 SWAP2 2588 90 SWAP1 2589 60 PUSH1 0x01 258B 01 ADD 258C 90 SWAP1 258D 61 PUSH2 0x2576 2590 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2582 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @2587 stack[-3] = 0x20 + stack[-3] // @258C stack[-2] = 0x01 + stack[-2] // @258C stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2576 label_2591: // Incoming jump from 0x2572, if !stack[-3] // Incoming jump from 0x254A // Incoming jump from 0x257E, if !(stack[-1] > stack[-3]) // Incoming jump from 0x2563 // Incoming jump from 0x257E, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @2596 stack[-4] // @2597 stack[-3] // } 2591 5B JUMPDEST 2592 50 POP 2593 61 PUSH2 0x259d 2596 92 SWAP3 2597 91 SWAP2 2598 50 POP 2599 61 PUSH2 0x25a1 259C 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2596 stack[-4] = 0x259d // @2597 stack[-3] = stack[-4] // } // Block ends with call to 0x25a1, returns to 0x259D label_259D: // Incoming jump from 0x25AA, if !(stack[-2] > stack[-1]) // Incoming jump from 0x25AA, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x25A1 at 0x259C // Inputs[2] // { // @259F stack[-3] // @259F stack[-2] // } 259D 5B JUMPDEST 259E 50 POP 259F 90 SWAP1 25A0 56 *JUMP // Stack delta = -2 // Outputs[1] { @259F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_25A1: // Incoming call from 0x259C, returns to 0x259D // Inputs[2] // { // @25A3 stack[-1] // @25A4 stack[-2] // } 25A1 5B JUMPDEST 25A2 5B JUMPDEST 25A3 80 DUP1 25A4 82 DUP3 25A5 11 GT 25A6 15 ISZERO 25A7 61 PUSH2 0x259d 25AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x259d, if !(stack[-2] > stack[-1]) label_25AB: // Incoming jump from 0x25AA, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x25AA, if not !(stack[-2] > stack[-1]) // Inputs[1] { @25AD stack[-1] } 25AB 60 PUSH1 0x00 25AD 81 DUP2 25AE 55 SSTORE 25AF 60 PUSH1 0x01 25B1 01 ADD 25B2 61 PUSH2 0x25a2 25B5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25AE storage[stack[-1]] = 0x00 // @25B1 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x25a2 label_25B6: // Incoming call from 0x2A17, returns to 0x2A18 // Incoming call from 0x272A, returns to 0x272B // Incoming call from 0x288D, returns to 0x288E // Incoming call from 0x2793, returns to 0x2794 // Incoming call from 0x28B7, returns to 0x28B8 // Incoming call from 0x282E, returns to 0x282F // Incoming call from 0x275B, returns to 0x275C // Incoming call from 0x2785, returns to 0x2786 // Incoming call from 0x283C, returns to 0x283D // Incoming call from 0x28E3, returns to 0x28E4 // Incoming call from 0x274D, returns to 0x274E // Inputs[2] // { // @25B7 stack[-1] // @25B8 msg.data[stack[-1]:stack[-1] + 0x20] // } 25B6 5B JUMPDEST 25B7 80 DUP1 25B8 35 CALLDATALOAD 25B9 60 PUSH1 0x01 25BB 60 PUSH1 0x01 25BD 60 PUSH1 0xa0 25BF 1B SHL 25C0 03 SUB 25C1 81 DUP2 25C2 16 AND 25C3 81 DUP2 25C4 14 EQ 25C5 61 PUSH2 0x25cd 25C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25B8 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x25cd, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_25C9: // Incoming jump from 0x25C8, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @25CC memory[0x00:0x00] } 25C9 60 PUSH1 0x00 25CB 80 DUP1 25CC FD *REVERT // Stack delta = +0 // Outputs[1] { @25CC revert(memory[0x00:0x00]); } // Block terminates label_25CD: // Incoming jump from 0x25C8, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x2698, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @25CE stack[-3] // @25CE stack[-1] // @25CF stack[-2] // } 25CD 5B JUMPDEST 25CE 91 SWAP2 25CF 90 SWAP1 25D0 50 POP 25D1 56 *JUMP // Stack delta = -2 // Outputs[1] { @25CE stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_25D2: // Incoming call from 0x292D, returns to 0x292E // Incoming call from 0x2971, returns to 0x2972 // Inputs[2] // { // @25D6 stack[-2] // @25D9 stack[-1] // } 25D2 5B JUMPDEST 25D3 60 PUSH1 0x00 25D5 80 DUP1 25D6 83 DUP4 25D7 60 PUSH1 0x1f 25D9 84 DUP5 25DA 01 ADD 25DB 12 SLT 25DC 61 PUSH2 0x25e4 25DF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25D3 stack[0] = 0x00 // @25D5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x25e4, if stack[-1] + 0x1f i< stack[-2] label_25E0: // Incoming jump from 0x25DF, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @25E3 memory[0x00:0x00] } 25E0 60 PUSH1 0x00 25E2 80 DUP1 25E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @25E3 revert(memory[0x00:0x00]); } // Block terminates label_25E4: // Incoming jump from 0x25DF, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @25E6 stack[-3] // @25E7 msg.data[stack[-3]:stack[-3] + 0x20] // } 25E4 5B JUMPDEST 25E5 50 POP 25E6 81 DUP2 25E7 35 CALLDATALOAD 25E8 60 PUSH1 0x01 25EA 60 PUSH1 0x01 25EC 60 PUSH1 0x40 25EE 1B SHL 25EF 03 SUB 25F0 81 DUP2 25F1 11 GT 25F2 15 ISZERO 25F3 61 PUSH2 0x25fb 25F6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @25E7 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x25fb, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_25F7: // Incoming jump from 0x25F6, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @25FA memory[0x00:0x00] } 25F7 60 PUSH1 0x00 25F9 80 DUP1 25FA FD *REVERT // Stack delta = +0 // Outputs[1] { @25FA revert(memory[0x00:0x00]); } // Block terminates label_25FB: // Incoming jump from 0x25F6, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[4] // { // @25FE stack[-3] // @2600 stack[-2] // @2602 stack[-4] // @2605 stack[-1] // } 25FB 5B JUMPDEST 25FC 60 PUSH1 0x20 25FE 83 DUP4 25FF 01 ADD 2600 91 SWAP2 2601 50 POP 2602 83 DUP4 2603 60 PUSH1 0x20 2605 82 DUP3 2606 60 PUSH1 0x05 2608 1B SHL 2609 85 DUP6 260A 01 ADD 260B 01 ADD 260C 11 GT 260D 15 ISZERO 260E 61 PUSH2 0x2235 2611 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2600 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x2235, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_2612: // Incoming jump from 0x2611, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @2615 memory[0x00:0x00] } 2612 60 PUSH1 0x00 2614 80 DUP1 2615 FD *REVERT // Stack delta = +0 // Outputs[1] { @2615 revert(memory[0x00:0x00]); } // Block terminates label_2616: // Incoming call from 0x27BB, returns to 0x27BC // Incoming call from 0x27DD, returns to 0x27DE // Incoming call from 0x2A4F, returns to 0x2A50 // Inputs[2] // { // @2619 stack[-2] // @261C stack[-1] // } 2616 5B JUMPDEST 2617 60 PUSH1 0x00 2619 82 DUP3 261A 60 PUSH1 0x1f 261C 83 DUP4 261D 01 ADD 261E 12 SLT 261F 61 PUSH2 0x2627 2622 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2617 stack[0] = 0x00 } // Block ends with conditional jump to 0x2627, if stack[-1] + 0x1f i< stack[-2] label_2623: // Incoming jump from 0x2622, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2626 memory[0x00:0x00] } 2623 60 PUSH1 0x00 2625 80 DUP1 2626 FD *REVERT // Stack delta = +0 // Outputs[1] { @2626 revert(memory[0x00:0x00]); } // Block terminates label_2627: // Incoming jump from 0x2622, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2628 stack[-2] // @2629 msg.data[stack[-2]:stack[-2] + 0x20] // } 2627 5B JUMPDEST 2628 81 DUP2 2629 35 CALLDATALOAD 262A 60 PUSH1 0x20 262C 61 PUSH2 0x2634 262F 82 DUP3 2630 61 PUSH2 0x2e93 2633 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2629 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @262A stack[1] = 0x20 // @262C stack[2] = 0x2634 // @262F stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2e93, returns to 0x2634 label_2634: // Incoming return from call to 0x2E93 at 0x2633 // Inputs[2] // { // @2637 memory[0x40:0x60] // @263B stack[-1] // } 2634 5B JUMPDEST 2635 60 PUSH1 0x40 2637 51 MLOAD 2638 61 PUSH2 0x2641 263B 82 DUP3 263C 82 DUP3 263D 61 PUSH2 0x2f39 2640 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2637 stack[0] = memory[0x40:0x60] // @2638 stack[1] = 0x2641 // @263B stack[2] = stack[-1] // @263C stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2f39, returns to 0x2641 label_2641: // Incoming return from call to 0x2F39 at 0x2640 // Inputs[6] // { // @2642 stack[-4] // @2643 stack[-1] // @2645 stack[-3] // @2648 stack[-2] // @264A stack[-6] // @2656 stack[-7] // } 2641 5B JUMPDEST 2642 83 DUP4 2643 81 DUP2 2644 52 MSTORE 2645 82 DUP3 2646 81 DUP2 2647 01 ADD 2648 91 SWAP2 2649 50 POP 264A 85 DUP6 264B 83 DUP4 264C 01 ADD 264D 60 PUSH1 0x05 264F 85 DUP6 2650 90 SWAP1 2651 1B SHL 2652 87 DUP8 2653 01 ADD 2654 84 DUP5 2655 01 ADD 2656 88 DUP9 2657 10 LT 2658 15 ISZERO 2659 61 PUSH2 0x2661 265C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2644 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @2648 stack[-2] = stack[-1] + stack[-3] // @264C stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x2661, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_265D: // Incoming jump from 0x265C, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[1] { @2660 memory[0x00:0x00] } 265D 60 PUSH1 0x00 265F 80 DUP1 2660 FD *REVERT // Stack delta = +0 // Outputs[1] { @2660 revert(memory[0x00:0x00]); } // Block terminates label_2661: // Incoming jump from 0x265C, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[1] { @2665 stack[-5] } 2661 5B JUMPDEST 2662 60 PUSH1 0x00 2664 5B JUMPDEST 2665 85 DUP6 2666 81 DUP2 2667 10 LT 2668 15 ISZERO 2669 61 PUSH2 0x2680 266C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2662 stack[0] = 0x00 } // Block ends with conditional jump to 0x2680, if !(0x00 < stack[-5]) label_266D: // Incoming jump from 0x266C, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x266C, if not !(0x00 < stack[-5]) // Inputs[5] // { // @266D stack[-2] // @266E msg.data[stack[-2]:stack[-2] + 0x20] // @266F stack[-4] // @2671 stack[-1] // @2672 stack[-5] // } 266D 81 DUP2 266E 35 CALLDATALOAD 266F 84 DUP5 2670 52 MSTORE 2671 92 SWAP3 2672 84 DUP5 2673 01 ADD 2674 92 SWAP3 2675 90 SWAP1 2676 84 DUP5 2677 01 ADD 2678 90 SWAP1 2679 60 PUSH1 0x01 267B 01 ADD 267C 61 PUSH2 0x2664 267F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2670 memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @2674 stack[-4] = stack[-5] + stack[-4] // @2678 stack[-2] = stack[-5] + stack[-2] // @267B stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2664 label_2680: // Incoming jump from 0x266C, if !(stack[-1] < stack[-6]) // Incoming jump from 0x266C, if !(0x00 < stack[-5]) // Inputs[4] // { // @2682 stack[-3] // @2682 stack[-2] // @2683 stack[-10] // @2684 stack[-9] // } 2680 5B JUMPDEST 2681 50 POP 2682 90 SWAP1 2683 97 SWAP8 2684 96 SWAP7 2685 50 POP 2686 50 POP 2687 50 POP 2688 50 POP 2689 50 POP 268A 50 POP 268B 50 POP 268C 56 *JUMP // Stack delta = -9 // Outputs[1] { @2683 stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_268D: // Incoming call from 0x289B, returns to 0x275C // Incoming call from 0x2A74, returns to 0x272B // Inputs[2] // { // @268E stack[-1] // @268F msg.data[stack[-1]:stack[-1] + 0x20] // } 268D 5B JUMPDEST 268E 80 DUP1 268F 35 CALLDATALOAD 2690 80 DUP1 2691 15 ISZERO 2692 15 ISZERO 2693 81 DUP2 2694 14 EQ 2695 61 PUSH2 0x25cd 2698 57 *JUMPI // Stack delta = +1 // Outputs[1] { @268F stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x25cd, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_2699: // Incoming jump from 0x2698, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @269C memory[0x00:0x00] } 2699 60 PUSH1 0x00 269B 80 DUP1 269C FD *REVERT // Stack delta = +0 // Outputs[1] { @269C revert(memory[0x00:0x00]); } // Block terminates label_269D: // Incoming call from 0x2800, returns to 0x2801 // Incoming call from 0x2B5D, returns to 0x2B5E // Incoming call from 0x2B9A, returns to 0x2B9B // Incoming call from 0x2871, returns to 0x2801 // Inputs[2] // { // @26A0 stack[-2] // @26A3 stack[-1] // } 269D 5B JUMPDEST 269E 60 PUSH1 0x00 26A0 82 DUP3 26A1 60 PUSH1 0x1f 26A3 83 DUP4 26A4 01 ADD 26A5 12 SLT 26A6 61 PUSH2 0x26ae 26A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @269E stack[0] = 0x00 } // Block ends with conditional jump to 0x26ae, if stack[-1] + 0x1f i< stack[-2] label_26AA: // Incoming jump from 0x26A9, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @26AD memory[0x00:0x00] } 26AA 60 PUSH1 0x00 26AC 80 DUP1 26AD FD *REVERT // Stack delta = +0 // Outputs[1] { @26AD revert(memory[0x00:0x00]); } // Block terminates label_26AE: // Incoming jump from 0x26A9, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @26AF stack[-2] // @26B0 msg.data[stack[-2]:stack[-2] + 0x20] // } 26AE 5B JUMPDEST 26AF 81 DUP2 26B0 35 CALLDATALOAD 26B1 60 PUSH1 0x01 26B3 60 PUSH1 0x01 26B5 60 PUSH1 0x40 26B7 1B SHL 26B8 03 SUB 26B9 81 DUP2 26BA 11 GT 26BB 15 ISZERO 26BC 61 PUSH2 0x26c7 26BF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26B0 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x26c7, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_26C0: // Incoming jump from 0x26BF, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) 26C0 61 PUSH2 0x26c7 26C3 61 PUSH2 0x2fc2 26C6 56 *JUMP // Stack delta = +1 // Outputs[1] { @26C0 stack[0] = 0x26c7 } // Block ends with unconditional jump to 0x2fc2 label_26C7: // Incoming jump from 0x26BF, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @26CA memory[0x40:0x60] // @26D0 stack[-1] // } 26C7 5B JUMPDEST 26C8 60 PUSH1 0x40 26CA 51 MLOAD 26CB 61 PUSH2 0x26de 26CE 60 PUSH1 0x1f 26D0 83 DUP4 26D1 01 ADD 26D2 60 PUSH1 0x1f 26D4 19 NOT 26D5 16 AND 26D6 60 PUSH1 0x20 26D8 01 ADD 26D9 82 DUP3 26DA 61 PUSH2 0x2f39 26DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26CA stack[0] = memory[0x40:0x60] // @26CB stack[1] = 0x26de // @26D8 stack[2] = 0x20 + (~0x1f & stack[-1] + 0x1f) // @26D9 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2f39, returns to 0x26DE label_26DE: // Incoming return from call to 0x2F39 at 0x26DD // Inputs[4] // { // @26DF stack[-2] // @26E0 stack[-1] // @26E2 stack[-5] // @26E6 stack[-4] // } 26DE 5B JUMPDEST 26DF 81 DUP2 26E0 81 DUP2 26E1 52 MSTORE 26E2 84 DUP5 26E3 60 PUSH1 0x20 26E5 83 DUP4 26E6 86 DUP7 26E7 01 ADD 26E8 01 ADD 26E9 11 GT 26EA 15 ISZERO 26EB 61 PUSH2 0x26f3 26EE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26E1 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x26f3, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_26EF: // Incoming jump from 0x26EE, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @26F2 memory[0x00:0x00] } 26EF 60 PUSH1 0x00 26F1 80 DUP1 26F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @26F2 revert(memory[0x00:0x00]); } // Block terminates label_26F3: // Incoming jump from 0x26EE, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[6] // { // @26F4 stack[-2] // @26F7 stack[-4] // @26FB stack[-1] // @26FD msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @270A stack[-6] // @270B stack[-5] // } 26F3 5B JUMPDEST 26F4 81 DUP2 26F5 60 PUSH1 0x20 26F7 85 DUP6 26F8 01 ADD 26F9 60 PUSH1 0x20 26FB 83 DUP4 26FC 01 ADD 26FD 37 CALLDATACOPY 26FE 60 PUSH1 0x00 2700 91 SWAP2 2701 81 DUP2 2702 01 ADD 2703 60 PUSH1 0x20 2705 01 ADD 2706 91 SWAP2 2707 90 SWAP1 2708 91 SWAP2 2709 52 MSTORE 270A 93 SWAP4 270B 92 SWAP3 270C 50 POP 270D 50 POP 270E 50 POP 270F 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @26FD memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @2709 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = 0x00 // @270A stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_2710: // Incoming call from 0x107C, returns to 0x107D // Incoming call from 0x0EA6, returns to 0x0EA7 // Incoming call from 0x0472, returns to 0x0473 // Incoming call from 0x0295, returns to 0x0296 // Incoming call from 0x0507, returns to 0x0508 // Inputs[2] // { // @2715 stack[-1] // @2716 stack[-2] // } 2710 5B JUMPDEST 2711 60 PUSH1 0x00 2713 60 PUSH1 0x20 2715 82 DUP3 2716 84 DUP5 2717 03 SUB 2718 12 SLT 2719 15 ISZERO 271A 61 PUSH2 0x2722 271D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2711 stack[0] = 0x00 } // Block ends with conditional jump to 0x2722, if !(stack[-2] - stack[-1] i< 0x20) label_271E: // Incoming jump from 0x271D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2721 memory[0x00:0x00] } 271E 60 PUSH1 0x00 2720 80 DUP1 2721 FD *REVERT // Stack delta = +0 // Outputs[1] { @2721 revert(memory[0x00:0x00]); } // Block terminates label_2722: // Incoming jump from 0x271D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2726 stack[-2] } 2722 5B JUMPDEST 2723 61 PUSH2 0x272b 2726 82 DUP3 2727 61 PUSH2 0x25b6 272A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2723 stack[0] = 0x272b // @2726 stack[1] = stack[-2] // } // Block ends with call to 0x25b6, returns to 0x272B label_272B: // Incoming return from call to 0x268D at 0x2A74 // Incoming return from call to 0x307D at 0x2B0C // Incoming return from call to 0x2BFE at 0x2D41 // Incoming return from call to 0x2BC3 at 0x2D00 // Incoming return from call to 0x25B6 at 0x272A // Inputs[3] // { // @272C stack[-5] // @272C stack[-1] // @272D stack[-4] // } 272B 5B JUMPDEST 272C 93 SWAP4 272D 92 SWAP3 272E 50 POP 272F 50 POP 2730 50 POP 2731 56 *JUMP // Stack delta = -4 // Outputs[1] { @272C stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2732: // Incoming call from 0x04B8, returns to 0x04B9 // Inputs[2] // { // @2738 stack[-1] // @2739 stack[-2] // } 2732 5B JUMPDEST 2733 60 PUSH1 0x00 2735 80 DUP1 2736 60 PUSH1 0x40 2738 83 DUP4 2739 85 DUP6 273A 03 SUB 273B 12 SLT 273C 15 ISZERO 273D 61 PUSH2 0x2745 2740 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2733 stack[0] = 0x00 // @2735 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2745, if !(stack[-2] - stack[-1] i< 0x40) label_2741: // Incoming jump from 0x2740, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2744 memory[0x00:0x00] } 2741 60 PUSH1 0x00 2743 80 DUP1 2744 FD *REVERT // Stack delta = +0 // Outputs[1] { @2744 revert(memory[0x00:0x00]); } // Block terminates label_2745: // Incoming jump from 0x2740, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2749 stack[-3] } 2745 5B JUMPDEST 2746 61 PUSH2 0x274e 2749 83 DUP4 274A 61 PUSH2 0x25b6 274D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2746 stack[0] = 0x274e // @2749 stack[1] = stack[-3] // } // Block ends with call to 0x25b6, returns to 0x274E label_274E: // Incoming return from call to 0x25B6 at 0x274D // Inputs[3] // { // @274F stack[-3] // @274F stack[-1] // @2756 stack[-4] // } 274E 5B JUMPDEST 274F 91 SWAP2 2750 50 POP 2751 61 PUSH2 0x275c 2754 60 PUSH1 0x20 2756 84 DUP5 2757 01 ADD 2758 61 PUSH2 0x25b6 275B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @274F stack[-3] = stack[-1] // @2751 stack[-1] = 0x275c // @2757 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x25b6, returns to 0x275C label_275C: // Incoming return from call to 0x268D at 0x289B // Incoming return from call to 0x25B6 at 0x275B // Inputs[6] // { // @275D stack[-1] // @275D stack[-2] // @275F stack[-5] // @2761 stack[-6] // @2761 stack[-3] // @2762 stack[-4] // } 275C 5B JUMPDEST 275D 90 SWAP1 275E 50 POP 275F 92 SWAP3 2760 50 POP 2761 92 SWAP3 2762 90 SWAP1 2763 50 POP 2764 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @275F stack[-5] = stack[-1] // @2761 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2765: // Incoming jump from 0x02FF // Inputs[2] // { // @2770 stack[-1] // @2771 stack[-2] // } 2765 5B JUMPDEST 2766 60 PUSH1 0x00 2768 80 DUP1 2769 60 PUSH1 0x00 276B 80 DUP1 276C 60 PUSH1 0x00 276E 60 PUSH1 0xa0 2770 86 DUP7 2771 88 DUP9 2772 03 SUB 2773 12 SLT 2774 15 ISZERO 2775 61 PUSH2 0x277d 2778 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2766 stack[0] = 0x00 // @2768 stack[1] = 0x00 // @2769 stack[2] = 0x00 // @276B stack[3] = 0x00 // @276C stack[4] = 0x00 // } // Block ends with conditional jump to 0x277d, if !(stack[-2] - stack[-1] i< 0xa0) label_2779: // Incoming jump from 0x2778, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @277C memory[0x00:0x00] } 2779 60 PUSH1 0x00 277B 80 DUP1 277C FD *REVERT // Stack delta = +0 // Outputs[1] { @277C revert(memory[0x00:0x00]); } // Block terminates label_277D: // Incoming jump from 0x2778, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2781 stack[-6] } 277D 5B JUMPDEST 277E 61 PUSH2 0x2786 2781 86 DUP7 2782 61 PUSH2 0x25b6 2785 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @277E stack[0] = 0x2786 // @2781 stack[1] = stack[-6] // } // Block ends with call to 0x25b6, returns to 0x2786 label_2786: // Incoming return from call to 0x25B6 at 0x2785 // Inputs[3] // { // @2787 stack[-6] // @2787 stack[-1] // @278E stack[-7] // } 2786 5B JUMPDEST 2787 94 SWAP5 2788 50 POP 2789 61 PUSH2 0x2794 278C 60 PUSH1 0x20 278E 87 DUP8 278F 01 ADD 2790 61 PUSH2 0x25b6 2793 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2787 stack[-6] = stack[-1] // @2789 stack[-1] = 0x2794 // @278F stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x25b6, returns to 0x2794 label_2794: // Incoming return from call to 0x25B6 at 0x2793 // Inputs[4] // { // @2795 stack[-1] // @2795 stack[-5] // @2799 stack[-7] // @279B msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 2794 5B JUMPDEST 2795 93 SWAP4 2796 50 POP 2797 60 PUSH1 0x40 2799 86 DUP7 279A 01 ADD 279B 35 CALLDATALOAD 279C 60 PUSH1 0x01 279E 60 PUSH1 0x01 27A0 60 PUSH1 0x40 27A2 1B SHL 27A3 03 SUB 27A4 80 DUP1 27A5 82 DUP3 27A6 11 GT 27A7 15 ISZERO 27A8 61 PUSH2 0x27b0 27AB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2795 stack[-5] = stack[-1] // @279B stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @27A3 stack[0] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x27b0, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) label_27AC: // Incoming jump from 0x27AB, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @27AF memory[0x00:0x00] } 27AC 60 PUSH1 0x00 27AE 80 DUP1 27AF FD *REVERT // Stack delta = +0 // Outputs[1] { @27AF revert(memory[0x00:0x00]); } // Block terminates label_27B0: // Incoming jump from 0x27AB, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @27B4 stack[-9] // @27B5 stack[-2] // @27B6 stack[-8] // } 27B0 5B JUMPDEST 27B1 61 PUSH2 0x27bc 27B4 89 DUP10 27B5 83 DUP4 27B6 8A DUP11 27B7 01 ADD 27B8 61 PUSH2 0x2616 27BB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27B1 stack[0] = 0x27bc // @27B4 stack[1] = stack[-9] // @27B7 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x2616, returns to 0x27BC label_27BC: // Incoming return from call to 0x2616 at 0x27BB // Inputs[6] // { // @27BD stack[-1] // @27BD stack[-6] // @27C1 stack[-9] // @27C3 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @27C4 stack[-3] // @27C6 stack[-2] // } 27BC 5B JUMPDEST 27BD 94 SWAP5 27BE 50 POP 27BF 60 PUSH1 0x60 27C1 88 DUP9 27C2 01 ADD 27C3 35 CALLDATALOAD 27C4 91 SWAP2 27C5 50 POP 27C6 80 DUP1 27C7 82 DUP3 27C8 11 GT 27C9 15 ISZERO 27CA 61 PUSH2 0x27d2 27CD 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @27BD stack[-6] = stack[-1] // @27C4 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x27d2, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_27CE: // Incoming jump from 0x27CD, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[1] { @27D1 memory[0x00:0x00] } 27CE 60 PUSH1 0x00 27D0 80 DUP1 27D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @27D1 revert(memory[0x00:0x00]); } // Block terminates label_27D2: // Incoming jump from 0x27CD, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @27D6 stack[-9] // @27D7 stack[-2] // @27D8 stack[-8] // } 27D2 5B JUMPDEST 27D3 61 PUSH2 0x27de 27D6 89 DUP10 27D7 83 DUP4 27D8 8A DUP11 27D9 01 ADD 27DA 61 PUSH2 0x2616 27DD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27D3 stack[0] = 0x27de // @27D6 stack[1] = stack[-9] // @27D9 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x2616, returns to 0x27DE label_27DE: // Incoming return from call to 0x2616 at 0x27DD // Inputs[6] // { // @27DF stack[-5] // @27DF stack[-1] // @27E3 stack[-9] // @27E5 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @27E6 stack[-3] // @27E8 stack[-2] // } 27DE 5B JUMPDEST 27DF 93 SWAP4 27E0 50 POP 27E1 60 PUSH1 0x80 27E3 88 DUP9 27E4 01 ADD 27E5 35 CALLDATALOAD 27E6 91 SWAP2 27E7 50 POP 27E8 80 DUP1 27E9 82 DUP3 27EA 11 GT 27EB 15 ISZERO 27EC 61 PUSH2 0x27f4 27EF 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @27DF stack[-5] = stack[-1] // @27E6 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x27f4, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_27F0: // Incoming jump from 0x27EF, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[1] { @27F3 memory[0x00:0x00] } 27F0 60 PUSH1 0x00 27F2 80 DUP1 27F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @27F3 revert(memory[0x00:0x00]); } // Block terminates label_27F4: // Incoming jump from 0x27EF, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @27F9 stack[-9] // @27FA stack[-2] // @27FB stack[-8] // } 27F4 5B JUMPDEST 27F5 50 POP 27F6 61 PUSH2 0x2801 27F9 88 DUP9 27FA 82 DUP3 27FB 89 DUP10 27FC 01 ADD 27FD 61 PUSH2 0x269d 2800 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @27F6 stack[-1] = 0x2801 // @27F9 stack[0] = stack[-9] // @27FC stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x269d, returns to 0x2801 label_2801: // Incoming return from call to 0x269D at 0x2800 // Incoming return from call to 0x269D at 0x2871 // Inputs[9] // { // @2802 stack[-1] // @2802 stack[-3] // @2805 stack[-6] // @2806 stack[-9] // @2808 stack[-4] // @2808 stack[-7] // @2809 stack[-10] // @280A stack[-5] // @280B stack[-8] // } 2801 5B JUMPDEST 2802 91 SWAP2 2803 50 POP 2804 50 POP 2805 92 SWAP3 2806 95 SWAP6 2807 50 POP 2808 92 SWAP3 2809 95 SWAP6 280A 90 SWAP1 280B 93 SWAP4 280C 50 POP 280D 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @2805 stack[-6] = stack[-1] // @2806 stack[-9] = stack[-6] // @2808 stack[-7] = stack[-4] // @2809 stack[-10] = stack[-7] // @280B stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_280E: // Incoming call from 0x04F4, returns to 0x04F5 // Inputs[2] // { // @2819 stack[-1] // @281A stack[-2] // } 280E 5B JUMPDEST 280F 60 PUSH1 0x00 2811 80 DUP1 2812 60 PUSH1 0x00 2814 80 DUP1 2815 60 PUSH1 0x00 2817 60 PUSH1 0xa0 2819 86 DUP7 281A 88 DUP9 281B 03 SUB 281C 12 SLT 281D 15 ISZERO 281E 61 PUSH2 0x2826 2821 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @280F stack[0] = 0x00 // @2811 stack[1] = 0x00 // @2812 stack[2] = 0x00 // @2814 stack[3] = 0x00 // @2815 stack[4] = 0x00 // } // Block ends with conditional jump to 0x2826, if !(stack[-2] - stack[-1] i< 0xa0) label_2822: // Incoming jump from 0x2821, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @2825 memory[0x00:0x00] } 2822 60 PUSH1 0x00 2824 80 DUP1 2825 FD *REVERT // Stack delta = +0 // Outputs[1] { @2825 revert(memory[0x00:0x00]); } // Block terminates label_2826: // Incoming jump from 0x2821, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @282A stack[-6] } 2826 5B JUMPDEST 2827 61 PUSH2 0x282f 282A 86 DUP7 282B 61 PUSH2 0x25b6 282E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2827 stack[0] = 0x282f // @282A stack[1] = stack[-6] // } // Block ends with call to 0x25b6, returns to 0x282F label_282F: // Incoming return from call to 0x25B6 at 0x282E // Inputs[3] // { // @2830 stack[-6] // @2830 stack[-1] // @2837 stack[-7] // } 282F 5B JUMPDEST 2830 94 SWAP5 2831 50 POP 2832 61 PUSH2 0x283d 2835 60 PUSH1 0x20 2837 87 DUP8 2838 01 ADD 2839 61 PUSH2 0x25b6 283C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2830 stack[-6] = stack[-1] // @2832 stack[-1] = 0x283d // @2838 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x25b6, returns to 0x283D label_283D: // Incoming return from call to 0x25B6 at 0x283C // Inputs[8] // { // @283E stack[-1] // @283E stack[-5] // @2842 stack[-7] // @2844 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2845 stack[-4] // @284B msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @284C stack[-3] // @2852 msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 283D 5B JUMPDEST 283E 93 SWAP4 283F 50 POP 2840 60 PUSH1 0x40 2842 86 DUP7 2843 01 ADD 2844 35 CALLDATALOAD 2845 92 SWAP3 2846 50 POP 2847 60 PUSH1 0x60 2849 86 DUP7 284A 01 ADD 284B 35 CALLDATALOAD 284C 91 SWAP2 284D 50 POP 284E 60 PUSH1 0x80 2850 86 DUP7 2851 01 ADD 2852 35 CALLDATALOAD 2853 60 PUSH1 0x01 2855 60 PUSH1 0x01 2857 60 PUSH1 0x40 2859 1B SHL 285A 03 SUB 285B 81 DUP2 285C 11 GT 285D 15 ISZERO 285E 61 PUSH2 0x2866 2861 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @283E stack[-5] = stack[-1] // @2845 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @284C stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @2852 stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x2866, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) label_2862: // Incoming jump from 0x2861, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2865 memory[0x00:0x00] } 2862 60 PUSH1 0x00 2864 80 DUP1 2865 FD *REVERT // Stack delta = +0 // Outputs[1] { @2865 revert(memory[0x00:0x00]); } // Block terminates label_2866: // Incoming jump from 0x2861, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @286A stack[-8] // @286B stack[-1] // @286C stack[-7] // } 2866 5B JUMPDEST 2867 61 PUSH2 0x2801 286A 88 DUP9 286B 82 DUP3 286C 89 DUP10 286D 01 ADD 286E 61 PUSH2 0x269d 2871 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2867 stack[0] = 0x2801 // @286A stack[1] = stack[-8] // @286D stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x269d, returns to 0x2801 label_2872: // Incoming call from 0x0419, returns to 0x041A // Inputs[2] // { // @2878 stack[-1] // @2879 stack[-2] // } 2872 5B JUMPDEST 2873 60 PUSH1 0x00 2875 80 DUP1 2876 60 PUSH1 0x40 2878 83 DUP4 2879 85 DUP6 287A 03 SUB 287B 12 SLT 287C 15 ISZERO 287D 61 PUSH2 0x2885 2880 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2873 stack[0] = 0x00 // @2875 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2885, if !(stack[-2] - stack[-1] i< 0x40) label_2881: // Incoming jump from 0x2880, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2884 memory[0x00:0x00] } 2881 60 PUSH1 0x00 2883 80 DUP1 2884 FD *REVERT // Stack delta = +0 // Outputs[1] { @2884 revert(memory[0x00:0x00]); } // Block terminates label_2885: // Incoming jump from 0x2880, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2889 stack[-3] } 2885 5B JUMPDEST 2886 61 PUSH2 0x288e 2889 83 DUP4 288A 61 PUSH2 0x25b6 288D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2886 stack[0] = 0x288e // @2889 stack[1] = stack[-3] // } // Block ends with call to 0x25b6, returns to 0x288E label_288E: // Incoming return from call to 0x25B6 at 0x288D // Inputs[3] // { // @288F stack[-3] // @288F stack[-1] // @2896 stack[-4] // } 288E 5B JUMPDEST 288F 91 SWAP2 2890 50 POP 2891 61 PUSH2 0x275c 2894 60 PUSH1 0x20 2896 84 DUP5 2897 01 ADD 2898 61 PUSH2 0x268d 289B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @288F stack[-3] = stack[-1] // @2891 stack[-1] = 0x275c // @2897 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x268d, returns to 0x275C label_289C: // Incoming call from 0x024C, returns to 0x024D // Inputs[2] // { // @28A2 stack[-1] // @28A3 stack[-2] // } 289C 5B JUMPDEST 289D 60 PUSH1 0x00 289F 80 DUP1 28A0 60 PUSH1 0x40 28A2 83 DUP4 28A3 85 DUP6 28A4 03 SUB 28A5 12 SLT 28A6 15 ISZERO 28A7 61 PUSH2 0x28af 28AA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @289D stack[0] = 0x00 // @289F stack[1] = 0x00 // } // Block ends with conditional jump to 0x28af, if !(stack[-2] - stack[-1] i< 0x40) label_28AB: // Incoming jump from 0x28AA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28AE memory[0x00:0x00] } 28AB 60 PUSH1 0x00 28AD 80 DUP1 28AE FD *REVERT // Stack delta = +0 // Outputs[1] { @28AE revert(memory[0x00:0x00]); } // Block terminates label_28AF: // Incoming jump from 0x28AA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28B3 stack[-3] } 28AF 5B JUMPDEST 28B0 61 PUSH2 0x28b8 28B3 83 DUP4 28B4 61 PUSH2 0x25b6 28B7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28B0 stack[0] = 0x28b8 // @28B3 stack[1] = stack[-3] // } // Block ends with call to 0x25b6, returns to 0x28B8 label_28B8: // Incoming return from call to 0x25B6 at 0x28B7 // Inputs[5] // { // @28B9 stack[-1] // @28B9 stack[-6] // @28BC stack[-4] // @28C0 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @28C1 stack[-5] // } 28B8 5B JUMPDEST 28B9 94 SWAP5 28BA 60 PUSH1 0x20 28BC 93 SWAP4 28BD 90 SWAP1 28BE 93 SWAP4 28BF 01 ADD 28C0 35 CALLDATALOAD 28C1 93 SWAP4 28C2 50 POP 28C3 50 POP 28C4 50 POP 28C5 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @28B9 stack[-6] = stack[-1] // @28C1 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_28C6: // Incoming call from 0x0237, returns to 0x0238 // Inputs[2] // { // @28CE stack[-1] // @28CF stack[-2] // } 28C6 5B JUMPDEST 28C7 60 PUSH1 0x00 28C9 80 DUP1 28CA 60 PUSH1 0x00 28CC 60 PUSH1 0x60 28CE 84 DUP5 28CF 86 DUP7 28D0 03 SUB 28D1 12 SLT 28D2 15 ISZERO 28D3 61 PUSH2 0x28db 28D6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @28C7 stack[0] = 0x00 // @28C9 stack[1] = 0x00 // @28CA stack[2] = 0x00 // } // Block ends with conditional jump to 0x28db, if !(stack[-2] - stack[-1] i< 0x60) label_28D7: // Incoming jump from 0x28D6, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @28DA memory[0x00:0x00] } 28D7 60 PUSH1 0x00 28D9 80 DUP1 28DA FD *REVERT // Stack delta = +0 // Outputs[1] { @28DA revert(memory[0x00:0x00]); } // Block terminates label_28DB: // Incoming jump from 0x28D6, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @28DF stack[-4] } 28DB 5B JUMPDEST 28DC 61 PUSH2 0x28e4 28DF 84 DUP5 28E0 61 PUSH2 0x25b6 28E3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28DC stack[0] = 0x28e4 // @28DF stack[1] = stack[-4] // } // Block ends with call to 0x25b6, returns to 0x28E4 label_28E4: // Incoming return from call to 0x25B6 at 0x28E3 // Inputs[7] // { // @28E5 stack[-7] // @28E5 stack[-1] // @28E8 stack[-5] // @28EA msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @28EB stack[-6] // @28F2 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @28F4 stack[-4] // } 28E4 5B JUMPDEST 28E5 95 SWAP6 28E6 60 PUSH1 0x20 28E8 85 DUP6 28E9 01 ADD 28EA 35 CALLDATALOAD 28EB 95 SWAP6 28EC 50 POP 28ED 60 PUSH1 0x40 28EF 90 SWAP1 28F0 94 SWAP5 28F1 01 ADD 28F2 35 CALLDATALOAD 28F3 93 SWAP4 28F4 92 SWAP3 28F5 50 POP 28F6 50 POP 28F7 50 POP 28F8 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @28E5 stack[-7] = stack[-1] // @28EB stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @28F3 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_28F9: // Incoming call from 0x03D0, returns to 0x03D1 // Inputs[2] // { // @28FF stack[-1] // @2900 stack[-2] // } 28F9 5B JUMPDEST 28FA 60 PUSH1 0x00 28FC 80 DUP1 28FD 60 PUSH1 0x20 28FF 83 DUP4 2900 85 DUP6 2901 03 SUB 2902 12 SLT 2903 15 ISZERO 2904 61 PUSH2 0x290c 2907 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28FA stack[0] = 0x00 // @28FC stack[1] = 0x00 // } // Block ends with conditional jump to 0x290c, if !(stack[-2] - stack[-1] i< 0x20) label_2908: // Incoming jump from 0x2907, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @290B memory[0x00:0x00] } 2908 60 PUSH1 0x00 290A 80 DUP1 290B FD *REVERT // Stack delta = +0 // Outputs[1] { @290B revert(memory[0x00:0x00]); } // Block terminates label_290C: // Incoming jump from 0x2907, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @290D stack[-3] // @290E msg.data[stack[-3]:stack[-3] + 0x20] // } 290C 5B JUMPDEST 290D 82 DUP3 290E 35 CALLDATALOAD 290F 60 PUSH1 0x01 2911 60 PUSH1 0x01 2913 60 PUSH1 0x40 2915 1B SHL 2916 03 SUB 2917 81 DUP2 2918 11 GT 2919 15 ISZERO 291A 61 PUSH2 0x2922 291D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @290E stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2922, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_291E: // Incoming jump from 0x291D, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2921 memory[0x00:0x00] } 291E 60 PUSH1 0x00 2920 80 DUP1 2921 FD *REVERT // Stack delta = +0 // Outputs[1] { @2921 revert(memory[0x00:0x00]); } // Block terminates label_2922: // Incoming jump from 0x291D, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2926 stack[-5] // @2927 stack[-1] // @2928 stack[-4] // } 2922 5B JUMPDEST 2923 61 PUSH2 0x292e 2926 85 DUP6 2927 82 DUP3 2928 86 DUP7 2929 01 ADD 292A 61 PUSH2 0x25d2 292D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2923 stack[0] = 0x292e // @2926 stack[1] = stack[-5] // @2929 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x25d2, returns to 0x292E label_292E: // Incoming return from call to 0x25D2 at 0x292D // Inputs[5] // { // @292F stack[-2] // @292F stack[-1] // @2930 stack[-8] // @2932 stack[-7] // @2934 stack[-6] // } 292E 5B JUMPDEST 292F 90 SWAP1 2930 96 SWAP7 2931 90 SWAP1 2932 95 SWAP6 2933 50 POP 2934 93 SWAP4 2935 50 POP 2936 50 POP 2937 50 POP 2938 50 POP 2939 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2930 stack[-8] = stack[-2] // @2932 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_293A: // Incoming call from 0x0378, returns to 0x0379 // Inputs[2] // { // @2943 stack[-1] // @2944 stack[-2] // } 293A 5B JUMPDEST 293B 60 PUSH1 0x00 293D 80 DUP1 293E 60 PUSH1 0x00 2940 80 DUP1 2941 60 PUSH1 0x60 2943 85 DUP6 2944 87 DUP8 2945 03 SUB 2946 12 SLT 2947 15 ISZERO 2948 61 PUSH2 0x2950 294B 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @293B stack[0] = 0x00 // @293D stack[1] = 0x00 // @293E stack[2] = 0x00 // @2940 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2950, if !(stack[-2] - stack[-1] i< 0x60) label_294C: // Incoming jump from 0x294B, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @294F memory[0x00:0x00] } 294C 60 PUSH1 0x00 294E 80 DUP1 294F FD *REVERT // Stack delta = +0 // Outputs[1] { @294F revert(memory[0x00:0x00]); } // Block terminates label_2950: // Incoming jump from 0x294B, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2951 stack[-5] // @2952 msg.data[stack[-5]:stack[-5] + 0x20] // } 2950 5B JUMPDEST 2951 84 DUP5 2952 35 CALLDATALOAD 2953 60 PUSH1 0x01 2955 60 PUSH1 0x01 2957 60 PUSH1 0x40 2959 1B SHL 295A 03 SUB 295B 81 DUP2 295C 11 GT 295D 15 ISZERO 295E 61 PUSH2 0x2966 2961 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2952 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] } // Block ends with conditional jump to 0x2966, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) label_2962: // Incoming jump from 0x2961, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2965 memory[0x00:0x00] } 2962 60 PUSH1 0x00 2964 80 DUP1 2965 FD *REVERT // Stack delta = +0 // Outputs[1] { @2965 revert(memory[0x00:0x00]); } // Block terminates label_2966: // Incoming jump from 0x2961, if !(msg.data[stack[-5]:stack[-5] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @296A stack[-7] // @296B stack[-1] // @296C stack[-6] // } 2966 5B JUMPDEST 2967 61 PUSH2 0x2972 296A 87 DUP8 296B 82 DUP3 296C 88 DUP9 296D 01 ADD 296E 61 PUSH2 0x25d2 2971 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2967 stack[0] = 0x2972 // @296A stack[1] = stack[-7] // @296D stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x25d2, returns to 0x2972 label_2972: // Incoming return from call to 0x25D2 at 0x2971 // Inputs[9] // { // @2973 stack[-1] // @2973 stack[-2] // @2974 stack[-10] // @2976 stack[-9] // @297A stack[-8] // @297C msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @2981 msg.data[0x40 + stack[-8]:0x40 + stack[-8] + 0x20] // @2982 stack[-7] // @2984 stack[-6] // } 2972 5B JUMPDEST 2973 90 SWAP1 2974 98 SWAP9 2975 90 SWAP1 2976 97 SWAP8 2977 50 POP 2978 60 PUSH1 0x20 297A 87 DUP8 297B 01 ADD 297C 35 CALLDATALOAD 297D 96 SWAP7 297E 60 PUSH1 0x40 2980 01 ADD 2981 35 CALLDATALOAD 2982 95 SWAP6 2983 50 POP 2984 93 SWAP4 2985 50 POP 2986 50 POP 2987 50 POP 2988 50 POP 2989 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2974 stack[-10] = stack[-2] // @2976 stack[-9] = stack[-1] // @297D stack[-8] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @2982 stack[-7] = msg.data[0x40 + stack[-8]:0x40 + stack[-8] + 0x20] // } // Block ends with unconditional jump to stack[-10] label_298A: // Incoming call from 0x0336, returns to 0x0337 // Inputs[2] // { // @2990 stack[-1] // @2991 stack[-2] // } 298A 5B JUMPDEST 298B 60 PUSH1 0x00 298D 80 DUP1 298E 60 PUSH1 0x40 2990 83 DUP4 2991 85 DUP6 2992 03 SUB 2993 12 SLT 2994 15 ISZERO 2995 61 PUSH2 0x299d 2998 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @298B stack[0] = 0x00 // @298D stack[1] = 0x00 // } // Block ends with conditional jump to 0x299d, if !(stack[-2] - stack[-1] i< 0x40) label_2999: // Incoming jump from 0x2998, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @299C memory[0x00:0x00] } 2999 60 PUSH1 0x00 299B 80 DUP1 299C FD *REVERT // Stack delta = +0 // Outputs[1] { @299C revert(memory[0x00:0x00]); } // Block terminates label_299D: // Incoming jump from 0x2998, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @299E stack[-3] // @299F msg.data[stack[-3]:stack[-3] + 0x20] // } 299D 5B JUMPDEST 299E 82 DUP3 299F 35 CALLDATALOAD 29A0 60 PUSH1 0x01 29A2 60 PUSH1 0x01 29A4 60 PUSH1 0x40 29A6 1B SHL 29A7 03 SUB 29A8 80 DUP1 29A9 82 DUP3 29AA 11 GT 29AB 15 ISZERO 29AC 61 PUSH2 0x29b4 29AF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @299F stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @29A7 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x29b4, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_29B0: // Incoming jump from 0x29AF, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @29B3 memory[0x00:0x00] } 29B0 60 PUSH1 0x00 29B2 80 DUP1 29B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @29B3 revert(memory[0x00:0x00]); } // Block terminates label_29B4: // Incoming jump from 0x29AF, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @29B5 stack[-2] // @29B6 stack[-5] // @29BA stack[-6] // } 29B4 5B JUMPDEST 29B5 81 DUP2 29B6 85 DUP6 29B7 01 ADD 29B8 91 SWAP2 29B9 50 POP 29BA 85 DUP6 29BB 60 PUSH1 0x1f 29BD 83 DUP4 29BE 01 ADD 29BF 12 SLT 29C0 61 PUSH2 0x29c8 29C3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @29B8 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x29c8, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_29C4: // Incoming jump from 0x29C3, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @29C7 memory[0x00:0x00] } 29C4 60 PUSH1 0x00 29C6 80 DUP1 29C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @29C7 revert(memory[0x00:0x00]); } // Block terminates label_29C8: // Incoming jump from 0x29C3, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @29C9 stack[-2] // @29CA msg.data[stack[-2]:stack[-2] + 0x20] // } 29C8 5B JUMPDEST 29C9 81 DUP2 29CA 35 CALLDATALOAD 29CB 60 PUSH1 0x20 29CD 61 PUSH2 0x29d5 29D0 82 DUP3 29D1 61 PUSH2 0x2e93 29D4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @29CA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @29CB stack[1] = 0x20 // @29CD stack[2] = 0x29d5 // @29D0 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2e93, returns to 0x29D5 label_29D5: // Incoming return from call to 0x2E93 at 0x29D4 // Inputs[2] // { // @29D8 memory[0x40:0x60] // @29DC stack[-1] // } 29D5 5B JUMPDEST 29D6 60 PUSH1 0x40 29D8 51 MLOAD 29D9 61 PUSH2 0x29e2 29DC 82 DUP3 29DD 82 DUP3 29DE 61 PUSH2 0x2f39 29E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @29D8 stack[0] = memory[0x40:0x60] // @29D9 stack[1] = 0x29e2 // @29DC stack[2] = stack[-1] // @29DD stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2f39, returns to 0x29E2 label_29E2: // Incoming return from call to 0x2F39 at 0x29E1 // Inputs[6] // { // @29E3 stack[-4] // @29E4 stack[-1] // @29E6 stack[-3] // @29E9 stack[-2] // @29EB stack[-6] // @29F7 stack[-10] // } 29E2 5B JUMPDEST 29E3 83 DUP4 29E4 81 DUP2 29E5 52 MSTORE 29E6 82 DUP3 29E7 81 DUP2 29E8 01 ADD 29E9 91 SWAP2 29EA 50 POP 29EB 85 DUP6 29EC 83 DUP4 29ED 01 ADD 29EE 60 PUSH1 0x05 29F0 85 DUP6 29F1 90 SWAP1 29F2 1B SHL 29F3 87 DUP8 29F4 01 ADD 29F5 84 DUP5 29F6 01 ADD 29F7 8B DUP12 29F8 10 LT 29F9 15 ISZERO 29FA 61 PUSH2 0x2a02 29FD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @29E5 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @29E9 stack[-2] = stack[-1] + stack[-3] // @29ED stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x2a02, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_29FE: // Incoming jump from 0x29FD, if not !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[1] { @2A01 memory[0x00:0x00] } 29FE 60 PUSH1 0x00 2A00 80 DUP1 2A01 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A01 revert(memory[0x00:0x00]); } // Block terminates label_2A02: // Incoming jump from 0x29FD, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @2A05 stack[-7] // @2A08 stack[-5] // } 2A02 5B JUMPDEST 2A03 60 PUSH1 0x00 2A05 96 SWAP7 2A06 50 POP 2A07 5B JUMPDEST 2A08 84 DUP5 2A09 87 DUP8 2A0A 10 LT 2A0B 15 ISZERO 2A0C 61 PUSH2 0x2a2c 2A0F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2A05 stack[-7] = 0x00 } // Block ends with conditional jump to 0x2a2c, if !(0x00 < stack[-5]) label_2A10: // Incoming jump from 0x2A0F, if not !(stack[-7] < stack[-5]) // Incoming jump from 0x2A0F, if not !(0x00 < stack[-5]) // Inputs[1] { @2A13 stack[-1] } 2A10 61 PUSH2 0x2a18 2A13 81 DUP2 2A14 61 PUSH2 0x25b6 2A17 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2A10 stack[0] = 0x2a18 // @2A13 stack[1] = stack[-1] // } // Block ends with call to 0x25b6, returns to 0x2A18 label_2A18: // Incoming return from call to 0x25B6 at 0x2A17 // Inputs[5] // { // @2A19 stack[-4] // @2A1A stack[-1] // @2A1D stack[-8] // @2A1E stack[-2] // @2A23 stack[-5] // } 2A18 5B JUMPDEST 2A19 83 DUP4 2A1A 52 MSTORE 2A1B 60 PUSH1 0x01 2A1D 96 SWAP7 2A1E 90 SWAP1 2A1F 96 SWAP7 2A20 01 ADD 2A21 95 SWAP6 2A22 91 SWAP2 2A23 83 DUP4 2A24 01 ADD 2A25 91 SWAP2 2A26 83 DUP4 2A27 01 ADD 2A28 61 PUSH2 0x2a07 2A2B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2A1A memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @2A21 stack[-8] = 0x01 + stack[-8] // @2A25 stack[-4] = stack[-5] + stack[-4] // @2A27 stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x2a07 label_2A2C: // Incoming jump from 0x2A0F, if !(stack[-7] < stack[-5]) // Incoming jump from 0x2A0F, if !(0x00 < stack[-5]) // Inputs[7] // { // @2A2E stack[-9] // @2A2E stack[-2] // @2A31 stack[-10] // @2A32 stack[-4] // @2A33 msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // @2A34 stack[-7] // @2A37 stack[-6] // } 2A2C 5B JUMPDEST 2A2D 50 POP 2A2E 96 SWAP7 2A2F 50 POP 2A30 50 POP 2A31 86 DUP7 2A32 01 ADD 2A33 35 CALLDATALOAD 2A34 92 SWAP3 2A35 50 POP 2A36 50 POP 2A37 80 DUP1 2A38 82 DUP3 2A39 11 GT 2A3A 15 ISZERO 2A3B 61 PUSH2 0x2a43 2A3E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2A2E stack[-9] = stack[-2] // @2A34 stack[-7] = msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // } // Block ends with conditional jump to 0x2a43, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) label_2A3F: // Incoming jump from 0x2A3E, if not !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[1] { @2A42 memory[0x00:0x00] } 2A3F 60 PUSH1 0x00 2A41 80 DUP1 2A42 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A42 revert(memory[0x00:0x00]); } // Block terminates label_2A43: // Incoming jump from 0x2A3E, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[3] // { // @2A48 stack[-6] // @2A49 stack[-2] // @2A4A stack[-5] // } 2A43 5B JUMPDEST 2A44 50 POP 2A45 61 PUSH2 0x2a50 2A48 85 DUP6 2A49 82 DUP3 2A4A 86 DUP7 2A4B 01 ADD 2A4C 61 PUSH2 0x2616 2A4F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2A45 stack[-1] = 0x2a50 // @2A48 stack[0] = stack[-6] // @2A4B stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x2616, returns to 0x2A50 label_2A50: // Incoming return from call to 0x2616 at 0x2A4F // Inputs[6] // { // @2A51 stack[-3] // @2A51 stack[-1] // @2A54 stack[-6] // @2A56 stack[-7] // @2A56 stack[-4] // @2A57 stack[-5] // } 2A50 5B JUMPDEST 2A51 91 SWAP2 2A52 50 POP 2A53 50 POP 2A54 92 SWAP3 2A55 50 POP 2A56 92 SWAP3 2A57 90 SWAP1 2A58 50 POP 2A59 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2A54 stack[-6] = stack[-1] // @2A56 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2A5A: // Incoming call from 0x031B, returns to 0x031C // Incoming call from 0x03FE, returns to 0x03FF // Inputs[2] // { // @2A5F stack[-1] // @2A60 stack[-2] // } 2A5A 5B JUMPDEST 2A5B 60 PUSH1 0x00 2A5D 60 PUSH1 0x20 2A5F 82 DUP3 2A60 84 DUP5 2A61 03 SUB 2A62 12 SLT 2A63 15 ISZERO 2A64 61 PUSH2 0x2a6c 2A67 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A5B stack[0] = 0x00 } // Block ends with conditional jump to 0x2a6c, if !(stack[-2] - stack[-1] i< 0x20) label_2A68: // Incoming jump from 0x2A67, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A6B memory[0x00:0x00] } 2A68 60 PUSH1 0x00 2A6A 80 DUP1 2A6B FD *REVERT // Stack delta = +0 // Outputs[1] { @2A6B revert(memory[0x00:0x00]); } // Block terminates label_2A6C: // Incoming jump from 0x2A67, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2A70 stack[-2] } 2A6C 5B JUMPDEST 2A6D 61 PUSH2 0x272b 2A70 82 DUP3 2A71 61 PUSH2 0x268d 2A74 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2A6D stack[0] = 0x272b // @2A70 stack[1] = stack[-2] // } // Block ends with call to 0x268d, returns to 0x272B label_2A75: // Incoming call from 0x051A, returns to 0x051B // Inputs[2] // { // @2A7D stack[-1] // @2A7E stack[-2] // } 2A75 5B JUMPDEST 2A76 60 PUSH1 0x00 2A78 80 DUP1 2A79 60 PUSH1 0x00 2A7B 60 PUSH1 0x40 2A7D 84 DUP5 2A7E 86 DUP7 2A7F 03 SUB 2A80 12 SLT 2A81 15 ISZERO 2A82 61 PUSH2 0x2a8a 2A85 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2A76 stack[0] = 0x00 // @2A78 stack[1] = 0x00 // @2A79 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2a8a, if !(stack[-2] - stack[-1] i< 0x40) label_2A86: // Incoming jump from 0x2A85, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2A89 memory[0x00:0x00] } 2A86 60 PUSH1 0x00 2A88 80 DUP1 2A89 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A89 revert(memory[0x00:0x00]); } // Block terminates label_2A8A: // Incoming jump from 0x2A85, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2A8B stack[-4] // @2A8C msg.data[stack[-4]:stack[-4] + 0x20] // @2A8D stack[-3] // @2A93 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2A8A 5B JUMPDEST 2A8B 83 DUP4 2A8C 35 CALLDATALOAD 2A8D 92 SWAP3 2A8E 50 POP 2A8F 60 PUSH1 0x20 2A91 84 DUP5 2A92 01 ADD 2A93 35 CALLDATALOAD 2A94 60 PUSH1 0x01 2A96 60 PUSH1 0x01 2A98 60 PUSH1 0x40 2A9A 1B SHL 2A9B 03 SUB 2A9C 80 DUP1 2A9D 82 DUP3 2A9E 11 GT 2A9F 15 ISZERO 2AA0 61 PUSH2 0x2aa8 2AA3 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2A8D stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @2A93 stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2A9B stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x2aa8, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_2AA4: // Incoming jump from 0x2AA3, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2AA7 memory[0x00:0x00] } 2AA4 60 PUSH1 0x00 2AA6 80 DUP1 2AA7 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AA7 revert(memory[0x00:0x00]); } // Block terminates label_2AA8: // Incoming jump from 0x2AA3, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2AA9 stack[-2] // @2AAA stack[-6] // @2AAE stack[-7] // } 2AA8 5B JUMPDEST 2AA9 81 DUP2 2AAA 86 DUP7 2AAB 01 ADD 2AAC 91 SWAP2 2AAD 50 POP 2AAE 86 DUP7 2AAF 60 PUSH1 0x1f 2AB1 83 DUP4 2AB2 01 ADD 2AB3 12 SLT 2AB4 61 PUSH2 0x2abc 2AB7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2AAC stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x2abc, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_2AB8: // Incoming jump from 0x2AB7, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @2ABB memory[0x00:0x00] } 2AB8 60 PUSH1 0x00 2ABA 80 DUP1 2ABB FD *REVERT // Stack delta = +0 // Outputs[1] { @2ABB revert(memory[0x00:0x00]); } // Block terminates label_2ABC: // Incoming jump from 0x2AB7, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @2ABD stack[-2] // @2ABE msg.data[stack[-2]:stack[-2] + 0x20] // @2ABF stack[-1] // } 2ABC 5B JUMPDEST 2ABD 81 DUP2 2ABE 35 CALLDATALOAD 2ABF 81 DUP2 2AC0 81 DUP2 2AC1 11 GT 2AC2 15 ISZERO 2AC3 61 PUSH2 0x2acb 2AC6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2ABE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2acb, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_2AC7: // Incoming jump from 0x2AC6, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @2ACA memory[0x00:0x00] } 2AC7 60 PUSH1 0x00 2AC9 80 DUP1 2ACA FD *REVERT // Stack delta = +0 // Outputs[1] { @2ACA revert(memory[0x00:0x00]); } // Block terminates label_2ACB: // Incoming jump from 0x2AC6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @2ACC stack[-8] // @2ACF stack[-1] // @2AD0 stack[-3] // } 2ACB 5B JUMPDEST 2ACC 87 DUP8 2ACD 60 PUSH1 0x20 2ACF 82 DUP3 2AD0 85 DUP6 2AD1 01 ADD 2AD2 01 ADD 2AD3 11 GT 2AD4 15 ISZERO 2AD5 61 PUSH2 0x2add 2AD8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2add, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) label_2AD9: // Incoming jump from 0x2AD8, if not !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[1] { @2ADC memory[0x00:0x00] } 2AD9 60 PUSH1 0x00 2ADB 80 DUP1 2ADC FD *REVERT // Stack delta = +0 // Outputs[1] { @2ADC revert(memory[0x00:0x00]); } // Block terminates label_2ADD: // Incoming jump from 0x2AD8, if !(stack[-3] + stack[-1] + 0x20 > stack[-8]) // Inputs[8] // { // @2AE0 stack[-3] // @2AE2 stack[-5] // @2AE4 stack[-1] // @2AE5 stack[-4] // @2AEA stack[-7] // @2AEC stack[-8] // @2AEE stack[-6] // @2AEE stack[-9] // } 2ADD 5B JUMPDEST 2ADE 60 PUSH1 0x20 2AE0 83 DUP4 2AE1 01 ADD 2AE2 94 SWAP5 2AE3 50 POP 2AE4 80 DUP1 2AE5 93 SWAP4 2AE6 50 POP 2AE7 50 POP 2AE8 50 POP 2AE9 50 POP 2AEA 92 SWAP3 2AEB 50 POP 2AEC 92 SWAP3 2AED 50 POP 2AEE 92 SWAP3 2AEF 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2AEA stack[-7] = stack[-1] // @2AEC stack[-8] = stack[-3] + 0x20 // @2AEE stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_2AF0: // Incoming call from 0x0272, returns to 0x0273 // Inputs[2] // { // @2AF5 stack[-1] // @2AF6 stack[-2] // } 2AF0 5B JUMPDEST 2AF1 60 PUSH1 0x00 2AF3 60 PUSH1 0x20 2AF5 82 DUP3 2AF6 84 DUP5 2AF7 03 SUB 2AF8 12 SLT 2AF9 15 ISZERO 2AFA 61 PUSH2 0x2b02 2AFD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AF1 stack[0] = 0x00 } // Block ends with conditional jump to 0x2b02, if !(stack[-2] - stack[-1] i< 0x20) label_2AFE: // Incoming jump from 0x2AFD, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2B01 memory[0x00:0x00] } 2AFE 60 PUSH1 0x00 2B00 80 DUP1 2B01 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B01 revert(memory[0x00:0x00]); } // Block terminates label_2B02: // Incoming jump from 0x2AFD, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2B03 stack[-2] // @2B04 msg.data[stack[-2]:stack[-2] + 0x20] // } 2B02 5B JUMPDEST 2B03 81 DUP2 2B04 35 CALLDATALOAD 2B05 61 PUSH2 0x272b 2B08 81 DUP2 2B09 61 PUSH2 0x307d 2B0C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B04 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2B05 stack[1] = 0x272b // @2B08 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x307d, returns to 0x272B 2B0D 5B JUMPDEST 2B0E 60 PUSH1 0x00 2B10 60 PUSH1 0x20 2B12 82 DUP3 2B13 84 DUP5 2B14 03 SUB 2B15 12 SLT 2B16 15 ISZERO 2B17 61 PUSH2 0x2b1f 2B1A 57 *JUMPI 2B1B 60 PUSH1 0x00 2B1D 80 DUP1 2B1E FD *REVERT 2B1F 5B JUMPDEST 2B20 81 DUP2 2B21 51 MLOAD 2B22 61 PUSH2 0x272b 2B25 81 DUP2 2B26 61 PUSH2 0x307d 2B29 56 *JUMP label_2B2A: // Incoming call from 0x044C, returns to 0x044D // Inputs[2] // { // @2B2F stack[-1] // @2B30 stack[-2] // } 2B2A 5B JUMPDEST 2B2B 60 PUSH1 0x00 2B2D 60 PUSH1 0x20 2B2F 82 DUP3 2B30 84 DUP5 2B31 03 SUB 2B32 12 SLT 2B33 15 ISZERO 2B34 61 PUSH2 0x2b3c 2B37 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B2B stack[0] = 0x00 } // Block ends with conditional jump to 0x2b3c, if !(stack[-2] - stack[-1] i< 0x20) label_2B38: // Incoming jump from 0x2B37, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2B3B memory[0x00:0x00] } 2B38 60 PUSH1 0x00 2B3A 80 DUP1 2B3B FD *REVERT // Stack delta = +0 // Outputs[1] { @2B3B revert(memory[0x00:0x00]); } // Block terminates label_2B3C: // Incoming jump from 0x2B37, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2B3D stack[-2] // @2B3E msg.data[stack[-2]:stack[-2] + 0x20] // } 2B3C 5B JUMPDEST 2B3D 81 DUP2 2B3E 35 CALLDATALOAD 2B3F 60 PUSH1 0x01 2B41 60 PUSH1 0x01 2B43 60 PUSH1 0x40 2B45 1B SHL 2B46 03 SUB 2B47 81 DUP2 2B48 11 GT 2B49 15 ISZERO 2B4A 61 PUSH2 0x2b52 2B4D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B3E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2b52, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_2B4E: // Incoming jump from 0x2B4D, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2B51 memory[0x00:0x00] } 2B4E 60 PUSH1 0x00 2B50 80 DUP1 2B51 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B51 revert(memory[0x00:0x00]); } // Block terminates label_2B52: // Incoming jump from 0x2B4D, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2B56 stack[-4] // @2B57 stack[-1] // @2B58 stack[-3] // } 2B52 5B JUMPDEST 2B53 61 PUSH2 0x2b5e 2B56 84 DUP5 2B57 82 DUP3 2B58 85 DUP6 2B59 01 ADD 2B5A 61 PUSH2 0x269d 2B5D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B53 stack[0] = 0x2b5e // @2B56 stack[1] = stack[-4] // @2B59 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x269d, returns to 0x2B5E label_2B5E: // Incoming return from call to 0x269D at 0x2B5D // Inputs[3] // { // @2B5F stack[-1] // @2B5F stack[-6] // @2B60 stack[-5] // } 2B5E 5B JUMPDEST 2B5F 94 SWAP5 2B60 93 SWAP4 2B61 50 POP 2B62 50 POP 2B63 50 POP 2B64 50 POP 2B65 56 *JUMP // Stack delta = -5 // Outputs[1] { @2B5F stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2B66: // Incoming call from 0x039D, returns to 0x039E // Inputs[2] // { // @2B6C stack[-1] // @2B6D stack[-2] // } 2B66 5B JUMPDEST 2B67 60 PUSH1 0x00 2B69 80 DUP1 2B6A 60 PUSH1 0x40 2B6C 83 DUP4 2B6D 85 DUP6 2B6E 03 SUB 2B6F 12 SLT 2B70 15 ISZERO 2B71 61 PUSH2 0x2b79 2B74 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B67 stack[0] = 0x00 // @2B69 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2b79, if !(stack[-2] - stack[-1] i< 0x40) label_2B75: // Incoming jump from 0x2B74, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2B78 memory[0x00:0x00] } 2B75 60 PUSH1 0x00 2B77 80 DUP1 2B78 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B78 revert(memory[0x00:0x00]); } // Block terminates label_2B79: // Incoming jump from 0x2B74, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2B7A stack[-3] // @2B7B msg.data[stack[-3]:stack[-3] + 0x20] // } 2B79 5B JUMPDEST 2B7A 82 DUP3 2B7B 35 CALLDATALOAD 2B7C 60 PUSH1 0x01 2B7E 60 PUSH1 0x01 2B80 60 PUSH1 0x40 2B82 1B SHL 2B83 03 SUB 2B84 81 DUP2 2B85 11 GT 2B86 15 ISZERO 2B87 61 PUSH2 0x2b8f 2B8A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B7B stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2b8f, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_2B8B: // Incoming jump from 0x2B8A, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2B8E memory[0x00:0x00] } 2B8B 60 PUSH1 0x00 2B8D 80 DUP1 2B8E FD *REVERT // Stack delta = +0 // Outputs[1] { @2B8E revert(memory[0x00:0x00]); } // Block terminates label_2B8F: // Incoming jump from 0x2B8A, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2B93 stack[-5] // @2B94 stack[-1] // @2B95 stack[-4] // } 2B8F 5B JUMPDEST 2B90 61 PUSH2 0x2b9b 2B93 85 DUP6 2B94 82 DUP3 2B95 86 DUP7 2B96 01 ADD 2B97 61 PUSH2 0x269d 2B9A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B90 stack[0] = 0x2b9b // @2B93 stack[1] = stack[-5] // @2B96 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x269d, returns to 0x2B9B label_2B9B: // Incoming return from call to 0x269D at 0x2B9A // Inputs[5] // { // @2B9C stack[-7] // @2B9C stack[-1] // @2B9F stack[-5] // @2BA3 msg.data[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // @2BA4 stack[-6] // } 2B9B 5B JUMPDEST 2B9C 95 SWAP6 2B9D 60 PUSH1 0x20 2B9F 94 SWAP5 2BA0 90 SWAP1 2BA1 94 SWAP5 2BA2 01 ADD 2BA3 35 CALLDATALOAD 2BA4 94 SWAP5 2BA5 50 POP 2BA6 50 POP 2BA7 50 POP 2BA8 50 POP 2BA9 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2B9C stack[-7] = stack[-1] // @2BA4 stack[-6] = msg.data[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2BAA: // Incoming call from 0x042C, returns to 0x042D // Incoming call from 0x02BD, returns to 0x02BE // Incoming call from 0x0495, returns to 0x0496 // Incoming call from 0x045F, returns to 0x0460 // Incoming call from 0x0356, returns to 0x0357 // Inputs[2] // { // @2BAF stack[-1] // @2BB0 stack[-2] // } 2BAA 5B JUMPDEST 2BAB 60 PUSH1 0x00 2BAD 60 PUSH1 0x20 2BAF 82 DUP3 2BB0 84 DUP5 2BB1 03 SUB 2BB2 12 SLT 2BB3 15 ISZERO 2BB4 61 PUSH2 0x2bbc 2BB7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BAB stack[0] = 0x00 } // Block ends with conditional jump to 0x2bbc, if !(stack[-2] - stack[-1] i< 0x20) label_2BB8: // Incoming jump from 0x2BB7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2BBB memory[0x00:0x00] } 2BB8 60 PUSH1 0x00 2BBA 80 DUP1 2BBB FD *REVERT // Stack delta = +0 // Outputs[1] { @2BBB revert(memory[0x00:0x00]); } // Block terminates label_2BBC: // Incoming jump from 0x2BB7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2BBE msg.data[stack[-2]:stack[-2] + 0x20] // @2BBE stack[-2] // @2BBF stack[-4] // @2BC0 stack[-3] // } 2BBC 5B JUMPDEST 2BBD 50 POP 2BBE 35 CALLDATALOAD 2BBF 91 SWAP2 2BC0 90 SWAP1 2BC1 50 POP 2BC2 56 *JUMP // Stack delta = -3 // Outputs[1] { @2BBF stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2BC3: // Incoming call from 0x2D00, returns to 0x272B // Inputs[3] // { // @2BC6 stack[-1] // @2BC7 memory[stack[-1]:stack[-1] + 0x20] // @2BC9 stack[-2] // } 2BC3 5B JUMPDEST 2BC4 60 PUSH1 0x00 2BC6 81 DUP2 2BC7 51 MLOAD 2BC8 80 DUP1 2BC9 84 DUP5 2BCA 52 MSTORE 2BCB 60 PUSH1 0x20 2BCD 80 DUP1 2BCE 85 DUP6 2BCF 01 ADD 2BD0 94 SWAP5 2BD1 50 POP 2BD2 80 DUP1 2BD3 84 DUP5 2BD4 01 ADD 2BD5 60 PUSH1 0x00 2BD7 5B JUMPDEST 2BD8 83 DUP4 2BD9 81 DUP2 2BDA 10 LT 2BDB 15 ISZERO 2BDC 61 PUSH2 0x2bf3 2BDF 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @2BC4 stack[0] = 0x00 // @2BC7 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2BCA memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2BCB stack[2] = 0x20 // @2BD0 stack[-2] = stack[-2] + 0x20 // @2BD4 stack[3] = stack[-1] + 0x20 // @2BD5 stack[4] = 0x00 // } // Block ends with conditional jump to 0x2bf3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_2BE0: // Incoming jump from 0x2BDF, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2BDF, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @2BE0 stack[-2] // @2BE1 memory[stack[-2]:stack[-2] + 0x20] // @2BE2 stack[-7] // @2BE4 stack[-1] // @2BE5 stack[-3] // } 2BE0 81 DUP2 2BE1 51 MLOAD 2BE2 87 DUP8 2BE3 52 MSTORE 2BE4 95 SWAP6 2BE5 82 DUP3 2BE6 01 ADD 2BE7 95 SWAP6 2BE8 90 SWAP1 2BE9 82 DUP3 2BEA 01 ADD 2BEB 90 SWAP1 2BEC 60 PUSH1 0x01 2BEE 01 ADD 2BEF 61 PUSH2 0x2bd7 2BF2 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2BE3 memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2BE7 stack[-7] = stack[-3] + stack[-7] // @2BEB stack[-2] = stack[-3] + stack[-2] // @2BEE stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2bd7 label_2BF3: // Incoming jump from 0x2BDF, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2BDF, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @2BF5 stack[-7] // @2BF5 stack[-2] // @2BF6 stack[-8] // } 2BF3 5B JUMPDEST 2BF4 50 POP 2BF5 94 SWAP5 2BF6 95 SWAP6 2BF7 94 SWAP5 2BF8 50 POP 2BF9 50 POP 2BFA 50 POP 2BFB 50 POP 2BFC 50 POP 2BFD 56 *JUMP // Stack delta = -7 // Outputs[1] { @2BF6 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_2BFE: // Incoming call from 0x2D41, returns to 0x272B // Inputs[3] // { // @2C01 stack[-1] // @2C02 memory[stack[-1]:stack[-1] + 0x20] // @2C04 stack[-2] // } 2BFE 5B JUMPDEST 2BFF 60 PUSH1 0x00 2C01 81 DUP2 2C02 51 MLOAD 2C03 80 DUP1 2C04 84 DUP5 2C05 52 MSTORE 2C06 60 PUSH1 0x00 2C08 5B JUMPDEST 2C09 81 DUP2 2C0A 81 DUP2 2C0B 10 LT 2C0C 15 ISZERO 2C0D 61 PUSH2 0x2c24 2C10 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @2BFF stack[0] = 0x00 // @2C02 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2C05 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2C06 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2c24, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_2C11: // Incoming jump from 0x2C10, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2C10, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @2C13 stack[-1] // @2C14 stack[-4] // @2C18 memory[0x20 + stack[-4] + stack[-1]:0x20 + stack[-4] + stack[-1] + 0x20] // @2C19 stack[-5] // } 2C11 60 PUSH1 0x20 2C13 81 DUP2 2C14 85 DUP6 2C15 01 ADD 2C16 81 DUP2 2C17 01 ADD 2C18 51 MLOAD 2C19 86 DUP7 2C1A 83 DUP4 2C1B 01 ADD 2C1C 82 DUP3 2C1D 01 ADD 2C1E 52 MSTORE 2C1F 01 ADD 2C20 61 PUSH2 0x2c08 2C23 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2C1E memory[0x20 + stack[-1] + stack[-5]:0x20 + stack[-1] + stack[-5] + 0x20] = memory[0x20 + stack[-4] + stack[-1]:0x20 + stack[-4] + stack[-1] + 0x20] // @2C1F stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2c08 label_2C24: // Incoming jump from 0x2C10, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2C10, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @2C25 stack[-2] // @2C26 stack[-1] // } 2C24 5B JUMPDEST 2C25 81 DUP2 2C26 81 DUP2 2C27 11 GT 2C28 15 ISZERO 2C29 61 PUSH2 0x2c36 2C2C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2c36, if !(stack[-1] > stack[-2]) label_2C2D: // Incoming jump from 0x2C2C, if not !(stack[-1] > stack[-2]) // Inputs[4] // { // @2C31 stack[-2] // @2C32 stack[-5] // @2C40 stack[-3] // @2C46 stack[-6] // } 2C2D 60 PUSH1 0x00 2C2F 60 PUSH1 0x20 2C31 83 DUP4 2C32 87 DUP8 2C33 01 ADD 2C34 01 ADD 2C35 52 MSTORE 2C36 5B JUMPDEST 2C37 50 POP 2C38 60 PUSH1 0x1f 2C3A 01 ADD 2C3B 60 PUSH1 0x1f 2C3D 19 NOT 2C3E 16 AND 2C3F 92 SWAP3 2C40 90 SWAP1 2C41 92 SWAP3 2C42 01 ADD 2C43 60 PUSH1 0x20 2C45 01 ADD 2C46 92 SWAP3 2C47 91 SWAP2 2C48 50 POP 2C49 50 POP 2C4A 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2C35 memory[stack[-5] + stack[-2] + 0x20:stack[-5] + stack[-2] + 0x20 + 0x20] = 0x00 // @2C46 stack[-6] = 0x20 + (~0x1f & 0x1f + stack[-2]) + stack[-5] // } // Block ends with unconditional jump to stack[-6] 2C4B 5B JUMPDEST 2C4C 60 PUSH1 0x01 2C4E 60 PUSH1 0x01 2C50 60 PUSH1 0xa0 2C52 1B SHL 2C53 03 SUB 2C54 86 DUP7 2C55 81 DUP2 2C56 16 AND 2C57 82 DUP3 2C58 52 MSTORE 2C59 85 DUP6 2C5A 16 AND 2C5B 60 PUSH1 0x20 2C5D 82 DUP3 2C5E 01 ADD 2C5F 52 MSTORE 2C60 60 PUSH1 0xa0 2C62 60 PUSH1 0x40 2C64 82 DUP3 2C65 01 ADD 2C66 81 DUP2 2C67 90 SWAP1 2C68 52 MSTORE 2C69 60 PUSH1 0x00 2C6B 90 SWAP1 2C6C 61 PUSH2 0x2c77 2C6F 90 SWAP1 2C70 83 DUP4 2C71 01 ADD 2C72 86 DUP7 2C73 61 PUSH2 0x2bc3 2C76 56 *JUMP 2C77 5B JUMPDEST 2C78 82 DUP3 2C79 81 DUP2 2C7A 03 SUB 2C7B 60 PUSH1 0x60 2C7D 84 DUP5 2C7E 01 ADD 2C7F 52 MSTORE 2C80 61 PUSH2 0x2c89 2C83 81 DUP2 2C84 86 DUP7 2C85 61 PUSH2 0x2bc3 2C88 56 *JUMP 2C89 5B JUMPDEST 2C8A 90 SWAP1 2C8B 50 POP 2C8C 82 DUP3 2C8D 81 DUP2 2C8E 03 SUB 2C8F 60 PUSH1 0x80 2C91 84 DUP5 2C92 01 ADD 2C93 52 MSTORE 2C94 61 PUSH2 0x2c9d 2C97 81 DUP2 2C98 85 DUP6 2C99 61 PUSH2 0x2bfe 2C9C 56 *JUMP 2C9D 5B JUMPDEST 2C9E 98 SWAP9 2C9F 97 SWAP8 2CA0 50 POP 2CA1 50 POP 2CA2 50 POP 2CA3 50 POP 2CA4 50 POP 2CA5 50 POP 2CA6 50 POP 2CA7 50 POP 2CA8 56 *JUMP 2CA9 5B JUMPDEST 2CAA 60 PUSH1 0x01 2CAC 60 PUSH1 0x01 2CAE 60 PUSH1 0xa0 2CB0 1B SHL 2CB1 03 SUB 2CB2 86 DUP7 2CB3 81 DUP2 2CB4 16 AND 2CB5 82 DUP3 2CB6 52 MSTORE 2CB7 85 DUP6 2CB8 16 AND 2CB9 60 PUSH1 0x20 2CBB 82 DUP3 2CBC 01 ADD 2CBD 52 MSTORE 2CBE 60 PUSH1 0x40 2CC0 81 DUP2 2CC1 01 ADD 2CC2 84 DUP5 2CC3 90 SWAP1 2CC4 52 MSTORE 2CC5 60 PUSH1 0x60 2CC7 81 DUP2 2CC8 01 ADD 2CC9 83 DUP4 2CCA 90 SWAP1 2CCB 52 MSTORE 2CCC 60 PUSH1 0xa0 2CCE 60 PUSH1 0x80 2CD0 82 DUP3 2CD1 01 ADD 2CD2 81 DUP2 2CD3 90 SWAP1 2CD4 52 MSTORE 2CD5 60 PUSH1 0x00 2CD7 90 SWAP1 2CD8 61 PUSH2 0x2ce3 2CDB 90 SWAP1 2CDC 83 DUP4 2CDD 01 ADD 2CDE 84 DUP5 2CDF 61 PUSH2 0x2bfe 2CE2 56 *JUMP 2CE3 5B JUMPDEST 2CE4 97 SWAP8 2CE5 96 SWAP7 2CE6 50 POP 2CE7 50 POP 2CE8 50 POP 2CE9 50 POP 2CEA 50 POP 2CEB 50 POP 2CEC 50 POP 2CED 56 *JUMP label_2CEE: // Incoming jump from 0x0348 // Inputs[2] // { // @2CF1 stack[-1] // @2CFC stack[-2] // } 2CEE 5B JUMPDEST 2CEF 60 PUSH1 0x20 2CF1 81 DUP2 2CF2 52 MSTORE 2CF3 60 PUSH1 0x00 2CF5 61 PUSH2 0x272b 2CF8 60 PUSH1 0x20 2CFA 83 DUP4 2CFB 01 ADD 2CFC 84 DUP5 2CFD 61 PUSH2 0x2bc3 2D00 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2CF2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2CF3 stack[0] = 0x00 // @2CF5 stack[1] = 0x272b // @2CFB stack[2] = stack[-1] + 0x20 // @2CFC stack[3] = stack[-2] // } // Block ends with call to 0x2bc3, returns to 0x272B 2D01 5B JUMPDEST 2D02 60 PUSH1 0x40 2D04 81 DUP2 2D05 52 MSTORE 2D06 60 PUSH1 0x00 2D08 61 PUSH2 0x2d14 2D0B 60 PUSH1 0x40 2D0D 83 DUP4 2D0E 01 ADD 2D0F 85 DUP6 2D10 61 PUSH2 0x2bc3 2D13 56 *JUMP 2D14 5B JUMPDEST 2D15 82 DUP3 2D16 81 DUP2 2D17 03 SUB 2D18 60 PUSH1 0x20 2D1A 84 DUP5 2D1B 01 ADD 2D1C 52 MSTORE 2D1D 61 PUSH2 0x2d26 2D20 81 DUP2 2D21 85 DUP6 2D22 61 PUSH2 0x2bc3 2D25 56 *JUMP 2D26 5B JUMPDEST 2D27 95 SWAP6 2D28 94 SWAP5 2D29 50 POP 2D2A 50 POP 2D2B 50 POP 2D2C 50 POP 2D2D 50 POP 2D2E 56 *JUMP label_2D2F: // Incoming jump from 0x02AF // Inputs[2] // { // @2D32 stack[-1] // @2D3D stack[-2] // } 2D2F 5B JUMPDEST 2D30 60 PUSH1 0x20 2D32 81 DUP2 2D33 52 MSTORE 2D34 60 PUSH1 0x00 2D36 61 PUSH2 0x272b 2D39 60 PUSH1 0x20 2D3B 83 DUP4 2D3C 01 ADD 2D3D 84 DUP5 2D3E 61 PUSH2 0x2bfe 2D41 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2D33 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2D34 stack[0] = 0x00 // @2D36 stack[1] = 0x272b // @2D3C stack[2] = stack[-1] + 0x20 // @2D3D stack[3] = stack[-2] // } // Block ends with call to 0x2bfe, returns to 0x272B 2D42 5B JUMPDEST 2D43 60 PUSH1 0x20 2D45 80 DUP1 2D46 82 DUP3 2D47 52 MSTORE 2D48 60 PUSH1 0x28 2D4A 90 SWAP1 2D4B 82 DUP3 2D4C 01 ADD 2D4D 52 MSTORE 2D4E 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 2D6F 60 PUSH1 0x40 2D71 82 DUP3 2D72 01 ADD 2D73 52 MSTORE 2D74 67 PUSH8 0x6420746f6b656e73 2D7D 60 PUSH1 0xc0 2D7F 1B SHL 2D80 60 PUSH1 0x60 2D82 82 DUP3 2D83 01 ADD 2D84 52 MSTORE 2D85 60 PUSH1 0x80 2D87 01 ADD 2D88 90 SWAP1 2D89 56 *JUMP label_2D8A: // Incoming call from 0x12AE, returns to 0x054A // Incoming call from 0x091A, returns to 0x054A // Inputs[2] // { // @2D8E stack[-1] // @2DCD stack[-2] // } 2D8A 5B JUMPDEST 2D8B 60 PUSH1 0x20 2D8D 80 DUP1 2D8E 82 DUP3 2D8F 52 MSTORE 2D90 60 PUSH1 0x25 2D92 90 SWAP1 2D93 82 DUP3 2D94 01 ADD 2D95 52 MSTORE 2D96 7F PUSH32 0x4d75737420696e766f6b65206469726563746c792066726f6d20796f75722077 2DB7 60 PUSH1 0x40 2DB9 82 DUP3 2DBA 01 ADD 2DBB 52 MSTORE 2DBC 64 PUSH5 0x185b1b195d 2DC2 60 PUSH1 0xda 2DC4 1B SHL 2DC5 60 PUSH1 0x60 2DC7 82 DUP3 2DC8 01 ADD 2DC9 52 MSTORE 2DCA 60 PUSH1 0x80 2DCC 01 ADD 2DCD 90 SWAP1 2DCE 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2D8F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2D95 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @2DBB memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d75737420696e766f6b65206469726563746c792066726f6d20796f75722077 // @2DC9 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x185b1b195d << 0xda // @2DCD stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2DCF: // Incoming call from 0x1EE9, returns to 0x054A // Inputs[2] // { // @2DD3 stack[-1] // @2E12 stack[-2] // } 2DCF 5B JUMPDEST 2DD0 60 PUSH1 0x20 2DD2 80 DUP1 2DD3 82 DUP3 2DD4 52 MSTORE 2DD5 60 PUSH1 0x25 2DD7 90 SWAP1 2DD8 82 DUP3 2DD9 01 ADD 2DDA 52 MSTORE 2DDB 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 2DFC 60 PUSH1 0x40 2DFE 82 DUP3 2DFF 01 ADD 2E00 52 MSTORE 2E01 64 PUSH5 0x6472657373 2E07 60 PUSH1 0xd8 2E09 1B SHL 2E0A 60 PUSH1 0x60 2E0C 82 DUP3 2E0D 01 ADD 2E0E 52 MSTORE 2E0F 60 PUSH1 0x80 2E11 01 ADD 2E12 90 SWAP1 2E13 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2DD4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2DDA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @2E00 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @2E0E memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6472657373 << 0xd8 // @2E12 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2E14 5B JUMPDEST 2E15 60 PUSH1 0x20 2E17 80 DUP1 2E18 82 DUP3 2E19 52 MSTORE 2E1A 60 PUSH1 0x2a 2E1C 90 SWAP1 2E1D 82 DUP3 2E1E 01 ADD 2E1F 52 MSTORE 2E20 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 2E41 60 PUSH1 0x40 2E43 82 DUP3 2E44 01 ADD 2E45 52 MSTORE 2E46 69 PUSH10 0x39103a3930b739b332b9 2E51 60 PUSH1 0xb1 2E53 1B SHL 2E54 60 PUSH1 0x60 2E56 82 DUP3 2E57 01 ADD 2E58 52 MSTORE 2E59 60 PUSH1 0x80 2E5B 01 ADD 2E5C 90 SWAP1 2E5D 56 *JUMP label_2E5E: // Incoming call from 0x0EF9, returns to 0x054A // Incoming call from 0x0F42, returns to 0x054A // Incoming call from 0x10C1, returns to 0x054A // Incoming call from 0x0C17, returns to 0x054A // Incoming call from 0x1221, returns to 0x054A // Incoming call from 0x0FA8, returns to 0x054A // Incoming call from 0x0B81, returns to 0x054A // Incoming call from 0x1180, returns to 0x054A // Incoming call from 0x0F76, returns to 0x054A // Incoming call from 0x0D74, returns to 0x054A // Incoming call from 0x0764, returns to 0x054A // Incoming call from 0x0549, returns to 0x054A // Inputs[2] // { // @2E62 stack[-1] // @2E91 stack[-2] // } 2E5E 5B JUMPDEST 2E5F 60 PUSH1 0x20 2E61 80 DUP1 2E62 82 DUP3 2E63 52 MSTORE 2E64 81 DUP2 2E65 81 DUP2 2E66 01 ADD 2E67 52 MSTORE 2E68 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2E89 60 PUSH1 0x40 2E8B 82 DUP3 2E8C 01 ADD 2E8D 52 MSTORE 2E8E 60 PUSH1 0x60 2E90 01 ADD 2E91 90 SWAP1 2E92 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2E63 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2E67 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2E8D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2E91 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2E93: // Incoming call from 0x29D4, returns to 0x29D5 // Incoming call from 0x2633, returns to 0x2634 // Inputs[1] { @2E9E stack[-1] } 2E93 5B JUMPDEST 2E94 60 PUSH1 0x00 2E96 60 PUSH1 0x01 2E98 60 PUSH1 0x01 2E9A 60 PUSH1 0x40 2E9C 1B SHL 2E9D 03 SUB 2E9E 82 DUP3 2E9F 11 GT 2EA0 15 ISZERO 2EA1 61 PUSH2 0x2eac 2EA4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E94 stack[0] = 0x00 } // Block ends with conditional jump to 0x2eac, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_2EA5: // Incoming jump from 0x2EA4, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 2EA5 61 PUSH2 0x2eac 2EA8 61 PUSH2 0x2fc2 2EAB 56 *JUMP // Stack delta = +1 // Outputs[1] { @2EA5 stack[0] = 0x2eac } // Block ends with unconditional jump to 0x2fc2 label_2EAC: // Incoming jump from 0x2EA4, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @2EB0 stack[-2] // @2EB4 stack[-3] // } 2EAC 5B JUMPDEST 2EAD 50 POP 2EAE 60 PUSH1 0x05 2EB0 1B SHL 2EB1 60 PUSH1 0x20 2EB3 01 ADD 2EB4 90 SWAP1 2EB5 56 *JUMP // Stack delta = -2 // Outputs[1] { @2EB4 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_2EB6: // Incoming call from 0x0E32, returns to 0x0E33 // Incoming call from 0x20C1, returns to 0x20C2 // Incoming call from 0x1008, returns to 0x1009 // Incoming call from 0x0E28, returns to 0x0E29 // Incoming call from 0x2500, returns to 0x2501 // Incoming call from 0x0A15, returns to 0x0A16 // Incoming call from 0x139A, returns to 0x139B // Incoming call from 0x0E1E, returns to 0x0E1F // Incoming call from 0x0A0B, returns to 0x0A0C // Incoming call from 0x0FFE, returns to 0x0FFF // Incoming call from 0x0FF4, returns to 0x0FF5 // Incoming call from 0x13A4, returns to 0x13A5 // Inputs[2] // { // @2EB9 stack[-2] // @2EBB stack[-1] // } 2EB6 5B JUMPDEST 2EB7 60 PUSH1 0x00 2EB9 82 DUP3 2EBA 19 NOT 2EBB 82 DUP3 2EBC 11 GT 2EBD 15 ISZERO 2EBE 61 PUSH2 0x2ec9 2EC1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2EB7 stack[0] = 0x00 } // Block ends with conditional jump to 0x2ec9, if !(stack[-1] > ~stack[-2]) label_2EC2: // Incoming jump from 0x2EC1, if not !(stack[-1] > ~stack[-2]) 2EC2 61 PUSH2 0x2ec9 2EC5 61 PUSH2 0x2f80 2EC8 56 *JUMP // Stack delta = +1 // Outputs[1] { @2EC2 stack[0] = 0x2ec9 } // Block ends with unconditional jump to 0x2f80 label_2EC9: // Incoming jump from 0x2EC1, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2ECB stack[-3] // @2ECB stack[-2] // @2ECC stack[-4] // } 2EC9 5B JUMPDEST 2ECA 50 POP 2ECB 01 ADD 2ECC 90 SWAP1 2ECD 56 *JUMP // Stack delta = -3 // Outputs[1] { @2ECC stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2ECE: // Incoming call from 0x0DDA, returns to 0x0DDB // Inputs[2] // { // @2ED1 stack[-1] // @2ED6 stack[-2] // } 2ECE 5B JUMPDEST 2ECF 60 PUSH1 0x00 2ED1 81 DUP2 2ED2 60 PUSH1 0x00 2ED4 19 NOT 2ED5 04 DIV 2ED6 83 DUP4 2ED7 11 GT 2ED8 82 DUP3 2ED9 15 ISZERO 2EDA 15 ISZERO 2EDB 16 AND 2EDC 15 ISZERO 2EDD 61 PUSH2 0x2ee8 2EE0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2ECF stack[0] = 0x00 } // Block ends with conditional jump to 0x2ee8, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2EE1: // Incoming jump from 0x2EE0, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2EE1 61 PUSH2 0x2ee8 2EE4 61 PUSH2 0x2f80 2EE7 56 *JUMP // Stack delta = +1 // Outputs[1] { @2EE1 stack[0] = 0x2ee8 } // Block ends with unconditional jump to 0x2f80 label_2EE8: // Incoming jump from 0x2EE0, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2EEA stack[-2] // @2EEA stack[-3] // @2EEB stack[-4] // } 2EE8 5B JUMPDEST 2EE9 50 POP 2EEA 02 MUL 2EEB 90 SWAP1 2EEC 56 *JUMP // Stack delta = -3 // Outputs[1] { @2EEB stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2EED: // Incoming call from 0x1633, returns to 0x1634 // Inputs[2] // { // @2EF0 stack[-2] // @2EF1 stack[-1] // } 2EED 5B JUMPDEST 2EEE 60 PUSH1 0x00 2EF0 82 DUP3 2EF1 82 DUP3 2EF2 10 LT 2EF3 15 ISZERO 2EF4 61 PUSH2 0x2eff 2EF7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2EEE stack[0] = 0x00 } // Block ends with conditional jump to 0x2eff, if !(stack[-1] < stack[-2]) label_2EF8: // Incoming jump from 0x2EF7, if not !(stack[-1] < stack[-2]) 2EF8 61 PUSH2 0x2eff 2EFB 61 PUSH2 0x2f80 2EFE 56 *JUMP // Stack delta = +1 // Outputs[1] { @2EF8 stack[0] = 0x2eff } // Block ends with unconditional jump to 0x2f80 label_2EFF: // Incoming jump from 0x2EF7, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @2F01 stack[-3] // @2F01 stack[-2] // @2F02 stack[-4] // } 2EFF 5B JUMPDEST 2F00 50 POP 2F01 03 SUB 2F02 90 SWAP1 2F03 56 *JUMP // Stack delta = -3 // Outputs[1] { @2F02 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_2F04: // Incoming call from 0x1623, returns to 0x0877 // Incoming call from 0x1147, returns to 0x07AF // Incoming call from 0x2528, returns to 0x2529 // Incoming call from 0x084C, returns to 0x084D // Incoming call from 0x0876, returns to 0x0877 // Incoming call from 0x07AE, returns to 0x07AF // Incoming call from 0x08A2, returns to 0x08A3 // Incoming call from 0x07DA, returns to 0x07DB // Incoming call from 0x11A2, returns to 0x07AF // Inputs[1] { @2F07 stack[-1] } 2F04 5B JUMPDEST 2F05 60 PUSH1 0x01 2F07 81 DUP2 2F08 81 DUP2 2F09 1C SHR 2F0A 90 SWAP1 2F0B 82 DUP3 2F0C 16 AND 2F0D 80 DUP1 2F0E 61 PUSH2 0x2f18 2F11 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2F0A stack[0] = stack[-1] >> 0x01 // @2F0C stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2f18, if stack[-1] & 0x01 label_2F12: // Incoming jump from 0x2F11, if not stack[-1] & 0x01 // Inputs[2] // { // @2F14 stack[-2] // @2F1D stack[-1] // } 2F12 60 PUSH1 0x7f 2F14 82 DUP3 2F15 16 AND 2F16 91 SWAP2 2F17 50 POP 2F18 5B JUMPDEST 2F19 60 PUSH1 0x20 2F1B 82 DUP3 2F1C 10 LT 2F1D 81 DUP2 2F1E 14 EQ 2F1F 15 ISZERO 2F20 61 PUSH2 0x169d 2F23 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2F16 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x169d, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2F24: // Incoming jump from 0x2F23, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2F23, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @2F38 memory[0x00:0x24] } 2F24 63 PUSH4 0x4e487b71 2F29 60 PUSH1 0xe0 2F2B 1B SHL 2F2C 60 PUSH1 0x00 2F2E 52 MSTORE 2F2F 60 PUSH1 0x22 2F31 60 PUSH1 0x04 2F33 52 MSTORE 2F34 60 PUSH1 0x24 2F36 60 PUSH1 0x00 2F38 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2F2E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2F33 memory[0x04:0x24] = 0x22 // @2F38 revert(memory[0x00:0x24]); // } // Block terminates label_2F39: // Incoming call from 0x2640, returns to 0x2641 // Incoming call from 0x26DD, returns to 0x26DE // Incoming call from 0x29E1, returns to 0x29E2 // Inputs[2] // { // @2F3C stack[-2] // @2F42 stack[-1] // } 2F39 5B JUMPDEST 2F3A 60 PUSH1 0x1f 2F3C 82 DUP3 2F3D 01 ADD 2F3E 60 PUSH1 0x1f 2F40 19 NOT 2F41 16 AND 2F42 81 DUP2 2F43 01 ADD 2F44 60 PUSH1 0x01 2F46 60 PUSH1 0x01 2F48 60 PUSH1 0x40 2F4A 1B SHL 2F4B 03 SUB 2F4C 81 DUP2 2F4D 11 GT 2F4E 82 DUP3 2F4F 82 DUP3 2F50 10 LT 2F51 17 OR 2F52 15 ISZERO 2F53 61 PUSH2 0x2f5e 2F56 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2F43 stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x2f5e, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) label_2F57: // Incoming jump from 0x2F56, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) 2F57 61 PUSH2 0x2f5e 2F5A 61 PUSH2 0x2fc2 2F5D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2F57 stack[0] = 0x2f5e } // Block ends with unconditional jump to 0x2fc2 label_2F5E: // Incoming jump from 0x2F56, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > (0x01 << 0x40) - 0x01)) // Inputs[2] // { // @2F61 stack[-1] // @2F64 stack[-4] // } 2F5E 5B JUMPDEST 2F5F 60 PUSH1 0x40 2F61 52 MSTORE 2F62 50 POP 2F63 50 POP 2F64 56 *JUMP // Stack delta = -4 // Outputs[1] { @2F61 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2F65: // Incoming call from 0x21C4, returns to 0x21C5 // Incoming call from 0x20D0, returns to 0x20D1 // Incoming call from 0x0D3B, returns to 0x0D3C // Inputs[1] { @2F6B stack[-1] } 2F65 5B JUMPDEST 2F66 60 PUSH1 0x00 2F68 60 PUSH1 0x00 2F6A 19 NOT 2F6B 82 DUP3 2F6C 14 EQ 2F6D 15 ISZERO 2F6E 61 PUSH2 0x2f79 2F71 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2F66 stack[0] = 0x00 } // Block ends with conditional jump to 0x2f79, if !(stack[-1] == ~0x00) label_2F72: // Incoming jump from 0x2F71, if not !(stack[-1] == ~0x00) 2F72 61 PUSH2 0x2f79 2F75 61 PUSH2 0x2f80 2F78 56 *JUMP // Stack delta = +1 // Outputs[1] { @2F72 stack[0] = 0x2f79 } // Block ends with unconditional jump to 0x2f80 label_2F79: // Incoming jump from 0x2F71, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2F7D stack[-2] // @2F7E stack[-3] // } 2F79 5B JUMPDEST 2F7A 50 POP 2F7B 60 PUSH1 0x01 2F7D 01 ADD 2F7E 90 SWAP1 2F7F 56 *JUMP // Stack delta = -2 // Outputs[1] { @2F7E stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2F80: // Incoming jump from 0x2F78 // Incoming jump from 0x2EC8 // Incoming jump from 0x2EFE // Incoming jump from 0x2EE7 // Inputs[1] { @2F95 memory[0x00:0x24] } 2F80 5B JUMPDEST 2F81 63 PUSH4 0x4e487b71 2F86 60 PUSH1 0xe0 2F88 1B SHL 2F89 60 PUSH1 0x00 2F8B 52 MSTORE 2F8C 60 PUSH1 0x11 2F8E 60 PUSH1 0x04 2F90 52 MSTORE 2F91 60 PUSH1 0x24 2F93 60 PUSH1 0x00 2F95 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2F8B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2F90 memory[0x04:0x24] = 0x11 // @2F95 revert(memory[0x00:0x24]); // } // Block terminates label_2F96: // Incoming jump from 0x2330 // Incoming jump from 0x226C // Incoming jump from 0x224F // Incoming jump from 0x22CE // Incoming jump from 0x239D // Inputs[1] { @2FAB memory[0x00:0x24] } 2F96 5B JUMPDEST 2F97 63 PUSH4 0x4e487b71 2F9C 60 PUSH1 0xe0 2F9E 1B SHL 2F9F 60 PUSH1 0x00 2FA1 52 MSTORE 2FA2 60 PUSH1 0x21 2FA4 60 PUSH1 0x04 2FA6 52 MSTORE 2FA7 60 PUSH1 0x24 2FA9 60 PUSH1 0x00 2FAB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2FA1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2FA6 memory[0x04:0x24] = 0x21 // @2FAB revert(memory[0x00:0x24]); // } // Block terminates label_2FAC: // Incoming jump from 0x1067 // Incoming jump from 0x0D27 // Incoming jump from 0x2107 // Incoming jump from 0x207E // Incoming jump from 0x0E91 // Incoming jump from 0x2125 // Incoming jump from 0x0D08 // Incoming jump from 0x0CEE // Incoming jump from 0x1C22 // Incoming jump from 0x209C // Inputs[1] { @2FC1 memory[0x00:0x24] } 2FAC 5B JUMPDEST 2FAD 63 PUSH4 0x4e487b71 2FB2 60 PUSH1 0xe0 2FB4 1B SHL 2FB5 60 PUSH1 0x00 2FB7 52 MSTORE 2FB8 60 PUSH1 0x32 2FBA 60 PUSH1 0x04 2FBC 52 MSTORE 2FBD 60 PUSH1 0x24 2FBF 60 PUSH1 0x00 2FC1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2FB7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2FBC memory[0x04:0x24] = 0x32 // @2FC1 revert(memory[0x00:0x24]); // } // Block terminates label_2FC2: // Incoming jump from 0x2EAB // Incoming jump from 0x2F5D // Incoming jump from 0x26C6 // Incoming jump from 0x0CA1 // Inputs[1] { @2FD7 memory[0x00:0x24] } 2FC2 5B JUMPDEST 2FC3 63 PUSH4 0x4e487b71 2FC8 60 PUSH1 0xe0 2FCA 1B SHL 2FCB 60 PUSH1 0x00 2FCD 52 MSTORE 2FCE 60 PUSH1 0x41 2FD0 60 PUSH1 0x04 2FD2 52 MSTORE 2FD3 60 PUSH1 0x24 2FD5 60 PUSH1 0x00 2FD7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2FCD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2FD2 memory[0x04:0x24] = 0x41 // @2FD7 revert(memory[0x00:0x24]); // } // Block terminates 2FD8 5B JUMPDEST 2FD9 60 PUSH1 0x00 2FDB 60 PUSH1 0x03 2FDD 3D RETURNDATASIZE 2FDE 11 GT 2FDF 15 ISZERO 2FE0 61 PUSH2 0x2ff1 2FE3 57 *JUMPI 2FE4 60 PUSH1 0x04 2FE6 60 PUSH1 0x00 2FE8 80 DUP1 2FE9 3E RETURNDATACOPY 2FEA 50 POP 2FEB 60 PUSH1 0x00 2FED 51 MLOAD 2FEE 60 PUSH1 0xe0 2FF0 1C SHR 2FF1 5B JUMPDEST 2FF2 90 SWAP1 2FF3 56 *JUMP 2FF4 5B JUMPDEST 2FF5 60 PUSH1 0x00 2FF7 60 PUSH1 0x44 2FF9 3D RETURNDATASIZE 2FFA 10 LT 2FFB 15 ISZERO 2FFC 61 PUSH2 0x3002 2FFF 57 *JUMPI 3000 90 SWAP1 3001 56 *JUMP 3002 5B JUMPDEST 3003 60 PUSH1 0x40 3005 51 MLOAD 3006 60 PUSH1 0x03 3008 19 NOT 3009 3D RETURNDATASIZE 300A 81 DUP2 300B 01 ADD 300C 60 PUSH1 0x04 300E 83 DUP4 300F 3E RETURNDATACOPY 3010 81 DUP2 3011 51 MLOAD 3012 3D RETURNDATASIZE 3013 60 PUSH1 0x01 3015 60 PUSH1 0x01 3017 60 PUSH1 0x40 3019 1B SHL 301A 03 SUB 301B 81 DUP2 301C 60 PUSH1 0x24 301E 84 DUP5 301F 01 ADD 3020 11 GT 3021 81 DUP2 3022 84 DUP5 3023 11 GT 3024 17 OR 3025 15 ISZERO 3026 61 PUSH2 0x3031 3029 57 *JUMPI 302A 50 POP 302B 50 POP 302C 50 POP 302D 50 POP 302E 50 POP 302F 90 SWAP1 3030 56 *JUMP 3031 5B JUMPDEST 3032 82 DUP3 3033 85 DUP6 3034 01 ADD 3035 91 SWAP2 3036 50 POP 3037 81 DUP2 3038 51 MLOAD 3039 81 DUP2 303A 81 DUP2 303B 11 GT 303C 15 ISZERO 303D 61 PUSH2 0x3049 3040 57 *JUMPI 3041 50 POP 3042 50 POP 3043 50 POP 3044 50 POP 3045 50 POP 3046 50 POP 3047 90 SWAP1 3048 56 *JUMP 3049 5B JUMPDEST 304A 84 DUP5 304B 3D RETURNDATASIZE 304C 87 DUP8 304D 01 ADD 304E 01 ADD 304F 60 PUSH1 0x20 3051 82 DUP3 3052 85 DUP6 3053 01 ADD 3054 01 ADD 3055 11 GT 3056 15 ISZERO 3057 61 PUSH2 0x3063 305A 57 *JUMPI 305B 50 POP 305C 50 POP 305D 50 POP 305E 50 POP 305F 50 POP 3060 50 POP 3061 90 SWAP1 3062 56 *JUMP 3063 5B JUMPDEST 3064 61 PUSH2 0x3072 3067 60 PUSH1 0x20 3069 82 DUP3 306A 86 DUP7 306B 01 ADD 306C 01 ADD 306D 87 DUP8 306E 61 PUSH2 0x2f39 3071 56 *JUMP 3072 5B JUMPDEST 3073 50 POP 3074 90 SWAP1 3075 95 SWAP6 3076 94 SWAP5 3077 50 POP 3078 50 POP 3079 50 POP 307A 50 POP 307B 50 POP 307C 56 *JUMP label_307D: // Incoming call from 0x2B0C, returns to 0x272B // Inputs[1] { @3087 stack[-1] } 307D 5B JUMPDEST 307E 60 PUSH1 0x01 3080 60 PUSH1 0x01 3082 60 PUSH1 0xe0 3084 1B SHL 3085 03 SUB 3086 19 NOT 3087 81 DUP2 3088 16 AND 3089 81 DUP2 308A 14 EQ 308B 61 PUSH2 0x0abe 308E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0abe, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_308F: // Incoming jump from 0x308E, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @3092 memory[0x00:0x00] } 308F 60 PUSH1 0x00 3091 80 DUP1 3092 FD *REVERT // Stack delta = +0 // Outputs[1] { @3092 revert(memory[0x00:0x00]); } // Block terminates 3093 FE *ASSERT 3094 C3 C3 3095 A2 LOG2 3096 4B 4B 3097 05 SDIV 3098 01 ADD 3099 BD BD 309A 2C 2C 309B 13 SGT 309C A7 A7 309D E5 E5 309E 7F PUSH32 0x2db4369ec4c223447539fc0724a9d55ac4a06ebd4da15bc60c955c405d20d914 30BF 9C SWAP13 30C0 70 PUSH17 0x9e2460f1c2d9a497496a7f46004d1772c3 30D2 05 SDIV 30D3 4C 4C 30D4 CB CB 30D5 C4 C4 30D6 E5 E5 30D7 FB FB 30D8 02 MUL 30D9 C3 C3 30DA D1 D1 30DB DE DE 30DC 23 23 30DD A9 A9 30DE F1 CALL 30DF E0 E0 30E0 14 EQ 30E1 B4 B4 30E2 D2 D2 30E3 EE EE 30E4 5A GAS 30E5 EA EA 30E6 EA EA 30E7 95 SWAP6 30E8 05 SDIV 30E9 DF DF 30EA 5E 5E 30EB 85 DUP6 30EC 5C 5C 30ED 92 SWAP3 30EE 10 LT 30EF BF BF 30F0 47 SELFBALANCE 30F1 24 24 30F2 95 SWAP6 30F3 AF AF 30F4 A2 LOG2 30F5 64 PUSH5 0x6970667358 30FB 22 22 30FC 12 SLT 30FD 20 SHA3 30FE A3 LOG3 30FF 5F PUSH0 3100 BF BF 3101 0C 0C 3102 6F PUSH16 0xb8ae07ff872d2b69ffda536257517d4e 3113 80 DUP1 3114 A0 LOG0 3115 EC EC 3116 30 ADDRESS 3117 13 SGT 3118 C1 C1 3119 26 26 311A A1 LOG1 311B 6D PUSH14 0x468564736f6c63430008070033