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 0x0248 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0248, 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 0x6352211e 0026 11 GT 0027 61 PUSH2 0x013b 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x013b, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb320f459 0031 11 GT 0032 61 PUSH2 0x00b8 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b8, if 0xb320f459 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb320f459 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe0fd045f 003C 11 GT 003D 61 PUSH2 0x007c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xe0fd045f > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe0fd045f > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe0fd045f 0047 14 EQ 0048 61 PUSH2 0x04d8 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d8, if 0xe0fd045f == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe0fd045f == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x04eb 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04eb, 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 0xf6b630f0 005D 14 EQ 005E 61 PUSH2 0x04fe 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fe, if 0xf6b630f0 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf6b630f0 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf8ccd5de 0068 14 EQ 0069 61 PUSH2 0x0511 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0511, if 0xf8ccd5de == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf8ccd5de == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xfad32197 0073 14 EQ 0074 61 PUSH2 0x0524 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0524, if 0xfad32197 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xfad32197 == stack[-1] 0078 61 PUSH2 0x0248 007B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_007C: // Incoming jump from 0x0040, if 0xe0fd045f > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0xb320f459 0083 14 EQ 0084 61 PUSH2 0x0484 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0484, if 0xb320f459 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xb320f459 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb88d4fde 008E 14 EQ 008F 61 PUSH2 0x0497 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0xb88d4fde == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xba339399 0099 14 EQ 009A 61 PUSH2 0x04aa 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04aa, if 0xba339399 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xba339399 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x04bd 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bd, 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 0xde5236fb 00AF 14 EQ 00B0 61 PUSH2 0x04d0 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d0, if 0xde5236fb == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xde5236fb == stack[-1] 00B4 61 PUSH2 0x0248 00B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_00B8: // Incoming jump from 0x0035, if 0xb320f459 > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B8 5B JUMPDEST 00B9 80 DUP1 00BA 63 PUSH4 0x95d89b41 00BF 11 GT 00C0 61 PUSH2 0x00ff 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ff, if 0x95d89b41 > stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x95d89b41 00CA 14 EQ 00CB 61 PUSH2 0x043b 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043b, if 0x95d89b41 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x9d8e7260 00D5 14 EQ 00D6 61 PUSH2 0x0443 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0443, if 0x9d8e7260 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x9d8e7260 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0xa1794bcd 00E0 14 EQ 00E1 61 PUSH2 0x0456 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0456, if 0xa1794bcd == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0xa1794bcd == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0xa22cb465 00EB 14 EQ 00EC 61 PUSH2 0x045e 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045e, if 0xa22cb465 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0xb1e130fc 00F6 14 EQ 00F7 61 PUSH2 0x0471 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0471, if 0xb1e130fc == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0xb1e130fc == stack[-1] 00FB 61 PUSH2 0x0248 00FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_00FF: // Incoming jump from 0x00C3, if 0x95d89b41 > stack[-1] // Inputs[1] { @0100 stack[-1] } 00FF 5B JUMPDEST 0100 80 DUP1 0101 63 PUSH4 0x6352211e 0106 14 EQ 0107 61 PUSH2 0x03e7 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e7, if 0x6352211e == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x6352211e == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x6c0360eb 0111 14 EQ 0112 61 PUSH2 0x03fa 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fa, if 0x6c0360eb == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x6c0360eb == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x70a08231 011C 14 EQ 011D 61 PUSH2 0x0402 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0402, if 0x70a08231 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x70a08231 == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x75682e79 0127 14 EQ 0128 61 PUSH2 0x0415 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0415, if 0x75682e79 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x75682e79 == stack[-1] // Inputs[1] { @012C stack[-1] } 012C 80 DUP1 012D 63 PUSH4 0x7a7a1202 0132 14 EQ 0133 61 PUSH2 0x0428 0136 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0428, if 0x7a7a1202 == stack[-1] label_0137: // Incoming jump from 0x0136, if not 0x7a7a1202 == stack[-1] 0137 61 PUSH2 0x0248 013A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_013B: // Incoming jump from 0x002A, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @013C stack[-1] } 013B 5B JUMPDEST 013C 80 DUP1 013D 63 PUSH4 0x23b872dd 0142 11 GT 0143 61 PUSH2 0x01c9 0146 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c9, if 0x23b872dd > stack[-1] label_0147: // Incoming jump from 0x0146, if not 0x23b872dd > stack[-1] // Inputs[1] { @0147 stack[-1] } 0147 80 DUP1 0148 63 PUSH4 0x42842e0e 014D 11 GT 014E 61 PUSH2 0x018d 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018d, if 0x42842e0e > stack[-1] label_0152: // Incoming jump from 0x0151, if not 0x42842e0e > stack[-1] // Inputs[1] { @0152 stack[-1] } 0152 80 DUP1 0153 63 PUSH4 0x42842e0e 0158 14 EQ 0159 61 PUSH2 0x0388 015C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0388, if 0x42842e0e == stack[-1] label_015D: // Incoming jump from 0x015C, if not 0x42842e0e == stack[-1] // Inputs[1] { @015D stack[-1] } 015D 80 DUP1 015E 63 PUSH4 0x42966c68 0163 14 EQ 0164 61 PUSH2 0x039b 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039b, if 0x42966c68 == stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x42966c68 == stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x4f6ccce7 016E 14 EQ 016F 61 PUSH2 0x03ae 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ae, if 0x4f6ccce7 == stack[-1] label_0173: // Incoming jump from 0x0172, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0173 stack[-1] } 0173 80 DUP1 0174 63 PUSH4 0x5bf62422 0179 14 EQ 017A 61 PUSH2 0x03c1 017D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c1, if 0x5bf62422 == stack[-1] label_017E: // Incoming jump from 0x017D, if not 0x5bf62422 == stack[-1] // Inputs[1] { @017E stack[-1] } 017E 80 DUP1 017F 63 PUSH4 0x62f24b70 0184 14 EQ 0185 61 PUSH2 0x03d4 0188 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d4, if 0x62f24b70 == stack[-1] label_0189: // Incoming jump from 0x0188, if not 0x62f24b70 == stack[-1] 0189 61 PUSH2 0x0248 018C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_018D: // Incoming jump from 0x0151, if 0x42842e0e > stack[-1] // Inputs[1] { @018E stack[-1] } 018D 5B JUMPDEST 018E 80 DUP1 018F 63 PUSH4 0x23b872dd 0194 14 EQ 0195 61 PUSH2 0x0334 0198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0334, if 0x23b872dd == stack[-1] label_0199: // Incoming jump from 0x0198, if not 0x23b872dd == stack[-1] // Inputs[1] { @0199 stack[-1] } 0199 80 DUP1 019A 63 PUSH4 0x28220f35 019F 14 EQ 01A0 61 PUSH2 0x0347 01A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0347, if 0x28220f35 == stack[-1] label_01A4: // Incoming jump from 0x01A3, if not 0x28220f35 == stack[-1] // Inputs[1] { @01A4 stack[-1] } 01A4 80 DUP1 01A5 63 PUSH4 0x2cca3237 01AA 14 EQ 01AB 61 PUSH2 0x035a 01AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035a, if 0x2cca3237 == stack[-1] label_01AF: // Incoming jump from 0x01AE, if not 0x2cca3237 == stack[-1] // Inputs[1] { @01AF stack[-1] } 01AF 80 DUP1 01B0 63 PUSH4 0x2f745c59 01B5 14 EQ 01B6 61 PUSH2 0x036d 01B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036d, if 0x2f745c59 == stack[-1] label_01BA: // Incoming jump from 0x01B9, if not 0x2f745c59 == stack[-1] // Inputs[1] { @01BA stack[-1] } 01BA 80 DUP1 01BB 63 PUSH4 0x30adf81f 01C0 14 EQ 01C1 61 PUSH2 0x0380 01C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0380, if 0x30adf81f == stack[-1] label_01C5: // Incoming jump from 0x01C4, if not 0x30adf81f == stack[-1] 01C5 61 PUSH2 0x0248 01C8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_01C9: // Incoming jump from 0x0146, if 0x23b872dd > stack[-1] // Inputs[1] { @01CA stack[-1] } 01C9 5B JUMPDEST 01CA 80 DUP1 01CB 63 PUSH4 0x0bcd899b 01D0 11 GT 01D1 61 PUSH2 0x0210 01D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0210, if 0x0bcd899b > stack[-1] label_01D5: // Incoming jump from 0x01D4, if not 0x0bcd899b > stack[-1] // Inputs[1] { @01D5 stack[-1] } 01D5 80 DUP1 01D6 63 PUSH4 0x0bcd899b 01DB 14 EQ 01DC 61 PUSH2 0x02e0 01DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e0, if 0x0bcd899b == stack[-1] label_01E0: // Incoming jump from 0x01DF, if not 0x0bcd899b == stack[-1] // Inputs[1] { @01E0 stack[-1] } 01E0 80 DUP1 01E1 63 PUSH4 0x0e2a1778 01E6 14 EQ 01E7 61 PUSH2 0x02f3 01EA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f3, if 0x0e2a1778 == stack[-1] label_01EB: // Incoming jump from 0x01EA, if not 0x0e2a1778 == stack[-1] // Inputs[1] { @01EB stack[-1] } 01EB 80 DUP1 01EC 63 PUSH4 0x157c3df9 01F1 14 EQ 01F2 61 PUSH2 0x0306 01F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0306, if 0x157c3df9 == stack[-1] label_01F6: // Incoming jump from 0x01F5, if not 0x157c3df9 == stack[-1] // Inputs[1] { @01F6 stack[-1] } 01F6 80 DUP1 01F7 63 PUSH4 0x18160ddd 01FC 14 EQ 01FD 61 PUSH2 0x0319 0200 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0319, if 0x18160ddd == stack[-1] label_0201: // Incoming jump from 0x0200, if not 0x18160ddd == stack[-1] // Inputs[1] { @0201 stack[-1] } 0201 80 DUP1 0202 63 PUSH4 0x18e97fd1 0207 14 EQ 0208 61 PUSH2 0x0321 020B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0321, if 0x18e97fd1 == stack[-1] label_020C: // Incoming jump from 0x020B, if not 0x18e97fd1 == stack[-1] 020C 61 PUSH2 0x0248 020F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0248 label_0210: // Incoming jump from 0x01D4, if 0x0bcd899b > stack[-1] // Inputs[1] { @0211 stack[-1] } 0210 5B JUMPDEST 0211 80 DUP1 0212 63 PUSH4 0x01ddc3b5 0217 14 EQ 0218 61 PUSH2 0x024d 021B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024d, if 0x01ddc3b5 == stack[-1] label_021C: // Incoming jump from 0x021B, if not 0x01ddc3b5 == stack[-1] // Inputs[1] { @021C stack[-1] } 021C 80 DUP1 021D 63 PUSH4 0x01ffc9a7 0222 14 EQ 0223 61 PUSH2 0x0276 0226 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0276, if 0x01ffc9a7 == stack[-1] label_0227: // Incoming jump from 0x0226, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0227 stack[-1] } 0227 80 DUP1 0228 63 PUSH4 0x06fdde03 022D 14 EQ 022E 61 PUSH2 0x0296 0231 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0296, if 0x06fdde03 == stack[-1] label_0232: // Incoming jump from 0x0231, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0232 stack[-1] } 0232 80 DUP1 0233 63 PUSH4 0x081812fc 0238 14 EQ 0239 61 PUSH2 0x02ab 023C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ab, if 0x081812fc == stack[-1] label_023D: // Incoming jump from 0x023C, if not 0x081812fc == stack[-1] // Inputs[1] { @023D stack[-1] } 023D 80 DUP1 023E 63 PUSH4 0x095ea7b3 0243 14 EQ 0244 61 PUSH2 0x02cb 0247 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cb, if 0x095ea7b3 == stack[-1] label_0248: // Incoming jump from 0x01C8 // Incoming jump from 0x020F // Incoming jump from 0x018C // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00FE // Incoming jump from 0x00B7 // Incoming jump from 0x013A // Incoming jump from 0x007B // Incoming jump from 0x0247, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @024C memory[0x00:0x00] } 0248 5B JUMPDEST 0249 60 PUSH1 0x00 024B 80 DUP1 024C FD *REVERT // Stack delta = +0 // Outputs[1] { @024C revert(memory[0x00:0x00]); } // Block terminates label_024D: // Incoming jump from 0x021B, if 0x01ddc3b5 == stack[-1] // Inputs[1] { @0254 msg.data.length } 024D 5B JUMPDEST 024E 61 PUSH2 0x0260 0251 61 PUSH2 0x025b 0254 36 CALLDATASIZE 0255 60 PUSH1 0x04 0257 61 PUSH2 0x2cda 025A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024E stack[0] = 0x0260 // @0251 stack[1] = 0x025b // @0254 stack[2] = msg.data.length // @0255 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x025B label_025B: // Incoming return from call to 0x2CDA at 0x025A 025B 5B JUMPDEST 025C 61 PUSH2 0x0537 025F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0537 label_0260: // Incoming return from call to 0x0CA7 at 0x0387 // Incoming return from call to 0x025B at 0x025A // Incoming return from call to 0x03BC at 0x03BB // Incoming return from call to 0x0532 at 0x0531 // Incoming return from call to 0x051F at 0x051E // Incoming return from call to 0x173F at 0x04D7 // Inputs[2] // { // @0263 memory[0x40:0x60] // @0267 stack[-1] // } 0260 5B JUMPDEST 0261 60 PUSH1 0x40 0263 51 MLOAD 0264 61 PUSH2 0x026d 0267 91 SWAP2 0268 90 SWAP1 0269 61 PUSH2 0x3019 026C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0267 stack[-1] = 0x026d // @0268 stack[1] = memory[0x40:0x60] // @0268 stack[0] = stack[-1] // } // Block ends with call to 0x3019, returns to 0x026D label_026D: // Incoming return from call to 0x300E at 0x0295 // Incoming return from call to 0x3019 at 0x026C // Incoming return from call to 0x2F7D at 0x02CA // Inputs[3] // { // @0270 memory[0x40:0x60] // @0272 stack[-1] // @0275 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 026D 5B JUMPDEST 026E 60 PUSH1 0x40 0270 51 MLOAD 0271 80 DUP1 0272 91 SWAP2 0273 03 SUB 0274 90 SWAP1 0275 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0275 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0276: // Incoming jump from 0x0226, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @027D msg.data.length } 0276 5B JUMPDEST 0277 61 PUSH2 0x0289 027A 61 PUSH2 0x0284 027D 36 CALLDATASIZE 027E 60 PUSH1 0x04 0280 61 PUSH2 0x2c5e 0283 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0277 stack[0] = 0x0289 // @027A stack[1] = 0x0284 // @027D stack[2] = msg.data.length // @027E stack[3] = 0x04 // } // Block ends with call to 0x2c5e, returns to 0x0284 label_0284: // Incoming return from call to 0x2C5E at 0x0283 0284 5B JUMPDEST 0285 61 PUSH2 0x0549 0288 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0549 label_0289: // Incoming return from call to 0x0284 at 0x0283 // Inputs[2] // { // @028C memory[0x40:0x60] // @0290 stack[-1] // } 0289 5B JUMPDEST 028A 60 PUSH1 0x40 028C 51 MLOAD 028D 61 PUSH2 0x026d 0290 91 SWAP2 0291 90 SWAP1 0292 61 PUSH2 0x300e 0295 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0290 stack[-1] = 0x026d // @0291 stack[1] = memory[0x40:0x60] // @0291 stack[0] = stack[-1] // } // Block ends with call to 0x300e, returns to 0x026D label_0296: // Incoming jump from 0x0231, if 0x06fdde03 == stack[-1] 0296 5B JUMPDEST 0297 61 PUSH2 0x029e 029A 61 PUSH2 0x0568 029D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0297 stack[0] = 0x029e } // Block ends with call to 0x0568, returns to 0x029E label_029E: // Incoming return from call to 0x04CB at 0x04CA // Incoming return from call to 0x0568 at 0x029D // Incoming return from call to 0x0F78 at 0x0401 // Incoming return from call to 0x1325 at 0x0442 // Incoming return from call to 0x0314 at 0x0313 // Inputs[2] // { // @02A1 memory[0x40:0x60] // @02A5 stack[-1] // } 029E 5B JUMPDEST 029F 60 PUSH1 0x40 02A1 51 MLOAD 02A2 61 PUSH2 0x026d 02A5 91 SWAP2 02A6 90 SWAP1 02A7 61 PUSH2 0x30c0 02AA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02A5 stack[-1] = 0x026d // @02A6 stack[1] = memory[0x40:0x60] // @02A6 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x30c0 label_02AB: // Incoming jump from 0x023C, if 0x081812fc == stack[-1] // Inputs[1] { @02B2 msg.data.length } 02AB 5B JUMPDEST 02AC 61 PUSH2 0x02be 02AF 61 PUSH2 0x02b9 02B2 36 CALLDATASIZE 02B3 60 PUSH1 0x04 02B5 61 PUSH2 0x2cda 02B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AC stack[0] = 0x02be // @02AF stack[1] = 0x02b9 // @02B2 stack[2] = msg.data.length // @02B3 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x02B9 label_02B9: // Incoming return from call to 0x2CDA at 0x02B8 02B9 5B JUMPDEST 02BA 61 PUSH2 0x05ff 02BD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05ff label_02BE: // Incoming return from call to 0x0451 at 0x0450 // Incoming return from call to 0x04E6 at 0x04E5 // Incoming return from call to 0x13A1 at 0x045D // Inputs[2] // { // @02C1 memory[0x40:0x60] // @02C5 stack[-1] // } 02BE 5B JUMPDEST 02BF 60 PUSH1 0x40 02C1 51 MLOAD 02C2 61 PUSH2 0x026d 02C5 91 SWAP2 02C6 90 SWAP1 02C7 61 PUSH2 0x2f7d 02CA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02C5 stack[-1] = 0x026d // @02C6 stack[1] = memory[0x40:0x60] // @02C6 stack[0] = stack[-1] // } // Block ends with call to 0x2f7d, returns to 0x026D label_02CB: // Incoming jump from 0x0247, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02D2 msg.data.length } 02CB 5B JUMPDEST 02CC 61 PUSH2 0x02de 02CF 61 PUSH2 0x02d9 02D2 36 CALLDATASIZE 02D3 60 PUSH1 0x04 02D5 61 PUSH2 0x2bf6 02D8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02CC stack[0] = 0x02de // @02CF stack[1] = 0x02d9 // @02D2 stack[2] = msg.data.length // @02D3 stack[3] = 0x04 // } // Block ends with call to 0x2bf6, returns to 0x02D9 label_02D9: // Incoming return from call to 0x2BF6 at 0x02D8 02D9 5B JUMPDEST 02DA 61 PUSH2 0x064b 02DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x064b label_02DE: // Incoming return from call to 0x046C at 0x046B // Incoming return from call to 0x0492 at 0x0491 02DE 5B JUMPDEST 02DF 00 *STOP // Stack delta = +0 // Outputs[1] { @02DF stop(); } // Block terminates label_02E0: // Incoming jump from 0x01DF, if 0x0bcd899b == stack[-1] // Inputs[1] { @02E7 msg.data.length } 02E0 5B JUMPDEST 02E1 61 PUSH2 0x0260 02E4 61 PUSH2 0x02ee 02E7 36 CALLDATASIZE 02E8 60 PUSH1 0x04 02EA 61 PUSH2 0x2a53 02ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E1 stack[0] = 0x0260 // @02E4 stack[1] = 0x02ee // @02E7 stack[2] = msg.data.length // @02E8 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2a53 02EE 5B JUMPDEST 02EF 61 PUSH2 0x06e3 02F2 56 *JUMP label_02F3: // Incoming jump from 0x01EA, if 0x0e2a1778 == stack[-1] // Inputs[1] { @02FA msg.data.length } 02F3 5B JUMPDEST 02F4 61 PUSH2 0x02de 02F7 61 PUSH2 0x0301 02FA 36 CALLDATASIZE 02FB 60 PUSH1 0x04 02FD 61 PUSH2 0x2c20 0300 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F4 stack[0] = 0x02de // @02F7 stack[1] = 0x0301 // @02FA stack[2] = msg.data.length // @02FB stack[3] = 0x04 // } // Block ends with call to 0x2c20, returns to 0x0301 label_0301: // Incoming return from call to 0x2C20 at 0x0300 0301 5B JUMPDEST 0302 61 PUSH2 0x06f5 0305 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06f5 label_0306: // Incoming jump from 0x01F5, if 0x157c3df9 == stack[-1] // Inputs[1] { @030D msg.data.length } 0306 5B JUMPDEST 0307 61 PUSH2 0x029e 030A 61 PUSH2 0x0314 030D 36 CALLDATASIZE 030E 60 PUSH1 0x04 0310 61 PUSH2 0x2cda 0313 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0307 stack[0] = 0x029e // @030A stack[1] = 0x0314 // @030D stack[2] = msg.data.length // @030E stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x0314 label_0314: // Incoming return from call to 0x2CDA at 0x0313 0314 5B JUMPDEST 0315 61 PUSH2 0x0919 0318 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0919 label_0319: // Incoming jump from 0x0200, if 0x18160ddd == stack[-1] 0319 5B JUMPDEST 031A 61 PUSH2 0x0260 031D 61 PUSH2 0x09e4 0320 56 *JUMP // Stack delta = +1 // Outputs[1] { @031A stack[0] = 0x0260 } // Block ends with unconditional jump to 0x09e4 label_0321: // Incoming jump from 0x020B, if 0x18e97fd1 == stack[-1] // Inputs[1] { @0328 msg.data.length } 0321 5B JUMPDEST 0322 61 PUSH2 0x02de 0325 61 PUSH2 0x032f 0328 36 CALLDATASIZE 0329 60 PUSH1 0x04 032B 61 PUSH2 0x2d15 032E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0322 stack[0] = 0x02de // @0325 stack[1] = 0x032f // @0328 stack[2] = msg.data.length // @0329 stack[3] = 0x04 // } // Block ends with call to 0x2d15, returns to 0x032F label_032F: // Incoming return from call to 0x2D15 at 0x032E 032F 5B JUMPDEST 0330 61 PUSH2 0x09f5 0333 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09f5 label_0334: // Incoming jump from 0x0198, if 0x23b872dd == stack[-1] // Inputs[1] { @033B msg.data.length } 0334 5B JUMPDEST 0335 61 PUSH2 0x02de 0338 61 PUSH2 0x0342 033B 36 CALLDATASIZE 033C 60 PUSH1 0x04 033E 61 PUSH2 0x2aa2 0341 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0335 stack[0] = 0x02de // @0338 stack[1] = 0x0342 // @033B stack[2] = msg.data.length // @033C stack[3] = 0x04 // } // Block ends with call to 0x2aa2, returns to 0x0342 label_0342: // Incoming return from call to 0x2AA2 at 0x0341 0342 5B JUMPDEST 0343 61 PUSH2 0x0b54 0346 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b54 label_0347: // Incoming jump from 0x01A3, if 0x28220f35 == stack[-1] // Inputs[1] { @034E msg.data.length } 0347 5B JUMPDEST 0348 61 PUSH2 0x02de 034B 61 PUSH2 0x0355 034E 36 CALLDATASIZE 034F 60 PUSH1 0x04 0351 61 PUSH2 0x2cda 0354 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0348 stack[0] = 0x02de // @034B stack[1] = 0x0355 // @034E stack[2] = msg.data.length // @034F stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x0355 label_0355: // Incoming return from call to 0x2CDA at 0x0354 0355 5B JUMPDEST 0356 61 PUSH2 0x0b8c 0359 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b8c label_035A: // Incoming jump from 0x01AE, if 0x2cca3237 == stack[-1] // Inputs[1] { @0361 msg.data.length } 035A 5B JUMPDEST 035B 61 PUSH2 0x02de 035E 61 PUSH2 0x0368 0361 36 CALLDATASIZE 0362 60 PUSH1 0x04 0364 61 PUSH2 0x2c96 0367 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @035B stack[0] = 0x02de // @035E stack[1] = 0x0368 // @0361 stack[2] = msg.data.length // @0362 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2c96 0368 5B JUMPDEST 0369 61 PUSH2 0x0c3a 036C 56 *JUMP label_036D: // Incoming jump from 0x01B9, if 0x2f745c59 == stack[-1] // Inputs[1] { @0374 msg.data.length } 036D 5B JUMPDEST 036E 61 PUSH2 0x0260 0371 61 PUSH2 0x037b 0374 36 CALLDATASIZE 0375 60 PUSH1 0x04 0377 61 PUSH2 0x2bf6 037A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036E stack[0] = 0x0260 // @0371 stack[1] = 0x037b // @0374 stack[2] = msg.data.length // @0375 stack[3] = 0x04 // } // Block ends with call to 0x2bf6, returns to 0x037B label_037B: // Incoming return from call to 0x2BF6 at 0x037A 037B 5B JUMPDEST 037C 61 PUSH2 0x0c76 037F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c76 label_0380: // Incoming jump from 0x01C4, if 0x30adf81f == stack[-1] 0380 5B JUMPDEST 0381 61 PUSH2 0x0260 0384 61 PUSH2 0x0ca7 0387 56 *JUMP // Stack delta = +1 // Outputs[1] { @0381 stack[0] = 0x0260 } // Block ends with call to 0x0ca7, returns to 0x0260 label_0388: // Incoming jump from 0x015C, if 0x42842e0e == stack[-1] // Inputs[1] { @038F msg.data.length } 0388 5B JUMPDEST 0389 61 PUSH2 0x02de 038C 61 PUSH2 0x0396 038F 36 CALLDATASIZE 0390 60 PUSH1 0x04 0392 61 PUSH2 0x2aa2 0395 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0389 stack[0] = 0x02de // @038C stack[1] = 0x0396 // @038F stack[2] = msg.data.length // @0390 stack[3] = 0x04 // } // Block ends with call to 0x2aa2, returns to 0x0396 label_0396: // Incoming return from call to 0x2AA2 at 0x0395 0396 5B JUMPDEST 0397 61 PUSH2 0x0ccb 039A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ccb label_039B: // Incoming jump from 0x0167, if 0x42966c68 == stack[-1] // Inputs[1] { @03A2 msg.data.length } 039B 5B JUMPDEST 039C 61 PUSH2 0x02de 039F 61 PUSH2 0x03a9 03A2 36 CALLDATASIZE 03A3 60 PUSH1 0x04 03A5 61 PUSH2 0x2cda 03A8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039C stack[0] = 0x02de // @039F stack[1] = 0x03a9 // @03A2 stack[2] = msg.data.length // @03A3 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x03A9 label_03A9: // Incoming return from call to 0x2CDA at 0x03A8 03A9 5B JUMPDEST 03AA 61 PUSH2 0x0ce6 03AD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ce6 label_03AE: // Incoming jump from 0x0172, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @03B5 msg.data.length } 03AE 5B JUMPDEST 03AF 61 PUSH2 0x0260 03B2 61 PUSH2 0x03bc 03B5 36 CALLDATASIZE 03B6 60 PUSH1 0x04 03B8 61 PUSH2 0x2cda 03BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03AF stack[0] = 0x0260 // @03B2 stack[1] = 0x03bc // @03B5 stack[2] = msg.data.length // @03B6 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x03BC label_03BC: // Incoming return from call to 0x2CDA at 0x03BB 03BC 5B JUMPDEST 03BD 61 PUSH2 0x0db8 03C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0db8 label_03C1: // Incoming jump from 0x017D, if 0x5bf62422 == stack[-1] // Inputs[1] { @03C8 msg.data.length } 03C1 5B JUMPDEST 03C2 61 PUSH2 0x02de 03C5 61 PUSH2 0x03cf 03C8 36 CALLDATASIZE 03C9 60 PUSH1 0x04 03CB 61 PUSH2 0x2de2 03CE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C2 stack[0] = 0x02de // @03C5 stack[1] = 0x03cf // @03C8 stack[2] = msg.data.length // @03C9 stack[3] = 0x04 // } // Block ends with call to 0x2de2, returns to 0x03CF label_03CF: // Incoming return from call to 0x2DE2 at 0x03CE 03CF 5B JUMPDEST 03D0 61 PUSH2 0x0dd4 03D3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd4 label_03D4: // Incoming jump from 0x0188, if 0x62f24b70 == stack[-1] // Inputs[1] { @03DB msg.data.length } 03D4 5B JUMPDEST 03D5 61 PUSH2 0x02de 03D8 61 PUSH2 0x03e2 03DB 36 CALLDATASIZE 03DC 60 PUSH1 0x04 03DE 61 PUSH2 0x2d8a 03E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D5 stack[0] = 0x02de // @03D8 stack[1] = 0x03e2 // @03DB stack[2] = msg.data.length // @03DC stack[3] = 0x04 // } // Block ends with call to 0x2d8a, returns to 0x03E2 label_03E2: // Incoming return from call to 0x2D8A at 0x03E1 03E2 5B JUMPDEST 03E3 61 PUSH2 0x0e8b 03E6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e8b label_03E7: // Incoming jump from 0x010A, if 0x6352211e == stack[-1] // Inputs[1] { @03EE msg.data.length } 03E7 5B JUMPDEST 03E8 61 PUSH2 0x02be 03EB 61 PUSH2 0x03f5 03EE 36 CALLDATASIZE 03EF 60 PUSH1 0x04 03F1 61 PUSH2 0x2cda 03F4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03E8 stack[0] = 0x02be // @03EB stack[1] = 0x03f5 // @03EE stack[2] = msg.data.length // @03EF stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x03F5 label_03F5: // Incoming return from call to 0x2CDA at 0x03F4 03F5 5B JUMPDEST 03F6 61 PUSH2 0x0f4a 03F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f4a label_03FA: // Incoming jump from 0x0115, if 0x6c0360eb == stack[-1] 03FA 5B JUMPDEST 03FB 61 PUSH2 0x029e 03FE 61 PUSH2 0x0f78 0401 56 *JUMP // Stack delta = +1 // Outputs[1] { @03FB stack[0] = 0x029e } // Block ends with call to 0x0f78, returns to 0x029E label_0402: // Incoming jump from 0x0120, if 0x70a08231 == stack[-1] // Inputs[1] { @0409 msg.data.length } 0402 5B JUMPDEST 0403 61 PUSH2 0x0260 0406 61 PUSH2 0x0410 0409 36 CALLDATASIZE 040A 60 PUSH1 0x04 040C 61 PUSH2 0x2a53 040F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0403 stack[0] = 0x0260 // @0406 stack[1] = 0x0410 // @0409 stack[2] = msg.data.length // @040A stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2a53 0410 5B JUMPDEST 0411 61 PUSH2 0x0fd9 0414 56 *JUMP label_0415: // Incoming jump from 0x012B, if 0x75682e79 == stack[-1] // Inputs[1] { @041C msg.data.length } 0415 5B JUMPDEST 0416 61 PUSH2 0x02de 0419 61 PUSH2 0x0423 041C 36 CALLDATASIZE 041D 60 PUSH1 0x04 041F 61 PUSH2 0x2d15 0422 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0416 stack[0] = 0x02de // @0419 stack[1] = 0x0423 // @041C stack[2] = msg.data.length // @041D stack[3] = 0x04 // } // Block ends with call to 0x2d15, returns to 0x0423 label_0423: // Incoming return from call to 0x2D15 at 0x0422 0423 5B JUMPDEST 0424 61 PUSH2 0x1022 0427 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1022 label_0428: // Incoming jump from 0x0136, if 0x7a7a1202 == stack[-1] // Inputs[1] { @042F msg.data.length } 0428 5B JUMPDEST 0429 61 PUSH2 0x02de 042C 61 PUSH2 0x0436 042F 36 CALLDATASIZE 0430 60 PUSH1 0x04 0432 61 PUSH2 0x2b85 0435 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0429 stack[0] = 0x02de // @042C stack[1] = 0x0436 // @042F stack[2] = msg.data.length // @0430 stack[3] = 0x04 // } // Block ends with call to 0x2b85, returns to 0x0436 label_0436: // Incoming return from call to 0x2B85 at 0x0435 0436 5B JUMPDEST 0437 61 PUSH2 0x116b 043A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x116b label_043B: // Incoming jump from 0x00CE, if 0x95d89b41 == stack[-1] 043B 5B JUMPDEST 043C 61 PUSH2 0x029e 043F 61 PUSH2 0x1325 0442 56 *JUMP // Stack delta = +1 // Outputs[1] { @043C stack[0] = 0x029e } // Block ends with call to 0x1325, returns to 0x029E label_0443: // Incoming jump from 0x00D9, if 0x9d8e7260 == stack[-1] // Inputs[1] { @044A msg.data.length } 0443 5B JUMPDEST 0444 61 PUSH2 0x02be 0447 61 PUSH2 0x0451 044A 36 CALLDATASIZE 044B 60 PUSH1 0x04 044D 61 PUSH2 0x2cda 0450 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0444 stack[0] = 0x02be // @0447 stack[1] = 0x0451 // @044A stack[2] = msg.data.length // @044B stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x0451 label_0451: // Incoming return from call to 0x2CDA at 0x0450 0451 5B JUMPDEST 0452 61 PUSH2 0x1386 0455 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1386 label_0456: // Incoming jump from 0x00E4, if 0xa1794bcd == stack[-1] 0456 5B JUMPDEST 0457 61 PUSH2 0x02be 045A 61 PUSH2 0x13a1 045D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0457 stack[0] = 0x02be } // Block ends with call to 0x13a1, returns to 0x02BE label_045E: // Incoming jump from 0x00EF, if 0xa22cb465 == stack[-1] // Inputs[1] { @0465 msg.data.length } 045E 5B JUMPDEST 045F 61 PUSH2 0x02de 0462 61 PUSH2 0x046c 0465 36 CALLDATASIZE 0466 60 PUSH1 0x04 0468 61 PUSH2 0x2b4a 046B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @045F stack[0] = 0x02de // @0462 stack[1] = 0x046c // @0465 stack[2] = msg.data.length // @0466 stack[3] = 0x04 // } // Block ends with call to 0x2b4a, returns to 0x046C label_046C: // Incoming return from call to 0x2B4A at 0x046B 046C 5B JUMPDEST 046D 61 PUSH2 0x13b0 0470 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13b0 label_0471: // Incoming jump from 0x00FA, if 0xb1e130fc == stack[-1] // Inputs[1] { @0478 msg.data.length } 0471 5B JUMPDEST 0472 61 PUSH2 0x02de 0475 61 PUSH2 0x047f 0478 36 CALLDATASIZE 0479 60 PUSH1 0x04 047B 61 PUSH2 0x2cda 047E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0472 stack[0] = 0x02de // @0475 stack[1] = 0x047f // @0478 stack[2] = msg.data.length // @0479 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x047F label_047F: // Incoming return from call to 0x2CDA at 0x047E 047F 5B JUMPDEST 0480 61 PUSH2 0x147e 0483 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x147e label_0484: // Incoming jump from 0x0087, if 0xb320f459 == stack[-1] // Inputs[1] { @048B msg.data.length } 0484 5B JUMPDEST 0485 61 PUSH2 0x02de 0488 61 PUSH2 0x0492 048B 36 CALLDATASIZE 048C 60 PUSH1 0x04 048E 61 PUSH2 0x2cda 0491 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0485 stack[0] = 0x02de // @0488 stack[1] = 0x0492 // @048B stack[2] = msg.data.length // @048C stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x0492 label_0492: // Incoming return from call to 0x2CDA at 0x0491 0492 5B JUMPDEST 0493 61 PUSH2 0x14f2 0496 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14f2 label_0497: // Incoming jump from 0x0092, if 0xb88d4fde == stack[-1] // Inputs[1] { @049E msg.data.length } 0497 5B JUMPDEST 0498 61 PUSH2 0x02de 049B 61 PUSH2 0x04a5 049E 36 CALLDATASIZE 049F 60 PUSH1 0x04 04A1 61 PUSH2 0x2ae2 04A4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0498 stack[0] = 0x02de // @049B stack[1] = 0x04a5 // @049E stack[2] = msg.data.length // @049F stack[3] = 0x04 // } // Block ends with call to 0x2ae2, returns to 0x04A5 label_04A5: // Incoming return from call to 0x2AE2 at 0x04A4 04A5 5B JUMPDEST 04A6 61 PUSH2 0x15b0 04A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15b0 label_04AA: // Incoming jump from 0x009D, if 0xba339399 == stack[-1] // Inputs[1] { @04B1 msg.data.length } 04AA 5B JUMPDEST 04AB 61 PUSH2 0x02de 04AE 61 PUSH2 0x04b8 04B1 36 CALLDATASIZE 04B2 60 PUSH1 0x04 04B4 61 PUSH2 0x2de2 04B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04AB stack[0] = 0x02de // @04AE stack[1] = 0x04b8 // @04B1 stack[2] = msg.data.length // @04B2 stack[3] = 0x04 // } // Block ends with call to 0x2de2, returns to 0x04B8 label_04B8: // Incoming return from call to 0x2DE2 at 0x04B7 04B8 5B JUMPDEST 04B9 61 PUSH2 0x15ef 04BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15ef label_04BD: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @04C4 msg.data.length } 04BD 5B JUMPDEST 04BE 61 PUSH2 0x029e 04C1 61 PUSH2 0x04cb 04C4 36 CALLDATASIZE 04C5 60 PUSH1 0x04 04C7 61 PUSH2 0x2cda 04CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04BE stack[0] = 0x029e // @04C1 stack[1] = 0x04cb // @04C4 stack[2] = msg.data.length // @04C5 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x04CB label_04CB: // Incoming return from call to 0x2CDA at 0x04CA 04CB 5B JUMPDEST 04CC 61 PUSH2 0x1671 04CF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1671 label_04D0: // Incoming jump from 0x00B3, if 0xde5236fb == stack[-1] 04D0 5B JUMPDEST 04D1 61 PUSH2 0x0260 04D4 61 PUSH2 0x173f 04D7 56 *JUMP // Stack delta = +1 // Outputs[1] { @04D1 stack[0] = 0x0260 } // Block ends with call to 0x173f, returns to 0x0260 label_04D8: // Incoming jump from 0x004B, if 0xe0fd045f == stack[-1] // Inputs[1] { @04DF msg.data.length } 04D8 5B JUMPDEST 04D9 61 PUSH2 0x02be 04DC 61 PUSH2 0x04e6 04DF 36 CALLDATASIZE 04E0 60 PUSH1 0x04 04E2 61 PUSH2 0x2cda 04E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04D9 stack[0] = 0x02be // @04DC stack[1] = 0x04e6 // @04DF stack[2] = msg.data.length // @04E0 stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x04E6 label_04E6: // Incoming return from call to 0x2CDA at 0x04E5 04E6 5B JUMPDEST 04E7 61 PUSH2 0x1763 04EA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1763 label_04EB: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @04F2 msg.data.length } 04EB 5B JUMPDEST 04EC 61 PUSH2 0x0289 04EF 61 PUSH2 0x04f9 04F2 36 CALLDATASIZE 04F3 60 PUSH1 0x04 04F5 61 PUSH2 0x2a6e 04F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04EC stack[0] = 0x0289 // @04EF stack[1] = 0x04f9 // @04F2 stack[2] = msg.data.length // @04F3 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2a6e 04F9 5B JUMPDEST 04FA 61 PUSH2 0x177e 04FD 56 *JUMP label_04FE: // Incoming jump from 0x0061, if 0xf6b630f0 == stack[-1] // Inputs[1] { @0505 msg.data.length } 04FE 5B JUMPDEST 04FF 61 PUSH2 0x02de 0502 61 PUSH2 0x050c 0505 36 CALLDATASIZE 0506 60 PUSH1 0x04 0508 61 PUSH2 0x2cf2 050B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04FF stack[0] = 0x02de // @0502 stack[1] = 0x050c // @0505 stack[2] = msg.data.length // @0506 stack[3] = 0x04 // } // Block ends with call to 0x2cf2, returns to 0x050C label_050C: // Incoming return from call to 0x2CF2 at 0x050B 050C 5B JUMPDEST 050D 61 PUSH2 0x17ac 0510 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x17ac label_0511: // Incoming jump from 0x006C, if 0xf8ccd5de == stack[-1] // Inputs[1] { @0518 msg.data.length } 0511 5B JUMPDEST 0512 61 PUSH2 0x0260 0515 61 PUSH2 0x051f 0518 36 CALLDATASIZE 0519 60 PUSH1 0x04 051B 61 PUSH2 0x2bf6 051E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0512 stack[0] = 0x0260 // @0515 stack[1] = 0x051f // @0518 stack[2] = msg.data.length // @0519 stack[3] = 0x04 // } // Block ends with call to 0x2bf6, returns to 0x051F label_051F: // Incoming return from call to 0x2BF6 at 0x051E 051F 5B JUMPDEST 0520 61 PUSH2 0x1832 0523 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1832 label_0524: // Incoming jump from 0x0077, if 0xfad32197 == stack[-1] // Inputs[1] { @052B msg.data.length } 0524 5B JUMPDEST 0525 61 PUSH2 0x0260 0528 61 PUSH2 0x0532 052B 36 CALLDATASIZE 052C 60 PUSH1 0x04 052E 61 PUSH2 0x2cda 0531 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0525 stack[0] = 0x0260 // @0528 stack[1] = 0x0532 // @052B stack[2] = msg.data.length // @052C stack[3] = 0x04 // } // Block ends with call to 0x2cda, returns to 0x0532 label_0532: // Incoming return from call to 0x2CDA at 0x0531 0532 5B JUMPDEST 0533 61 PUSH2 0x184f 0536 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x184f label_0537: // Incoming jump from 0x025F // Inputs[4] // { // @053F stack[-1] // @0545 memory[0x00:0x40] // @0546 storage[keccak256(memory[0x00:0x40])] // @0547 stack[-2] // } 0537 5B JUMPDEST 0538 60 PUSH1 0x10 053A 60 PUSH1 0x20 053C 52 MSTORE 053D 60 PUSH1 0x00 053F 90 SWAP1 0540 81 DUP2 0541 52 MSTORE 0542 60 PUSH1 0x40 0544 90 SWAP1 0545 20 SHA3 0546 54 SLOAD 0547 81 DUP2 0548 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @053C memory[0x20:0x40] = 0x10 // @0541 memory[0x00:0x20] = stack[-1] // @0546 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0549: // Incoming jump from 0x0288 // Inputs[4] // { // @0553 stack[-1] // @0561 memory[0x00:0x40] // @0562 storage[keccak256(memory[0x00:0x40])] // @0566 stack[-2] // } 0549 5B JUMPDEST 054A 60 PUSH1 0x01 054C 60 PUSH1 0x01 054E 60 PUSH1 0xe0 0550 1B SHL 0551 03 SUB 0552 19 NOT 0553 16 AND 0554 60 PUSH1 0x00 0556 90 SWAP1 0557 81 DUP2 0558 52 MSTORE 0559 60 PUSH1 0x20 055B 81 DUP2 055C 90 SWAP1 055D 52 MSTORE 055E 60 PUSH1 0x40 0560 90 SWAP1 0561 20 SHA3 0562 54 SLOAD 0563 60 PUSH1 0xff 0565 16 AND 0566 90 SWAP1 0567 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0558 memory[0x00:0x20] = ~((0x01 << 0xe0) - 0x01) & stack[-1] // @055D memory[0x20:0x40] = 0x00 // @0566 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0568: // Incoming call from 0x029D, returns to 0x029E // Inputs[2] // { // @056C storage[0x06] // @0570 memory[0x40:0x60] // } 0568 5B JUMPDEST 0569 60 PUSH1 0x06 056B 80 DUP1 056C 54 SLOAD 056D 60 PUSH1 0x40 056F 80 DUP1 0570 51 MLOAD 0571 60 PUSH1 0x20 0573 60 PUSH1 0x1f 0575 60 PUSH1 0x02 0577 60 PUSH1 0x00 0579 19 NOT 057A 61 PUSH2 0x0100 057D 60 PUSH1 0x01 057F 88 DUP9 0580 16 AND 0581 15 ISZERO 0582 02 MUL 0583 01 ADD 0584 90 SWAP1 0585 95 SWAP6 0586 16 AND 0587 94 SWAP5 0588 90 SWAP1 0589 94 SWAP5 058A 04 DIV 058B 93 SWAP4 058C 84 DUP5 058D 01 ADD 058E 81 DUP2 058F 90 SWAP1 0590 04 DIV 0591 81 DUP2 0592 02 MUL 0593 82 DUP3 0594 01 ADD 0595 81 DUP2 0596 01 ADD 0597 90 SWAP1 0598 92 SWAP3 0599 52 MSTORE 059A 82 DUP3 059B 81 DUP2 059C 52 MSTORE 059D 60 PUSH1 0x60 059F 93 SWAP4 05A0 90 SWAP1 05A1 92 SWAP3 05A2 90 SWAP1 05A3 91 SWAP2 05A4 83 DUP4 05A5 01 ADD 05A6 82 DUP3 05A7 82 DUP3 05A8 80 DUP1 05A9 15 ISZERO 05AA 61 PUSH2 0x05f4 05AD 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0599 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @059C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 // @059F stack[0] = 0x60 // @05A1 stack[1] = memory[0x40:0x60] // @05A2 stack[3] = (storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 // @05A3 stack[2] = 0x06 // @05A5 stack[4] = memory[0x40:0x60] + 0x20 // @05A6 stack[5] = 0x06 // @05A7 stack[6] = (storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x05f4, if !((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02) label_05AE: // Incoming jump from 0x05AD, if not !((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @05AE stack[-1] } 05AE 80 DUP1 05AF 60 PUSH1 0x1f 05B1 10 LT 05B2 61 PUSH2 0x05c9 05B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c9, if 0x1f < stack[-1] label_05B6: // Incoming jump from 0x05B5, if not 0x1f < stack[-1] // Inputs[4] // { // @05BA stack[-2] // @05BB storage[stack[-2]] // @05BE stack[-3] // @05C0 stack[-1] // } 05B6 61 PUSH2 0x0100 05B9 80 DUP1 05BA 83 DUP4 05BB 54 SLOAD 05BC 04 DIV 05BD 02 MUL 05BE 83 DUP4 05BF 52 MSTORE 05C0 91 SWAP2 05C1 60 PUSH1 0x20 05C3 01 ADD 05C4 91 SWAP2 05C5 61 PUSH2 0x05f4 05C8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @05BF memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @05C4 stack[-1] = stack[-1] // @05C4 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x05f4 label_05C9: // Incoming jump from 0x1372, if 0x1f < stack[-1] // Incoming jump from 0x0FC5, if 0x1f < stack[-1] // Incoming jump from 0x05B5, if 0x1f < stack[-1] // Inputs[5] // { // @05CA stack[-3] // @05CB stack[-1] // @05CD stack[-2] // @05D5 memory[0x00:0x20] // @05D9 storage[keccak256(memory[0x00:0x20])] // } 05C9 5B JUMPDEST 05CA 82 DUP3 05CB 01 ADD 05CC 91 SWAP2 05CD 90 SWAP1 05CE 60 PUSH1 0x00 05D0 52 MSTORE 05D1 60 PUSH1 0x20 05D3 60 PUSH1 0x00 05D5 20 SHA3 05D6 90 SWAP1 05D7 5B JUMPDEST 05D8 81 DUP2 05D9 54 SLOAD 05DA 81 DUP2 05DB 52 MSTORE 05DC 90 SWAP1 05DD 60 PUSH1 0x01 05DF 01 ADD 05E0 90 SWAP1 05E1 60 PUSH1 0x20 05E3 01 ADD 05E4 80 DUP1 05E5 83 DUP4 05E6 11 GT 05E7 61 PUSH2 0x05d7 05EA 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @05CC stack[-3] = stack[-3] + stack[-1] // @05D0 memory[0x00:0x20] = stack[-2] // @05DB memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @05E0 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @05E3 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x05d7, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_05EB: // Incoming jump from 0x05EA, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x05EA, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @05EB stack[-3] // @05EC stack[-1] // } 05EB 82 DUP3 05EC 90 SWAP1 05ED 03 SUB 05EE 60 PUSH1 0x1f 05F0 16 AND 05F1 82 DUP3 05F2 01 ADD 05F3 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @05F3 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @05F3 stack[-1] = stack[-3] // } // Block continues label_05F4: // Incoming jump from 0x05C8 // Incoming jump from 0x0FD8 // Incoming jump from 0x136A, if !((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x05AD, if !((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x05F3 // Incoming jump from 0x0FBD, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x1385 // Inputs[3] // { // @05FA stack[-7] // @05FA stack[-6] // @05FD stack[-8] // } 05F4 5B JUMPDEST 05F5 50 POP 05F6 50 POP 05F7 50 POP 05F8 50 POP 05F9 50 POP 05FA 90 SWAP1 05FB 50 POP 05FC 5B JUMPDEST 05FD 90 SWAP1 05FE 56 *JUMP // Stack delta = -7 // Outputs[1] { @05FD stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_05FF: // Incoming jump from 0x02BD // Incoming jump from 0x14AE // Inputs[1] { @0605 stack[-1] } 05FF 5B JUMPDEST 0600 60 PUSH1 0x00 0602 61 PUSH2 0x060a 0605 82 DUP3 0606 61 PUSH2 0x1861 0609 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0600 stack[0] = 0x00 // @0602 stack[1] = 0x060a // @0605 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1861 060A 5B JUMPDEST 060B 61 PUSH2 0x062f 060E 57 *JUMPI 060F 60 PUSH1 0x40 0611 51 MLOAD 0612 62 PUSH3 0x461bcd 0616 60 PUSH1 0xe5 0618 1B SHL 0619 81 DUP2 061A 52 MSTORE 061B 60 PUSH1 0x04 061D 01 ADD 061E 61 PUSH2 0x0626 0621 90 SWAP1 0622 61 PUSH2 0x361f 0625 56 *JUMP label_0626: // Incoming return from call to 0x380F at 0x11BD // Incoming return from call to 0x393C at 0x1044 // Incoming return from call to 0x393C at 0x0BAE // Incoming return from call to 0x3115 at 0x1542 // Incoming return from call to 0x35A6 at 0x255F // Incoming return from call to 0x393C at 0x0A17 // Incoming return from call to 0x393C at 0x1611 // Incoming return from call to 0x3789 at 0x1B97 // Incoming return from call to 0x3973 at 0x1B00 // Incoming return from call to 0x34D0 at 0x1B76 // Incoming return from call to 0x393C at 0x1514 // Incoming return from call to 0x3115 at 0x0943 // Incoming return from call to 0x32E4 at 0x13E8 // Incoming return from call to 0x3973 at 0x1B23 // Incoming return from call to 0x393C at 0x0717 // Incoming return from call to 0x3115 at 0x169B // Incoming return from call to 0x393C at 0x0DF6 // Incoming return from call to 0x38CE at 0x1319 // Incoming return from call to 0x393C at 0x14A0 // Incoming return from call to 0x352D at 0x2189 // Incoming return from call to 0x30D3 at 0x2069 // Incoming return from call to 0x393C at 0x0EAD // Incoming return from call to 0x393C at 0x0D08 // Incoming return from call to 0x393C at 0x118D // Incoming return from call to 0x336A at 0x1B44 // Incoming return from call to 0x356F at 0x17D5 // Inputs[3] // { // @0629 memory[0x40:0x60] // @062B stack[-1] // @062E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0626 5B JUMPDEST 0627 60 PUSH1 0x40 0629 51 MLOAD 062A 80 DUP1 062B 91 SWAP2 062C 03 SUB 062D 90 SWAP1 062E FD *REVERT // Stack delta = -1 // Outputs[1] { @062E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates 062F 5B JUMPDEST 0630 50 POP 0631 60 PUSH1 0x00 0633 90 SWAP1 0634 81 DUP2 0635 52 MSTORE 0636 60 PUSH1 0x04 0638 60 PUSH1 0x20 063A 52 MSTORE 063B 60 PUSH1 0x40 063D 90 SWAP1 063E 20 SHA3 063F 54 SLOAD 0640 60 PUSH1 0x01 0642 60 PUSH1 0x01 0644 60 PUSH1 0xa0 0646 1B SHL 0647 03 SUB 0648 16 AND 0649 90 SWAP1 064A 56 *JUMP label_064B: // Incoming jump from 0x02DD // Inputs[1] { @0651 stack[-1] } 064B 5B JUMPDEST 064C 60 PUSH1 0x00 064E 61 PUSH2 0x0656 0651 82 DUP3 0652 61 PUSH2 0x0f4a 0655 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @064C stack[0] = 0x00 // @064E stack[1] = 0x0656 // @0651 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0f4a 0656 5B JUMPDEST 0657 90 SWAP1 0658 50 POP 0659 80 DUP1 065A 60 PUSH1 0x01 065C 60 PUSH1 0x01 065E 60 PUSH1 0xa0 0660 1B SHL 0661 03 SUB 0662 16 AND 0663 83 DUP4 0664 60 PUSH1 0x01 0666 60 PUSH1 0x01 0668 60 PUSH1 0xa0 066A 1B SHL 066B 03 SUB 066C 16 AND 066D 14 EQ 066E 15 ISZERO 066F 61 PUSH2 0x068a 0672 57 *JUMPI 0673 60 PUSH1 0x40 0675 51 MLOAD 0676 62 PUSH3 0x461bcd 067A 60 PUSH1 0xe5 067C 1B SHL 067D 81 DUP2 067E 52 MSTORE 067F 60 PUSH1 0x04 0681 01 ADD 0682 61 PUSH2 0x0626 0685 90 SWAP1 0686 61 PUSH2 0x37ce 0689 56 *JUMP 068A 5B JUMPDEST 068B 80 DUP1 068C 60 PUSH1 0x01 068E 60 PUSH1 0x01 0690 60 PUSH1 0xa0 0692 1B SHL 0693 03 SUB 0694 16 AND 0695 61 PUSH2 0x069c 0698 61 PUSH2 0x1874 069B 56 *JUMP 069C 5B JUMPDEST 069D 60 PUSH1 0x01 069F 60 PUSH1 0x01 06A1 60 PUSH1 0xa0 06A3 1B SHL 06A4 03 SUB 06A5 16 AND 06A6 14 EQ 06A7 80 DUP1 06A8 61 PUSH2 0x06b8 06AB 57 *JUMPI 06AC 50 POP 06AD 61 PUSH2 0x06b8 06B0 81 DUP2 06B1 61 PUSH2 0x04f9 06B4 61 PUSH2 0x1874 06B7 56 *JUMP 06B8 5B JUMPDEST 06B9 61 PUSH2 0x06d4 06BC 57 *JUMPI 06BD 60 PUSH1 0x40 06BF 51 MLOAD 06C0 62 PUSH3 0x461bcd 06C4 60 PUSH1 0xe5 06C6 1B SHL 06C7 81 DUP2 06C8 52 MSTORE 06C9 60 PUSH1 0x04 06CB 01 ADD 06CC 61 PUSH2 0x0626 06CF 90 SWAP1 06D0 61 PUSH2 0x33fa 06D3 56 *JUMP 06D4 5B JUMPDEST 06D5 61 PUSH2 0x06de 06D8 83 DUP4 06D9 83 DUP4 06DA 61 PUSH2 0x1878 06DD 56 *JUMP 06DE 5B JUMPDEST 06DF 50 POP 06E0 50 POP 06E1 50 POP 06E2 56 *JUMP 06E3 5B JUMPDEST 06E4 60 PUSH1 0x14 06E6 60 PUSH1 0x20 06E8 52 MSTORE 06E9 60 PUSH1 0x00 06EB 90 SWAP1 06EC 81 DUP2 06ED 52 MSTORE 06EE 60 PUSH1 0x40 06F0 90 SWAP1 06F1 20 SHA3 06F2 54 SLOAD 06F3 81 DUP2 06F4 56 *JUMP label_06F5: // Incoming jump from 0x0305 // Inputs[1] { @06FA storage[0x0a] } 06F5 5B JUMPDEST 06F6 60 PUSH1 0x02 06F8 60 PUSH1 0x0a 06FA 54 SLOAD 06FB 14 EQ 06FC 15 ISZERO 06FD 61 PUSH2 0x0718 0700 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0718, if !(storage[0x0a] == 0x02) label_0701: // Incoming jump from 0x0700, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0703 memory[0x40:0x60] } 0701 60 PUSH1 0x40 0703 51 MLOAD 0704 62 PUSH3 0x461bcd 0708 60 PUSH1 0xe5 070A 1B SHL 070B 81 DUP2 070C 52 MSTORE 070D 60 PUSH1 0x04 070F 01 ADD 0710 61 PUSH2 0x0626 0713 90 SWAP1 0714 61 PUSH2 0x393c 0717 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @070C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0713 stack[0] = 0x0626 // @0713 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_0718: // Incoming jump from 0x0700, if !(storage[0x0a] == 0x02) // Inputs[1] { @071E stack[-2] } 0718 5B JUMPDEST 0719 60 PUSH1 0x02 071B 60 PUSH1 0x0a 071D 55 SSTORE 071E 81 DUP2 071F 61 PUSH2 0x0727 0722 81 DUP2 0723 61 PUSH2 0x1861 0726 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @071D storage[0x0a] = 0x02 // @071E stack[0] = stack[-2] // @071F stack[1] = 0x0727 // @0722 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1861 0727 5B JUMPDEST 0728 61 PUSH2 0x0743 072B 57 *JUMPI 072C 60 PUSH1 0x40 072E 51 MLOAD 072F 62 PUSH3 0x461bcd 0733 60 PUSH1 0xe5 0735 1B SHL 0736 81 DUP2 0737 52 MSTORE 0738 60 PUSH1 0x04 073A 01 ADD 073B 61 PUSH2 0x0626 073E 90 SWAP1 073F 61 PUSH2 0x3905 0742 56 *JUMP 0743 5B JUMPDEST 0744 81 DUP2 0745 51 MLOAD 0746 15 ISZERO 0747 80 DUP1 0748 61 PUSH2 0x0752 074B 57 *JUMPI 074C 50 POP 074D 81 DUP2 074E 51 MLOAD 074F 42 TIMESTAMP 0750 11 GT 0751 15 ISZERO 0752 5B JUMPDEST 0753 61 PUSH2 0x076e 0756 57 *JUMPI 0757 60 PUSH1 0x40 0759 51 MLOAD 075A 62 PUSH3 0x461bcd 075E 60 PUSH1 0xe5 0760 1B SHL 0761 81 DUP2 0762 52 MSTORE 0763 60 PUSH1 0x04 0765 01 ADD 0766 61 PUSH2 0x0626 0769 90 SWAP1 076A 61 PUSH2 0x34a1 076D 56 *JUMP 076E 5B JUMPDEST 076F 60 PUSH1 0x01 0771 60 PUSH1 0x01 0773 60 PUSH1 0xa0 0775 1B SHL 0776 03 SUB 0777 84 DUP5 0778 16 AND 0779 61 PUSH2 0x0794 077C 57 *JUMPI 077D 60 PUSH1 0x40 077F 51 MLOAD 0780 62 PUSH3 0x461bcd 0784 60 PUSH1 0xe5 0786 1B SHL 0787 81 DUP2 0788 52 MSTORE 0789 60 PUSH1 0x04 078B 01 ADD 078C 61 PUSH2 0x0626 078F 90 SWAP1 0790 61 PUSH2 0x31af 0793 56 *JUMP 0794 5B JUMPDEST 0795 60 PUSH1 0x00 0797 61 PUSH2 0x079e 079A 61 PUSH2 0x18e6 079D 56 *JUMP 079E 5B JUMPDEST 079F 90 SWAP1 07A0 50 POP 07A1 60 PUSH1 0x00 07A3 81 DUP2 07A4 7F PUSH32 0x49ecf333e5b8c95c40fdafc95c1ad136e8914a8fb55e9dc8bb01eaa83a2df9ad 07C5 87 DUP8 07C6 87 DUP8 07C7 60 PUSH1 0x13 07C9 85 DUP6 07CA 61 PUSH2 0x07d2 07CD 83 DUP4 07CE 61 PUSH2 0x0f4a 07D1 56 *JUMP 07D2 5B JUMPDEST 07D3 60 PUSH1 0x01 07D5 60 PUSH1 0x01 07D7 60 PUSH1 0xa0 07D9 1B SHL 07DA 03 SUB 07DB 16 AND 07DC 81 DUP2 07DD 52 MSTORE 07DE 60 PUSH1 0x20 07E0 80 DUP1 07E1 82 DUP3 07E2 01 ADD 07E3 92 SWAP3 07E4 90 SWAP1 07E5 92 SWAP3 07E6 52 MSTORE 07E7 60 PUSH1 0x40 07E9 90 SWAP1 07EA 81 DUP2 07EB 01 ADD 07EC 60 PUSH1 0x00 07EE 90 SWAP1 07EF 81 DUP2 07F0 20 SHA3 07F1 8C DUP13 07F2 82 DUP3 07F3 52 MSTORE 07F4 83 DUP4 07F5 52 MSTORE 07F6 81 DUP2 07F7 90 SWAP1 07F8 20 SHA3 07F9 80 DUP1 07FA 54 SLOAD 07FB 60 PUSH1 0x01 07FD 81 DUP2 07FE 01 ADD 07FF 90 SWAP1 0800 91 SWAP2 0801 55 SSTORE 0802 8A DUP11 0803 51 MLOAD 0804 91 SWAP2 0805 51 MLOAD 0806 61 PUSH2 0x0815 0809 96 SWAP7 080A 95 SWAP6 080B 94 SWAP5 080C 93 SWAP4 080D 91 SWAP2 080E 92 SWAP3 080F 91 SWAP2 0810 01 ADD 0811 61 PUSH2 0x3022 0814 56 *JUMP 0815 5B JUMPDEST 0816 60 PUSH1 0x40 0818 51 MLOAD 0819 60 PUSH1 0x20 081B 81 DUP2 081C 83 DUP4 081D 03 SUB 081E 03 SUB 081F 81 DUP2 0820 52 MSTORE 0821 90 SWAP1 0822 60 PUSH1 0x40 0824 52 MSTORE 0825 80 DUP1 0826 51 MLOAD 0827 90 SWAP1 0828 60 PUSH1 0x20 082A 01 ADD 082B 20 SHA3 082C 60 PUSH1 0x40 082E 51 MLOAD 082F 60 PUSH1 0x20 0831 01 ADD 0832 61 PUSH2 0x083c 0835 92 SWAP3 0836 91 SWAP2 0837 90 SWAP1 0838 61 PUSH2 0x2ef8 083B 56 *JUMP 083C 5B JUMPDEST 083D 60 PUSH1 0x40 083F 51 MLOAD 0840 60 PUSH1 0x20 0842 81 DUP2 0843 83 DUP4 0844 03 SUB 0845 03 SUB 0846 81 DUP2 0847 52 MSTORE 0848 90 SWAP1 0849 60 PUSH1 0x40 084B 52 MSTORE 084C 80 DUP1 084D 51 MLOAD 084E 90 SWAP1 084F 60 PUSH1 0x20 0851 01 ADD 0852 20 SHA3 0853 90 SWAP1 0854 50 POP 0855 60 PUSH1 0x00 0857 60 PUSH1 0x01 0859 82 DUP3 085A 86 DUP7 085B 60 PUSH1 0x20 085D 01 ADD 085E 51 MLOAD 085F 87 DUP8 0860 60 PUSH1 0x40 0862 01 ADD 0863 51 MLOAD 0864 88 DUP9 0865 60 PUSH1 0x60 0867 01 ADD 0868 51 MLOAD 0869 60 PUSH1 0x40 086B 51 MLOAD 086C 60 PUSH1 0x00 086E 81 DUP2 086F 52 MSTORE 0870 60 PUSH1 0x20 0872 01 ADD 0873 60 PUSH1 0x40 0875 52 MSTORE 0876 60 PUSH1 0x40 0878 51 MLOAD 0879 61 PUSH2 0x0885 087C 94 SWAP5 087D 93 SWAP4 087E 92 SWAP3 087F 91 SWAP2 0880 90 SWAP1 0881 61 PUSH2 0x30a2 0884 56 *JUMP 0885 5B JUMPDEST 0886 60 PUSH1 0x20 0888 60 PUSH1 0x40 088A 51 MLOAD 088B 60 PUSH1 0x20 088D 81 DUP2 088E 03 SUB 088F 90 SWAP1 0890 80 DUP1 0891 84 DUP5 0892 03 SUB 0893 90 SWAP1 0894 85 DUP6 0895 5A GAS 0896 FA STATICCALL 0897 15 ISZERO 0898 80 DUP1 0899 15 ISZERO 089A 61 PUSH2 0x08a7 089D 57 *JUMPI 089E 3D RETURNDATASIZE 089F 60 PUSH1 0x00 08A1 80 DUP1 08A2 3E RETURNDATACOPY 08A3 3D RETURNDATASIZE 08A4 60 PUSH1 0x00 08A6 FD *REVERT 08A7 5B JUMPDEST 08A8 50 POP 08A9 50 POP 08AA 60 PUSH1 0x40 08AC 51 MLOAD 08AD 60 PUSH1 0x1f 08AF 19 NOT 08B0 01 ADD 08B1 51 MLOAD 08B2 91 SWAP2 08B3 50 POP 08B4 50 POP 08B5 60 PUSH1 0x01 08B7 60 PUSH1 0x01 08B9 60 PUSH1 0xa0 08BB 1B SHL 08BC 03 SUB 08BD 81 DUP2 08BE 16 AND 08BF 15 ISZERO 08C0 80 DUP1 08C1 15 ISZERO 08C2 90 SWAP1 08C3 61 PUSH2 0x08e5 08C6 57 *JUMPI 08C7 50 POP 08C8 80 DUP1 08C9 60 PUSH1 0x01 08CB 60 PUSH1 0x01 08CD 60 PUSH1 0xa0 08CF 1B SHL 08D0 03 SUB 08D1 16 AND 08D2 61 PUSH2 0x08da 08D5 87 DUP8 08D6 61 PUSH2 0x0f4a 08D9 56 *JUMP 08DA 5B JUMPDEST 08DB 60 PUSH1 0x01 08DD 60 PUSH1 0x01 08DF 60 PUSH1 0xa0 08E1 1B SHL 08E2 03 SUB 08E3 16 AND 08E4 14 EQ 08E5 5B JUMPDEST 08E6 61 PUSH2 0x0901 08E9 57 *JUMPI 08EA 60 PUSH1 0x40 08EC 51 MLOAD 08ED 62 PUSH3 0x461bcd 08F1 60 PUSH1 0xe5 08F3 1B SHL 08F4 81 DUP2 08F5 52 MSTORE 08F6 60 PUSH1 0x04 08F8 01 ADD 08F9 61 PUSH2 0x0626 08FC 90 SWAP1 08FD 61 PUSH2 0x38ce 0900 56 *JUMP 0901 5B JUMPDEST 0902 61 PUSH2 0x090b 0905 87 DUP8 0906 87 DUP8 0907 61 PUSH2 0x1878 090A 56 *JUMP 090B 5B JUMPDEST 090C 50 POP 090D 50 POP 090E 60 PUSH1 0x01 0910 60 PUSH1 0x0a 0912 55 SSTORE 0913 50 POP 0914 50 POP 0915 50 POP 0916 50 POP 0917 50 POP 0918 56 *JUMP label_0919: // Incoming jump from 0x0318 // Inputs[1] { @091C stack[-1] } 0919 5B JUMPDEST 091A 60 PUSH1 0x60 091C 81 DUP2 091D 80 DUP1 091E 61 PUSH2 0x0927 0921 60 PUSH1 0x15 0923 61 PUSH2 0x199c 0926 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @091A stack[0] = 0x60 // @091C stack[1] = stack[-1] // @091D stack[2] = stack[-1] // @091E stack[3] = 0x0927 // @0921 stack[4] = 0x15 // } // Block ends with call to 0x199c, returns to 0x0927 label_0927: // Incoming return from call to 0x199C at 0x0926 // Inputs[2] // { // @0928 stack[-1] // @0928 stack[-2] // } 0927 5B JUMPDEST 0928 11 GT 0929 61 PUSH2 0x0944 092C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0944, if stack[-1] > stack[-2] label_092D: // Incoming jump from 0x092C, if not stack[-1] > stack[-2] // Inputs[1] { @092F memory[0x40:0x60] } 092D 60 PUSH1 0x40 092F 51 MLOAD 0930 62 PUSH3 0x461bcd 0934 60 PUSH1 0xe5 0936 1B SHL 0937 81 DUP2 0938 52 MSTORE 0939 60 PUSH1 0x04 093B 01 ADD 093C 61 PUSH2 0x0626 093F 90 SWAP1 0940 61 PUSH2 0x3115 0943 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0938 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @093F stack[0] = 0x0626 // @093F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3115, returns to 0x0626 label_0944: // Incoming jump from 0x092C, if stack[-1] > stack[-2] // Inputs[4] // { // @0947 stack[-3] // @0956 memory[0x00:0x40] // @0958 storage[keccak256(memory[0x00:0x40])] // @095A memory[0x40:0x60] // } 0944 5B JUMPDEST 0945 60 PUSH1 0x00 0947 83 DUP4 0948 81 DUP2 0949 52 MSTORE 094A 60 PUSH1 0x11 094C 60 PUSH1 0x20 094E 90 SWAP1 094F 81 DUP2 0950 52 MSTORE 0951 60 PUSH1 0x40 0953 91 SWAP2 0954 82 DUP3 0955 90 SWAP1 0956 20 SHA3 0957 80 DUP1 0958 54 SLOAD 0959 83 DUP4 095A 51 MLOAD 095B 60 PUSH1 0x1f 095D 60 PUSH1 0x02 095F 60 PUSH1 0x00 0961 19 NOT 0962 61 PUSH2 0x0100 0965 60 PUSH1 0x01 0967 86 DUP7 0968 16 AND 0969 15 ISZERO 096A 02 MUL 096B 01 ADD 096C 90 SWAP1 096D 93 SWAP4 096E 16 AND 096F 92 SWAP3 0970 90 SWAP1 0971 92 SWAP3 0972 04 DIV 0973 91 SWAP2 0974 82 DUP3 0975 01 ADD 0976 84 DUP5 0977 90 SWAP1 0978 04 DIV 0979 84 DUP5 097A 02 MUL 097B 81 DUP2 097C 01 ADD 097D 84 DUP5 097E 01 ADD 097F 90 SWAP1 0980 94 SWAP5 0981 52 MSTORE 0982 80 DUP1 0983 84 DUP5 0984 52 MSTORE 0985 90 SWAP1 0986 91 SWAP2 0987 83 DUP4 0988 01 ADD 0989 82 DUP3 098A 82 DUP3 098B 80 DUP1 098C 15 ISZERO 098D 61 PUSH2 0x09d7 0990 57 *JUMPI // Stack delta = +6 // Outputs[10] // { // @0949 memory[0x00:0x20] = stack[-3] // @0950 memory[0x20:0x40] = 0x11 // @0980 stack[0] = memory[0x40:0x60] // @0981 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0984 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0985 stack[2] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0986 stack[1] = keccak256(memory[0x00:0x40]) // @0988 stack[3] = memory[0x40:0x60] + 0x20 // @0989 stack[4] = keccak256(memory[0x00:0x40]) // @098A stack[5] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x09d7, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0991: // Incoming jump from 0x0990, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0991 stack[-1] } 0991 80 DUP1 0992 60 PUSH1 0x1f 0994 10 LT 0995 61 PUSH2 0x09ac 0998 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ac, if 0x1f < stack[-1] label_0999: // Incoming jump from 0x0998, if not 0x1f < stack[-1] // Inputs[4] // { // @099D stack[-2] // @099E storage[stack[-2]] // @09A1 stack[-3] // @09A3 stack[-1] // } 0999 61 PUSH2 0x0100 099C 80 DUP1 099D 83 DUP4 099E 54 SLOAD 099F 04 DIV 09A0 02 MUL 09A1 83 DUP4 09A2 52 MSTORE 09A3 91 SWAP2 09A4 60 PUSH1 0x20 09A6 01 ADD 09A7 91 SWAP2 09A8 61 PUSH2 0x09d7 09AB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09A2 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09A7 stack[-1] = stack[-1] // @09A7 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x09d7 label_09AC: // Incoming jump from 0x0998, if 0x1f < stack[-1] // Inputs[5] // { // @09AD stack[-3] // @09AE stack[-1] // @09B0 stack[-2] // @09B8 memory[0x00:0x20] // @09BC storage[keccak256(memory[0x00:0x20])] // } 09AC 5B JUMPDEST 09AD 82 DUP3 09AE 01 ADD 09AF 91 SWAP2 09B0 90 SWAP1 09B1 60 PUSH1 0x00 09B3 52 MSTORE 09B4 60 PUSH1 0x20 09B6 60 PUSH1 0x00 09B8 20 SHA3 09B9 90 SWAP1 09BA 5B JUMPDEST 09BB 81 DUP2 09BC 54 SLOAD 09BD 81 DUP2 09BE 52 MSTORE 09BF 90 SWAP1 09C0 60 PUSH1 0x01 09C2 01 ADD 09C3 90 SWAP1 09C4 60 PUSH1 0x20 09C6 01 ADD 09C7 80 DUP1 09C8 83 DUP4 09C9 11 GT 09CA 61 PUSH2 0x09ba 09CD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @09AF stack[-3] = stack[-3] + stack[-1] // @09B3 memory[0x00:0x20] = stack[-2] // @09BE memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09C3 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09C6 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09ba, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_09CE: // Incoming jump from 0x09CD, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x09CD, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @09CE stack[-3] // @09CF stack[-1] // } 09CE 82 DUP3 09CF 90 SWAP1 09D0 03 SUB 09D1 60 PUSH1 0x1f 09D3 16 AND 09D4 82 DUP3 09D5 01 ADD 09D6 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @09D6 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @09D6 stack[-1] = stack[-3] // } // Block continues label_09D7: // Incoming jump from 0x09D6 // Incoming jump from 0x09AB // Incoming jump from 0x0990, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[4] // { // @09DD stack[-6] // @09DD stack[-8] // @09E0 stack[-10] // @09E1 stack[-9] // } 09D7 5B JUMPDEST 09D8 50 POP 09D9 50 POP 09DA 50 POP 09DB 50 POP 09DC 50 POP 09DD 91 SWAP2 09DE 50 POP 09DF 50 POP 09E0 91 SWAP2 09E1 90 SWAP1 09E2 50 POP 09E3 56 *JUMP // Stack delta = -9 // Outputs[1] { @09E0 stack[-10] = stack[-6] } // Block ends with unconditional jump to stack[-10] label_09E4: // Incoming jump from 0x0320 09E4 5B JUMPDEST 09E5 60 PUSH1 0x00 09E7 61 PUSH2 0x09f0 09EA 60 PUSH1 0x02 09EC 61 PUSH2 0x19a0 09EF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09E5 stack[0] = 0x00 // @09E7 stack[1] = 0x09f0 // @09EA stack[2] = 0x02 // } // Block ends with unconditional jump to 0x19a0 09F0 5B JUMPDEST 09F1 90 SWAP1 09F2 50 POP 09F3 90 SWAP1 09F4 56 *JUMP label_09F5: // Incoming jump from 0x0333 // Inputs[1] { @09FA storage[0x0a] } 09F5 5B JUMPDEST 09F6 60 PUSH1 0x02 09F8 60 PUSH1 0x0a 09FA 54 SLOAD 09FB 14 EQ 09FC 15 ISZERO 09FD 61 PUSH2 0x0a18 0A00 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a18, if !(storage[0x0a] == 0x02) label_0A01: // Incoming jump from 0x0A00, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0A03 memory[0x40:0x60] } 0A01 60 PUSH1 0x40 0A03 51 MLOAD 0A04 62 PUSH3 0x461bcd 0A08 60 PUSH1 0xe5 0A0A 1B SHL 0A0B 81 DUP2 0A0C 52 MSTORE 0A0D 60 PUSH1 0x04 0A0F 01 ADD 0A10 61 PUSH2 0x0626 0A13 90 SWAP1 0A14 61 PUSH2 0x393c 0A17 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A0C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A13 stack[0] = 0x0626 // @0A13 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_0A18: // Incoming jump from 0x0A00, if !(storage[0x0a] == 0x02) // Inputs[2] // { // @0A1E msg.sender // @0A1F stack[-3] // } 0A18 5B JUMPDEST 0A19 60 PUSH1 0x02 0A1B 60 PUSH1 0x0a 0A1D 55 SSTORE 0A1E 33 CALLER 0A1F 83 DUP4 0A20 61 PUSH2 0x0a29 0A23 82 DUP3 0A24 82 DUP3 0A25 61 PUSH2 0x19ab 0A28 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0A1D storage[0x0a] = 0x02 // @0A1E stack[0] = msg.sender // @0A1F stack[1] = stack[-3] // @0A20 stack[2] = 0x0a29 // @0A23 stack[3] = msg.sender // @0A24 stack[4] = stack[-3] // } // Block ends with unconditional jump to 0x19ab 0A29 5B JUMPDEST 0A2A 61 PUSH2 0x0a45 0A2D 57 *JUMPI 0A2E 60 PUSH1 0x40 0A30 51 MLOAD 0A31 62 PUSH3 0x461bcd 0A35 60 PUSH1 0xe5 0A37 1B SHL 0A38 81 DUP2 0A39 52 MSTORE 0A3A 60 PUSH1 0x04 0A3C 01 ADD 0A3D 61 PUSH2 0x0626 0A40 90 SWAP1 0A41 61 PUSH2 0x36b7 0A44 56 *JUMP 0A45 5B JUMPDEST 0A46 60 PUSH1 0x00 0A48 85 DUP6 0A49 81 DUP2 0A4A 52 MSTORE 0A4B 60 PUSH1 0x0f 0A4D 60 PUSH1 0x20 0A4F 52 MSTORE 0A50 60 PUSH1 0x40 0A52 90 SWAP1 0A53 20 SHA3 0A54 54 SLOAD 0A55 85 DUP6 0A56 90 SWAP1 0A57 61 PUSH2 0x0a72 0A5A 57 *JUMPI 0A5B 60 PUSH1 0x40 0A5D 51 MLOAD 0A5E 62 PUSH3 0x461bcd 0A62 60 PUSH1 0xe5 0A64 1B SHL 0A65 81 DUP2 0A66 52 MSTORE 0A67 60 PUSH1 0x04 0A69 01 ADD 0A6A 61 PUSH2 0x0626 0A6D 90 SWAP1 0A6E 61 PUSH2 0x3737 0A71 56 *JUMP 0A72 5B JUMPDEST 0A73 84 DUP5 0A74 84 DUP5 0A75 80 DUP1 0A76 80 DUP1 0A77 60 PUSH1 0x1f 0A79 01 ADD 0A7A 60 PUSH1 0x20 0A7C 80 DUP1 0A7D 91 SWAP2 0A7E 04 DIV 0A7F 02 MUL 0A80 60 PUSH1 0x20 0A82 01 ADD 0A83 60 PUSH1 0x40 0A85 51 MLOAD 0A86 90 SWAP1 0A87 81 DUP2 0A88 01 ADD 0A89 60 PUSH1 0x40 0A8B 52 MSTORE 0A8C 80 DUP1 0A8D 93 SWAP4 0A8E 92 SWAP3 0A8F 91 SWAP2 0A90 90 SWAP1 0A91 81 DUP2 0A92 81 DUP2 0A93 52 MSTORE 0A94 60 PUSH1 0x20 0A96 01 ADD 0A97 83 DUP4 0A98 83 DUP4 0A99 80 DUP1 0A9A 82 DUP3 0A9B 84 DUP5 0A9C 37 CALLDATACOPY 0A9D 60 PUSH1 0x00 0A9F 92 SWAP3 0AA0 01 ADD 0AA1 91 SWAP2 0AA2 90 SWAP1 0AA3 91 SWAP2 0AA4 52 MSTORE 0AA5 50 POP 0AA6 50 POP 0AA7 82 DUP3 0AA8 51 MLOAD 0AA9 15 ISZERO 0AAA 15 ISZERO 0AAB 91 SWAP2 0AAC 50 POP 0AAD 61 PUSH2 0x0aca 0AB0 90 SWAP1 0AB1 50 POP 0AB2 57 *JUMPI 0AB3 60 PUSH1 0x40 0AB5 51 MLOAD 0AB6 62 PUSH3 0x461bcd 0ABA 60 PUSH1 0xe5 0ABC 1B SHL 0ABD 81 DUP2 0ABE 52 MSTORE 0ABF 60 PUSH1 0x04 0AC1 01 ADD 0AC2 61 PUSH2 0x0626 0AC5 90 SWAP1 0AC6 61 PUSH2 0x3973 0AC9 56 *JUMP 0ACA 5B JUMPDEST 0ACB 61 PUSH2 0x0b0a 0ACE 87 DUP8 0ACF 87 DUP8 0AD0 87 DUP8 0AD1 80 DUP1 0AD2 80 DUP1 0AD3 60 PUSH1 0x1f 0AD5 01 ADD 0AD6 60 PUSH1 0x20 0AD8 80 DUP1 0AD9 91 SWAP2 0ADA 04 DIV 0ADB 02 MUL 0ADC 60 PUSH1 0x20 0ADE 01 ADD 0ADF 60 PUSH1 0x40 0AE1 51 MLOAD 0AE2 90 SWAP1 0AE3 81 DUP2 0AE4 01 ADD 0AE5 60 PUSH1 0x40 0AE7 52 MSTORE 0AE8 80 DUP1 0AE9 93 SWAP4 0AEA 92 SWAP3 0AEB 91 SWAP2 0AEC 90 SWAP1 0AED 81 DUP2 0AEE 81 DUP2 0AEF 52 MSTORE 0AF0 60 PUSH1 0x20 0AF2 01 ADD 0AF3 83 DUP4 0AF4 83 DUP4 0AF5 80 DUP1 0AF6 82 DUP3 0AF7 84 DUP5 0AF8 37 CALLDATACOPY 0AF9 60 PUSH1 0x00 0AFB 92 SWAP3 0AFC 01 ADD 0AFD 91 SWAP2 0AFE 90 SWAP1 0AFF 91 SWAP2 0B00 52 MSTORE 0B01 50 POP 0B02 61 PUSH2 0x1a30 0B05 92 SWAP3 0B06 50 POP 0B07 50 POP 0B08 50 POP 0B09 56 *JUMP 0B0A 5B JUMPDEST 0B0B 86 DUP7 0B0C 7F PUSH32 0x702fe2dc2dc0f68023540aa4a1e11811c0f29112f6ebf01e61b90538e4f29810 0B2D 33 CALLER 0B2E 88 DUP9 0B2F 88 DUP9 0B30 60 PUSH1 0x40 0B32 51 MLOAD 0B33 61 PUSH2 0x0b3e 0B36 93 SWAP4 0B37 92 SWAP3 0B38 91 SWAP2 0B39 90 SWAP1 0B3A 61 PUSH2 0x2fce 0B3D 56 *JUMP 0B3E 5B JUMPDEST 0B3F 60 PUSH1 0x40 0B41 51 MLOAD 0B42 80 DUP1 0B43 91 SWAP2 0B44 03 SUB 0B45 90 SWAP1 0B46 A2 LOG2 0B47 50 POP 0B48 50 POP 0B49 60 PUSH1 0x01 0B4B 60 PUSH1 0x0a 0B4D 55 SSTORE 0B4E 50 POP 0B4F 50 POP 0B50 50 POP 0B51 50 POP 0B52 50 POP 0B53 56 *JUMP label_0B54: // Incoming jump from 0x0346 0B54 5B JUMPDEST 0B55 61 PUSH2 0x0b65 0B58 61 PUSH2 0x0b5f 0B5B 61 PUSH2 0x1874 0B5E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B55 stack[0] = 0x0b65 // @0B58 stack[1] = 0x0b5f // } // Block ends with call to 0x1874, returns to 0x0B5F label_0B5F: // Incoming return from call to 0x1874 at 0x0B5E // Inputs[1] { @0B60 stack[-3] } 0B5F 5B JUMPDEST 0B60 82 DUP3 0B61 61 PUSH2 0x19ab 0B64 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B60 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x19ab 0B65 5B JUMPDEST 0B66 61 PUSH2 0x0b81 0B69 57 *JUMPI 0B6A 60 PUSH1 0x40 0B6C 51 MLOAD 0B6D 62 PUSH3 0x461bcd 0B71 60 PUSH1 0xe5 0B73 1B SHL 0B74 81 DUP2 0B75 52 MSTORE 0B76 60 PUSH1 0x04 0B78 01 ADD 0B79 61 PUSH2 0x0626 0B7C 90 SWAP1 0B7D 61 PUSH2 0x3846 0B80 56 *JUMP 0B81 5B JUMPDEST 0B82 61 PUSH2 0x06de 0B85 83 DUP4 0B86 83 DUP4 0B87 83 DUP4 0B88 61 PUSH2 0x1a74 0B8B 56 *JUMP label_0B8C: // Incoming jump from 0x0359 // Inputs[1] { @0B91 storage[0x0a] } 0B8C 5B JUMPDEST 0B8D 60 PUSH1 0x02 0B8F 60 PUSH1 0x0a 0B91 54 SLOAD 0B92 14 EQ 0B93 15 ISZERO 0B94 61 PUSH2 0x0baf 0B97 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0baf, if !(storage[0x0a] == 0x02) label_0B98: // Incoming jump from 0x0B97, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0B9A memory[0x40:0x60] } 0B98 60 PUSH1 0x40 0B9A 51 MLOAD 0B9B 62 PUSH3 0x461bcd 0B9F 60 PUSH1 0xe5 0BA1 1B SHL 0BA2 81 DUP2 0BA3 52 MSTORE 0BA4 60 PUSH1 0x04 0BA6 01 ADD 0BA7 61 PUSH2 0x0626 0BAA 90 SWAP1 0BAB 61 PUSH2 0x393c 0BAE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BAA stack[0] = 0x0626 // @0BAA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_0BAF: // Incoming jump from 0x0B97, if !(storage[0x0a] == 0x02) // Inputs[2] // { // @0BB5 msg.sender // @0BB6 stack[-1] // } 0BAF 5B JUMPDEST 0BB0 60 PUSH1 0x02 0BB2 60 PUSH1 0x0a 0BB4 55 SSTORE 0BB5 33 CALLER 0BB6 81 DUP2 0BB7 61 PUSH2 0x0bc0 0BBA 82 DUP3 0BBB 82 DUP3 0BBC 61 PUSH2 0x19ab 0BBF 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0BB4 storage[0x0a] = 0x02 // @0BB5 stack[0] = msg.sender // @0BB6 stack[1] = stack[-1] // @0BB7 stack[2] = 0x0bc0 // @0BBA stack[3] = msg.sender // @0BBB stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x19ab 0BC0 5B JUMPDEST 0BC1 61 PUSH2 0x0bdc 0BC4 57 *JUMPI 0BC5 60 PUSH1 0x40 0BC7 51 MLOAD 0BC8 62 PUSH3 0x461bcd 0BCC 60 PUSH1 0xe5 0BCE 1B SHL 0BCF 81 DUP2 0BD0 52 MSTORE 0BD1 60 PUSH1 0x04 0BD3 01 ADD 0BD4 61 PUSH2 0x0626 0BD7 90 SWAP1 0BD8 61 PUSH2 0x36b7 0BDB 56 *JUMP 0BDC 5B JUMPDEST 0BDD 60 PUSH1 0x0b 0BDF 54 SLOAD 0BE0 60 PUSH1 0x40 0BE2 51 MLOAD 0BE3 63 PUSH4 0x28220f35 0BE8 60 PUSH1 0xe0 0BEA 1B SHL 0BEB 81 DUP2 0BEC 52 MSTORE 0BED 60 PUSH1 0x01 0BEF 60 PUSH1 0x01 0BF1 60 PUSH1 0xa0 0BF3 1B SHL 0BF4 03 SUB 0BF5 90 SWAP1 0BF6 91 SWAP2 0BF7 16 AND 0BF8 90 SWAP1 0BF9 63 PUSH4 0x28220f35 0BFE 90 SWAP1 0BFF 61 PUSH2 0x0c0c 0C02 90 SWAP1 0C03 86 DUP7 0C04 90 SWAP1 0C05 60 PUSH1 0x04 0C07 01 ADD 0C08 61 PUSH2 0x3019 0C0B 56 *JUMP 0C0C 5B JUMPDEST 0C0D 60 PUSH1 0x00 0C0F 60 PUSH1 0x40 0C11 51 MLOAD 0C12 80 DUP1 0C13 83 DUP4 0C14 03 SUB 0C15 81 DUP2 0C16 60 PUSH1 0x00 0C18 87 DUP8 0C19 80 DUP1 0C1A 3B EXTCODESIZE 0C1B 15 ISZERO 0C1C 80 DUP1 0C1D 15 ISZERO 0C1E 61 PUSH2 0x0c26 0C21 57 *JUMPI 0C22 60 PUSH1 0x00 0C24 80 DUP1 0C25 FD *REVERT 0C26 5B JUMPDEST 0C27 50 POP 0C28 5A GAS 0C29 F1 CALL 0C2A 15 ISZERO 0C2B 80 DUP1 0C2C 15 ISZERO 0C2D 61 PUSH2 0x090b 0C30 57 *JUMPI 0C31 3D RETURNDATASIZE 0C32 60 PUSH1 0x00 0C34 80 DUP1 0C35 3E RETURNDATACOPY 0C36 3D RETURNDATASIZE 0C37 60 PUSH1 0x00 0C39 FD *REVERT 0C3A 5B JUMPDEST 0C3B 60 PUSH1 0x02 0C3D 60 PUSH1 0x0a 0C3F 54 SLOAD 0C40 14 EQ 0C41 15 ISZERO 0C42 61 PUSH2 0x0c5d 0C45 57 *JUMPI 0C46 60 PUSH1 0x40 0C48 51 MLOAD 0C49 62 PUSH3 0x461bcd 0C4D 60 PUSH1 0xe5 0C4F 1B SHL 0C50 81 DUP2 0C51 52 MSTORE 0C52 60 PUSH1 0x04 0C54 01 ADD 0C55 61 PUSH2 0x0626 0C58 90 SWAP1 0C59 61 PUSH2 0x393c 0C5C 56 *JUMP 0C5D 5B JUMPDEST 0C5E 60 PUSH1 0x02 0C60 60 PUSH1 0x0a 0C62 55 SSTORE 0C63 61 PUSH2 0x0c6d 0C66 33 CALLER 0C67 83 DUP4 0C68 83 DUP4 0C69 61 PUSH2 0x1ae1 0C6C 56 *JUMP 0C6D 5B JUMPDEST 0C6E 50 POP 0C6F 50 POP 0C70 60 PUSH1 0x01 0C72 60 PUSH1 0x0a 0C74 55 SSTORE 0C75 56 *JUMP label_0C76: // Incoming jump from 0x037F // Inputs[3] // { // @0C7F stack[-2] // @0C8E memory[0x00:0x40] // @0C93 stack[-1] // } 0C76 5B JUMPDEST 0C77 60 PUSH1 0x01 0C79 60 PUSH1 0x01 0C7B 60 PUSH1 0xa0 0C7D 1B SHL 0C7E 03 SUB 0C7F 82 DUP3 0C80 16 AND 0C81 60 PUSH1 0x00 0C83 90 SWAP1 0C84 81 DUP2 0C85 52 MSTORE 0C86 60 PUSH1 0x01 0C88 60 PUSH1 0x20 0C8A 52 MSTORE 0C8B 60 PUSH1 0x40 0C8D 81 DUP2 0C8E 20 SHA3 0C8F 61 PUSH2 0x0c9e 0C92 90 SWAP1 0C93 83 DUP4 0C94 63 PUSH4 0xffffffff 0C99 61 PUSH2 0x1cd7 0C9C 16 AND 0C9D 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0C83 stack[0] = 0x00 // @0C85 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0C8A memory[0x20:0x40] = 0x01 // @0C92 stack[2] = keccak256(memory[0x00:0x40]) // @0C92 stack[1] = 0x0c9e // @0C93 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1cd7 & 0xffffffff label_0C9E: // Incoming return from call to 0x2E6F at 0x30D2 // Incoming return from call to 0x2047 at 0x1CE2 // Incoming return from call to 0x2881 at 0x2A6D // Incoming return from call to 0x2305 at 0x1E85 // Inputs[2] // { // @0C9F stack[-1] // @0C9F stack[-2] // } 0C9E 5B JUMPDEST 0C9F 90 SWAP1 0CA0 50 POP // Stack delta = -1 // Outputs[1] { @0C9F stack[-2] = stack[-1] } // Block continues label_0CA1: // Incoming return from call to 0x199C at 0x19AA // Incoming jump from 0x2893, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0CA0 // Inputs[3] // { // @0CA2 stack[-1] // @0CA2 stack[-4] // @0CA3 stack[-3] // } 0CA1 5B JUMPDEST 0CA2 92 SWAP3 0CA3 91 SWAP2 0CA4 50 POP 0CA5 50 POP 0CA6 56 *JUMP // Stack delta = -3 // Outputs[1] { @0CA2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0CA7: // Incoming call from 0x0387, returns to 0x0260 // Inputs[1] { @0CC9 stack[-1] } 0CA7 5B JUMPDEST 0CA8 7F PUSH32 0x49ecf333e5b8c95c40fdafc95c1ad136e8914a8fb55e9dc8bb01eaa83a2df9ad 0CC9 81 DUP2 0CCA 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CA8 stack[0] = 0x49ecf333e5b8c95c40fdafc95c1ad136e8914a8fb55e9dc8bb01eaa83a2df9ad } // Block ends with unconditional jump to stack[-1] label_0CCB: // Incoming jump from 0x039A // Inputs[4] // { // @0CCF stack[-3] // @0CD0 stack[-2] // @0CD1 stack[-1] // @0CD4 memory[0x40:0x60] // } 0CCB 5B JUMPDEST 0CCC 61 PUSH2 0x06de 0CCF 83 DUP4 0CD0 83 DUP4 0CD1 83 DUP4 0CD2 60 PUSH1 0x40 0CD4 51 MLOAD 0CD5 80 DUP1 0CD6 60 PUSH1 0x20 0CD8 01 ADD 0CD9 60 PUSH1 0x40 0CDB 52 MSTORE 0CDC 80 DUP1 0CDD 60 PUSH1 0x00 0CDF 81 DUP2 0CE0 52 MSTORE 0CE1 50 POP 0CE2 61 PUSH2 0x15b0 0CE5 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0CCC stack[0] = 0x06de // @0CCF stack[1] = stack[-3] // @0CD0 stack[2] = stack[-2] // @0CD1 stack[3] = stack[-1] // @0CD4 stack[4] = memory[0x40:0x60] // @0CDB memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x15b0 label_0CE6: // Incoming jump from 0x03AD // Inputs[1] { @0CEB storage[0x0a] } 0CE6 5B JUMPDEST 0CE7 60 PUSH1 0x02 0CE9 60 PUSH1 0x0a 0CEB 54 SLOAD 0CEC 14 EQ 0CED 15 ISZERO 0CEE 61 PUSH2 0x0d09 0CF1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d09, if !(storage[0x0a] == 0x02) label_0CF2: // Incoming jump from 0x0CF1, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0CF4 memory[0x40:0x60] } 0CF2 60 PUSH1 0x40 0CF4 51 MLOAD 0CF5 62 PUSH3 0x461bcd 0CF9 60 PUSH1 0xe5 0CFB 1B SHL 0CFC 81 DUP2 0CFD 52 MSTORE 0CFE 60 PUSH1 0x04 0D00 01 ADD 0D01 61 PUSH2 0x0626 0D04 90 SWAP1 0D05 61 PUSH2 0x393c 0D08 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D04 stack[0] = 0x0626 // @0D04 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_0D09: // Incoming jump from 0x0CF1, if !(storage[0x0a] == 0x02) // Inputs[1] { @0D0F stack[-1] } 0D09 5B JUMPDEST 0D0A 60 PUSH1 0x02 0D0C 60 PUSH1 0x0a 0D0E 55 SSTORE 0D0F 80 DUP1 0D10 61 PUSH2 0x0d18 0D13 81 DUP2 0D14 61 PUSH2 0x1861 0D17 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0D0E storage[0x0a] = 0x02 // @0D0F stack[0] = stack[-1] // @0D10 stack[1] = 0x0d18 // @0D13 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1861 0D18 5B JUMPDEST 0D19 61 PUSH2 0x0d34 0D1C 57 *JUMPI 0D1D 60 PUSH1 0x40 0D1F 51 MLOAD 0D20 62 PUSH3 0x461bcd 0D24 60 PUSH1 0xe5 0D26 1B SHL 0D27 81 DUP2 0D28 52 MSTORE 0D29 60 PUSH1 0x04 0D2B 01 ADD 0D2C 61 PUSH2 0x0626 0D2F 90 SWAP1 0D30 61 PUSH2 0x3905 0D33 56 *JUMP 0D34 5B JUMPDEST 0D35 33 CALLER 0D36 82 DUP3 0D37 61 PUSH2 0x0d40 0D3A 82 DUP3 0D3B 82 DUP3 0D3C 61 PUSH2 0x19ab 0D3F 56 *JUMP 0D40 5B JUMPDEST 0D41 61 PUSH2 0x0d5c 0D44 57 *JUMPI 0D45 60 PUSH1 0x40 0D47 51 MLOAD 0D48 62 PUSH3 0x461bcd 0D4C 60 PUSH1 0xe5 0D4E 1B SHL 0D4F 81 DUP2 0D50 52 MSTORE 0D51 60 PUSH1 0x04 0D53 01 ADD 0D54 61 PUSH2 0x0626 0D57 90 SWAP1 0D58 61 PUSH2 0x36b7 0D5B 56 *JUMP 0D5C 5B JUMPDEST 0D5D 60 PUSH1 0x00 0D5F 61 PUSH2 0x0d67 0D62 85 DUP6 0D63 61 PUSH2 0x0f4a 0D66 56 *JUMP 0D67 5B JUMPDEST 0D68 60 PUSH1 0x00 0D6A 86 DUP7 0D6B 81 DUP2 0D6C 52 MSTORE 0D6D 60 PUSH1 0x0d 0D6F 60 PUSH1 0x20 0D71 52 MSTORE 0D72 60 PUSH1 0x40 0D74 90 SWAP1 0D75 20 SHA3 0D76 54 SLOAD 0D77 90 SWAP1 0D78 91 SWAP2 0D79 50 POP 0D7A 60 PUSH1 0x01 0D7C 60 PUSH1 0x01 0D7E 60 PUSH1 0xa0 0D80 1B SHL 0D81 03 SUB 0D82 80 DUP1 0D83 83 DUP4 0D84 16 AND 0D85 91 SWAP2 0D86 16 AND 0D87 14 EQ 0D88 61 PUSH2 0x0da3 0D8B 57 *JUMPI 0D8C 60 PUSH1 0x40 0D8E 51 MLOAD 0D8F 62 PUSH3 0x461bcd 0D93 60 PUSH1 0xe5 0D95 1B SHL 0D96 81 DUP2 0D97 52 MSTORE 0D98 60 PUSH1 0x04 0D9A 01 ADD 0D9B 61 PUSH2 0x0626 0D9E 90 SWAP1 0D9F 61 PUSH2 0x35db 0DA2 56 *JUMP 0DA3 5B JUMPDEST 0DA4 61 PUSH2 0x0dac 0DA7 85 DUP6 0DA8 61 PUSH2 0x1ce3 0DAB 56 *JUMP 0DAC 5B JUMPDEST 0DAD 50 POP 0DAE 50 POP 0DAF 60 PUSH1 0x01 0DB1 60 PUSH1 0x0a 0DB3 55 SSTORE 0DB4 50 POP 0DB5 50 POP 0DB6 50 POP 0DB7 56 *JUMP label_0DB8: // Incoming jump from 0x03C0 // Inputs[1] { @0DC1 stack[-1] } 0DB8 5B JUMPDEST 0DB9 60 PUSH1 0x00 0DBB 80 DUP1 0DBC 61 PUSH2 0x0dcc 0DBF 60 PUSH1 0x02 0DC1 84 DUP5 0DC2 63 PUSH4 0xffffffff 0DC7 61 PUSH2 0x1dcf 0DCA 16 AND 0DCB 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DB9 stack[0] = 0x00 // @0DBB stack[1] = 0x00 // @0DBC stack[2] = 0x0dcc // @0DBF stack[3] = 0x02 // @0DC1 stack[4] = stack[-1] // } // Block ends with call to 0x1dcf & 0xffffffff, returns to 0x0DCC label_0DCC: // Incoming return from call to 0x1DCF at 0x0DCB // Inputs[3] // { // @0DCE stack[-2] // @0DCE stack[-6] // @0DCF stack[-5] // } 0DCC 5B JUMPDEST 0DCD 50 POP 0DCE 93 SWAP4 0DCF 92 SWAP3 0DD0 50 POP 0DD1 50 POP 0DD2 50 POP 0DD3 56 *JUMP // Stack delta = -5 // Outputs[1] { @0DCE stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0DD4: // Incoming jump from 0x03D3 // Inputs[1] { @0DD9 storage[0x0a] } 0DD4 5B JUMPDEST 0DD5 60 PUSH1 0x02 0DD7 60 PUSH1 0x0a 0DD9 54 SLOAD 0DDA 14 EQ 0DDB 15 ISZERO 0DDC 61 PUSH2 0x0df7 0DDF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df7, if !(storage[0x0a] == 0x02) label_0DE0: // Incoming jump from 0x0DDF, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0DE2 memory[0x40:0x60] } 0DE0 60 PUSH1 0x40 0DE2 51 MLOAD 0DE3 62 PUSH3 0x461bcd 0DE7 60 PUSH1 0xe5 0DE9 1B SHL 0DEA 81 DUP2 0DEB 52 MSTORE 0DEC 60 PUSH1 0x04 0DEE 01 ADD 0DEF 61 PUSH2 0x0626 0DF2 90 SWAP1 0DF3 61 PUSH2 0x393c 0DF6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF2 stack[0] = 0x0626 // @0DF2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_0DF7: // Incoming jump from 0x0DDF, if !(storage[0x0a] == 0x02) // Inputs[1] { @0DFD stack[-2] } 0DF7 5B JUMPDEST 0DF8 60 PUSH1 0x02 0DFA 60 PUSH1 0x0a 0DFC 55 SSTORE 0DFD 81 DUP2 0DFE 61 PUSH2 0x0e06 0E01 81 DUP2 0E02 61 PUSH2 0x1861 0E05 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0DFC storage[0x0a] = 0x02 // @0DFD stack[0] = stack[-2] // @0DFE stack[1] = 0x0e06 // @0E01 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1861 0E06 5B JUMPDEST 0E07 61 PUSH2 0x0e22 0E0A 57 *JUMPI 0E0B 60 PUSH1 0x40 0E0D 51 MLOAD 0E0E 62 PUSH3 0x461bcd 0E12 60 PUSH1 0xe5 0E14 1B SHL 0E15 81 DUP2 0E16 52 MSTORE 0E17 60 PUSH1 0x04 0E19 01 ADD 0E1A 61 PUSH2 0x0626 0E1D 90 SWAP1 0E1E 61 PUSH2 0x3905 0E21 56 *JUMP 0E22 5B JUMPDEST 0E23 81 DUP2 0E24 60 PUSH1 0x40 0E26 01 ADD 0E27 51 MLOAD 0E28 60 PUSH1 0x01 0E2A 60 PUSH1 0x01 0E2C 60 PUSH1 0xa0 0E2E 1B SHL 0E2F 03 SUB 0E30 16 AND 0E31 33 CALLER 0E32 60 PUSH1 0x01 0E34 60 PUSH1 0x01 0E36 60 PUSH1 0xa0 0E38 1B SHL 0E39 03 SUB 0E3A 16 AND 0E3B 14 EQ 0E3C 61 PUSH2 0x0e57 0E3F 57 *JUMPI 0E40 60 PUSH1 0x40 0E42 51 MLOAD 0E43 62 PUSH3 0x461bcd 0E47 60 PUSH1 0xe5 0E49 1B SHL 0E4A 81 DUP2 0E4B 52 MSTORE 0E4C 60 PUSH1 0x04 0E4E 01 ADD 0E4F 61 PUSH2 0x0626 0E52 90 SWAP1 0E53 61 PUSH2 0x321d 0E56 56 *JUMP 0E57 5B JUMPDEST 0E58 60 PUSH1 0x0b 0E5A 54 SLOAD 0E5B 60 PUSH1 0x40 0E5D 51 MLOAD 0E5E 63 PUSH4 0x17b6b0d3 0E63 60 PUSH1 0xe3 0E65 1B SHL 0E66 81 DUP2 0E67 52 MSTORE 0E68 60 PUSH1 0x01 0E6A 60 PUSH1 0x01 0E6C 60 PUSH1 0xa0 0E6E 1B SHL 0E6F 03 SUB 0E70 90 SWAP1 0E71 91 SWAP2 0E72 16 AND 0E73 90 SWAP1 0E74 63 PUSH4 0xbdb58698 0E79 90 SWAP1 0E7A 61 PUSH2 0x0c0c 0E7D 90 SWAP1 0E7E 86 DUP7 0E7F 90 SWAP1 0E80 86 DUP7 0E81 90 SWAP1 0E82 33 CALLER 0E83 90 SWAP1 0E84 60 PUSH1 0x04 0E86 01 ADD 0E87 61 PUSH2 0x3a32 0E8A 56 *JUMP label_0E8B: // Incoming jump from 0x03E6 // Inputs[1] { @0E90 storage[0x0a] } 0E8B 5B JUMPDEST 0E8C 60 PUSH1 0x02 0E8E 60 PUSH1 0x0a 0E90 54 SLOAD 0E91 14 EQ 0E92 15 ISZERO 0E93 61 PUSH2 0x0eae 0E96 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eae, if !(storage[0x0a] == 0x02) label_0E97: // Incoming jump from 0x0E96, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0E99 memory[0x40:0x60] } 0E97 60 PUSH1 0x40 0E99 51 MLOAD 0E9A 62 PUSH3 0x461bcd 0E9E 60 PUSH1 0xe5 0EA0 1B SHL 0EA1 81 DUP2 0EA2 52 MSTORE 0EA3 60 PUSH1 0x04 0EA5 01 ADD 0EA6 61 PUSH2 0x0626 0EA9 90 SWAP1 0EAA 61 PUSH2 0x393c 0EAD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EA9 stack[0] = 0x0626 // @0EA9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_0EAE: // Incoming jump from 0x0E96, if !(storage[0x0a] == 0x02) // Inputs[2] // { // @0EB4 msg.sender // @0EB5 stack[-2] // } 0EAE 5B JUMPDEST 0EAF 60 PUSH1 0x02 0EB1 60 PUSH1 0x0a 0EB3 55 SSTORE 0EB4 33 CALLER 0EB5 82 DUP3 0EB6 61 PUSH2 0x0ebf 0EB9 82 DUP3 0EBA 82 DUP3 0EBB 61 PUSH2 0x19ab 0EBE 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0EB3 storage[0x0a] = 0x02 // @0EB4 stack[0] = msg.sender // @0EB5 stack[1] = stack[-2] // @0EB6 stack[2] = 0x0ebf // @0EB9 stack[3] = msg.sender // @0EBA stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x19ab 0EBF 5B JUMPDEST 0EC0 61 PUSH2 0x0edb 0EC3 57 *JUMPI 0EC4 60 PUSH1 0x40 0EC6 51 MLOAD 0EC7 62 PUSH3 0x461bcd 0ECB 60 PUSH1 0xe5 0ECD 1B SHL 0ECE 81 DUP2 0ECF 52 MSTORE 0ED0 60 PUSH1 0x04 0ED2 01 ADD 0ED3 61 PUSH2 0x0626 0ED6 90 SWAP1 0ED7 61 PUSH2 0x36b7 0EDA 56 *JUMP 0EDB 5B JUMPDEST 0EDC 60 PUSH1 0x0b 0EDE 54 SLOAD 0EDF 60 PUSH1 0x40 0EE1 51 MLOAD 0EE2 63 PUSH4 0x062f24b7 0EE7 60 PUSH1 0xe4 0EE9 1B SHL 0EEA 81 DUP2 0EEB 52 MSTORE 0EEC 60 PUSH1 0x01 0EEE 60 PUSH1 0x01 0EF0 60 PUSH1 0xa0 0EF2 1B SHL 0EF3 03 SUB 0EF4 90 SWAP1 0EF5 91 SWAP2 0EF6 16 AND 0EF7 90 SWAP1 0EF8 63 PUSH4 0x62f24b70 0EFD 90 SWAP1 0EFE 61 PUSH2 0x0f0d 0F01 90 SWAP1 0F02 87 DUP8 0F03 90 SWAP1 0F04 87 DUP8 0F05 90 SWAP1 0F06 60 PUSH1 0x04 0F08 01 ADD 0F09 61 PUSH2 0x39d0 0F0C 56 *JUMP 0F0D 5B JUMPDEST 0F0E 60 PUSH1 0x00 0F10 60 PUSH1 0x40 0F12 51 MLOAD 0F13 80 DUP1 0F14 83 DUP4 0F15 03 SUB 0F16 81 DUP2 0F17 60 PUSH1 0x00 0F19 87 DUP8 0F1A 80 DUP1 0F1B 3B EXTCODESIZE 0F1C 15 ISZERO 0F1D 80 DUP1 0F1E 15 ISZERO 0F1F 61 PUSH2 0x0f27 0F22 57 *JUMPI 0F23 60 PUSH1 0x00 0F25 80 DUP1 0F26 FD *REVERT 0F27 5B JUMPDEST 0F28 50 POP 0F29 5A GAS 0F2A F1 CALL 0F2B 15 ISZERO 0F2C 80 DUP1 0F2D 15 ISZERO 0F2E 61 PUSH2 0x0f3b 0F31 57 *JUMPI 0F32 3D RETURNDATASIZE 0F33 60 PUSH1 0x00 0F35 80 DUP1 0F36 3E RETURNDATACOPY 0F37 3D RETURNDATASIZE 0F38 60 PUSH1 0x00 0F3A FD *REVERT 0F3B 5B JUMPDEST 0F3C 50 POP 0F3D 50 POP 0F3E 60 PUSH1 0x01 0F40 60 PUSH1 0x0a 0F42 55 SSTORE 0F43 50 POP 0F44 50 POP 0F45 50 POP 0F46 50 POP 0F47 50 POP 0F48 50 POP 0F49 56 *JUMP label_0F4A: // Incoming jump from 0x0655 // Incoming jump from 0x03F9 // Incoming jump from 0x17DE // Inputs[2] // { // @0F50 stack[-1] // @0F53 memory[0x40:0x60] // } 0F4A 5B JUMPDEST 0F4B 60 PUSH1 0x00 0F4D 61 PUSH2 0x0ca1 0F50 82 DUP3 0F51 60 PUSH1 0x40 0F53 51 MLOAD 0F54 80 DUP1 0F55 60 PUSH1 0x60 0F57 01 ADD 0F58 60 PUSH1 0x40 0F5A 52 MSTORE 0F5B 80 DUP1 0F5C 60 PUSH1 0x29 0F5E 81 DUP2 0F5F 52 MSTORE 0F60 60 PUSH1 0x20 0F62 01 ADD 0F63 61 PUSH2 0x3b10 0F66 60 PUSH1 0x29 0F68 91 SWAP2 0F69 39 CODECOPY 0F6A 60 PUSH1 0x02 0F6C 91 SWAP2 0F6D 90 SWAP1 0F6E 63 PUSH4 0xffffffff 0F73 61 PUSH2 0x1deb 0F76 16 AND 0F77 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @0F4B stack[0] = 0x00 // @0F4D stack[1] = 0x0ca1 // @0F5A memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0F5F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x29 // @0F69 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x29] = code[0x3b10:0x3b39] // @0F6C stack[2] = 0x02 // @0F6D stack[3] = stack[-1] // @0F6D stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1deb & 0xffffffff label_0F78: // Incoming call from 0x0401, returns to 0x029E // Inputs[2] // { // @0F7C storage[0x09] // @0F80 memory[0x40:0x60] // } 0F78 5B JUMPDEST 0F79 60 PUSH1 0x09 0F7B 80 DUP1 0F7C 54 SLOAD 0F7D 60 PUSH1 0x40 0F7F 80 DUP1 0F80 51 MLOAD 0F81 60 PUSH1 0x20 0F83 60 PUSH1 0x1f 0F85 60 PUSH1 0x02 0F87 60 PUSH1 0x00 0F89 19 NOT 0F8A 61 PUSH2 0x0100 0F8D 60 PUSH1 0x01 0F8F 88 DUP9 0F90 16 AND 0F91 15 ISZERO 0F92 02 MUL 0F93 01 ADD 0F94 90 SWAP1 0F95 95 SWAP6 0F96 16 AND 0F97 94 SWAP5 0F98 90 SWAP1 0F99 94 SWAP5 0F9A 04 DIV 0F9B 93 SWAP4 0F9C 84 DUP5 0F9D 01 ADD 0F9E 81 DUP2 0F9F 90 SWAP1 0FA0 04 DIV 0FA1 81 DUP2 0FA2 02 MUL 0FA3 82 DUP3 0FA4 01 ADD 0FA5 81 DUP2 0FA6 01 ADD 0FA7 90 SWAP1 0FA8 92 SWAP3 0FA9 52 MSTORE 0FAA 82 DUP3 0FAB 81 DUP2 0FAC 52 MSTORE 0FAD 60 PUSH1 0x60 0FAF 93 SWAP4 0FB0 90 SWAP1 0FB1 92 SWAP3 0FB2 90 SWAP1 0FB3 91 SWAP2 0FB4 83 DUP4 0FB5 01 ADD 0FB6 82 DUP3 0FB7 82 DUP3 0FB8 80 DUP1 0FB9 15 ISZERO 0FBA 61 PUSH2 0x05f4 0FBD 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0FA9 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0FAC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0FAF stack[0] = 0x60 // @0FB1 stack[1] = memory[0x40:0x60] // @0FB2 stack[3] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0FB3 stack[2] = 0x09 // @0FB5 stack[4] = memory[0x40:0x60] + 0x20 // @0FB6 stack[5] = 0x09 // @0FB7 stack[6] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x05f4, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0FBE: // Incoming jump from 0x0FBD, if not !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0FBE stack[-1] } 0FBE 80 DUP1 0FBF 60 PUSH1 0x1f 0FC1 10 LT 0FC2 61 PUSH2 0x05c9 0FC5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c9, if 0x1f < stack[-1] label_0FC6: // Incoming jump from 0x0FC5, if not 0x1f < stack[-1] // Inputs[4] // { // @0FCA stack[-2] // @0FCB storage[stack[-2]] // @0FCE stack[-3] // @0FD0 stack[-1] // } 0FC6 61 PUSH2 0x0100 0FC9 80 DUP1 0FCA 83 DUP4 0FCB 54 SLOAD 0FCC 04 DIV 0FCD 02 MUL 0FCE 83 DUP4 0FCF 52 MSTORE 0FD0 91 SWAP2 0FD1 60 PUSH1 0x20 0FD3 01 ADD 0FD4 91 SWAP2 0FD5 61 PUSH2 0x05f4 0FD8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0FCF memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0FD4 stack[-1] = stack[-1] // @0FD4 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x05f4 0FD9 5B JUMPDEST 0FDA 60 PUSH1 0x00 0FDC 60 PUSH1 0x01 0FDE 60 PUSH1 0x01 0FE0 60 PUSH1 0xa0 0FE2 1B SHL 0FE3 03 SUB 0FE4 82 DUP3 0FE5 16 AND 0FE6 61 PUSH2 0x1001 0FE9 57 *JUMPI 0FEA 60 PUSH1 0x40 0FEC 51 MLOAD 0FED 62 PUSH3 0x461bcd 0FF1 60 PUSH1 0xe5 0FF3 1B SHL 0FF4 81 DUP2 0FF5 52 MSTORE 0FF6 60 PUSH1 0x04 0FF8 01 ADD 0FF9 61 PUSH2 0x0626 0FFC 90 SWAP1 0FFD 61 PUSH2 0x3457 1000 56 *JUMP 1001 5B JUMPDEST 1002 60 PUSH1 0x01 1004 60 PUSH1 0x01 1006 60 PUSH1 0xa0 1008 1B SHL 1009 03 SUB 100A 82 DUP3 100B 16 AND 100C 60 PUSH1 0x00 100E 90 SWAP1 100F 81 DUP2 1010 52 MSTORE 1011 60 PUSH1 0x01 1013 60 PUSH1 0x20 1015 52 MSTORE 1016 60 PUSH1 0x40 1018 90 SWAP1 1019 20 SHA3 101A 61 PUSH2 0x0ca1 101D 90 SWAP1 101E 61 PUSH2 0x19a0 1021 56 *JUMP label_1022: // Incoming jump from 0x0427 // Inputs[1] { @1027 storage[0x0a] } 1022 5B JUMPDEST 1023 60 PUSH1 0x02 1025 60 PUSH1 0x0a 1027 54 SLOAD 1028 14 EQ 1029 15 ISZERO 102A 61 PUSH2 0x1045 102D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1045, if !(storage[0x0a] == 0x02) label_102E: // Incoming jump from 0x102D, if not !(storage[0x0a] == 0x02) // Inputs[1] { @1030 memory[0x40:0x60] } 102E 60 PUSH1 0x40 1030 51 MLOAD 1031 62 PUSH3 0x461bcd 1035 60 PUSH1 0xe5 1037 1B SHL 1038 81 DUP2 1039 52 MSTORE 103A 60 PUSH1 0x04 103C 01 ADD 103D 61 PUSH2 0x0626 1040 90 SWAP1 1041 61 PUSH2 0x393c 1044 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1039 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1040 stack[0] = 0x0626 // @1040 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_1045: // Incoming jump from 0x102D, if !(storage[0x0a] == 0x02) // Inputs[2] // { // @104B msg.sender // @104C stack[-3] // } 1045 5B JUMPDEST 1046 60 PUSH1 0x02 1048 60 PUSH1 0x0a 104A 55 SSTORE 104B 33 CALLER 104C 83 DUP4 104D 61 PUSH2 0x1056 1050 82 DUP3 1051 82 DUP3 1052 61 PUSH2 0x19ab 1055 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @104A storage[0x0a] = 0x02 // @104B stack[0] = msg.sender // @104C stack[1] = stack[-3] // @104D stack[2] = 0x1056 // @1050 stack[3] = msg.sender // @1051 stack[4] = stack[-3] // } // Block ends with unconditional jump to 0x19ab 1056 5B JUMPDEST 1057 61 PUSH2 0x1072 105A 57 *JUMPI 105B 60 PUSH1 0x40 105D 51 MLOAD 105E 62 PUSH3 0x461bcd 1062 60 PUSH1 0xe5 1064 1B SHL 1065 81 DUP2 1066 52 MSTORE 1067 60 PUSH1 0x04 1069 01 ADD 106A 61 PUSH2 0x0626 106D 90 SWAP1 106E 61 PUSH2 0x36b7 1071 56 *JUMP 1072 5B JUMPDEST 1073 60 PUSH1 0x00 1075 85 DUP6 1076 81 DUP2 1077 52 MSTORE 1078 60 PUSH1 0x10 107A 60 PUSH1 0x20 107C 52 MSTORE 107D 60 PUSH1 0x40 107F 90 SWAP1 1080 20 SHA3 1081 54 SLOAD 1082 85 DUP6 1083 90 SWAP1 1084 61 PUSH2 0x109f 1087 57 *JUMPI 1088 60 PUSH1 0x40 108A 51 MLOAD 108B 62 PUSH3 0x461bcd 108F 60 PUSH1 0xe5 1091 1B SHL 1092 81 DUP2 1093 52 MSTORE 1094 60 PUSH1 0x04 1096 01 ADD 1097 61 PUSH2 0x0626 109A 90 SWAP1 109B 61 PUSH2 0x331b 109E 56 *JUMP 109F 5B JUMPDEST 10A0 84 DUP5 10A1 84 DUP5 10A2 80 DUP1 10A3 80 DUP1 10A4 60 PUSH1 0x1f 10A6 01 ADD 10A7 60 PUSH1 0x20 10A9 80 DUP1 10AA 91 SWAP2 10AB 04 DIV 10AC 02 MUL 10AD 60 PUSH1 0x20 10AF 01 ADD 10B0 60 PUSH1 0x40 10B2 51 MLOAD 10B3 90 SWAP1 10B4 81 DUP2 10B5 01 ADD 10B6 60 PUSH1 0x40 10B8 52 MSTORE 10B9 80 DUP1 10BA 93 SWAP4 10BB 92 SWAP3 10BC 91 SWAP2 10BD 90 SWAP1 10BE 81 DUP2 10BF 81 DUP2 10C0 52 MSTORE 10C1 60 PUSH1 0x20 10C3 01 ADD 10C4 83 DUP4 10C5 83 DUP4 10C6 80 DUP1 10C7 82 DUP3 10C8 84 DUP5 10C9 37 CALLDATACOPY 10CA 60 PUSH1 0x00 10CC 92 SWAP3 10CD 01 ADD 10CE 91 SWAP2 10CF 90 SWAP1 10D0 91 SWAP2 10D1 52 MSTORE 10D2 50 POP 10D3 50 POP 10D4 82 DUP3 10D5 51 MLOAD 10D6 15 ISZERO 10D7 15 ISZERO 10D8 91 SWAP2 10D9 50 POP 10DA 61 PUSH2 0x10f7 10DD 90 SWAP1 10DE 50 POP 10DF 57 *JUMPI 10E0 60 PUSH1 0x40 10E2 51 MLOAD 10E3 62 PUSH3 0x461bcd 10E7 60 PUSH1 0xe5 10E9 1B SHL 10EA 81 DUP2 10EB 52 MSTORE 10EC 60 PUSH1 0x04 10EE 01 ADD 10EF 61 PUSH2 0x0626 10F2 90 SWAP1 10F3 61 PUSH2 0x3973 10F6 56 *JUMP 10F7 5B JUMPDEST 10F8 61 PUSH2 0x1137 10FB 87 DUP8 10FC 87 DUP8 10FD 87 DUP8 10FE 80 DUP1 10FF 80 DUP1 1100 60 PUSH1 0x1f 1102 01 ADD 1103 60 PUSH1 0x20 1105 80 DUP1 1106 91 SWAP2 1107 04 DIV 1108 02 MUL 1109 60 PUSH1 0x20 110B 01 ADD 110C 60 PUSH1 0x40 110E 51 MLOAD 110F 90 SWAP1 1110 81 DUP2 1111 01 ADD 1112 60 PUSH1 0x40 1114 52 MSTORE 1115 80 DUP1 1116 93 SWAP4 1117 92 SWAP3 1118 91 SWAP2 1119 90 SWAP1 111A 81 DUP2 111B 81 DUP2 111C 52 MSTORE 111D 60 PUSH1 0x20 111F 01 ADD 1120 83 DUP4 1121 83 DUP4 1122 80 DUP1 1123 82 DUP3 1124 84 DUP5 1125 37 CALLDATACOPY 1126 60 PUSH1 0x00 1128 92 SWAP3 1129 01 ADD 112A 91 SWAP2 112B 90 SWAP1 112C 91 SWAP2 112D 52 MSTORE 112E 50 POP 112F 61 PUSH2 0x1e02 1132 92 SWAP3 1133 50 POP 1134 50 POP 1135 50 POP 1136 56 *JUMP 1137 5B JUMPDEST 1138 86 DUP7 1139 7F PUSH32 0xe3df41127db820c79e5b8d541a63e40e3e97b9af96f7a50bded13091b70df9ae 115A 33 CALLER 115B 88 DUP9 115C 88 DUP9 115D 60 PUSH1 0x40 115F 51 MLOAD 1160 61 PUSH2 0x0b3e 1163 93 SWAP4 1164 92 SWAP3 1165 91 SWAP2 1166 90 SWAP1 1167 61 PUSH2 0x2fce 116A 56 *JUMP label_116B: // Incoming jump from 0x043A // Inputs[1] { @1170 storage[0x0a] } 116B 5B JUMPDEST 116C 60 PUSH1 0x02 116E 60 PUSH1 0x0a 1170 54 SLOAD 1171 14 EQ 1172 15 ISZERO 1173 61 PUSH2 0x118e 1176 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x118e, if !(storage[0x0a] == 0x02) label_1177: // Incoming jump from 0x1176, if not !(storage[0x0a] == 0x02) // Inputs[1] { @1179 memory[0x40:0x60] } 1177 60 PUSH1 0x40 1179 51 MLOAD 117A 62 PUSH3 0x461bcd 117E 60 PUSH1 0xe5 1180 1B SHL 1181 81 DUP2 1182 52 MSTORE 1183 60 PUSH1 0x04 1185 01 ADD 1186 61 PUSH2 0x0626 1189 90 SWAP1 118A 61 PUSH2 0x393c 118D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1182 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1189 stack[0] = 0x0626 // @1189 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_118E: // Incoming jump from 0x1176, if !(storage[0x0a] == 0x02) // Inputs[2] // { // @1194 stack[-1] // @1195 memory[stack[-1]:stack[-1] + 0x20] // } 118E 5B JUMPDEST 118F 60 PUSH1 0x02 1191 60 PUSH1 0x0a 1193 55 SSTORE 1194 80 DUP1 1195 51 MLOAD 1196 15 ISZERO 1197 80 DUP1 1198 61 PUSH2 0x11a2 119B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1193 storage[0x0a] = 0x02 // @1196 stack[0] = !memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x11a2, if !memory[stack[-1]:stack[-1] + 0x20] label_119C: // Incoming jump from 0x119B, if not !memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @119D stack[-2] // @119E memory[stack[-2]:stack[-2] + 0x20] // @119F block.timestamp // } 119C 50 POP 119D 80 DUP1 119E 51 MLOAD 119F 42 TIMESTAMP 11A0 11 GT 11A1 15 ISZERO 11A2 5B JUMPDEST 11A3 61 PUSH2 0x11be 11A6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11be, if !(block.timestamp > memory[stack[-2]:stack[-2] + 0x20]) label_11A7: // Incoming jump from 0x11A6, if not !(block.timestamp > memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x11A6, if not stack[-1] // Inputs[1] { @11A9 memory[0x40:0x60] } 11A7 60 PUSH1 0x40 11A9 51 MLOAD 11AA 62 PUSH3 0x461bcd 11AE 60 PUSH1 0xe5 11B0 1B SHL 11B1 81 DUP2 11B2 52 MSTORE 11B3 60 PUSH1 0x04 11B5 01 ADD 11B6 61 PUSH2 0x0626 11B9 90 SWAP1 11BA 61 PUSH2 0x380f 11BD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11B9 stack[0] = 0x0626 // @11B9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x380f, returns to 0x0626 label_11BE: // Incoming jump from 0x11A6, if !(block.timestamp > memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x11A6, if stack[-1] 11BE 5B JUMPDEST 11BF 60 PUSH1 0x00 11C1 61 PUSH2 0x11c8 11C4 61 PUSH2 0x18e6 11C7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11BF stack[0] = 0x00 // @11C1 stack[1] = 0x11c8 // } // Block ends with call to 0x18e6, returns to 0x11C8 label_11C8: // Incoming return from call to 0x18E6 at 0x11C7 // Inputs[14] // { // @11CC stack[-5] // @11CE memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @11D3 memory[stack[-5] + 0x60:stack[-5] + 0x60 + 0x20] // @11D7 stack[-4] // @11D9 memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @11DA memory[memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20]:memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] + 0x20] // @11E3 stack[-6] // @11F0 memory[0x00:0x40] // @11F2 storage[keccak256(memory[0x00:0x40])] // @11FA stack[-3] // @11FB memory[stack[-3]:stack[-3] + 0x20] // @11FD memory[0x40:0x60] // @11FE stack[-1] // @11FF stack[-2] // } 11C8 5B JUMPDEST 11C9 60 PUSH1 0x40 11CB 80 DUP1 11CC 86 DUP7 11CD 01 ADD 11CE 51 MLOAD 11CF 60 PUSH1 0x60 11D1 87 DUP8 11D2 01 ADD 11D3 51 MLOAD 11D4 60 PUSH1 0x20 11D6 80 DUP1 11D7 88 DUP9 11D8 01 ADD 11D9 51 MLOAD 11DA 51 MLOAD 11DB 60 PUSH1 0x01 11DD 60 PUSH1 0x01 11DF 60 PUSH1 0xa0 11E1 1B SHL 11E2 03 SUB 11E3 8B DUP12 11E4 16 AND 11E5 60 PUSH1 0x00 11E7 90 SWAP1 11E8 81 DUP2 11E9 52 MSTORE 11EA 60 PUSH1 0x14 11EC 83 DUP4 11ED 52 MSTORE 11EE 85 DUP6 11EF 81 DUP2 11F0 20 SHA3 11F1 80 DUP1 11F2 54 SLOAD 11F3 60 PUSH1 0x01 11F5 81 DUP2 11F6 01 ADD 11F7 90 SWAP1 11F8 91 SWAP2 11F9 55 SSTORE 11FA 89 DUP10 11FB 51 MLOAD 11FC 96 SWAP7 11FD 51 MLOAD 11FE 97 SWAP8 11FF 98 SWAP9 1200 50 POP 1201 90 SWAP1 1202 96 SWAP7 1203 88 DUP9 1204 96 SWAP7 1205 61 PUSH2 0x1236 1208 96 SWAP7 1209 7F PUSH32 0x2952e482b8e2b192305f87374d7af45dc2eafafe4f50d26a0c02e90f2fdbe14b 122A 96 SWAP7 122B 90 SWAP1 122C 95 SWAP6 122D 90 SWAP1 122E 94 SWAP5 122F 93 SWAP4 1230 92 SWAP3 1231 01 ADD 1232 61 PUSH2 0x307a 1235 56 *JUMP // Stack delta = +9 // Outputs[14] // { // @11E9 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @11ED memory[0x20:0x40] = 0x14 // @11F9 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @11FF stack[-2] = stack[-1] // @1202 stack[-1] = 0x00 // @1204 stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @1204 stack[0] = stack[-1] // @1208 stack[1] = 0x1236 // @122A stack[2] = 0x2952e482b8e2b192305f87374d7af45dc2eafafe4f50d26a0c02e90f2fdbe14b // @122C stack[3] = memory[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @122E stack[4] = memory[stack[-5] + 0x60:stack[-5] + 0x60 + 0x20] // @122F stack[5] = memory[memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20]:memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] + 0x20] // @1230 stack[6] = storage[keccak256(memory[0x00:0x40])] // @1231 stack[8] = memory[0x40:0x60] + 0x20 // } // Block ends with call to 0x307a, returns to 0x1236 label_1236: // Incoming return from call to 0x307A at 0x1235 // Inputs[6] // { // @1239 memory[0x40:0x60] // @123D stack[-1] // @1247 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @124C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @124F memory[0x40:0x60] // @1256 stack[-2] // } 1236 5B JUMPDEST 1237 60 PUSH1 0x40 1239 51 MLOAD 123A 60 PUSH1 0x20 123C 81 DUP2 123D 83 DUP4 123E 03 SUB 123F 03 SUB 1240 81 DUP2 1241 52 MSTORE 1242 90 SWAP1 1243 60 PUSH1 0x40 1245 52 MSTORE 1246 80 DUP1 1247 51 MLOAD 1248 90 SWAP1 1249 60 PUSH1 0x20 124B 01 ADD 124C 20 SHA3 124D 60 PUSH1 0x40 124F 51 MLOAD 1250 60 PUSH1 0x20 1252 01 ADD 1253 61 PUSH2 0x125d 1256 92 SWAP3 1257 91 SWAP2 1258 90 SWAP1 1259 61 PUSH2 0x2ef8 125C 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1241 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1245 memory[0x40:0x60] = stack[-1] // @1256 stack[-2] = 0x125d // @1257 stack[-1] = stack[-2] // @1258 stack[1] = 0x20 + memory[0x40:0x60] // @1258 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x2ef8, returns to 0x125D label_125D: // Incoming return from call to 0x2EF8 at 0x125C // Inputs[11] // { // @1260 memory[0x40:0x60] // @1264 stack[-1] // @126E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1273 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1274 stack[-2] // @127B stack[-4] // @127F memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1284 memory[0x40 + stack[-4]:0x40 + stack[-4] + 0x20] // @1289 memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // @128C memory[0x40:0x60] // @1299 memory[0x40:0x60] // } 125D 5B JUMPDEST 125E 60 PUSH1 0x40 1260 51 MLOAD 1261 60 PUSH1 0x20 1263 81 DUP2 1264 83 DUP4 1265 03 SUB 1266 03 SUB 1267 81 DUP2 1268 52 MSTORE 1269 90 SWAP1 126A 60 PUSH1 0x40 126C 52 MSTORE 126D 80 DUP1 126E 51 MLOAD 126F 90 SWAP1 1270 60 PUSH1 0x20 1272 01 ADD 1273 20 SHA3 1274 90 SWAP1 1275 50 POP 1276 60 PUSH1 0x00 1278 60 PUSH1 0x01 127A 82 DUP3 127B 85 DUP6 127C 60 PUSH1 0x20 127E 01 ADD 127F 51 MLOAD 1280 86 DUP7 1281 60 PUSH1 0x40 1283 01 ADD 1284 51 MLOAD 1285 87 DUP8 1286 60 PUSH1 0x60 1288 01 ADD 1289 51 MLOAD 128A 60 PUSH1 0x40 128C 51 MLOAD 128D 60 PUSH1 0x00 128F 81 DUP2 1290 52 MSTORE 1291 60 PUSH1 0x20 1293 01 ADD 1294 60 PUSH1 0x40 1296 52 MSTORE 1297 60 PUSH1 0x40 1299 51 MLOAD 129A 61 PUSH2 0x12a6 129D 94 SWAP5 129E 93 SWAP4 129F 92 SWAP3 12A0 91 SWAP2 12A1 90 SWAP1 12A2 61 PUSH2 0x30a2 12A5 56 *JUMP // Stack delta = +7 // Outputs[13] // { // @1268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @126C memory[0x40:0x60] = stack[-1] // @1274 stack[-2] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1276 stack[-1] = 0x00 // @1278 stack[0] = 0x01 // @1290 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1296 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @129D stack[1] = 0x12a6 // @129E stack[2] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @129F stack[3] = memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @12A0 stack[4] = memory[0x40 + stack[-4]:0x40 + stack[-4] + 0x20] // @12A1 stack[6] = memory[0x40:0x60] // @12A1 stack[5] = memory[0x60 + stack[-4]:0x60 + stack[-4] + 0x20] // } // Block ends with call to 0x30a2, returns to 0x12A6 label_12A6: // Incoming return from call to 0x30A2 at 0x12A5 // Inputs[6] // { // @12AB memory[0x40:0x60] // @12B2 stack[-1] // @12B5 stack[-2] // @12B6 msg.gas // @12B7 address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @12B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 12A6 5B JUMPDEST 12A7 60 PUSH1 0x20 12A9 60 PUSH1 0x40 12AB 51 MLOAD 12AC 60 PUSH1 0x20 12AE 81 DUP2 12AF 03 SUB 12B0 90 SWAP1 12B1 80 DUP1 12B2 84 DUP5 12B3 03 SUB 12B4 90 SWAP1 12B5 85 DUP6 12B6 5A GAS 12B7 FA STATICCALL 12B8 15 ISZERO 12B9 80 DUP1 12BA 15 ISZERO 12BB 61 PUSH2 0x12c8 12BE 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @12B7 memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @12B8 stack[0] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x12c8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_12BF: // Incoming jump from 0x12BE, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[4] // { // @12BF returndata.length // @12C3 returndata[0x00:0x00 + returndata.length] // @12C4 returndata.length // @12C7 memory[0x00:0x00 + returndata.length] // } 12BF 3D RETURNDATASIZE 12C0 60 PUSH1 0x00 12C2 80 DUP1 12C3 3E RETURNDATACOPY 12C4 3D RETURNDATASIZE 12C5 60 PUSH1 0x00 12C7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12C3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @12C7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_12C8: // Incoming jump from 0x12BE, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[3] // { // @12CD memory[0x40:0x60] // @12D2 memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @12D3 stack[-4] // } 12C8 5B JUMPDEST 12C9 50 POP 12CA 50 POP 12CB 60 PUSH1 0x40 12CD 51 MLOAD 12CE 60 PUSH1 0x1f 12D0 19 NOT 12D1 01 ADD 12D2 51 MLOAD 12D3 91 SWAP2 12D4 50 POP 12D5 50 POP 12D6 60 PUSH1 0x01 12D8 60 PUSH1 0x01 12DA 60 PUSH1 0xa0 12DC 1B SHL 12DD 03 SUB 12DE 81 DUP2 12DF 16 AND 12E0 15 ISZERO 12E1 80 DUP1 12E2 15 ISZERO 12E3 90 SWAP1 12E4 61 PUSH2 0x12fe 12E7 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @12D3 stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @12E3 stack[-3] = !!(memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x12fe, if !(memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01) label_12E8: // Incoming jump from 0x12E7, if not !(memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01) // Inputs[2] // { // @12E9 stack[-2] // @12F3 stack[-8] // } 12E8 50 POP 12E9 80 DUP1 12EA 60 PUSH1 0x01 12EC 60 PUSH1 0x01 12EE 60 PUSH1 0xa0 12F0 1B SHL 12F1 03 SUB 12F2 16 AND 12F3 87 DUP8 12F4 60 PUSH1 0x01 12F6 60 PUSH1 0x01 12F8 60 PUSH1 0xa0 12FA 1B SHL 12FB 03 SUB 12FC 16 AND 12FD 14 EQ 12FE 5B JUMPDEST 12FF 61 PUSH2 0x131a 1302 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x131a, if (0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-2] label_1303: // Incoming jump from 0x1302, if not (0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-2] // Incoming jump from 0x1302, if not stack[-1] // Inputs[1] { @1305 memory[0x40:0x60] } 1303 60 PUSH1 0x40 1305 51 MLOAD 1306 62 PUSH3 0x461bcd 130A 60 PUSH1 0xe5 130C 1B SHL 130D 81 DUP2 130E 52 MSTORE 130F 60 PUSH1 0x04 1311 01 ADD 1312 61 PUSH2 0x0626 1315 90 SWAP1 1316 61 PUSH2 0x38ce 1319 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @130E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1315 stack[0] = 0x0626 // @1315 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x38ce, returns to 0x0626 label_131A: // Incoming jump from 0x1302, if (0x01 << 0xa0) - 0x01 & stack[-8] == (0x01 << 0xa0) - 0x01 & stack[-2] // Incoming jump from 0x1302, if stack[-1] // Inputs[3] // { // @131E stack[-1] // @131F stack[-6] // @1320 stack[-5] // } 131A 5B JUMPDEST 131B 61 PUSH2 0x090b 131E 81 DUP2 131F 87 DUP8 1320 87 DUP8 1321 61 PUSH2 0x1ae1 1324 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @131B stack[0] = 0x090b // @131E stack[1] = stack[-1] // @131F stack[2] = stack[-6] // @1320 stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x1ae1 label_1325: // Incoming call from 0x0442, returns to 0x029E // Inputs[2] // { // @1329 storage[0x07] // @132D memory[0x40:0x60] // } 1325 5B JUMPDEST 1326 60 PUSH1 0x07 1328 80 DUP1 1329 54 SLOAD 132A 60 PUSH1 0x40 132C 80 DUP1 132D 51 MLOAD 132E 60 PUSH1 0x20 1330 60 PUSH1 0x1f 1332 60 PUSH1 0x02 1334 60 PUSH1 0x00 1336 19 NOT 1337 61 PUSH2 0x0100 133A 60 PUSH1 0x01 133C 88 DUP9 133D 16 AND 133E 15 ISZERO 133F 02 MUL 1340 01 ADD 1341 90 SWAP1 1342 95 SWAP6 1343 16 AND 1344 94 SWAP5 1345 90 SWAP1 1346 94 SWAP5 1347 04 DIV 1348 93 SWAP4 1349 84 DUP5 134A 01 ADD 134B 81 DUP2 134C 90 SWAP1 134D 04 DIV 134E 81 DUP2 134F 02 MUL 1350 82 DUP3 1351 01 ADD 1352 81 DUP2 1353 01 ADD 1354 90 SWAP1 1355 92 SWAP3 1356 52 MSTORE 1357 82 DUP3 1358 81 DUP2 1359 52 MSTORE 135A 60 PUSH1 0x60 135C 93 SWAP4 135D 90 SWAP1 135E 92 SWAP3 135F 90 SWAP1 1360 91 SWAP2 1361 83 DUP4 1362 01 ADD 1363 82 DUP3 1364 82 DUP3 1365 80 DUP1 1366 15 ISZERO 1367 61 PUSH2 0x05f4 136A 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1356 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @1359 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 // @135C stack[0] = 0x60 // @135E stack[1] = memory[0x40:0x60] // @135F stack[3] = (storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 // @1360 stack[2] = 0x07 // @1362 stack[4] = memory[0x40:0x60] + 0x20 // @1363 stack[5] = 0x07 // @1364 stack[6] = (storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x05f4, if !((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02) label_136B: // Incoming jump from 0x136A, if not !((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @136B stack[-1] } 136B 80 DUP1 136C 60 PUSH1 0x1f 136E 10 LT 136F 61 PUSH2 0x05c9 1372 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c9, if 0x1f < stack[-1] label_1373: // Incoming jump from 0x1372, if not 0x1f < stack[-1] // Inputs[4] // { // @1377 stack[-2] // @1378 storage[stack[-2]] // @137B stack[-3] // @137D stack[-1] // } 1373 61 PUSH2 0x0100 1376 80 DUP1 1377 83 DUP4 1378 54 SLOAD 1379 04 DIV 137A 02 MUL 137B 83 DUP4 137C 52 MSTORE 137D 91 SWAP2 137E 60 PUSH1 0x20 1380 01 ADD 1381 91 SWAP2 1382 61 PUSH2 0x05f4 1385 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @137C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1381 stack[-1] = stack[-1] // @1381 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x05f4 label_1386: // Incoming jump from 0x0455 // Inputs[4] // { // @138E stack[-1] // @1394 memory[0x00:0x40] // @1395 storage[keccak256(memory[0x00:0x40])] // @139F stack[-2] // } 1386 5B JUMPDEST 1387 60 PUSH1 0x0c 1389 60 PUSH1 0x20 138B 52 MSTORE 138C 60 PUSH1 0x00 138E 90 SWAP1 138F 81 DUP2 1390 52 MSTORE 1391 60 PUSH1 0x40 1393 90 SWAP1 1394 20 SHA3 1395 54 SLOAD 1396 60 PUSH1 0x01 1398 60 PUSH1 0x01 139A 60 PUSH1 0xa0 139C 1B SHL 139D 03 SUB 139E 16 AND 139F 81 DUP2 13A0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @138B memory[0x20:0x40] = 0x0c // @1390 memory[0x00:0x20] = stack[-1] // @139E stack[-1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_13A1: // Incoming call from 0x045D, returns to 0x02BE // Inputs[2] // { // @13A4 storage[0x0b] // @13AE stack[-1] // } 13A1 5B JUMPDEST 13A2 60 PUSH1 0x0b 13A4 54 SLOAD 13A5 60 PUSH1 0x01 13A7 60 PUSH1 0x01 13A9 60 PUSH1 0xa0 13AB 1B SHL 13AC 03 SUB 13AD 16 AND 13AE 81 DUP2 13AF 56 *JUMP // Stack delta = +1 // Outputs[1] { @13AD stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0b] } // Block ends with unconditional jump to stack[-1] label_13B0: // Incoming jump from 0x0470 13B0 5B JUMPDEST 13B1 61 PUSH2 0x13b8 13B4 61 PUSH2 0x1874 13B7 56 *JUMP // Stack delta = +1 // Outputs[1] { @13B1 stack[0] = 0x13b8 } // Block ends with call to 0x1874, returns to 0x13B8 label_13B8: // Incoming return from call to 0x1874 at 0x13B7 // Inputs[2] // { // @13C1 stack[-1] // @13C2 stack[-3] // } 13B8 5B JUMPDEST 13B9 60 PUSH1 0x01 13BB 60 PUSH1 0x01 13BD 60 PUSH1 0xa0 13BF 1B SHL 13C0 03 SUB 13C1 16 AND 13C2 82 DUP3 13C3 60 PUSH1 0x01 13C5 60 PUSH1 0x01 13C7 60 PUSH1 0xa0 13C9 1B SHL 13CA 03 SUB 13CB 16 AND 13CC 14 EQ 13CD 15 ISZERO 13CE 61 PUSH2 0x13e9 13D1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13e9, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_13D2: // Incoming jump from 0x13D1, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @13D4 memory[0x40:0x60] } 13D2 60 PUSH1 0x40 13D4 51 MLOAD 13D5 62 PUSH3 0x461bcd 13D9 60 PUSH1 0xe5 13DB 1B SHL 13DC 81 DUP2 13DD 52 MSTORE 13DE 60 PUSH1 0x04 13E0 01 ADD 13E1 61 PUSH2 0x0626 13E4 90 SWAP1 13E5 61 PUSH2 0x32e4 13E8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E4 stack[0] = 0x0626 // @13E4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x32e4, returns to 0x0626 label_13E9: // Incoming jump from 0x13D1, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @13EA stack[-1] } 13E9 5B JUMPDEST 13EA 80 DUP1 13EB 60 PUSH1 0x05 13ED 60 PUSH1 0x00 13EF 61 PUSH2 0x13f6 13F2 61 PUSH2 0x1874 13F5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13EA stack[0] = stack[-1] // @13EB stack[1] = 0x05 // @13ED stack[2] = 0x00 // @13EF stack[3] = 0x13f6 // } // Block ends with call to 0x1874, returns to 0x13F6 label_13F6: // Incoming return from call to 0x1874 at 0x13F5 // Inputs[8] // { // @13FF stack[-1] // @1402 stack[-2] // @1409 stack[-3] // @1416 memory[0x00:0x00 + 0x40 + stack[-2]] // @1418 stack[-6] // @1422 memory[0x00:0x40] // @1424 storage[keccak256(memory[0x00:0x40])] // @1429 stack[-4] // } 13F6 5B JUMPDEST 13F7 60 PUSH1 0x01 13F9 60 PUSH1 0x01 13FB 60 PUSH1 0xa0 13FD 1B SHL 13FE 03 SUB 13FF 90 SWAP1 1400 81 DUP2 1401 16 AND 1402 82 DUP3 1403 52 MSTORE 1404 60 PUSH1 0x20 1406 80 DUP1 1407 83 DUP4 1408 01 ADD 1409 93 SWAP4 140A 90 SWAP1 140B 93 SWAP4 140C 52 MSTORE 140D 60 PUSH1 0x40 140F 91 SWAP2 1410 82 DUP3 1411 01 ADD 1412 60 PUSH1 0x00 1414 90 SWAP1 1415 81 DUP2 1416 20 SHA3 1417 91 SWAP2 1418 87 DUP8 1419 16 AND 141A 80 DUP1 141B 82 DUP3 141C 52 MSTORE 141D 91 SWAP2 141E 90 SWAP1 141F 93 SWAP4 1420 52 MSTORE 1421 91 SWAP2 1422 20 SHA3 1423 80 DUP1 1424 54 SLOAD 1425 60 PUSH1 0xff 1427 19 NOT 1428 16 AND 1429 92 SWAP3 142A 15 ISZERO 142B 15 ISZERO 142C 92 SWAP3 142D 90 SWAP1 142E 92 SWAP3 142F 17 OR 1430 90 SWAP1 1431 91 SWAP2 1432 55 SSTORE 1433 61 PUSH2 0x143a 1436 61 PUSH2 0x1874 1439 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @1403 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @140C memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @141C memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1420 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @1431 stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1432 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1433 stack[-3] = 0x143a // } // Block ends with call to 0x1874, returns to 0x143A label_143A: // Incoming return from call to 0x1874 at 0x1439 // Inputs[3] // { // @1443 stack[-1] // @1465 stack[-3] // @1468 memory[0x40:0x60] // } 143A 5B JUMPDEST 143B 60 PUSH1 0x01 143D 60 PUSH1 0x01 143F 60 PUSH1 0xa0 1441 1B SHL 1442 03 SUB 1443 16 AND 1444 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1465 83 DUP4 1466 60 PUSH1 0x40 1468 51 MLOAD 1469 61 PUSH2 0x1472 146C 91 SWAP2 146D 90 SWAP1 146E 61 PUSH2 0x300e 1471 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1443 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1444 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @146C stack[1] = 0x1472 // @146D stack[3] = memory[0x40:0x60] // @146D stack[2] = stack[-3] // } // Block ends with call to 0x300e, returns to 0x1472 label_1472: // Incoming return from call to 0x300E at 0x1471 // Inputs[7] // { // @1475 memory[0x40:0x60] // @1477 stack[-1] // @147A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @147A stack[-4] // @147A stack[-3] // @147A stack[-2] // @147D stack[-7] // } 1472 5B JUMPDEST 1473 60 PUSH1 0x40 1475 51 MLOAD 1476 80 DUP1 1477 91 SWAP2 1478 03 SUB 1479 90 SWAP1 147A A3 LOG3 147B 50 POP 147C 50 POP 147D 56 *JUMP // Stack delta = -7 // Outputs[1] { @147A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_147E: // Incoming jump from 0x0483 // Inputs[1] { @1483 storage[0x0a] } 147E 5B JUMPDEST 147F 60 PUSH1 0x02 1481 60 PUSH1 0x0a 1483 54 SLOAD 1484 14 EQ 1485 15 ISZERO 1486 61 PUSH2 0x14a1 1489 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14a1, if !(storage[0x0a] == 0x02) label_148A: // Incoming jump from 0x1489, if not !(storage[0x0a] == 0x02) // Inputs[1] { @148C memory[0x40:0x60] } 148A 60 PUSH1 0x40 148C 51 MLOAD 148D 62 PUSH3 0x461bcd 1491 60 PUSH1 0xe5 1493 1B SHL 1494 81 DUP2 1495 52 MSTORE 1496 60 PUSH1 0x04 1498 01 ADD 1499 61 PUSH2 0x0626 149C 90 SWAP1 149D 61 PUSH2 0x393c 14A0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1495 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @149C stack[0] = 0x0626 // @149C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_14A1: // Incoming jump from 0x1489, if !(storage[0x0a] == 0x02) // Inputs[1] { @14AA stack[-1] } 14A1 5B JUMPDEST 14A2 60 PUSH1 0x02 14A4 60 PUSH1 0x0a 14A6 55 SSTORE 14A7 61 PUSH2 0x14af 14AA 81 DUP2 14AB 61 PUSH2 0x05ff 14AE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14A6 storage[0x0a] = 0x02 // @14A7 stack[0] = 0x14af // @14AA stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x05ff 14AF 5B JUMPDEST 14B0 60 PUSH1 0x01 14B2 60 PUSH1 0x01 14B4 60 PUSH1 0xa0 14B6 1B SHL 14B7 03 SUB 14B8 16 AND 14B9 33 CALLER 14BA 60 PUSH1 0x01 14BC 60 PUSH1 0x01 14BE 60 PUSH1 0xa0 14C0 1B SHL 14C1 03 SUB 14C2 16 AND 14C3 14 EQ 14C4 61 PUSH2 0x14df 14C7 57 *JUMPI 14C8 60 PUSH1 0x40 14CA 51 MLOAD 14CB 62 PUSH3 0x461bcd 14CF 60 PUSH1 0xe5 14D1 1B SHL 14D2 81 DUP2 14D3 52 MSTORE 14D4 60 PUSH1 0x04 14D6 01 ADD 14D7 61 PUSH2 0x0626 14DA 90 SWAP1 14DB 61 PUSH2 0x325e 14DE 56 *JUMP 14DF 5B JUMPDEST 14E0 61 PUSH2 0x14ea 14E3 60 PUSH1 0x00 14E5 82 DUP3 14E6 61 PUSH2 0x1878 14E9 56 *JUMP 14EA 5B JUMPDEST 14EB 50 POP 14EC 60 PUSH1 0x01 14EE 60 PUSH1 0x0a 14F0 55 SSTORE 14F1 56 *JUMP label_14F2: // Incoming jump from 0x0496 // Inputs[1] { @14F7 storage[0x0a] } 14F2 5B JUMPDEST 14F3 60 PUSH1 0x02 14F5 60 PUSH1 0x0a 14F7 54 SLOAD 14F8 14 EQ 14F9 15 ISZERO 14FA 61 PUSH2 0x1515 14FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1515, if !(storage[0x0a] == 0x02) label_14FE: // Incoming jump from 0x14FD, if not !(storage[0x0a] == 0x02) // Inputs[1] { @1500 memory[0x40:0x60] } 14FE 60 PUSH1 0x40 1500 51 MLOAD 1501 62 PUSH3 0x461bcd 1505 60 PUSH1 0xe5 1507 1B SHL 1508 81 DUP2 1509 52 MSTORE 150A 60 PUSH1 0x04 150C 01 ADD 150D 61 PUSH2 0x0626 1510 90 SWAP1 1511 61 PUSH2 0x393c 1514 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1509 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1510 stack[0] = 0x0626 // @1510 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_1515: // Incoming jump from 0x14FD, if !(storage[0x0a] == 0x02) // Inputs[1] { @151B stack[-1] } 1515 5B JUMPDEST 1516 60 PUSH1 0x02 1518 60 PUSH1 0x0a 151A 55 SSTORE 151B 80 DUP1 151C 80 DUP1 151D 61 PUSH2 0x1526 1520 60 PUSH1 0x15 1522 61 PUSH2 0x199c 1525 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @151A storage[0x0a] = 0x02 // @151B stack[0] = stack[-1] // @151C stack[1] = stack[-1] // @151D stack[2] = 0x1526 // @1520 stack[3] = 0x15 // } // Block ends with call to 0x199c, returns to 0x1526 label_1526: // Incoming return from call to 0x199C at 0x1525 // Inputs[2] // { // @1527 stack[-2] // @1527 stack[-1] // } 1526 5B JUMPDEST 1527 11 GT 1528 61 PUSH2 0x1543 152B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1543, if stack[-1] > stack[-2] label_152C: // Incoming jump from 0x152B, if not stack[-1] > stack[-2] // Inputs[1] { @152E memory[0x40:0x60] } 152C 60 PUSH1 0x40 152E 51 MLOAD 152F 62 PUSH3 0x461bcd 1533 60 PUSH1 0xe5 1535 1B SHL 1536 81 DUP2 1537 52 MSTORE 1538 60 PUSH1 0x04 153A 01 ADD 153B 61 PUSH2 0x0626 153E 90 SWAP1 153F 61 PUSH2 0x3115 1542 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1537 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @153E stack[0] = 0x0626 // @153E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3115, returns to 0x0626 label_1543: // Incoming jump from 0x152B, if stack[-1] > stack[-2] // Inputs[4] // { // @1546 storage[0x0b] // @1549 memory[0x40:0x60] // @156A stack[-2] // @156C msg.sender // } 1543 5B JUMPDEST 1544 60 PUSH1 0x0b 1546 54 SLOAD 1547 60 PUSH1 0x40 1549 51 MLOAD 154A 63 PUSH4 0x776a0835 154F 60 PUSH1 0xe0 1551 1B SHL 1552 81 DUP2 1553 52 MSTORE 1554 60 PUSH1 0x01 1556 60 PUSH1 0x01 1558 60 PUSH1 0xa0 155A 1B SHL 155B 03 SUB 155C 90 SWAP1 155D 91 SWAP2 155E 16 AND 155F 90 SWAP1 1560 63 PUSH4 0x776a0835 1565 90 SWAP1 1566 61 PUSH2 0x1575 1569 90 SWAP1 156A 85 DUP6 156B 90 SWAP1 156C 33 CALLER 156D 90 SWAP1 156E 60 PUSH1 0x04 1570 01 ADD 1571 61 PUSH2 0x39b9 1574 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1553 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x776a0835 << 0xe0 // @155F stack[0] = storage[0x0b] & (0x01 << 0xa0) - 0x01 // @1565 stack[1] = 0x776a0835 // @1569 stack[2] = 0x1575 // @156B stack[3] = stack[-2] // @156D stack[4] = msg.sender // @1570 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x39b9, returns to 0x1575 label_1575: // Incoming return from call to 0x39B9 at 0x1574 // Inputs[4] // { // @157A memory[0x40:0x60] // @157C stack[-1] // @1581 stack[-3] // @1583 address(stack[-3]).code.length // } 1575 5B JUMPDEST 1576 60 PUSH1 0x00 1578 60 PUSH1 0x40 157A 51 MLOAD 157B 80 DUP1 157C 83 DUP4 157D 03 SUB 157E 81 DUP2 157F 60 PUSH1 0x00 1581 87 DUP8 1582 80 DUP1 1583 3B EXTCODESIZE 1584 15 ISZERO 1585 80 DUP1 1586 15 ISZERO 1587 61 PUSH2 0x158f 158A 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1576 stack[0] = 0x00 // @157A stack[1] = memory[0x40:0x60] // @157D stack[2] = stack[-1] - memory[0x40:0x60] // @157E stack[3] = memory[0x40:0x60] // @157F stack[4] = 0x00 // @1581 stack[5] = stack[-3] // @1584 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x158f, if !!address(stack[-3]).code.length label_158B: // Incoming jump from 0x158A, if not !!address(stack[-3]).code.length // Inputs[1] { @158E memory[0x00:0x00] } 158B 60 PUSH1 0x00 158D 80 DUP1 158E FD *REVERT // Stack delta = +0 // Outputs[1] { @158E revert(memory[0x00:0x00]); } // Block terminates label_158F: // Incoming jump from 0x158A, if !!address(stack[-3]).code.length // Inputs[9] // { // @1591 msg.gas // @1592 stack[-6] // @1592 stack[-7] // @1592 stack[-4] // @1592 stack[-5] // @1592 memory[stack[-4]:stack[-4] + stack[-5]] // @1592 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1592 stack[-2] // @1592 stack[-3] // } 158F 5B JUMPDEST 1590 50 POP 1591 5A GAS 1592 F1 CALL 1593 15 ISZERO 1594 80 DUP1 1595 15 ISZERO 1596 61 PUSH2 0x15a3 1599 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1592 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1593 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x15a3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_159A: // Incoming jump from 0x1599, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @159A returndata.length // @159E returndata[0x00:0x00 + returndata.length] // @159F returndata.length // @15A2 memory[0x00:0x00 + returndata.length] // } 159A 3D RETURNDATASIZE 159B 60 PUSH1 0x00 159D 80 DUP1 159E 3E RETURNDATACOPY 159F 3D RETURNDATASIZE 15A0 60 PUSH1 0x00 15A2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @159E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @15A2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_15A3: // Incoming jump from 0x1599, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @15AF stack[-7] } 15A3 5B JUMPDEST 15A4 50 POP 15A5 50 POP 15A6 60 PUSH1 0x01 15A8 60 PUSH1 0x0a 15AA 55 SSTORE 15AB 50 POP 15AC 50 POP 15AD 50 POP 15AE 50 POP 15AF 56 *JUMP // Stack delta = -7 // Outputs[1] { @15AA storage[0x0a] = 0x01 } // Block ends with unconditional jump to stack[-7] label_15B0: // Incoming jump from 0x04A9 // Incoming jump from 0x0CE5 15B0 5B JUMPDEST 15B1 61 PUSH2 0x15c1 15B4 61 PUSH2 0x15bb 15B7 61 PUSH2 0x1874 15BA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15B1 stack[0] = 0x15c1 // @15B4 stack[1] = 0x15bb // } // Block ends with call to 0x1874, returns to 0x15BB label_15BB: // Incoming return from call to 0x1874 at 0x15BA // Inputs[1] { @15BC stack[-4] } 15BB 5B JUMPDEST 15BC 83 DUP4 15BD 61 PUSH2 0x19ab 15C0 56 *JUMP // Stack delta = +1 // Outputs[1] { @15BC stack[0] = stack[-4] } // Block ends with unconditional jump to 0x19ab 15C1 5B JUMPDEST 15C2 61 PUSH2 0x15dd 15C5 57 *JUMPI 15C6 60 PUSH1 0x40 15C8 51 MLOAD 15C9 62 PUSH3 0x461bcd 15CD 60 PUSH1 0xe5 15CF 1B SHL 15D0 81 DUP2 15D1 52 MSTORE 15D2 60 PUSH1 0x04 15D4 01 ADD 15D5 61 PUSH2 0x0626 15D8 90 SWAP1 15D9 61 PUSH2 0x3846 15DC 56 *JUMP 15DD 5B JUMPDEST 15DE 61 PUSH2 0x15e9 15E1 84 DUP5 15E2 84 DUP5 15E3 84 DUP5 15E4 84 DUP5 15E5 61 PUSH2 0x1e47 15E8 56 *JUMP label_15E9: // Incoming jump from 0x3AA9, if !(stack[-1] > stack[-4]) // Inputs[1] { @15EE stack[-5] } 15E9 5B JUMPDEST 15EA 50 POP 15EB 50 POP 15EC 50 POP 15ED 50 POP 15EE 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_15EF: // Incoming jump from 0x04BC // Inputs[1] { @15F4 storage[0x0a] } 15EF 5B JUMPDEST 15F0 60 PUSH1 0x02 15F2 60 PUSH1 0x0a 15F4 54 SLOAD 15F5 14 EQ 15F6 15 ISZERO 15F7 61 PUSH2 0x1612 15FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1612, if !(storage[0x0a] == 0x02) label_15FB: // Incoming jump from 0x15FA, if not !(storage[0x0a] == 0x02) // Inputs[1] { @15FD memory[0x40:0x60] } 15FB 60 PUSH1 0x40 15FD 51 MLOAD 15FE 62 PUSH3 0x461bcd 1602 60 PUSH1 0xe5 1604 1B SHL 1605 81 DUP2 1606 52 MSTORE 1607 60 PUSH1 0x04 1609 01 ADD 160A 61 PUSH2 0x0626 160D 90 SWAP1 160E 61 PUSH2 0x393c 1611 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1606 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @160D stack[0] = 0x0626 // @160D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x393c, returns to 0x0626 label_1612: // Incoming jump from 0x15FA, if !(storage[0x0a] == 0x02) // Inputs[2] // { // @1618 msg.sender // @1619 stack[-2] // } 1612 5B JUMPDEST 1613 60 PUSH1 0x02 1615 60 PUSH1 0x0a 1617 55 SSTORE 1618 33 CALLER 1619 82 DUP3 161A 61 PUSH2 0x1623 161D 82 DUP3 161E 82 DUP3 161F 61 PUSH2 0x19ab 1622 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1617 storage[0x0a] = 0x02 // @1618 stack[0] = msg.sender // @1619 stack[1] = stack[-2] // @161A stack[2] = 0x1623 // @161D stack[3] = msg.sender // @161E stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x19ab 1623 5B JUMPDEST 1624 61 PUSH2 0x163f 1627 57 *JUMPI 1628 60 PUSH1 0x40 162A 51 MLOAD 162B 62 PUSH3 0x461bcd 162F 60 PUSH1 0xe5 1631 1B SHL 1632 81 DUP2 1633 52 MSTORE 1634 60 PUSH1 0x04 1636 01 ADD 1637 61 PUSH2 0x0626 163A 90 SWAP1 163B 61 PUSH2 0x36b7 163E 56 *JUMP 163F 5B JUMPDEST 1640 60 PUSH1 0x0b 1642 54 SLOAD 1643 60 PUSH1 0x40 1645 51 MLOAD 1646 63 PUSH4 0xba339399 164B 60 PUSH1 0xe0 164D 1B SHL 164E 81 DUP2 164F 52 MSTORE 1650 60 PUSH1 0x01 1652 60 PUSH1 0x01 1654 60 PUSH1 0xa0 1656 1B SHL 1657 03 SUB 1658 90 SWAP1 1659 91 SWAP2 165A 16 AND 165B 90 SWAP1 165C 63 PUSH4 0xba339399 1661 90 SWAP1 1662 61 PUSH2 0x0f0d 1665 90 SWAP1 1666 87 DUP8 1667 90 SWAP1 1668 87 DUP8 1669 90 SWAP1 166A 60 PUSH1 0x04 166C 01 ADD 166D 61 PUSH2 0x3a1e 1670 56 *JUMP label_1671: // Incoming jump from 0x04CF // Inputs[1] { @1674 stack[-1] } 1671 5B JUMPDEST 1672 60 PUSH1 0x60 1674 81 DUP2 1675 80 DUP1 1676 61 PUSH2 0x167f 1679 60 PUSH1 0x15 167B 61 PUSH2 0x199c 167E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1672 stack[0] = 0x60 // @1674 stack[1] = stack[-1] // @1675 stack[2] = stack[-1] // @1676 stack[3] = 0x167f // @1679 stack[4] = 0x15 // } // Block ends with call to 0x199c, returns to 0x167F label_167F: // Incoming return from call to 0x199C at 0x167E // Inputs[2] // { // @1680 stack[-1] // @1680 stack[-2] // } 167F 5B JUMPDEST 1680 11 GT 1681 61 PUSH2 0x169c 1684 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x169c, if stack[-1] > stack[-2] label_1685: // Incoming jump from 0x1684, if not stack[-1] > stack[-2] // Inputs[1] { @1687 memory[0x40:0x60] } 1685 60 PUSH1 0x40 1687 51 MLOAD 1688 62 PUSH3 0x461bcd 168C 60 PUSH1 0xe5 168E 1B SHL 168F 81 DUP2 1690 52 MSTORE 1691 60 PUSH1 0x04 1693 01 ADD 1694 61 PUSH2 0x0626 1697 90 SWAP1 1698 61 PUSH2 0x3115 169B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1690 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1697 stack[0] = 0x0626 // @1697 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3115, returns to 0x0626 label_169C: // Incoming jump from 0x1684, if stack[-1] > stack[-2] // Inputs[4] // { // @169F stack[-3] // @16AE memory[0x00:0x40] // @16B0 storage[keccak256(memory[0x00:0x40])] // @16B2 memory[0x40:0x60] // } 169C 5B JUMPDEST 169D 60 PUSH1 0x00 169F 83 DUP4 16A0 81 DUP2 16A1 52 MSTORE 16A2 60 PUSH1 0x08 16A4 60 PUSH1 0x20 16A6 90 SWAP1 16A7 81 DUP2 16A8 52 MSTORE 16A9 60 PUSH1 0x40 16AB 91 SWAP2 16AC 82 DUP3 16AD 90 SWAP1 16AE 20 SHA3 16AF 80 DUP1 16B0 54 SLOAD 16B1 83 DUP4 16B2 51 MLOAD 16B3 60 PUSH1 0x1f 16B5 60 PUSH1 0x02 16B7 60 PUSH1 0x00 16B9 19 NOT 16BA 61 PUSH2 0x0100 16BD 60 PUSH1 0x01 16BF 86 DUP7 16C0 16 AND 16C1 15 ISZERO 16C2 02 MUL 16C3 01 ADD 16C4 90 SWAP1 16C5 93 SWAP4 16C6 16 AND 16C7 92 SWAP3 16C8 90 SWAP1 16C9 92 SWAP3 16CA 04 DIV 16CB 91 SWAP2 16CC 82 DUP3 16CD 01 ADD 16CE 84 DUP5 16CF 90 SWAP1 16D0 04 DIV 16D1 84 DUP5 16D2 02 MUL 16D3 81 DUP2 16D4 01 ADD 16D5 84 DUP5 16D6 01 ADD 16D7 90 SWAP1 16D8 94 SWAP5 16D9 52 MSTORE 16DA 80 DUP1 16DB 84 DUP5 16DC 52 MSTORE 16DD 60 PUSH1 0x60 16DF 93 SWAP4 16E0 92 SWAP3 16E1 83 DUP4 16E2 01 ADD 16E3 82 DUP3 16E4 82 DUP3 16E5 80 DUP1 16E6 15 ISZERO 16E7 61 PUSH2 0x1731 16EA 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @16A1 memory[0x00:0x20] = stack[-3] // @16A8 memory[0x20:0x40] = 0x08 // @16AE stack[2] = keccak256(memory[0x00:0x40]) // @16CB stack[3] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @16D9 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @16DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @16DF stack[0] = 0x60 // @16E0 stack[1] = memory[0x40:0x60] // @16E2 stack[4] = memory[0x40:0x60] + 0x20 // @16E3 stack[5] = keccak256(memory[0x00:0x40]) // @16E4 stack[6] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x1731, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_16EB: // Incoming jump from 0x16EA, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @16EB stack[-1] } 16EB 80 DUP1 16EC 60 PUSH1 0x1f 16EE 10 LT 16EF 61 PUSH2 0x1706 16F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1706, if 0x1f < stack[-1] label_16F3: // Incoming jump from 0x16F2, if not 0x1f < stack[-1] // Inputs[4] // { // @16F7 stack[-2] // @16F8 storage[stack[-2]] // @16FB stack[-3] // @16FD stack[-1] // } 16F3 61 PUSH2 0x0100 16F6 80 DUP1 16F7 83 DUP4 16F8 54 SLOAD 16F9 04 DIV 16FA 02 MUL 16FB 83 DUP4 16FC 52 MSTORE 16FD 91 SWAP2 16FE 60 PUSH1 0x20 1700 01 ADD 1701 91 SWAP2 1702 61 PUSH2 0x1731 1705 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @16FC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1701 stack[-1] = stack[-1] // @1701 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1731 label_1706: // Incoming jump from 0x16F2, if 0x1f < stack[-1] // Inputs[5] // { // @1707 stack[-3] // @1708 stack[-1] // @170A stack[-2] // @1712 memory[0x00:0x20] // @1716 storage[keccak256(memory[0x00:0x20])] // } 1706 5B JUMPDEST 1707 82 DUP3 1708 01 ADD 1709 91 SWAP2 170A 90 SWAP1 170B 60 PUSH1 0x00 170D 52 MSTORE 170E 60 PUSH1 0x20 1710 60 PUSH1 0x00 1712 20 SHA3 1713 90 SWAP1 1714 5B JUMPDEST 1715 81 DUP2 1716 54 SLOAD 1717 81 DUP2 1718 52 MSTORE 1719 90 SWAP1 171A 60 PUSH1 0x01 171C 01 ADD 171D 90 SWAP1 171E 60 PUSH1 0x20 1720 01 ADD 1721 80 DUP1 1722 83 DUP4 1723 11 GT 1724 61 PUSH2 0x1714 1727 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1709 stack[-3] = stack[-3] + stack[-1] // @170D memory[0x00:0x20] = stack[-2] // @1718 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @171D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1720 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1714, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1728: // Incoming jump from 0x1727, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1727, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1728 stack[-3] // @1729 stack[-1] // } 1728 82 DUP3 1729 90 SWAP1 172A 03 SUB 172B 60 PUSH1 0x1f 172D 16 AND 172E 82 DUP3 172F 01 ADD 1730 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1730 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1730 stack[-1] = stack[-3] // } // Block continues label_1731: // Incoming jump from 0x1730 // Incoming jump from 0x1705 // Incoming jump from 0x16EA, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[4] // { // @1733 stack[-6] // @1733 stack[-2] // @1734 stack[-11] // @1735 stack[-10] // } 1731 5B JUMPDEST 1732 50 POP 1733 93 SWAP4 1734 98 SWAP9 1735 97 SWAP8 1736 50 POP 1737 50 POP 1738 50 POP 1739 50 POP 173A 50 POP 173B 50 POP 173C 50 POP 173D 50 POP 173E 56 *JUMP // Stack delta = -10 // Outputs[1] { @1734 stack[-11] = stack[-6] } // Block ends with unconditional jump to stack[-11] label_173F: // Incoming call from 0x04D7, returns to 0x0260 // Inputs[1] { @1761 stack[-1] } 173F 5B JUMPDEST 1740 7F PUSH32 0x2952e482b8e2b192305f87374d7af45dc2eafafe4f50d26a0c02e90f2fdbe14b 1761 81 DUP2 1762 56 *JUMP // Stack delta = +1 // Outputs[1] { @1740 stack[0] = 0x2952e482b8e2b192305f87374d7af45dc2eafafe4f50d26a0c02e90f2fdbe14b } // Block ends with unconditional jump to stack[-1] label_1763: // Incoming jump from 0x04EA // Inputs[4] // { // @176B stack[-1] // @1771 memory[0x00:0x40] // @1772 storage[keccak256(memory[0x00:0x40])] // @177C stack[-2] // } 1763 5B JUMPDEST 1764 60 PUSH1 0x0d 1766 60 PUSH1 0x20 1768 52 MSTORE 1769 60 PUSH1 0x00 176B 90 SWAP1 176C 81 DUP2 176D 52 MSTORE 176E 60 PUSH1 0x40 1770 90 SWAP1 1771 20 SHA3 1772 54 SLOAD 1773 60 PUSH1 0x01 1775 60 PUSH1 0x01 1777 60 PUSH1 0xa0 1779 1B SHL 177A 03 SUB 177B 16 AND 177C 81 DUP2 177D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1768 memory[0x20:0x40] = 0x0d // @176D memory[0x00:0x20] = stack[-1] // @177B stack[-1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] 177E 5B JUMPDEST 177F 60 PUSH1 0x01 1781 60 PUSH1 0x01 1783 60 PUSH1 0xa0 1785 1B SHL 1786 03 SUB 1787 91 SWAP2 1788 82 DUP3 1789 16 AND 178A 60 PUSH1 0x00 178C 90 SWAP1 178D 81 DUP2 178E 52 MSTORE 178F 60 PUSH1 0x05 1791 60 PUSH1 0x20 1793 90 SWAP1 1794 81 DUP2 1795 52 MSTORE 1796 60 PUSH1 0x40 1798 80 DUP1 1799 83 DUP4 179A 20 SHA3 179B 93 SWAP4 179C 90 SWAP1 179D 94 SWAP5 179E 16 AND 179F 82 DUP3 17A0 52 MSTORE 17A1 91 SWAP2 17A2 90 SWAP1 17A3 91 SWAP2 17A4 52 MSTORE 17A5 20 SHA3 17A6 54 SLOAD 17A7 60 PUSH1 0xff 17A9 16 AND 17AA 90 SWAP1 17AB 56 *JUMP label_17AC: // Incoming jump from 0x0510 // Inputs[2] // { // @17AF storage[0x0b] // @17B9 msg.sender // } 17AC 5B JUMPDEST 17AD 60 PUSH1 0x0b 17AF 54 SLOAD 17B0 60 PUSH1 0x01 17B2 60 PUSH1 0x01 17B4 60 PUSH1 0xa0 17B6 1B SHL 17B7 03 SUB 17B8 16 AND 17B9 33 CALLER 17BA 14 EQ 17BB 61 PUSH2 0x17d6 17BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17d6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] label_17BF: // Incoming jump from 0x17BE, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] // Inputs[1] { @17C1 memory[0x40:0x60] } 17BF 60 PUSH1 0x40 17C1 51 MLOAD 17C2 62 PUSH3 0x461bcd 17C6 60 PUSH1 0xe5 17C8 1B SHL 17C9 81 DUP2 17CA 52 MSTORE 17CB 60 PUSH1 0x04 17CD 01 ADD 17CE 61 PUSH2 0x0626 17D1 90 SWAP1 17D2 61 PUSH2 0x356f 17D5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17D1 stack[0] = 0x0626 // @17D1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x356f, returns to 0x0626 label_17D6: // Incoming jump from 0x17BE, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] // Inputs[1] { @17DA stack[-2] } 17D6 5B JUMPDEST 17D7 61 PUSH2 0x17df 17DA 82 DUP3 17DB 61 PUSH2 0x0f4a 17DE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @17D7 stack[0] = 0x17df // @17DA stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x0f4a 17DF 5B JUMPDEST 17E0 60 PUSH1 0x00 17E2 83 DUP4 17E3 81 DUP2 17E4 52 MSTORE 17E5 60 PUSH1 0x0c 17E7 60 PUSH1 0x20 17E9 52 MSTORE 17EA 60 PUSH1 0x40 17EC 90 SWAP1 17ED 20 SHA3 17EE 80 DUP1 17EF 54 SLOAD 17F0 60 PUSH1 0x01 17F2 60 PUSH1 0x01 17F4 60 PUSH1 0xa0 17F6 1B SHL 17F7 03 SUB 17F8 19 NOT 17F9 16 AND 17FA 60 PUSH1 0x01 17FC 60 PUSH1 0x01 17FE 60 PUSH1 0xa0 1800 1B SHL 1801 03 SUB 1802 92 SWAP3 1803 90 SWAP1 1804 92 SWAP3 1805 16 AND 1806 91 SWAP2 1807 90 SWAP1 1808 91 SWAP2 1809 17 OR 180A 90 SWAP1 180B 55 SSTORE 180C 61 PUSH2 0x182e 180F 61 PUSH2 0x1817 1812 83 DUP4 1813 61 PUSH2 0x0f4a 1816 56 *JUMP 1817 5B JUMPDEST 1818 82 DUP3 1819 84 DUP5 181A 60 PUSH1 0x40 181C 51 MLOAD 181D 80 DUP1 181E 60 PUSH1 0x20 1820 01 ADD 1821 60 PUSH1 0x40 1823 52 MSTORE 1824 80 DUP1 1825 60 PUSH1 0x00 1827 81 DUP2 1828 52 MSTORE 1829 50 POP 182A 61 PUSH2 0x1e47 182D 56 *JUMP 182E 5B JUMPDEST 182F 50 POP 1830 50 POP 1831 56 *JUMP label_1832: // Incoming jump from 0x0523 // Inputs[6] // { // @183C stack[-2] // @1843 memory[0x00:0x40] // @1847 stack[-1] // @184B memory[0x00:0x40] // @184C storage[keccak256(memory[0x00:0x40])] // @184D stack[-3] // } 1832 5B JUMPDEST 1833 60 PUSH1 0x13 1835 60 PUSH1 0x20 1837 90 SWAP1 1838 81 DUP2 1839 52 MSTORE 183A 60 PUSH1 0x00 183C 92 SWAP3 183D 83 DUP4 183E 52 MSTORE 183F 60 PUSH1 0x40 1841 80 DUP1 1842 84 DUP5 1843 20 SHA3 1844 90 SWAP1 1845 91 SWAP2 1846 52 MSTORE 1847 90 SWAP1 1848 82 DUP3 1849 52 MSTORE 184A 90 SWAP1 184B 20 SHA3 184C 54 SLOAD 184D 81 DUP2 184E 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1839 memory[0x20:0x40] = 0x13 // @183E memory[0x00:0x20] = stack[-2] // @1846 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1849 memory[0x00:0x20] = stack[-1] // @184C stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_184F: // Incoming jump from 0x0536 // Inputs[4] // { // @1857 stack[-1] // @185D memory[0x00:0x40] // @185E storage[keccak256(memory[0x00:0x40])] // @185F stack[-2] // } 184F 5B JUMPDEST 1850 60 PUSH1 0x0f 1852 60 PUSH1 0x20 1854 52 MSTORE 1855 60 PUSH1 0x00 1857 90 SWAP1 1858 81 DUP2 1859 52 MSTORE 185A 60 PUSH1 0x40 185C 90 SWAP1 185D 20 SHA3 185E 54 SLOAD 185F 81 DUP2 1860 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1854 memory[0x20:0x40] = 0x0f // @1859 memory[0x00:0x20] = stack[-1] // @185E stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_1861: // Incoming jump from 0x0E05 // Incoming jump from 0x0D17 // Incoming jump from 0x0726 // Incoming jump from 0x0609 // Incoming jump from 0x2568 // Incoming jump from 0x19B5 // Inputs[1] { @1869 stack[-1] } 1861 5B JUMPDEST 1862 60 PUSH1 0x00 1864 61 PUSH2 0x0ca1 1867 60 PUSH1 0x02 1869 83 DUP4 186A 63 PUSH4 0xffffffff 186F 61 PUSH2 0x1e7a 1872 16 AND 1873 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1862 stack[0] = 0x00 // @1864 stack[1] = 0x0ca1 // @1867 stack[2] = 0x02 // @1869 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1e7a & 0xffffffff label_1874: // Incoming call from 0x13F5, returns to 0x13F6 // Incoming call from 0x13B7, returns to 0x13B8 // Incoming call from 0x1439, returns to 0x143A // Incoming call from 0x0B5E, returns to 0x0B5F // Incoming call from 0x15BA, returns to 0x15BB // Inputs[2] // { // @1875 msg.sender // @1876 stack[-1] // } 1874 5B JUMPDEST 1875 33 CALLER 1876 90 SWAP1 1877 56 *JUMP // Stack delta = +0 // Outputs[1] { @1876 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] 1878 5B JUMPDEST 1879 60 PUSH1 0x00 187B 81 DUP2 187C 81 DUP2 187D 52 MSTORE 187E 60 PUSH1 0x04 1880 60 PUSH1 0x20 1882 52 MSTORE 1883 60 PUSH1 0x40 1885 90 SWAP1 1886 20 SHA3 1887 80 DUP1 1888 54 SLOAD 1889 60 PUSH1 0x01 188B 60 PUSH1 0x01 188D 60 PUSH1 0xa0 188F 1B SHL 1890 03 SUB 1891 19 NOT 1892 16 AND 1893 60 PUSH1 0x01 1895 60 PUSH1 0x01 1897 60 PUSH1 0xa0 1899 1B SHL 189A 03 SUB 189B 84 DUP5 189C 16 AND 189D 90 SWAP1 189E 81 DUP2 189F 17 OR 18A0 90 SWAP1 18A1 91 SWAP2 18A2 55 SSTORE 18A3 81 DUP2 18A4 90 SWAP1 18A5 61 PUSH2 0x18ad 18A8 82 DUP3 18A9 61 PUSH2 0x0f4a 18AC 56 *JUMP 18AD 5B JUMPDEST 18AE 60 PUSH1 0x01 18B0 60 PUSH1 0x01 18B2 60 PUSH1 0xa0 18B4 1B SHL 18B5 03 SUB 18B6 16 AND 18B7 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 18D8 60 PUSH1 0x40 18DA 51 MLOAD 18DB 60 PUSH1 0x40 18DD 51 MLOAD 18DE 80 DUP1 18DF 91 SWAP2 18E0 03 SUB 18E1 90 SWAP1 18E2 A4 LOG4 18E3 50 POP 18E4 50 POP 18E5 56 *JUMP label_18E6: // Incoming call from 0x11C7, returns to 0x11C8 // Inputs[2] // { // @18E9 memory[0x40:0x60] // @18ED CHAINID() // } 18E6 5B JUMPDEST 18E7 60 PUSH1 0x40 18E9 51 MLOAD 18EA 60 PUSH1 0x00 18EC 90 SWAP1 18ED 46 CHAINID 18EE 90 SWAP1 18EF 61 PUSH2 0x18f7 18F2 90 SWAP1 18F3 61 PUSH2 0x2f13 18F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18EC stack[0] = 0x00 // @18EE stack[1] = CHAINID() // @18F2 stack[2] = 0x18f7 // @18F2 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2f13, returns to 0x18F7 label_18F7: // Incoming return from call to 0x2F13 at 0x18F6 // Inputs[7] // { // @18FB memory[0x40:0x60] // @18FC stack[-1] // @1901 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @191A memory[0x40:0x60] // @192E memory[0x40:0x60] // @1977 stack[-2] // @1979 address(this) // } 18F7 5B JUMPDEST 18F8 60 PUSH1 0x40 18FA 80 DUP1 18FB 51 MLOAD 18FC 91 SWAP2 18FD 82 DUP3 18FE 90 SWAP1 18FF 03 SUB 1900 82 DUP3 1901 20 SHA3 1902 82 DUP3 1903 82 DUP3 1904 01 ADD 1905 82 DUP3 1906 52 MSTORE 1907 60 PUSH1 0x04 1909 83 DUP4 190A 52 MSTORE 190B 63 PUSH4 0x5a6f7261 1910 60 PUSH1 0xe0 1912 1B SHL 1913 60 PUSH1 0x20 1915 93 SWAP4 1916 84 DUP5 1917 01 ADD 1918 52 MSTORE 1919 81 DUP2 191A 51 MLOAD 191B 80 DUP1 191C 83 DUP4 191D 01 ADD 191E 83 DUP4 191F 52 MSTORE 1920 60 PUSH1 0x01 1922 81 DUP2 1923 52 MSTORE 1924 60 PUSH1 0x31 1926 60 PUSH1 0xf8 1928 1B SHL 1929 90 SWAP1 192A 84 DUP5 192B 01 ADD 192C 52 MSTORE 192D 90 SWAP1 192E 51 MLOAD 192F 61 PUSH2 0x1980 1932 92 SWAP3 1933 7F PUSH32 0x91beda2a71cae260ce24b7d0ba9253f7212b59cbe39b0f303ac34fac7c00047d 1954 91 SWAP2 1955 7F PUSH32 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6 1976 91 SWAP2 1977 86 DUP7 1978 91 SWAP2 1979 30 ADDRESS 197A 91 SWAP2 197B 01 ADD 197C 61 PUSH2 0x304e 197F 56 *JUMP // Stack delta = +6 // Outputs[13] // { // @1906 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @190A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x04 // @1918 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x5a6f7261 << 0xe0 // @191F memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1923 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @192C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x31 << 0xf8 // @192D stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1932 stack[-1] = 0x1980 // @1954 stack[1] = 0x91beda2a71cae260ce24b7d0ba9253f7212b59cbe39b0f303ac34fac7c00047d // @1976 stack[2] = 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6 // @1978 stack[3] = stack[-2] // @197A stack[4] = address(this) // @197B stack[5] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x304e, returns to 0x1980 label_1980: // Incoming return from call to 0x304E at 0x197F // Inputs[6] // { // @1983 memory[0x40:0x60] // @1987 stack[-1] // @1991 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1996 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1997 stack[-3] // @199A stack[-4] // } 1980 5B JUMPDEST 1981 60 PUSH1 0x40 1983 51 MLOAD 1984 60 PUSH1 0x20 1986 81 DUP2 1987 83 DUP4 1988 03 SUB 1989 03 SUB 198A 81 DUP2 198B 52 MSTORE 198C 90 SWAP1 198D 60 PUSH1 0x40 198F 52 MSTORE 1990 80 DUP1 1991 51 MLOAD 1992 90 SWAP1 1993 60 PUSH1 0x20 1995 01 ADD 1996 20 SHA3 1997 91 SWAP2 1998 50 POP 1999 50 POP 199A 90 SWAP1 199B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @198B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @198F memory[0x40:0x60] = stack[-1] // @199A stack[-4] = 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[-4] label_199C: // Incoming call from 0x1525, returns to 0x1526 // Incoming call from 0x19AA, returns to 0x0CA1 // Incoming call from 0x1BA3, returns to 0x1BA4 // Incoming call from 0x167E, returns to 0x167F // Incoming call from 0x0926, returns to 0x0927 // Inputs[3] // { // @199D stack[-1] // @199D storage[stack[-1]] // @199E stack[-2] // } 199C 5B JUMPDEST 199D 54 SLOAD 199E 90 SWAP1 199F 56 *JUMP // Stack delta = -1 // Outputs[1] { @199E stack[-2] = storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] label_19A0: // Incoming jump from 0x09EF // Inputs[1] { @19A6 stack[-1] } 19A0 5B JUMPDEST 19A1 60 PUSH1 0x00 19A3 61 PUSH2 0x0ca1 19A6 82 DUP3 19A7 61 PUSH2 0x199c 19AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19A1 stack[0] = 0x00 // @19A3 stack[1] = 0x0ca1 // @19A6 stack[2] = stack[-1] // } // Block ends with call to 0x199c, returns to 0x0CA1 label_19AB: // Incoming jump from 0x0BBF // Incoming jump from 0x1622 // Incoming jump from 0x15C0 // Incoming jump from 0x0A28 // Incoming jump from 0x1055 // Incoming jump from 0x0EBE // Incoming jump from 0x0B64 // Inputs[1] { @19B1 stack[-1] } 19AB 5B JUMPDEST 19AC 60 PUSH1 0x00 19AE 61 PUSH2 0x19b6 19B1 82 DUP3 19B2 61 PUSH2 0x1861 19B5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19AC stack[0] = 0x00 // @19AE stack[1] = 0x19b6 // @19B1 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1861 19B6 5B JUMPDEST 19B7 61 PUSH2 0x19d2 19BA 57 *JUMPI 19BB 60 PUSH1 0x40 19BD 51 MLOAD 19BE 62 PUSH3 0x461bcd 19C2 60 PUSH1 0xe5 19C4 1B SHL 19C5 81 DUP2 19C6 52 MSTORE 19C7 60 PUSH1 0x04 19C9 01 ADD 19CA 61 PUSH2 0x0626 19CD 90 SWAP1 19CE 61 PUSH2 0x33ae 19D1 56 *JUMP 19D2 5B JUMPDEST 19D3 60 PUSH1 0x00 19D5 61 PUSH2 0x19dd 19D8 83 DUP4 19D9 61 PUSH2 0x0f4a 19DC 56 *JUMP 19DD 5B JUMPDEST 19DE 90 SWAP1 19DF 50 POP 19E0 80 DUP1 19E1 60 PUSH1 0x01 19E3 60 PUSH1 0x01 19E5 60 PUSH1 0xa0 19E7 1B SHL 19E8 03 SUB 19E9 16 AND 19EA 84 DUP5 19EB 60 PUSH1 0x01 19ED 60 PUSH1 0x01 19EF 60 PUSH1 0xa0 19F1 1B SHL 19F2 03 SUB 19F3 16 AND 19F4 14 EQ 19F5 80 DUP1 19F6 61 PUSH2 0x1a18 19F9 57 *JUMPI 19FA 50 POP 19FB 83 DUP4 19FC 60 PUSH1 0x01 19FE 60 PUSH1 0x01 1A00 60 PUSH1 0xa0 1A02 1B SHL 1A03 03 SUB 1A04 16 AND 1A05 61 PUSH2 0x1a0d 1A08 84 DUP5 1A09 61 PUSH2 0x05ff 1A0C 56 *JUMP 1A0D 5B JUMPDEST 1A0E 60 PUSH1 0x01 1A10 60 PUSH1 0x01 1A12 60 PUSH1 0xa0 1A14 1B SHL 1A15 03 SUB 1A16 16 AND 1A17 14 EQ 1A18 5B JUMPDEST 1A19 80 DUP1 1A1A 61 PUSH2 0x1a28 1A1D 57 *JUMPI 1A1E 50 POP 1A1F 61 PUSH2 0x1a28 1A22 81 DUP2 1A23 85 DUP6 1A24 61 PUSH2 0x177e 1A27 56 *JUMP 1A28 5B JUMPDEST 1A29 94 SWAP5 1A2A 93 SWAP4 1A2B 50 POP 1A2C 50 POP 1A2D 50 POP 1A2E 50 POP 1A2F 56 *JUMP 1A30 5B JUMPDEST 1A31 61 PUSH2 0x1a39 1A34 82 DUP3 1A35 61 PUSH2 0x1861 1A38 56 *JUMP 1A39 5B JUMPDEST 1A3A 61 PUSH2 0x1a55 1A3D 57 *JUMPI 1A3E 60 PUSH1 0x40 1A40 51 MLOAD 1A41 62 PUSH3 0x461bcd 1A45 60 PUSH1 0xe5 1A47 1B SHL 1A48 81 DUP2 1A49 52 MSTORE 1A4A 60 PUSH1 0x04 1A4C 01 ADD 1A4D 61 PUSH2 0x0626 1A50 90 SWAP1 1A51 61 PUSH2 0x366b 1A54 56 *JUMP 1A55 5B JUMPDEST 1A56 60 PUSH1 0x00 1A58 82 DUP3 1A59 81 DUP2 1A5A 52 MSTORE 1A5B 60 PUSH1 0x08 1A5D 60 PUSH1 0x20 1A5F 90 SWAP1 1A60 81 DUP2 1A61 52 MSTORE 1A62 60 PUSH1 0x40 1A64 90 SWAP1 1A65 91 SWAP2 1A66 20 SHA3 1A67 82 DUP3 1A68 51 MLOAD 1A69 61 PUSH2 0x06de 1A6C 92 SWAP3 1A6D 84 DUP5 1A6E 01 ADD 1A6F 90 SWAP1 1A70 61 PUSH2 0x27a2 1A73 56 *JUMP 1A74 5B JUMPDEST 1A75 60 PUSH1 0x0b 1A77 54 SLOAD 1A78 60 PUSH1 0x40 1A7A 51 MLOAD 1A7B 63 PUSH4 0x28220f35 1A80 60 PUSH1 0xe0 1A82 1B SHL 1A83 81 DUP2 1A84 52 MSTORE 1A85 60 PUSH1 0x01 1A87 60 PUSH1 0x01 1A89 60 PUSH1 0xa0 1A8B 1B SHL 1A8C 03 SUB 1A8D 90 SWAP1 1A8E 91 SWAP2 1A8F 16 AND 1A90 90 SWAP1 1A91 63 PUSH4 0x28220f35 1A96 90 SWAP1 1A97 61 PUSH2 0x1aa4 1A9A 90 SWAP1 1A9B 84 DUP5 1A9C 90 SWAP1 1A9D 60 PUSH1 0x04 1A9F 01 ADD 1AA0 61 PUSH2 0x3019 1AA3 56 *JUMP 1AA4 5B JUMPDEST 1AA5 60 PUSH1 0x00 1AA7 60 PUSH1 0x40 1AA9 51 MLOAD 1AAA 80 DUP1 1AAB 83 DUP4 1AAC 03 SUB 1AAD 81 DUP2 1AAE 60 PUSH1 0x00 1AB0 87 DUP8 1AB1 80 DUP1 1AB2 3B EXTCODESIZE 1AB3 15 ISZERO 1AB4 80 DUP1 1AB5 15 ISZERO 1AB6 61 PUSH2 0x1abe 1AB9 57 *JUMPI 1ABA 60 PUSH1 0x00 1ABC 80 DUP1 1ABD FD *REVERT 1ABE 5B JUMPDEST 1ABF 50 POP 1AC0 5A GAS 1AC1 F1 CALL 1AC2 15 ISZERO 1AC3 80 DUP1 1AC4 15 ISZERO 1AC5 61 PUSH2 0x1ad2 1AC8 57 *JUMPI 1AC9 3D RETURNDATASIZE 1ACA 60 PUSH1 0x00 1ACC 80 DUP1 1ACD 3E RETURNDATACOPY 1ACE 3D RETURNDATASIZE 1ACF 60 PUSH1 0x00 1AD1 FD *REVERT 1AD2 5B JUMPDEST 1AD3 50 POP 1AD4 50 POP 1AD5 50 POP 1AD6 50 POP 1AD7 61 PUSH2 0x06de 1ADA 83 DUP4 1ADB 83 DUP4 1ADC 83 DUP4 1ADD 61 PUSH2 0x1e86 1AE0 56 *JUMP label_1AE1: // Incoming jump from 0x1324 // Inputs[3] // { // @1AE2 stack[-2] // @1AE3 memory[stack[-2]:stack[-2] + 0x20] // @1AE5 memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] // } 1AE1 5B JUMPDEST 1AE2 81 DUP2 1AE3 51 MLOAD 1AE4 80 DUP1 1AE5 51 MLOAD 1AE6 61 PUSH2 0x1b01 1AE9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AE3 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1b01, if memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] label_1AEA: // Incoming jump from 0x1AE9, if not memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] // Inputs[1] { @1AEC memory[0x40:0x60] } 1AEA 60 PUSH1 0x40 1AEC 51 MLOAD 1AED 62 PUSH3 0x461bcd 1AF1 60 PUSH1 0xe5 1AF3 1B SHL 1AF4 81 DUP2 1AF5 52 MSTORE 1AF6 60 PUSH1 0x04 1AF8 01 ADD 1AF9 61 PUSH2 0x0626 1AFC 90 SWAP1 1AFD 61 PUSH2 0x3973 1B00 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1AF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1AFC stack[0] = 0x0626 // @1AFC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3973, returns to 0x0626 label_1B01: // Incoming jump from 0x1AE9, if memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] // Inputs[3] // { // @1B04 stack[-3] // @1B06 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1B08 memory[memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]:memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] + 0x20] // } 1B01 5B JUMPDEST 1B02 60 PUSH1 0x20 1B04 83 DUP4 1B05 01 ADD 1B06 51 MLOAD 1B07 80 DUP1 1B08 51 MLOAD 1B09 61 PUSH2 0x1b24 1B0C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B06 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] } // Block ends with conditional jump to 0x1b24, if memory[memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]:memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] + 0x20] label_1B0D: // Incoming jump from 0x1B0C, if not memory[memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]:memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] + 0x20] // Inputs[1] { @1B0F memory[0x40:0x60] } 1B0D 60 PUSH1 0x40 1B0F 51 MLOAD 1B10 62 PUSH3 0x461bcd 1B14 60 PUSH1 0xe5 1B16 1B SHL 1B17 81 DUP2 1B18 52 MSTORE 1B19 60 PUSH1 0x04 1B1B 01 ADD 1B1C 61 PUSH2 0x0626 1B1F 90 SWAP1 1B20 61 PUSH2 0x3973 1B23 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B1F stack[0] = 0x0626 // @1B1F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3973, returns to 0x0626 label_1B24: // Incoming jump from 0x1B0C, if memory[memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]:memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] + 0x20] // Inputs[2] // { // @1B27 stack[-4] // @1B29 memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // } 1B24 5B JUMPDEST 1B25 60 PUSH1 0x40 1B27 84 DUP5 1B28 01 ADD 1B29 51 MLOAD 1B2A 61 PUSH2 0x1b45 1B2D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b45, if memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] label_1B2E: // Incoming jump from 0x1B2D, if not memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // Inputs[1] { @1B30 memory[0x40:0x60] } 1B2E 60 PUSH1 0x40 1B30 51 MLOAD 1B31 62 PUSH3 0x461bcd 1B35 60 PUSH1 0xe5 1B37 1B SHL 1B38 81 DUP2 1B39 52 MSTORE 1B3A 60 PUSH1 0x04 1B3C 01 ADD 1B3D 61 PUSH2 0x0626 1B40 90 SWAP1 1B41 61 PUSH2 0x336a 1B44 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B39 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B40 stack[0] = 0x0626 // @1B40 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x336a, returns to 0x0626 label_1B45: // Incoming jump from 0x1B2D, if memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // Inputs[4] // { // @1B49 stack[-4] // @1B4B memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @1B56 memory[0x00:0x40] // @1B57 storage[keccak256(memory[0x00:0x40])] // } 1B45 5B JUMPDEST 1B46 60 PUSH1 0x40 1B48 80 DUP1 1B49 85 DUP6 1B4A 01 ADD 1B4B 51 MLOAD 1B4C 60 PUSH1 0x00 1B4E 90 SWAP1 1B4F 81 DUP2 1B50 52 MSTORE 1B51 60 PUSH1 0x12 1B53 60 PUSH1 0x20 1B55 52 MSTORE 1B56 20 SHA3 1B57 54 SLOAD 1B58 60 PUSH1 0xff 1B5A 16 AND 1B5B 15 ISZERO 1B5C 61 PUSH2 0x1b77 1B5F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1B50 memory[0x00:0x20] = memory[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @1B55 memory[0x20:0x40] = 0x12 // } // Block ends with conditional jump to 0x1b77, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1B60: // Incoming jump from 0x1B5F, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1B62 memory[0x40:0x60] } 1B60 60 PUSH1 0x40 1B62 51 MLOAD 1B63 62 PUSH3 0x461bcd 1B67 60 PUSH1 0xe5 1B69 1B SHL 1B6A 81 DUP2 1B6B 52 MSTORE 1B6C 60 PUSH1 0x04 1B6E 01 ADD 1B6F 61 PUSH2 0x0626 1B72 90 SWAP1 1B73 61 PUSH2 0x34d0 1B76 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B72 stack[0] = 0x0626 // @1B72 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x34d0, returns to 0x0626 label_1B77: // Incoming jump from 0x1B5F, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @1B7A stack[-4] // @1B7C memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // } 1B77 5B JUMPDEST 1B78 60 PUSH1 0x60 1B7A 84 DUP5 1B7B 01 ADD 1B7C 51 MLOAD 1B7D 61 PUSH2 0x1b98 1B80 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b98, if memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] label_1B81: // Incoming jump from 0x1B80, if not memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // Inputs[1] { @1B83 memory[0x40:0x60] } 1B81 60 PUSH1 0x40 1B83 51 MLOAD 1B84 62 PUSH3 0x461bcd 1B88 60 PUSH1 0xe5 1B8A 1B SHL 1B8B 81 DUP2 1B8C 52 MSTORE 1B8D 60 PUSH1 0x04 1B8F 01 ADD 1B90 61 PUSH2 0x0626 1B93 90 SWAP1 1B94 61 PUSH2 0x3789 1B97 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1B8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B93 stack[0] = 0x0626 // @1B93 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3789, returns to 0x0626 label_1B98: // Incoming jump from 0x1B80, if memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] 1B98 5B JUMPDEST 1B99 60 PUSH1 0x00 1B9B 61 PUSH2 0x1ba4 1B9E 60 PUSH1 0x15 1BA0 61 PUSH2 0x199c 1BA3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B99 stack[0] = 0x00 // @1B9B stack[1] = 0x1ba4 // @1B9E stack[2] = 0x15 // } // Block ends with call to 0x199c, returns to 0x1BA4 label_1BA4: // Incoming return from call to 0x199C at 0x1BA3 // Inputs[3] // { // @1BA5 stack[-1] // @1BA5 stack[-2] // @1BAA stack[-7] // } 1BA4 5B JUMPDEST 1BA5 90 SWAP1 1BA6 50 POP 1BA7 61 PUSH2 0x1bb0 1BAA 86 DUP7 1BAB 82 DUP3 1BAC 61 PUSH2 0x1fa6 1BAF 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1BA5 stack[-2] = stack[-1] // @1BA7 stack[-1] = 0x1bb0 // @1BAA stack[0] = stack[-7] // @1BAB stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1fa6 1BB0 5B JUMPDEST 1BB1 61 PUSH2 0x1bba 1BB4 60 PUSH1 0x15 1BB6 61 PUSH2 0x1fc0 1BB9 56 *JUMP 1BBA 5B JUMPDEST 1BBB 61 PUSH2 0x1bc8 1BBE 81 DUP2 1BBF 86 DUP7 1BC0 60 PUSH1 0x40 1BC2 01 ADD 1BC3 51 MLOAD 1BC4 61 PUSH2 0x1fc9 1BC7 56 *JUMP 1BC8 5B JUMPDEST 1BC9 61 PUSH2 0x1bd6 1BCC 81 DUP2 1BCD 86 DUP7 1BCE 60 PUSH1 0x60 1BD0 01 ADD 1BD1 51 MLOAD 1BD2 61 PUSH2 0x2002 1BD5 56 *JUMP 1BD6 5B JUMPDEST 1BD7 61 PUSH2 0x1be4 1BDA 81 DUP2 1BDB 86 DUP7 1BDC 60 PUSH1 0x20 1BDE 01 ADD 1BDF 51 MLOAD 1BE0 61 PUSH2 0x1e02 1BE3 56 *JUMP 1BE4 5B JUMPDEST 1BE5 61 PUSH2 0x1bf2 1BE8 81 DUP2 1BE9 86 DUP7 1BEA 60 PUSH1 0x00 1BEC 01 ADD 1BED 51 MLOAD 1BEE 61 PUSH2 0x1a30 1BF1 56 *JUMP 1BF2 5B JUMPDEST 1BF3 60 PUSH1 0x01 1BF5 60 PUSH1 0x01 1BF7 60 PUSH1 0xa0 1BF9 1B SHL 1BFA 03 SUB 1BFB 86 DUP7 1BFC 16 AND 1BFD 60 PUSH1 0x00 1BFF 90 SWAP1 1C00 81 DUP2 1C01 52 MSTORE 1C02 60 PUSH1 0x0e 1C04 60 PUSH1 0x20 1C06 52 MSTORE 1C07 60 PUSH1 0x40 1C09 90 SWAP1 1C0A 20 SHA3 1C0B 61 PUSH2 0x1c1a 1C0E 90 SWAP1 1C0F 82 DUP3 1C10 63 PUSH4 0xffffffff 1C15 61 PUSH2 0x203b 1C18 16 AND 1C19 56 *JUMP 1C1A 5B JUMPDEST 1C1B 50 POP 1C1C 60 PUSH1 0x40 1C1E 80 DUP1 1C1F 86 DUP7 1C20 01 ADD 1C21 51 MLOAD 1C22 60 PUSH1 0x00 1C24 90 SWAP1 1C25 81 DUP2 1C26 52 MSTORE 1C27 60 PUSH1 0x12 1C29 60 PUSH1 0x20 1C2B 90 SWAP1 1C2C 81 DUP2 1C2D 52 MSTORE 1C2E 82 DUP3 1C2F 82 DUP3 1C30 20 SHA3 1C31 80 DUP1 1C32 54 SLOAD 1C33 60 PUSH1 0xff 1C35 19 NOT 1C36 16 AND 1C37 60 PUSH1 0x01 1C39 17 OR 1C3A 90 SWAP1 1C3B 55 SSTORE 1C3C 83 DUP4 1C3D 82 DUP3 1C3E 52 MSTORE 1C3F 60 PUSH1 0x0d 1C41 81 DUP2 1C42 52 MSTORE 1C43 82 DUP3 1C44 82 DUP3 1C45 20 SHA3 1C46 80 DUP1 1C47 54 SLOAD 1C48 60 PUSH1 0x01 1C4A 60 PUSH1 0x01 1C4C 60 PUSH1 0xa0 1C4E 1B SHL 1C4F 03 SUB 1C50 80 DUP1 1C51 8C DUP13 1C52 16 AND 1C53 60 PUSH1 0x01 1C55 60 PUSH1 0x01 1C57 60 PUSH1 0xa0 1C59 1B SHL 1C5A 03 SUB 1C5B 19 NOT 1C5C 92 SWAP3 1C5D 83 DUP4 1C5E 16 AND 1C5F 81 DUP2 1C60 17 OR 1C61 90 SWAP1 1C62 93 SWAP4 1C63 55 SSTORE 1C64 60 PUSH1 0x0c 1C66 90 SWAP1 1C67 93 SWAP4 1C68 52 MSTORE 1C69 92 SWAP3 1C6A 84 DUP5 1C6B 90 SWAP1 1C6C 20 SHA3 1C6D 80 DUP1 1C6E 54 SLOAD 1C6F 90 SWAP1 1C70 93 SWAP4 1C71 16 AND 1C72 17 OR 1C73 90 SWAP1 1C74 91 SWAP2 1C75 55 SSTORE 1C76 60 PUSH1 0x0b 1C78 54 SLOAD 1C79 91 SWAP2 1C7A 51 MLOAD 1C7B 63 PUSH4 0x75aab41d 1C80 60 PUSH1 0xe1 1C82 1B SHL 1C83 81 DUP2 1C84 52 MSTORE 1C85 91 SWAP2 1C86 16 AND 1C87 90 SWAP1 1C88 63 PUSH4 0xeb55683a 1C8D 90 SWAP1 1C8E 61 PUSH2 0x1c9d 1C91 90 SWAP1 1C92 84 DUP5 1C93 90 SWAP1 1C94 88 DUP9 1C95 90 SWAP1 1C96 60 PUSH1 0x04 1C98 01 ADD 1C99 61 PUSH2 0x39f4 1C9C 56 *JUMP 1C9D 5B JUMPDEST 1C9E 60 PUSH1 0x00 1CA0 60 PUSH1 0x40 1CA2 51 MLOAD 1CA3 80 DUP1 1CA4 83 DUP4 1CA5 03 SUB 1CA6 81 DUP2 1CA7 60 PUSH1 0x00 1CA9 87 DUP8 1CAA 80 DUP1 1CAB 3B EXTCODESIZE 1CAC 15 ISZERO 1CAD 80 DUP1 1CAE 15 ISZERO 1CAF 61 PUSH2 0x1cb7 1CB2 57 *JUMPI 1CB3 60 PUSH1 0x00 1CB5 80 DUP1 1CB6 FD *REVERT 1CB7 5B JUMPDEST 1CB8 50 POP 1CB9 5A GAS 1CBA F1 CALL 1CBB 15 ISZERO 1CBC 80 DUP1 1CBD 15 ISZERO 1CBE 61 PUSH2 0x1ccb 1CC1 57 *JUMPI 1CC2 3D RETURNDATASIZE 1CC3 60 PUSH1 0x00 1CC5 80 DUP1 1CC6 3E RETURNDATACOPY 1CC7 3D RETURNDATASIZE 1CC8 60 PUSH1 0x00 1CCA FD *REVERT 1CCB 5B JUMPDEST 1CCC 50 POP 1CCD 50 POP 1CCE 50 POP 1CCF 50 POP 1CD0 50 POP 1CD1 50 POP 1CD2 50 POP 1CD3 50 POP 1CD4 50 POP 1CD5 50 POP 1CD6 56 *JUMP label_1CD7: // Incoming jump from 0x0C9D // Inputs[2] // { // @1CDD stack[-2] // @1CDE stack[-1] // } 1CD7 5B JUMPDEST 1CD8 60 PUSH1 0x00 1CDA 61 PUSH2 0x0c9e 1CDD 83 DUP4 1CDE 83 DUP4 1CDF 61 PUSH2 0x2047 1CE2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CD8 stack[0] = 0x00 // @1CDA stack[1] = 0x0c9e // @1CDD stack[2] = stack[-2] // @1CDE stack[3] = stack[-1] // } // Block ends with call to 0x2047, returns to 0x0C9E 1CE3 5B JUMPDEST 1CE4 60 PUSH1 0x00 1CE6 81 DUP2 1CE7 81 DUP2 1CE8 52 MSTORE 1CE9 60 PUSH1 0x08 1CEB 60 PUSH1 0x20 1CED 90 SWAP1 1CEE 81 DUP2 1CEF 52 MSTORE 1CF0 60 PUSH1 0x40 1CF2 91 SWAP2 1CF3 82 DUP3 1CF4 90 SWAP1 1CF5 20 SHA3 1CF6 80 DUP1 1CF7 54 SLOAD 1CF8 83 DUP4 1CF9 51 MLOAD 1CFA 60 PUSH1 0x1f 1CFC 60 PUSH1 0x02 1CFE 60 PUSH1 0x00 1D00 19 NOT 1D01 61 PUSH2 0x0100 1D04 60 PUSH1 0x01 1D06 86 DUP7 1D07 16 AND 1D08 15 ISZERO 1D09 02 MUL 1D0A 01 ADD 1D0B 90 SWAP1 1D0C 93 SWAP4 1D0D 16 AND 1D0E 92 SWAP3 1D0F 90 SWAP1 1D10 92 SWAP3 1D11 04 DIV 1D12 91 SWAP2 1D13 82 DUP3 1D14 01 ADD 1D15 84 DUP5 1D16 90 SWAP1 1D17 04 DIV 1D18 84 DUP5 1D19 02 MUL 1D1A 81 DUP2 1D1B 01 ADD 1D1C 84 DUP5 1D1D 01 ADD 1D1E 90 SWAP1 1D1F 94 SWAP5 1D20 52 MSTORE 1D21 80 DUP1 1D22 84 DUP5 1D23 52 MSTORE 1D24 60 PUSH1 0x60 1D26 93 SWAP4 1D27 92 SWAP3 1D28 83 DUP4 1D29 01 ADD 1D2A 82 DUP3 1D2B 82 DUP3 1D2C 80 DUP1 1D2D 15 ISZERO 1D2E 61 PUSH2 0x1d78 1D31 57 *JUMPI 1D32 80 DUP1 1D33 60 PUSH1 0x1f 1D35 10 LT 1D36 61 PUSH2 0x1d4d 1D39 57 *JUMPI 1D3A 61 PUSH2 0x0100 1D3D 80 DUP1 1D3E 83 DUP4 1D3F 54 SLOAD 1D40 04 DIV 1D41 02 MUL 1D42 83 DUP4 1D43 52 MSTORE 1D44 91 SWAP2 1D45 60 PUSH1 0x20 1D47 01 ADD 1D48 91 SWAP2 1D49 61 PUSH2 0x1d78 1D4C 56 *JUMP 1D4D 5B JUMPDEST 1D4E 82 DUP3 1D4F 01 ADD 1D50 91 SWAP2 1D51 90 SWAP1 1D52 60 PUSH1 0x00 1D54 52 MSTORE 1D55 60 PUSH1 0x20 1D57 60 PUSH1 0x00 1D59 20 SHA3 1D5A 90 SWAP1 1D5B 5B JUMPDEST 1D5C 81 DUP2 1D5D 54 SLOAD 1D5E 81 DUP2 1D5F 52 MSTORE 1D60 90 SWAP1 1D61 60 PUSH1 0x01 1D63 01 ADD 1D64 90 SWAP1 1D65 60 PUSH1 0x20 1D67 01 ADD 1D68 80 DUP1 1D69 83 DUP4 1D6A 11 GT 1D6B 61 PUSH2 0x1d5b 1D6E 57 *JUMPI 1D6F 82 DUP3 1D70 90 SWAP1 1D71 03 SUB 1D72 60 PUSH1 0x1f 1D74 16 AND 1D75 82 DUP3 1D76 01 ADD 1D77 91 SWAP2 1D78 5B JUMPDEST 1D79 50 POP 1D7A 50 POP 1D7B 50 POP 1D7C 50 POP 1D7D 50 POP 1D7E 90 SWAP1 1D7F 50 POP 1D80 61 PUSH2 0x1d88 1D83 82 DUP3 1D84 61 PUSH2 0x208c 1D87 56 *JUMP 1D88 5B JUMPDEST 1D89 80 DUP1 1D8A 51 MLOAD 1D8B 15 ISZERO 1D8C 61 PUSH2 0x1db0 1D8F 57 *JUMPI 1D90 60 PUSH1 0x00 1D92 82 DUP3 1D93 81 DUP2 1D94 52 MSTORE 1D95 60 PUSH1 0x08 1D97 60 PUSH1 0x20 1D99 90 SWAP1 1D9A 81 DUP2 1D9B 52 MSTORE 1D9C 60 PUSH1 0x40 1D9E 90 SWAP1 1D9F 91 SWAP2 1DA0 20 SHA3 1DA1 82 DUP3 1DA2 51 MLOAD 1DA3 61 PUSH2 0x1dae 1DA6 92 SWAP3 1DA7 84 DUP5 1DA8 01 ADD 1DA9 90 SWAP1 1DAA 61 PUSH2 0x27a2 1DAD 56 *JUMP 1DAE 5B JUMPDEST 1DAF 50 POP 1DB0 5B JUMPDEST 1DB1 50 POP 1DB2 60 PUSH1 0x00 1DB4 90 SWAP1 1DB5 81 DUP2 1DB6 52 MSTORE 1DB7 60 PUSH1 0x0c 1DB9 60 PUSH1 0x20 1DBB 52 MSTORE 1DBC 60 PUSH1 0x40 1DBE 90 SWAP1 1DBF 20 SHA3 1DC0 80 DUP1 1DC1 54 SLOAD 1DC2 60 PUSH1 0x01 1DC4 60 PUSH1 0x01 1DC6 60 PUSH1 0xa0 1DC8 1B SHL 1DC9 03 SUB 1DCA 19 NOT 1DCB 16 AND 1DCC 90 SWAP1 1DCD 55 SSTORE 1DCE 56 *JUMP label_1DCF: // Incoming call from 0x0DCB, returns to 0x0DCC // Inputs[2] // { // @1DD8 stack[-2] // @1DD9 stack[-1] // } 1DCF 5B JUMPDEST 1DD0 60 PUSH1 0x00 1DD2 80 DUP1 1DD3 80 DUP1 1DD4 80 DUP1 1DD5 61 PUSH2 0x1dde 1DD8 86 DUP7 1DD9 86 DUP7 1DDA 61 PUSH2 0x2165 1DDD 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1DD0 stack[0] = 0x00 // @1DD2 stack[1] = 0x00 // @1DD3 stack[2] = 0x00 // @1DD4 stack[3] = 0x00 // @1DD5 stack[4] = 0x1dde // @1DD8 stack[5] = stack[-2] // @1DD9 stack[6] = stack[-1] // } // Block ends with call to 0x2165, returns to 0x1DDE label_1DDE: // Incoming return from call to 0x2165 at 0x1DDD // Inputs[5] // { // @1DDF stack[-1] // @1DDF stack[-2] // @1DE0 stack[-9] // @1DE2 stack[-8] // @1DE4 stack[-7] // } 1DDE 5B JUMPDEST 1DDF 90 SWAP1 1DE0 97 SWAP8 1DE1 90 SWAP1 1DE2 96 SWAP7 1DE3 50 POP 1DE4 94 SWAP5 1DE5 50 POP 1DE6 50 POP 1DE7 50 POP 1DE8 50 POP 1DE9 50 POP 1DEA 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @1DE0 stack[-9] = stack[-2] // @1DE2 stack[-8] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_1DEB: // Incoming jump from 0x0F77 // Inputs[3] // { // @1DF1 stack[-3] // @1DF2 stack[-2] // @1DF3 stack[-1] // } 1DEB 5B JUMPDEST 1DEC 60 PUSH1 0x00 1DEE 61 PUSH2 0x1df8 1DF1 84 DUP5 1DF2 84 DUP5 1DF3 84 DUP5 1DF4 61 PUSH2 0x21c1 1DF7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1DEC stack[0] = 0x00 // @1DEE stack[1] = 0x1df8 // @1DF1 stack[2] = stack[-3] // @1DF2 stack[3] = stack[-2] // @1DF3 stack[4] = stack[-1] // } // Block ends with call to 0x21c1, returns to 0x1DF8 label_1DF8: // Incoming return from call to 0x21C1 at 0x1DF7 // Inputs[2] // { // @1DF9 stack[-1] // @1DF9 stack[-2] // } 1DF8 5B JUMPDEST 1DF9 90 SWAP1 1DFA 50 POP // Stack delta = -1 // Outputs[1] { @1DF9 stack[-2] = stack[-1] } // Block continues label_1DFB: // Incoming return from call to 0x3AC7 at 0x2C79 // Incoming jump from 0x1DFA // Inputs[3] // { // @1DFC stack[-5] // @1DFC stack[-1] // @1DFD stack[-4] // } 1DFB 5B JUMPDEST 1DFC 93 SWAP4 1DFD 92 SWAP3 1DFE 50 POP 1DFF 50 POP 1E00 50 POP 1E01 56 *JUMP // Stack delta = -4 // Outputs[1] { @1DFC stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 1E02 5B JUMPDEST 1E03 81 DUP2 1E04 61 PUSH2 0x1e0c 1E07 81 DUP2 1E08 61 PUSH2 0x1861 1E0B 56 *JUMP 1E0C 5B JUMPDEST 1E0D 61 PUSH2 0x1e28 1E10 57 *JUMPI 1E11 60 PUSH1 0x40 1E13 51 MLOAD 1E14 62 PUSH3 0x461bcd 1E18 60 PUSH1 0xe5 1E1A 1B SHL 1E1B 81 DUP2 1E1C 52 MSTORE 1E1D 60 PUSH1 0x04 1E1F 01 ADD 1E20 61 PUSH2 0x0626 1E23 90 SWAP1 1E24 61 PUSH2 0x3905 1E27 56 *JUMP 1E28 5B JUMPDEST 1E29 60 PUSH1 0x00 1E2B 83 DUP4 1E2C 81 DUP2 1E2D 52 MSTORE 1E2E 60 PUSH1 0x11 1E30 60 PUSH1 0x20 1E32 90 SWAP1 1E33 81 DUP2 1E34 52 MSTORE 1E35 60 PUSH1 0x40 1E37 90 SWAP1 1E38 91 SWAP2 1E39 20 SHA3 1E3A 83 DUP4 1E3B 51 MLOAD 1E3C 61 PUSH2 0x15e9 1E3F 92 SWAP3 1E40 85 DUP6 1E41 01 ADD 1E42 90 SWAP1 1E43 61 PUSH2 0x27a2 1E46 56 *JUMP 1E47 5B JUMPDEST 1E48 61 PUSH2 0x1e52 1E4B 84 DUP5 1E4C 84 DUP5 1E4D 84 DUP5 1E4E 61 PUSH2 0x1a74 1E51 56 *JUMP 1E52 5B JUMPDEST 1E53 61 PUSH2 0x1e5e 1E56 84 DUP5 1E57 84 DUP5 1E58 84 DUP5 1E59 84 DUP5 1E5A 61 PUSH2 0x2220 1E5D 56 *JUMP 1E5E 5B JUMPDEST 1E5F 61 PUSH2 0x15e9 1E62 57 *JUMPI 1E63 60 PUSH1 0x40 1E65 51 MLOAD 1E66 62 PUSH3 0x461bcd 1E6A 60 PUSH1 0xe5 1E6C 1B SHL 1E6D 81 DUP2 1E6E 52 MSTORE 1E6F 60 PUSH1 0x04 1E71 01 ADD 1E72 61 PUSH2 0x0626 1E75 90 SWAP1 1E76 61 PUSH2 0x315d 1E79 56 *JUMP label_1E7A: // Incoming jump from 0x1873 // Inputs[2] // { // @1E80 stack[-2] // @1E81 stack[-1] // } 1E7A 5B JUMPDEST 1E7B 60 PUSH1 0x00 1E7D 61 PUSH2 0x0c9e 1E80 83 DUP4 1E81 83 DUP4 1E82 61 PUSH2 0x2305 1E85 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E7B stack[0] = 0x00 // @1E7D stack[1] = 0x0c9e // @1E80 stack[2] = stack[-2] // @1E81 stack[3] = stack[-1] // } // Block ends with call to 0x2305, returns to 0x0C9E 1E86 5B JUMPDEST 1E87 82 DUP3 1E88 60 PUSH1 0x01 1E8A 60 PUSH1 0x01 1E8C 60 PUSH1 0xa0 1E8E 1B SHL 1E8F 03 SUB 1E90 16 AND 1E91 61 PUSH2 0x1e99 1E94 82 DUP3 1E95 61 PUSH2 0x0f4a 1E98 56 *JUMP 1E99 5B JUMPDEST 1E9A 60 PUSH1 0x01 1E9C 60 PUSH1 0x01 1E9E 60 PUSH1 0xa0 1EA0 1B SHL 1EA1 03 SUB 1EA2 16 AND 1EA3 14 EQ 1EA4 61 PUSH2 0x1ebf 1EA7 57 *JUMPI 1EA8 60 PUSH1 0x40 1EAA 51 MLOAD 1EAB 62 PUSH3 0x461bcd 1EAF 60 PUSH1 0xe5 1EB1 1B SHL 1EB2 81 DUP2 1EB3 52 MSTORE 1EB4 60 PUSH1 0x04 1EB6 01 ADD 1EB7 61 PUSH2 0x0626 1EBA 90 SWAP1 1EBB 61 PUSH2 0x36ee 1EBE 56 *JUMP 1EBF 5B JUMPDEST 1EC0 60 PUSH1 0x01 1EC2 60 PUSH1 0x01 1EC4 60 PUSH1 0xa0 1EC6 1B SHL 1EC7 03 SUB 1EC8 82 DUP3 1EC9 16 AND 1ECA 61 PUSH2 0x1ee5 1ECD 57 *JUMPI 1ECE 60 PUSH1 0x40 1ED0 51 MLOAD 1ED1 62 PUSH3 0x461bcd 1ED5 60 PUSH1 0xe5 1ED7 1B SHL 1ED8 81 DUP2 1ED9 52 MSTORE 1EDA 60 PUSH1 0x04 1EDC 01 ADD 1EDD 61 PUSH2 0x0626 1EE0 90 SWAP1 1EE1 61 PUSH2 0x32a0 1EE4 56 *JUMP 1EE5 5B JUMPDEST 1EE6 61 PUSH2 0x1ef0 1EE9 83 DUP4 1EEA 83 DUP4 1EEB 83 DUP4 1EEC 61 PUSH2 0x06de 1EEF 56 *JUMP 1EF0 5B JUMPDEST 1EF1 61 PUSH2 0x1efb 1EF4 60 PUSH1 0x00 1EF6 82 DUP3 1EF7 61 PUSH2 0x1878 1EFA 56 *JUMP 1EFB 5B JUMPDEST 1EFC 60 PUSH1 0x01 1EFE 60 PUSH1 0x01 1F00 60 PUSH1 0xa0 1F02 1B SHL 1F03 03 SUB 1F04 83 DUP4 1F05 16 AND 1F06 60 PUSH1 0x00 1F08 90 SWAP1 1F09 81 DUP2 1F0A 52 MSTORE 1F0B 60 PUSH1 0x01 1F0D 60 PUSH1 0x20 1F0F 52 MSTORE 1F10 60 PUSH1 0x40 1F12 90 SWAP1 1F13 20 SHA3 1F14 61 PUSH2 0x1f23 1F17 90 SWAP1 1F18 82 DUP3 1F19 63 PUSH4 0xffffffff 1F1E 61 PUSH2 0x231d 1F21 16 AND 1F22 56 *JUMP 1F23 5B JUMPDEST 1F24 50 POP 1F25 60 PUSH1 0x01 1F27 60 PUSH1 0x01 1F29 60 PUSH1 0xa0 1F2B 1B SHL 1F2C 03 SUB 1F2D 82 DUP3 1F2E 16 AND 1F2F 60 PUSH1 0x00 1F31 90 SWAP1 1F32 81 DUP2 1F33 52 MSTORE 1F34 60 PUSH1 0x01 1F36 60 PUSH1 0x20 1F38 52 MSTORE 1F39 60 PUSH1 0x40 1F3B 90 SWAP1 1F3C 20 SHA3 1F3D 61 PUSH2 0x1f4c 1F40 90 SWAP1 1F41 82 DUP3 1F42 63 PUSH4 0xffffffff 1F47 61 PUSH2 0x203b 1F4A 16 AND 1F4B 56 *JUMP 1F4C 5B JUMPDEST 1F4D 50 POP 1F4E 61 PUSH2 0x1f5f 1F51 60 PUSH1 0x02 1F53 82 DUP3 1F54 84 DUP5 1F55 63 PUSH4 0xffffffff 1F5A 61 PUSH2 0x2329 1F5D 16 AND 1F5E 56 *JUMP 1F5F 5B JUMPDEST 1F60 50 POP 1F61 80 DUP1 1F62 82 DUP3 1F63 60 PUSH1 0x01 1F65 60 PUSH1 0x01 1F67 60 PUSH1 0xa0 1F69 1B SHL 1F6A 03 SUB 1F6B 16 AND 1F6C 84 DUP5 1F6D 60 PUSH1 0x01 1F6F 60 PUSH1 0x01 1F71 60 PUSH1 0xa0 1F73 1B SHL 1F74 03 SUB 1F75 16 AND 1F76 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1F97 60 PUSH1 0x40 1F99 51 MLOAD 1F9A 60 PUSH1 0x40 1F9C 51 MLOAD 1F9D 80 DUP1 1F9E 91 SWAP2 1F9F 03 SUB 1FA0 90 SWAP1 1FA1 A4 LOG4 1FA2 50 POP 1FA3 50 POP 1FA4 50 POP 1FA5 56 *JUMP label_1FA6: // Incoming jump from 0x1BAF // Inputs[3] // { // @1FAA stack[-2] // @1FAB stack[-1] // @1FAE memory[0x40:0x60] // } 1FA6 5B JUMPDEST 1FA7 61 PUSH2 0x182e 1FAA 82 DUP3 1FAB 82 DUP3 1FAC 60 PUSH1 0x40 1FAE 51 MLOAD 1FAF 80 DUP1 1FB0 60 PUSH1 0x20 1FB2 01 ADD 1FB3 60 PUSH1 0x40 1FB5 52 MSTORE 1FB6 80 DUP1 1FB7 60 PUSH1 0x00 1FB9 81 DUP2 1FBA 52 MSTORE 1FBB 50 POP 1FBC 61 PUSH2 0x233f 1FBF 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1FA7 stack[0] = 0x182e // @1FAA stack[1] = stack[-2] // @1FAB stack[2] = stack[-1] // @1FAE stack[3] = memory[0x40:0x60] // @1FB5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1FBA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x233f 1FC0 5B JUMPDEST 1FC1 80 DUP1 1FC2 54 SLOAD 1FC3 60 PUSH1 0x01 1FC5 01 ADD 1FC6 90 SWAP1 1FC7 55 SSTORE 1FC8 56 *JUMP 1FC9 5B JUMPDEST 1FCA 81 DUP2 1FCB 61 PUSH2 0x1fd3 1FCE 81 DUP2 1FCF 61 PUSH2 0x1861 1FD2 56 *JUMP 1FD3 5B JUMPDEST 1FD4 61 PUSH2 0x1fef 1FD7 57 *JUMPI 1FD8 60 PUSH1 0x40 1FDA 51 MLOAD 1FDB 62 PUSH3 0x461bcd 1FDF 60 PUSH1 0xe5 1FE1 1B SHL 1FE2 81 DUP2 1FE3 52 MSTORE 1FE4 60 PUSH1 0x04 1FE6 01 ADD 1FE7 61 PUSH2 0x0626 1FEA 90 SWAP1 1FEB 61 PUSH2 0x3905 1FEE 56 *JUMP 1FEF 5B JUMPDEST 1FF0 50 POP 1FF1 60 PUSH1 0x00 1FF3 91 SWAP2 1FF4 82 DUP3 1FF5 52 MSTORE 1FF6 60 PUSH1 0x0f 1FF8 60 PUSH1 0x20 1FFA 52 MSTORE 1FFB 60 PUSH1 0x40 1FFD 90 SWAP1 1FFE 91 SWAP2 1FFF 20 SHA3 2000 55 SSTORE 2001 56 *JUMP 2002 5B JUMPDEST 2003 81 DUP2 2004 61 PUSH2 0x200c 2007 81 DUP2 2008 61 PUSH2 0x1861 200B 56 *JUMP 200C 5B JUMPDEST 200D 61 PUSH2 0x2028 2010 57 *JUMPI 2011 60 PUSH1 0x40 2013 51 MLOAD 2014 62 PUSH3 0x461bcd 2018 60 PUSH1 0xe5 201A 1B SHL 201B 81 DUP2 201C 52 MSTORE 201D 60 PUSH1 0x04 201F 01 ADD 2020 61 PUSH2 0x0626 2023 90 SWAP1 2024 61 PUSH2 0x3905 2027 56 *JUMP 2028 5B JUMPDEST 2029 50 POP 202A 60 PUSH1 0x00 202C 91 SWAP2 202D 82 DUP3 202E 52 MSTORE 202F 60 PUSH1 0x10 2031 60 PUSH1 0x20 2033 52 MSTORE 2034 60 PUSH1 0x40 2036 90 SWAP1 2037 91 SWAP2 2038 20 SHA3 2039 55 SSTORE 203A 56 *JUMP 203B 5B JUMPDEST 203C 60 PUSH1 0x00 203E 61 PUSH2 0x0c9e 2041 83 DUP4 2042 83 DUP4 2043 61 PUSH2 0x2372 2046 56 *JUMP label_2047: // Incoming call from 0x1CE2, returns to 0x0C9E // Inputs[3] // { // @2048 stack[-2] // @2049 storage[stack[-2]] // @204D stack[-1] // } 2047 5B JUMPDEST 2048 81 DUP2 2049 54 SLOAD 204A 60 PUSH1 0x00 204C 90 SWAP1 204D 82 DUP3 204E 10 LT 204F 61 PUSH2 0x206a 2052 57 *JUMPI // Stack delta = +1 // Outputs[1] { @204C stack[0] = 0x00 } // Block ends with conditional jump to 0x206a, if stack[-1] < storage[stack[-2]] label_2053: // Incoming jump from 0x2052, if not stack[-1] < storage[stack[-2]] // Inputs[1] { @2055 memory[0x40:0x60] } 2053 60 PUSH1 0x40 2055 51 MLOAD 2056 62 PUSH3 0x461bcd 205A 60 PUSH1 0xe5 205C 1B SHL 205D 81 DUP2 205E 52 MSTORE 205F 60 PUSH1 0x04 2061 01 ADD 2062 61 PUSH2 0x0626 2065 90 SWAP1 2066 61 PUSH2 0x30d3 2069 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @205E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2065 stack[0] = 0x0626 // @2065 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x30d3, returns to 0x0626 label_206A: // Incoming jump from 0x2052, if stack[-1] < storage[stack[-2]] // Inputs[3] // { // @206B stack[-3] // @206F stack[-2] // @2071 storage[0x00 + stack[-3]] // } 206A 5B JUMPDEST 206B 82 DUP3 206C 60 PUSH1 0x00 206E 01 ADD 206F 82 DUP3 2070 81 DUP2 2071 54 SLOAD 2072 81 DUP2 2073 10 LT 2074 61 PUSH2 0x2079 2077 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @206E stack[0] = 0x00 + stack[-3] // @206F stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2079, if stack[-2] < storage[0x00 + stack[-3]] label_2078: // Incoming jump from 0x2077, if not stack[-2] < storage[0x00 + stack[-3]] 2078 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2078 assert(); } // Block terminates label_2079: // Incoming jump from 0x2077, if stack[-2] < storage[0x00 + stack[-3]] // Inputs[7] // { // @207A stack[-2] // @207A stack[-1] // @2082 memory[0x00:0x20] // @2084 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2085 stack[-3] // @2087 stack[-6] // @2088 stack[-5] // } 2079 5B JUMPDEST 207A 90 SWAP1 207B 60 PUSH1 0x00 207D 52 MSTORE 207E 60 PUSH1 0x20 2080 60 PUSH1 0x00 2082 20 SHA3 2083 01 ADD 2084 54 SLOAD 2085 90 SWAP1 2086 50 POP 2087 92 SWAP3 2088 91 SWAP2 2089 50 POP 208A 50 POP 208B 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @207D memory[0x00:0x20] = stack[-2] // @2087 stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] 208C 5B JUMPDEST 208D 60 PUSH1 0x00 208F 61 PUSH2 0x2097 2092 82 DUP3 2093 61 PUSH2 0x0f4a 2096 56 *JUMP 2097 5B JUMPDEST 2098 90 SWAP1 2099 50 POP 209A 61 PUSH2 0x20a5 209D 81 DUP2 209E 60 PUSH1 0x00 20A0 84 DUP5 20A1 61 PUSH2 0x06de 20A4 56 *JUMP 20A5 5B JUMPDEST 20A6 61 PUSH2 0x20b0 20A9 60 PUSH1 0x00 20AB 83 DUP4 20AC 61 PUSH2 0x1878 20AF 56 *JUMP 20B0 5B JUMPDEST 20B1 60 PUSH1 0x00 20B3 82 DUP3 20B4 81 DUP2 20B5 52 MSTORE 20B6 60 PUSH1 0x08 20B8 60 PUSH1 0x20 20BA 52 MSTORE 20BB 60 PUSH1 0x40 20BD 90 SWAP1 20BE 20 SHA3 20BF 54 SLOAD 20C0 60 PUSH1 0x02 20C2 60 PUSH1 0x00 20C4 19 NOT 20C5 61 PUSH2 0x0100 20C8 60 PUSH1 0x01 20CA 84 DUP5 20CB 16 AND 20CC 15 ISZERO 20CD 02 MUL 20CE 01 ADD 20CF 90 SWAP1 20D0 91 SWAP2 20D1 16 AND 20D2 04 DIV 20D3 15 ISZERO 20D4 61 PUSH2 0x20ee 20D7 57 *JUMPI 20D8 60 PUSH1 0x00 20DA 82 DUP3 20DB 81 DUP2 20DC 52 MSTORE 20DD 60 PUSH1 0x08 20DF 60 PUSH1 0x20 20E1 52 MSTORE 20E2 60 PUSH1 0x40 20E4 81 DUP2 20E5 20 SHA3 20E6 61 PUSH2 0x20ee 20E9 91 SWAP2 20EA 61 PUSH2 0x2820 20ED 56 *JUMP 20EE 5B JUMPDEST 20EF 60 PUSH1 0x01 20F1 60 PUSH1 0x01 20F3 60 PUSH1 0xa0 20F5 1B SHL 20F6 03 SUB 20F7 81 DUP2 20F8 16 AND 20F9 60 PUSH1 0x00 20FB 90 SWAP1 20FC 81 DUP2 20FD 52 MSTORE 20FE 60 PUSH1 0x01 2100 60 PUSH1 0x20 2102 52 MSTORE 2103 60 PUSH1 0x40 2105 90 SWAP1 2106 20 SHA3 2107 61 PUSH2 0x2116 210A 90 SWAP1 210B 83 DUP4 210C 63 PUSH4 0xffffffff 2111 61 PUSH2 0x231d 2114 16 AND 2115 56 *JUMP 2116 5B JUMPDEST 2117 50 POP 2118 61 PUSH2 0x2128 211B 60 PUSH1 0x02 211D 83 DUP4 211E 63 PUSH4 0xffffffff 2123 61 PUSH2 0x23bc 2126 16 AND 2127 56 *JUMP 2128 5B JUMPDEST 2129 50 POP 212A 60 PUSH1 0x40 212C 51 MLOAD 212D 82 DUP3 212E 90 SWAP1 212F 60 PUSH1 0x00 2131 90 SWAP1 2132 60 PUSH1 0x01 2134 60 PUSH1 0x01 2136 60 PUSH1 0xa0 2138 1B SHL 2139 03 SUB 213A 84 DUP5 213B 16 AND 213C 90 SWAP1 213D 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 215E 90 SWAP1 215F 83 DUP4 2160 90 SWAP1 2161 A4 LOG4 2162 50 POP 2163 50 POP 2164 56 *JUMP label_2165: // Incoming call from 0x1DDD, returns to 0x1DDE // Inputs[3] // { // @2166 stack[-2] // @2167 storage[stack[-2]] // @216D stack[-1] // } 2165 5B JUMPDEST 2166 81 DUP2 2167 54 SLOAD 2168 60 PUSH1 0x00 216A 90 SWAP1 216B 81 DUP2 216C 90 SWAP1 216D 83 DUP4 216E 10 LT 216F 61 PUSH2 0x218a 2172 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @216A stack[0] = 0x00 // @216C stack[1] = 0x00 // } // Block ends with conditional jump to 0x218a, if stack[-1] < storage[stack[-2]] label_2173: // Incoming jump from 0x2172, if not stack[-1] < storage[stack[-2]] // Inputs[1] { @2175 memory[0x40:0x60] } 2173 60 PUSH1 0x40 2175 51 MLOAD 2176 62 PUSH3 0x461bcd 217A 60 PUSH1 0xe5 217C 1B SHL 217D 81 DUP2 217E 52 MSTORE 217F 60 PUSH1 0x04 2181 01 ADD 2182 61 PUSH2 0x0626 2185 90 SWAP1 2186 61 PUSH2 0x352d 2189 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @217E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2185 stack[0] = 0x0626 // @2185 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x352d, returns to 0x0626 label_218A: // Incoming jump from 0x2172, if stack[-1] < storage[stack[-2]] // Inputs[3] // { // @218D stack[-4] // @2191 stack[-3] // @2193 storage[0x00 + stack[-4]] // } 218A 5B JUMPDEST 218B 60 PUSH1 0x00 218D 84 DUP5 218E 60 PUSH1 0x00 2190 01 ADD 2191 84 DUP5 2192 81 DUP2 2193 54 SLOAD 2194 81 DUP2 2195 10 LT 2196 61 PUSH2 0x219b 2199 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @218B stack[0] = 0x00 // @2190 stack[1] = 0x00 + stack[-4] // @2191 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x219b, if stack[-3] < storage[0x00 + stack[-4]] label_219A: // Incoming jump from 0x2199, if not stack[-3] < storage[0x00 + stack[-4]] 219A FE *ASSERT // Stack delta = +0 // Outputs[1] { @219A assert(); } // Block terminates label_219B: // Incoming jump from 0x2199, if stack[-3] < storage[0x00 + stack[-4]] // Inputs[11] // { // @219C stack[-2] // @219C stack[-1] // @21A4 memory[0x00:0x20] // @21AA stack[-3] // @21B0 storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @21B5 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @21B6 stack[-4] // @21B8 stack[-5] // @21BB stack[-7] // @21BD stack[-8] // @21BE stack[-6] // } 219B 5B JUMPDEST 219C 90 SWAP1 219D 60 PUSH1 0x00 219F 52 MSTORE 21A0 60 PUSH1 0x20 21A2 60 PUSH1 0x00 21A4 20 SHA3 21A5 90 SWAP1 21A6 60 PUSH1 0x02 21A8 02 MUL 21A9 01 ADD 21AA 90 SWAP1 21AB 50 POP 21AC 80 DUP1 21AD 60 PUSH1 0x00 21AF 01 ADD 21B0 54 SLOAD 21B1 81 DUP2 21B2 60 PUSH1 0x01 21B4 01 ADD 21B5 54 SLOAD 21B6 92 SWAP3 21B7 50 POP 21B8 92 SWAP3 21B9 50 POP 21BA 50 POP 21BB 92 SWAP3 21BC 50 POP 21BD 92 SWAP3 21BE 90 SWAP1 21BF 50 POP 21C0 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @219F memory[0x00:0x20] = stack[-2] // @21BB stack[-7] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @21BD stack[-8] = storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-8] label_21C1: // Incoming call from 0x1DF7, returns to 0x1DF8 // Inputs[5] // { // @21C4 stack[-2] // @21C9 stack[-3] // @21D1 memory[0x00:0x40] // @21D2 storage[keccak256(memory[0x00:0x40])] // @21D3 stack[-1] // } 21C1 5B JUMPDEST 21C2 60 PUSH1 0x00 21C4 82 DUP3 21C5 81 DUP2 21C6 52 MSTORE 21C7 60 PUSH1 0x01 21C9 84 DUP5 21CA 01 ADD 21CB 60 PUSH1 0x20 21CD 52 MSTORE 21CE 60 PUSH1 0x40 21D0 81 DUP2 21D1 20 SHA3 21D2 54 SLOAD 21D3 82 DUP3 21D4 81 DUP2 21D5 61 PUSH2 0x21f1 21D8 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @21C2 stack[0] = 0x00 // @21C6 memory[0x00:0x20] = stack[-2] // @21CD memory[0x20:0x40] = stack[-3] + 0x01 // @21D2 stack[1] = storage[keccak256(memory[0x00:0x40])] // @21D3 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x21f1, if storage[keccak256(memory[0x00:0x40])] label_21D9: // Incoming jump from 0x21D8, if not storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @21DB memory[0x40:0x60] // @21EB stack[-1] // } 21D9 60 PUSH1 0x40 21DB 51 MLOAD 21DC 62 PUSH3 0x461bcd 21E0 60 PUSH1 0xe5 21E2 1B SHL 21E3 81 DUP2 21E4 52 MSTORE 21E5 60 PUSH1 0x04 21E7 01 ADD 21E8 61 PUSH2 0x0626 21EB 91 SWAP2 21EC 90 SWAP1 21ED 61 PUSH2 0x30c0 21F0 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @21E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @21EB stack[-1] = 0x0626 // @21EC stack[1] = 0x04 + memory[0x40:0x60] // @21EC stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x30c0 label_21F1: // Incoming jump from 0x21D8, if storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @21F3 stack[-6] // @21F9 stack[-2] // @21FC storage[0x00 + stack[-6]] // } 21F1 5B JUMPDEST 21F2 50 POP 21F3 84 DUP5 21F4 60 PUSH1 0x00 21F6 01 ADD 21F7 60 PUSH1 0x01 21F9 82 DUP3 21FA 03 SUB 21FB 81 DUP2 21FC 54 SLOAD 21FD 81 DUP2 21FE 10 LT 21FF 61 PUSH2 0x2204 2202 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @21F6 stack[-1] = 0x00 + stack[-6] // @21FA stack[0] = stack[-2] - 0x01 // } // Block ends with conditional jump to 0x2204, if stack[-2] - 0x01 < storage[0x00 + stack[-6]] label_2203: // Incoming jump from 0x2202, if not stack[-2] - 0x01 < storage[0x00 + stack[-6]] 2203 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2203 assert(); } // Block terminates label_2204: // Incoming jump from 0x2202, if stack[-2] - 0x01 < storage[0x00 + stack[-6]] // Inputs[7] // { // @2205 stack[-2] // @2205 stack[-1] // @220D memory[0x00:0x20] // @2216 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @2217 stack[-4] // @221A stack[-8] // @221B stack[-7] // } 2204 5B JUMPDEST 2205 90 SWAP1 2206 60 PUSH1 0x00 2208 52 MSTORE 2209 60 PUSH1 0x20 220B 60 PUSH1 0x00 220D 20 SHA3 220E 90 SWAP1 220F 60 PUSH1 0x02 2211 02 MUL 2212 01 ADD 2213 60 PUSH1 0x01 2215 01 ADD 2216 54 SLOAD 2217 91 SWAP2 2218 50 POP 2219 50 POP 221A 93 SWAP4 221B 92 SWAP3 221C 50 POP 221D 50 POP 221E 50 POP 221F 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @2208 memory[0x00:0x20] = stack[-2] // @221A stack[-8] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-8] 2220 5B JUMPDEST 2221 60 PUSH1 0x00 2223 61 PUSH2 0x2234 2226 84 DUP5 2227 60 PUSH1 0x01 2229 60 PUSH1 0x01 222B 60 PUSH1 0xa0 222D 1B SHL 222E 03 SUB 222F 16 AND 2230 61 PUSH2 0x23c8 2233 56 *JUMP 2234 5B JUMPDEST 2235 61 PUSH2 0x2240 2238 57 *JUMPI 2239 50 POP 223A 60 PUSH1 0x01 223C 61 PUSH2 0x1a28 223F 56 *JUMP 2240 5B JUMPDEST 2241 60 PUSH1 0x60 2243 61 PUSH2 0x22ce 2246 63 PUSH4 0x0a85bd01 224B 60 PUSH1 0xe1 224D 1B SHL 224E 61 PUSH2 0x2255 2251 61 PUSH2 0x1874 2254 56 *JUMP 2255 5B JUMPDEST 2256 88 DUP9 2257 87 DUP8 2258 87 DUP8 2259 60 PUSH1 0x40 225B 51 MLOAD 225C 60 PUSH1 0x24 225E 01 ADD 225F 61 PUSH2 0x226b 2262 94 SWAP5 2263 93 SWAP4 2264 92 SWAP3 2265 91 SWAP2 2266 90 SWAP1 2267 61 PUSH2 0x2f91 226A 56 *JUMP 226B 5B JUMPDEST 226C 60 PUSH1 0x40 226E 51 MLOAD 226F 60 PUSH1 0x20 2271 81 DUP2 2272 83 DUP4 2273 03 SUB 2274 03 SUB 2275 81 DUP2 2276 52 MSTORE 2277 90 SWAP1 2278 60 PUSH1 0x40 227A 52 MSTORE 227B 90 SWAP1 227C 60 PUSH1 0x01 227E 60 PUSH1 0x01 2280 60 PUSH1 0xe0 2282 1B SHL 2283 03 SUB 2284 19 NOT 2285 16 AND 2286 60 PUSH1 0x20 2288 82 DUP3 2289 01 ADD 228A 80 DUP1 228B 51 MLOAD 228C 60 PUSH1 0x01 228E 60 PUSH1 0x01 2290 60 PUSH1 0xe0 2292 1B SHL 2293 03 SUB 2294 83 DUP4 2295 81 DUP2 2296 83 DUP4 2297 16 AND 2298 17 OR 2299 83 DUP4 229A 52 MSTORE 229B 50 POP 229C 50 POP 229D 50 POP 229E 50 POP 229F 60 PUSH1 0x40 22A1 51 MLOAD 22A2 80 DUP1 22A3 60 PUSH1 0x60 22A5 01 ADD 22A6 60 PUSH1 0x40 22A8 52 MSTORE 22A9 80 DUP1 22AA 60 PUSH1 0x32 22AC 81 DUP2 22AD 52 MSTORE 22AE 60 PUSH1 0x20 22B0 01 ADD 22B1 61 PUSH2 0x3ade 22B4 60 PUSH1 0x32 22B6 91 SWAP2 22B7 39 CODECOPY 22B8 60 PUSH1 0x01 22BA 60 PUSH1 0x01 22BC 60 PUSH1 0xa0 22BE 1B SHL 22BF 03 SUB 22C0 88 DUP9 22C1 16 AND 22C2 91 SWAP2 22C3 90 SWAP1 22C4 63 PUSH4 0xffffffff 22C9 61 PUSH2 0x23ce 22CC 16 AND 22CD 56 *JUMP 22CE 5B JUMPDEST 22CF 90 SWAP1 22D0 50 POP 22D1 60 PUSH1 0x00 22D3 81 DUP2 22D4 80 DUP1 22D5 60 PUSH1 0x20 22D7 01 ADD 22D8 90 SWAP1 22D9 51 MLOAD 22DA 81 DUP2 22DB 01 ADD 22DC 90 SWAP1 22DD 61 PUSH2 0x22e6 22E0 91 SWAP2 22E1 90 SWAP1 22E2 61 PUSH2 0x2c7a 22E5 56 *JUMP 22E6 5B JUMPDEST 22E7 60 PUSH1 0x01 22E9 60 PUSH1 0x01 22EB 60 PUSH1 0xe0 22ED 1B SHL 22EE 03 SUB 22EF 19 NOT 22F0 16 AND 22F1 63 PUSH4 0x0a85bd01 22F6 60 PUSH1 0xe1 22F8 1B SHL 22F9 14 EQ 22FA 92 SWAP3 22FB 50 POP 22FC 50 POP 22FD 50 POP 22FE 94 SWAP5 22FF 93 SWAP4 2300 50 POP 2301 50 POP 2302 50 POP 2303 50 POP 2304 56 *JUMP label_2305: // Incoming call from 0x1E85, returns to 0x0C9E // Inputs[5] // { // @2308 stack[-1] // @230D stack[-2] // @2317 memory[0x00:0x40] // @2318 storage[keccak256(memory[0x00:0x40])] // @231B stack[-3] // } 2305 5B JUMPDEST 2306 60 PUSH1 0x00 2308 90 SWAP1 2309 81 DUP2 230A 52 MSTORE 230B 60 PUSH1 0x01 230D 91 SWAP2 230E 90 SWAP1 230F 91 SWAP2 2310 01 ADD 2311 60 PUSH1 0x20 2313 52 MSTORE 2314 60 PUSH1 0x40 2316 90 SWAP1 2317 20 SHA3 2318 54 SLOAD 2319 15 ISZERO 231A 15 ISZERO 231B 90 SWAP1 231C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @230A memory[0x00:0x20] = stack[-1] // @2313 memory[0x20:0x40] = 0x01 + stack[-2] // @231B stack[-3] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 231D 5B JUMPDEST 231E 60 PUSH1 0x00 2320 61 PUSH2 0x0c9e 2323 83 DUP4 2324 83 DUP4 2325 61 PUSH2 0x23dd 2328 56 *JUMP 2329 5B JUMPDEST 232A 60 PUSH1 0x00 232C 61 PUSH2 0x1df8 232F 84 DUP5 2330 84 DUP5 2331 60 PUSH1 0x01 2333 60 PUSH1 0x01 2335 60 PUSH1 0xa0 2337 1B SHL 2338 03 SUB 2339 85 DUP6 233A 16 AND 233B 61 PUSH2 0x24a3 233E 56 *JUMP label_233F: // Incoming jump from 0x1FBF // Inputs[2] // { // @2343 stack[-3] // @2344 stack[-2] // } 233F 5B JUMPDEST 2340 61 PUSH2 0x2349 2343 83 DUP4 2344 83 DUP4 2345 61 PUSH2 0x253a 2348 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2340 stack[0] = 0x2349 // @2343 stack[1] = stack[-3] // @2344 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x253a 2349 5B JUMPDEST 234A 61 PUSH2 0x2356 234D 60 PUSH1 0x00 234F 84 DUP5 2350 84 DUP5 2351 84 DUP5 2352 61 PUSH2 0x2220 2355 56 *JUMP 2356 5B JUMPDEST 2357 61 PUSH2 0x06de 235A 57 *JUMPI 235B 60 PUSH1 0x40 235D 51 MLOAD 235E 62 PUSH3 0x461bcd 2362 60 PUSH1 0xe5 2364 1B SHL 2365 81 DUP2 2366 52 MSTORE 2367 60 PUSH1 0x04 2369 01 ADD 236A 61 PUSH2 0x0626 236D 90 SWAP1 236E 61 PUSH2 0x315d 2371 56 *JUMP 2372 5B JUMPDEST 2373 60 PUSH1 0x00 2375 61 PUSH2 0x237e 2378 83 DUP4 2379 83 DUP4 237A 61 PUSH2 0x2305 237D 56 *JUMP 237E 5B JUMPDEST 237F 61 PUSH2 0x23b4 2382 57 *JUMPI 2383 50 POP 2384 81 DUP2 2385 54 SLOAD 2386 60 PUSH1 0x01 2388 81 DUP2 2389 81 DUP2 238A 01 ADD 238B 84 DUP5 238C 55 SSTORE 238D 60 PUSH1 0x00 238F 84 DUP5 2390 81 DUP2 2391 52 MSTORE 2392 60 PUSH1 0x20 2394 80 DUP1 2395 82 DUP3 2396 20 SHA3 2397 90 SWAP1 2398 93 SWAP4 2399 01 ADD 239A 84 DUP5 239B 90 SWAP1 239C 55 SSTORE 239D 84 DUP5 239E 54 SLOAD 239F 84 DUP5 23A0 82 DUP3 23A1 52 MSTORE 23A2 82 DUP3 23A3 86 DUP7 23A4 01 ADD 23A5 90 SWAP1 23A6 93 SWAP4 23A7 52 MSTORE 23A8 60 PUSH1 0x40 23AA 90 SWAP1 23AB 20 SHA3 23AC 91 SWAP2 23AD 90 SWAP1 23AE 91 SWAP2 23AF 55 SSTORE 23B0 61 PUSH2 0x0ca1 23B3 56 *JUMP 23B4 5B JUMPDEST 23B5 50 POP 23B6 60 PUSH1 0x00 23B8 61 PUSH2 0x0ca1 23BB 56 *JUMP 23BC 5B JUMPDEST 23BD 60 PUSH1 0x00 23BF 61 PUSH2 0x0c9e 23C2 83 DUP4 23C3 83 DUP4 23C4 61 PUSH2 0x260a 23C7 56 *JUMP 23C8 5B JUMPDEST 23C9 3B EXTCODESIZE 23CA 15 ISZERO 23CB 15 ISZERO 23CC 90 SWAP1 23CD 56 *JUMP 23CE 5B JUMPDEST 23CF 60 PUSH1 0x60 23D1 61 PUSH2 0x1df8 23D4 84 DUP5 23D5 84 DUP5 23D6 60 PUSH1 0x00 23D8 85 DUP6 23D9 61 PUSH2 0x26de 23DC 56 *JUMP 23DD 5B JUMPDEST 23DE 60 PUSH1 0x00 23E0 81 DUP2 23E1 81 DUP2 23E2 52 MSTORE 23E3 60 PUSH1 0x01 23E5 83 DUP4 23E6 01 ADD 23E7 60 PUSH1 0x20 23E9 52 MSTORE 23EA 60 PUSH1 0x40 23EC 81 DUP2 23ED 20 SHA3 23EE 54 SLOAD 23EF 80 DUP1 23F0 15 ISZERO 23F1 61 PUSH2 0x2499 23F4 57 *JUMPI 23F5 83 DUP4 23F6 54 SLOAD 23F7 60 PUSH1 0x00 23F9 19 NOT 23FA 80 DUP1 23FB 83 DUP4 23FC 01 ADD 23FD 91 SWAP2 23FE 90 SWAP1 23FF 81 DUP2 2400 01 ADD 2401 90 SWAP1 2402 60 PUSH1 0x00 2404 90 SWAP1 2405 87 DUP8 2406 90 SWAP1 2407 83 DUP4 2408 90 SWAP1 2409 81 DUP2 240A 10 LT 240B 61 PUSH2 0x2410 240E 57 *JUMPI 240F FE *ASSERT 2410 5B JUMPDEST 2411 90 SWAP1 2412 60 PUSH1 0x00 2414 52 MSTORE 2415 60 PUSH1 0x20 2417 60 PUSH1 0x00 2419 20 SHA3 241A 01 ADD 241B 54 SLOAD 241C 90 SWAP1 241D 50 POP 241E 80 DUP1 241F 87 DUP8 2420 60 PUSH1 0x00 2422 01 ADD 2423 84 DUP5 2424 81 DUP2 2425 54 SLOAD 2426 81 DUP2 2427 10 LT 2428 61 PUSH2 0x242d 242B 57 *JUMPI 242C FE *ASSERT 242D 5B JUMPDEST 242E 60 PUSH1 0x00 2430 91 SWAP2 2431 82 DUP3 2432 52 MSTORE 2433 60 PUSH1 0x20 2435 80 DUP1 2436 83 DUP4 2437 20 SHA3 2438 90 SWAP1 2439 91 SWAP2 243A 01 ADD 243B 92 SWAP3 243C 90 SWAP1 243D 92 SWAP3 243E 55 SSTORE 243F 82 DUP3 2440 81 DUP2 2441 52 MSTORE 2442 60 PUSH1 0x01 2444 89 DUP10 2445 81 DUP2 2446 01 ADD 2447 90 SWAP1 2448 92 SWAP3 2449 52 MSTORE 244A 60 PUSH1 0x40 244C 90 SWAP1 244D 20 SHA3 244E 90 SWAP1 244F 84 DUP5 2450 01 ADD 2451 90 SWAP1 2452 55 SSTORE 2453 86 DUP7 2454 54 SLOAD 2455 87 DUP8 2456 90 SWAP1 2457 80 DUP1 2458 61 PUSH2 0x245d 245B 57 *JUMPI 245C FE *ASSERT 245D 5B JUMPDEST 245E 60 PUSH1 0x01 2460 90 SWAP1 2461 03 SUB 2462 81 DUP2 2463 81 DUP2 2464 90 SWAP1 2465 60 PUSH1 0x00 2467 52 MSTORE 2468 60 PUSH1 0x20 246A 60 PUSH1 0x00 246C 20 SHA3 246D 01 ADD 246E 60 PUSH1 0x00 2470 90 SWAP1 2471 55 SSTORE 2472 90 SWAP1 2473 55 SSTORE 2474 86 DUP7 2475 60 PUSH1 0x01 2477 01 ADD 2478 60 PUSH1 0x00 247A 87 DUP8 247B 81 DUP2 247C 52 MSTORE 247D 60 PUSH1 0x20 247F 01 ADD 2480 90 SWAP1 2481 81 DUP2 2482 52 MSTORE 2483 60 PUSH1 0x20 2485 01 ADD 2486 60 PUSH1 0x00 2488 20 SHA3 2489 60 PUSH1 0x00 248B 90 SWAP1 248C 55 SSTORE 248D 60 PUSH1 0x01 248F 94 SWAP5 2490 50 POP 2491 50 POP 2492 50 POP 2493 50 POP 2494 50 POP 2495 61 PUSH2 0x0ca1 2498 56 *JUMP 2499 5B JUMPDEST 249A 60 PUSH1 0x00 249C 91 SWAP2 249D 50 POP 249E 50 POP 249F 61 PUSH2 0x0ca1 24A2 56 *JUMP 24A3 5B JUMPDEST 24A4 60 PUSH1 0x00 24A6 82 DUP3 24A7 81 DUP2 24A8 52 MSTORE 24A9 60 PUSH1 0x01 24AB 84 DUP5 24AC 01 ADD 24AD 60 PUSH1 0x20 24AF 52 MSTORE 24B0 60 PUSH1 0x40 24B2 81 DUP2 24B3 20 SHA3 24B4 54 SLOAD 24B5 80 DUP1 24B6 61 PUSH2 0x2508 24B9 57 *JUMPI 24BA 50 POP 24BB 50 POP 24BC 60 PUSH1 0x40 24BE 80 DUP1 24BF 51 MLOAD 24C0 80 DUP1 24C1 82 DUP3 24C2 01 ADD 24C3 82 DUP3 24C4 52 MSTORE 24C5 83 DUP4 24C6 81 DUP2 24C7 52 MSTORE 24C8 60 PUSH1 0x20 24CA 80 DUP1 24CB 82 DUP3 24CC 01 ADD 24CD 84 DUP5 24CE 81 DUP2 24CF 52 MSTORE 24D0 86 DUP7 24D1 54 SLOAD 24D2 60 PUSH1 0x01 24D4 81 DUP2 24D5 81 DUP2 24D6 01 ADD 24D7 89 DUP10 24D8 55 SSTORE 24D9 60 PUSH1 0x00 24DB 89 DUP10 24DC 81 DUP2 24DD 52 MSTORE 24DE 84 DUP5 24DF 81 DUP2 24E0 20 SHA3 24E1 95 SWAP6 24E2 51 MLOAD 24E3 60 PUSH1 0x02 24E5 90 SWAP1 24E6 93 SWAP4 24E7 02 MUL 24E8 90 SWAP1 24E9 95 SWAP6 24EA 01 ADD 24EB 91 SWAP2 24EC 82 DUP3 24ED 55 SSTORE 24EE 91 SWAP2 24EF 51 MLOAD 24F0 90 SWAP1 24F1 82 DUP3 24F2 01 ADD 24F3 55 SSTORE 24F4 86 DUP7 24F5 54 SLOAD 24F6 86 DUP7 24F7 84 DUP5 24F8 52 MSTORE 24F9 81 DUP2 24FA 88 DUP9 24FB 01 ADD 24FC 90 SWAP1 24FD 92 SWAP3 24FE 52 MSTORE 24FF 92 SWAP3 2500 90 SWAP1 2501 91 SWAP2 2502 20 SHA3 2503 55 SSTORE 2504 61 PUSH2 0x1dfb 2507 56 *JUMP 2508 5B JUMPDEST 2509 82 DUP3 250A 85 DUP6 250B 60 PUSH1 0x00 250D 01 ADD 250E 60 PUSH1 0x01 2510 83 DUP4 2511 03 SUB 2512 81 DUP2 2513 54 SLOAD 2514 81 DUP2 2515 10 LT 2516 61 PUSH2 0x251b 2519 57 *JUMPI 251A FE *ASSERT 251B 5B JUMPDEST 251C 90 SWAP1 251D 60 PUSH1 0x00 251F 52 MSTORE 2520 60 PUSH1 0x20 2522 60 PUSH1 0x00 2524 20 SHA3 2525 90 SWAP1 2526 60 PUSH1 0x02 2528 02 MUL 2529 01 ADD 252A 60 PUSH1 0x01 252C 01 ADD 252D 81 DUP2 252E 90 SWAP1 252F 55 SSTORE 2530 50 POP 2531 60 PUSH1 0x00 2533 91 SWAP2 2534 50 POP 2535 50 POP 2536 61 PUSH2 0x1dfb 2539 56 *JUMP label_253A: // Incoming jump from 0x2348 // Inputs[1] { @2543 stack[-2] } 253A 5B JUMPDEST 253B 60 PUSH1 0x01 253D 60 PUSH1 0x01 253F 60 PUSH1 0xa0 2541 1B SHL 2542 03 SUB 2543 82 DUP3 2544 16 AND 2545 61 PUSH2 0x2560 2548 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2560, if stack[-2] & (0x01 << 0xa0) - 0x01 label_2549: // Incoming jump from 0x2548, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @254B memory[0x40:0x60] } 2549 60 PUSH1 0x40 254B 51 MLOAD 254C 62 PUSH3 0x461bcd 2550 60 PUSH1 0xe5 2552 1B SHL 2553 81 DUP2 2554 52 MSTORE 2555 60 PUSH1 0x04 2557 01 ADD 2558 61 PUSH2 0x0626 255B 90 SWAP1 255C 61 PUSH2 0x35a6 255F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2554 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @255B stack[0] = 0x0626 // @255B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x35a6, returns to 0x0626 label_2560: // Incoming jump from 0x2548, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2564 stack[-1] } 2560 5B JUMPDEST 2561 61 PUSH2 0x2569 2564 81 DUP2 2565 61 PUSH2 0x1861 2568 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2561 stack[0] = 0x2569 // @2564 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1861 2569 5B JUMPDEST 256A 15 ISZERO 256B 61 PUSH2 0x2586 256E 57 *JUMPI 256F 60 PUSH1 0x40 2571 51 MLOAD 2572 62 PUSH3 0x461bcd 2576 60 PUSH1 0xe5 2578 1B SHL 2579 81 DUP2 257A 52 MSTORE 257B 60 PUSH1 0x04 257D 01 ADD 257E 61 PUSH2 0x0626 2581 90 SWAP1 2582 61 PUSH2 0x31e6 2585 56 *JUMP 2586 5B JUMPDEST 2587 61 PUSH2 0x2592 258A 60 PUSH1 0x00 258C 83 DUP4 258D 83 DUP4 258E 61 PUSH2 0x06de 2591 56 *JUMP 2592 5B JUMPDEST 2593 60 PUSH1 0x01 2595 60 PUSH1 0x01 2597 60 PUSH1 0xa0 2599 1B SHL 259A 03 SUB 259B 82 DUP3 259C 16 AND 259D 60 PUSH1 0x00 259F 90 SWAP1 25A0 81 DUP2 25A1 52 MSTORE 25A2 60 PUSH1 0x01 25A4 60 PUSH1 0x20 25A6 52 MSTORE 25A7 60 PUSH1 0x40 25A9 90 SWAP1 25AA 20 SHA3 25AB 61 PUSH2 0x25ba 25AE 90 SWAP1 25AF 82 DUP3 25B0 63 PUSH4 0xffffffff 25B5 61 PUSH2 0x203b 25B8 16 AND 25B9 56 *JUMP 25BA 5B JUMPDEST 25BB 50 POP 25BC 61 PUSH2 0x25cd 25BF 60 PUSH1 0x02 25C1 82 DUP3 25C2 84 DUP5 25C3 63 PUSH4 0xffffffff 25C8 61 PUSH2 0x2329 25CB 16 AND 25CC 56 *JUMP 25CD 5B JUMPDEST 25CE 50 POP 25CF 60 PUSH1 0x40 25D1 51 MLOAD 25D2 81 DUP2 25D3 90 SWAP1 25D4 60 PUSH1 0x01 25D6 60 PUSH1 0x01 25D8 60 PUSH1 0xa0 25DA 1B SHL 25DB 03 SUB 25DC 84 DUP5 25DD 16 AND 25DE 90 SWAP1 25DF 60 PUSH1 0x00 25E1 90 SWAP1 25E2 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2603 90 SWAP1 2604 82 DUP3 2605 90 SWAP1 2606 A4 LOG4 2607 50 POP 2608 50 POP 2609 56 *JUMP 260A 5B JUMPDEST 260B 60 PUSH1 0x00 260D 81 DUP2 260E 81 DUP2 260F 52 MSTORE 2610 60 PUSH1 0x01 2612 83 DUP4 2613 01 ADD 2614 60 PUSH1 0x20 2616 52 MSTORE 2617 60 PUSH1 0x40 2619 81 DUP2 261A 20 SHA3 261B 54 SLOAD 261C 80 DUP1 261D 15 ISZERO 261E 61 PUSH2 0x2499 2621 57 *JUMPI 2622 83 DUP4 2623 54 SLOAD 2624 60 PUSH1 0x00 2626 19 NOT 2627 80 DUP1 2628 83 DUP4 2629 01 ADD 262A 91 SWAP2 262B 90 SWAP1 262C 81 DUP2 262D 01 ADD 262E 90 SWAP1 262F 60 PUSH1 0x00 2631 90 SWAP1 2632 87 DUP8 2633 90 SWAP1 2634 83 DUP4 2635 90 SWAP1 2636 81 DUP2 2637 10 LT 2638 61 PUSH2 0x263d 263B 57 *JUMPI 263C FE *ASSERT 263D 5B JUMPDEST 263E 90 SWAP1 263F 60 PUSH1 0x00 2641 52 MSTORE 2642 60 PUSH1 0x20 2644 60 PUSH1 0x00 2646 20 SHA3 2647 90 SWAP1 2648 60 PUSH1 0x02 264A 02 MUL 264B 01 ADD 264C 90 SWAP1 264D 50 POP 264E 80 DUP1 264F 87 DUP8 2650 60 PUSH1 0x00 2652 01 ADD 2653 84 DUP5 2654 81 DUP2 2655 54 SLOAD 2656 81 DUP2 2657 10 LT 2658 61 PUSH2 0x265d 265B 57 *JUMPI 265C FE *ASSERT 265D 5B JUMPDEST 265E 60 PUSH1 0x00 2660 91 SWAP2 2661 82 DUP3 2662 52 MSTORE 2663 60 PUSH1 0x20 2665 80 DUP1 2666 83 DUP4 2667 20 SHA3 2668 84 DUP5 2669 54 SLOAD 266A 60 PUSH1 0x02 266C 90 SWAP1 266D 93 SWAP4 266E 02 MUL 266F 01 ADD 2670 91 SWAP2 2671 82 DUP3 2672 55 SSTORE 2673 60 PUSH1 0x01 2675 93 SWAP4 2676 84 DUP5 2677 01 ADD 2678 54 SLOAD 2679 91 SWAP2 267A 84 DUP5 267B 01 ADD 267C 91 SWAP2 267D 90 SWAP1 267E 91 SWAP2 267F 55 SSTORE 2680 83 DUP4 2681 54 SLOAD 2682 82 DUP3 2683 52 MSTORE 2684 89 DUP10 2685 83 DUP4 2686 01 ADD 2687 90 SWAP1 2688 52 MSTORE 2689 60 PUSH1 0x40 268B 90 SWAP1 268C 20 SHA3 268D 90 SWAP1 268E 84 DUP5 268F 01 ADD 2690 90 SWAP1 2691 55 SSTORE 2692 86 DUP7 2693 54 SLOAD 2694 87 DUP8 2695 90 SWAP1 2696 80 DUP1 2697 61 PUSH2 0x269c 269A 57 *JUMPI 269B FE *ASSERT 269C 5B JUMPDEST 269D 60 PUSH1 0x00 269F 82 DUP3 26A0 81 DUP2 26A1 52 MSTORE 26A2 60 PUSH1 0x20 26A4 80 DUP1 26A5 82 DUP3 26A6 20 SHA3 26A7 60 PUSH1 0x02 26A9 60 PUSH1 0x00 26AB 19 NOT 26AC 90 SWAP1 26AD 94 SWAP5 26AE 01 ADD 26AF 93 SWAP4 26B0 84 DUP5 26B1 02 MUL 26B2 01 ADD 26B3 82 DUP3 26B4 81 DUP2 26B5 55 SSTORE 26B6 60 PUSH1 0x01 26B8 90 SWAP1 26B9 81 DUP2 26BA 01 ADD 26BB 83 DUP4 26BC 90 SWAP1 26BD 55 SSTORE 26BE 92 SWAP3 26BF 90 SWAP1 26C0 93 SWAP4 26C1 55 SSTORE 26C2 88 DUP9 26C3 81 DUP2 26C4 52 MSTORE 26C5 89 DUP10 26C6 82 DUP3 26C7 01 ADD 26C8 90 SWAP1 26C9 92 SWAP3 26CA 52 MSTORE 26CB 60 PUSH1 0x40 26CD 82 DUP3 26CE 20 SHA3 26CF 91 SWAP2 26D0 90 SWAP1 26D1 91 SWAP2 26D2 55 SSTORE 26D3 94 SWAP5 26D4 50 POP 26D5 61 PUSH2 0x0ca1 26D8 93 SWAP4 26D9 50 POP 26DA 50 POP 26DB 50 POP 26DC 50 POP 26DD 56 *JUMP 26DE 5B JUMPDEST 26DF 60 PUSH1 0x60 26E1 61 PUSH2 0x26e9 26E4 85 DUP6 26E5 61 PUSH2 0x23c8 26E8 56 *JUMP 26E9 5B JUMPDEST 26EA 61 PUSH2 0x2705 26ED 57 *JUMPI 26EE 60 PUSH1 0x40 26F0 51 MLOAD 26F1 62 PUSH3 0x461bcd 26F5 60 PUSH1 0xe5 26F7 1B SHL 26F8 81 DUP2 26F9 52 MSTORE 26FA 60 PUSH1 0x04 26FC 01 ADD 26FD 61 PUSH2 0x0626 2700 90 SWAP1 2701 61 PUSH2 0x3897 2704 56 *JUMP 2705 5B JUMPDEST 2706 60 PUSH1 0x00 2708 60 PUSH1 0x60 270A 86 DUP7 270B 60 PUSH1 0x01 270D 60 PUSH1 0x01 270F 60 PUSH1 0xa0 2711 1B SHL 2712 03 SUB 2713 16 AND 2714 85 DUP6 2715 87 DUP8 2716 60 PUSH1 0x40 2718 51 MLOAD 2719 61 PUSH2 0x2722 271C 91 SWAP2 271D 90 SWAP1 271E 61 PUSH2 0x2edc 2721 56 *JUMP 2722 5B JUMPDEST 2723 60 PUSH1 0x00 2725 60 PUSH1 0x40 2727 51 MLOAD 2728 80 DUP1 2729 83 DUP4 272A 03 SUB 272B 81 DUP2 272C 85 DUP6 272D 87 DUP8 272E 5A GAS 272F F1 CALL 2730 92 SWAP3 2731 50 POP 2732 50 POP 2733 50 POP 2734 3D RETURNDATASIZE 2735 80 DUP1 2736 60 PUSH1 0x00 2738 81 DUP2 2739 14 EQ 273A 61 PUSH2 0x275f 273D 57 *JUMPI 273E 60 PUSH1 0x40 2740 51 MLOAD 2741 91 SWAP2 2742 50 POP 2743 60 PUSH1 0x1f 2745 19 NOT 2746 60 PUSH1 0x3f 2748 3D RETURNDATASIZE 2749 01 ADD 274A 16 AND 274B 82 DUP3 274C 01 ADD 274D 60 PUSH1 0x40 274F 52 MSTORE 2750 3D RETURNDATASIZE 2751 82 DUP3 2752 52 MSTORE 2753 3D RETURNDATASIZE 2754 60 PUSH1 0x00 2756 60 PUSH1 0x20 2758 84 DUP5 2759 01 ADD 275A 3E RETURNDATACOPY 275B 61 PUSH2 0x2764 275E 56 *JUMP 275F 5B JUMPDEST 2760 60 PUSH1 0x60 2762 91 SWAP2 2763 50 POP 2764 5B JUMPDEST 2765 50 POP 2766 91 SWAP2 2767 50 POP 2768 91 SWAP2 2769 50 POP 276A 81 DUP2 276B 15 ISZERO 276C 61 PUSH2 0x2778 276F 57 *JUMPI 2770 91 SWAP2 2771 50 POP 2772 61 PUSH2 0x1a28 2775 90 SWAP1 2776 50 POP 2777 56 *JUMP 2778 5B JUMPDEST 2779 80 DUP1 277A 51 MLOAD 277B 15 ISZERO 277C 61 PUSH2 0x2788 277F 57 *JUMPI 2780 80 DUP1 2781 51 MLOAD 2782 80 DUP1 2783 82 DUP3 2784 60 PUSH1 0x20 2786 01 ADD 2787 FD *REVERT 2788 5B JUMPDEST 2789 83 DUP4 278A 60 PUSH1 0x40 278C 51 MLOAD 278D 62 PUSH3 0x461bcd 2791 60 PUSH1 0xe5 2793 1B SHL 2794 81 DUP2 2795 52 MSTORE 2796 60 PUSH1 0x04 2798 01 ADD 2799 61 PUSH2 0x0626 279C 91 SWAP2 279D 90 SWAP1 279E 61 PUSH2 0x30c0 27A1 56 *JUMP 27A2 5B JUMPDEST 27A3 82 DUP3 27A4 80 DUP1 27A5 54 SLOAD 27A6 60 PUSH1 0x01 27A8 81 DUP2 27A9 60 PUSH1 0x01 27AB 16 AND 27AC 15 ISZERO 27AD 61 PUSH2 0x0100 27B0 02 MUL 27B1 03 SUB 27B2 16 AND 27B3 60 PUSH1 0x02 27B5 90 SWAP1 27B6 04 DIV 27B7 90 SWAP1 27B8 60 PUSH1 0x00 27BA 52 MSTORE 27BB 60 PUSH1 0x20 27BD 60 PUSH1 0x00 27BF 20 SHA3 27C0 90 SWAP1 27C1 60 PUSH1 0x1f 27C3 01 ADD 27C4 60 PUSH1 0x20 27C6 90 SWAP1 27C7 04 DIV 27C8 81 DUP2 27C9 01 ADD 27CA 92 SWAP3 27CB 82 DUP3 27CC 60 PUSH1 0x1f 27CE 10 LT 27CF 61 PUSH2 0x27e3 27D2 57 *JUMPI 27D3 80 DUP1 27D4 51 MLOAD 27D5 60 PUSH1 0xff 27D7 19 NOT 27D8 16 AND 27D9 83 DUP4 27DA 80 DUP1 27DB 01 ADD 27DC 17 OR 27DD 85 DUP6 27DE 55 SSTORE 27DF 61 PUSH2 0x2810 27E2 56 *JUMP 27E3 5B JUMPDEST 27E4 82 DUP3 27E5 80 DUP1 27E6 01 ADD 27E7 60 PUSH1 0x01 27E9 01 ADD 27EA 85 DUP6 27EB 55 SSTORE 27EC 82 DUP3 27ED 15 ISZERO 27EE 61 PUSH2 0x2810 27F1 57 *JUMPI 27F2 91 SWAP2 27F3 82 DUP3 27F4 01 ADD 27F5 5B JUMPDEST 27F6 82 DUP3 27F7 81 DUP2 27F8 11 GT 27F9 15 ISZERO 27FA 61 PUSH2 0x2810 27FD 57 *JUMPI 27FE 82 DUP3 27FF 51 MLOAD 2800 82 DUP3 2801 55 SSTORE 2802 91 SWAP2 2803 60 PUSH1 0x20 2805 01 ADD 2806 91 SWAP2 2807 90 SWAP1 2808 60 PUSH1 0x01 280A 01 ADD 280B 90 SWAP1 280C 61 PUSH2 0x27f5 280F 56 *JUMP 2810 5B JUMPDEST 2811 50 POP 2812 61 PUSH2 0x281c 2815 92 SWAP3 2816 91 SWAP2 2817 50 POP 2818 61 PUSH2 0x2867 281B 56 *JUMP 281C 5B JUMPDEST 281D 50 POP 281E 90 SWAP1 281F 56 *JUMP 2820 5B JUMPDEST 2821 50 POP 2822 80 DUP1 2823 54 SLOAD 2824 60 PUSH1 0x01 2826 81 DUP2 2827 60 PUSH1 0x01 2829 16 AND 282A 15 ISZERO 282B 61 PUSH2 0x0100 282E 02 MUL 282F 03 SUB 2830 16 AND 2831 60 PUSH1 0x02 2833 90 SWAP1 2834 04 DIV 2835 60 PUSH1 0x00 2837 82 DUP3 2838 55 SSTORE 2839 80 DUP1 283A 60 PUSH1 0x1f 283C 10 LT 283D 61 PUSH2 0x2846 2840 57 *JUMPI 2841 50 POP 2842 61 PUSH2 0x2864 2845 56 *JUMP 2846 5B JUMPDEST 2847 60 PUSH1 0x1f 2849 01 ADD 284A 60 PUSH1 0x20 284C 90 SWAP1 284D 04 DIV 284E 90 SWAP1 284F 60 PUSH1 0x00 2851 52 MSTORE 2852 60 PUSH1 0x20 2854 60 PUSH1 0x00 2856 20 SHA3 2857 90 SWAP1 2858 81 DUP2 2859 01 ADD 285A 90 SWAP1 285B 61 PUSH2 0x2864 285E 91 SWAP2 285F 90 SWAP1 2860 61 PUSH2 0x2867 2863 56 *JUMP label_2864: // Incoming jump from 0x3AD8, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x3AC2, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2866 stack[-2] } 2864 5B JUMPDEST 2865 50 POP 2866 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 2867 5B JUMPDEST 2868 61 PUSH2 0x05fc 286B 91 SWAP2 286C 90 SWAP1 286D 5B JUMPDEST 286E 80 DUP1 286F 82 DUP3 2870 11 GT 2871 15 ISZERO 2872 61 PUSH2 0x281c 2875 57 *JUMPI 2876 60 PUSH1 0x00 2878 81 DUP2 2879 55 SSTORE 287A 60 PUSH1 0x01 287C 01 ADD 287D 61 PUSH2 0x286d 2880 56 *JUMP label_2881: // Incoming call from 0x2A98, returns to 0x2A99 // Incoming call from 0x2BA4, returns to 0x2BA5 // Incoming call from 0x2C11, returns to 0x2C12 // Incoming call from 0x2E4C, returns to 0x2E4D // Incoming call from 0x2B0F, returns to 0x2B10 // Incoming call from 0x2A89, returns to 0x2A8A // Incoming call from 0x2A6D, returns to 0x0C9E // Incoming call from 0x2E28, returns to 0x2E29 // Incoming call from 0x2B65, returns to 0x2B66 // Incoming call from 0x2D14, returns to 0x2A99 // Incoming call from 0x2E3A, returns to 0x2E3B // Incoming call from 0x2B00, returns to 0x2B01 // Inputs[2] // { // @2882 stack[-1] // @2883 msg.data[stack[-1]:stack[-1] + 0x20] // } 2881 5B JUMPDEST 2882 80 DUP1 2883 35 CALLDATALOAD 2884 60 PUSH1 0x01 2886 60 PUSH1 0x01 2888 60 PUSH1 0xa0 288A 1B SHL 288B 03 SUB 288C 81 DUP2 288D 16 AND 288E 81 DUP2 288F 14 EQ 2890 61 PUSH2 0x0ca1 2893 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2883 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0ca1, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2894: // Incoming jump from 0x2893, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2897 memory[0x00:0x00] } 2894 60 PUSH1 0x00 2896 80 DUP1 2897 FD *REVERT // Stack delta = +0 // Outputs[1] { @2897 revert(memory[0x00:0x00]); } // Block terminates label_2898: // Incoming call from 0x2B3D, returns to 0x2B3E // Incoming call from 0x2A32, returns to 0x2A33 // Incoming call from 0x2A0F, returns to 0x2A10 // Inputs[2] // { // @289B stack[-2] // @289E stack[-1] // } 2898 5B JUMPDEST 2899 60 PUSH1 0x00 289B 82 DUP3 289C 60 PUSH1 0x1f 289E 83 DUP4 289F 01 ADD 28A0 12 SLT 28A1 61 PUSH2 0x28a8 28A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2899 stack[0] = 0x00 } // Block ends with conditional jump to 0x28a8, if stack[-1] + 0x1f i< stack[-2] label_28A5: // Incoming jump from 0x28A4, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @28A5 stack[-1] // @28A7 memory[stack[-1]:stack[-1] + stack[-1]] // } 28A5 80 DUP1 28A6 81 DUP2 28A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @28A7 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_28A8: // Incoming jump from 0x28A4, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @28A9 stack[-2] // @28AA msg.data[stack[-2]:stack[-2] + 0x20] // } 28A8 5B JUMPDEST 28A9 81 DUP2 28AA 35 CALLDATALOAD 28AB 67 PUSH8 0xffffffffffffffff 28B4 81 DUP2 28B5 11 GT 28B6 15 ISZERO 28B7 61 PUSH2 0x28be 28BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28AA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x28be, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_28BB: // Incoming jump from 0x28BA, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @28BB stack[-2] // @28BD memory[stack[-2]:stack[-2] + stack[-2]] // } 28BB 81 DUP2 28BC 82 DUP3 28BD FD *REVERT // Stack delta = +0 // Outputs[1] { @28BD revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_28BE: // Incoming jump from 0x28BA, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @28C4 stack[-1] } 28BE 5B JUMPDEST 28BF 61 PUSH2 0x28d1 28C2 60 PUSH1 0x1f 28C4 82 DUP3 28C5 01 ADD 28C6 60 PUSH1 0x1f 28C8 19 NOT 28C9 16 AND 28CA 60 PUSH1 0x20 28CC 01 ADD 28CD 61 PUSH2 0x3a5f 28D0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @28BF stack[0] = 0x28d1 // @28CC stack[1] = 0x20 + (~0x1f & stack[-1] + 0x1f) // } // Block ends with call to 0x3a5f, returns to 0x28D1 label_28D1: // Incoming return from call to 0x3A5F at 0x28D0 // Inputs[5] // { // @28D2 stack[-3] // @28D2 stack[-1] // @28D4 stack[-2] // @28D7 stack[-5] // @28DB stack[-4] // } 28D1 5B JUMPDEST 28D2 91 SWAP2 28D3 50 POP 28D4 80 DUP1 28D5 82 DUP3 28D6 52 MSTORE 28D7 83 DUP4 28D8 60 PUSH1 0x20 28DA 82 DUP3 28DB 85 DUP6 28DC 01 ADD 28DD 01 ADD 28DE 11 GT 28DF 15 ISZERO 28E0 61 PUSH2 0x28e8 28E3 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @28D2 stack[-3] = stack[-1] // @28D6 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // } // Block ends with conditional jump to 0x28e8, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_28E4: // Incoming jump from 0x28E3, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[1] { @28E7 memory[0x00:0x00] } 28E4 60 PUSH1 0x00 28E6 80 DUP1 28E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @28E7 revert(memory[0x00:0x00]); } // Block terminates label_28E8: // Incoming jump from 0x28E3, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[6] // { // @28E9 stack[-1] // @28EC stack[-3] // @28F0 stack[-2] // @28F2 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-1]] // @28FC stack[-5] // @28FD stack[-4] // } 28E8 5B JUMPDEST 28E9 80 DUP1 28EA 60 PUSH1 0x20 28EC 84 DUP5 28ED 01 ADD 28EE 60 PUSH1 0x20 28F0 84 DUP5 28F1 01 ADD 28F2 37 CALLDATACOPY 28F3 60 PUSH1 0x00 28F5 90 SWAP1 28F6 82 DUP3 28F7 01 ADD 28F8 60 PUSH1 0x20 28FA 01 ADD 28FB 52 MSTORE 28FC 92 SWAP3 28FD 91 SWAP2 28FE 50 POP 28FF 50 POP 2900 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @28F2 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-1]] // @28FB memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] = 0x00 // @28FC stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_2901: // Incoming call from 0x2BDB, returns to 0x2BDC // Incoming call from 0x2CD9, returns to 0x2A99 // Inputs[2] // { // @2906 stack[-1] // @2907 stack[-2] // } 2901 5B JUMPDEST 2902 60 PUSH1 0x00 2904 60 PUSH1 0x60 2906 82 DUP3 2907 84 DUP5 2908 03 SUB 2909 12 SLT 290A 15 ISZERO 290B 61 PUSH2 0x2912 290E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2902 stack[0] = 0x00 } // Block ends with conditional jump to 0x2912, if !(stack[-2] - stack[-1] i< 0x60) label_290F: // Incoming jump from 0x290E, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @290F stack[-1] // @2911 memory[stack[-1]:stack[-1] + stack[-1]] // } 290F 80 DUP1 2910 81 DUP2 2911 FD *REVERT // Stack delta = +0 // Outputs[1] { @2911 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2912: // Incoming jump from 0x290E, if !(stack[-2] - stack[-1] i< 0x60) 2912 5B JUMPDEST 2913 61 PUSH2 0x291c 2916 60 PUSH1 0x60 2918 61 PUSH2 0x3a5f 291B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2913 stack[0] = 0x291c // @2916 stack[1] = 0x60 // } // Block ends with call to 0x3a5f, returns to 0x291C label_291C: // Incoming return from call to 0x3A5F at 0x291B // Inputs[4] // { // @291D stack[-2] // @291D stack[-1] // @2922 stack[-4] // @2923 stack[-3] // } 291C 5B JUMPDEST 291D 90 SWAP1 291E 50 POP 291F 61 PUSH2 0x2928 2922 83 DUP4 2923 83 DUP4 2924 61 PUSH2 0x2954 2927 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @291D stack[-2] = stack[-1] // @291F stack[-1] = 0x2928 // @2922 stack[0] = stack[-4] // @2923 stack[1] = stack[-3] // } // Block ends with call to 0x2954, returns to 0x2928 label_2928: // Incoming return from call to 0x2954 at 0x2927 // Inputs[4] // { // @2929 stack[-2] // @292A stack[-1] // @292E stack[-4] // @2931 stack[-3] // } 2928 5B JUMPDEST 2929 81 DUP2 292A 52 MSTORE 292B 61 PUSH2 0x2937 292E 83 DUP4 292F 60 PUSH1 0x20 2931 84 DUP5 2932 01 ADD 2933 61 PUSH2 0x2954 2936 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @292A memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @292B stack[-1] = 0x2937 // @292E stack[0] = stack[-4] // @2932 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x2954, returns to 0x2937 label_2937: // Incoming return from call to 0x2954 at 0x2936 // Inputs[4] // { // @293A stack[-2] // @293C stack[-1] // @2940 stack[-4] // @2943 stack[-3] // } 2937 5B JUMPDEST 2938 60 PUSH1 0x20 293A 82 DUP3 293B 01 ADD 293C 52 MSTORE 293D 61 PUSH2 0x2949 2940 83 DUP4 2941 60 PUSH1 0x40 2943 84 DUP5 2944 01 ADD 2945 61 PUSH2 0x2954 2948 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @293C memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @293D stack[-1] = 0x2949 // @2940 stack[0] = stack[-4] // @2944 stack[1] = stack[-3] + 0x40 // } // Block ends with call to 0x2954, returns to 0x2949 label_2949: // Incoming return from call to 0x2954 at 0x2948 // Inputs[4] // { // @294C stack[-2] // @294E stack[-1] // @294F stack[-5] // @2950 stack[-4] // } 2949 5B JUMPDEST 294A 60 PUSH1 0x40 294C 82 DUP3 294D 01 ADD 294E 52 MSTORE 294F 92 SWAP3 2950 91 SWAP2 2951 50 POP 2952 50 POP 2953 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @294E memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = stack[-1] // @294F stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_2954: // Incoming call from 0x2948, returns to 0x2949 // Incoming call from 0x2E5E, returns to 0x2E5F // Incoming call from 0x2927, returns to 0x2928 // Incoming call from 0x2936, returns to 0x2937 // Inputs[2] // { // @2959 stack[-1] // @295A stack[-2] // } 2954 5B JUMPDEST 2955 60 PUSH1 0x00 2957 60 PUSH1 0x20 2959 82 DUP3 295A 84 DUP5 295B 03 SUB 295C 12 SLT 295D 15 ISZERO 295E 61 PUSH2 0x2965 2961 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2955 stack[0] = 0x00 } // Block ends with conditional jump to 0x2965, if !(stack[-2] - stack[-1] i< 0x20) label_2962: // Incoming jump from 0x2961, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2962 stack[-1] // @2964 memory[stack[-1]:stack[-1] + stack[-1]] // } 2962 80 DUP1 2963 81 DUP2 2964 FD *REVERT // Stack delta = +0 // Outputs[1] { @2964 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2965: // Incoming jump from 0x2961, if !(stack[-2] - stack[-1] i< 0x20) 2965 5B JUMPDEST 2966 61 PUSH2 0x296f 2969 60 PUSH1 0x20 296B 61 PUSH2 0x3a5f 296E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2966 stack[0] = 0x296f // @2969 stack[1] = 0x20 // } // Block ends with call to 0x3a5f, returns to 0x296F label_296F: // Incoming return from call to 0x3A5F at 0x296E // Inputs[5] // { // @2970 stack[-3] // @2970 stack[-1] // @2971 msg.data[stack[-3]:stack[-3] + 0x20] // @2975 stack[-5] // @2976 stack[-4] // } 296F 5B JUMPDEST 2970 91 SWAP2 2971 35 CALLDATALOAD 2972 82 DUP3 2973 52 MSTORE 2974 50 POP 2975 91 SWAP2 2976 90 SWAP1 2977 50 POP 2978 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2973 memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-3]:stack[-3] + 0x20] // @2975 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_2979: // Incoming call from 0x2BEA, returns to 0x2BEB // Incoming call from 0x2C54, returns to 0x2C55 // Inputs[2] // { // @297E stack[-1] // @297F stack[-2] // } 2979 5B JUMPDEST 297A 60 PUSH1 0x00 297C 60 PUSH1 0x80 297E 82 DUP3 297F 84 DUP5 2980 03 SUB 2981 12 SLT 2982 15 ISZERO 2983 61 PUSH2 0x298a 2986 57 *JUMPI // Stack delta = +1 // Outputs[1] { @297A stack[0] = 0x00 } // Block ends with conditional jump to 0x298a, if !(stack[-2] - stack[-1] i< 0x80) label_2987: // Incoming jump from 0x2986, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2987 stack[-1] // @2989 memory[stack[-1]:stack[-1] + stack[-1]] // } 2987 80 DUP1 2988 81 DUP2 2989 FD *REVERT // Stack delta = +0 // Outputs[1] { @2989 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_298A: // Incoming jump from 0x2986, if !(stack[-2] - stack[-1] i< 0x80) 298A 5B JUMPDEST 298B 61 PUSH2 0x2994 298E 60 PUSH1 0x80 2990 61 PUSH2 0x3a5f 2993 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @298B stack[0] = 0x2994 // @298E stack[1] = 0x80 // } // Block ends with call to 0x3a5f, returns to 0x2994 label_2994: // Incoming return from call to 0x3A5F at 0x2993 // Inputs[5] // { // @2995 stack[-2] // @2995 stack[-1] // @2997 stack[-3] // @2998 msg.data[stack[-3]:stack[-3] + 0x20] // @299F msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 2994 5B JUMPDEST 2995 90 SWAP1 2996 50 POP 2997 81 DUP2 2998 35 CALLDATALOAD 2999 81 DUP2 299A 52 MSTORE 299B 60 PUSH1 0x20 299D 82 DUP3 299E 01 ADD 299F 35 CALLDATALOAD 29A0 60 PUSH1 0xff 29A2 81 DUP2 29A3 16 AND 29A4 81 DUP2 29A5 14 EQ 29A6 61 PUSH2 0x29ae 29A9 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2995 stack[-2] = stack[-1] // @299A memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-3]:stack[-3] + 0x20] // @299F stack[-1] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x29ae, if msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] == msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] & 0xff label_29AA: // Incoming jump from 0x29A9, if not msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] == msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] & 0xff // Inputs[1] { @29AD memory[0x00:0x00] } 29AA 60 PUSH1 0x00 29AC 80 DUP1 29AD FD *REVERT // Stack delta = +0 // Outputs[1] { @29AD revert(memory[0x00:0x00]); } // Block terminates label_29AE: // Incoming jump from 0x29A9, if msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] == msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] & 0xff // Inputs[7] // { // @29AF stack[-1] // @29B2 stack[-2] // @29B8 stack[-3] // @29BA msg.data[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @29C4 msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @29CA stack[-5] // @29CB stack[-4] // } 29AE 5B JUMPDEST 29AF 80 DUP1 29B0 60 PUSH1 0x20 29B2 83 DUP4 29B3 01 ADD 29B4 52 MSTORE 29B5 50 POP 29B6 60 PUSH1 0x40 29B8 82 DUP3 29B9 01 ADD 29BA 35 CALLDATALOAD 29BB 60 PUSH1 0x40 29BD 82 DUP3 29BE 01 ADD 29BF 52 MSTORE 29C0 60 PUSH1 0x60 29C2 82 DUP3 29C3 01 ADD 29C4 35 CALLDATALOAD 29C5 60 PUSH1 0x60 29C7 82 DUP3 29C8 01 ADD 29C9 52 MSTORE 29CA 92 SWAP3 29CB 91 SWAP2 29CC 50 POP 29CD 50 POP 29CE 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @29B4 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @29BF memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = msg.data[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @29C9 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @29CA stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_29CF: // Incoming call from 0x2BCB, returns to 0x2BCC // Incoming call from 0x2CC9, returns to 0x2CCA // Inputs[2] // { // @29D4 stack[-1] // @29D5 stack[-2] // } 29CF 5B JUMPDEST 29D0 60 PUSH1 0x00 29D2 60 PUSH1 0x80 29D4 82 DUP3 29D5 84 DUP5 29D6 03 SUB 29D7 12 SLT 29D8 15 ISZERO 29D9 61 PUSH2 0x29e0 29DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x29e0, if !(stack[-2] - stack[-1] i< 0x80) label_29DD: // Incoming jump from 0x29DC, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @29DD stack[-1] // @29DF memory[stack[-1]:stack[-1] + stack[-1]] // } 29DD 80 DUP1 29DE 81 DUP2 29DF FD *REVERT // Stack delta = +0 // Outputs[1] { @29DF revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_29E0: // Incoming jump from 0x29DC, if !(stack[-2] - stack[-1] i< 0x80) 29E0 5B JUMPDEST 29E1 61 PUSH2 0x29ea 29E4 60 PUSH1 0x80 29E6 61 PUSH2 0x3a5f 29E9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29E1 stack[0] = 0x29ea // @29E4 stack[1] = 0x80 // } // Block ends with call to 0x3a5f, returns to 0x29EA label_29EA: // Incoming return from call to 0x3A5F at 0x29E9 // Inputs[4] // { // @29EB stack[-1] // @29EB stack[-2] // @29ED stack[-3] // @29EE msg.data[stack[-3]:stack[-3] + 0x20] // } 29EA 5B JUMPDEST 29EB 90 SWAP1 29EC 50 POP 29ED 81 DUP2 29EE 35 CALLDATALOAD 29EF 67 PUSH8 0xffffffffffffffff 29F8 80 DUP1 29F9 82 DUP3 29FA 11 GT 29FB 15 ISZERO 29FC 61 PUSH2 0x2a04 29FF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @29EB stack[-2] = stack[-1] // @29EE stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] // @29EF stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2a04, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2A00: // Incoming jump from 0x29FF, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2A03 memory[0x00:0x00] } 2A00 60 PUSH1 0x00 2A02 80 DUP1 2A03 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A03 revert(memory[0x00:0x00]); } // Block terminates label_2A04: // Incoming jump from 0x29FF, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2A08 stack[-5] // @2A09 stack[-2] // @2A0A stack[-4] // } 2A04 5B JUMPDEST 2A05 61 PUSH2 0x2a10 2A08 85 DUP6 2A09 83 DUP4 2A0A 86 DUP7 2A0B 01 ADD 2A0C 61 PUSH2 0x2898 2A0F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A05 stack[0] = 0x2a10 // @2A08 stack[1] = stack[-5] // @2A0B stack[2] = stack[-4] + stack[-2] // } // Block ends with call to 0x2898, returns to 0x2A10 label_2A10: // Incoming return from call to 0x2898 at 0x2A0F // Inputs[6] // { // @2A11 stack[-4] // @2A12 stack[-1] // @2A15 stack[-5] // @2A17 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2A18 stack[-3] // @2A1A stack[-2] // } 2A10 5B JUMPDEST 2A11 83 DUP4 2A12 52 MSTORE 2A13 60 PUSH1 0x20 2A15 84 DUP5 2A16 01 ADD 2A17 35 CALLDATALOAD 2A18 91 SWAP2 2A19 50 POP 2A1A 80 DUP1 2A1B 82 DUP3 2A1C 11 GT 2A1D 15 ISZERO 2A1E 61 PUSH2 0x2a26 2A21 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @2A12 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @2A18 stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2a26, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > stack[-2]) label_2A22: // Incoming jump from 0x2A21, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > stack[-2]) // Inputs[1] { @2A25 memory[0x00:0x00] } 2A22 60 PUSH1 0x00 2A24 80 DUP1 2A25 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A25 revert(memory[0x00:0x00]); } // Block terminates label_2A26: // Incoming jump from 0x2A21, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @2A2B stack[-5] // @2A2C stack[-2] // @2A2D stack[-4] // } 2A26 5B JUMPDEST 2A27 50 POP 2A28 61 PUSH2 0x2a33 2A2B 84 DUP5 2A2C 82 DUP3 2A2D 85 DUP6 2A2E 01 ADD 2A2F 61 PUSH2 0x2898 2A32 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2A28 stack[-1] = 0x2a33 // @2A2B stack[0] = stack[-5] // @2A2E stack[1] = stack[-4] + stack[-2] // } // Block ends with call to 0x2898, returns to 0x2A33 label_2A33: // Incoming return from call to 0x2898 at 0x2A32 // Inputs[7] // { // @2A36 stack[-3] // @2A38 stack[-1] // @2A3C stack[-4] // @2A3E msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @2A48 msg.data[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // @2A4E stack[-6] // @2A4F stack[-5] // } 2A33 5B JUMPDEST 2A34 60 PUSH1 0x20 2A36 83 DUP4 2A37 01 ADD 2A38 52 MSTORE 2A39 50 POP 2A3A 60 PUSH1 0x40 2A3C 82 DUP3 2A3D 01 ADD 2A3E 35 CALLDATALOAD 2A3F 60 PUSH1 0x40 2A41 82 DUP3 2A42 01 ADD 2A43 52 MSTORE 2A44 60 PUSH1 0x60 2A46 82 DUP3 2A47 01 ADD 2A48 35 CALLDATALOAD 2A49 60 PUSH1 0x60 2A4B 82 DUP3 2A4C 01 ADD 2A4D 52 MSTORE 2A4E 92 SWAP3 2A4F 91 SWAP2 2A50 50 POP 2A51 50 POP 2A52 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2A38 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] // @2A43 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] = msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @2A4D memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = msg.data[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // @2A4E stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2A53: // Incoming jump from 0x02ED // Incoming jump from 0x040F // Inputs[2] // { // @2A58 stack[-1] // @2A59 stack[-2] // } 2A53 5B JUMPDEST 2A54 60 PUSH1 0x00 2A56 60 PUSH1 0x20 2A58 82 DUP3 2A59 84 DUP5 2A5A 03 SUB 2A5B 12 SLT 2A5C 15 ISZERO 2A5D 61 PUSH2 0x2a64 2A60 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A54 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a64, if !(stack[-2] - stack[-1] i< 0x20) label_2A61: // Incoming jump from 0x2A60, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2A61 stack[-1] // @2A63 memory[stack[-1]:stack[-1] + stack[-1]] // } 2A61 80 DUP1 2A62 81 DUP2 2A63 FD *REVERT // Stack delta = +0 // Outputs[1] { @2A63 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2A64: // Incoming jump from 0x2A60, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2A68 stack[-3] // @2A69 stack[-2] // } 2A64 5B JUMPDEST 2A65 61 PUSH2 0x0c9e 2A68 83 DUP4 2A69 83 DUP4 2A6A 61 PUSH2 0x2881 2A6D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A65 stack[0] = 0x0c9e // @2A68 stack[1] = stack[-3] // @2A69 stack[2] = stack[-2] // } // Block ends with call to 0x2881, returns to 0x0C9E label_2A6E: // Incoming jump from 0x04F8 // Inputs[2] // { // @2A74 stack[-1] // @2A75 stack[-2] // } 2A6E 5B JUMPDEST 2A6F 60 PUSH1 0x00 2A71 80 DUP1 2A72 60 PUSH1 0x40 2A74 83 DUP4 2A75 85 DUP6 2A76 03 SUB 2A77 12 SLT 2A78 15 ISZERO 2A79 61 PUSH2 0x2a80 2A7C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2A6F stack[0] = 0x00 // @2A71 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2a80, if !(stack[-2] - stack[-1] i< 0x40) label_2A7D: // Incoming jump from 0x2A7C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2A7D stack[-1] // @2A7F memory[stack[-1]:stack[-1] + stack[-1]] // } 2A7D 80 DUP1 2A7E 81 DUP2 2A7F FD *REVERT // Stack delta = +0 // Outputs[1] { @2A7F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2A80: // Incoming jump from 0x2A7C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2A84 stack[-4] // @2A85 stack[-3] // } 2A80 5B JUMPDEST 2A81 61 PUSH2 0x2a8a 2A84 84 DUP5 2A85 84 DUP5 2A86 61 PUSH2 0x2881 2A89 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A81 stack[0] = 0x2a8a // @2A84 stack[1] = stack[-4] // @2A85 stack[2] = stack[-3] // } // Block ends with call to 0x2881, returns to 0x2A8A label_2A8A: // Incoming return from call to 0x2881 at 0x2A89 // Inputs[4] // { // @2A8B stack[-3] // @2A8B stack[-1] // @2A90 stack[-5] // @2A93 stack[-4] // } 2A8A 5B JUMPDEST 2A8B 91 SWAP2 2A8C 50 POP 2A8D 61 PUSH2 0x2a99 2A90 84 DUP5 2A91 60 PUSH1 0x20 2A93 85 DUP6 2A94 01 ADD 2A95 61 PUSH2 0x2881 2A98 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2A8B stack[-3] = stack[-1] // @2A8D stack[-1] = 0x2a99 // @2A90 stack[0] = stack[-5] // @2A94 stack[1] = stack[-4] + 0x20 // } // Block ends with call to 0x2881, returns to 0x2A99 label_2A99: // Incoming return from call to 0x2901 at 0x2CD9 // Incoming return from call to 0x2881 at 0x2D14 // Incoming return from call to 0x2881 at 0x2A98 // Inputs[6] // { // @2A9A stack[-2] // @2A9A stack[-1] // @2A9C stack[-5] // @2A9E stack[-6] // @2A9E stack[-3] // @2A9F stack[-4] // } 2A99 5B JUMPDEST 2A9A 90 SWAP1 2A9B 50 POP 2A9C 92 SWAP3 2A9D 50 POP 2A9E 92 SWAP3 2A9F 90 SWAP1 2AA0 50 POP 2AA1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2A9C stack[-5] = stack[-1] // @2A9E stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2AA2: // Incoming call from 0x0341, returns to 0x0342 // Incoming call from 0x0395, returns to 0x0396 // Inputs[2] // { // @2AAA stack[-1] // @2AAB stack[-2] // } 2AA2 5B JUMPDEST 2AA3 60 PUSH1 0x00 2AA5 80 DUP1 2AA6 60 PUSH1 0x00 2AA8 60 PUSH1 0x60 2AAA 84 DUP5 2AAB 86 DUP7 2AAC 03 SUB 2AAD 12 SLT 2AAE 15 ISZERO 2AAF 61 PUSH2 0x2ab6 2AB2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2AA3 stack[0] = 0x00 // @2AA5 stack[1] = 0x00 // @2AA6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2ab6, if !(stack[-2] - stack[-1] i< 0x60) label_2AB3: // Incoming jump from 0x2AB2, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2AB3 stack[-1] // @2AB5 memory[stack[-1]:stack[-1] + stack[-1]] // } 2AB3 80 DUP1 2AB4 81 DUP2 2AB5 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AB5 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2AB6: // Incoming jump from 0x2AB2, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2AB7 stack[-4] // @2AB8 msg.data[stack[-4]:stack[-4] + 0x20] // } 2AB6 5B JUMPDEST 2AB7 83 DUP4 2AB8 35 CALLDATALOAD 2AB9 61 PUSH2 0x2ac1 2ABC 81 DUP2 2ABD 61 PUSH2 0x3ab2 2AC0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2AB8 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @2AB9 stack[1] = 0x2ac1 // @2ABC stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3ab2, returns to 0x2AC1 label_2AC1: // Incoming return from call to 0x3AB2 at 0x2AC0 // Inputs[4] // { // @2AC2 stack[-1] // @2AC2 stack[-4] // @2AC6 stack[-5] // @2AC8 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2AC1 5B JUMPDEST 2AC2 92 SWAP3 2AC3 50 POP 2AC4 60 PUSH1 0x20 2AC6 84 DUP5 2AC7 01 ADD 2AC8 35 CALLDATALOAD 2AC9 61 PUSH2 0x2ad1 2ACC 81 DUP2 2ACD 61 PUSH2 0x3ab2 2AD0 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2AC2 stack[-4] = stack[-1] // @2AC8 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2AC9 stack[0] = 0x2ad1 // @2ACC stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x3ab2, returns to 0x2AD1 label_2AD1: // Incoming return from call to 0x3AB2 at 0x2AD0 // Inputs[6] // { // @2AD2 stack[-1] // @2AD2 stack[-4] // @2AD3 stack[-7] // @2AD5 stack[-6] // @2ADB stack[-5] // @2ADF msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 2AD1 5B JUMPDEST 2AD2 92 SWAP3 2AD3 95 SWAP6 2AD4 92 SWAP3 2AD5 94 SWAP5 2AD6 50 POP 2AD7 50 POP 2AD8 50 POP 2AD9 60 PUSH1 0x40 2ADB 91 SWAP2 2ADC 90 SWAP1 2ADD 91 SWAP2 2ADE 01 ADD 2ADF 35 CALLDATALOAD 2AE0 90 SWAP1 2AE1 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2AD3 stack[-7] = stack[-4] // @2AD5 stack[-6] = stack[-1] // @2AE0 stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2AE2: // Incoming call from 0x04A4, returns to 0x04A5 // Inputs[2] // { // @2AEB stack[-1] // @2AEC stack[-2] // } 2AE2 5B JUMPDEST 2AE3 60 PUSH1 0x00 2AE5 80 DUP1 2AE6 60 PUSH1 0x00 2AE8 80 DUP1 2AE9 60 PUSH1 0x80 2AEB 85 DUP6 2AEC 87 DUP8 2AED 03 SUB 2AEE 12 SLT 2AEF 15 ISZERO 2AF0 61 PUSH2 0x2af7 2AF3 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2AE3 stack[0] = 0x00 // @2AE5 stack[1] = 0x00 // @2AE6 stack[2] = 0x00 // @2AE8 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2af7, if !(stack[-2] - stack[-1] i< 0x80) label_2AF4: // Incoming jump from 0x2AF3, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2AF4 stack[-1] // @2AF6 memory[stack[-1]:stack[-1] + stack[-1]] // } 2AF4 80 DUP1 2AF5 81 DUP2 2AF6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AF6 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2AF7: // Incoming jump from 0x2AF3, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2AFB stack[-6] // @2AFC stack[-5] // } 2AF7 5B JUMPDEST 2AF8 61 PUSH2 0x2b01 2AFB 86 DUP7 2AFC 86 DUP7 2AFD 61 PUSH2 0x2881 2B00 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2AF8 stack[0] = 0x2b01 // @2AFB stack[1] = stack[-6] // @2AFC stack[2] = stack[-5] // } // Block ends with call to 0x2881, returns to 0x2B01 label_2B01: // Incoming return from call to 0x2881 at 0x2B00 // Inputs[4] // { // @2B02 stack[-5] // @2B02 stack[-1] // @2B07 stack[-7] // @2B0A stack[-6] // } 2B01 5B JUMPDEST 2B02 93 SWAP4 2B03 50 POP 2B04 61 PUSH2 0x2b10 2B07 86 DUP7 2B08 60 PUSH1 0x20 2B0A 87 DUP8 2B0B 01 ADD 2B0C 61 PUSH2 0x2881 2B0F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2B02 stack[-5] = stack[-1] // @2B04 stack[-1] = 0x2b10 // @2B07 stack[0] = stack[-7] // @2B0B stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x2881, returns to 0x2B10 label_2B10: // Incoming return from call to 0x2881 at 0x2B0F // Inputs[6] // { // @2B11 stack[-1] // @2B11 stack[-4] // @2B15 stack[-6] // @2B17 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2B18 stack[-3] // @2B1E msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2B10 5B JUMPDEST 2B11 92 SWAP3 2B12 50 POP 2B13 60 PUSH1 0x40 2B15 85 DUP6 2B16 01 ADD 2B17 35 CALLDATALOAD 2B18 91 SWAP2 2B19 50 POP 2B1A 60 PUSH1 0x60 2B1C 85 DUP6 2B1D 01 ADD 2B1E 35 CALLDATALOAD 2B1F 67 PUSH8 0xffffffffffffffff 2B28 81 DUP2 2B29 11 GT 2B2A 15 ISZERO 2B2B 61 PUSH2 0x2b32 2B2E 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2B11 stack[-4] = stack[-1] // @2B18 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2B1E stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2b32, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2B2F: // Incoming jump from 0x2B2E, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2B2F stack[-2] // @2B31 memory[stack[-2]:stack[-2] + stack[-2]] // } 2B2F 81 DUP2 2B30 82 DUP3 2B31 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B31 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2B32: // Incoming jump from 0x2B2E, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2B36 stack[-7] // @2B37 stack[-1] // @2B38 stack[-6] // } 2B32 5B JUMPDEST 2B33 61 PUSH2 0x2b3e 2B36 87 DUP8 2B37 82 DUP3 2B38 88 DUP9 2B39 01 ADD 2B3A 61 PUSH2 0x2898 2B3D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B33 stack[0] = 0x2b3e // @2B36 stack[1] = stack[-7] // @2B39 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x2898, returns to 0x2B3E label_2B3E: // Incoming return from call to 0x2898 at 0x2B3D // Inputs[8] // { // @2B3F stack[-1] // @2B3F stack[-3] // @2B42 stack[-6] // @2B43 stack[-9] // @2B44 stack[-5] // @2B45 stack[-8] // @2B47 stack[-7] // @2B47 stack[-4] // } 2B3E 5B JUMPDEST 2B3F 91 SWAP2 2B40 50 POP 2B41 50 POP 2B42 92 SWAP3 2B43 95 SWAP6 2B44 91 SWAP2 2B45 94 SWAP5 2B46 50 POP 2B47 92 SWAP3 2B48 50 POP 2B49 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2B42 stack[-6] = stack[-1] // @2B43 stack[-9] = stack[-6] // @2B45 stack[-8] = stack[-5] // @2B47 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2B4A: // Incoming call from 0x046B, returns to 0x046C // Inputs[2] // { // @2B50 stack[-1] // @2B51 stack[-2] // } 2B4A 5B JUMPDEST 2B4B 60 PUSH1 0x00 2B4D 80 DUP1 2B4E 60 PUSH1 0x40 2B50 83 DUP4 2B51 85 DUP6 2B52 03 SUB 2B53 12 SLT 2B54 15 ISZERO 2B55 61 PUSH2 0x2b5c 2B58 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B4B stack[0] = 0x00 // @2B4D stack[1] = 0x00 // } // Block ends with conditional jump to 0x2b5c, if !(stack[-2] - stack[-1] i< 0x40) label_2B59: // Incoming jump from 0x2B58, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2B59 stack[-2] // @2B5B memory[stack[-2]:stack[-2] + stack[-2]] // } 2B59 81 DUP2 2B5A 82 DUP3 2B5B FD *REVERT // Stack delta = +0 // Outputs[1] { @2B5B revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2B5C: // Incoming jump from 0x2B58, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2B60 stack[-4] // @2B61 stack[-3] // } 2B5C 5B JUMPDEST 2B5D 61 PUSH2 0x2b66 2B60 84 DUP5 2B61 84 DUP5 2B62 61 PUSH2 0x2881 2B65 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B5D stack[0] = 0x2b66 // @2B60 stack[1] = stack[-4] // @2B61 stack[2] = stack[-3] // } // Block ends with call to 0x2881, returns to 0x2B66 label_2B66: // Incoming return from call to 0x2881 at 0x2B65 // Inputs[4] // { // @2B67 stack[-1] // @2B67 stack[-3] // @2B6B stack[-4] // @2B6D msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2B66 5B JUMPDEST 2B67 91 SWAP2 2B68 50 POP 2B69 60 PUSH1 0x20 2B6B 83 DUP4 2B6C 01 ADD 2B6D 35 CALLDATALOAD 2B6E 80 DUP1 2B6F 15 ISZERO 2B70 15 ISZERO 2B71 81 DUP2 2B72 14 EQ 2B73 61 PUSH2 0x2b7a 2B76 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2B67 stack[-3] = stack[-1] // @2B6D stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2b7a, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_2B77: // Incoming jump from 0x2B76, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @2B77 stack[-2] // @2B79 memory[stack[-2]:stack[-2] + stack[-2]] // } 2B77 81 DUP2 2B78 82 DUP3 2B79 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B79 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2B7A: // Incoming jump from 0x2B76, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @2B7B stack[-1] // @2B7C stack[-2] // @2B7F stack[-5] // @2B81 stack[-6] // @2B81 stack[-3] // @2B82 stack[-4] // } 2B7A 5B JUMPDEST 2B7B 80 DUP1 2B7C 91 SWAP2 2B7D 50 POP 2B7E 50 POP 2B7F 92 SWAP3 2B80 50 POP 2B81 92 SWAP3 2B82 90 SWAP1 2B83 50 POP 2B84 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2B7F stack[-5] = stack[-1] // @2B81 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2B85: // Incoming call from 0x0435, returns to 0x0436 // Inputs[2] // { // @2B8F stack[-1] // @2B90 stack[-2] // } 2B85 5B JUMPDEST 2B86 60 PUSH1 0x00 2B88 80 DUP1 2B89 60 PUSH1 0x00 2B8B 80 DUP1 2B8C 61 PUSH2 0x0120 2B8F 85 DUP6 2B90 87 DUP8 2B91 03 SUB 2B92 12 SLT 2B93 15 ISZERO 2B94 61 PUSH2 0x2b9b 2B97 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2B86 stack[0] = 0x00 // @2B88 stack[1] = 0x00 // @2B89 stack[2] = 0x00 // @2B8B stack[3] = 0x00 // } // Block ends with conditional jump to 0x2b9b, if !(stack[-2] - stack[-1] i< 0x0120) label_2B98: // Incoming jump from 0x2B97, if not !(stack[-2] - stack[-1] i< 0x0120) // Inputs[2] // { // @2B98 stack[-1] // @2B9A memory[stack[-1]:stack[-1] + stack[-1]] // } 2B98 80 DUP1 2B99 81 DUP2 2B9A FD *REVERT // Stack delta = +0 // Outputs[1] { @2B9A revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2B9B: // Incoming jump from 0x2B97, if !(stack[-2] - stack[-1] i< 0x0120) // Inputs[2] // { // @2B9F stack[-6] // @2BA0 stack[-5] // } 2B9B 5B JUMPDEST 2B9C 61 PUSH2 0x2ba5 2B9F 86 DUP7 2BA0 86 DUP7 2BA1 61 PUSH2 0x2881 2BA4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B9C stack[0] = 0x2ba5 // @2B9F stack[1] = stack[-6] // @2BA0 stack[2] = stack[-5] // } // Block ends with call to 0x2881, returns to 0x2BA5 label_2BA5: // Incoming return from call to 0x2881 at 0x2BA4 // Inputs[4] // { // @2BA6 stack[-1] // @2BA6 stack[-5] // @2BAA stack[-6] // @2BAC msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 2BA5 5B JUMPDEST 2BA6 93 SWAP4 2BA7 50 POP 2BA8 60 PUSH1 0x20 2BAA 85 DUP6 2BAB 01 ADD 2BAC 35 CALLDATALOAD 2BAD 67 PUSH8 0xffffffffffffffff 2BB6 81 DUP2 2BB7 11 GT 2BB8 15 ISZERO 2BB9 61 PUSH2 0x2bc0 2BBC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2BA6 stack[-5] = stack[-1] // @2BAC stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2bc0, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > 0xffffffffffffffff) label_2BBD: // Incoming jump from 0x2BBC, if not !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2BBD stack[-2] // @2BBF memory[stack[-2]:stack[-2] + stack[-2]] // } 2BBD 81 DUP2 2BBE 82 DUP3 2BBF FD *REVERT // Stack delta = +0 // Outputs[1] { @2BBF revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2BC0: // Incoming jump from 0x2BBC, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2BC4 stack[-7] // @2BC5 stack[-1] // @2BC6 stack[-6] // } 2BC0 5B JUMPDEST 2BC1 61 PUSH2 0x2bcc 2BC4 87 DUP8 2BC5 82 DUP3 2BC6 88 DUP9 2BC7 01 ADD 2BC8 61 PUSH2 0x29cf 2BCB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2BC1 stack[0] = 0x2bcc // @2BC4 stack[1] = stack[-7] // @2BC7 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x29cf, returns to 0x2BCC label_2BCC: // Incoming return from call to 0x29CF at 0x2BCB // Inputs[4] // { // @2BCD stack[-1] // @2BCD stack[-5] // @2BD3 stack[-8] // @2BD6 stack[-7] // } 2BCC 5B JUMPDEST 2BCD 93 SWAP4 2BCE 50 POP 2BCF 50 POP 2BD0 61 PUSH2 0x2bdc 2BD3 86 DUP7 2BD4 60 PUSH1 0x40 2BD6 87 DUP8 2BD7 01 ADD 2BD8 61 PUSH2 0x2901 2BDB 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2BCD stack[-5] = stack[-1] // @2BD0 stack[-2] = 0x2bdc // @2BD3 stack[-1] = stack[-8] // @2BD7 stack[0] = stack[-7] + 0x40 // } // Block ends with call to 0x2901, returns to 0x2BDC label_2BDC: // Incoming return from call to 0x2901 at 0x2BDB // Inputs[4] // { // @2BDD stack[-3] // @2BDD stack[-1] // @2BE2 stack[-7] // @2BE5 stack[-6] // } 2BDC 5B JUMPDEST 2BDD 91 SWAP2 2BDE 50 POP 2BDF 61 PUSH2 0x2beb 2BE2 86 DUP7 2BE3 60 PUSH1 0xa0 2BE5 87 DUP8 2BE6 01 ADD 2BE7 61 PUSH2 0x2979 2BEA 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2BDD stack[-3] = stack[-1] // @2BDF stack[-1] = 0x2beb // @2BE2 stack[0] = stack[-7] // @2BE6 stack[1] = stack[-6] + 0xa0 // } // Block ends with call to 0x2979, returns to 0x2BEB label_2BEB: // Incoming return from call to 0x2979 at 0x2BEA // Inputs[8] // { // @2BEC stack[-1] // @2BEC stack[-2] // @2BEE stack[-5] // @2BEF stack[-8] // @2BF0 stack[-4] // @2BF1 stack[-7] // @2BF3 stack[-3] // @2BF3 stack[-6] // } 2BEB 5B JUMPDEST 2BEC 90 SWAP1 2BED 50 POP 2BEE 92 SWAP3 2BEF 95 SWAP6 2BF0 91 SWAP2 2BF1 94 SWAP5 2BF2 50 POP 2BF3 92 SWAP3 2BF4 50 POP 2BF5 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @2BEE stack[-5] = stack[-1] // @2BEF stack[-8] = stack[-5] // @2BF1 stack[-7] = stack[-4] // @2BF3 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-8] label_2BF6: // Incoming call from 0x051E, returns to 0x051F // Incoming call from 0x02D8, returns to 0x02D9 // Incoming call from 0x037A, returns to 0x037B // Inputs[2] // { // @2BFC stack[-1] // @2BFD stack[-2] // } 2BF6 5B JUMPDEST 2BF7 60 PUSH1 0x00 2BF9 80 DUP1 2BFA 60 PUSH1 0x40 2BFC 83 DUP4 2BFD 85 DUP6 2BFE 03 SUB 2BFF 12 SLT 2C00 15 ISZERO 2C01 61 PUSH2 0x2c08 2C04 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2BF7 stack[0] = 0x00 // @2BF9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2c08, if !(stack[-2] - stack[-1] i< 0x40) label_2C05: // Incoming jump from 0x2C04, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2C05 stack[-2] // @2C07 memory[stack[-2]:stack[-2] + stack[-2]] // } 2C05 81 DUP2 2C06 82 DUP3 2C07 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C07 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2C08: // Incoming jump from 0x2C04, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2C0C stack[-4] // @2C0D stack[-3] // } 2C08 5B JUMPDEST 2C09 61 PUSH2 0x2c12 2C0C 84 DUP5 2C0D 84 DUP5 2C0E 61 PUSH2 0x2881 2C11 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C09 stack[0] = 0x2c12 // @2C0C stack[1] = stack[-4] // @2C0D stack[2] = stack[-3] // } // Block ends with call to 0x2881, returns to 0x2C12 label_2C12: // Incoming return from call to 0x2881 at 0x2C11 // Inputs[5] // { // @2C13 stack[-1] // @2C13 stack[-6] // @2C16 stack[-4] // @2C1A msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2C1B stack[-5] // } 2C12 5B JUMPDEST 2C13 94 SWAP5 2C14 60 PUSH1 0x20 2C16 93 SWAP4 2C17 90 SWAP1 2C18 93 SWAP4 2C19 01 ADD 2C1A 35 CALLDATALOAD 2C1B 93 SWAP4 2C1C 50 POP 2C1D 50 POP 2C1E 50 POP 2C1F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2C13 stack[-6] = stack[-1] // @2C1B stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2C20: // Incoming call from 0x0300, returns to 0x0301 // Inputs[2] // { // @2C28 stack[-1] // @2C29 stack[-2] // } 2C20 5B JUMPDEST 2C21 60 PUSH1 0x00 2C23 80 DUP1 2C24 60 PUSH1 0x00 2C26 60 PUSH1 0xc0 2C28 84 DUP5 2C29 86 DUP7 2C2A 03 SUB 2C2B 12 SLT 2C2C 15 ISZERO 2C2D 61 PUSH2 0x2c34 2C30 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2C21 stack[0] = 0x00 // @2C23 stack[1] = 0x00 // @2C24 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2c34, if !(stack[-2] - stack[-1] i< 0xc0) label_2C31: // Incoming jump from 0x2C30, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @2C31 stack[-1] // @2C33 memory[stack[-1]:stack[-1] + stack[-1]] // } 2C31 80 DUP1 2C32 81 DUP2 2C33 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C33 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2C34: // Incoming jump from 0x2C30, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @2C35 stack[-4] // @2C36 msg.data[stack[-4]:stack[-4] + 0x20] // } 2C34 5B JUMPDEST 2C35 83 DUP4 2C36 35 CALLDATALOAD 2C37 61 PUSH2 0x2c3f 2C3A 81 DUP2 2C3B 61 PUSH2 0x3ab2 2C3E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C36 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @2C37 stack[1] = 0x2c3f // @2C3A stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3ab2, returns to 0x2C3F label_2C3F: // Incoming return from call to 0x3AB2 at 0x2C3E // Inputs[6] // { // @2C40 stack[-1] // @2C40 stack[-4] // @2C44 stack[-5] // @2C46 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2C47 stack[-3] // @2C4C stack[-6] // } 2C3F 5B JUMPDEST 2C40 92 SWAP3 2C41 50 POP 2C42 60 PUSH1 0x20 2C44 84 DUP5 2C45 01 ADD 2C46 35 CALLDATALOAD 2C47 91 SWAP2 2C48 50 POP 2C49 61 PUSH2 0x2c55 2C4C 85 DUP6 2C4D 60 PUSH1 0x40 2C4F 86 DUP7 2C50 01 ADD 2C51 61 PUSH2 0x2979 2C54 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2C40 stack[-4] = stack[-1] // @2C47 stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2C49 stack[-1] = 0x2c55 // @2C4C stack[0] = stack[-6] // @2C50 stack[1] = stack[-5] + 0x40 // } // Block ends with call to 0x2979, returns to 0x2C55 label_2C55: // Incoming return from call to 0x2979 at 0x2C54 // Inputs[7] // { // @2C56 stack[-1] // @2C56 stack[-2] // @2C58 stack[-5] // @2C5A stack[-6] // @2C5A stack[-3] // @2C5C stack[-7] // @2C5C stack[-4] // } 2C55 5B JUMPDEST 2C56 90 SWAP1 2C57 50 POP 2C58 92 SWAP3 2C59 50 POP 2C5A 92 SWAP3 2C5B 50 POP 2C5C 92 SWAP3 2C5D 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2C58 stack[-5] = stack[-1] // @2C5A stack[-6] = stack[-3] // @2C5C stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2C5E: // Incoming call from 0x0283, returns to 0x0284 // Inputs[2] // { // @2C63 stack[-1] // @2C64 stack[-2] // } 2C5E 5B JUMPDEST 2C5F 60 PUSH1 0x00 2C61 60 PUSH1 0x20 2C63 82 DUP3 2C64 84 DUP5 2C65 03 SUB 2C66 12 SLT 2C67 15 ISZERO 2C68 61 PUSH2 0x2c6f 2C6B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2C5F stack[0] = 0x00 } // Block ends with conditional jump to 0x2c6f, if !(stack[-2] - stack[-1] i< 0x20) label_2C6C: // Incoming jump from 0x2C6B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2C6C stack[-1] // @2C6E memory[stack[-1]:stack[-1] + stack[-1]] // } 2C6C 80 DUP1 2C6D 81 DUP2 2C6E FD *REVERT // Stack delta = +0 // Outputs[1] { @2C6E revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2C6F: // Incoming jump from 0x2C6B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2C70 stack[-2] // @2C71 msg.data[stack[-2]:stack[-2] + 0x20] // } 2C6F 5B JUMPDEST 2C70 81 DUP2 2C71 35 CALLDATALOAD 2C72 61 PUSH2 0x1dfb 2C75 81 DUP2 2C76 61 PUSH2 0x3ac7 2C79 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C71 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2C72 stack[1] = 0x1dfb // @2C75 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3ac7, returns to 0x1DFB 2C7A 5B JUMPDEST 2C7B 60 PUSH1 0x00 2C7D 60 PUSH1 0x20 2C7F 82 DUP3 2C80 84 DUP5 2C81 03 SUB 2C82 12 SLT 2C83 15 ISZERO 2C84 61 PUSH2 0x2c8b 2C87 57 *JUMPI 2C88 80 DUP1 2C89 81 DUP2 2C8A FD *REVERT 2C8B 5B JUMPDEST 2C8C 81 DUP2 2C8D 51 MLOAD 2C8E 61 PUSH2 0x1dfb 2C91 81 DUP2 2C92 61 PUSH2 0x3ac7 2C95 56 *JUMP label_2C96: // Incoming jump from 0x0367 // Inputs[2] // { // @2C9C stack[-1] // @2C9D stack[-2] // } 2C96 5B JUMPDEST 2C97 60 PUSH1 0x00 2C99 80 DUP1 2C9A 60 PUSH1 0x80 2C9C 83 DUP4 2C9D 85 DUP6 2C9E 03 SUB 2C9F 12 SLT 2CA0 15 ISZERO 2CA1 61 PUSH2 0x2ca8 2CA4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2C97 stack[0] = 0x00 // @2C99 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2ca8, if !(stack[-2] - stack[-1] i< 0x80) label_2CA5: // Incoming jump from 0x2CA4, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2CA5 stack[-2] // @2CA7 memory[stack[-2]:stack[-2] + stack[-2]] // } 2CA5 81 DUP2 2CA6 82 DUP3 2CA7 FD *REVERT // Stack delta = +0 // Outputs[1] { @2CA7 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2CA8: // Incoming jump from 0x2CA4, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2CA9 stack[-3] // @2CAA msg.data[stack[-3]:stack[-3] + 0x20] // } 2CA8 5B JUMPDEST 2CA9 82 DUP3 2CAA 35 CALLDATALOAD 2CAB 67 PUSH8 0xffffffffffffffff 2CB4 81 DUP2 2CB5 11 GT 2CB6 15 ISZERO 2CB7 61 PUSH2 0x2cbe 2CBA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2CAA stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2cbe, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2CBB: // Incoming jump from 0x2CBA, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2CBB stack[-3] // @2CBD memory[stack[-3]:stack[-3] + stack[-3]] // } 2CBB 82 DUP3 2CBC 83 DUP4 2CBD FD *REVERT // Stack delta = +0 // Outputs[1] { @2CBD revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2CBE: // Incoming jump from 0x2CBA, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2CC2 stack[-5] // @2CC3 stack[-1] // @2CC4 stack[-4] // } 2CBE 5B JUMPDEST 2CBF 61 PUSH2 0x2cca 2CC2 85 DUP6 2CC3 82 DUP3 2CC4 86 DUP7 2CC5 01 ADD 2CC6 61 PUSH2 0x29cf 2CC9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2CBF stack[0] = 0x2cca // @2CC2 stack[1] = stack[-5] // @2CC5 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x29cf, returns to 0x2CCA label_2CCA: // Incoming return from call to 0x29CF at 0x2CC9 // Inputs[4] // { // @2CCB stack[-4] // @2CCB stack[-1] // @2CD1 stack[-6] // @2CD4 stack[-5] // } 2CCA 5B JUMPDEST 2CCB 92 SWAP3 2CCC 50 POP 2CCD 50 POP 2CCE 61 PUSH2 0x2a99 2CD1 84 DUP5 2CD2 60 PUSH1 0x20 2CD4 85 DUP6 2CD5 01 ADD 2CD6 61 PUSH2 0x2901 2CD9 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @2CCB stack[-4] = stack[-1] // @2CCE stack[-2] = 0x2a99 // @2CD1 stack[-1] = stack[-6] // @2CD5 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x2901, returns to 0x2A99 label_2CDA: // Incoming call from 0x03F4, returns to 0x03F5 // Incoming call from 0x025A, returns to 0x025B // Incoming call from 0x04CA, returns to 0x04CB // Incoming call from 0x0354, returns to 0x0355 // Incoming call from 0x0313, returns to 0x0314 // Incoming call from 0x047E, returns to 0x047F // Incoming call from 0x0491, returns to 0x0492 // Incoming call from 0x04E5, returns to 0x04E6 // Incoming call from 0x0531, returns to 0x0532 // Incoming call from 0x02B8, returns to 0x02B9 // Incoming call from 0x03A8, returns to 0x03A9 // Incoming call from 0x0450, returns to 0x0451 // Incoming call from 0x03BB, returns to 0x03BC // Inputs[2] // { // @2CDF stack[-1] // @2CE0 stack[-2] // } 2CDA 5B JUMPDEST 2CDB 60 PUSH1 0x00 2CDD 60 PUSH1 0x20 2CDF 82 DUP3 2CE0 84 DUP5 2CE1 03 SUB 2CE2 12 SLT 2CE3 15 ISZERO 2CE4 61 PUSH2 0x2ceb 2CE7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2CDB stack[0] = 0x00 } // Block ends with conditional jump to 0x2ceb, if !(stack[-2] - stack[-1] i< 0x20) label_2CE8: // Incoming jump from 0x2CE7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2CE8 stack[-1] // @2CEA memory[stack[-1]:stack[-1] + stack[-1]] // } 2CE8 80 DUP1 2CE9 81 DUP2 2CEA FD *REVERT // Stack delta = +0 // Outputs[1] { @2CEA revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2CEB: // Incoming jump from 0x2CE7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2CED stack[-2] // @2CED msg.data[stack[-2]:stack[-2] + 0x20] // @2CEE stack[-4] // @2CEF stack[-3] // } 2CEB 5B JUMPDEST 2CEC 50 POP 2CED 35 CALLDATALOAD 2CEE 91 SWAP2 2CEF 90 SWAP1 2CF0 50 POP 2CF1 56 *JUMP // Stack delta = -3 // Outputs[1] { @2CEE stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2CF2: // Incoming call from 0x050B, returns to 0x050C // Inputs[2] // { // @2CF8 stack[-1] // @2CF9 stack[-2] // } 2CF2 5B JUMPDEST 2CF3 60 PUSH1 0x00 2CF5 80 DUP1 2CF6 60 PUSH1 0x40 2CF8 83 DUP4 2CF9 85 DUP6 2CFA 03 SUB 2CFB 12 SLT 2CFC 15 ISZERO 2CFD 61 PUSH2 0x2d04 2D00 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2CF3 stack[0] = 0x00 // @2CF5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2d04, if !(stack[-2] - stack[-1] i< 0x40) label_2D01: // Incoming jump from 0x2D00, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2D01 stack[-2] // @2D03 memory[stack[-2]:stack[-2] + stack[-2]] // } 2D01 81 DUP2 2D02 82 DUP3 2D03 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D03 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2D04: // Incoming jump from 0x2D00, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2D05 stack[-3] // @2D06 msg.data[stack[-3]:stack[-3] + 0x20] // @2D07 stack[-2] // @2D0C stack[-4] // } 2D04 5B JUMPDEST 2D05 82 DUP3 2D06 35 CALLDATALOAD 2D07 91 SWAP2 2D08 50 POP 2D09 61 PUSH2 0x2a99 2D0C 84 DUP5 2D0D 60 PUSH1 0x20 2D0F 85 DUP6 2D10 01 ADD 2D11 61 PUSH2 0x2881 2D14 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2D07 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @2D09 stack[0] = 0x2a99 // @2D0C stack[1] = stack[-4] // @2D10 stack[2] = stack[-3] + 0x20 // } // Block ends with call to 0x2881, returns to 0x2A99 label_2D15: // Incoming call from 0x032E, returns to 0x032F // Incoming call from 0x0422, returns to 0x0423 // Inputs[2] // { // @2D1D stack[-1] // @2D1E stack[-2] // } 2D15 5B JUMPDEST 2D16 60 PUSH1 0x00 2D18 80 DUP1 2D19 60 PUSH1 0x00 2D1B 60 PUSH1 0x40 2D1D 84 DUP5 2D1E 86 DUP7 2D1F 03 SUB 2D20 12 SLT 2D21 15 ISZERO 2D22 61 PUSH2 0x2d29 2D25 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2D16 stack[0] = 0x00 // @2D18 stack[1] = 0x00 // @2D19 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2d29, if !(stack[-2] - stack[-1] i< 0x40) label_2D26: // Incoming jump from 0x2D25, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2D26 stack[-1] // @2D28 memory[stack[-1]:stack[-1] + stack[-1]] // } 2D26 80 DUP1 2D27 81 DUP2 2D28 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D28 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2D29: // Incoming jump from 0x2D25, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2D2A stack[-4] // @2D2B msg.data[stack[-4]:stack[-4] + 0x20] // @2D2C stack[-3] // @2D32 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2D29 5B JUMPDEST 2D2A 83 DUP4 2D2B 35 CALLDATALOAD 2D2C 92 SWAP3 2D2D 50 POP 2D2E 60 PUSH1 0x20 2D30 84 DUP5 2D31 01 ADD 2D32 35 CALLDATALOAD 2D33 67 PUSH8 0xffffffffffffffff 2D3C 80 DUP1 2D3D 82 DUP3 2D3E 11 GT 2D3F 15 ISZERO 2D40 61 PUSH2 0x2d47 2D43 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2D2C stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @2D32 stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2D33 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2d47, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_2D44: // Incoming jump from 0x2D43, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2D44 stack[-3] // @2D46 memory[stack[-3]:stack[-3] + stack[-3]] // } 2D44 82 DUP3 2D45 83 DUP4 2D46 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D46 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2D47: // Incoming jump from 0x2D43, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2D48 stack[-2] // @2D49 stack[-6] // @2D4B stack[-7] // } 2D47 5B JUMPDEST 2D48 81 DUP2 2D49 86 DUP7 2D4A 01 ADD 2D4B 87 DUP8 2D4C 60 PUSH1 0x1f 2D4E 82 DUP3 2D4F 01 ADD 2D50 12 SLT 2D51 61 PUSH2 0x2d58 2D54 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D4A stack[0] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x2d58, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_2D55: // Incoming jump from 0x2D54, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[2] // { // @2D55 stack[-4] // @2D57 memory[stack[-4]:stack[-4] + stack[-4]] // } 2D55 83 DUP4 2D56 84 DUP5 2D57 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D57 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_2D58: // Incoming jump from 0x2D54, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[4] // { // @2D59 stack[-1] // @2D5A msg.data[stack[-1]:stack[-1] + 0x20] // @2D5B stack[-3] // @2D5D stack[-2] // } 2D58 5B JUMPDEST 2D59 80 DUP1 2D5A 35 CALLDATALOAD 2D5B 92 SWAP3 2D5C 50 POP 2D5D 81 DUP2 2D5E 83 DUP4 2D5F 11 GT 2D60 15 ISZERO 2D61 61 PUSH2 0x2d68 2D64 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2D5B stack[-3] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2d68, if !(msg.data[stack[-1]:stack[-1] + 0x20] > stack[-2]) label_2D65: // Incoming jump from 0x2D64, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > stack[-2]) // Inputs[2] // { // @2D65 stack[-4] // @2D67 memory[stack[-4]:stack[-4] + stack[-4]] // } 2D65 83 DUP4 2D66 84 DUP5 2D67 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D67 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_2D68: // Incoming jump from 0x2D64, if !(msg.data[stack[-1]:stack[-1] + 0x20] > stack[-2]) // Inputs[3] // { // @2D69 stack[-8] // @2D6C stack[-3] // @2D6D stack[-1] // } 2D68 5B JUMPDEST 2D69 87 DUP8 2D6A 60 PUSH1 0x20 2D6C 84 DUP5 2D6D 83 DUP4 2D6E 01 ADD 2D6F 01 ADD 2D70 11 GT 2D71 15 ISZERO 2D72 61 PUSH2 0x2d79 2D75 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d79, if !(stack[-1] + stack[-3] + 0x20 > stack[-8]) label_2D76: // Incoming jump from 0x2D75, if not !(stack[-1] + stack[-3] + 0x20 > stack[-8]) // Inputs[2] // { // @2D76 stack[-4] // @2D78 memory[stack[-4]:stack[-4] + stack[-4]] // } 2D76 83 DUP4 2D77 84 DUP5 2D78 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D78 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_2D79: // Incoming jump from 0x2D75, if !(stack[-1] + stack[-3] + 0x20 > stack[-8]) // Inputs[7] // { // @2D7A stack[-1] // @2D7A stack[-6] // @2D7B stack[-9] // @2D81 stack[-8] // @2D83 stack[-3] // @2D83 stack[-2] // @2D84 stack[-7] // } 2D79 5B JUMPDEST 2D7A 94 SWAP5 2D7B 97 SWAP8 2D7C 60 PUSH1 0x20 2D7E 90 SWAP1 2D7F 95 SWAP6 2D80 01 ADD 2D81 96 SWAP7 2D82 50 POP 2D83 90 SWAP1 2D84 94 SWAP5 2D85 50 POP 2D86 50 POP 2D87 50 POP 2D88 50 POP 2D89 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2D7B stack[-9] = stack[-6] // @2D81 stack[-8] = stack[-1] + 0x20 // @2D84 stack[-7] = stack[-3] // } // Block ends with unconditional jump to stack[-9] label_2D8A: // Incoming call from 0x03E1, returns to 0x03E2 // Inputs[2] // { // @2D8E stack[-1] // @2D8F stack[-2] // } 2D8A 5B JUMPDEST 2D8B 60 PUSH1 0x00 2D8D 80 DUP1 2D8E 82 DUP3 2D8F 84 DUP5 2D90 03 SUB 2D91 60 PUSH1 0x60 2D93 81 DUP2 2D94 12 SLT 2D95 15 ISZERO 2D96 61 PUSH2 0x2d9d 2D99 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2D8B stack[0] = 0x00 // @2D8D stack[1] = 0x00 // @2D90 stack[2] = stack[-2] - stack[-1] // } // Block ends with conditional jump to 0x2d9d, if !(stack[-2] - stack[-1] i< 0x60) label_2D9A: // Incoming jump from 0x2D99, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2D9A stack[-3] // @2D9C memory[stack[-3]:stack[-3] + stack[-3]] // } 2D9A 82 DUP3 2D9B 83 DUP4 2D9C FD *REVERT // Stack delta = +0 // Outputs[1] { @2D9C revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2D9D: // Incoming jump from 0x2D99, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[4] // { // @2D9E stack[-4] // @2D9F msg.data[stack[-4]:stack[-4] + 0x20] // @2DA0 stack[-3] // @2DA7 stack[-1] // } 2D9D 5B JUMPDEST 2D9E 83 DUP4 2D9F 35 CALLDATALOAD 2DA0 92 SWAP3 2DA1 50 POP 2DA2 60 PUSH1 0x40 2DA4 60 PUSH1 0x1f 2DA6 19 NOT 2DA7 82 DUP3 2DA8 01 ADD 2DA9 12 SLT 2DAA 15 ISZERO 2DAB 61 PUSH2 0x2db2 2DAE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2DA0 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] } // Block ends with conditional jump to 0x2db2, if !(stack[-1] + ~0x1f i< 0x40) label_2DAF: // Incoming jump from 0x2DAE, if not !(stack[-1] + ~0x1f i< 0x40) // Inputs[2] // { // @2DAF stack[-2] // @2DB1 memory[stack[-2]:stack[-2] + stack[-2]] // } 2DAF 81 DUP2 2DB0 82 DUP3 2DB1 FD *REVERT // Stack delta = +0 // Outputs[1] { @2DB1 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2DB2: // Incoming jump from 0x2DAE, if !(stack[-1] + ~0x1f i< 0x40) 2DB2 5B JUMPDEST 2DB3 50 POP 2DB4 61 PUSH2 0x2dbd 2DB7 60 PUSH1 0x40 2DB9 61 PUSH2 0x3a5f 2DBC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2DB4 stack[-1] = 0x2dbd // @2DB7 stack[0] = 0x40 // } // Block ends with call to 0x3a5f, returns to 0x2DBD label_2DBD: // Incoming return from call to 0x3A5F at 0x2DBC // Inputs[4] // { // @2DC0 stack[-4] // @2DC2 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2DC3 stack[-1] // @2DC9 msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // } 2DBD 5B JUMPDEST 2DBE 60 PUSH1 0x20 2DC0 84 DUP5 2DC1 01 ADD 2DC2 35 CALLDATALOAD 2DC3 81 DUP2 2DC4 52 MSTORE 2DC5 60 PUSH1 0x40 2DC7 84 DUP5 2DC8 01 ADD 2DC9 35 CALLDATALOAD 2DCA 61 PUSH2 0x2dd2 2DCD 81 DUP2 2DCE 61 PUSH2 0x3ab2 2DD1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2DC4 memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2DC9 stack[0] = msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // @2DCA stack[1] = 0x2dd2 // @2DCD stack[2] = msg.data[stack[-4] + 0x40:stack[-4] + 0x40 + 0x20] // } // Block ends with call to 0x3ab2, returns to 0x2DD2 label_2DD2: // Incoming return from call to 0x3AB2 at 0x2DD1 // Inputs[7] // { // @2DD5 stack[-2] // @2DD7 stack[-1] // @2DD8 stack[-4] // @2DD9 stack[-7] // @2DDB stack[-6] // @2DDD stack[-3] // @2DDE stack[-5] // } 2DD2 5B JUMPDEST 2DD3 60 PUSH1 0x20 2DD5 82 DUP3 2DD6 01 ADD 2DD7 52 MSTORE 2DD8 91 SWAP2 2DD9 94 SWAP5 2DDA 91 SWAP2 2DDB 93 SWAP4 2DDC 50 POP 2DDD 90 SWAP1 2DDE 91 SWAP2 2DDF 50 POP 2DE0 50 POP 2DE1 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2DD7 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @2DD9 stack[-7] = stack[-4] // @2DDB stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_2DE2: // Incoming call from 0x04B7, returns to 0x04B8 // Incoming call from 0x03CE, returns to 0x03CF // Inputs[2] // { // @2DE6 stack[-1] // @2DE7 stack[-2] // } 2DE2 5B JUMPDEST 2DE3 60 PUSH1 0x00 2DE5 80 DUP1 2DE6 82 DUP3 2DE7 84 DUP5 2DE8 03 SUB 2DE9 60 PUSH1 0xc0 2DEB 81 DUP2 2DEC 12 SLT 2DED 15 ISZERO 2DEE 61 PUSH2 0x2df5 2DF1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2DE3 stack[0] = 0x00 // @2DE5 stack[1] = 0x00 // @2DE8 stack[2] = stack[-2] - stack[-1] // } // Block ends with conditional jump to 0x2df5, if !(stack[-2] - stack[-1] i< 0xc0) label_2DF2: // Incoming jump from 0x2DF1, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @2DF2 stack[-3] // @2DF4 memory[stack[-3]:stack[-3] + stack[-3]] // } 2DF2 82 DUP3 2DF3 83 DUP4 2DF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @2DF4 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2DF5: // Incoming jump from 0x2DF1, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[4] // { // @2DF6 stack[-4] // @2DF7 msg.data[stack[-4]:stack[-4] + 0x20] // @2DF8 stack[-3] // @2DFF stack[-1] // } 2DF5 5B JUMPDEST 2DF6 83 DUP4 2DF7 35 CALLDATALOAD 2DF8 92 SWAP3 2DF9 50 POP 2DFA 60 PUSH1 0xa0 2DFC 60 PUSH1 0x1f 2DFE 19 NOT 2DFF 82 DUP3 2E00 01 ADD 2E01 12 SLT 2E02 15 ISZERO 2E03 61 PUSH2 0x2e0a 2E06 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2DF8 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] } // Block ends with conditional jump to 0x2e0a, if !(stack[-1] + ~0x1f i< 0xa0) label_2E07: // Incoming jump from 0x2E06, if not !(stack[-1] + ~0x1f i< 0xa0) // Inputs[2] // { // @2E07 stack[-2] // @2E09 memory[stack[-2]:stack[-2] + stack[-2]] // } 2E07 81 DUP2 2E08 82 DUP3 2E09 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E09 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2E0A: // Incoming jump from 0x2E06, if !(stack[-1] + ~0x1f i< 0xa0) 2E0A 5B JUMPDEST 2E0B 50 POP 2E0C 61 PUSH2 0x2e15 2E0F 60 PUSH1 0xa0 2E11 61 PUSH2 0x3a5f 2E14 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2E0C stack[-1] = 0x2e15 // @2E0F stack[0] = 0xa0 // } // Block ends with call to 0x3a5f, returns to 0x2E15 label_2E15: // Incoming return from call to 0x3A5F at 0x2E14 // Inputs[4] // { // @2E18 stack[-4] // @2E1A msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2E1B stack[-1] // @2E20 stack[-5] // } 2E15 5B JUMPDEST 2E16 60 PUSH1 0x20 2E18 84 DUP5 2E19 01 ADD 2E1A 35 CALLDATALOAD 2E1B 81 DUP2 2E1C 52 MSTORE 2E1D 61 PUSH2 0x2e29 2E20 85 DUP6 2E21 60 PUSH1 0x40 2E23 86 DUP7 2E24 01 ADD 2E25 61 PUSH2 0x2881 2E28 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2E1C memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2E1D stack[0] = 0x2e29 // @2E20 stack[1] = stack[-5] // @2E24 stack[2] = stack[-4] + 0x40 // } // Block ends with call to 0x2881, returns to 0x2E29 label_2E29: // Incoming return from call to 0x2881 at 0x2E28 // Inputs[4] // { // @2E2C stack[-2] // @2E2E stack[-1] // @2E32 stack[-6] // @2E35 stack[-5] // } 2E29 5B JUMPDEST 2E2A 60 PUSH1 0x20 2E2C 82 DUP3 2E2D 01 ADD 2E2E 52 MSTORE 2E2F 61 PUSH2 0x2e3b 2E32 85 DUP6 2E33 60 PUSH1 0x60 2E35 86 DUP7 2E36 01 ADD 2E37 61 PUSH2 0x2881 2E3A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2E2E memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @2E2F stack[-1] = 0x2e3b // @2E32 stack[0] = stack[-6] // @2E36 stack[1] = stack[-5] + 0x60 // } // Block ends with call to 0x2881, returns to 0x2E3B label_2E3B: // Incoming return from call to 0x2881 at 0x2E3A // Inputs[4] // { // @2E3E stack[-2] // @2E40 stack[-1] // @2E44 stack[-6] // @2E47 stack[-5] // } 2E3B 5B JUMPDEST 2E3C 60 PUSH1 0x40 2E3E 82 DUP3 2E3F 01 ADD 2E40 52 MSTORE 2E41 61 PUSH2 0x2e4d 2E44 85 DUP6 2E45 60 PUSH1 0x80 2E47 86 DUP7 2E48 01 ADD 2E49 61 PUSH2 0x2881 2E4C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2E40 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = stack[-1] // @2E41 stack[-1] = 0x2e4d // @2E44 stack[0] = stack[-6] // @2E48 stack[1] = stack[-5] + 0x80 // } // Block ends with call to 0x2881, returns to 0x2E4D label_2E4D: // Incoming return from call to 0x2881 at 0x2E4C // Inputs[4] // { // @2E50 stack[-2] // @2E52 stack[-1] // @2E56 stack[-6] // @2E59 stack[-5] // } 2E4D 5B JUMPDEST 2E4E 60 PUSH1 0x60 2E50 82 DUP3 2E51 01 ADD 2E52 52 MSTORE 2E53 61 PUSH2 0x2e5f 2E56 85 DUP6 2E57 60 PUSH1 0xa0 2E59 86 DUP7 2E5A 01 ADD 2E5B 61 PUSH2 0x2954 2E5E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2E52 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = stack[-1] // @2E53 stack[-1] = 0x2e5f // @2E56 stack[0] = stack[-6] // @2E5A stack[1] = stack[-5] + 0xa0 // } // Block ends with call to 0x2954, returns to 0x2E5F label_2E5F: // Incoming return from call to 0x2954 at 0x2E5E // Inputs[7] // { // @2E62 stack[-2] // @2E64 stack[-1] // @2E66 stack[-3] // @2E69 stack[-6] // @2E6B stack[-4] // @2E6B stack[-7] // @2E6C stack[-5] // } 2E5F 5B JUMPDEST 2E60 60 PUSH1 0x80 2E62 82 DUP3 2E63 01 ADD 2E64 52 MSTORE 2E65 80 DUP1 2E66 91 SWAP2 2E67 50 POP 2E68 50 POP 2E69 92 SWAP3 2E6A 50 POP 2E6B 92 SWAP3 2E6C 90 SWAP1 2E6D 50 POP 2E6E 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2E64 memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] = stack[-1] // @2E69 stack[-6] = stack[-2] // @2E6B stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2E6F: // Incoming call from 0x30D2, returns to 0x0C9E // Inputs[3] // { // @2E72 stack[-1] // @2E73 memory[stack[-1]:stack[-1] + 0x20] // @2E75 stack[-2] // } 2E6F 5B JUMPDEST 2E70 60 PUSH1 0x00 2E72 81 DUP2 2E73 51 MLOAD 2E74 80 DUP1 2E75 84 DUP5 2E76 52 MSTORE 2E77 61 PUSH2 0x2e87 2E7A 81 DUP2 2E7B 60 PUSH1 0x20 2E7D 86 DUP7 2E7E 01 ADD 2E7F 60 PUSH1 0x20 2E81 86 DUP7 2E82 01 ADD 2E83 61 PUSH2 0x3a86 2E86 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2E70 stack[0] = 0x00 // @2E73 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2E76 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2E77 stack[2] = 0x2e87 // @2E7A stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2E7E stack[4] = stack[-2] + 0x20 // @2E82 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x3a86, returns to 0x2E87 label_2E87: // Incoming return from call to 0x3A86 at 0x2E86 // Inputs[4] // { // @2E8A stack[-1] // @2E8F stack[-4] // @2E90 stack[-2] // @2E96 stack[-5] // } 2E87 5B JUMPDEST 2E88 60 PUSH1 0x1f 2E8A 01 ADD 2E8B 60 PUSH1 0x1f 2E8D 19 NOT 2E8E 16 AND 2E8F 92 SWAP3 2E90 90 SWAP1 2E91 92 SWAP3 2E92 01 ADD 2E93 60 PUSH1 0x20 2E95 01 ADD 2E96 92 SWAP3 2E97 91 SWAP2 2E98 50 POP 2E99 50 POP 2E9A 56 *JUMP // Stack delta = -4 // Outputs[1] { @2E96 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 2E9B 5B JUMPDEST 2E9C 80 DUP1 2E9D 51 MLOAD 2E9E 82 DUP3 2E9F 52 MSTORE 2EA0 60 PUSH1 0x20 2EA2 80 DUP1 2EA3 82 DUP3 2EA4 01 ADD 2EA5 51 MLOAD 2EA6 60 PUSH1 0x01 2EA8 60 PUSH1 0x01 2EAA 60 PUSH1 0xa0 2EAC 1B SHL 2EAD 03 SUB 2EAE 90 SWAP1 2EAF 81 DUP2 2EB0 16 AND 2EB1 91 SWAP2 2EB2 84 DUP5 2EB3 01 ADD 2EB4 91 SWAP2 2EB5 90 SWAP1 2EB6 91 SWAP2 2EB7 52 MSTORE 2EB8 60 PUSH1 0x40 2EBA 80 DUP1 2EBB 83 DUP4 2EBC 01 ADD 2EBD 51 MLOAD 2EBE 82 DUP3 2EBF 16 AND 2EC0 90 SWAP1 2EC1 84 DUP5 2EC2 01 ADD 2EC3 52 MSTORE 2EC4 60 PUSH1 0x60 2EC6 80 DUP1 2EC7 83 DUP4 2EC8 01 ADD 2EC9 51 MLOAD 2ECA 90 SWAP1 2ECB 91 SWAP2 2ECC 16 AND 2ECD 90 SWAP1 2ECE 83 DUP4 2ECF 01 ADD 2ED0 52 MSTORE 2ED1 60 PUSH1 0x80 2ED3 90 SWAP1 2ED4 81 DUP2 2ED5 01 ADD 2ED6 51 MLOAD 2ED7 51 MLOAD 2ED8 91 SWAP2 2ED9 01 ADD 2EDA 52 MSTORE 2EDB 56 *JUMP 2EDC 5B JUMPDEST 2EDD 60 PUSH1 0x00 2EDF 82 DUP3 2EE0 51 MLOAD 2EE1 61 PUSH2 0x2eee 2EE4 81 DUP2 2EE5 84 DUP5 2EE6 60 PUSH1 0x20 2EE8 87 DUP8 2EE9 01 ADD 2EEA 61 PUSH2 0x3a86 2EED 56 *JUMP 2EEE 5B JUMPDEST 2EEF 91 SWAP2 2EF0 90 SWAP1 2EF1 91 SWAP2 2EF2 01 ADD 2EF3 92 SWAP3 2EF4 91 SWAP2 2EF5 50 POP 2EF6 50 POP 2EF7 56 *JUMP label_2EF8: // Incoming call from 0x125C, returns to 0x125D // Inputs[4] // { // @2EFF stack[-1] // @2F05 stack[-3] // @2F0D stack[-2] // @2F11 stack[-4] // } 2EF8 5B JUMPDEST 2EF9 61 PUSH2 0x1901 2EFC 60 PUSH1 0xf0 2EFE 1B SHL 2EFF 81 DUP2 2F00 52 MSTORE 2F01 60 PUSH1 0x02 2F03 81 DUP2 2F04 01 ADD 2F05 92 SWAP3 2F06 90 SWAP1 2F07 92 SWAP3 2F08 52 MSTORE 2F09 60 PUSH1 0x22 2F0B 82 DUP3 2F0C 01 ADD 2F0D 52 MSTORE 2F0E 60 PUSH1 0x42 2F10 01 ADD 2F11 90 SWAP1 2F12 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @2F00 memory[stack[-1]:stack[-1] + 0x20] = 0x1901 << 0xf0 // @2F08 memory[stack[-1] + 0x02:stack[-1] + 0x02 + 0x20] = stack[-3] // @2F0D memory[stack[-1] + 0x22:stack[-1] + 0x22 + 0x20] = stack[-2] // @2F11 stack[-4] = 0x42 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_2F13: // Incoming call from 0x18F6, returns to 0x18F7 // Inputs[2] // { // @2F35 stack[-1] // @2F7B stack[-2] // } 2F13 5B JUMPDEST 2F14 7F PUSH32 0x454950373132446f6d61696e28737472696e67206e616d652c737472696e6720 2F35 81 DUP2 2F36 52 MSTORE 2F37 7F PUSH32 0x76657273696f6e2c75696e7432353620636861696e49642c6164647265737320 2F58 60 PUSH1 0x20 2F5A 82 DUP3 2F5B 01 ADD 2F5C 52 MSTORE 2F5D 71 PUSH18 0x766572696679696e67436f6e747261637429 2F70 60 PUSH1 0x70 2F72 1B SHL 2F73 60 PUSH1 0x40 2F75 82 DUP3 2F76 01 ADD 2F77 52 MSTORE 2F78 60 PUSH1 0x52 2F7A 01 ADD 2F7B 90 SWAP1 2F7C 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2F36 memory[stack[-1]:stack[-1] + 0x20] = 0x454950373132446f6d61696e28737472696e67206e616d652c737472696e6720 // @2F5C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x76657273696f6e2c75696e7432353620636861696e49642c6164647265737320 // @2F77 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x766572696679696e67436f6e747261637429 << 0x70 // @2F7B stack[-2] = 0x52 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2F7D: // Incoming call from 0x02CA, returns to 0x026D // Inputs[3] // { // @2F86 stack[-2] // @2F87 stack[-1] // @2F8F stack[-3] // } 2F7D 5B JUMPDEST 2F7E 60 PUSH1 0x01 2F80 60 PUSH1 0x01 2F82 60 PUSH1 0xa0 2F84 1B SHL 2F85 03 SUB 2F86 91 SWAP2 2F87 90 SWAP1 2F88 91 SWAP2 2F89 16 AND 2F8A 81 DUP2 2F8B 52 MSTORE 2F8C 60 PUSH1 0x20 2F8E 01 ADD 2F8F 90 SWAP1 2F90 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2F8B memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @2F8F stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 2F91 5B JUMPDEST 2F92 60 PUSH1 0x01 2F94 60 PUSH1 0x01 2F96 60 PUSH1 0xa0 2F98 1B SHL 2F99 03 SUB 2F9A 85 DUP6 2F9B 81 DUP2 2F9C 16 AND 2F9D 82 DUP3 2F9E 52 MSTORE 2F9F 84 DUP5 2FA0 16 AND 2FA1 60 PUSH1 0x20 2FA3 82 DUP3 2FA4 01 ADD 2FA5 52 MSTORE 2FA6 60 PUSH1 0x40 2FA8 81 DUP2 2FA9 01 ADD 2FAA 83 DUP4 2FAB 90 SWAP1 2FAC 52 MSTORE 2FAD 60 PUSH1 0x80 2FAF 60 PUSH1 0x60 2FB1 82 DUP3 2FB2 01 ADD 2FB3 81 DUP2 2FB4 90 SWAP1 2FB5 52 MSTORE 2FB6 60 PUSH1 0x00 2FB8 90 SWAP1 2FB9 61 PUSH2 0x2fc4 2FBC 90 SWAP1 2FBD 83 DUP4 2FBE 01 ADD 2FBF 84 DUP5 2FC0 61 PUSH2 0x2e6f 2FC3 56 *JUMP 2FC4 5B JUMPDEST 2FC5 96 SWAP7 2FC6 95 SWAP6 2FC7 50 POP 2FC8 50 POP 2FC9 50 POP 2FCA 50 POP 2FCB 50 POP 2FCC 50 POP 2FCD 56 *JUMP 2FCE 5B JUMPDEST 2FCF 60 PUSH1 0x01 2FD1 60 PUSH1 0x01 2FD3 60 PUSH1 0xa0 2FD5 1B SHL 2FD6 03 SUB 2FD7 84 DUP5 2FD8 16 AND 2FD9 81 DUP2 2FDA 52 MSTORE 2FDB 60 PUSH1 0x40 2FDD 60 PUSH1 0x20 2FDF 82 DUP3 2FE0 01 ADD 2FE1 81 DUP2 2FE2 90 SWAP1 2FE3 52 MSTORE 2FE4 81 DUP2 2FE5 01 ADD 2FE6 82 DUP3 2FE7 90 SWAP1 2FE8 52 MSTORE 2FE9 60 PUSH1 0x00 2FEB 82 DUP3 2FEC 84 DUP5 2FED 60 PUSH1 0x60 2FEF 84 DUP5 2FF0 01 ADD 2FF1 37 CALLDATACOPY 2FF2 81 DUP2 2FF3 83 DUP4 2FF4 01 ADD 2FF5 60 PUSH1 0x60 2FF7 90 SWAP1 2FF8 81 DUP2 2FF9 01 ADD 2FFA 91 SWAP2 2FFB 90 SWAP1 2FFC 91 SWAP2 2FFD 52 MSTORE 2FFE 60 PUSH1 0x1f 3000 90 SWAP1 3001 92 SWAP3 3002 01 ADD 3003 60 PUSH1 0x1f 3005 19 NOT 3006 16 AND 3007 01 ADD 3008 01 ADD 3009 92 SWAP3 300A 91 SWAP2 300B 50 POP 300C 50 POP 300D 56 *JUMP label_300E: // Incoming call from 0x1471, returns to 0x1472 // Incoming call from 0x0295, returns to 0x026D // Inputs[3] // { // @300F stack[-1] // @300F stack[-2] // @3017 stack[-3] // } 300E 5B JUMPDEST 300F 90 SWAP1 3010 15 ISZERO 3011 15 ISZERO 3012 81 DUP2 3013 52 MSTORE 3014 60 PUSH1 0x20 3016 01 ADD 3017 90 SWAP1 3018 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3013 memory[stack[-1]:stack[-1] + 0x20] = !!stack[-2] // @3017 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3019: // Incoming call from 0x026C, returns to 0x026D // Inputs[3] // { // @301A stack[-1] // @301A stack[-2] // @3020 stack[-3] // } 3019 5B JUMPDEST 301A 90 SWAP1 301B 81 DUP2 301C 52 MSTORE 301D 60 PUSH1 0x20 301F 01 ADD 3020 90 SWAP1 3021 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @301C memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @3020 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 3022 5B JUMPDEST 3023 94 SWAP5 3024 85 DUP6 3025 52 MSTORE 3026 60 PUSH1 0x01 3028 60 PUSH1 0x01 302A 60 PUSH1 0xa0 302C 1B SHL 302D 03 SUB 302E 93 SWAP4 302F 90 SWAP1 3030 93 SWAP4 3031 16 AND 3032 60 PUSH1 0x20 3034 85 DUP6 3035 01 ADD 3036 52 MSTORE 3037 60 PUSH1 0x40 3039 84 DUP5 303A 01 ADD 303B 91 SWAP2 303C 90 SWAP1 303D 91 SWAP2 303E 52 MSTORE 303F 60 PUSH1 0x60 3041 83 DUP4 3042 01 ADD 3043 52 MSTORE 3044 60 PUSH1 0x80 3046 82 DUP3 3047 01 ADD 3048 52 MSTORE 3049 60 PUSH1 0xa0 304B 01 ADD 304C 90 SWAP1 304D 56 *JUMP label_304E: // Incoming call from 0x197F, returns to 0x1980 // Inputs[7] // { // @304F stack[-1] // @304F stack[-6] // @3056 stack[-5] // @3057 stack[-2] // @305E stack[-4] // @305F stack[-3] // @3078 stack[-7] // } 304E 5B JUMPDEST 304F 94 SWAP5 3050 85 DUP6 3051 52 MSTORE 3052 60 PUSH1 0x20 3054 85 DUP6 3055 01 ADD 3056 93 SWAP4 3057 90 SWAP1 3058 93 SWAP4 3059 52 MSTORE 305A 60 PUSH1 0x40 305C 84 DUP5 305D 01 ADD 305E 91 SWAP2 305F 90 SWAP1 3060 91 SWAP2 3061 52 MSTORE 3062 60 PUSH1 0x60 3064 83 DUP4 3065 01 ADD 3066 52 MSTORE 3067 60 PUSH1 0x01 3069 60 PUSH1 0x01 306B 60 PUSH1 0xa0 306D 1B SHL 306E 03 SUB 306F 16 AND 3070 60 PUSH1 0x80 3072 82 DUP3 3073 01 ADD 3074 52 MSTORE 3075 60 PUSH1 0xa0 3077 01 ADD 3078 90 SWAP1 3079 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @3051 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // @3059 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] // @3061 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @3066 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-3] // @3074 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @3078 stack[-7] = 0xa0 + stack[-1] // } // Block ends with unconditional jump to stack[-7] label_307A: // Incoming call from 0x1235, returns to 0x1236 // Inputs[8] // { // @307B stack[-1] // @307B stack[-7] // @3082 stack[-6] // @3083 stack[-2] // @308A stack[-5] // @308B stack[-3] // @3092 stack[-4] // @30A0 stack[-8] // } 307A 5B JUMPDEST 307B 95 SWAP6 307C 86 DUP7 307D 52 MSTORE 307E 60 PUSH1 0x20 3080 86 DUP7 3081 01 ADD 3082 94 SWAP5 3083 90 SWAP1 3084 94 SWAP5 3085 52 MSTORE 3086 60 PUSH1 0x40 3088 85 DUP6 3089 01 ADD 308A 92 SWAP3 308B 90 SWAP1 308C 92 SWAP3 308D 52 MSTORE 308E 60 PUSH1 0x60 3090 84 DUP5 3091 01 ADD 3092 52 MSTORE 3093 60 PUSH1 0x80 3095 83 DUP4 3096 01 ADD 3097 52 MSTORE 3098 60 PUSH1 0xa0 309A 82 DUP3 309B 01 ADD 309C 52 MSTORE 309D 60 PUSH1 0xc0 309F 01 ADD 30A0 90 SWAP1 30A1 56 *JUMP // Stack delta = -7 // Outputs[7] // { // @307D memory[stack[-1]:stack[-1] + 0x20] = stack[-7] // @3085 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-6] // @308D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-5] // @3092 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-4] // @3097 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = stack[-3] // @309C memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] = stack[-2] // @30A0 stack[-8] = 0xc0 + stack[-1] // } // Block ends with unconditional jump to stack[-8] label_30A2: // Incoming call from 0x12A5, returns to 0x12A6 // Inputs[6] // { // @30A3 stack[-1] // @30A3 stack[-5] // @30A8 stack[-4] // @30A9 stack[-2] // @30B5 stack[-3] // @30BE stack[-6] // } 30A2 5B JUMPDEST 30A3 93 SWAP4 30A4 84 DUP5 30A5 52 MSTORE 30A6 60 PUSH1 0xff 30A8 92 SWAP3 30A9 90 SWAP1 30AA 92 SWAP3 30AB 16 AND 30AC 60 PUSH1 0x20 30AE 84 DUP5 30AF 01 ADD 30B0 52 MSTORE 30B1 60 PUSH1 0x40 30B3 83 DUP4 30B4 01 ADD 30B5 52 MSTORE 30B6 60 PUSH1 0x60 30B8 82 DUP3 30B9 01 ADD 30BA 52 MSTORE 30BB 60 PUSH1 0x80 30BD 01 ADD 30BE 90 SWAP1 30BF 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @30A5 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] // @30B0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0xff & stack[-4] // @30B5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @30BA memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-2] // @30BE stack[-6] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-6] label_30C0: // Incoming jump from 0x02AA // Incoming jump from 0x21F0 // Inputs[2] // { // @30C5 stack[-1] // @30CE stack[-2] // } 30C0 5B JUMPDEST 30C1 60 PUSH1 0x00 30C3 60 PUSH1 0x20 30C5 82 DUP3 30C6 52 MSTORE 30C7 61 PUSH2 0x0c9e 30CA 60 PUSH1 0x20 30CC 83 DUP4 30CD 01 ADD 30CE 84 DUP5 30CF 61 PUSH2 0x2e6f 30D2 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @30C1 stack[0] = 0x00 // @30C6 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @30C7 stack[1] = 0x0c9e // @30CD stack[2] = stack[-1] + 0x20 // @30CE stack[3] = stack[-2] // } // Block ends with call to 0x2e6f, returns to 0x0C9E label_30D3: // Incoming call from 0x2069, returns to 0x0626 // Inputs[2] // { // @30D7 stack[-1] // @3113 stack[-2] // } 30D3 5B JUMPDEST 30D4 60 PUSH1 0x20 30D6 80 DUP1 30D7 82 DUP3 30D8 52 MSTORE 30D9 60 PUSH1 0x22 30DB 90 SWAP1 30DC 82 DUP3 30DD 01 ADD 30DE 52 MSTORE 30DF 7F PUSH32 0x456e756d657261626c655365743a20696e646578206f7574206f6620626f756e 3100 60 PUSH1 0x40 3102 82 DUP3 3103 01 ADD 3104 52 MSTORE 3105 61 PUSH2 0x6473 3108 60 PUSH1 0xf0 310A 1B SHL 310B 60 PUSH1 0x60 310D 82 DUP3 310E 01 ADD 310F 52 MSTORE 3110 60 PUSH1 0x80 3112 01 ADD 3113 90 SWAP1 3114 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @30D8 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @30DE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @3104 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x456e756d657261626c655365743a20696e646578206f7574206f6620626f756e // @310F memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6473 << 0xf0 // @3113 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3115: // Incoming call from 0x169B, returns to 0x0626 // Incoming call from 0x1542, returns to 0x0626 // Incoming call from 0x0943, returns to 0x0626 // Inputs[2] // { // @3119 stack[-1] // @315B stack[-2] // } 3115 5B JUMPDEST 3116 60 PUSH1 0x20 3118 80 DUP1 3119 82 DUP3 311A 52 MSTORE 311B 60 PUSH1 0x28 311D 90 SWAP1 311E 82 DUP3 311F 01 ADD 3120 52 MSTORE 3121 7F PUSH32 0x4d656469613a20746f6b656e2077697468207468617420696420646f6573206e 3142 60 PUSH1 0x40 3144 82 DUP3 3145 01 ADD 3146 52 MSTORE 3147 67 PUSH8 0x1bdd08195e1a5cdd 3150 60 PUSH1 0xc2 3152 1B SHL 3153 60 PUSH1 0x60 3155 82 DUP3 3156 01 ADD 3157 52 MSTORE 3158 60 PUSH1 0x80 315A 01 ADD 315B 90 SWAP1 315C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @311A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3120 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @3146 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a20746f6b656e2077697468207468617420696420646f6573206e // @3157 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1bdd08195e1a5cdd << 0xc2 // @315B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 315D 5B JUMPDEST 315E 60 PUSH1 0x20 3160 80 DUP1 3161 82 DUP3 3162 52 MSTORE 3163 60 PUSH1 0x32 3165 90 SWAP1 3166 82 DUP3 3167 01 ADD 3168 52 MSTORE 3169 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 318A 60 PUSH1 0x40 318C 82 DUP3 318D 01 ADD 318E 52 MSTORE 318F 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 31A2 60 PUSH1 0x71 31A4 1B SHL 31A5 60 PUSH1 0x60 31A7 82 DUP3 31A8 01 ADD 31A9 52 MSTORE 31AA 60 PUSH1 0x80 31AC 01 ADD 31AD 90 SWAP1 31AE 56 *JUMP 31AF 5B JUMPDEST 31B0 60 PUSH1 0x20 31B2 80 DUP1 31B3 82 DUP3 31B4 52 MSTORE 31B5 60 PUSH1 0x1c 31B7 90 SWAP1 31B8 82 DUP3 31B9 01 ADD 31BA 52 MSTORE 31BB 7F PUSH32 0x4d656469613a207370656e6465722063616e6e6f742062652030783000000000 31DC 60 PUSH1 0x40 31DE 82 DUP3 31DF 01 ADD 31E0 52 MSTORE 31E1 60 PUSH1 0x60 31E3 01 ADD 31E4 90 SWAP1 31E5 56 *JUMP 31E6 5B JUMPDEST 31E7 60 PUSH1 0x20 31E9 80 DUP1 31EA 82 DUP3 31EB 52 MSTORE 31EC 60 PUSH1 0x1c 31EE 90 SWAP1 31EF 82 DUP3 31F0 01 ADD 31F1 52 MSTORE 31F2 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 3213 60 PUSH1 0x40 3215 82 DUP3 3216 01 ADD 3217 52 MSTORE 3218 60 PUSH1 0x60 321A 01 ADD 321B 90 SWAP1 321C 56 *JUMP 321D 5B JUMPDEST 321E 60 PUSH1 0x20 3220 80 DUP1 3221 82 DUP3 3222 52 MSTORE 3223 60 PUSH1 0x21 3225 90 SWAP1 3226 82 DUP3 3227 01 ADD 3228 52 MSTORE 3229 7F PUSH32 0x4d61726b65743a20426964646572206d757374206265206d73672073656e6465 324A 60 PUSH1 0x40 324C 82 DUP3 324D 01 ADD 324E 52 MSTORE 324F 60 PUSH1 0x39 3251 60 PUSH1 0xf9 3253 1B SHL 3254 60 PUSH1 0x60 3256 82 DUP3 3257 01 ADD 3258 52 MSTORE 3259 60 PUSH1 0x80 325B 01 ADD 325C 90 SWAP1 325D 56 *JUMP 325E 5B JUMPDEST 325F 60 PUSH1 0x20 3261 80 DUP1 3262 82 DUP3 3263 52 MSTORE 3264 60 PUSH1 0x22 3266 90 SWAP1 3267 82 DUP3 3268 01 ADD 3269 52 MSTORE 326A 7F PUSH32 0x4d656469613a2063616c6c6572206e6f7420617070726f766564206164647265 328B 60 PUSH1 0x40 328D 82 DUP3 328E 01 ADD 328F 52 MSTORE 3290 61 PUSH2 0x7373 3293 60 PUSH1 0xf0 3295 1B SHL 3296 60 PUSH1 0x60 3298 82 DUP3 3299 01 ADD 329A 52 MSTORE 329B 60 PUSH1 0x80 329D 01 ADD 329E 90 SWAP1 329F 56 *JUMP 32A0 5B JUMPDEST 32A1 60 PUSH1 0x20 32A3 80 DUP1 32A4 82 DUP3 32A5 52 MSTORE 32A6 60 PUSH1 0x24 32A8 90 SWAP1 32A9 82 DUP3 32AA 01 ADD 32AB 52 MSTORE 32AC 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 32CD 60 PUSH1 0x40 32CF 82 DUP3 32D0 01 ADD 32D1 52 MSTORE 32D2 63 PUSH4 0x72657373 32D7 60 PUSH1 0xe0 32D9 1B SHL 32DA 60 PUSH1 0x60 32DC 82 DUP3 32DD 01 ADD 32DE 52 MSTORE 32DF 60 PUSH1 0x80 32E1 01 ADD 32E2 90 SWAP1 32E3 56 *JUMP label_32E4: // Incoming call from 0x13E8, returns to 0x0626 // Inputs[2] // { // @32E8 stack[-1] // @3319 stack[-2] // } 32E4 5B JUMPDEST 32E5 60 PUSH1 0x20 32E7 80 DUP1 32E8 82 DUP3 32E9 52 MSTORE 32EA 60 PUSH1 0x19 32EC 90 SWAP1 32ED 82 DUP3 32EE 01 ADD 32EF 52 MSTORE 32F0 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 3311 60 PUSH1 0x40 3313 82 DUP3 3314 01 ADD 3315 52 MSTORE 3316 60 PUSH1 0x60 3318 01 ADD 3319 90 SWAP1 331A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @32E9 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @32EF memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x19 // @3315 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @3319 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 331B 5B JUMPDEST 331C 60 PUSH1 0x20 331E 80 DUP1 331F 82 DUP3 3320 52 MSTORE 3321 60 PUSH1 0x2f 3323 90 SWAP1 3324 82 DUP3 3325 01 ADD 3326 52 MSTORE 3327 7F PUSH32 0x4d656469613a20746f6b656e20646f6573206e6f742068617665206861736820 3348 60 PUSH1 0x40 334A 82 DUP3 334B 01 ADD 334C 52 MSTORE 334D 6E PUSH15 0x6f6620697473206d65746164617461 335D 60 PUSH1 0x88 335F 1B SHL 3360 60 PUSH1 0x60 3362 82 DUP3 3363 01 ADD 3364 52 MSTORE 3365 60 PUSH1 0x80 3367 01 ADD 3368 90 SWAP1 3369 56 *JUMP label_336A: // Incoming call from 0x1B44, returns to 0x0626 // Inputs[2] // { // @336E stack[-1] // @33AC stack[-2] // } 336A 5B JUMPDEST 336B 60 PUSH1 0x20 336D 80 DUP1 336E 82 DUP3 336F 52 MSTORE 3370 60 PUSH1 0x24 3372 90 SWAP1 3373 82 DUP3 3374 01 ADD 3375 52 MSTORE 3376 7F PUSH32 0x4d656469613a20636f6e74656e742068617368206d757374206265206e6f6e2d 3397 60 PUSH1 0x40 3399 82 DUP3 339A 01 ADD 339B 52 MSTORE 339C 63 PUSH4 0x7a65726f 33A1 60 PUSH1 0xe0 33A3 1B SHL 33A4 60 PUSH1 0x60 33A6 82 DUP3 33A7 01 ADD 33A8 52 MSTORE 33A9 60 PUSH1 0x80 33AB 01 ADD 33AC 90 SWAP1 33AD 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @336F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3375 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x24 // @339B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a20636f6e74656e742068617368206d757374206265206e6f6e2d // @33A8 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x7a65726f << 0xe0 // @33AC stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 33AE 5B JUMPDEST 33AF 60 PUSH1 0x20 33B1 80 DUP1 33B2 82 DUP3 33B3 52 MSTORE 33B4 60 PUSH1 0x2c 33B6 90 SWAP1 33B7 82 DUP3 33B8 01 ADD 33B9 52 MSTORE 33BA 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 33DB 60 PUSH1 0x40 33DD 82 DUP3 33DE 01 ADD 33DF 52 MSTORE 33E0 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 33ED 60 PUSH1 0xa1 33EF 1B SHL 33F0 60 PUSH1 0x60 33F2 82 DUP3 33F3 01 ADD 33F4 52 MSTORE 33F5 60 PUSH1 0x80 33F7 01 ADD 33F8 90 SWAP1 33F9 56 *JUMP 33FA 5B JUMPDEST 33FB 60 PUSH1 0x20 33FD 80 DUP1 33FE 82 DUP3 33FF 52 MSTORE 3400 60 PUSH1 0x38 3402 90 SWAP1 3403 82 DUP3 3404 01 ADD 3405 52 MSTORE 3406 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 3427 60 PUSH1 0x40 3429 82 DUP3 342A 01 ADD 342B 52 MSTORE 342C 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 344D 60 PUSH1 0x60 344F 82 DUP3 3450 01 ADD 3451 52 MSTORE 3452 60 PUSH1 0x80 3454 01 ADD 3455 90 SWAP1 3456 56 *JUMP 3457 5B JUMPDEST 3458 60 PUSH1 0x20 345A 80 DUP1 345B 82 DUP3 345C 52 MSTORE 345D 60 PUSH1 0x2a 345F 90 SWAP1 3460 82 DUP3 3461 01 ADD 3462 52 MSTORE 3463 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 3484 60 PUSH1 0x40 3486 82 DUP3 3487 01 ADD 3488 52 MSTORE 3489 69 PUSH10 0x726f2061646472657373 3494 60 PUSH1 0xb0 3496 1B SHL 3497 60 PUSH1 0x60 3499 82 DUP3 349A 01 ADD 349B 52 MSTORE 349C 60 PUSH1 0x80 349E 01 ADD 349F 90 SWAP1 34A0 56 *JUMP 34A1 5B JUMPDEST 34A2 60 PUSH1 0x20 34A4 80 DUP1 34A5 82 DUP3 34A6 52 MSTORE 34A7 60 PUSH1 0x15 34A9 90 SWAP1 34AA 82 DUP3 34AB 01 ADD 34AC 52 MSTORE 34AD 74 PUSH21 0x1359591a584e8814195c9b5a5d08195e1c1a5c9959 34C3 60 PUSH1 0x5a 34C5 1B SHL 34C6 60 PUSH1 0x40 34C8 82 DUP3 34C9 01 ADD 34CA 52 MSTORE 34CB 60 PUSH1 0x60 34CD 01 ADD 34CE 90 SWAP1 34CF 56 *JUMP label_34D0: // Incoming call from 0x1B76, returns to 0x0626 // Inputs[2] // { // @34D4 stack[-1] // @352B stack[-2] // } 34D0 5B JUMPDEST 34D1 60 PUSH1 0x20 34D3 80 DUP1 34D4 82 DUP3 34D5 52 MSTORE 34D6 60 PUSH1 0x3e 34D8 90 SWAP1 34D9 82 DUP3 34DA 01 ADD 34DB 52 MSTORE 34DC 7F PUSH32 0x4d656469613a206120746f6b656e2068617320616c7265616479206265656e20 34FD 60 PUSH1 0x40 34FF 82 DUP3 3500 01 ADD 3501 52 MSTORE 3502 7F PUSH32 0x637265617465642077697468207468697320636f6e74656e7420686173680000 3523 60 PUSH1 0x60 3525 82 DUP3 3526 01 ADD 3527 52 MSTORE 3528 60 PUSH1 0x80 352A 01 ADD 352B 90 SWAP1 352C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @34D5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @34DB memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x3e // @3501 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a206120746f6b656e2068617320616c7265616479206265656e20 // @3527 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x637265617465642077697468207468697320636f6e74656e7420686173680000 // @352B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_352D: // Incoming call from 0x2189, returns to 0x0626 // Inputs[2] // { // @3531 stack[-1] // @356D stack[-2] // } 352D 5B JUMPDEST 352E 60 PUSH1 0x20 3530 80 DUP1 3531 82 DUP3 3532 52 MSTORE 3533 60 PUSH1 0x22 3535 90 SWAP1 3536 82 DUP3 3537 01 ADD 3538 52 MSTORE 3539 7F PUSH32 0x456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e 355A 60 PUSH1 0x40 355C 82 DUP3 355D 01 ADD 355E 52 MSTORE 355F 61 PUSH2 0x6473 3562 60 PUSH1 0xf0 3564 1B SHL 3565 60 PUSH1 0x60 3567 82 DUP3 3568 01 ADD 3569 52 MSTORE 356A 60 PUSH1 0x80 356C 01 ADD 356D 90 SWAP1 356E 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3532 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3538 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @355E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e // @3569 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6473 << 0xf0 // @356D stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_356F: // Incoming call from 0x17D5, returns to 0x0626 // Inputs[2] // { // @3573 stack[-1] // @35A4 stack[-2] // } 356F 5B JUMPDEST 3570 60 PUSH1 0x20 3572 80 DUP1 3573 82 DUP3 3574 52 MSTORE 3575 60 PUSH1 0x1b 3577 90 SWAP1 3578 82 DUP3 3579 01 ADD 357A 52 MSTORE 357B 7F PUSH32 0x4d656469613a206f6e6c79206d61726b657420636f6e74726163740000000000 359C 60 PUSH1 0x40 359E 82 DUP3 359F 01 ADD 35A0 52 MSTORE 35A1 60 PUSH1 0x60 35A3 01 ADD 35A4 90 SWAP1 35A5 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3574 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @357A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1b // @35A0 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a206f6e6c79206d61726b657420636f6e74726163740000000000 // @35A4 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_35A6: // Incoming call from 0x255F, returns to 0x0626 // Inputs[2] // { // @35AA stack[-1] // @35D9 stack[-2] // } 35A6 5B JUMPDEST 35A7 60 PUSH1 0x20 35A9 80 DUP1 35AA 82 DUP3 35AB 52 MSTORE 35AC 81 DUP2 35AD 81 DUP2 35AE 01 ADD 35AF 52 MSTORE 35B0 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 35D1 60 PUSH1 0x40 35D3 82 DUP3 35D4 01 ADD 35D5 52 MSTORE 35D6 60 PUSH1 0x60 35D8 01 ADD 35D9 90 SWAP1 35DA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @35AB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @35AF memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @35D5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @35D9 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 35DB 5B JUMPDEST 35DC 60 PUSH1 0x20 35DE 80 DUP1 35DF 82 DUP3 35E0 52 MSTORE 35E1 60 PUSH1 0x24 35E3 90 SWAP1 35E4 82 DUP3 35E5 01 ADD 35E6 52 MSTORE 35E7 7F PUSH32 0x4d656469613a206f776e6572206973206e6f742063726561746f72206f66206d 3608 60 PUSH1 0x40 360A 82 DUP3 360B 01 ADD 360C 52 MSTORE 360D 63 PUSH4 0x65646961 3612 60 PUSH1 0xe0 3614 1B SHL 3615 60 PUSH1 0x60 3617 82 DUP3 3618 01 ADD 3619 52 MSTORE 361A 60 PUSH1 0x80 361C 01 ADD 361D 90 SWAP1 361E 56 *JUMP 361F 5B JUMPDEST 3620 60 PUSH1 0x20 3622 80 DUP1 3623 82 DUP3 3624 52 MSTORE 3625 60 PUSH1 0x2c 3627 90 SWAP1 3628 82 DUP3 3629 01 ADD 362A 52 MSTORE 362B 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 364C 60 PUSH1 0x40 364E 82 DUP3 364F 01 ADD 3650 52 MSTORE 3651 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 365E 60 PUSH1 0xa1 3660 1B SHL 3661 60 PUSH1 0x60 3663 82 DUP3 3664 01 ADD 3665 52 MSTORE 3666 60 PUSH1 0x80 3668 01 ADD 3669 90 SWAP1 366A 56 *JUMP 366B 5B JUMPDEST 366C 60 PUSH1 0x20 366E 80 DUP1 366F 82 DUP3 3670 52 MSTORE 3671 60 PUSH1 0x2c 3673 90 SWAP1 3674 82 DUP3 3675 01 ADD 3676 52 MSTORE 3677 7F PUSH32 0x4552433732314d657461646174613a2055524920736574206f66206e6f6e6578 3698 60 PUSH1 0x40 369A 82 DUP3 369B 01 ADD 369C 52 MSTORE 369D 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 36AA 60 PUSH1 0xa1 36AC 1B SHL 36AD 60 PUSH1 0x60 36AF 82 DUP3 36B0 01 ADD 36B1 52 MSTORE 36B2 60 PUSH1 0x80 36B4 01 ADD 36B5 90 SWAP1 36B6 56 *JUMP 36B7 5B JUMPDEST 36B8 60 PUSH1 0x20 36BA 80 DUP1 36BB 82 DUP3 36BC 52 MSTORE 36BD 60 PUSH1 0x1d 36BF 90 SWAP1 36C0 82 DUP3 36C1 01 ADD 36C2 52 MSTORE 36C3 7F PUSH32 0x4d656469613a204f6e6c7920617070726f766564206f72206f776e6572000000 36E4 60 PUSH1 0x40 36E6 82 DUP3 36E7 01 ADD 36E8 52 MSTORE 36E9 60 PUSH1 0x60 36EB 01 ADD 36EC 90 SWAP1 36ED 56 *JUMP 36EE 5B JUMPDEST 36EF 60 PUSH1 0x20 36F1 80 DUP1 36F2 82 DUP3 36F3 52 MSTORE 36F4 60 PUSH1 0x29 36F6 90 SWAP1 36F7 82 DUP3 36F8 01 ADD 36F9 52 MSTORE 36FA 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 371B 60 PUSH1 0x40 371D 82 DUP3 371E 01 ADD 371F 52 MSTORE 3720 68 PUSH9 0x39903737ba1037bbb7 372A 60 PUSH1 0xb9 372C 1B SHL 372D 60 PUSH1 0x60 372F 82 DUP3 3730 01 ADD 3731 52 MSTORE 3732 60 PUSH1 0x80 3734 01 ADD 3735 90 SWAP1 3736 56 *JUMP 3737 5B JUMPDEST 3738 60 PUSH1 0x20 373A 80 DUP1 373B 82 DUP3 373C 52 MSTORE 373D 60 PUSH1 0x32 373F 90 SWAP1 3740 82 DUP3 3741 01 ADD 3742 52 MSTORE 3743 7F PUSH32 0x4d656469613a20746f6b656e20646f6573206e6f742068617665206861736820 3764 60 PUSH1 0x40 3766 82 DUP3 3767 01 ADD 3768 52 MSTORE 3769 71 PUSH18 0x1bd98818dc99585d19590818dbdb9d195b9d 377C 60 PUSH1 0x72 377E 1B SHL 377F 60 PUSH1 0x60 3781 82 DUP3 3782 01 ADD 3783 52 MSTORE 3784 60 PUSH1 0x80 3786 01 ADD 3787 90 SWAP1 3788 56 *JUMP label_3789: // Incoming call from 0x1B97, returns to 0x0626 // Inputs[2] // { // @378D stack[-1] // @37CC stack[-2] // } 3789 5B JUMPDEST 378A 60 PUSH1 0x20 378C 80 DUP1 378D 82 DUP3 378E 52 MSTORE 378F 60 PUSH1 0x25 3791 90 SWAP1 3792 82 DUP3 3793 01 ADD 3794 52 MSTORE 3795 7F PUSH32 0x4d656469613a206d657461646174612068617368206d757374206265206e6f6e 37B6 60 PUSH1 0x40 37B8 82 DUP3 37B9 01 ADD 37BA 52 MSTORE 37BB 64 PUSH5 0x2d7a65726f 37C1 60 PUSH1 0xd8 37C3 1B SHL 37C4 60 PUSH1 0x60 37C6 82 DUP3 37C7 01 ADD 37C8 52 MSTORE 37C9 60 PUSH1 0x80 37CB 01 ADD 37CC 90 SWAP1 37CD 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @378E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3794 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @37BA memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a206d657461646174612068617368206d757374206265206e6f6e // @37C8 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x2d7a65726f << 0xd8 // @37CC stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 37CE 5B JUMPDEST 37CF 60 PUSH1 0x20 37D1 80 DUP1 37D2 82 DUP3 37D3 52 MSTORE 37D4 60 PUSH1 0x21 37D6 90 SWAP1 37D7 82 DUP3 37D8 01 ADD 37D9 52 MSTORE 37DA 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 37FB 60 PUSH1 0x40 37FD 82 DUP3 37FE 01 ADD 37FF 52 MSTORE 3800 60 PUSH1 0x39 3802 60 PUSH1 0xf9 3804 1B SHL 3805 60 PUSH1 0x60 3807 82 DUP3 3808 01 ADD 3809 52 MSTORE 380A 60 PUSH1 0x80 380C 01 ADD 380D 90 SWAP1 380E 56 *JUMP label_380F: // Incoming call from 0x11BD, returns to 0x0626 // Inputs[2] // { // @3813 stack[-1] // @3844 stack[-2] // } 380F 5B JUMPDEST 3810 60 PUSH1 0x20 3812 80 DUP1 3813 82 DUP3 3814 52 MSTORE 3815 60 PUSH1 0x1a 3817 90 SWAP1 3818 82 DUP3 3819 01 ADD 381A 52 MSTORE 381B 7F PUSH32 0x4d656469613a206d696e74576974685369672065787069726564000000000000 383C 60 PUSH1 0x40 383E 82 DUP3 383F 01 ADD 3840 52 MSTORE 3841 60 PUSH1 0x60 3843 01 ADD 3844 90 SWAP1 3845 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3814 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @381A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1a // @3840 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a206d696e74576974685369672065787069726564000000000000 // @3844 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3846 5B JUMPDEST 3847 60 PUSH1 0x20 3849 80 DUP1 384A 82 DUP3 384B 52 MSTORE 384C 60 PUSH1 0x31 384E 90 SWAP1 384F 82 DUP3 3850 01 ADD 3851 52 MSTORE 3852 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 3873 60 PUSH1 0x40 3875 82 DUP3 3876 01 ADD 3877 52 MSTORE 3878 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 388A 60 PUSH1 0x7a 388C 1B SHL 388D 60 PUSH1 0x60 388F 82 DUP3 3890 01 ADD 3891 52 MSTORE 3892 60 PUSH1 0x80 3894 01 ADD 3895 90 SWAP1 3896 56 *JUMP 3897 5B JUMPDEST 3898 60 PUSH1 0x20 389A 80 DUP1 389B 82 DUP3 389C 52 MSTORE 389D 60 PUSH1 0x1d 389F 90 SWAP1 38A0 82 DUP3 38A1 01 ADD 38A2 52 MSTORE 38A3 7F PUSH32 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 38C4 60 PUSH1 0x40 38C6 82 DUP3 38C7 01 ADD 38C8 52 MSTORE 38C9 60 PUSH1 0x60 38CB 01 ADD 38CC 90 SWAP1 38CD 56 *JUMP label_38CE: // Incoming call from 0x1319, returns to 0x0626 // Inputs[2] // { // @38D2 stack[-1] // @3903 stack[-2] // } 38CE 5B JUMPDEST 38CF 60 PUSH1 0x20 38D1 80 DUP1 38D2 82 DUP3 38D3 52 MSTORE 38D4 60 PUSH1 0x18 38D6 90 SWAP1 38D7 82 DUP3 38D8 01 ADD 38D9 52 MSTORE 38DA 7F PUSH32 0x4d656469613a205369676e617475726520696e76616c69640000000000000000 38FB 60 PUSH1 0x40 38FD 82 DUP3 38FE 01 ADD 38FF 52 MSTORE 3900 60 PUSH1 0x60 3902 01 ADD 3903 90 SWAP1 3904 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @38D3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @38D9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x18 // @38FF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a205369676e617475726520696e76616c69640000000000000000 // @3903 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3905 5B JUMPDEST 3906 60 PUSH1 0x20 3908 80 DUP1 3909 82 DUP3 390A 52 MSTORE 390B 60 PUSH1 0x18 390D 90 SWAP1 390E 82 DUP3 390F 01 ADD 3910 52 MSTORE 3911 7F PUSH32 0x4d656469613a206e6f6e6578697374656e7420746f6b656e0000000000000000 3932 60 PUSH1 0x40 3934 82 DUP3 3935 01 ADD 3936 52 MSTORE 3937 60 PUSH1 0x60 3939 01 ADD 393A 90 SWAP1 393B 56 *JUMP label_393C: // Incoming call from 0x1514, returns to 0x0626 // Incoming call from 0x1044, returns to 0x0626 // Incoming call from 0x0DF6, returns to 0x0626 // Incoming call from 0x0BAE, returns to 0x0626 // Incoming call from 0x0D08, returns to 0x0626 // Incoming call from 0x0717, returns to 0x0626 // Incoming call from 0x0A17, returns to 0x0626 // Incoming call from 0x14A0, returns to 0x0626 // Incoming call from 0x118D, returns to 0x0626 // Incoming call from 0x1611, returns to 0x0626 // Incoming call from 0x0EAD, returns to 0x0626 // Inputs[2] // { // @3940 stack[-1] // @3971 stack[-2] // } 393C 5B JUMPDEST 393D 60 PUSH1 0x20 393F 80 DUP1 3940 82 DUP3 3941 52 MSTORE 3942 60 PUSH1 0x1f 3944 90 SWAP1 3945 82 DUP3 3946 01 ADD 3947 52 MSTORE 3948 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 3969 60 PUSH1 0x40 396B 82 DUP3 396C 01 ADD 396D 52 MSTORE 396E 60 PUSH1 0x60 3970 01 ADD 3971 90 SWAP1 3972 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3941 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3947 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1f // @396D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @3971 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3973: // Incoming call from 0x1B00, returns to 0x0626 // Incoming call from 0x1B23, returns to 0x0626 // Inputs[2] // { // @3977 stack[-1] // @39B7 stack[-2] // } 3973 5B JUMPDEST 3974 60 PUSH1 0x20 3976 80 DUP1 3977 82 DUP3 3978 52 MSTORE 3979 60 PUSH1 0x26 397B 90 SWAP1 397C 82 DUP3 397D 01 ADD 397E 52 MSTORE 397F 7F PUSH32 0x4d656469613a2073706563696669656420757269206d757374206265206e6f6e 39A0 60 PUSH1 0x40 39A2 82 DUP3 39A3 01 ADD 39A4 52 MSTORE 39A5 65 PUSH6 0x2d656d707479 39AC 60 PUSH1 0xd0 39AE 1B SHL 39AF 60 PUSH1 0x60 39B1 82 DUP3 39B2 01 ADD 39B3 52 MSTORE 39B4 60 PUSH1 0x80 39B6 01 ADD 39B7 90 SWAP1 39B8 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3978 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @397E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x26 // @39A4 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d656469613a2073706563696669656420757269206d757374206265206e6f6e // @39B3 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x2d656d707479 << 0xd0 // @39B7 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_39B9: // Incoming call from 0x1574, returns to 0x1575 // Inputs[4] // { // @39BA stack[-1] // @39BA stack[-3] // @39C5 stack[-2] // @39CE stack[-4] // } 39B9 5B JUMPDEST 39BA 91 SWAP2 39BB 82 DUP3 39BC 52 MSTORE 39BD 60 PUSH1 0x01 39BF 60 PUSH1 0x01 39C1 60 PUSH1 0xa0 39C3 1B SHL 39C4 03 SUB 39C5 16 AND 39C6 60 PUSH1 0x20 39C8 82 DUP3 39C9 01 ADD 39CA 52 MSTORE 39CB 60 PUSH1 0x40 39CD 01 ADD 39CE 90 SWAP1 39CF 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @39BC memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @39CA memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @39CE stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] 39D0 5B JUMPDEST 39D1 91 SWAP2 39D2 82 DUP3 39D3 52 MSTORE 39D4 80 DUP1 39D5 51 MLOAD 39D6 60 PUSH1 0x20 39D8 80 DUP1 39D9 84 DUP5 39DA 01 ADD 39DB 91 SWAP2 39DC 90 SWAP1 39DD 91 SWAP2 39DE 52 MSTORE 39DF 01 ADD 39E0 51 MLOAD 39E1 60 PUSH1 0x01 39E3 60 PUSH1 0x01 39E5 60 PUSH1 0xa0 39E7 1B SHL 39E8 03 SUB 39E9 16 AND 39EA 60 PUSH1 0x40 39EC 82 DUP3 39ED 01 ADD 39EE 52 MSTORE 39EF 60 PUSH1 0x60 39F1 01 ADD 39F2 90 SWAP1 39F3 56 *JUMP 39F4 5B JUMPDEST 39F5 91 SWAP2 39F6 82 DUP3 39F7 52 MSTORE 39F8 80 DUP1 39F9 51 MLOAD 39FA 51 MLOAD 39FB 60 PUSH1 0x20 39FD 80 DUP1 39FE 84 DUP5 39FF 01 ADD 3A00 91 SWAP2 3A01 90 SWAP1 3A02 91 SWAP2 3A03 52 MSTORE 3A04 81 DUP2 3A05 01 ADD 3A06 51 MLOAD 3A07 51 MLOAD 3A08 60 PUSH1 0x40 3A0A 80 DUP1 3A0B 84 DUP5 3A0C 01 ADD 3A0D 91 SWAP2 3A0E 90 SWAP1 3A0F 91 SWAP2 3A10 52 MSTORE 3A11 01 ADD 3A12 51 MLOAD 3A13 51 MLOAD 3A14 60 PUSH1 0x60 3A16 82 DUP3 3A17 01 ADD 3A18 52 MSTORE 3A19 60 PUSH1 0x80 3A1B 01 ADD 3A1C 90 SWAP1 3A1D 56 *JUMP 3A1E 5B JUMPDEST 3A1F 82 DUP3 3A20 81 DUP2 3A21 52 MSTORE 3A22 60 PUSH1 0xc0 3A24 81 DUP2 3A25 01 ADD 3A26 61 PUSH2 0x1dfb 3A29 60 PUSH1 0x20 3A2B 83 DUP4 3A2C 01 ADD 3A2D 84 DUP5 3A2E 61 PUSH2 0x2e9b 3A31 56 *JUMP 3A32 5B JUMPDEST 3A33 83 DUP4 3A34 81 DUP2 3A35 52 MSTORE 3A36 60 PUSH1 0xe0 3A38 81 DUP2 3A39 01 ADD 3A3A 61 PUSH2 0x3a46 3A3D 60 PUSH1 0x20 3A3F 83 DUP4 3A40 01 ADD 3A41 85 DUP6 3A42 61 PUSH2 0x2e9b 3A45 56 *JUMP 3A46 5B JUMPDEST 3A47 60 PUSH1 0x01 3A49 60 PUSH1 0x01 3A4B 60 PUSH1 0xa0 3A4D 1B SHL 3A4E 03 SUB 3A4F 92 SWAP3 3A50 90 SWAP1 3A51 92 SWAP3 3A52 16 AND 3A53 60 PUSH1 0xc0 3A55 91 SWAP2 3A56 90 SWAP1 3A57 91 SWAP2 3A58 01 ADD 3A59 52 MSTORE 3A5A 92 SWAP3 3A5B 91 SWAP2 3A5C 50 POP 3A5D 50 POP 3A5E 56 *JUMP label_3A5F: // Incoming call from 0x2E14, returns to 0x2E15 // Incoming call from 0x29E9, returns to 0x29EA // Incoming call from 0x2DBC, returns to 0x2DBD // Incoming call from 0x28D0, returns to 0x28D1 // Incoming call from 0x2993, returns to 0x2994 // Incoming call from 0x291B, returns to 0x291C // Incoming call from 0x296E, returns to 0x296F // Inputs[2] // { // @3A62 memory[0x40:0x60] // @3A63 stack[-1] // } 3A5F 5B JUMPDEST 3A60 60 PUSH1 0x40 3A62 51 MLOAD 3A63 81 DUP2 3A64 81 DUP2 3A65 01 ADD 3A66 67 PUSH8 0xffffffffffffffff 3A6F 81 DUP2 3A70 11 GT 3A71 82 DUP3 3A72 82 DUP3 3A73 10 LT 3A74 17 OR 3A75 15 ISZERO 3A76 61 PUSH2 0x3a7e 3A79 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3A62 stack[0] = memory[0x40:0x60] // @3A65 stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x3a7e, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) label_3A7A: // Incoming jump from 0x3A79, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[1] { @3A7D memory[0x00:0x00] } 3A7A 60 PUSH1 0x00 3A7C 80 DUP1 3A7D FD *REVERT // Stack delta = +0 // Outputs[1] { @3A7D revert(memory[0x00:0x00]); } // Block terminates label_3A7E: // Incoming jump from 0x3A79, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[4] // { // @3A81 stack[-1] // @3A82 stack[-2] // @3A82 stack[-4] // @3A83 stack[-3] // } 3A7E 5B JUMPDEST 3A7F 60 PUSH1 0x40 3A81 52 MSTORE 3A82 91 SWAP2 3A83 90 SWAP1 3A84 50 POP 3A85 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3A81 memory[0x40:0x60] = stack[-1] // @3A82 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_3A86: // Incoming call from 0x2E86, returns to 0x2E87 // Inputs[1] { @3A8A stack[-3] } 3A86 5B JUMPDEST 3A87 60 PUSH1 0x00 3A89 5B JUMPDEST 3A8A 83 DUP4 3A8B 81 DUP2 3A8C 10 LT 3A8D 15 ISZERO 3A8E 61 PUSH2 0x3aa1 3A91 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A87 stack[0] = 0x00 } // Block ends with conditional jump to 0x3aa1, if !(0x00 < stack[-3]) label_3A92: // Incoming jump from 0x3A91, if not !(0x00 < stack[-3]) // Incoming jump from 0x3A91, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3A92 stack[-2] // @3A93 stack[-1] // @3A95 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3A96 stack[-3] // } 3A92 81 DUP2 3A93 81 DUP2 3A94 01 ADD 3A95 51 MLOAD 3A96 83 DUP4 3A97 82 DUP3 3A98 01 ADD 3A99 52 MSTORE 3A9A 60 PUSH1 0x20 3A9C 01 ADD 3A9D 61 PUSH2 0x3a89 3AA0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3A99 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3A9C stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x3a89 label_3AA1: // Incoming jump from 0x3A91, if !(0x00 < stack[-3]) // Incoming jump from 0x3A91, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @3AA2 stack[-4] // @3AA3 stack[-1] // } 3AA1 5B JUMPDEST 3AA2 83 DUP4 3AA3 81 DUP2 3AA4 11 GT 3AA5 15 ISZERO 3AA6 61 PUSH2 0x15e9 3AA9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15e9, if !(stack[-1] > stack[-4]) label_3AAA: // Incoming jump from 0x3AA9, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @3AAE stack[-4] // @3AAF stack[-3] // @3AB1 stack[-5] // } 3AAA 50 POP 3AAB 50 POP 3AAC 60 PUSH1 0x00 3AAE 91 SWAP2 3AAF 01 ADD 3AB0 52 MSTORE 3AB1 56 *JUMP // Stack delta = -5 // Outputs[1] { @3AB0 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_3AB2: // Incoming call from 0x2AC0, returns to 0x2AC1 // Incoming call from 0x2DD1, returns to 0x2DD2 // Incoming call from 0x2AD0, returns to 0x2AD1 // Incoming call from 0x2C3E, returns to 0x2C3F // Inputs[1] { @3ABB stack[-1] } 3AB2 5B JUMPDEST 3AB3 60 PUSH1 0x01 3AB5 60 PUSH1 0x01 3AB7 60 PUSH1 0xa0 3AB9 1B SHL 3ABA 03 SUB 3ABB 81 DUP2 3ABC 16 AND 3ABD 81 DUP2 3ABE 14 EQ 3ABF 61 PUSH2 0x2864 3AC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2864, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_3AC3: // Incoming jump from 0x3AC2, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @3AC6 memory[0x00:0x00] } 3AC3 60 PUSH1 0x00 3AC5 80 DUP1 3AC6 FD *REVERT // Stack delta = +0 // Outputs[1] { @3AC6 revert(memory[0x00:0x00]); } // Block terminates label_3AC7: // Incoming call from 0x2C79, returns to 0x1DFB // Inputs[1] { @3AD1 stack[-1] } 3AC7 5B JUMPDEST 3AC8 60 PUSH1 0x01 3ACA 60 PUSH1 0x01 3ACC 60 PUSH1 0xe0 3ACE 1B SHL 3ACF 03 SUB 3AD0 19 NOT 3AD1 81 DUP2 3AD2 16 AND 3AD3 81 DUP2 3AD4 14 EQ 3AD5 61 PUSH2 0x2864 3AD8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2864, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_3AD9: // Incoming jump from 0x3AD8, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @3ADC memory[0x00:0x00] } 3AD9 60 PUSH1 0x00 3ADB 80 DUP1 3ADC FD *REVERT // Stack delta = +0 // Outputs[1] { @3ADC revert(memory[0x00:0x00]); } // Block terminates 3ADD FE *ASSERT 3ADE 45 GASLIMIT 3ADF 52 MSTORE 3AE0 43 NUMBER 3AE1 37 CALLDATACOPY 3AE2 32 ORIGIN 3AE3 31 BALANCE 3AE4 3A GASPRICE 3AE5 20 SHA3 3AE6 74 PUSH21 0x72616e7366657220746f206e6f6e20455243373231 3AFC 52 MSTORE 3AFD 65 PUSH6 0x636569766572 3B04 20 SHA3 3B05 69 PUSH10 0x6d706c656d656e746572 3B10 45 GASLIMIT 3B11 52 MSTORE 3B12 43 NUMBER 3B13 37 CALLDATACOPY 3B14 32 ORIGIN 3B15 31 BALANCE 3B16 3A GASPRICE 3B17 20 SHA3 3B18 6F PUSH16 0x776e657220717565727920666f72206e 3B29 6F PUSH16 0x6e6578697374656e7420746f6b656ea2 3B3A 64 PUSH5 0x6970667358 3B40 22 22 3B41 12 SLT 3B42 20 SHA3 3B43 6E PUSH15 0x7e03b577d7c79d4475964fc3384380 3B53 54 SLOAD 3B54 E0 E0 3B55 7F PUSH32 0x10c4421ee6a364158a7b63f58064736f6c63430006080033