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 0x028a 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x028a, 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 0x715018a6 0026 11 GT 0027 61 PUSH2 0x015c 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x015c, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xc30f4a5a 0031 11 GT 0032 61 PUSH2 0x00ce 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ce, if 0xc30f4a5a > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xc30f4a5a > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xf119f567 003C 11 GT 003D 61 PUSH2 0x0087 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0087, if 0xf119f567 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xf119f567 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xf119f567 0047 14 EQ 0048 61 PUSH2 0x0545 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0545, if 0xf119f567 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xf119f567 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf23a6e61 0052 14 EQ 0053 61 PUSH2 0x0558 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0558, if 0xf23a6e61 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf23a6e61 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf27620f7 005D 14 EQ 005E 61 PUSH2 0x0578 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0578, if 0xf27620f7 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf27620f7 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x0580 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0580, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf535f546 0073 14 EQ 0074 61 PUSH2 0x0593 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0593, if 0xf535f546 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf535f546 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0xfa75796a 007E 14 EQ 007F 61 PUSH2 0x05a6 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a6, if 0xfa75796a == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0xfa75796a == stack[-1] 0083 61 PUSH2 0x028a 0086 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_0087: // Incoming jump from 0x0040, if 0xf119f567 > stack[-1] // Inputs[1] { @0088 stack[-1] } 0087 5B JUMPDEST 0088 80 DUP1 0089 63 PUSH4 0xc30f4a5a 008E 14 EQ 008F 61 PUSH2 0x04d3 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d3, if 0xc30f4a5a == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xc30f4a5a == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xc39cbef1 0099 14 EQ 009A 61 PUSH2 0x04e6 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e6, if 0xc39cbef1 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xc39cbef1 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc87b56dd 00A4 14 EQ 00A5 61 PUSH2 0x04f9 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f9, 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 0xcc371bf3 00AF 14 EQ 00B0 61 PUSH2 0x050c 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050c, if 0xcc371bf3 == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xcc371bf3 == stack[-1] // Inputs[1] { @00B4 stack[-1] } 00B4 80 DUP1 00B5 63 PUSH4 0xd9ecad7b 00BA 14 EQ 00BB 61 PUSH2 0x051f 00BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051f, if 0xd9ecad7b == stack[-1] label_00BF: // Incoming jump from 0x00BE, if not 0xd9ecad7b == stack[-1] // Inputs[1] { @00BF stack[-1] } 00BF 80 DUP1 00C0 63 PUSH4 0xe985e9c5 00C5 14 EQ 00C6 61 PUSH2 0x0532 00C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0532, if 0xe985e9c5 == stack[-1] label_00CA: // Incoming jump from 0x00C9, if not 0xe985e9c5 == stack[-1] 00CA 61 PUSH2 0x028a 00CD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_00CE: // Incoming jump from 0x0035, if 0xc30f4a5a > stack[-1] // Inputs[1] { @00CF stack[-1] } 00CE 5B JUMPDEST 00CF 80 DUP1 00D0 63 PUSH4 0x95d89b41 00D5 11 GT 00D6 61 PUSH2 0x0120 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0120, if 0x95d89b41 > stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x95d89b41 00E0 14 EQ 00E1 61 PUSH2 0x0469 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0469, if 0x95d89b41 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x9ffdb65a 00EB 14 EQ 00EC 61 PUSH2 0x0471 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0471, if 0x9ffdb65a == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x9ffdb65a == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0xa22cb465 00F6 14 EQ 00F7 61 PUSH2 0x0484 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0484, if 0xa22cb465 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00FB stack[-1] } 00FB 80 DUP1 00FC 63 PUSH4 0xae78b548 0101 14 EQ 0102 61 PUSH2 0x0497 0105 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0xae78b548 == stack[-1] label_0106: // Incoming jump from 0x0105, if not 0xae78b548 == stack[-1] // Inputs[1] { @0106 stack[-1] } 0106 80 DUP1 0107 63 PUSH4 0xb88d4fde 010C 14 EQ 010D 61 PUSH2 0x04b8 0110 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b8, if 0xb88d4fde == stack[-1] label_0111: // Incoming jump from 0x0110, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0111 stack[-1] } 0111 80 DUP1 0112 63 PUSH4 0xbf424e7e 0117 14 EQ 0118 61 PUSH2 0x04cb 011B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cb, if 0xbf424e7e == stack[-1] label_011C: // Incoming jump from 0x011B, if not 0xbf424e7e == stack[-1] 011C 61 PUSH2 0x028a 011F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_0120: // Incoming jump from 0x00D9, if 0x95d89b41 > stack[-1] // Inputs[1] { @0121 stack[-1] } 0120 5B JUMPDEST 0121 80 DUP1 0122 63 PUSH4 0x715018a6 0127 14 EQ 0128 61 PUSH2 0x0436 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0436, if 0x715018a6 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x715018a6 == stack[-1] // Inputs[1] { @012C stack[-1] } 012C 80 DUP1 012D 63 PUSH4 0x74151be0 0132 14 EQ 0133 61 PUSH2 0x043e 0136 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043e, if 0x74151be0 == stack[-1] label_0137: // Incoming jump from 0x0136, if not 0x74151be0 == stack[-1] // Inputs[1] { @0137 stack[-1] } 0137 80 DUP1 0138 63 PUSH4 0x76d5de85 013D 14 EQ 013E 61 PUSH2 0x0446 0141 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0446, if 0x76d5de85 == stack[-1] label_0142: // Incoming jump from 0x0141, if not 0x76d5de85 == stack[-1] // Inputs[1] { @0142 stack[-1] } 0142 80 DUP1 0143 63 PUSH4 0x8da5cb5b 0148 14 EQ 0149 61 PUSH2 0x044e 014C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044e, if 0x8da5cb5b == stack[-1] label_014D: // Incoming jump from 0x014C, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @014D stack[-1] } 014D 80 DUP1 014E 63 PUSH4 0x9416b423 0153 14 EQ 0154 61 PUSH2 0x0456 0157 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0456, if 0x9416b423 == stack[-1] label_0158: // Incoming jump from 0x0157, if not 0x9416b423 == stack[-1] 0158 61 PUSH2 0x028a 015B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_015C: // Incoming jump from 0x002A, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @015D stack[-1] } 015C 5B JUMPDEST 015D 80 DUP1 015E 63 PUSH4 0x38712d8d 0163 11 GT 0164 61 PUSH2 0x0200 0167 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0200, if 0x38712d8d > stack[-1] label_0168: // Incoming jump from 0x0167, if not 0x38712d8d > stack[-1] // Inputs[1] { @0168 stack[-1] } 0168 80 DUP1 0169 63 PUSH4 0x4f6ccce7 016E 11 GT 016F 61 PUSH2 0x01b9 0172 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b9, 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 0x4f6ccce7 0179 14 EQ 017A 61 PUSH2 0x03da 017D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03da, if 0x4f6ccce7 == stack[-1] label_017E: // Incoming jump from 0x017D, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @017E stack[-1] } 017E 80 DUP1 017F 63 PUSH4 0x582abd12 0184 14 EQ 0185 61 PUSH2 0x03ed 0188 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ed, if 0x582abd12 == stack[-1] label_0189: // Incoming jump from 0x0188, if not 0x582abd12 == stack[-1] // Inputs[1] { @0189 stack[-1] } 0189 80 DUP1 018A 63 PUSH4 0x6352211e 018F 14 EQ 0190 61 PUSH2 0x03f5 0193 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f5, if 0x6352211e == stack[-1] label_0194: // Incoming jump from 0x0193, if not 0x6352211e == stack[-1] // Inputs[1] { @0194 stack[-1] } 0194 80 DUP1 0195 63 PUSH4 0x6c0360eb 019A 14 EQ 019B 61 PUSH2 0x0408 019E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0408, if 0x6c0360eb == stack[-1] label_019F: // Incoming jump from 0x019E, if not 0x6c0360eb == stack[-1] // Inputs[1] { @019F stack[-1] } 019F 80 DUP1 01A0 63 PUSH4 0x6d522418 01A5 14 EQ 01A6 61 PUSH2 0x0410 01A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0410, if 0x6d522418 == stack[-1] label_01AA: // Incoming jump from 0x01A9, if not 0x6d522418 == stack[-1] // Inputs[1] { @01AA stack[-1] } 01AA 80 DUP1 01AB 63 PUSH4 0x70a08231 01B0 14 EQ 01B1 61 PUSH2 0x0423 01B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0423, if 0x70a08231 == stack[-1] label_01B5: // Incoming jump from 0x01B4, if not 0x70a08231 == stack[-1] 01B5 61 PUSH2 0x028a 01B8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_01B9: // Incoming jump from 0x0172, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @01BA stack[-1] } 01B9 5B JUMPDEST 01BA 80 DUP1 01BB 63 PUSH4 0x38712d8d 01C0 14 EQ 01C1 61 PUSH2 0x0389 01C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0389, if 0x38712d8d == stack[-1] label_01C5: // Incoming jump from 0x01C4, if not 0x38712d8d == stack[-1] // Inputs[1] { @01C5 stack[-1] } 01C5 80 DUP1 01C6 63 PUSH4 0x3d18b912 01CB 14 EQ 01CC 61 PUSH2 0x039c 01CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039c, if 0x3d18b912 == stack[-1] label_01D0: // Incoming jump from 0x01CF, if not 0x3d18b912 == stack[-1] // Inputs[1] { @01D0 stack[-1] } 01D0 80 DUP1 01D1 63 PUSH4 0x42842e0e 01D6 14 EQ 01D7 61 PUSH2 0x03a4 01DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a4, if 0x42842e0e == stack[-1] label_01DB: // Incoming jump from 0x01DA, if not 0x42842e0e == stack[-1] // Inputs[1] { @01DB stack[-1] } 01DB 80 DUP1 01DC 63 PUSH4 0x44df8e70 01E1 14 EQ 01E2 61 PUSH2 0x03b7 01E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b7, if 0x44df8e70 == stack[-1] label_01E6: // Incoming jump from 0x01E5, if not 0x44df8e70 == stack[-1] // Inputs[1] { @01E6 stack[-1] } 01E6 80 DUP1 01E7 63 PUSH4 0x45ca7738 01EC 14 EQ 01ED 61 PUSH2 0x03bf 01F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bf, if 0x45ca7738 == stack[-1] label_01F1: // Incoming jump from 0x01F0, if not 0x45ca7738 == stack[-1] // Inputs[1] { @01F1 stack[-1] } 01F1 80 DUP1 01F2 63 PUSH4 0x4d426528 01F7 14 EQ 01F8 61 PUSH2 0x03c7 01FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c7, if 0x4d426528 == stack[-1] label_01FC: // Incoming jump from 0x01FB, if not 0x4d426528 == stack[-1] 01FC 61 PUSH2 0x028a 01FF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_0200: // Incoming jump from 0x0167, if 0x38712d8d > stack[-1] // Inputs[1] { @0201 stack[-1] } 0200 5B JUMPDEST 0201 80 DUP1 0202 63 PUSH4 0x15b56d10 0207 11 GT 0208 61 PUSH2 0x0252 020B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0252, if 0x15b56d10 > stack[-1] label_020C: // Incoming jump from 0x020B, if not 0x15b56d10 > stack[-1] // Inputs[1] { @020C stack[-1] } 020C 80 DUP1 020D 63 PUSH4 0x15b56d10 0212 14 EQ 0213 61 PUSH2 0x0315 0216 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0315, if 0x15b56d10 == stack[-1] label_0217: // Incoming jump from 0x0216, if not 0x15b56d10 == stack[-1] // Inputs[1] { @0217 stack[-1] } 0217 80 DUP1 0218 63 PUSH4 0x18160ddd 021D 14 EQ 021E 61 PUSH2 0x0328 0221 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0328, if 0x18160ddd == stack[-1] label_0222: // Incoming jump from 0x0221, if not 0x18160ddd == stack[-1] // Inputs[1] { @0222 stack[-1] } 0222 80 DUP1 0223 63 PUSH4 0x23b872dd 0228 14 EQ 0229 61 PUSH2 0x033d 022C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033d, if 0x23b872dd == stack[-1] label_022D: // Incoming jump from 0x022C, if not 0x23b872dd == stack[-1] // Inputs[1] { @022D stack[-1] } 022D 80 DUP1 022E 63 PUSH4 0x23ffce85 0233 14 EQ 0234 61 PUSH2 0x0350 0237 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0350, if 0x23ffce85 == stack[-1] label_0238: // Incoming jump from 0x0237, if not 0x23ffce85 == stack[-1] // Inputs[1] { @0238 stack[-1] } 0238 80 DUP1 0239 63 PUSH4 0x2f745c59 023E 14 EQ 023F 61 PUSH2 0x0363 0242 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0363, if 0x2f745c59 == stack[-1] label_0243: // Incoming jump from 0x0242, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0243 stack[-1] } 0243 80 DUP1 0244 63 PUSH4 0x36033deb 0249 14 EQ 024A 61 PUSH2 0x0376 024D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0376, if 0x36033deb == stack[-1] label_024E: // Incoming jump from 0x024D, if not 0x36033deb == stack[-1] 024E 61 PUSH2 0x028a 0251 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x028a label_0252: // Incoming jump from 0x020B, if 0x15b56d10 > stack[-1] // Inputs[1] { @0253 stack[-1] } 0252 5B JUMPDEST 0253 80 DUP1 0254 63 PUSH4 0x01ffc9a7 0259 14 EQ 025A 61 PUSH2 0x028f 025D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028f, if 0x01ffc9a7 == stack[-1] label_025E: // Incoming jump from 0x025D, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @025E stack[-1] } 025E 80 DUP1 025F 63 PUSH4 0x045869a4 0264 14 EQ 0265 61 PUSH2 0x02b8 0268 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b8, if 0x045869a4 == stack[-1] label_0269: // Incoming jump from 0x0268, if not 0x045869a4 == stack[-1] // Inputs[1] { @0269 stack[-1] } 0269 80 DUP1 026A 63 PUSH4 0x06fdde03 026F 14 EQ 0270 61 PUSH2 0x02cd 0273 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cd, if 0x06fdde03 == stack[-1] label_0274: // Incoming jump from 0x0273, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0274 stack[-1] } 0274 80 DUP1 0275 63 PUSH4 0x081812fc 027A 14 EQ 027B 61 PUSH2 0x02e2 027E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e2, if 0x081812fc == stack[-1] label_027F: // Incoming jump from 0x027E, if not 0x081812fc == stack[-1] // Inputs[1] { @027F stack[-1] } 027F 80 DUP1 0280 63 PUSH4 0x095ea7b3 0285 14 EQ 0286 61 PUSH2 0x0302 0289 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0302, if 0x095ea7b3 == stack[-1] label_028A: // Incoming jump from 0x00CD // Incoming jump from 0x01FF // Incoming jump from 0x0251 // Incoming jump from 0x015B // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x011F // Incoming jump from 0x0086 // Incoming jump from 0x01B8 // Incoming jump from 0x0289, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @028E memory[0x00:0x00] } 028A 5B JUMPDEST 028B 60 PUSH1 0x00 028D 80 DUP1 028E FD *REVERT // Stack delta = +0 // Outputs[1] { @028E revert(memory[0x00:0x00]); } // Block terminates label_028F: // Incoming jump from 0x025D, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0296 msg.data.length } 028F 5B JUMPDEST 0290 61 PUSH2 0x02a2 0293 61 PUSH2 0x029d 0296 36 CALLDATASIZE 0297 60 PUSH1 0x04 0299 61 PUSH2 0x2dbe 029C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0290 stack[0] = 0x02a2 // @0293 stack[1] = 0x029d // @0296 stack[2] = msg.data.length // @0297 stack[3] = 0x04 // } // Block ends with call to 0x2dbe, returns to 0x029D label_029D: // Incoming return from call to 0x2DBE at 0x029C 029D 5B JUMPDEST 029E 61 PUSH2 0x05ae 02A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05ae label_02A2: // Incoming return from call to 0x047F at 0x047E // Incoming return from call to 0x0323 at 0x0322 // Incoming return from call to 0x029D at 0x029C // Incoming return from call to 0x0540 at 0x053F // Inputs[2] // { // @02A5 memory[0x40:0x60] // @02A9 stack[-1] // } 02A2 5B JUMPDEST 02A3 60 PUSH1 0x40 02A5 51 MLOAD 02A6 61 PUSH2 0x02af 02A9 91 SWAP2 02AA 90 SWAP1 02AB 61 PUSH2 0x312c 02AE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02A9 stack[-1] = 0x02af // @02AA stack[1] = memory[0x40:0x60] // @02AA stack[0] = stack[-1] // } // Block ends with call to 0x312c, returns to 0x02AF label_02AF: // Incoming return from call to 0x3070 at 0x0301 // Incoming return from call to 0x3155 at 0x0577 // Incoming return from call to 0x38A4 at 0x033C // Incoming return from call to 0x312C at 0x02AE // Incoming return from call to 0x3062 at 0x04B7 // Inputs[3] // { // @02B2 memory[0x40:0x60] // @02B4 stack[-1] // @02B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02AF 5B JUMPDEST 02B0 60 PUSH1 0x40 02B2 51 MLOAD 02B3 80 DUP1 02B4 91 SWAP2 02B5 03 SUB 02B6 90 SWAP1 02B7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02B7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02B8: // Incoming jump from 0x0268, if 0x045869a4 == stack[-1] // Inputs[1] { @02BF msg.data.length } 02B8 5B JUMPDEST 02B9 61 PUSH2 0x02cb 02BC 61 PUSH2 0x02c6 02BF 36 CALLDATASIZE 02C0 60 PUSH1 0x04 02C2 61 PUSH2 0x2ea7 02C5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B9 stack[0] = 0x02cb // @02BC stack[1] = 0x02c6 // @02BF stack[2] = msg.data.length // @02C0 stack[3] = 0x04 // } // Block ends with call to 0x2ea7, returns to 0x02C6 label_02C6: // Incoming return from call to 0x2EA7 at 0x02C5 02C6 5B JUMPDEST 02C7 61 PUSH2 0x05d1 02CA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05d1 label_02CB: // Incoming return from call to 0x0BB8 at 0x03A3 // Incoming return from call to 0x0492 at 0x0491 // Incoming return from call to 0x0EC6 at 0x043D // Incoming return from call to 0x051A at 0x0519 02CB 5B JUMPDEST 02CC 00 *STOP // Stack delta = +0 // Outputs[1] { @02CC stop(); } // Block terminates label_02CD: // Incoming jump from 0x0273, if 0x06fdde03 == stack[-1] 02CD 5B JUMPDEST 02CE 61 PUSH2 0x02d5 02D1 61 PUSH2 0x0828 02D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @02CE stack[0] = 0x02d5 } // Block ends with call to 0x0828, returns to 0x02D5 label_02D5: // Incoming return from call to 0x0384 at 0x0383 // Incoming return from call to 0x041E at 0x041D // Incoming return from call to 0x1092 at 0x0470 // Incoming return from call to 0x0D7B at 0x040F // Incoming return from call to 0x0464 at 0x0463 // Incoming return from call to 0x0828 at 0x02D4 // Inputs[2] // { // @02D8 memory[0x40:0x60] // @02DC stack[-1] // } 02D5 5B JUMPDEST 02D6 60 PUSH1 0x40 02D8 51 MLOAD 02D9 61 PUSH2 0x02af 02DC 91 SWAP2 02DD 90 SWAP1 02DE 61 PUSH2 0x316a 02E1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02DC stack[-1] = 0x02af // @02DD stack[1] = memory[0x40:0x60] // @02DD stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x316a label_02E2: // Incoming jump from 0x027E, if 0x081812fc == stack[-1] // Inputs[1] { @02E9 msg.data.length } 02E2 5B JUMPDEST 02E3 61 PUSH2 0x02f5 02E6 61 PUSH2 0x02f0 02E9 36 CALLDATASIZE 02EA 60 PUSH1 0x04 02EC 61 PUSH2 0x2e29 02EF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E3 stack[0] = 0x02f5 // @02E6 stack[1] = 0x02f0 // @02E9 stack[2] = msg.data.length // @02EA stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x02F0 label_02F0: // Incoming return from call to 0x2E29 at 0x02EF 02F0 5B JUMPDEST 02F1 61 PUSH2 0x08be 02F4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08be label_02F5: // Incoming return from call to 0x0C9E at 0x03BE // Incoming return from call to 0x0D3B at 0x03F4 // Incoming return from call to 0x19D8 at 0x057F // Incoming return from call to 0x0F52 at 0x044D // Incoming return from call to 0x0F61 at 0x0455 // Inputs[2] // { // @02F8 memory[0x40:0x60] // @02FC stack[-1] // } 02F5 5B JUMPDEST 02F6 60 PUSH1 0x40 02F8 51 MLOAD 02F9 61 PUSH2 0x02af 02FC 91 SWAP2 02FD 90 SWAP1 02FE 61 PUSH2 0x3070 0301 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02FC stack[-1] = 0x02af // @02FD stack[1] = memory[0x40:0x60] // @02FD stack[0] = stack[-1] // } // Block ends with call to 0x3070, returns to 0x02AF label_0302: // Incoming jump from 0x0289, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0309 msg.data.length } 0302 5B JUMPDEST 0303 61 PUSH2 0x02cb 0306 61 PUSH2 0x0310 0309 36 CALLDATASIZE 030A 60 PUSH1 0x04 030C 61 PUSH2 0x2d60 030F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0303 stack[0] = 0x02cb // @0306 stack[1] = 0x0310 // @0309 stack[2] = msg.data.length // @030A stack[3] = 0x04 // } // Block ends with call to 0x2d60, returns to 0x0310 label_0310: // Incoming return from call to 0x2D60 at 0x030F 0310 5B JUMPDEST 0311 61 PUSH2 0x0901 0314 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0901 label_0315: // Incoming jump from 0x0216, if 0x15b56d10 == stack[-1] // Inputs[1] { @031C msg.data.length } 0315 5B JUMPDEST 0316 61 PUSH2 0x02a2 0319 61 PUSH2 0x0323 031C 36 CALLDATASIZE 031D 60 PUSH1 0x04 031F 61 PUSH2 0x2df6 0322 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0316 stack[0] = 0x02a2 // @0319 stack[1] = 0x0323 // @031C stack[2] = msg.data.length // @031D stack[3] = 0x04 // } // Block ends with call to 0x2df6, returns to 0x0323 label_0323: // Incoming return from call to 0x2DF6 at 0x0322 0323 5B JUMPDEST 0324 61 PUSH2 0x0999 0327 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0999 label_0328: // Incoming jump from 0x0221, if 0x18160ddd == stack[-1] 0328 5B JUMPDEST 0329 61 PUSH2 0x0330 032C 61 PUSH2 0x09cd 032F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0329 stack[0] = 0x0330 } // Block ends with unconditional jump to 0x09cd label_0330: // Incoming return from call to 0x0CA4 at 0x03C6 // Incoming return from call to 0x1471 at 0x04D2 // Incoming return from call to 0x0F45 at 0x0445 // Incoming return from call to 0x1AFE at 0x05AD // Inputs[2] // { // @0333 memory[0x40:0x60] // @0337 stack[-1] // } 0330 5B JUMPDEST 0331 60 PUSH1 0x40 0333 51 MLOAD 0334 61 PUSH2 0x02af 0337 91 SWAP2 0338 90 SWAP1 0339 61 PUSH2 0x38a4 033C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0337 stack[-1] = 0x02af // @0338 stack[1] = memory[0x40:0x60] // @0338 stack[0] = stack[-1] // } // Block ends with call to 0x38a4, returns to 0x02AF label_033D: // Incoming jump from 0x022C, if 0x23b872dd == stack[-1] // Inputs[1] { @0344 msg.data.length } 033D 5B JUMPDEST 033E 61 PUSH2 0x02cb 0341 61 PUSH2 0x034b 0344 36 CALLDATASIZE 0345 60 PUSH1 0x04 0347 61 PUSH2 0x2c07 034A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @033E stack[0] = 0x02cb // @0341 stack[1] = 0x034b // @0344 stack[2] = msg.data.length // @0345 stack[3] = 0x04 // } // Block ends with call to 0x2c07, returns to 0x034B label_034B: // Incoming return from call to 0x2C07 at 0x034A 034B 5B JUMPDEST 034C 61 PUSH2 0x09de 034F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09de label_0350: // Incoming jump from 0x0237, if 0x23ffce85 == stack[-1] // Inputs[1] { @0357 msg.data.length } 0350 5B JUMPDEST 0351 61 PUSH2 0x02cb 0354 61 PUSH2 0x035e 0357 36 CALLDATASIZE 0358 60 PUSH1 0x04 035A 61 PUSH2 0x2bb8 035D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0351 stack[0] = 0x02cb // @0354 stack[1] = 0x035e // @0357 stack[2] = msg.data.length // @0358 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2bb8 035E 5B JUMPDEST 035F 61 PUSH2 0x0a89 0362 56 *JUMP label_0363: // Incoming jump from 0x0242, if 0x2f745c59 == stack[-1] // Inputs[1] { @036A msg.data.length } 0363 5B JUMPDEST 0364 61 PUSH2 0x0330 0367 61 PUSH2 0x0371 036A 36 CALLDATASIZE 036B 60 PUSH1 0x04 036D 61 PUSH2 0x2d60 0370 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0364 stack[0] = 0x0330 // @0367 stack[1] = 0x0371 // @036A stack[2] = msg.data.length // @036B stack[3] = 0x04 // } // Block ends with call to 0x2d60, returns to 0x0371 label_0371: // Incoming return from call to 0x2D60 at 0x0370 0371 5B JUMPDEST 0372 61 PUSH2 0x0ae0 0375 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ae0 label_0376: // Incoming jump from 0x024D, if 0x36033deb == stack[-1] // Inputs[1] { @037D msg.data.length } 0376 5B JUMPDEST 0377 61 PUSH2 0x02d5 037A 61 PUSH2 0x0384 037D 36 CALLDATASIZE 037E 60 PUSH1 0x04 0380 61 PUSH2 0x2e29 0383 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0377 stack[0] = 0x02d5 // @037A stack[1] = 0x0384 // @037D stack[2] = msg.data.length // @037E stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x0384 label_0384: // Incoming return from call to 0x2E29 at 0x0383 0384 5B JUMPDEST 0385 61 PUSH2 0x0b0b 0388 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b0b label_0389: // Incoming jump from 0x01C4, if 0x38712d8d == stack[-1] // Inputs[1] { @0390 msg.data.length } 0389 5B JUMPDEST 038A 61 PUSH2 0x0330 038D 61 PUSH2 0x0397 0390 36 CALLDATASIZE 0391 60 PUSH1 0x04 0393 61 PUSH2 0x2bb8 0396 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @038A stack[0] = 0x0330 // @038D stack[1] = 0x0397 // @0390 stack[2] = msg.data.length // @0391 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2bb8 0397 5B JUMPDEST 0398 61 PUSH2 0x0ba6 039B 56 *JUMP label_039C: // Incoming jump from 0x01CF, if 0x3d18b912 == stack[-1] 039C 5B JUMPDEST 039D 61 PUSH2 0x02cb 03A0 61 PUSH2 0x0bb8 03A3 56 *JUMP // Stack delta = +1 // Outputs[1] { @039D stack[0] = 0x02cb } // Block ends with call to 0x0bb8, returns to 0x02CB label_03A4: // Incoming jump from 0x01DA, if 0x42842e0e == stack[-1] // Inputs[1] { @03AB msg.data.length } 03A4 5B JUMPDEST 03A5 61 PUSH2 0x02cb 03A8 61 PUSH2 0x03b2 03AB 36 CALLDATASIZE 03AC 60 PUSH1 0x04 03AE 61 PUSH2 0x2c07 03B1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A5 stack[0] = 0x02cb // @03A8 stack[1] = 0x03b2 // @03AB stack[2] = msg.data.length // @03AC stack[3] = 0x04 // } // Block ends with call to 0x2c07, returns to 0x03B2 label_03B2: // Incoming return from call to 0x2C07 at 0x03B1 03B2 5B JUMPDEST 03B3 61 PUSH2 0x0c83 03B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c83 label_03B7: // Incoming jump from 0x01E5, if 0x44df8e70 == stack[-1] 03B7 5B JUMPDEST 03B8 61 PUSH2 0x02f5 03BB 61 PUSH2 0x0c9e 03BE 56 *JUMP // Stack delta = +1 // Outputs[1] { @03B8 stack[0] = 0x02f5 } // Block ends with call to 0x0c9e, returns to 0x02F5 label_03BF: // Incoming jump from 0x01F0, if 0x45ca7738 == stack[-1] 03BF 5B JUMPDEST 03C0 61 PUSH2 0x0330 03C3 61 PUSH2 0x0ca4 03C6 56 *JUMP // Stack delta = +1 // Outputs[1] { @03C0 stack[0] = 0x0330 } // Block ends with call to 0x0ca4, returns to 0x0330 label_03C7: // Incoming jump from 0x01FB, if 0x4d426528 == stack[-1] // Inputs[1] { @03CE msg.data.length } 03C7 5B JUMPDEST 03C8 61 PUSH2 0x02cb 03CB 61 PUSH2 0x03d5 03CE 36 CALLDATASIZE 03CF 60 PUSH1 0x04 03D1 61 PUSH2 0x2e41 03D4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03C8 stack[0] = 0x02cb // @03CB stack[1] = 0x03d5 // @03CE stack[2] = msg.data.length // @03CF stack[3] = 0x04 // } // Block ends with call to 0x2e41, returns to 0x03D5 label_03D5: // Incoming return from call to 0x2E41 at 0x03D4 03D5 5B JUMPDEST 03D6 61 PUSH2 0x0caa 03D9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0caa label_03DA: // Incoming jump from 0x017D, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @03E1 msg.data.length } 03DA 5B JUMPDEST 03DB 61 PUSH2 0x0330 03DE 61 PUSH2 0x03e8 03E1 36 CALLDATASIZE 03E2 60 PUSH1 0x04 03E4 61 PUSH2 0x2e29 03E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03DB stack[0] = 0x0330 // @03DE stack[1] = 0x03e8 // @03E1 stack[2] = msg.data.length // @03E2 stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x03E8 label_03E8: // Incoming return from call to 0x2E29 at 0x03E7 03E8 5B JUMPDEST 03E9 61 PUSH2 0x0d25 03EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d25 label_03ED: // Incoming jump from 0x0188, if 0x582abd12 == stack[-1] 03ED 5B JUMPDEST 03EE 61 PUSH2 0x02f5 03F1 61 PUSH2 0x0d3b 03F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @03EE stack[0] = 0x02f5 } // Block ends with call to 0x0d3b, returns to 0x02F5 label_03F5: // Incoming jump from 0x0193, if 0x6352211e == stack[-1] // Inputs[1] { @03FC msg.data.length } 03F5 5B JUMPDEST 03F6 61 PUSH2 0x02f5 03F9 61 PUSH2 0x0403 03FC 36 CALLDATASIZE 03FD 60 PUSH1 0x04 03FF 61 PUSH2 0x2e29 0402 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03F6 stack[0] = 0x02f5 // @03F9 stack[1] = 0x0403 // @03FC stack[2] = msg.data.length // @03FD stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x0403 label_0403: // Incoming return from call to 0x2E29 at 0x0402 0403 5B JUMPDEST 0404 61 PUSH2 0x0d53 0407 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d53 label_0408: // Incoming jump from 0x019E, if 0x6c0360eb == stack[-1] 0408 5B JUMPDEST 0409 61 PUSH2 0x02d5 040C 61 PUSH2 0x0d7b 040F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0409 stack[0] = 0x02d5 } // Block ends with call to 0x0d7b, returns to 0x02D5 label_0410: // Incoming jump from 0x01A9, if 0x6d522418 == stack[-1] // Inputs[1] { @0417 msg.data.length } 0410 5B JUMPDEST 0411 61 PUSH2 0x02d5 0414 61 PUSH2 0x041e 0417 36 CALLDATASIZE 0418 60 PUSH1 0x04 041A 61 PUSH2 0x2e29 041D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0411 stack[0] = 0x02d5 // @0414 stack[1] = 0x041e // @0417 stack[2] = msg.data.length // @0418 stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x041E label_041E: // Incoming return from call to 0x2E29 at 0x041D 041E 5B JUMPDEST 041F 61 PUSH2 0x0ddc 0422 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ddc label_0423: // Incoming jump from 0x01B4, if 0x70a08231 == stack[-1] // Inputs[1] { @042A msg.data.length } 0423 5B JUMPDEST 0424 61 PUSH2 0x0330 0427 61 PUSH2 0x0431 042A 36 CALLDATASIZE 042B 60 PUSH1 0x04 042D 61 PUSH2 0x2bb8 0430 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0424 stack[0] = 0x0330 // @0427 stack[1] = 0x0431 // @042A stack[2] = msg.data.length // @042B stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2bb8 0431 5B JUMPDEST 0432 61 PUSH2 0x0e7d 0435 56 *JUMP label_0436: // Incoming jump from 0x012B, if 0x715018a6 == stack[-1] 0436 5B JUMPDEST 0437 61 PUSH2 0x02cb 043A 61 PUSH2 0x0ec6 043D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0437 stack[0] = 0x02cb } // Block ends with call to 0x0ec6, returns to 0x02CB label_043E: // Incoming jump from 0x0136, if 0x74151be0 == stack[-1] 043E 5B JUMPDEST 043F 61 PUSH2 0x0330 0442 61 PUSH2 0x0f45 0445 56 *JUMP // Stack delta = +1 // Outputs[1] { @043F stack[0] = 0x0330 } // Block ends with call to 0x0f45, returns to 0x0330 label_0446: // Incoming jump from 0x0141, if 0x76d5de85 == stack[-1] 0446 5B JUMPDEST 0447 61 PUSH2 0x02f5 044A 61 PUSH2 0x0f52 044D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0447 stack[0] = 0x02f5 } // Block ends with call to 0x0f52, returns to 0x02F5 label_044E: // Incoming jump from 0x014C, if 0x8da5cb5b == stack[-1] 044E 5B JUMPDEST 044F 61 PUSH2 0x02f5 0452 61 PUSH2 0x0f61 0455 56 *JUMP // Stack delta = +1 // Outputs[1] { @044F stack[0] = 0x02f5 } // Block ends with call to 0x0f61, returns to 0x02F5 label_0456: // Incoming jump from 0x0157, if 0x9416b423 == stack[-1] // Inputs[1] { @045D msg.data.length } 0456 5B JUMPDEST 0457 61 PUSH2 0x02d5 045A 61 PUSH2 0x0464 045D 36 CALLDATASIZE 045E 60 PUSH1 0x04 0460 61 PUSH2 0x2df6 0463 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0457 stack[0] = 0x02d5 // @045A stack[1] = 0x0464 // @045D stack[2] = msg.data.length // @045E stack[3] = 0x04 // } // Block ends with call to 0x2df6, returns to 0x0464 label_0464: // Incoming return from call to 0x2DF6 at 0x0463 0464 5B JUMPDEST 0465 61 PUSH2 0x0f70 0468 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f70 label_0469: // Incoming jump from 0x00E4, if 0x95d89b41 == stack[-1] 0469 5B JUMPDEST 046A 61 PUSH2 0x02d5 046D 61 PUSH2 0x1092 0470 56 *JUMP // Stack delta = +1 // Outputs[1] { @046A stack[0] = 0x02d5 } // Block ends with call to 0x1092, returns to 0x02D5 label_0471: // Incoming jump from 0x00EF, if 0x9ffdb65a == stack[-1] // Inputs[1] { @0478 msg.data.length } 0471 5B JUMPDEST 0472 61 PUSH2 0x02a2 0475 61 PUSH2 0x047f 0478 36 CALLDATASIZE 0479 60 PUSH1 0x04 047B 61 PUSH2 0x2df6 047E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0472 stack[0] = 0x02a2 // @0475 stack[1] = 0x047f // @0478 stack[2] = msg.data.length // @0479 stack[3] = 0x04 // } // Block ends with call to 0x2df6, returns to 0x047F label_047F: // Incoming return from call to 0x2DF6 at 0x047E 047F 5B JUMPDEST 0480 61 PUSH2 0x10f3 0483 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10f3 label_0484: // Incoming jump from 0x00FA, if 0xa22cb465 == stack[-1] // Inputs[1] { @048B msg.data.length } 0484 5B JUMPDEST 0485 61 PUSH2 0x02cb 0488 61 PUSH2 0x0492 048B 36 CALLDATASIZE 048C 60 PUSH1 0x04 048E 61 PUSH2 0x2d29 0491 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0485 stack[0] = 0x02cb // @0488 stack[1] = 0x0492 // @048B stack[2] = msg.data.length // @048C stack[3] = 0x04 // } // Block ends with call to 0x2d29, returns to 0x0492 label_0492: // Incoming return from call to 0x2D29 at 0x0491 0492 5B JUMPDEST 0493 61 PUSH2 0x12de 0496 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12de label_0497: // Incoming jump from 0x0105, if 0xae78b548 == stack[-1] // Inputs[1] { @049E msg.data.length } 0497 5B JUMPDEST 0498 61 PUSH2 0x04aa 049B 61 PUSH2 0x04a5 049E 36 CALLDATASIZE 049F 60 PUSH1 0x04 04A1 61 PUSH2 0x2e29 04A4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0498 stack[0] = 0x04aa // @049B stack[1] = 0x04a5 // @049E stack[2] = msg.data.length // @049F stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x04A5 label_04A5: // Incoming return from call to 0x2E29 at 0x04A4 04A5 5B JUMPDEST 04A6 61 PUSH2 0x13ac 04A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13ac label_04AA: // Incoming return from call to 0x04A5 at 0x04A4 // Inputs[3] // { // @04AD memory[0x40:0x60] // @04B1 stack[-2] // @04B2 stack[-1] // } 04AA 5B JUMPDEST 04AB 60 PUSH1 0x40 04AD 51 MLOAD 04AE 61 PUSH2 0x02af 04B1 92 SWAP3 04B2 91 SWAP2 04B3 90 SWAP1 04B4 61 PUSH2 0x3062 04B7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @04B1 stack[-2] = 0x02af // @04B2 stack[-1] = stack[-2] // @04B3 stack[1] = memory[0x40:0x60] // @04B3 stack[0] = stack[-1] // } // Block ends with call to 0x3062, returns to 0x02AF label_04B8: // Incoming jump from 0x0110, if 0xb88d4fde == stack[-1] // Inputs[1] { @04BF msg.data.length } 04B8 5B JUMPDEST 04B9 61 PUSH2 0x02cb 04BC 61 PUSH2 0x04c6 04BF 36 CALLDATASIZE 04C0 60 PUSH1 0x04 04C2 61 PUSH2 0x2c47 04C5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04B9 stack[0] = 0x02cb // @04BC stack[1] = 0x04c6 // @04BF stack[2] = msg.data.length // @04C0 stack[3] = 0x04 // } // Block ends with call to 0x2c47, returns to 0x04C6 label_04C6: // Incoming return from call to 0x2C47 at 0x04C5 04C6 5B JUMPDEST 04C7 61 PUSH2 0x13c5 04CA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13c5 label_04CB: // Incoming jump from 0x011B, if 0xbf424e7e == stack[-1] 04CB 5B JUMPDEST 04CC 61 PUSH2 0x0330 04CF 61 PUSH2 0x1471 04D2 56 *JUMP // Stack delta = +1 // Outputs[1] { @04CC stack[0] = 0x0330 } // Block ends with call to 0x1471, returns to 0x0330 label_04D3: // Incoming jump from 0x0092, if 0xc30f4a5a == stack[-1] // Inputs[1] { @04DA msg.data.length } 04D3 5B JUMPDEST 04D4 61 PUSH2 0x02cb 04D7 61 PUSH2 0x04e1 04DA 36 CALLDATASIZE 04DB 60 PUSH1 0x04 04DD 61 PUSH2 0x2df6 04E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04D4 stack[0] = 0x02cb // @04D7 stack[1] = 0x04e1 // @04DA stack[2] = msg.data.length // @04DB stack[3] = 0x04 // } // Block ends with call to 0x2df6, returns to 0x04E1 label_04E1: // Incoming return from call to 0x2DF6 at 0x04E0 04E1 5B JUMPDEST 04E2 61 PUSH2 0x147e 04E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x147e label_04E6: // Incoming jump from 0x009D, if 0xc39cbef1 == stack[-1] // Inputs[1] { @04ED msg.data.length } 04E6 5B JUMPDEST 04E7 61 PUSH2 0x02cb 04EA 61 PUSH2 0x04f4 04ED 36 CALLDATASIZE 04EE 60 PUSH1 0x04 04F0 61 PUSH2 0x2e41 04F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04E7 stack[0] = 0x02cb // @04EA stack[1] = 0x04f4 // @04ED stack[2] = msg.data.length // @04EE stack[3] = 0x04 // } // Block ends with call to 0x2e41, returns to 0x04F4 label_04F4: // Incoming return from call to 0x2E41 at 0x04F3 04F4 5B JUMPDEST 04F5 61 PUSH2 0x14bf 04F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14bf label_04F9: // Incoming jump from 0x00A8, if 0xc87b56dd == stack[-1] // Inputs[1] { @0500 msg.data.length } 04F9 5B JUMPDEST 04FA 61 PUSH2 0x02d5 04FD 61 PUSH2 0x0507 0500 36 CALLDATASIZE 0501 60 PUSH1 0x04 0503 61 PUSH2 0x2e29 0506 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04FA stack[0] = 0x02d5 // @04FD stack[1] = 0x0507 // @0500 stack[2] = msg.data.length // @0501 stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x0507 label_0507: // Incoming return from call to 0x2E29 at 0x0506 0507 5B JUMPDEST 0508 61 PUSH2 0x152f 050B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x152f label_050C: // Incoming jump from 0x00B3, if 0xcc371bf3 == stack[-1] // Inputs[1] { @0513 msg.data.length } 050C 5B JUMPDEST 050D 61 PUSH2 0x02cb 0510 61 PUSH2 0x051a 0513 36 CALLDATASIZE 0514 60 PUSH1 0x04 0516 61 PUSH2 0x2e29 0519 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @050D stack[0] = 0x02cb // @0510 stack[1] = 0x051a // @0513 stack[2] = msg.data.length // @0514 stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x051A label_051A: // Incoming return from call to 0x2E29 at 0x0519 051A 5B JUMPDEST 051B 61 PUSH2 0x1679 051E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1679 label_051F: // Incoming jump from 0x00BE, if 0xd9ecad7b == stack[-1] // Inputs[1] { @0526 msg.data.length } 051F 5B JUMPDEST 0520 61 PUSH2 0x02cb 0523 61 PUSH2 0x052d 0526 36 CALLDATASIZE 0527 60 PUSH1 0x04 0529 61 PUSH2 0x2e86 052C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0520 stack[0] = 0x02cb // @0523 stack[1] = 0x052d // @0526 stack[2] = msg.data.length // @0527 stack[3] = 0x04 // } // Block ends with call to 0x2e86, returns to 0x052D label_052D: // Incoming return from call to 0x2E86 at 0x052C 052D 5B JUMPDEST 052E 61 PUSH2 0x16b3 0531 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16b3 label_0532: // Incoming jump from 0x00C9, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0539 msg.data.length } 0532 5B JUMPDEST 0533 61 PUSH2 0x02a2 0536 61 PUSH2 0x0540 0539 36 CALLDATASIZE 053A 60 PUSH1 0x04 053C 61 PUSH2 0x2bd3 053F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0533 stack[0] = 0x02a2 // @0536 stack[1] = 0x0540 // @0539 stack[2] = msg.data.length // @053A stack[3] = 0x04 // } // Block ends with call to 0x2bd3, returns to 0x0540 label_0540: // Incoming return from call to 0x2BD3 at 0x053F 0540 5B JUMPDEST 0541 61 PUSH2 0x1872 0544 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1872 label_0545: // Incoming jump from 0x004B, if 0xf119f567 == stack[-1] // Inputs[1] { @054C msg.data.length } 0545 5B JUMPDEST 0546 61 PUSH2 0x02cb 0549 61 PUSH2 0x0553 054C 36 CALLDATASIZE 054D 60 PUSH1 0x04 054F 61 PUSH2 0x2e29 0552 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0546 stack[0] = 0x02cb // @0549 stack[1] = 0x0553 // @054C stack[2] = msg.data.length // @054D stack[3] = 0x04 // } // Block ends with call to 0x2e29, returns to 0x0553 label_0553: // Incoming return from call to 0x2E29 at 0x0552 0553 5B JUMPDEST 0554 61 PUSH2 0x18a0 0557 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x18a0 label_0558: // Incoming jump from 0x0056, if 0xf23a6e61 == stack[-1] // Inputs[1] { @055F msg.data.length } 0558 5B JUMPDEST 0559 61 PUSH2 0x056b 055C 61 PUSH2 0x0566 055F 36 CALLDATASIZE 0560 60 PUSH1 0x04 0562 61 PUSH2 0x2caf 0565 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0559 stack[0] = 0x056b // @055C stack[1] = 0x0566 // @055F stack[2] = msg.data.length // @0560 stack[3] = 0x04 // } // Block ends with call to 0x2caf, returns to 0x0566 label_0566: // Incoming return from call to 0x2CAF at 0x0565 0566 5B JUMPDEST 0567 61 PUSH2 0x1990 056A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1990 label_056B: // Incoming return from call to 0x0566 at 0x0565 // Inputs[2] // { // @056E memory[0x40:0x60] // @0572 stack[-1] // } 056B 5B JUMPDEST 056C 60 PUSH1 0x40 056E 51 MLOAD 056F 61 PUSH2 0x02af 0572 91 SWAP2 0573 90 SWAP1 0574 61 PUSH2 0x3155 0577 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0572 stack[-1] = 0x02af // @0573 stack[1] = memory[0x40:0x60] // @0573 stack[0] = stack[-1] // } // Block ends with call to 0x3155, returns to 0x02AF label_0578: // Incoming jump from 0x0061, if 0xf27620f7 == stack[-1] 0578 5B JUMPDEST 0579 61 PUSH2 0x02f5 057C 61 PUSH2 0x19d8 057F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0579 stack[0] = 0x02f5 } // Block ends with call to 0x19d8, returns to 0x02F5 label_0580: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @0587 msg.data.length } 0580 5B JUMPDEST 0581 61 PUSH2 0x02cb 0584 61 PUSH2 0x058e 0587 36 CALLDATASIZE 0588 60 PUSH1 0x04 058A 61 PUSH2 0x2bb8 058D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0581 stack[0] = 0x02cb // @0584 stack[1] = 0x058e // @0587 stack[2] = msg.data.length // @0588 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2bb8 058E 5B JUMPDEST 058F 61 PUSH2 0x19f0 0592 56 *JUMP label_0593: // Incoming jump from 0x0077, if 0xf535f546 == stack[-1] // Inputs[1] { @059A msg.data.length } 0593 5B JUMPDEST 0594 61 PUSH2 0x02cb 0597 61 PUSH2 0x05a1 059A 36 CALLDATASIZE 059B 60 PUSH1 0x04 059D 61 PUSH2 0x2bb8 05A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0594 stack[0] = 0x02cb // @0597 stack[1] = 0x05a1 // @059A stack[2] = msg.data.length // @059B stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2bb8 05A1 5B JUMPDEST 05A2 61 PUSH2 0x1aa7 05A5 56 *JUMP label_05A6: // Incoming jump from 0x0082, if 0xfa75796a == stack[-1] 05A6 5B JUMPDEST 05A7 61 PUSH2 0x0330 05AA 61 PUSH2 0x1afe 05AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @05A7 stack[0] = 0x0330 } // Block ends with call to 0x1afe, returns to 0x0330 label_05AE: // Incoming jump from 0x02A1 // Inputs[4] // { // @05B8 stack[-1] // @05C7 memory[0x00:0x40] // @05C8 storage[keccak256(memory[0x00:0x40])] // @05CD stack[-2] // } 05AE 5B JUMPDEST 05AF 60 PUSH1 0x01 05B1 60 PUSH1 0x01 05B3 60 PUSH1 0xe0 05B5 1B SHL 05B6 03 SUB 05B7 19 NOT 05B8 81 DUP2 05B9 16 AND 05BA 60 PUSH1 0x00 05BC 90 SWAP1 05BD 81 DUP2 05BE 52 MSTORE 05BF 60 PUSH1 0x20 05C1 81 DUP2 05C2 90 SWAP1 05C3 52 MSTORE 05C4 60 PUSH1 0x40 05C6 90 SWAP1 05C7 20 SHA3 05C8 54 SLOAD 05C9 60 PUSH1 0xff 05CB 16 AND 05CC 5B JUMPDEST 05CD 91 SWAP2 05CE 90 SWAP1 05CF 50 POP 05D0 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @05BE memory[0x00:0x20] = stack[-1] & ~((0x01 << 0xe0) - 0x01) // @05C3 memory[0x20:0x40] = 0x00 // @05CD stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_05D1: // Incoming jump from 0x02CA // Inputs[1] { @05D5 stack[-4] } 05D1 5B JUMPDEST 05D2 61 PUSH2 0x05da 05D5 84 DUP5 05D6 61 PUSH2 0x1b3c 05D9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05D2 stack[0] = 0x05da // @05D5 stack[1] = stack[-4] // } // Block ends with call to 0x1b3c, returns to 0x05DA label_05DA: // Incoming return from call to 0x1B3C at 0x05D9 // Inputs[1] { @05DE stack[-1] } 05DA 5B JUMPDEST 05DB 61 PUSH2 0x05ff 05DE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05ff, if stack[-1] label_05DF: // Incoming jump from 0x05DE, if not stack[-1] // Inputs[1] { @05E1 memory[0x40:0x60] } 05DF 60 PUSH1 0x40 05E1 51 MLOAD 05E2 62 PUSH3 0x461bcd 05E6 60 PUSH1 0xe5 05E8 1B SHL 05E9 81 DUP2 05EA 52 MSTORE 05EB 60 PUSH1 0x04 05ED 01 ADD 05EE 61 PUSH2 0x05f6 05F1 90 SWAP1 05F2 61 PUSH2 0x33ae 05F5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05F1 stack[0] = 0x05f6 // @05F1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x33ae, returns to 0x05F6 label_05F6: // Incoming return from call to 0x31F6 at 0x1CB4 // Incoming return from call to 0x3666 at 0x16AD // Incoming return from call to 0x3666 at 0x14B2 // Incoming return from call to 0x3377 at 0x1316 // Incoming return from call to 0x383F at 0x19C4 // Incoming return from call to 0x3532 at 0x1D3B // Incoming return from call to 0x3464 at 0x06C0 // Incoming return from call to 0x3666 at 0x0EFA // Incoming return from call to 0x317D at 0x1DB5 // Incoming return from call to 0x33D6 at 0x1D06 // Incoming return from call to 0x3574 at 0x26C4 // Incoming return from call to 0x31B4 at 0x267D // Incoming return from call to 0x33AE at 0x05F5 // Incoming return from call to 0x35B6 at 0x1DE5 // Inputs[3] // { // @05F9 memory[0x40:0x60] // @05FB stack[-1] // @05FE memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05F6 5B JUMPDEST 05F7 60 PUSH1 0x40 05F9 51 MLOAD 05FA 80 DUP1 05FB 91 SWAP2 05FC 03 SUB 05FD 90 SWAP1 05FE FD *REVERT // Stack delta = -1 // Outputs[1] { @05FE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_05FF: // Incoming jump from 0x05DE, if stack[-1] // Inputs[1] { @0605 stack[-4] } 05FF 5B JUMPDEST 0600 60 PUSH1 0x00 0602 61 PUSH2 0x060a 0605 85 DUP6 0606 61 PUSH2 0x1be8 0609 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0600 stack[0] = 0x00 // @0602 stack[1] = 0x060a // @0605 stack[2] = stack[-4] // } // Block ends with call to 0x1be8, returns to 0x060A label_060A: // Incoming return from call to 0x1BE8 at 0x0609 // Inputs[8] // { // @060B stack[-1] // @060B stack[-2] // @062E stack[-4] // @062F stack[-3] // @0640 memory[0x40:0x60] // @0657 msg.data[stack[-4]:stack[-4] + stack[-3]] // @0664 memory[0x40:0x60] // @0671 stack[-5] // } 060A 5B JUMPDEST 060B 90 SWAP1 060C 50 POP 060D 73 PUSH20 0x5e5e683b687f509968d90acd31ce6b8cfa3d25e4 0622 60 PUSH1 0x01 0624 60 PUSH1 0x01 0626 60 PUSH1 0xa0 0628 1B SHL 0629 03 SUB 062A 16 AND 062B 61 PUSH2 0x069b 062E 84 DUP5 062F 84 DUP5 0630 80 DUP1 0631 80 DUP1 0632 60 PUSH1 0x1f 0634 01 ADD 0635 60 PUSH1 0x20 0637 80 DUP1 0638 91 SWAP2 0639 04 DIV 063A 02 MUL 063B 60 PUSH1 0x20 063D 01 ADD 063E 60 PUSH1 0x40 0640 51 MLOAD 0641 90 SWAP1 0642 81 DUP2 0643 01 ADD 0644 60 PUSH1 0x40 0646 52 MSTORE 0647 80 DUP1 0648 93 SWAP4 0649 92 SWAP3 064A 91 SWAP2 064B 90 SWAP1 064C 81 DUP2 064D 81 DUP2 064E 52 MSTORE 064F 60 PUSH1 0x20 0651 01 ADD 0652 83 DUP4 0653 83 DUP4 0654 80 DUP1 0655 82 DUP3 0656 84 DUP5 0657 37 CALLDATACOPY 0658 60 PUSH1 0x00 065A 92 SWAP3 065B 01 ADD 065C 91 SWAP2 065D 90 SWAP1 065E 91 SWAP2 065F 52 MSTORE 0660 50 POP 0661 50 POP 0662 60 PUSH1 0x40 0664 51 MLOAD 0665 61 PUSH2 0x0695 0668 92 SWAP3 0669 50 POP 066A 61 PUSH2 0x067a 066D 91 SWAP2 066E 50 POP 066F 86 DUP7 0670 90 SWAP1 0671 8A DUP11 0672 90 SWAP1 0673 60 PUSH1 0x20 0675 01 ADD 0676 61 PUSH2 0x3062 0679 56 *JUMP // Stack delta = +7 // Outputs[13] // { // @060B stack[-2] = stack[-1] // @062A stack[-1] = (0x01 << 0xa0) - 0x01 & 0x5e5e683b687f509968d90acd31ce6b8cfa3d25e4 // @062B stack[0] = 0x069b // @0646 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-3]) / 0x20 * 0x20 // @0648 stack[1] = memory[0x40:0x60] // @064E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0657 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-3]] = msg.data[stack[-4]:stack[-4] + stack[-3]] // @065F memory[0x20 + memory[0x40:0x60] + stack[-3]:0x20 + memory[0x40:0x60] + stack[-3] + 0x20] = 0x00 // @0668 stack[2] = 0x0695 // @066D stack[3] = 0x067a // @0670 stack[4] = stack[-1] // @0672 stack[5] = stack[-5] // @0675 stack[6] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3062, returns to 0x067A label_067A: // Incoming return from call to 0x3062 at 0x0679 // Inputs[4] // { // @067D memory[0x40:0x60] // @0681 stack[-1] // @068B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0690 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 067A 5B JUMPDEST 067B 60 PUSH1 0x40 067D 51 MLOAD 067E 60 PUSH1 0x20 0680 81 DUP2 0681 83 DUP4 0682 03 SUB 0683 03 SUB 0684 81 DUP2 0685 52 MSTORE 0686 90 SWAP1 0687 60 PUSH1 0x40 0689 52 MSTORE 068A 80 DUP1 068B 51 MLOAD 068C 90 SWAP1 068D 60 PUSH1 0x20 068F 01 ADD 0690 20 SHA3 0691 61 PUSH2 0x1c62 0694 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0685 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0689 memory[0x40:0x60] = stack[-1] // @0690 stack[-1] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x1c62 label_0695: // Incoming return from call to 0x067A at 0x0679 // Inputs[2] // { // @0696 stack[-2] // @0696 stack[-1] // } 0695 5B JUMPDEST 0696 90 SWAP1 0697 61 PUSH2 0x1c92 069A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0696 stack[-1] = stack[-2] // @0696 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x1c92 label_069B: // Incoming return from call to 0x0695 at 0x0679 // Inputs[2] // { // @06A4 stack[-1] // @06A5 stack[-2] // } 069B 5B JUMPDEST 069C 60 PUSH1 0x01 069E 60 PUSH1 0x01 06A0 60 PUSH1 0xa0 06A2 1B SHL 06A3 03 SUB 06A4 16 AND 06A5 14 EQ 06A6 61 PUSH2 0x06c1 06A9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x06c1, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_06AA: // Incoming jump from 0x06A9, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @06AC memory[0x40:0x60] } 06AA 60 PUSH1 0x40 06AC 51 MLOAD 06AD 62 PUSH3 0x461bcd 06B1 60 PUSH1 0xe5 06B3 1B SHL 06B4 81 DUP2 06B5 52 MSTORE 06B6 60 PUSH1 0x04 06B8 01 ADD 06B9 61 PUSH2 0x05f6 06BC 90 SWAP1 06BD 61 PUSH2 0x3464 06C0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06BC stack[0] = 0x05f6 // @06BC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3464, returns to 0x05F6 label_06C1: // Incoming jump from 0x06A9, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[8] // { // @06C5 memory[0x40:0x60] // @06CB stack[-4] // @06CE block.timestamp // @06D9 stack[-1] // @06E4 memory[0x00:0x40] // @06E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @06EA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @06F4 msg.sender // } 06C1 5B JUMPDEST 06C2 60 PUSH1 0x40 06C4 80 DUP1 06C5 51 MLOAD 06C6 80 DUP1 06C7 82 DUP3 06C8 01 ADD 06C9 82 DUP3 06CA 52 MSTORE 06CB 85 DUP6 06CC 81 DUP2 06CD 52 MSTORE 06CE 42 TIMESTAMP 06CF 60 PUSH1 0x20 06D1 80 DUP1 06D2 83 DUP4 06D3 01 ADD 06D4 91 SWAP2 06D5 82 DUP3 06D6 52 MSTORE 06D7 60 PUSH1 0x00 06D9 85 DUP6 06DA 81 DUP2 06DB 52 MSTORE 06DC 60 PUSH1 0x0f 06DE 90 SWAP1 06DF 91 SWAP2 06E0 52 MSTORE 06E1 92 SWAP3 06E2 90 SWAP1 06E3 92 SWAP3 06E4 20 SHA3 06E5 90 SWAP1 06E6 51 MLOAD 06E7 81 DUP2 06E8 55 SSTORE 06E9 90 SWAP1 06EA 51 MLOAD 06EB 60 PUSH1 0x01 06ED 90 SWAP1 06EE 91 SWAP2 06EF 01 ADD 06F0 55 SSTORE 06F1 61 PUSH2 0x06fa 06F4 33 CALLER 06F5 82 DUP3 06F6 61 PUSH2 0x1dc0 06F9 56 *JUMP // Stack delta = +3 // Outputs[10] // { // @06CA memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @06CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @06D6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = block.timestamp // @06DB memory[0x00:0x20] = stack[-1] // @06E0 memory[0x20:0x40] = 0x0f // @06E8 storage[keccak256(memory[0x00:0x40])] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @06F0 storage[keccak256(memory[0x00:0x40]) + 0x01] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @06F1 stack[0] = 0x06fa // @06F4 stack[1] = msg.sender // @06F5 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1dc0 06FA 5B JUMPDEST 06FB 60 PUSH1 0x40 06FD 51 MLOAD 06FE 63 PUSH4 0x79212195 0703 60 PUSH1 0xe1 0705 1B SHL 0706 81 DUP2 0707 52 MSTORE 0708 73 PUSH20 0x495f947276749ce646f68ac8c248420045cb7b5e 071D 90 SWAP1 071E 63 PUSH4 0xf242432a 0723 90 SWAP1 0724 61 PUSH2 0x073a 0727 90 SWAP1 0728 33 CALLER 0729 90 SWAP1 072A 61 PUSH2 0xdead 072D 90 SWAP1 072E 8A DUP11 072F 90 SWAP1 0730 60 PUSH1 0x01 0732 90 SWAP1 0733 60 PUSH1 0x04 0735 01 ADD 0736 61 PUSH2 0x30db 0739 56 *JUMP 073A 5B JUMPDEST 073B 60 PUSH1 0x00 073D 60 PUSH1 0x40 073F 51 MLOAD 0740 80 DUP1 0741 83 DUP4 0742 03 SUB 0743 81 DUP2 0744 60 PUSH1 0x00 0746 87 DUP8 0747 80 DUP1 0748 3B EXTCODESIZE 0749 15 ISZERO 074A 80 DUP1 074B 15 ISZERO 074C 61 PUSH2 0x0754 074F 57 *JUMPI 0750 60 PUSH1 0x00 0752 80 DUP1 0753 FD *REVERT 0754 5B JUMPDEST 0755 50 POP 0756 5A GAS 0757 F1 CALL 0758 15 ISZERO 0759 80 DUP1 075A 15 ISZERO 075B 61 PUSH2 0x0768 075E 57 *JUMPI 075F 3D RETURNDATASIZE 0760 60 PUSH1 0x00 0762 80 DUP1 0763 3E RETURNDATACOPY 0764 3D RETURNDATASIZE 0765 60 PUSH1 0x00 0767 FD *REVERT 0768 5B JUMPDEST 0769 50 POP 076A 50 POP 076B 60 PUSH1 0x12 076D 54 SLOAD 076E 60 PUSH1 0x40 0770 51 MLOAD 0771 63 PUSH4 0xcc240c01 0776 60 PUSH1 0xe0 0778 1B SHL 0779 81 DUP2 077A 52 MSTORE 077B 60 PUSH1 0x01 077D 60 PUSH1 0x01 077F 60 PUSH1 0xa0 0781 1B SHL 0782 03 SUB 0783 90 SWAP1 0784 91 SWAP2 0785 16 AND 0786 92 SWAP3 0787 50 POP 0788 63 PUSH4 0xcc240c01 078D 91 SWAP2 078E 50 POP 078F 61 PUSH2 0x079f 0792 90 SWAP1 0793 33 CALLER 0794 90 SWAP1 0795 60 PUSH1 0x01 0797 90 SWAP1 0798 60 PUSH1 0x04 079A 01 ADD 079B 61 PUSH2 0x3113 079E 56 *JUMP 079F 5B JUMPDEST 07A0 60 PUSH1 0x00 07A2 60 PUSH1 0x40 07A4 51 MLOAD 07A5 80 DUP1 07A6 83 DUP4 07A7 03 SUB 07A8 81 DUP2 07A9 60 PUSH1 0x00 07AB 87 DUP8 07AC 80 DUP1 07AD 3B EXTCODESIZE 07AE 15 ISZERO 07AF 80 DUP1 07B0 15 ISZERO 07B1 61 PUSH2 0x07b9 07B4 57 *JUMPI 07B5 60 PUSH1 0x00 07B7 80 DUP1 07B8 FD *REVERT 07B9 5B JUMPDEST 07BA 50 POP 07BB 5A GAS 07BC F1 CALL 07BD 15 ISZERO 07BE 80 DUP1 07BF 15 ISZERO 07C0 61 PUSH2 0x07cd 07C3 57 *JUMPI 07C4 3D RETURNDATASIZE 07C5 60 PUSH1 0x00 07C7 80 DUP1 07C8 3E RETURNDATACOPY 07C9 3D RETURNDATASIZE 07CA 60 PUSH1 0x00 07CC FD *REVERT 07CD 5B JUMPDEST 07CE 50 POP 07CF 50 POP 07D0 33 CALLER 07D1 60 PUSH1 0x00 07D3 90 SWAP1 07D4 81 DUP2 07D5 52 MSTORE 07D6 60 PUSH1 0x10 07D8 60 PUSH1 0x20 07DA 52 MSTORE 07DB 60 PUSH1 0x40 07DD 90 SWAP1 07DE 81 DUP2 07DF 90 SWAP1 07E0 20 SHA3 07E1 80 DUP1 07E2 54 SLOAD 07E3 60 PUSH1 0x01 07E5 01 ADD 07E6 90 SWAP1 07E7 55 SSTORE 07E8 51 MLOAD 07E9 7F PUSH32 0x338ecae7e0cfb58419f5abadadb411fcd7243a3275c945c6b4227367aaec82c3 080A 92 SWAP3 080B 50 POP 080C 61 PUSH2 0x0819 080F 91 SWAP2 0810 50 POP 0811 83 DUP4 0812 90 SWAP1 0813 87 DUP8 0814 90 SWAP1 0815 61 PUSH2 0x3062 0818 56 *JUMP 0819 5B JUMPDEST 081A 60 PUSH1 0x40 081C 51 MLOAD 081D 80 DUP1 081E 91 SWAP2 081F 03 SUB 0820 90 SWAP1 0821 A1 LOG1 0822 50 POP 0823 50 POP 0824 50 POP 0825 50 POP 0826 50 POP 0827 56 *JUMP label_0828: // Incoming call from 0x02D4, returns to 0x02D5 // Inputs[2] // { // @082C storage[0x06] // @0830 memory[0x40:0x60] // } 0828 5B JUMPDEST 0829 60 PUSH1 0x06 082B 80 DUP1 082C 54 SLOAD 082D 60 PUSH1 0x40 082F 80 DUP1 0830 51 MLOAD 0831 60 PUSH1 0x20 0833 60 PUSH1 0x1f 0835 60 PUSH1 0x02 0837 60 PUSH1 0x00 0839 19 NOT 083A 61 PUSH2 0x0100 083D 60 PUSH1 0x01 083F 88 DUP9 0840 16 AND 0841 15 ISZERO 0842 02 MUL 0843 01 ADD 0844 90 SWAP1 0845 95 SWAP6 0846 16 AND 0847 94 SWAP5 0848 90 SWAP1 0849 94 SWAP5 084A 04 DIV 084B 93 SWAP4 084C 84 DUP5 084D 01 ADD 084E 81 DUP2 084F 90 SWAP1 0850 04 DIV 0851 81 DUP2 0852 02 MUL 0853 82 DUP3 0854 01 ADD 0855 81 DUP2 0856 01 ADD 0857 90 SWAP1 0858 92 SWAP3 0859 52 MSTORE 085A 82 DUP3 085B 81 DUP2 085C 52 MSTORE 085D 60 PUSH1 0x60 085F 93 SWAP4 0860 90 SWAP1 0861 92 SWAP3 0862 90 SWAP1 0863 91 SWAP2 0864 83 DUP4 0865 01 ADD 0866 82 DUP3 0867 82 DUP3 0868 80 DUP1 0869 15 ISZERO 086A 61 PUSH2 0x08b4 086D 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0859 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @085C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 // @085F stack[0] = 0x60 // @0861 stack[1] = memory[0x40:0x60] // @0862 stack[3] = (storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0863 stack[2] = 0x06 // @0865 stack[4] = memory[0x40:0x60] + 0x20 // @0866 stack[5] = 0x06 // @0867 stack[6] = (storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x08b4, if !((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02) label_086E: // Incoming jump from 0x086D, if not !((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @086E stack[-1] } 086E 80 DUP1 086F 60 PUSH1 0x1f 0871 10 LT 0872 61 PUSH2 0x0889 0875 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0889, if 0x1f < stack[-1] label_0876: // Incoming jump from 0x0875, if not 0x1f < stack[-1] // Inputs[4] // { // @087A stack[-2] // @087B storage[stack[-2]] // @087E stack[-3] // @0880 stack[-1] // } 0876 61 PUSH2 0x0100 0879 80 DUP1 087A 83 DUP4 087B 54 SLOAD 087C 04 DIV 087D 02 MUL 087E 83 DUP4 087F 52 MSTORE 0880 91 SWAP2 0881 60 PUSH1 0x20 0883 01 ADD 0884 91 SWAP2 0885 61 PUSH2 0x08b4 0888 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @087F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0884 stack[-1] = stack[-1] // @0884 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08b4 label_0889: // Incoming jump from 0x0875, if 0x1f < stack[-1] // Incoming jump from 0x0DC8, if 0x1f < stack[-1] // Incoming jump from 0x10DF, if 0x1f < stack[-1] // Inputs[5] // { // @088A stack[-3] // @088B stack[-1] // @088D stack[-2] // @0895 memory[0x00:0x20] // @0899 storage[keccak256(memory[0x00:0x20])] // } 0889 5B JUMPDEST 088A 82 DUP3 088B 01 ADD 088C 91 SWAP2 088D 90 SWAP1 088E 60 PUSH1 0x00 0890 52 MSTORE 0891 60 PUSH1 0x20 0893 60 PUSH1 0x00 0895 20 SHA3 0896 90 SWAP1 0897 5B JUMPDEST 0898 81 DUP2 0899 54 SLOAD 089A 81 DUP2 089B 52 MSTORE 089C 90 SWAP1 089D 60 PUSH1 0x01 089F 01 ADD 08A0 90 SWAP1 08A1 60 PUSH1 0x20 08A3 01 ADD 08A4 80 DUP1 08A5 83 DUP4 08A6 11 GT 08A7 61 PUSH2 0x0897 08AA 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @088C stack[-3] = stack[-3] + stack[-1] // @0890 memory[0x00:0x20] = stack[-2] // @089B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @08A0 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @08A3 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0897, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_08AB: // Incoming jump from 0x08AA, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x08AA, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @08AB stack[-3] // @08AC stack[-1] // } 08AB 82 DUP3 08AC 90 SWAP1 08AD 03 SUB 08AE 60 PUSH1 0x1f 08B0 16 AND 08B1 82 DUP3 08B2 01 ADD 08B3 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @08B3 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @08B3 stack[-1] = stack[-3] // } // Block continues label_08B4: // Incoming jump from 0x0DDB // Incoming jump from 0x10F2 // Incoming jump from 0x0888 // Incoming jump from 0x10D7, if !((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x086D, if !((storage[0x06] & !(storage[0x06] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0DC0, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x08B3 // Inputs[3] // { // @08BA stack[-6] // @08BA stack[-7] // @08BC stack[-8] // } 08B4 5B JUMPDEST 08B5 50 POP 08B6 50 POP 08B7 50 POP 08B8 50 POP 08B9 50 POP 08BA 90 SWAP1 08BB 50 POP 08BC 90 SWAP1 08BD 56 *JUMP // Stack delta = -7 // Outputs[1] { @08BC stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_08BE: // Incoming jump from 0x02F4 // Inputs[1] { @08C4 stack[-1] } 08BE 5B JUMPDEST 08BF 60 PUSH1 0x00 08C1 61 PUSH2 0x08c9 08C4 82 DUP3 08C5 61 PUSH2 0x1e84 08C8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08BF stack[0] = 0x00 // @08C1 stack[1] = 0x08c9 // @08C4 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1e84 08C9 5B JUMPDEST 08CA 61 PUSH2 0x08e5 08CD 57 *JUMPI 08CE 60 PUSH1 0x40 08D0 51 MLOAD 08D1 62 PUSH3 0x461bcd 08D5 60 PUSH1 0xe5 08D7 1B SHL 08D8 81 DUP2 08D9 52 MSTORE 08DA 60 PUSH1 0x04 08DC 01 ADD 08DD 61 PUSH2 0x05f6 08E0 90 SWAP1 08E1 61 PUSH2 0x361a 08E4 56 *JUMP 08E5 5B JUMPDEST 08E6 50 POP 08E7 60 PUSH1 0x00 08E9 90 SWAP1 08EA 81 DUP2 08EB 52 MSTORE 08EC 60 PUSH1 0x04 08EE 60 PUSH1 0x20 08F0 52 MSTORE 08F1 60 PUSH1 0x40 08F3 90 SWAP1 08F4 20 SHA3 08F5 54 SLOAD 08F6 60 PUSH1 0x01 08F8 60 PUSH1 0x01 08FA 60 PUSH1 0xa0 08FC 1B SHL 08FD 03 SUB 08FE 16 AND 08FF 90 SWAP1 0900 56 *JUMP label_0901: // Incoming jump from 0x0314 // Inputs[1] { @0907 stack[-1] } 0901 5B JUMPDEST 0902 60 PUSH1 0x00 0904 61 PUSH2 0x090c 0907 82 DUP3 0908 61 PUSH2 0x0d53 090B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0902 stack[0] = 0x00 // @0904 stack[1] = 0x090c // @0907 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0d53 090C 5B JUMPDEST 090D 90 SWAP1 090E 50 POP 090F 80 DUP1 0910 60 PUSH1 0x01 0912 60 PUSH1 0x01 0914 60 PUSH1 0xa0 0916 1B SHL 0917 03 SUB 0918 16 AND 0919 83 DUP4 091A 60 PUSH1 0x01 091C 60 PUSH1 0x01 091E 60 PUSH1 0xa0 0920 1B SHL 0921 03 SUB 0922 16 AND 0923 14 EQ 0924 15 ISZERO 0925 61 PUSH2 0x0940 0928 57 *JUMPI 0929 60 PUSH1 0x40 092B 51 MLOAD 092C 62 PUSH3 0x461bcd 0930 60 PUSH1 0xe5 0932 1B SHL 0933 81 DUP2 0934 52 MSTORE 0935 60 PUSH1 0x04 0937 01 ADD 0938 61 PUSH2 0x05f6 093B 90 SWAP1 093C 61 PUSH2 0x3776 093F 56 *JUMP 0940 5B JUMPDEST 0941 80 DUP1 0942 60 PUSH1 0x01 0944 60 PUSH1 0x01 0946 60 PUSH1 0xa0 0948 1B SHL 0949 03 SUB 094A 16 AND 094B 61 PUSH2 0x0952 094E 61 PUSH2 0x1e91 0951 56 *JUMP 0952 5B JUMPDEST 0953 60 PUSH1 0x01 0955 60 PUSH1 0x01 0957 60 PUSH1 0xa0 0959 1B SHL 095A 03 SUB 095B 16 AND 095C 14 EQ 095D 80 DUP1 095E 61 PUSH2 0x096e 0961 57 *JUMPI 0962 50 POP 0963 61 PUSH2 0x096e 0966 81 DUP2 0967 61 PUSH2 0x0540 096A 61 PUSH2 0x1e91 096D 56 *JUMP 096E 5B JUMPDEST 096F 61 PUSH2 0x098a 0972 57 *JUMPI 0973 60 PUSH1 0x40 0975 51 MLOAD 0976 62 PUSH3 0x461bcd 097A 60 PUSH1 0xe5 097C 1B SHL 097D 81 DUP2 097E 52 MSTORE 097F 60 PUSH1 0x04 0981 01 ADD 0982 61 PUSH2 0x05f6 0985 90 SWAP1 0986 61 PUSH2 0x348b 0989 56 *JUMP 098A 5B JUMPDEST 098B 61 PUSH2 0x0994 098E 83 DUP4 098F 83 DUP4 0990 61 PUSH2 0x1e95 0993 56 *JUMP 0994 5B JUMPDEST 0995 50 POP 0996 50 POP 0997 50 POP 0998 56 *JUMP label_0999: // Incoming jump from 0x0327 // Inputs[1] { @09A1 stack[-1] } 0999 5B JUMPDEST 099A 60 PUSH1 0x00 099C 60 PUSH1 0x0d 099E 61 PUSH2 0x09a6 09A1 83 DUP4 09A2 61 PUSH2 0x0f70 09A5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @099A stack[0] = 0x00 // @099C stack[1] = 0x0d // @099E stack[2] = 0x09a6 // @09A1 stack[3] = stack[-1] // } // Block ends with call to 0x0f70, returns to 0x09A6 label_09A6: // Incoming return from call to 0x0F70 at 0x09A5 // Inputs[2] // { // @09A9 memory[0x40:0x60] // @09AD stack[-1] // } 09A6 5B JUMPDEST 09A7 60 PUSH1 0x40 09A9 51 MLOAD 09AA 61 PUSH2 0x09b3 09AD 91 SWAP2 09AE 90 SWAP1 09AF 61 PUSH2 0x2f24 09B2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09AD stack[-1] = 0x09b3 // @09AE stack[1] = memory[0x40:0x60] // @09AE stack[0] = stack[-1] // } // Block ends with call to 0x2f24, returns to 0x09B3 label_09B3: // Incoming return from call to 0x2F24 at 0x09B2 // Inputs[8] // { // @09B4 stack[-2] // @09B4 stack[-1] // @09B9 memory[0x40:0x60] // @09C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (stack[-1] - memory[0x40:0x60])] // @09C3 storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (stack[-1] - memory[0x40:0x60])])] // @09C7 stack[-3] // @09C9 stack[-5] // @09CA stack[-4] // } 09B3 5B JUMPDEST 09B4 90 SWAP1 09B5 81 DUP2 09B6 52 MSTORE 09B7 60 PUSH1 0x40 09B9 51 MLOAD 09BA 90 SWAP1 09BB 81 DUP2 09BC 90 SWAP1 09BD 03 SUB 09BE 60 PUSH1 0x20 09C0 01 ADD 09C1 90 SWAP1 09C2 20 SHA3 09C3 54 SLOAD 09C4 60 PUSH1 0xff 09C6 16 AND 09C7 90 SWAP1 09C8 50 POP 09C9 91 SWAP2 09CA 90 SWAP1 09CB 50 POP 09CC 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @09B6 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @09C9 stack[-5] = 0xff & storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (stack[-1] - memory[0x40:0x60])])] // } // Block ends with unconditional jump to stack[-5] label_09CD: // Incoming jump from 0x032F 09CD 5B JUMPDEST 09CE 60 PUSH1 0x00 09D0 61 PUSH2 0x09d9 09D3 60 PUSH1 0x02 09D5 61 PUSH2 0x1f03 09D8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09CE stack[0] = 0x00 // @09D0 stack[1] = 0x09d9 // @09D3 stack[2] = 0x02 // } // Block ends with unconditional jump to 0x1f03 09D9 5B JUMPDEST 09DA 90 SWAP1 09DB 50 POP 09DC 90 SWAP1 09DD 56 *JUMP label_09DE: // Incoming jump from 0x034F // Inputs[5] // { // @09E1 storage[0x12] // @09E4 memory[0x40:0x60] // @0A05 stack[-3] // @0A07 stack[-2] // @0A09 stack[-1] // } 09DE 5B JUMPDEST 09DF 60 PUSH1 0x12 09E1 54 SLOAD 09E2 60 PUSH1 0x40 09E4 51 MLOAD 09E5 63 PUSH4 0x164746fd 09EA 60 PUSH1 0xe1 09EC 1B SHL 09ED 81 DUP2 09EE 52 MSTORE 09EF 60 PUSH1 0x01 09F1 60 PUSH1 0x01 09F3 60 PUSH1 0xa0 09F5 1B SHL 09F6 03 SUB 09F7 90 SWAP1 09F8 91 SWAP2 09F9 16 AND 09FA 90 SWAP1 09FB 63 PUSH4 0x2c8e8dfa 0A00 90 SWAP1 0A01 61 PUSH2 0x0a12 0A04 90 SWAP1 0A05 86 DUP7 0A06 90 SWAP1 0A07 86 DUP7 0A08 90 SWAP1 0A09 86 DUP7 0A0A 90 SWAP1 0A0B 60 PUSH1 0x04 0A0D 01 ADD 0A0E 61 PUSH2 0x3084 0A11 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @09EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x164746fd << 0xe1 // @09FA stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0A00 stack[1] = 0x2c8e8dfa // @0A04 stack[2] = 0x0a12 // @0A06 stack[3] = stack[-3] // @0A08 stack[4] = stack[-2] // @0A0A stack[5] = stack[-1] // @0A0D stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3084, returns to 0x0A12 label_0A12: // Incoming return from call to 0x3084 at 0x0A11 // Inputs[4] // { // @0A17 memory[0x40:0x60] // @0A19 stack[-1] // @0A1E stack[-3] // @0A20 address(stack[-3]).code.length // } 0A12 5B JUMPDEST 0A13 60 PUSH1 0x00 0A15 60 PUSH1 0x40 0A17 51 MLOAD 0A18 80 DUP1 0A19 83 DUP4 0A1A 03 SUB 0A1B 81 DUP2 0A1C 60 PUSH1 0x00 0A1E 87 DUP8 0A1F 80 DUP1 0A20 3B EXTCODESIZE 0A21 15 ISZERO 0A22 80 DUP1 0A23 15 ISZERO 0A24 61 PUSH2 0x0a2c 0A27 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0A13 stack[0] = 0x00 // @0A17 stack[1] = memory[0x40:0x60] // @0A1A stack[2] = stack[-1] - memory[0x40:0x60] // @0A1B stack[3] = memory[0x40:0x60] // @0A1C stack[4] = 0x00 // @0A1E stack[5] = stack[-3] // @0A21 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0a2c, if !!address(stack[-3]).code.length label_0A28: // Incoming jump from 0x0A27, if not !!address(stack[-3]).code.length // Inputs[1] { @0A2B memory[0x00:0x00] } 0A28 60 PUSH1 0x00 0A2A 80 DUP1 0A2B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A2B revert(memory[0x00:0x00]); } // Block terminates label_0A2C: // Incoming jump from 0x0A27, if !!address(stack[-3]).code.length // Inputs[9] // { // @0A2E msg.gas // @0A2F memory[stack[-4]:stack[-4] + stack[-5]] // @0A2F stack[-3] // @0A2F stack[-6] // @0A2F stack[-2] // @0A2F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0A2F stack[-4] // @0A2F stack[-7] // @0A2F stack[-5] // } 0A2C 5B JUMPDEST 0A2D 50 POP 0A2E 5A GAS 0A2F F1 CALL 0A30 15 ISZERO 0A31 80 DUP1 0A32 15 ISZERO 0A33 61 PUSH2 0x0a40 0A36 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0A2F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0A30 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 0x0a40, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0A37: // Incoming jump from 0x0A36, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0A37 returndata.length // @0A3B returndata[0x00:0x00 + returndata.length] // @0A3C returndata.length // @0A3F memory[0x00:0x00 + returndata.length] // } 0A37 3D RETURNDATASIZE 0A38 60 PUSH1 0x00 0A3A 80 DUP1 0A3B 3E RETURNDATACOPY 0A3C 3D RETURNDATASIZE 0A3D 60 PUSH1 0x00 0A3F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A3B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A3F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A40: // Incoming jump from 0x0A36, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0A48 stack[-5] } 0A40 5B JUMPDEST 0A41 50 POP 0A42 50 POP 0A43 50 POP 0A44 50 POP 0A45 61 PUSH2 0x03e9 0A48 81 DUP2 0A49 10 LT 0A4A 15 ISZERO 0A4B 61 PUSH2 0x0a7e 0A4E 57 *JUMPI // Stack delta = -4 // Block ends with conditional jump to 0x0a7e, if !(stack[-5] < 0x03e9) label_0A4F: // Incoming jump from 0x0A4E, if not !(stack[-5] < 0x03e9) // Inputs[7] // { // @0A58 stack[-3] // @0A68 memory[0x00:0x40] // @0A6A storage[keccak256(memory[0x00:0x40])] // @0A72 stack[-2] // @0A76 memory[0x00:0x40] // @0A78 storage[keccak256(memory[0x00:0x40])] // @0A84 stack[-1] // } 0A4F 60 PUSH1 0x01 0A51 60 PUSH1 0x01 0A53 60 PUSH1 0xa0 0A55 1B SHL 0A56 03 SUB 0A57 80 DUP1 0A58 84 DUP5 0A59 16 AND 0A5A 60 PUSH1 0x00 0A5C 90 SWAP1 0A5D 81 DUP2 0A5E 52 MSTORE 0A5F 60 PUSH1 0x10 0A61 60 PUSH1 0x20 0A63 52 MSTORE 0A64 60 PUSH1 0x40 0A66 80 DUP1 0A67 82 DUP3 0A68 20 SHA3 0A69 80 DUP1 0A6A 54 SLOAD 0A6B 60 PUSH1 0x00 0A6D 19 NOT 0A6E 01 ADD 0A6F 90 SWAP1 0A70 55 SSTORE 0A71 91 SWAP2 0A72 84 DUP5 0A73 16 AND 0A74 81 DUP2 0A75 52 MSTORE 0A76 20 SHA3 0A77 80 DUP1 0A78 54 SLOAD 0A79 60 PUSH1 0x01 0A7B 01 ADD 0A7C 90 SWAP1 0A7D 55 SSTORE 0A7E 5B JUMPDEST 0A7F 61 PUSH2 0x0994 0A82 83 DUP4 0A83 83 DUP4 0A84 83 DUP4 0A85 61 PUSH2 0x1f0e 0A88 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @0A5E memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0A63 memory[0x20:0x40] = 0x10 // @0A70 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @0A75 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0A7D storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @0A7F stack[0] = 0x0994 // @0A82 stack[1] = stack[-3] // @0A83 stack[2] = stack[-2] // @0A84 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1f0e 0A89 5B JUMPDEST 0A8A 61 PUSH2 0x0a91 0A8D 61 PUSH2 0x1e91 0A90 56 *JUMP 0A91 5B JUMPDEST 0A92 60 PUSH1 0x0e 0A94 54 SLOAD 0A95 60 PUSH1 0x01 0A97 60 PUSH1 0x01 0A99 60 PUSH1 0xa0 0A9B 1B SHL 0A9C 03 SUB 0A9D 90 SWAP1 0A9E 81 DUP2 0A9F 16 AND 0AA0 91 SWAP2 0AA1 16 AND 0AA2 14 EQ 0AA3 61 PUSH2 0x0abe 0AA6 57 *JUMPI 0AA7 60 PUSH1 0x40 0AA9 51 MLOAD 0AAA 62 PUSH3 0x461bcd 0AAE 60 PUSH1 0xe5 0AB0 1B SHL 0AB1 81 DUP2 0AB2 52 MSTORE 0AB3 60 PUSH1 0x04 0AB5 01 ADD 0AB6 61 PUSH2 0x05f6 0AB9 90 SWAP1 0ABA 61 PUSH2 0x3666 0ABD 56 *JUMP 0ABE 5B JUMPDEST 0ABF 60 PUSH1 0x12 0AC1 80 DUP1 0AC2 54 SLOAD 0AC3 60 PUSH1 0x01 0AC5 60 PUSH1 0x01 0AC7 60 PUSH1 0xa0 0AC9 1B SHL 0ACA 03 SUB 0ACB 19 NOT 0ACC 16 AND 0ACD 60 PUSH1 0x01 0ACF 60 PUSH1 0x01 0AD1 60 PUSH1 0xa0 0AD3 1B SHL 0AD4 03 SUB 0AD5 92 SWAP3 0AD6 90 SWAP1 0AD7 92 SWAP3 0AD8 16 AND 0AD9 91 SWAP2 0ADA 90 SWAP1 0ADB 91 SWAP2 0ADC 17 OR 0ADD 90 SWAP1 0ADE 55 SSTORE 0ADF 56 *JUMP label_0AE0: // Incoming jump from 0x0375 // Inputs[3] // { // @0AE9 stack[-2] // @0AF8 memory[0x00:0x40] // @0AFD stack[-1] // } 0AE0 5B JUMPDEST 0AE1 60 PUSH1 0x01 0AE3 60 PUSH1 0x01 0AE5 60 PUSH1 0xa0 0AE7 1B SHL 0AE8 03 SUB 0AE9 82 DUP3 0AEA 16 AND 0AEB 60 PUSH1 0x00 0AED 90 SWAP1 0AEE 81 DUP2 0AEF 52 MSTORE 0AF0 60 PUSH1 0x01 0AF2 60 PUSH1 0x20 0AF4 52 MSTORE 0AF5 60 PUSH1 0x40 0AF7 81 DUP2 0AF8 20 SHA3 0AF9 61 PUSH2 0x0b02 0AFC 90 SWAP1 0AFD 83 DUP4 0AFE 61 PUSH2 0x1f46 0B01 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0AED stack[0] = 0x00 // @0AEF memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0AF4 memory[0x20:0x40] = 0x01 // @0AFC stack[2] = keccak256(memory[0x00:0x40]) // @0AFC stack[1] = 0x0b02 // @0AFD stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1f46 label_0B02: // Incoming return from call to 0x24AC at 0x1B3B // Incoming return from call to 0x2AE3 at 0x2BD2 // Incoming return from call to 0x265B at 0x1F51 // Incoming return from call to 0x2EF8 at 0x317C // Inputs[2] // { // @0B03 stack[-2] // @0B03 stack[-1] // } 0B02 5B JUMPDEST 0B03 90 SWAP1 0B04 50 POP // Stack delta = -1 // Outputs[1] { @0B03 stack[-2] = stack[-1] } // Block continues label_0B05: // Incoming return from call to 0x24C4 at 0x1F0D // Incoming jump from 0x2AF5, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0B04 // Inputs[3] // { // @0B06 stack[-1] // @0B06 stack[-4] // @0B07 stack[-3] // } 0B05 5B JUMPDEST 0B06 92 SWAP3 0B07 91 SWAP2 0B08 50 POP 0B09 50 POP 0B0A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0B06 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0B0B: // Incoming jump from 0x0388 // Inputs[4] // { // @0B15 stack[-1] // @0B1D memory[0x00:0x40] // @0B1F storage[keccak256(memory[0x00:0x40])] // @0B21 memory[0x40:0x60] // } 0B0B 5B JUMPDEST 0B0C 60 PUSH1 0x0b 0B0E 60 PUSH1 0x20 0B10 90 SWAP1 0B11 81 DUP2 0B12 52 MSTORE 0B13 60 PUSH1 0x00 0B15 91 SWAP2 0B16 82 DUP3 0B17 52 MSTORE 0B18 60 PUSH1 0x40 0B1A 91 SWAP2 0B1B 82 DUP3 0B1C 90 SWAP1 0B1D 20 SHA3 0B1E 80 DUP1 0B1F 54 SLOAD 0B20 83 DUP4 0B21 51 MLOAD 0B22 60 PUSH1 0x1f 0B24 60 PUSH1 0x02 0B26 60 PUSH1 0x00 0B28 19 NOT 0B29 61 PUSH2 0x0100 0B2C 60 PUSH1 0x01 0B2E 86 DUP7 0B2F 16 AND 0B30 15 ISZERO 0B31 02 MUL 0B32 01 ADD 0B33 90 SWAP1 0B34 93 SWAP4 0B35 16 AND 0B36 92 SWAP3 0B37 90 SWAP1 0B38 92 SWAP3 0B39 04 DIV 0B3A 91 SWAP2 0B3B 82 DUP3 0B3C 01 ADD 0B3D 84 DUP5 0B3E 90 SWAP1 0B3F 04 DIV 0B40 84 DUP5 0B41 02 MUL 0B42 81 DUP2 0B43 01 ADD 0B44 84 DUP5 0B45 01 ADD 0B46 90 SWAP1 0B47 94 SWAP5 0B48 52 MSTORE 0B49 80 DUP1 0B4A 84 DUP5 0B4B 52 MSTORE 0B4C 90 SWAP1 0B4D 91 SWAP2 0B4E 83 DUP4 0B4F 01 ADD 0B50 82 DUP3 0B51 82 DUP3 0B52 80 DUP1 0B53 15 ISZERO 0B54 61 PUSH2 0x0b9e 0B57 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @0B12 memory[0x20:0x40] = 0x0b // @0B17 memory[0x00:0x20] = stack[-1] // @0B47 stack[-1] = memory[0x40:0x60] // @0B48 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0B4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0B4C stack[1] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0B4D stack[0] = keccak256(memory[0x00:0x40]) // @0B4F stack[2] = memory[0x40:0x60] + 0x20 // @0B50 stack[3] = keccak256(memory[0x00:0x40]) // @0B51 stack[4] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0b9e, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0B58: // Incoming jump from 0x0B57, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0B58 stack[-1] } 0B58 80 DUP1 0B59 60 PUSH1 0x1f 0B5B 10 LT 0B5C 61 PUSH2 0x0b73 0B5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b73, if 0x1f < stack[-1] label_0B60: // Incoming jump from 0x0B5F, if not 0x1f < stack[-1] // Inputs[4] // { // @0B64 stack[-2] // @0B65 storage[stack[-2]] // @0B68 stack[-3] // @0B6A stack[-1] // } 0B60 61 PUSH2 0x0100 0B63 80 DUP1 0B64 83 DUP4 0B65 54 SLOAD 0B66 04 DIV 0B67 02 MUL 0B68 83 DUP4 0B69 52 MSTORE 0B6A 91 SWAP2 0B6B 60 PUSH1 0x20 0B6D 01 ADD 0B6E 91 SWAP2 0B6F 61 PUSH2 0x0b9e 0B72 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B69 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B6E stack[-1] = stack[-1] // @0B6E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b9e label_0B73: // Incoming jump from 0x0B5F, if 0x1f < stack[-1] // Inputs[5] // { // @0B74 stack[-3] // @0B75 stack[-1] // @0B77 stack[-2] // @0B7F memory[0x00:0x20] // @0B83 storage[keccak256(memory[0x00:0x20])] // } 0B73 5B JUMPDEST 0B74 82 DUP3 0B75 01 ADD 0B76 91 SWAP2 0B77 90 SWAP1 0B78 60 PUSH1 0x00 0B7A 52 MSTORE 0B7B 60 PUSH1 0x20 0B7D 60 PUSH1 0x00 0B7F 20 SHA3 0B80 90 SWAP1 0B81 5B JUMPDEST 0B82 81 DUP2 0B83 54 SLOAD 0B84 81 DUP2 0B85 52 MSTORE 0B86 90 SWAP1 0B87 60 PUSH1 0x01 0B89 01 ADD 0B8A 90 SWAP1 0B8B 60 PUSH1 0x20 0B8D 01 ADD 0B8E 80 DUP1 0B8F 83 DUP4 0B90 11 GT 0B91 61 PUSH2 0x0b81 0B94 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B76 stack[-3] = stack[-3] + stack[-1] // @0B7A memory[0x00:0x20] = stack[-2] // @0B85 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B8A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B8D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b81, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B95: // Incoming jump from 0x0B94, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0B94, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0B95 stack[-3] // @0B96 stack[-1] // } 0B95 82 DUP3 0B96 90 SWAP1 0B97 03 SUB 0B98 60 PUSH1 0x1f 0B9A 16 AND 0B9B 82 DUP3 0B9C 01 ADD 0B9D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B9D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B9D stack[-1] = stack[-3] // } // Block continues label_0B9E: // Incoming jump from 0x0B9D // Incoming jump from 0x0B57, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0B72 // Inputs[1] { @0BA4 stack[-7] } 0B9E 5B JUMPDEST 0B9F 50 POP 0BA0 50 POP 0BA1 50 POP 0BA2 50 POP 0BA3 50 POP 0BA4 81 DUP2 0BA5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] 0BA6 5B JUMPDEST 0BA7 60 PUSH1 0x10 0BA9 60 PUSH1 0x20 0BAB 52 MSTORE 0BAC 60 PUSH1 0x00 0BAE 90 SWAP1 0BAF 81 DUP2 0BB0 52 MSTORE 0BB1 60 PUSH1 0x40 0BB3 90 SWAP1 0BB4 20 SHA3 0BB5 54 SLOAD 0BB6 81 DUP2 0BB7 56 *JUMP label_0BB8: // Incoming call from 0x03A3, returns to 0x02CB // Inputs[3] // { // @0BBB storage[0x12] // @0BBE memory[0x40:0x60] // @0BDF msg.sender // } 0BB8 5B JUMPDEST 0BB9 60 PUSH1 0x12 0BBB 54 SLOAD 0BBC 60 PUSH1 0x40 0BBE 51 MLOAD 0BBF 63 PUSH4 0x164746fd 0BC4 60 PUSH1 0xe1 0BC6 1B SHL 0BC7 81 DUP2 0BC8 52 MSTORE 0BC9 60 PUSH1 0x01 0BCB 60 PUSH1 0x01 0BCD 60 PUSH1 0xa0 0BCF 1B SHL 0BD0 03 SUB 0BD1 90 SWAP1 0BD2 91 SWAP2 0BD3 16 AND 0BD4 90 SWAP1 0BD5 63 PUSH4 0x2c8e8dfa 0BDA 90 SWAP1 0BDB 61 PUSH2 0x0bed 0BDE 90 SWAP1 0BDF 33 CALLER 0BE0 90 SWAP1 0BE1 60 PUSH1 0x00 0BE3 90 SWAP1 0BE4 81 DUP2 0BE5 90 SWAP1 0BE6 60 PUSH1 0x04 0BE8 01 ADD 0BE9 61 PUSH2 0x3084 0BEC 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @0BC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x164746fd << 0xe1 // @0BD4 stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0BDA stack[1] = 0x2c8e8dfa // @0BDE stack[2] = 0x0bed // @0BE0 stack[3] = msg.sender // @0BE3 stack[4] = 0x00 // @0BE5 stack[5] = 0x00 // @0BE8 stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3084, returns to 0x0BED label_0BED: // Incoming return from call to 0x3084 at 0x0BEC // Inputs[4] // { // @0BF2 memory[0x40:0x60] // @0BF4 stack[-1] // @0BF9 stack[-3] // @0BFB address(stack[-3]).code.length // } 0BED 5B JUMPDEST 0BEE 60 PUSH1 0x00 0BF0 60 PUSH1 0x40 0BF2 51 MLOAD 0BF3 80 DUP1 0BF4 83 DUP4 0BF5 03 SUB 0BF6 81 DUP2 0BF7 60 PUSH1 0x00 0BF9 87 DUP8 0BFA 80 DUP1 0BFB 3B EXTCODESIZE 0BFC 15 ISZERO 0BFD 80 DUP1 0BFE 15 ISZERO 0BFF 61 PUSH2 0x0c07 0C02 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0BEE stack[0] = 0x00 // @0BF2 stack[1] = memory[0x40:0x60] // @0BF5 stack[2] = stack[-1] - memory[0x40:0x60] // @0BF6 stack[3] = memory[0x40:0x60] // @0BF7 stack[4] = 0x00 // @0BF9 stack[5] = stack[-3] // @0BFC stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0c07, if !!address(stack[-3]).code.length label_0C03: // Incoming jump from 0x0C02, if not !!address(stack[-3]).code.length // Inputs[1] { @0C06 memory[0x00:0x00] } 0C03 60 PUSH1 0x00 0C05 80 DUP1 0C06 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C06 revert(memory[0x00:0x00]); } // Block terminates label_0C07: // Incoming jump from 0x0C02, if !!address(stack[-3]).code.length // Inputs[9] // { // @0C09 msg.gas // @0C0A address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C0A stack[-6] // @0C0A stack[-5] // @0C0A stack[-3] // @0C0A stack[-2] // @0C0A memory[stack[-4]:stack[-4] + stack[-5]] // @0C0A stack[-4] // @0C0A stack[-7] // } 0C07 5B JUMPDEST 0C08 50 POP 0C09 5A GAS 0C0A F1 CALL 0C0B 15 ISZERO 0C0C 80 DUP1 0C0D 15 ISZERO 0C0E 61 PUSH2 0x0c1b 0C11 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0C0A memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C0B 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 0x0c1b, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0C12: // Incoming jump from 0x0C11, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0C12 returndata.length // @0C16 returndata[0x00:0x00 + returndata.length] // @0C17 returndata.length // @0C1A memory[0x00:0x00 + returndata.length] // } 0C12 3D RETURNDATASIZE 0C13 60 PUSH1 0x00 0C15 80 DUP1 0C16 3E RETURNDATACOPY 0C17 3D RETURNDATASIZE 0C18 60 PUSH1 0x00 0C1A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C16 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C1A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C1B: // Incoming jump from 0x0C11, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[5] // { // @0C20 storage[0x12] // @0C23 memory[0x40:0x60] // @0C39 stack[-4] // @0C40 stack[-3] // @0C46 msg.sender // } 0C1B 5B JUMPDEST 0C1C 50 POP 0C1D 50 POP 0C1E 60 PUSH1 0x12 0C20 54 SLOAD 0C21 60 PUSH1 0x40 0C23 51 MLOAD 0C24 63 PUSH4 0x0c00007b 0C29 60 PUSH1 0xe4 0C2B 1B SHL 0C2C 81 DUP2 0C2D 52 MSTORE 0C2E 60 PUSH1 0x01 0C30 60 PUSH1 0x01 0C32 60 PUSH1 0xa0 0C34 1B SHL 0C35 03 SUB 0C36 90 SWAP1 0C37 91 SWAP2 0C38 16 AND 0C39 92 SWAP3 0C3A 50 POP 0C3B 63 PUSH4 0xc00007b0 0C40 91 SWAP2 0C41 50 POP 0C42 61 PUSH2 0x0c4f 0C45 90 SWAP1 0C46 33 CALLER 0C47 90 SWAP1 0C48 60 PUSH1 0x04 0C4A 01 ADD 0C4B 61 PUSH2 0x3070 0C4E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0c00007b << 0xe4 // @0C39 stack[-4] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0C40 stack[-3] = 0xc00007b0 // @0C45 stack[-2] = 0x0c4f // @0C47 stack[-1] = msg.sender // @0C4A stack[0] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3070, returns to 0x0C4F label_0C4F: // Incoming return from call to 0x3070 at 0x0C4E // Inputs[4] // { // @0C54 memory[0x40:0x60] // @0C56 stack[-1] // @0C5B stack[-3] // @0C5D address(stack[-3]).code.length // } 0C4F 5B JUMPDEST 0C50 60 PUSH1 0x00 0C52 60 PUSH1 0x40 0C54 51 MLOAD 0C55 80 DUP1 0C56 83 DUP4 0C57 03 SUB 0C58 81 DUP2 0C59 60 PUSH1 0x00 0C5B 87 DUP8 0C5C 80 DUP1 0C5D 3B EXTCODESIZE 0C5E 15 ISZERO 0C5F 80 DUP1 0C60 15 ISZERO 0C61 61 PUSH2 0x0c69 0C64 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0C50 stack[0] = 0x00 // @0C54 stack[1] = memory[0x40:0x60] // @0C57 stack[2] = stack[-1] - memory[0x40:0x60] // @0C58 stack[3] = memory[0x40:0x60] // @0C59 stack[4] = 0x00 // @0C5B stack[5] = stack[-3] // @0C5E stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0c69, if !!address(stack[-3]).code.length label_0C65: // Incoming jump from 0x0C64, if not !!address(stack[-3]).code.length // Inputs[1] { @0C68 memory[0x00:0x00] } 0C65 60 PUSH1 0x00 0C67 80 DUP1 0C68 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C68 revert(memory[0x00:0x00]); } // Block terminates label_0C69: // Incoming jump from 0x0C64, if !!address(stack[-3]).code.length // Inputs[9] // { // @0C6B msg.gas // @0C6C stack[-7] // @0C6C stack[-3] // @0C6C stack[-6] // @0C6C stack[-5] // @0C6C stack[-4] // @0C6C stack[-2] // @0C6C address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C6C memory[stack[-4]:stack[-4] + stack[-5]] // } 0C69 5B JUMPDEST 0C6A 50 POP 0C6B 5A GAS 0C6C F1 CALL 0C6D 15 ISZERO 0C6E 80 DUP1 0C6F 15 ISZERO 0C70 61 PUSH2 0x0c7d 0C73 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0C6C memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C6D 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 0x0c7d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0C74: // Incoming jump from 0x0C73, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0C74 returndata.length // @0C78 returndata[0x00:0x00 + returndata.length] // @0C79 returndata.length // @0C7C memory[0x00:0x00 + returndata.length] // } 0C74 3D RETURNDATASIZE 0C75 60 PUSH1 0x00 0C77 80 DUP1 0C78 3E RETURNDATACOPY 0C79 3D RETURNDATASIZE 0C7A 60 PUSH1 0x00 0C7C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C78 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C7C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C7D: // Incoming jump from 0x38E6, if !(stack[-1] > stack[-4]) // Incoming jump from 0x0C73, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0C82 stack[-5] } 0C7D 5B JUMPDEST 0C7E 50 POP 0C7F 50 POP 0C80 50 POP 0C81 50 POP 0C82 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0C83: // Incoming jump from 0x03B6 // Inputs[4] // { // @0C87 stack[-3] // @0C88 stack[-2] // @0C89 stack[-1] // @0C8C memory[0x40:0x60] // } 0C83 5B JUMPDEST 0C84 61 PUSH2 0x0994 0C87 83 DUP4 0C88 83 DUP4 0C89 83 DUP4 0C8A 60 PUSH1 0x40 0C8C 51 MLOAD 0C8D 80 DUP1 0C8E 60 PUSH1 0x20 0C90 01 ADD 0C91 60 PUSH1 0x40 0C93 52 MSTORE 0C94 80 DUP1 0C95 60 PUSH1 0x00 0C97 81 DUP2 0C98 52 MSTORE 0C99 50 POP 0C9A 61 PUSH2 0x13c5 0C9D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0C84 stack[0] = 0x0994 // @0C87 stack[1] = stack[-3] // @0C88 stack[2] = stack[-2] // @0C89 stack[3] = stack[-1] // @0C8C stack[4] = memory[0x40:0x60] // @0C93 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0C98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x13c5 label_0C9E: // Incoming call from 0x03BE, returns to 0x02F5 // Inputs[1] { @0CA2 stack[-1] } 0C9E 5B JUMPDEST 0C9F 61 PUSH2 0xdead 0CA2 81 DUP2 0CA3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C9F stack[0] = 0xdead } // Block ends with unconditional jump to stack[-1] label_0CA4: // Incoming call from 0x03C6, returns to 0x0330 // Inputs[2] // { // @0CA7 storage[0x0a] // @0CA8 stack[-1] // } 0CA4 5B JUMPDEST 0CA5 60 PUSH1 0x0a 0CA7 54 SLOAD 0CA8 81 DUP2 0CA9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CA7 stack[0] = storage[0x0a] } // Block ends with unconditional jump to stack[-1] label_0CAA: // Incoming jump from 0x03D9 // Inputs[3] // { // @0CAD storage[0x12] // @0CB0 memory[0x40:0x60] // @0CD1 msg.sender // } 0CAA 5B JUMPDEST 0CAB 60 PUSH1 0x12 0CAD 54 SLOAD 0CAE 60 PUSH1 0x40 0CB0 51 MLOAD 0CB1 63 PUSH4 0x2770a7eb 0CB6 60 PUSH1 0xe2 0CB8 1B SHL 0CB9 81 DUP2 0CBA 52 MSTORE 0CBB 60 PUSH1 0x01 0CBD 60 PUSH1 0x01 0CBF 60 PUSH1 0xa0 0CC1 1B SHL 0CC2 03 SUB 0CC3 90 SWAP1 0CC4 91 SWAP2 0CC5 16 AND 0CC6 90 SWAP1 0CC7 63 PUSH4 0x9dc29fac 0CCC 90 SWAP1 0CCD 61 PUSH2 0x0ce5 0CD0 90 SWAP1 0CD1 33 CALLER 0CD2 90 SWAP1 0CD3 68 PUSH9 0x056bc75e2d63100000 0CDD 90 SWAP1 0CDE 60 PUSH1 0x04 0CE0 01 ADD 0CE1 61 PUSH2 0x3113 0CE4 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @0CBA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2770a7eb << 0xe2 // @0CC6 stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @0CCC stack[1] = 0x9dc29fac // @0CD0 stack[2] = 0x0ce5 // @0CD2 stack[3] = msg.sender // @0CDD stack[4] = 0x056bc75e2d63100000 // @0CE0 stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3113, returns to 0x0CE5 label_0CE5: // Incoming return from call to 0x3113 at 0x0CE4 // Inputs[4] // { // @0CEA memory[0x40:0x60] // @0CEC stack[-1] // @0CF1 stack[-3] // @0CF3 address(stack[-3]).code.length // } 0CE5 5B JUMPDEST 0CE6 60 PUSH1 0x00 0CE8 60 PUSH1 0x40 0CEA 51 MLOAD 0CEB 80 DUP1 0CEC 83 DUP4 0CED 03 SUB 0CEE 81 DUP2 0CEF 60 PUSH1 0x00 0CF1 87 DUP8 0CF2 80 DUP1 0CF3 3B EXTCODESIZE 0CF4 15 ISZERO 0CF5 80 DUP1 0CF6 15 ISZERO 0CF7 61 PUSH2 0x0cff 0CFA 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0CE6 stack[0] = 0x00 // @0CEA stack[1] = memory[0x40:0x60] // @0CED stack[2] = stack[-1] - memory[0x40:0x60] // @0CEE stack[3] = memory[0x40:0x60] // @0CEF stack[4] = 0x00 // @0CF1 stack[5] = stack[-3] // @0CF4 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0cff, if !!address(stack[-3]).code.length label_0CFB: // Incoming jump from 0x0CFA, if not !!address(stack[-3]).code.length // Inputs[1] { @0CFE memory[0x00:0x00] } 0CFB 60 PUSH1 0x00 0CFD 80 DUP1 0CFE FD *REVERT // Stack delta = +0 // Outputs[1] { @0CFE revert(memory[0x00:0x00]); } // Block terminates label_0CFF: // Incoming jump from 0x0CFA, if !!address(stack[-3]).code.length // Inputs[9] // { // @0D01 msg.gas // @0D02 stack[-2] // @0D02 stack[-4] // @0D02 stack[-7] // @0D02 stack[-3] // @0D02 memory[stack[-4]:stack[-4] + stack[-5]] // @0D02 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0D02 stack[-6] // @0D02 stack[-5] // } 0CFF 5B JUMPDEST 0D00 50 POP 0D01 5A GAS 0D02 F1 CALL 0D03 15 ISZERO 0D04 80 DUP1 0D05 15 ISZERO 0D06 61 PUSH2 0x0d13 0D09 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0D02 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0D03 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 0x0d13, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0D0A: // Incoming jump from 0x0D09, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0D0A returndata.length // @0D0E returndata[0x00:0x00 + returndata.length] // @0D0F returndata.length // @0D12 memory[0x00:0x00 + returndata.length] // } 0D0A 3D RETURNDATASIZE 0D0B 60 PUSH1 0x00 0D0D 80 DUP1 0D0E 3E RETURNDATACOPY 0D0F 3D RETURNDATASIZE 0D10 60 PUSH1 0x00 0D12 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D0E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D12 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D13: // Incoming jump from 0x0D09, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0D1B stack[-6] // @0D1C stack[-5] // } 0D13 5B JUMPDEST 0D14 50 POP 0D15 50 POP 0D16 50 POP 0D17 50 POP 0D18 61 PUSH2 0x0d21 0D1B 82 DUP3 0D1C 82 DUP3 0D1D 61 PUSH2 0x1f52 0D20 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0D18 stack[-4] = 0x0d21 // @0D1B stack[-3] = stack[-6] // @0D1C stack[-2] = stack[-5] // } // Block ends with unconditional jump to 0x1f52 0D21 5B JUMPDEST 0D22 50 POP 0D23 50 POP 0D24 56 *JUMP label_0D25: // Incoming jump from 0x03EC // Inputs[1] { @0D2E stack[-1] } 0D25 5B JUMPDEST 0D26 60 PUSH1 0x00 0D28 80 DUP1 0D29 61 PUSH2 0x0d33 0D2C 60 PUSH1 0x02 0D2E 84 DUP5 0D2F 61 PUSH2 0x1ff4 0D32 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D26 stack[0] = 0x00 // @0D28 stack[1] = 0x00 // @0D29 stack[2] = 0x0d33 // @0D2C stack[3] = 0x02 // @0D2E stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1ff4 label_0D33: // Incoming jump from 0x0FCA, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0FCA, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0FCA, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @0D35 stack[-2] // @0D35 stack[-6] // @0D36 stack[-5] // } 0D33 5B JUMPDEST 0D34 50 POP 0D35 93 SWAP4 0D36 92 SWAP3 0D37 50 POP 0D38 50 POP 0D39 50 POP 0D3A 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D35 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0D3B: // Incoming call from 0x03F4, returns to 0x02F5 // Inputs[1] { @0D51 stack[-1] } 0D3B 5B JUMPDEST 0D3C 73 PUSH20 0x5e5e683b687f509968d90acd31ce6b8cfa3d25e4 0D51 81 DUP2 0D52 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D3C stack[0] = 0x5e5e683b687f509968d90acd31ce6b8cfa3d25e4 } // Block ends with unconditional jump to stack[-1] label_0D53: // Incoming jump from 0x0407 // Incoming jump from 0x18A9 // Incoming jump from 0x16BC // Incoming jump from 0x090B // Incoming jump from 0x1F5C // Incoming jump from 0x2075 // Inputs[2] // { // @0D59 stack[-1] // @0D5C memory[0x40:0x60] // } 0D53 5B JUMPDEST 0D54 60 PUSH1 0x00 0D56 61 PUSH2 0x0b05 0D59 82 DUP3 0D5A 60 PUSH1 0x40 0D5C 51 MLOAD 0D5D 80 DUP1 0D5E 60 PUSH1 0x60 0D60 01 ADD 0D61 60 PUSH1 0x40 0D63 52 MSTORE 0D64 80 DUP1 0D65 60 PUSH1 0x29 0D67 81 DUP2 0D68 52 MSTORE 0D69 60 PUSH1 0x20 0D6B 01 ADD 0D6C 61 PUSH2 0x395b 0D6F 60 PUSH1 0x29 0D71 91 SWAP2 0D72 39 CODECOPY 0D73 60 PUSH1 0x02 0D75 91 SWAP2 0D76 90 SWAP1 0D77 61 PUSH2 0x2012 0D7A 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @0D54 stack[0] = 0x00 // @0D56 stack[1] = 0x0b05 // @0D63 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0D68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x29 // @0D72 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x29] = code[0x395b:0x3984] // @0D75 stack[2] = 0x02 // @0D76 stack[3] = stack[-1] // @0D76 stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2012 label_0D7B: // Incoming call from 0x040F, returns to 0x02D5 // Inputs[2] // { // @0D7F storage[0x09] // @0D83 memory[0x40:0x60] // } 0D7B 5B JUMPDEST 0D7C 60 PUSH1 0x09 0D7E 80 DUP1 0D7F 54 SLOAD 0D80 60 PUSH1 0x40 0D82 80 DUP1 0D83 51 MLOAD 0D84 60 PUSH1 0x20 0D86 60 PUSH1 0x1f 0D88 60 PUSH1 0x02 0D8A 60 PUSH1 0x00 0D8C 19 NOT 0D8D 61 PUSH2 0x0100 0D90 60 PUSH1 0x01 0D92 88 DUP9 0D93 16 AND 0D94 15 ISZERO 0D95 02 MUL 0D96 01 ADD 0D97 90 SWAP1 0D98 95 SWAP6 0D99 16 AND 0D9A 94 SWAP5 0D9B 90 SWAP1 0D9C 94 SWAP5 0D9D 04 DIV 0D9E 93 SWAP4 0D9F 84 DUP5 0DA0 01 ADD 0DA1 81 DUP2 0DA2 90 SWAP1 0DA3 04 DIV 0DA4 81 DUP2 0DA5 02 MUL 0DA6 82 DUP3 0DA7 01 ADD 0DA8 81 DUP2 0DA9 01 ADD 0DAA 90 SWAP1 0DAB 92 SWAP3 0DAC 52 MSTORE 0DAD 82 DUP3 0DAE 81 DUP2 0DAF 52 MSTORE 0DB0 60 PUSH1 0x60 0DB2 93 SWAP4 0DB3 90 SWAP1 0DB4 92 SWAP3 0DB5 90 SWAP1 0DB6 91 SWAP2 0DB7 83 DUP4 0DB8 01 ADD 0DB9 82 DUP3 0DBA 82 DUP3 0DBB 80 DUP1 0DBC 15 ISZERO 0DBD 61 PUSH2 0x08b4 0DC0 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0DAC memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0DAF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0DB2 stack[0] = 0x60 // @0DB4 stack[1] = memory[0x40:0x60] // @0DB5 stack[3] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0DB6 stack[2] = 0x09 // @0DB8 stack[4] = memory[0x40:0x60] + 0x20 // @0DB9 stack[5] = 0x09 // @0DBA stack[6] = (storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x08b4, if !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0DC1: // Incoming jump from 0x0DC0, if not !((storage[0x09] & !(storage[0x09] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0DC1 stack[-1] } 0DC1 80 DUP1 0DC2 60 PUSH1 0x1f 0DC4 10 LT 0DC5 61 PUSH2 0x0889 0DC8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0889, if 0x1f < stack[-1] label_0DC9: // Incoming jump from 0x0DC8, if not 0x1f < stack[-1] // Inputs[4] // { // @0DCD stack[-2] // @0DCE storage[stack[-2]] // @0DD1 stack[-3] // @0DD3 stack[-1] // } 0DC9 61 PUSH2 0x0100 0DCC 80 DUP1 0DCD 83 DUP4 0DCE 54 SLOAD 0DCF 04 DIV 0DD0 02 MUL 0DD1 83 DUP4 0DD2 52 MSTORE 0DD3 91 SWAP2 0DD4 60 PUSH1 0x20 0DD6 01 ADD 0DD7 91 SWAP2 0DD8 61 PUSH2 0x08b4 0DDB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0DD2 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0DD7 stack[-1] = stack[-1] // @0DD7 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08b4 label_0DDC: // Incoming jump from 0x0422 // Inputs[4] // { // @0DDF stack[-1] // @0DEE memory[0x00:0x40] // @0DF0 storage[keccak256(memory[0x00:0x40])] // @0DF2 memory[0x40:0x60] // } 0DDC 5B JUMPDEST 0DDD 60 PUSH1 0x00 0DDF 81 DUP2 0DE0 81 DUP2 0DE1 52 MSTORE 0DE2 60 PUSH1 0x0c 0DE4 60 PUSH1 0x20 0DE6 90 SWAP1 0DE7 81 DUP2 0DE8 52 MSTORE 0DE9 60 PUSH1 0x40 0DEB 91 SWAP2 0DEC 82 DUP3 0DED 90 SWAP1 0DEE 20 SHA3 0DEF 80 DUP1 0DF0 54 SLOAD 0DF1 83 DUP4 0DF2 51 MLOAD 0DF3 60 PUSH1 0x1f 0DF5 60 PUSH1 0x02 0DF7 60 PUSH1 0x00 0DF9 19 NOT 0DFA 61 PUSH2 0x0100 0DFD 60 PUSH1 0x01 0DFF 86 DUP7 0E00 16 AND 0E01 15 ISZERO 0E02 02 MUL 0E03 01 ADD 0E04 90 SWAP1 0E05 93 SWAP4 0E06 16 AND 0E07 92 SWAP3 0E08 90 SWAP1 0E09 92 SWAP3 0E0A 04 DIV 0E0B 91 SWAP2 0E0C 82 DUP3 0E0D 01 ADD 0E0E 84 DUP5 0E0F 90 SWAP1 0E10 04 DIV 0E11 84 DUP5 0E12 02 MUL 0E13 81 DUP2 0E14 01 ADD 0E15 84 DUP5 0E16 01 ADD 0E17 90 SWAP1 0E18 94 SWAP5 0E19 52 MSTORE 0E1A 80 DUP1 0E1B 84 DUP5 0E1C 52 MSTORE 0E1D 60 PUSH1 0x60 0E1F 93 SWAP4 0E20 92 SWAP3 0E21 83 DUP4 0E22 01 ADD 0E23 82 DUP3 0E24 82 DUP3 0E25 80 DUP1 0E26 15 ISZERO 0E27 61 PUSH2 0x0e71 0E2A 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @0DE1 memory[0x00:0x20] = stack[-1] // @0DE8 memory[0x20:0x40] = 0x0c // @0DEE stack[2] = keccak256(memory[0x00:0x40]) // @0E0B stack[3] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0E19 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0E1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0E1F stack[0] = 0x60 // @0E20 stack[1] = memory[0x40:0x60] // @0E22 stack[4] = memory[0x40:0x60] + 0x20 // @0E23 stack[5] = keccak256(memory[0x00:0x40]) // @0E24 stack[6] = (storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0e71, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0E2B: // Incoming jump from 0x0E2A, if not !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0E2B stack[-1] } 0E2B 80 DUP1 0E2C 60 PUSH1 0x1f 0E2E 10 LT 0E2F 61 PUSH2 0x0e46 0E32 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e46, if 0x1f < stack[-1] label_0E33: // Incoming jump from 0x0E32, if not 0x1f < stack[-1] // Inputs[4] // { // @0E37 stack[-2] // @0E38 storage[stack[-2]] // @0E3B stack[-3] // @0E3D stack[-1] // } 0E33 61 PUSH2 0x0100 0E36 80 DUP1 0E37 83 DUP4 0E38 54 SLOAD 0E39 04 DIV 0E3A 02 MUL 0E3B 83 DUP4 0E3C 52 MSTORE 0E3D 91 SWAP2 0E3E 60 PUSH1 0x20 0E40 01 ADD 0E41 91 SWAP2 0E42 61 PUSH2 0x0e71 0E45 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0E3C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0E41 stack[-1] = stack[-1] // @0E41 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0e71 label_0E46: // Incoming jump from 0x0E32, if 0x1f < stack[-1] // Inputs[5] // { // @0E47 stack[-3] // @0E48 stack[-1] // @0E4A stack[-2] // @0E52 memory[0x00:0x20] // @0E56 storage[keccak256(memory[0x00:0x20])] // } 0E46 5B JUMPDEST 0E47 82 DUP3 0E48 01 ADD 0E49 91 SWAP2 0E4A 90 SWAP1 0E4B 60 PUSH1 0x00 0E4D 52 MSTORE 0E4E 60 PUSH1 0x20 0E50 60 PUSH1 0x00 0E52 20 SHA3 0E53 90 SWAP1 0E54 5B JUMPDEST 0E55 81 DUP2 0E56 54 SLOAD 0E57 81 DUP2 0E58 52 MSTORE 0E59 90 SWAP1 0E5A 60 PUSH1 0x01 0E5C 01 ADD 0E5D 90 SWAP1 0E5E 60 PUSH1 0x20 0E60 01 ADD 0E61 80 DUP1 0E62 83 DUP4 0E63 11 GT 0E64 61 PUSH2 0x0e54 0E67 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0E49 stack[-3] = stack[-3] + stack[-1] // @0E4D memory[0x00:0x20] = stack[-2] // @0E58 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0E5D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0E60 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0e54, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0E68: // Incoming jump from 0x0E67, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0E67, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0E68 stack[-3] // @0E69 stack[-1] // } 0E68 82 DUP3 0E69 90 SWAP1 0E6A 03 SUB 0E6B 60 PUSH1 0x1f 0E6D 16 AND 0E6E 82 DUP3 0E6F 01 ADD 0E70 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0E70 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0E70 stack[-1] = stack[-3] // } // Block continues label_0E71: // Incoming jump from 0x0E2A, if !((storage[keccak256(memory[0x00:0x40])] & !(storage[keccak256(memory[0x00:0x40])] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0E45 // Incoming jump from 0x0E70 // Inputs[4] // { // @0E77 stack[-6] // @0E77 stack[-7] // @0E79 stack[-9] // @0E7A stack[-8] // } 0E71 5B JUMPDEST 0E72 50 POP 0E73 50 POP 0E74 50 POP 0E75 50 POP 0E76 50 POP 0E77 90 SWAP1 0E78 50 POP 0E79 91 SWAP2 0E7A 90 SWAP1 0E7B 50 POP 0E7C 56 *JUMP // Stack delta = -8 // Outputs[1] { @0E79 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] 0E7D 5B JUMPDEST 0E7E 60 PUSH1 0x00 0E80 60 PUSH1 0x01 0E82 60 PUSH1 0x01 0E84 60 PUSH1 0xa0 0E86 1B SHL 0E87 03 SUB 0E88 82 DUP3 0E89 16 AND 0E8A 61 PUSH2 0x0ea5 0E8D 57 *JUMPI 0E8E 60 PUSH1 0x40 0E90 51 MLOAD 0E91 62 PUSH3 0x461bcd 0E95 60 PUSH1 0xe5 0E97 1B SHL 0E98 81 DUP2 0E99 52 MSTORE 0E9A 60 PUSH1 0x04 0E9C 01 ADD 0E9D 61 PUSH2 0x05f6 0EA0 90 SWAP1 0EA1 61 PUSH2 0x34e8 0EA4 56 *JUMP 0EA5 5B JUMPDEST 0EA6 60 PUSH1 0x01 0EA8 60 PUSH1 0x01 0EAA 60 PUSH1 0xa0 0EAC 1B SHL 0EAD 03 SUB 0EAE 82 DUP3 0EAF 16 AND 0EB0 60 PUSH1 0x00 0EB2 90 SWAP1 0EB3 81 DUP2 0EB4 52 MSTORE 0EB5 60 PUSH1 0x01 0EB7 60 PUSH1 0x20 0EB9 52 MSTORE 0EBA 60 PUSH1 0x40 0EBC 90 SWAP1 0EBD 20 SHA3 0EBE 61 PUSH2 0x0b05 0EC1 90 SWAP1 0EC2 61 PUSH2 0x1f03 0EC5 56 *JUMP label_0EC6: // Incoming call from 0x043D, returns to 0x02CB 0EC6 5B JUMPDEST 0EC7 61 PUSH2 0x0ece 0ECA 61 PUSH2 0x1e91 0ECD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EC7 stack[0] = 0x0ece } // Block ends with call to 0x1e91, returns to 0x0ECE label_0ECE: // Incoming return from call to 0x1E91 at 0x0ECD // Inputs[2] // { // @0ED1 storage[0x0e] // @0EDD stack[-1] // } 0ECE 5B JUMPDEST 0ECF 60 PUSH1 0x0e 0ED1 54 SLOAD 0ED2 60 PUSH1 0x01 0ED4 60 PUSH1 0x01 0ED6 60 PUSH1 0xa0 0ED8 1B SHL 0ED9 03 SUB 0EDA 90 SWAP1 0EDB 81 DUP2 0EDC 16 AND 0EDD 91 SWAP2 0EDE 16 AND 0EDF 14 EQ 0EE0 61 PUSH2 0x0efb 0EE3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0efb, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_0EE4: // Incoming jump from 0x0EE3, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @0EE6 memory[0x40:0x60] } 0EE4 60 PUSH1 0x40 0EE6 51 MLOAD 0EE7 62 PUSH3 0x461bcd 0EEB 60 PUSH1 0xe5 0EED 1B SHL 0EEE 81 DUP2 0EEF 52 MSTORE 0EF0 60 PUSH1 0x04 0EF2 01 ADD 0EF3 61 PUSH2 0x05f6 0EF6 90 SWAP1 0EF7 61 PUSH2 0x3666 0EFA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EF6 stack[0] = 0x05f6 // @0EF6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3666, returns to 0x05F6 label_0EFB: // Incoming jump from 0x0EE3, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[5] // { // @0EFE storage[0x0e] // @0F01 memory[0x40:0x60] // @0F33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0F37 storage[0x0e] // @0F44 stack[-1] // } 0EFB 5B JUMPDEST 0EFC 60 PUSH1 0x0e 0EFE 54 SLOAD 0EFF 60 PUSH1 0x40 0F01 51 MLOAD 0F02 60 PUSH1 0x00 0F04 91 SWAP2 0F05 60 PUSH1 0x01 0F07 60 PUSH1 0x01 0F09 60 PUSH1 0xa0 0F0B 1B SHL 0F0C 03 SUB 0F0D 16 AND 0F0E 90 SWAP1 0F0F 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0F30 90 SWAP1 0F31 83 DUP4 0F32 90 SWAP1 0F33 A3 LOG3 0F34 60 PUSH1 0x0e 0F36 80 DUP1 0F37 54 SLOAD 0F38 60 PUSH1 0x01 0F3A 60 PUSH1 0x01 0F3C 60 PUSH1 0xa0 0F3E 1B SHL 0F3F 03 SUB 0F40 19 NOT 0F41 16 AND 0F42 90 SWAP1 0F43 55 SSTORE 0F44 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0F33 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0e] & (0x01 << 0xa0) - 0x01, 0x00]); // @0F43 storage[0x0e] = ~((0x01 << 0xa0) - 0x01) & storage[0x0e] // } // Block ends with unconditional jump to stack[-1] label_0F45: // Incoming call from 0x0445, returns to 0x0330 // Inputs[1] { @0F50 stack[-1] } 0F45 5B JUMPDEST 0F46 68 PUSH9 0x056bc75e2d63100000 0F50 81 DUP2 0F51 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F46 stack[0] = 0x056bc75e2d63100000 } // Block ends with unconditional jump to stack[-1] label_0F52: // Incoming call from 0x044D, returns to 0x02F5 // Inputs[2] // { // @0F55 storage[0x12] // @0F5F stack[-1] // } 0F52 5B JUMPDEST 0F53 60 PUSH1 0x12 0F55 54 SLOAD 0F56 60 PUSH1 0x01 0F58 60 PUSH1 0x01 0F5A 60 PUSH1 0xa0 0F5C 1B SHL 0F5D 03 SUB 0F5E 16 AND 0F5F 81 DUP2 0F60 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F5E stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x12] } // Block ends with unconditional jump to stack[-1] label_0F61: // Incoming call from 0x0455, returns to 0x02F5 // Inputs[2] // { // @0F64 storage[0x0e] // @0F6E stack[-1] // } 0F61 5B JUMPDEST 0F62 60 PUSH1 0x0e 0F64 54 SLOAD 0F65 60 PUSH1 0x01 0F67 60 PUSH1 0x01 0F69 60 PUSH1 0xa0 0F6B 1B SHL 0F6C 03 SUB 0F6D 16 AND 0F6E 90 SWAP1 0F6F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0F6E stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0e] } // Block ends with unconditional jump to stack[-1] label_0F70: // Incoming call from 0x09A5, returns to 0x09A6 // Incoming jump from 0x0468 // Inputs[2] // { // @0F74 stack[-1] // @0F7A memory[stack[-1]:stack[-1] + 0x20] // } 0F70 5B JUMPDEST 0F71 60 PUSH1 0x60 0F73 80 DUP1 0F74 82 DUP3 0F75 90 SWAP1 0F76 50 POP 0F77 60 PUSH1 0x60 0F79 81 DUP2 0F7A 51 MLOAD 0F7B 67 PUSH8 0xffffffffffffffff 0F84 81 DUP2 0F85 11 GT 0F86 80 DUP1 0F87 15 ISZERO 0F88 61 PUSH2 0x0f90 0F8B 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0F71 stack[0] = 0x60 // @0F75 stack[1] = stack[-1] // @0F77 stack[2] = 0x60 // @0F7A stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @0F85 stack[4] = memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x0f90, if !(memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff) label_0F8C: // Incoming jump from 0x0F8B, if not !(memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0F8F memory[0x00:0x00] } 0F8C 60 PUSH1 0x00 0F8E 80 DUP1 0F8F FD *REVERT // Stack delta = +0 // Outputs[1] { @0F8F revert(memory[0x00:0x00]); } // Block terminates label_0F90: // Incoming jump from 0x0F8B, if !(memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @0F94 memory[0x40:0x60] // @0F95 stack[-2] // } 0F90 5B JUMPDEST 0F91 50 POP 0F92 60 PUSH1 0x40 0F94 51 MLOAD 0F95 90 SWAP1 0F96 80 DUP1 0F97 82 DUP3 0F98 52 MSTORE 0F99 80 DUP1 0F9A 60 PUSH1 0x1f 0F9C 01 ADD 0F9D 60 PUSH1 0x1f 0F9F 19 NOT 0FA0 16 AND 0FA1 60 PUSH1 0x20 0FA3 01 ADD 0FA4 82 DUP3 0FA5 01 ADD 0FA6 60 PUSH1 0x40 0FA8 52 MSTORE 0FA9 80 DUP1 0FAA 15 ISZERO 0FAB 61 PUSH2 0x0fbb 0FAE 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0F95 stack[-2] = memory[0x40:0x60] // @0F95 stack[-1] = stack[-2] // @0F98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0FA8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-2]) // } // Block ends with conditional jump to 0x0fbb, if !stack[-2] label_0FAF: // Incoming jump from 0x0FAE, if not !stack[-2] // Inputs[7] // { // @0FB1 stack[-2] // @0FB3 stack[-1] // @0FB5 msg.data.length // @0FB7 msg.data[msg.data.length:msg.data.length + stack[-1]] // @0FBD stack[-3] // @0FC2 stack[-4] // @0FC3 memory[stack[-4]:stack[-4] + 0x20] // } 0FAF 60 PUSH1 0x20 0FB1 82 DUP3 0FB2 01 ADD 0FB3 81 DUP2 0FB4 80 DUP1 0FB5 36 CALLDATASIZE 0FB6 83 DUP4 0FB7 37 CALLDATACOPY 0FB8 01 ADD 0FB9 90 SWAP1 0FBA 50 POP 0FBB 5B JUMPDEST 0FBC 50 POP 0FBD 90 SWAP1 0FBE 50 POP 0FBF 60 PUSH1 0x00 0FC1 5B JUMPDEST 0FC2 82 DUP3 0FC3 51 MLOAD 0FC4 81 DUP2 0FC5 10 LT 0FC6 15 ISZERO 0FC7 61 PUSH2 0x0d33 0FCA 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0FB7 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @0FBD stack[-3] = stack[-2] // @0FBF stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0d33, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_0FCB: // Incoming jump from 0x0FCA, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0FCA, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0FCA, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @0FCD stack[-3] // @0FCE stack[-1] // @0FD0 memory[stack[-3]:stack[-3] + 0x20] // } 0FCB 60 PUSH1 0x41 0FCD 83 DUP4 0FCE 82 DUP3 0FCF 81 DUP2 0FD0 51 MLOAD 0FD1 81 DUP2 0FD2 10 LT 0FD3 61 PUSH2 0x0fd8 0FD6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0FCB stack[0] = 0x41 // @0FCD stack[1] = stack[-3] // @0FCE stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0fd8, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0FD7: // Incoming jump from 0x0FD6, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 0FD7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FD7 assert(); } // Block terminates label_0FD8: // Incoming jump from 0x0FD6, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0FD9 stack[-2] // @0FD9 stack[-1] // @0FDD memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @0FE1 stack[-3] // } 0FD8 5B JUMPDEST 0FD9 01 ADD 0FDA 60 PUSH1 0x20 0FDC 01 ADD 0FDD 51 MLOAD 0FDE 60 PUSH1 0xf8 0FE0 1C SHR 0FE1 10 LT 0FE2 80 DUP1 0FE3 15 ISZERO 0FE4 90 SWAP1 0FE5 61 PUSH2 0x1002 0FE8 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0FE4 stack[-3] = !(memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8 < stack[-3]) } // Block ends with conditional jump to 0x1002, if memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8 < stack[-3] label_0FE9: // Incoming jump from 0x0FE8, if not memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8 < stack[-3] // Inputs[3] // { // @0FEC stack[-4] // @0FED stack[-2] // @0FEF memory[stack[-4]:stack[-4] + 0x20] // } 0FE9 50 POP 0FEA 60 PUSH1 0x5a 0FEC 83 DUP4 0FED 82 DUP3 0FEE 81 DUP2 0FEF 51 MLOAD 0FF0 81 DUP2 0FF1 10 LT 0FF2 61 PUSH2 0x0ff7 0FF5 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0FEA stack[-1] = 0x5a // @0FEC stack[0] = stack[-4] // @0FED stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0ff7, if stack[-2] < memory[stack[-4]:stack[-4] + 0x20] label_0FF6: // Incoming jump from 0x0FF5, if not stack[-2] < memory[stack[-4]:stack[-4] + 0x20] 0FF6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FF6 assert(); } // Block terminates label_0FF7: // Incoming jump from 0x0FF5, if stack[-2] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @0FF8 stack[-1] // @0FF8 stack[-2] // @0FFC memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @1000 stack[-3] // } 0FF7 5B JUMPDEST 0FF8 01 ADD 0FF9 60 PUSH1 0x20 0FFB 01 ADD 0FFC 51 MLOAD 0FFD 60 PUSH1 0xf8 0FFF 1C SHR 1000 11 GT 1001 15 ISZERO // Stack delta = -2 // Outputs[1] { @1001 stack[-3] = !(memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8 > stack[-3]) } // Block continues label_1002: // Incoming jump from 0x1001 // Incoming jump from 0x0FE8, if memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8 < stack[-3] // Inputs[1] { @1003 stack[-1] } 1002 5B JUMPDEST 1003 15 ISZERO 1004 61 PUSH2 0x104f 1007 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x104f, if !stack[-1] label_1008: // Incoming jump from 0x1007, if not !stack[-1] // Inputs[3] // { // @1008 stack[-3] // @1009 stack[-1] // @100B memory[stack[-3]:stack[-3] + 0x20] // } 1008 82 DUP3 1009 81 DUP2 100A 81 DUP2 100B 51 MLOAD 100C 81 DUP2 100D 10 LT 100E 61 PUSH2 0x1013 1011 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1008 stack[0] = stack[-3] // @1009 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1013, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_1012: // Incoming jump from 0x1011, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 1012 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1012 assert(); } // Block terminates label_1013: // Incoming jump from 0x1011, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @1016 stack[-1] // @1017 stack[-2] // @1018 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @1028 stack[-4] // @1029 stack[-3] // @102B memory[stack[-4]:stack[-4] + 0x20] // } 1013 5B JUMPDEST 1014 60 PUSH1 0x20 1016 01 ADD 1017 01 ADD 1018 51 MLOAD 1019 60 PUSH1 0xf8 101B 1C SHR 101C 60 PUSH1 0xf8 101E 1B SHL 101F 60 PUSH1 0xf8 1021 1C SHR 1022 60 PUSH1 0x20 1024 01 ADD 1025 60 PUSH1 0xf8 1027 1B SHL 1028 82 DUP3 1029 82 DUP3 102A 81 DUP2 102B 51 MLOAD 102C 81 DUP2 102D 10 LT 102E 61 PUSH2 0x1033 1031 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1027 stack[-2] = 0x20 + (((memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8) << 0xf8) >> 0xf8) << 0xf8 // @1028 stack[-1] = stack[-4] // @1029 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1033, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_1032: // Incoming jump from 0x1031, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 1032 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1032 assert(); } // Block terminates label_1033: // Incoming jump from 0x1031, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1036 stack[-1] // @1037 stack[-2] // @1038 stack[-3] // } 1033 5B JUMPDEST 1034 60 PUSH1 0x20 1036 01 ADD 1037 01 ADD 1038 90 SWAP1 1039 60 PUSH1 0x01 103B 60 PUSH1 0x01 103D 60 PUSH1 0xf8 103F 1B SHL 1040 03 SUB 1041 19 NOT 1042 16 AND 1043 90 SWAP1 1044 81 DUP2 1045 60 PUSH1 0x00 1047 1A BYTE 1048 90 SWAP1 1049 53 MSTORE8 104A 50 POP 104B 61 PUSH2 0x108a 104E 56 *JUMP // Stack delta = -3 // Outputs[1] { @1049 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) } // Block ends with unconditional jump to 0x108a label_104F: // Incoming jump from 0x1007, if !stack[-1] // Inputs[3] // { // @1050 stack[-3] // @1051 stack[-1] // @1053 memory[stack[-3]:stack[-3] + 0x20] // } 104F 5B JUMPDEST 1050 82 DUP3 1051 81 DUP2 1052 81 DUP2 1053 51 MLOAD 1054 81 DUP2 1055 10 LT 1056 61 PUSH2 0x105b 1059 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1050 stack[0] = stack[-3] // @1051 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x105b, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_105A: // Incoming jump from 0x1059, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 105A FE *ASSERT // Stack delta = +0 // Outputs[1] { @105A assert(); } // Block terminates label_105B: // Incoming jump from 0x1059, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @105E stack[-1] // @105F stack[-2] // @1060 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @1067 stack[-4] // @1068 stack[-3] // @106A memory[stack[-4]:stack[-4] + 0x20] // } 105B 5B JUMPDEST 105C 60 PUSH1 0x20 105E 01 ADD 105F 01 ADD 1060 51 MLOAD 1061 60 PUSH1 0xf8 1063 1C SHR 1064 60 PUSH1 0xf8 1066 1B SHL 1067 82 DUP3 1068 82 DUP3 1069 81 DUP2 106A 51 MLOAD 106B 81 DUP2 106C 10 LT 106D 61 PUSH2 0x1072 1070 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1066 stack[-2] = (memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8) << 0xf8 // @1067 stack[-1] = stack[-4] // @1068 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1072, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_1071: // Incoming jump from 0x1070, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 1071 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1071 assert(); } // Block terminates label_1072: // Incoming jump from 0x1070, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @1075 stack[-1] // @1076 stack[-2] // @1077 stack[-3] // @108D stack[-4] // } 1072 5B JUMPDEST 1073 60 PUSH1 0x20 1075 01 ADD 1076 01 ADD 1077 90 SWAP1 1078 60 PUSH1 0x01 107A 60 PUSH1 0x01 107C 60 PUSH1 0xf8 107E 1B SHL 107F 03 SUB 1080 19 NOT 1081 16 AND 1082 90 SWAP1 1083 81 DUP2 1084 60 PUSH1 0x00 1086 1A BYTE 1087 90 SWAP1 1088 53 MSTORE8 1089 50 POP 108A 5B JUMPDEST 108B 60 PUSH1 0x01 108D 01 ADD 108E 61 PUSH2 0x0fc1 1091 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1088 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @108D stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x0fc1 label_1092: // Incoming call from 0x0470, returns to 0x02D5 // Inputs[2] // { // @1096 storage[0x07] // @109A memory[0x40:0x60] // } 1092 5B JUMPDEST 1093 60 PUSH1 0x07 1095 80 DUP1 1096 54 SLOAD 1097 60 PUSH1 0x40 1099 80 DUP1 109A 51 MLOAD 109B 60 PUSH1 0x20 109D 60 PUSH1 0x1f 109F 60 PUSH1 0x02 10A1 60 PUSH1 0x00 10A3 19 NOT 10A4 61 PUSH2 0x0100 10A7 60 PUSH1 0x01 10A9 88 DUP9 10AA 16 AND 10AB 15 ISZERO 10AC 02 MUL 10AD 01 ADD 10AE 90 SWAP1 10AF 95 SWAP6 10B0 16 AND 10B1 94 SWAP5 10B2 90 SWAP1 10B3 94 SWAP5 10B4 04 DIV 10B5 93 SWAP4 10B6 84 DUP5 10B7 01 ADD 10B8 81 DUP2 10B9 90 SWAP1 10BA 04 DIV 10BB 81 DUP2 10BC 02 MUL 10BD 82 DUP3 10BE 01 ADD 10BF 81 DUP2 10C0 01 ADD 10C1 90 SWAP1 10C2 92 SWAP3 10C3 52 MSTORE 10C4 82 DUP3 10C5 81 DUP2 10C6 52 MSTORE 10C7 60 PUSH1 0x60 10C9 93 SWAP4 10CA 90 SWAP1 10CB 92 SWAP3 10CC 90 SWAP1 10CD 91 SWAP2 10CE 83 DUP4 10CF 01 ADD 10D0 82 DUP3 10D1 82 DUP3 10D2 80 DUP1 10D3 15 ISZERO 10D4 61 PUSH2 0x08b4 10D7 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @10C3 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @10C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 // @10C9 stack[0] = 0x60 // @10CB stack[1] = memory[0x40:0x60] // @10CC stack[3] = (storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 // @10CD stack[2] = 0x07 // @10CF stack[4] = memory[0x40:0x60] + 0x20 // @10D0 stack[5] = 0x07 // @10D1 stack[6] = (storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x08b4, if !((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02) label_10D8: // Incoming jump from 0x10D7, if not !((storage[0x07] & !(storage[0x07] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @10D8 stack[-1] } 10D8 80 DUP1 10D9 60 PUSH1 0x1f 10DB 10 LT 10DC 61 PUSH2 0x0889 10DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0889, if 0x1f < stack[-1] label_10E0: // Incoming jump from 0x10DF, if not 0x1f < stack[-1] // Inputs[4] // { // @10E4 stack[-2] // @10E5 storage[stack[-2]] // @10E8 stack[-3] // @10EA stack[-1] // } 10E0 61 PUSH2 0x0100 10E3 80 DUP1 10E4 83 DUP4 10E5 54 SLOAD 10E6 04 DIV 10E7 02 MUL 10E8 83 DUP4 10E9 52 MSTORE 10EA 91 SWAP2 10EB 60 PUSH1 0x20 10ED 01 ADD 10EE 91 SWAP2 10EF 61 PUSH2 0x08b4 10F2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @10E9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @10EE stack[-1] = stack[-1] // @10EE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08b4 label_10F3: // Incoming jump from 0x0483 // Inputs[2] // { // @10F8 stack[-1] // @10FE memory[stack[-1]:stack[-1] + 0x20] // } 10F3 5B JUMPDEST 10F4 60 PUSH1 0x00 10F6 60 PUSH1 0x60 10F8 82 DUP3 10F9 90 SWAP1 10FA 50 POP 10FB 60 PUSH1 0x01 10FD 81 DUP2 10FE 51 MLOAD 10FF 10 LT 1100 15 ISZERO 1101 61 PUSH2 0x110e 1104 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @10F4 stack[0] = 0x00 // @10F9 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x110e, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x01) label_1105: // Incoming jump from 0x1104, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x01) // Inputs[1] { @1107 stack[-2] } 1105 60 PUSH1 0x00 1107 91 SWAP2 1108 50 POP 1109 50 POP 110A 61 PUSH2 0x05cc 110D 56 *JUMP // Stack delta = -1 // Outputs[1] { @1107 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x05cc label_110E: // Incoming jump from 0x1104, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x01) // Inputs[2] // { // @1111 stack[-1] // @1112 memory[stack[-1]:stack[-1] + 0x20] // } 110E 5B JUMPDEST 110F 60 PUSH1 0x19 1111 81 DUP2 1112 51 MLOAD 1113 11 GT 1114 15 ISZERO 1115 61 PUSH2 0x1122 1118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1122, if !(memory[stack[-1]:stack[-1] + 0x20] > 0x19) label_1119: // Incoming jump from 0x1118, if not !(memory[stack[-1]:stack[-1] + 0x20] > 0x19) // Inputs[1] { @111B stack[-2] } 1119 60 PUSH1 0x00 111B 91 SWAP2 111C 50 POP 111D 50 POP 111E 61 PUSH2 0x05cc 1121 56 *JUMP // Stack delta = -1 // Outputs[1] { @111B stack[-2] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1122: // Incoming jump from 0x1118, if !(memory[stack[-1]:stack[-1] + 0x20] > 0x19) // Inputs[2] // { // @1123 stack[-1] // @1127 memory[stack[-1]:stack[-1] + 0x20] // } 1122 5B JUMPDEST 1123 80 DUP1 1124 60 PUSH1 0x00 1126 81 DUP2 1127 51 MLOAD 1128 81 DUP2 1129 10 LT 112A 61 PUSH2 0x112f 112D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1123 stack[0] = stack[-1] // @1124 stack[1] = 0x00 // } // Block ends with conditional jump to 0x112f, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_112E: // Incoming jump from 0x112D, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 112E FE *ASSERT // Stack delta = +0 // Outputs[1] { @112E assert(); } // Block terminates label_112F: // Incoming jump from 0x112D, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1132 stack[-2] // @1133 stack[-1] // @1135 memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 112F 5B JUMPDEST 1130 60 PUSH1 0x20 1132 91 SWAP2 1133 01 ADD 1134 01 ADD 1135 51 MLOAD 1136 60 PUSH1 0x01 1138 60 PUSH1 0x01 113A 60 PUSH1 0xf8 113C 1B SHL 113D 03 SUB 113E 19 NOT 113F 16 AND 1140 60 PUSH1 0x01 1142 60 PUSH1 0xfd 1144 1B SHL 1145 14 EQ 1146 15 ISZERO 1147 61 PUSH2 0x1154 114A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1154, if !(0x01 << 0xfd == ~((0x01 << 0xf8) - 0x01) & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20]) label_114B: // Incoming jump from 0x114A, if not !(0x01 << 0xfd == ~((0x01 << 0xf8) - 0x01) & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20]) // Inputs[1] { @114D stack[-2] } 114B 60 PUSH1 0x00 114D 91 SWAP2 114E 50 POP 114F 50 POP 1150 61 PUSH2 0x05cc 1153 56 *JUMP // Stack delta = -1 // Outputs[1] { @114D stack[-2] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1154: // Incoming jump from 0x114A, if !(0x01 << 0xfd == ~((0x01 << 0xf8) - 0x01) & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20]) // Inputs[3] // { // @1155 stack[-1] // @1159 memory[stack[-1]:stack[-1] + 0x20] // @115C memory[stack[-1]:stack[-1] + 0x20] // } 1154 5B JUMPDEST 1155 80 DUP1 1156 60 PUSH1 0x01 1158 82 DUP3 1159 51 MLOAD 115A 03 SUB 115B 81 DUP2 115C 51 MLOAD 115D 81 DUP2 115E 10 LT 115F 61 PUSH2 0x1164 1162 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1155 stack[0] = stack[-1] // @115A stack[1] = memory[stack[-1]:stack[-1] + 0x20] - 0x01 // } // Block ends with conditional jump to 0x1164, if memory[stack[-1]:stack[-1] + 0x20] - 0x01 < memory[stack[-1]:stack[-1] + 0x20] label_1163: // Incoming jump from 0x1162, if not memory[stack[-1]:stack[-1] + 0x20] - 0x01 < memory[stack[-1]:stack[-1] + 0x20] 1163 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1163 assert(); } // Block terminates label_1164: // Incoming jump from 0x1162, if memory[stack[-1]:stack[-1] + 0x20] - 0x01 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @1167 stack[-2] // @1168 stack[-1] // @116A memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20] // } 1164 5B JUMPDEST 1165 60 PUSH1 0x20 1167 91 SWAP2 1168 01 ADD 1169 01 ADD 116A 51 MLOAD 116B 60 PUSH1 0x01 116D 60 PUSH1 0x01 116F 60 PUSH1 0xf8 1171 1B SHL 1172 03 SUB 1173 19 NOT 1174 16 AND 1175 60 PUSH1 0x01 1177 60 PUSH1 0xfd 1179 1B SHL 117A 14 EQ 117B 15 ISZERO 117C 61 PUSH2 0x1189 117F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1189, if !(0x01 << 0xfd == ~((0x01 << 0xf8) - 0x01) & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20]) label_1180: // Incoming jump from 0x117F, if not !(0x01 << 0xfd == ~((0x01 << 0xf8) - 0x01) & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20]) // Inputs[1] { @1182 stack[-2] } 1180 60 PUSH1 0x00 1182 91 SWAP2 1183 50 POP 1184 50 POP 1185 61 PUSH2 0x05cc 1188 56 *JUMP // Stack delta = -1 // Outputs[1] { @1182 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1189: // Incoming jump from 0x117F, if !(0x01 << 0xfd == ~((0x01 << 0xf8) - 0x01) & memory[stack[-2] + stack[-1] + 0x20:stack[-2] + stack[-1] + 0x20 + 0x20]) // Inputs[2] // { // @118C stack[-1] // @1190 memory[stack[-1]:stack[-1] + 0x20] // } 1189 5B JUMPDEST 118A 60 PUSH1 0x00 118C 81 DUP2 118D 60 PUSH1 0x00 118F 81 DUP2 1190 51 MLOAD 1191 81 DUP2 1192 10 LT 1193 61 PUSH2 0x1198 1196 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @118A stack[0] = 0x00 // @118C stack[1] = stack[-1] // @118D stack[2] = 0x00 // } // Block ends with conditional jump to 0x1198, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_1197: // Incoming jump from 0x1196, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 1197 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1197 assert(); } // Block terminates label_1198: // Incoming jump from 0x1196, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[6] // { // @1199 stack[-2] // @1199 stack[-1] // @119D memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @11A8 stack[-3] // @11AD stack[-4] // @11AE memory[stack[-4]:stack[-4] + 0x20] // } 1198 5B JUMPDEST 1199 01 ADD 119A 60 PUSH1 0x20 119C 01 ADD 119D 51 MLOAD 119E 60 PUSH1 0x01 11A0 60 PUSH1 0x01 11A2 60 PUSH1 0xf8 11A4 1B SHL 11A5 03 SUB 11A6 19 NOT 11A7 16 AND 11A8 90 SWAP1 11A9 50 POP 11AA 60 PUSH1 0x00 11AC 5B JUMPDEST 11AD 82 DUP3 11AE 51 MLOAD 11AF 81 DUP2 11B0 10 LT 11B1 15 ISZERO 11B2 61 PUSH2 0x12d3 11B5 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @11A8 stack[-3] = ~((0x01 << 0xf8) - 0x01) & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @11AA stack[-2] = 0x00 // } // Block ends with conditional jump to 0x12d3, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_11B6: // Incoming jump from 0x11B5, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x11B5, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @11B8 stack[-3] // @11B9 stack[-1] // @11BB memory[stack[-3]:stack[-3] + 0x20] // } 11B6 60 PUSH1 0x00 11B8 83 DUP4 11B9 82 DUP3 11BA 81 DUP2 11BB 51 MLOAD 11BC 81 DUP2 11BD 10 LT 11BE 61 PUSH2 0x11c3 11C1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @11B6 stack[0] = 0x00 // @11B8 stack[1] = stack[-3] // @11B9 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x11c3, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_11C2: // Incoming jump from 0x11C1, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 11C2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @11C2 assert(); } // Block terminates label_11C3: // Incoming jump from 0x11C1, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @11C4 stack[-1] // @11C4 stack[-2] // @11C8 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @11D3 stack[-3] // } 11C3 5B JUMPDEST 11C4 01 ADD 11C5 60 PUSH1 0x20 11C7 01 ADD 11C8 51 MLOAD 11C9 60 PUSH1 0x01 11CB 60 PUSH1 0x01 11CD 60 PUSH1 0xf8 11CF 1B SHL 11D0 03 SUB 11D1 19 NOT 11D2 16 AND 11D3 90 SWAP1 11D4 50 POP 11D5 60 PUSH1 0x01 11D7 60 PUSH1 0xfd 11D9 1B SHL 11DA 81 DUP2 11DB 14 EQ 11DC 80 DUP1 11DD 15 ISZERO 11DE 61 PUSH2 0x11f4 11E1 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @11D3 stack[-3] = ~((0x01 << 0xf8) - 0x01) & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @11DB stack[-2] = ~((0x01 << 0xf8) - 0x01) & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] == 0x01 << 0xfd // } // Block ends with conditional jump to 0x11f4, if !(~((0x01 << 0xf8) - 0x01) & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] == 0x01 << 0xfd) label_11E2: // Incoming jump from 0x11E1, if not !(~((0x01 << 0xf8) - 0x01) & memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] == 0x01 << 0xfd) // Inputs[1] { @11F1 stack[-4] } 11E2 50 POP 11E3 60 PUSH1 0x01 11E5 60 PUSH1 0xfd 11E7 1B SHL 11E8 60 PUSH1 0x01 11EA 60 PUSH1 0x01 11EC 60 PUSH1 0xf8 11EE 1B SHL 11EF 03 SUB 11F0 19 NOT 11F1 84 DUP5 11F2 16 AND 11F3 14 EQ 11F4 5B JUMPDEST 11F5 15 ISZERO 11F6 61 PUSH2 0x1206 11F9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1206, if !(stack[-4] & ~((0x01 << 0xf8) - 0x01) == 0x01 << 0xfd) label_11FA: // Incoming jump from 0x11F9, if not !(stack[-4] & ~((0x01 << 0xf8) - 0x01) == 0x01 << 0xfd) // Incoming jump from 0x11F9, if not !stack[-1] // Inputs[1] { @11FC stack[-5] } 11FA 60 PUSH1 0x00 11FC 94 SWAP5 11FD 50 POP 11FE 50 POP 11FF 50 POP 1200 50 POP 1201 50 POP 1202 61 PUSH2 0x05cc 1205 56 *JUMP // Stack delta = -4 // Outputs[1] { @11FC stack[-5] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1206: // Incoming jump from 0x11F9, if !(stack[-4] & ~((0x01 << 0xf8) - 0x01) == 0x01 << 0xfd) // Incoming jump from 0x11F9, if !stack[-1] // Inputs[1] { @1215 stack[-1] } 1206 5B JUMPDEST 1207 60 PUSH1 0x03 1209 60 PUSH1 0xfc 120B 1B SHL 120C 60 PUSH1 0x01 120E 60 PUSH1 0x01 1210 60 PUSH1 0xf8 1212 1B SHL 1213 03 SUB 1214 19 NOT 1215 82 DUP3 1216 16 AND 1217 10 LT 1218 80 DUP1 1219 15 ISZERO 121A 90 SWAP1 121B 61 PUSH2 0x1232 121E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @121A stack[0] = !(stack[-1] & ~((0x01 << 0xf8) - 0x01) < 0x03 << 0xfc) } // Block ends with conditional jump to 0x1232, if stack[-1] & ~((0x01 << 0xf8) - 0x01) < 0x03 << 0xfc label_121F: // Incoming jump from 0x121E, if not stack[-1] & ~((0x01 << 0xf8) - 0x01) < 0x03 << 0xfc // Inputs[1] { @122E stack[-2] } 121F 50 POP 1220 60 PUSH1 0x39 1222 60 PUSH1 0xf8 1224 1B SHL 1225 60 PUSH1 0x01 1227 60 PUSH1 0x01 1229 60 PUSH1 0xf8 122B 1B SHL 122C 03 SUB 122D 19 NOT 122E 82 DUP3 122F 16 AND 1230 11 GT 1231 15 ISZERO 1232 5B JUMPDEST 1233 15 ISZERO 1234 80 DUP1 1235 15 ISZERO 1236 61 PUSH2 0x1268 1239 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1233 stack[-1] = !!(stack[-2] & ~((0x01 << 0xf8) - 0x01) > 0x39 << 0xf8) } // Block ends with conditional jump to 0x1268, if !!!(stack[-2] & ~((0x01 << 0xf8) - 0x01) > 0x39 << 0xf8) label_123A: // Incoming jump from 0x1239, if not !!!(stack[-2] & ~((0x01 << 0xf8) - 0x01) > 0x39 << 0xf8) // Incoming jump from 0x1239, if not !!stack[-1] // Inputs[1] { @1249 stack[-2] } 123A 50 POP 123B 60 PUSH1 0x41 123D 60 PUSH1 0xf8 123F 1B SHL 1240 60 PUSH1 0x01 1242 60 PUSH1 0x01 1244 60 PUSH1 0xf8 1246 1B SHL 1247 03 SUB 1248 19 NOT 1249 82 DUP3 124A 16 AND 124B 10 LT 124C 80 DUP1 124D 15 ISZERO 124E 90 SWAP1 124F 61 PUSH2 0x1266 1252 57 *JUMPI // Stack delta = +0 // Outputs[1] { @124E stack[-1] = !(stack[-2] & ~((0x01 << 0xf8) - 0x01) < 0x41 << 0xf8) } // Block ends with conditional jump to 0x1266, if stack[-2] & ~((0x01 << 0xf8) - 0x01) < 0x41 << 0xf8 label_1253: // Incoming jump from 0x1252, if not stack[-2] & ~((0x01 << 0xf8) - 0x01) < 0x41 << 0xf8 // Inputs[1] { @1262 stack[-2] } 1253 50 POP 1254 60 PUSH1 0x2d 1256 60 PUSH1 0xf9 1258 1B SHL 1259 60 PUSH1 0x01 125B 60 PUSH1 0x01 125D 60 PUSH1 0xf8 125F 1B SHL 1260 03 SUB 1261 19 NOT 1262 82 DUP3 1263 16 AND 1264 11 GT 1265 15 ISZERO 1266 5B JUMPDEST 1267 15 ISZERO // Stack delta = +0 // Outputs[1] { @1267 stack[-1] = !!(stack[-2] & ~((0x01 << 0xf8) - 0x01) > 0x2d << 0xf9) } // Block continues label_1268: // Incoming jump from 0x1267 // Incoming jump from 0x1239, if !!stack[-1] // Incoming jump from 0x1239, if !!!(stack[-2] & ~((0x01 << 0xf8) - 0x01) > 0x39 << 0xf8) // Incoming jump from 0x1267 // Inputs[1] { @1269 stack[-1] } 1268 5B JUMPDEST 1269 80 DUP1 126A 15 ISZERO 126B 61 PUSH2 0x129d 126E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x129d, if !stack[-1] label_126F: // Incoming jump from 0x126E, if not !stack[-1] // Inputs[1] { @127E stack[-2] } 126F 50 POP 1270 60 PUSH1 0x61 1272 60 PUSH1 0xf8 1274 1B SHL 1275 60 PUSH1 0x01 1277 60 PUSH1 0x01 1279 60 PUSH1 0xf8 127B 1B SHL 127C 03 SUB 127D 19 NOT 127E 82 DUP3 127F 16 AND 1280 10 LT 1281 80 DUP1 1282 15 ISZERO 1283 90 SWAP1 1284 61 PUSH2 0x129b 1287 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1283 stack[-1] = !(stack[-2] & ~((0x01 << 0xf8) - 0x01) < 0x61 << 0xf8) } // Block ends with conditional jump to 0x129b, if stack[-2] & ~((0x01 << 0xf8) - 0x01) < 0x61 << 0xf8 label_1288: // Incoming jump from 0x1287, if not stack[-2] & ~((0x01 << 0xf8) - 0x01) < 0x61 << 0xf8 // Inputs[1] { @1297 stack[-2] } 1288 50 POP 1289 60 PUSH1 0x3d 128B 60 PUSH1 0xf9 128D 1B SHL 128E 60 PUSH1 0x01 1290 60 PUSH1 0x01 1292 60 PUSH1 0xf8 1294 1B SHL 1295 03 SUB 1296 19 NOT 1297 82 DUP3 1298 16 AND 1299 11 GT 129A 15 ISZERO 129B 5B JUMPDEST 129C 15 ISZERO // Stack delta = +0 // Outputs[1] { @129C stack[-1] = !!(stack[-2] & ~((0x01 << 0xf8) - 0x01) > 0x3d << 0xf9) } // Block continues label_129D: // Incoming jump from 0x129C // Incoming jump from 0x126E, if !stack[-1] // Incoming jump from 0x129C // Inputs[1] { @129E stack[-1] } 129D 5B JUMPDEST 129E 80 DUP1 129F 15 ISZERO 12A0 61 PUSH2 0x12b7 12A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12b7, if !stack[-1] label_12A4: // Incoming jump from 0x12A3, if not !stack[-1] // Inputs[1] { @12B3 stack[-2] } 12A4 50 POP 12A5 60 PUSH1 0x01 12A7 60 PUSH1 0xfd 12A9 1B SHL 12AA 60 PUSH1 0x01 12AC 60 PUSH1 0x01 12AE 60 PUSH1 0xf8 12B0 1B SHL 12B1 03 SUB 12B2 19 NOT 12B3 82 DUP3 12B4 16 AND 12B5 14 EQ 12B6 15 ISZERO 12B7 5B JUMPDEST 12B8 15 ISZERO 12B9 61 PUSH2 0x12c9 12BC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12c9, if !!(stack[-2] & ~((0x01 << 0xf8) - 0x01) == 0x01 << 0xfd) label_12BD: // Incoming jump from 0x12BC, if not !!(stack[-2] & ~((0x01 << 0xf8) - 0x01) == 0x01 << 0xfd) // Incoming jump from 0x12BC, if not !stack[-1] // Inputs[1] { @12BF stack[-5] } 12BD 60 PUSH1 0x00 12BF 94 SWAP5 12C0 50 POP 12C1 50 POP 12C2 50 POP 12C3 50 POP 12C4 50 POP 12C5 61 PUSH2 0x05cc 12C8 56 *JUMP // Stack delta = -4 // Outputs[1] { @12BF stack[-5] = 0x00 } // Block ends with unconditional jump to 0x05cc label_12C9: // Incoming jump from 0x12BC, if !!(stack[-2] & ~((0x01 << 0xf8) - 0x01) == 0x01 << 0xfd) // Incoming jump from 0x12BC, if !stack[-1] // Inputs[3] // { // @12CA stack[-1] // @12CA stack[-3] // @12CE stack[-2] // } 12C9 5B JUMPDEST 12CA 91 SWAP2 12CB 50 POP 12CC 60 PUSH1 0x01 12CE 01 ADD 12CF 61 PUSH2 0x11ac 12D2 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @12CA stack[-3] = stack[-1] // @12CE stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x11ac label_12D3: // Incoming jump from 0x11B5, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x11B5, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[2] // { // @12D7 stack[-6] // @12D8 stack[-5] // } 12D3 5B JUMPDEST 12D4 50 POP 12D5 60 PUSH1 0x01 12D7 94 SWAP5 12D8 93 SWAP4 12D9 50 POP 12DA 50 POP 12DB 50 POP 12DC 50 POP 12DD 56 *JUMP // Stack delta = -5 // Outputs[1] { @12D7 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_12DE: // Incoming jump from 0x0496 12DE 5B JUMPDEST 12DF 61 PUSH2 0x12e6 12E2 61 PUSH2 0x1e91 12E5 56 *JUMP // Stack delta = +1 // Outputs[1] { @12DF stack[0] = 0x12e6 } // Block ends with call to 0x1e91, returns to 0x12E6 label_12E6: // Incoming return from call to 0x1E91 at 0x12E5 // Inputs[2] // { // @12EF stack[-1] // @12F0 stack[-3] // } 12E6 5B JUMPDEST 12E7 60 PUSH1 0x01 12E9 60 PUSH1 0x01 12EB 60 PUSH1 0xa0 12ED 1B SHL 12EE 03 SUB 12EF 16 AND 12F0 82 DUP3 12F1 60 PUSH1 0x01 12F3 60 PUSH1 0x01 12F5 60 PUSH1 0xa0 12F7 1B SHL 12F8 03 SUB 12F9 16 AND 12FA 14 EQ 12FB 15 ISZERO 12FC 61 PUSH2 0x1317 12FF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1317, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_1300: // Incoming jump from 0x12FF, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @1302 memory[0x40:0x60] } 1300 60 PUSH1 0x40 1302 51 MLOAD 1303 62 PUSH3 0x461bcd 1307 60 PUSH1 0xe5 1309 1B SHL 130A 81 DUP2 130B 52 MSTORE 130C 60 PUSH1 0x04 130E 01 ADD 130F 61 PUSH2 0x05f6 1312 90 SWAP1 1313 61 PUSH2 0x3377 1316 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @130B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1312 stack[0] = 0x05f6 // @1312 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3377, returns to 0x05F6 label_1317: // Incoming jump from 0x12FF, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @1318 stack[-1] } 1317 5B JUMPDEST 1318 80 DUP1 1319 60 PUSH1 0x05 131B 60 PUSH1 0x00 131D 61 PUSH2 0x1324 1320 61 PUSH2 0x1e91 1323 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1318 stack[0] = stack[-1] // @1319 stack[1] = 0x05 // @131B stack[2] = 0x00 // @131D stack[3] = 0x1324 // } // Block ends with call to 0x1e91, returns to 0x1324 label_1324: // Incoming return from call to 0x1E91 at 0x1323 // Inputs[8] // { // @132D stack[-1] // @1330 stack[-2] // @1337 stack[-3] // @1344 memory[0x00:0x00 + 0x40 + stack[-2]] // @1346 stack[-6] // @1350 memory[0x00:0x40] // @1352 storage[keccak256(memory[0x00:0x40])] // @1357 stack[-4] // } 1324 5B JUMPDEST 1325 60 PUSH1 0x01 1327 60 PUSH1 0x01 1329 60 PUSH1 0xa0 132B 1B SHL 132C 03 SUB 132D 90 SWAP1 132E 81 DUP2 132F 16 AND 1330 82 DUP3 1331 52 MSTORE 1332 60 PUSH1 0x20 1334 80 DUP1 1335 83 DUP4 1336 01 ADD 1337 93 SWAP4 1338 90 SWAP1 1339 93 SWAP4 133A 52 MSTORE 133B 60 PUSH1 0x40 133D 91 SWAP2 133E 82 DUP3 133F 01 ADD 1340 60 PUSH1 0x00 1342 90 SWAP1 1343 81 DUP2 1344 20 SHA3 1345 91 SWAP2 1346 87 DUP8 1347 16 AND 1348 80 DUP1 1349 82 DUP3 134A 52 MSTORE 134B 91 SWAP2 134C 90 SWAP1 134D 93 SWAP4 134E 52 MSTORE 134F 91 SWAP2 1350 20 SHA3 1351 80 DUP1 1352 54 SLOAD 1353 60 PUSH1 0xff 1355 19 NOT 1356 16 AND 1357 92 SWAP3 1358 15 ISZERO 1359 15 ISZERO 135A 92 SWAP3 135B 90 SWAP1 135C 92 SWAP3 135D 17 OR 135E 90 SWAP1 135F 91 SWAP2 1360 55 SSTORE 1361 61 PUSH2 0x1368 1364 61 PUSH2 0x1e91 1367 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @1331 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @133A memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @134A memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @134E memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @135F stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1360 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1361 stack[-3] = 0x1368 // } // Block ends with call to 0x1e91, returns to 0x1368 label_1368: // Incoming return from call to 0x1E91 at 0x1367 // Inputs[3] // { // @1371 stack[-1] // @1393 stack[-3] // @1396 memory[0x40:0x60] // } 1368 5B JUMPDEST 1369 60 PUSH1 0x01 136B 60 PUSH1 0x01 136D 60 PUSH1 0xa0 136F 1B SHL 1370 03 SUB 1371 16 AND 1372 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1393 83 DUP4 1394 60 PUSH1 0x40 1396 51 MLOAD 1397 61 PUSH2 0x13a0 139A 91 SWAP2 139B 90 SWAP1 139C 61 PUSH2 0x312c 139F 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1371 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1372 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @139A stack[1] = 0x13a0 // @139B stack[3] = memory[0x40:0x60] // @139B stack[2] = stack[-3] // } // Block ends with call to 0x312c, returns to 0x13A0 label_13A0: // Incoming return from call to 0x312C at 0x139F // Inputs[7] // { // @13A3 memory[0x40:0x60] // @13A5 stack[-1] // @13A8 stack[-2] // @13A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @13A8 stack[-3] // @13A8 stack[-4] // @13AB stack[-7] // } 13A0 5B JUMPDEST 13A1 60 PUSH1 0x40 13A3 51 MLOAD 13A4 80 DUP1 13A5 91 SWAP2 13A6 03 SUB 13A7 90 SWAP1 13A8 A3 LOG3 13A9 50 POP 13AA 50 POP 13AB 56 *JUMP // Stack delta = -7 // Outputs[1] { @13A8 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_13AC: // Incoming jump from 0x04A9 // Inputs[5] // { // @13B4 stack[-1] // @13BA memory[0x00:0x40] // @13BC storage[keccak256(memory[0x00:0x40])] // @13C2 storage[keccak256(memory[0x00:0x40]) + 0x01] // @13C3 stack[-2] // } 13AC 5B JUMPDEST 13AD 60 PUSH1 0x0f 13AF 60 PUSH1 0x20 13B1 52 MSTORE 13B2 60 PUSH1 0x00 13B4 90 SWAP1 13B5 81 DUP2 13B6 52 MSTORE 13B7 60 PUSH1 0x40 13B9 90 SWAP1 13BA 20 SHA3 13BB 80 DUP1 13BC 54 SLOAD 13BD 60 PUSH1 0x01 13BF 90 SWAP1 13C0 91 SWAP2 13C1 01 ADD 13C2 54 SLOAD 13C3 82 DUP3 13C4 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @13B1 memory[0x20:0x40] = 0x0f // @13B6 memory[0x00:0x20] = stack[-1] // @13C0 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @13C2 stack[0] = storage[keccak256(memory[0x00:0x40]) + 0x01] // } // Block ends with unconditional jump to stack[-2] label_13C5: // Incoming jump from 0x04CA // Incoming jump from 0x0C9D // Inputs[5] // { // @13C8 storage[0x12] // @13CB memory[0x40:0x60] // @13EC stack[-4] // @13EE stack[-3] // @13F0 stack[-2] // } 13C5 5B JUMPDEST 13C6 60 PUSH1 0x12 13C8 54 SLOAD 13C9 60 PUSH1 0x40 13CB 51 MLOAD 13CC 63 PUSH4 0x164746fd 13D1 60 PUSH1 0xe1 13D3 1B SHL 13D4 81 DUP2 13D5 52 MSTORE 13D6 60 PUSH1 0x01 13D8 60 PUSH1 0x01 13DA 60 PUSH1 0xa0 13DC 1B SHL 13DD 03 SUB 13DE 90 SWAP1 13DF 91 SWAP2 13E0 16 AND 13E1 90 SWAP1 13E2 63 PUSH4 0x2c8e8dfa 13E7 90 SWAP1 13E8 61 PUSH2 0x13f9 13EB 90 SWAP1 13EC 87 DUP8 13ED 90 SWAP1 13EE 87 DUP8 13EF 90 SWAP1 13F0 87 DUP8 13F1 90 SWAP1 13F2 60 PUSH1 0x04 13F4 01 ADD 13F5 61 PUSH2 0x3084 13F8 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @13D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x164746fd << 0xe1 // @13E1 stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @13E7 stack[1] = 0x2c8e8dfa // @13EB stack[2] = 0x13f9 // @13ED stack[3] = stack[-4] // @13EF stack[4] = stack[-3] // @13F1 stack[5] = stack[-2] // @13F4 stack[6] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3084, returns to 0x13F9 label_13F9: // Incoming return from call to 0x3084 at 0x13F8 // Inputs[4] // { // @13FE memory[0x40:0x60] // @1400 stack[-1] // @1405 stack[-3] // @1407 address(stack[-3]).code.length // } 13F9 5B JUMPDEST 13FA 60 PUSH1 0x00 13FC 60 PUSH1 0x40 13FE 51 MLOAD 13FF 80 DUP1 1400 83 DUP4 1401 03 SUB 1402 81 DUP2 1403 60 PUSH1 0x00 1405 87 DUP8 1406 80 DUP1 1407 3B EXTCODESIZE 1408 15 ISZERO 1409 80 DUP1 140A 15 ISZERO 140B 61 PUSH2 0x1413 140E 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @13FA stack[0] = 0x00 // @13FE stack[1] = memory[0x40:0x60] // @1401 stack[2] = stack[-1] - memory[0x40:0x60] // @1402 stack[3] = memory[0x40:0x60] // @1403 stack[4] = 0x00 // @1405 stack[5] = stack[-3] // @1408 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1413, if !!address(stack[-3]).code.length label_140F: // Incoming jump from 0x140E, if not !!address(stack[-3]).code.length // Inputs[1] { @1412 memory[0x00:0x00] } 140F 60 PUSH1 0x00 1411 80 DUP1 1412 FD *REVERT // Stack delta = +0 // Outputs[1] { @1412 revert(memory[0x00:0x00]); } // Block terminates label_1413: // Incoming jump from 0x140E, if !!address(stack[-3]).code.length // Inputs[9] // { // @1415 msg.gas // @1416 stack[-3] // @1416 stack[-6] // @1416 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1416 memory[stack[-4]:stack[-4] + stack[-5]] // @1416 stack[-2] // @1416 stack[-5] // @1416 stack[-4] // @1416 stack[-7] // } 1413 5B JUMPDEST 1414 50 POP 1415 5A GAS 1416 F1 CALL 1417 15 ISZERO 1418 80 DUP1 1419 15 ISZERO 141A 61 PUSH2 0x1427 141D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1416 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1417 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 0x1427, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_141E: // Incoming jump from 0x141D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @141E returndata.length // @1422 returndata[0x00:0x00 + returndata.length] // @1423 returndata.length // @1426 memory[0x00:0x00 + returndata.length] // } 141E 3D RETURNDATASIZE 141F 60 PUSH1 0x00 1421 80 DUP1 1422 3E RETURNDATACOPY 1423 3D RETURNDATASIZE 1424 60 PUSH1 0x00 1426 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1422 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1426 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1427: // Incoming jump from 0x141D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @142F stack[-6] } 1427 5B JUMPDEST 1428 50 POP 1429 50 POP 142A 50 POP 142B 50 POP 142C 61 PUSH2 0x03e9 142F 82 DUP3 1430 10 LT 1431 15 ISZERO 1432 61 PUSH2 0x1465 1435 57 *JUMPI // Stack delta = -4 // Block ends with conditional jump to 0x1465, if !(stack[-6] < 0x03e9) label_1436: // Incoming jump from 0x1435, if not !(stack[-6] < 0x03e9) // Inputs[8] // { // @143F stack[-4] // @144F memory[0x00:0x40] // @1451 storage[keccak256(memory[0x00:0x40])] // @1459 stack[-3] // @145D memory[0x00:0x40] // @145F storage[keccak256(memory[0x00:0x40])] // @146B stack[-2] // @146C stack[-1] // } 1436 60 PUSH1 0x01 1438 60 PUSH1 0x01 143A 60 PUSH1 0xa0 143C 1B SHL 143D 03 SUB 143E 80 DUP1 143F 85 DUP6 1440 16 AND 1441 60 PUSH1 0x00 1443 90 SWAP1 1444 81 DUP2 1445 52 MSTORE 1446 60 PUSH1 0x10 1448 60 PUSH1 0x20 144A 52 MSTORE 144B 60 PUSH1 0x40 144D 80 DUP1 144E 82 DUP3 144F 20 SHA3 1450 80 DUP1 1451 54 SLOAD 1452 60 PUSH1 0x00 1454 19 NOT 1455 01 ADD 1456 90 SWAP1 1457 55 SSTORE 1458 91 SWAP2 1459 85 DUP6 145A 16 AND 145B 81 DUP2 145C 52 MSTORE 145D 20 SHA3 145E 80 DUP1 145F 54 SLOAD 1460 60 PUSH1 0x01 1462 01 ADD 1463 90 SWAP1 1464 55 SSTORE 1465 5B JUMPDEST 1466 61 PUSH2 0x0c7d 1469 84 DUP5 146A 84 DUP5 146B 84 DUP5 146C 84 DUP5 146D 61 PUSH2 0x201f 1470 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @1445 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @144A memory[0x20:0x40] = 0x10 // @1457 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @145C memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1464 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @1466 stack[0] = 0x0c7d // @1469 stack[1] = stack[-4] // @146A stack[2] = stack[-3] // @146B stack[3] = stack[-2] // @146C stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x201f label_1471: // Incoming call from 0x04D2, returns to 0x0330 // Inputs[1] { @147C stack[-1] } 1471 5B JUMPDEST 1472 68 PUSH9 0x2086ac351052600000 147C 81 DUP2 147D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1472 stack[0] = 0x2086ac351052600000 } // Block ends with unconditional jump to stack[-1] label_147E: // Incoming jump from 0x04E5 147E 5B JUMPDEST 147F 61 PUSH2 0x1486 1482 61 PUSH2 0x1e91 1485 56 *JUMP // Stack delta = +1 // Outputs[1] { @147F stack[0] = 0x1486 } // Block ends with call to 0x1e91, returns to 0x1486 label_1486: // Incoming return from call to 0x1E91 at 0x1485 // Inputs[2] // { // @1489 storage[0x0e] // @1495 stack[-1] // } 1486 5B JUMPDEST 1487 60 PUSH1 0x0e 1489 54 SLOAD 148A 60 PUSH1 0x01 148C 60 PUSH1 0x01 148E 60 PUSH1 0xa0 1490 1B SHL 1491 03 SUB 1492 90 SWAP1 1493 81 DUP2 1494 16 AND 1495 91 SWAP2 1496 16 AND 1497 14 EQ 1498 61 PUSH2 0x14b3 149B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14b3, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_149C: // Incoming jump from 0x149B, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @149E memory[0x40:0x60] } 149C 60 PUSH1 0x40 149E 51 MLOAD 149F 62 PUSH3 0x461bcd 14A3 60 PUSH1 0xe5 14A5 1B SHL 14A6 81 DUP2 14A7 52 MSTORE 14A8 60 PUSH1 0x04 14AA 01 ADD 14AB 61 PUSH2 0x05f6 14AE 90 SWAP1 14AF 61 PUSH2 0x3666 14B2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14AE stack[0] = 0x05f6 // @14AE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3666, returns to 0x05F6 label_14B3: // Incoming jump from 0x149B, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @14B7 stack[-1] } 14B3 5B JUMPDEST 14B4 61 PUSH2 0x14bc 14B7 81 DUP2 14B8 61 PUSH2 0x2058 14BB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14B4 stack[0] = 0x14bc // @14B7 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x2058 label_14BC: // Incoming jump from 0x3923, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x390D, if stack[-1] == !!stack[-1] // Incoming jump from 0x38FF, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14BE stack[-2] } 14BC 5B JUMPDEST 14BD 50 POP 14BE 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_14BF: // Incoming jump from 0x04F8 // Inputs[4] // { // @14C2 storage[0x12] // @14C5 storage[0x0a] // @14C8 memory[0x40:0x60] // @14E9 msg.sender // } 14BF 5B JUMPDEST 14C0 60 PUSH1 0x12 14C2 54 SLOAD 14C3 60 PUSH1 0x0a 14C5 54 SLOAD 14C6 60 PUSH1 0x40 14C8 51 MLOAD 14C9 63 PUSH4 0x2770a7eb 14CE 60 PUSH1 0xe2 14D0 1B SHL 14D1 81 DUP2 14D2 52 MSTORE 14D3 60 PUSH1 0x01 14D5 60 PUSH1 0x01 14D7 60 PUSH1 0xa0 14D9 1B SHL 14DA 03 SUB 14DB 90 SWAP1 14DC 92 SWAP3 14DD 16 AND 14DE 91 SWAP2 14DF 63 PUSH4 0x9dc29fac 14E4 91 SWAP2 14E5 61 PUSH2 0x14f3 14E8 91 SWAP2 14E9 33 CALLER 14EA 91 SWAP2 14EB 90 SWAP1 14EC 60 PUSH1 0x04 14EE 01 ADD 14EF 61 PUSH2 0x3113 14F2 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @14D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2770a7eb << 0xe2 // @14DE stack[0] = storage[0x12] & (0x01 << 0xa0) - 0x01 // @14E4 stack[1] = 0x9dc29fac // @14E8 stack[2] = 0x14f3 // @14EA stack[3] = msg.sender // @14EB stack[4] = storage[0x0a] // @14EE stack[5] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3113, returns to 0x14F3 label_14F3: // Incoming return from call to 0x3113 at 0x14F2 // Inputs[4] // { // @14F8 memory[0x40:0x60] // @14FA stack[-1] // @14FF stack[-3] // @1501 address(stack[-3]).code.length // } 14F3 5B JUMPDEST 14F4 60 PUSH1 0x00 14F6 60 PUSH1 0x40 14F8 51 MLOAD 14F9 80 DUP1 14FA 83 DUP4 14FB 03 SUB 14FC 81 DUP2 14FD 60 PUSH1 0x00 14FF 87 DUP8 1500 80 DUP1 1501 3B EXTCODESIZE 1502 15 ISZERO 1503 80 DUP1 1504 15 ISZERO 1505 61 PUSH2 0x150d 1508 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @14F4 stack[0] = 0x00 // @14F8 stack[1] = memory[0x40:0x60] // @14FB stack[2] = stack[-1] - memory[0x40:0x60] // @14FC stack[3] = memory[0x40:0x60] // @14FD stack[4] = 0x00 // @14FF stack[5] = stack[-3] // @1502 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x150d, if !!address(stack[-3]).code.length label_1509: // Incoming jump from 0x1508, if not !!address(stack[-3]).code.length // Inputs[1] { @150C memory[0x00:0x00] } 1509 60 PUSH1 0x00 150B 80 DUP1 150C FD *REVERT // Stack delta = +0 // Outputs[1] { @150C revert(memory[0x00:0x00]); } // Block terminates label_150D: // Incoming jump from 0x1508, if !!address(stack[-3]).code.length // Inputs[9] // { // @150F msg.gas // @1510 stack[-7] // @1510 stack[-5] // @1510 memory[stack[-4]:stack[-4] + stack[-5]] // @1510 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1510 stack[-2] // @1510 stack[-3] // @1510 stack[-4] // @1510 stack[-6] // } 150D 5B JUMPDEST 150E 50 POP 150F 5A GAS 1510 F1 CALL 1511 15 ISZERO 1512 80 DUP1 1513 15 ISZERO 1514 61 PUSH2 0x1521 1517 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1510 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1511 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 0x1521, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1518: // Incoming jump from 0x1517, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1518 returndata.length // @151C returndata[0x00:0x00 + returndata.length] // @151D returndata.length // @1520 memory[0x00:0x00 + returndata.length] // } 1518 3D RETURNDATASIZE 1519 60 PUSH1 0x00 151B 80 DUP1 151C 3E RETURNDATACOPY 151D 3D RETURNDATASIZE 151E 60 PUSH1 0x00 1520 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @151C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1520 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1521: // Incoming jump from 0x1517, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1529 stack[-6] // @152A stack[-5] // } 1521 5B JUMPDEST 1522 50 POP 1523 50 POP 1524 50 POP 1525 50 POP 1526 61 PUSH2 0x0d21 1529 82 DUP3 152A 82 DUP3 152B 61 PUSH2 0x206b 152E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1526 stack[-4] = 0x0d21 // @1529 stack[-3] = stack[-6] // @152A stack[-2] = stack[-5] // } // Block ends with unconditional jump to 0x206b label_152F: // Incoming jump from 0x050B // Inputs[1] { @1535 stack[-1] } 152F 5B JUMPDEST 1530 60 PUSH1 0x60 1532 61 PUSH2 0x153a 1535 82 DUP3 1536 61 PUSH2 0x1e84 1539 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1530 stack[0] = 0x60 // @1532 stack[1] = 0x153a // @1535 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1e84 153A 5B JUMPDEST 153B 61 PUSH2 0x1556 153E 57 *JUMPI 153F 60 PUSH1 0x40 1541 51 MLOAD 1542 62 PUSH3 0x461bcd 1546 60 PUSH1 0xe5 1548 1B SHL 1549 81 DUP2 154A 52 MSTORE 154B 60 PUSH1 0x04 154D 01 ADD 154E 61 PUSH2 0x05f6 1551 90 SWAP1 1552 61 PUSH2 0x36e4 1555 56 *JUMP 1556 5B JUMPDEST 1557 60 PUSH1 0x00 1559 82 DUP3 155A 81 DUP2 155B 52 MSTORE 155C 60 PUSH1 0x08 155E 60 PUSH1 0x20 1560 90 SWAP1 1561 81 DUP2 1562 52 MSTORE 1563 60 PUSH1 0x40 1565 91 SWAP2 1566 82 DUP3 1567 90 SWAP1 1568 20 SHA3 1569 80 DUP1 156A 54 SLOAD 156B 83 DUP4 156C 51 MLOAD 156D 60 PUSH1 0x1f 156F 60 PUSH1 0x02 1571 60 PUSH1 0x00 1573 19 NOT 1574 61 PUSH2 0x0100 1577 60 PUSH1 0x01 1579 86 DUP7 157A 16 AND 157B 15 ISZERO 157C 02 MUL 157D 01 ADD 157E 90 SWAP1 157F 93 SWAP4 1580 16 AND 1581 92 SWAP3 1582 90 SWAP1 1583 92 SWAP3 1584 04 DIV 1585 91 SWAP2 1586 82 DUP3 1587 01 ADD 1588 84 DUP5 1589 90 SWAP1 158A 04 DIV 158B 84 DUP5 158C 02 MUL 158D 81 DUP2 158E 01 ADD 158F 84 DUP5 1590 01 ADD 1591 90 SWAP1 1592 94 SWAP5 1593 52 MSTORE 1594 80 DUP1 1595 84 DUP5 1596 52 MSTORE 1597 60 PUSH1 0x60 1599 93 SWAP4 159A 92 SWAP3 159B 83 DUP4 159C 01 ADD 159D 82 DUP3 159E 82 DUP3 159F 80 DUP1 15A0 15 ISZERO 15A1 61 PUSH2 0x15eb 15A4 57 *JUMPI 15A5 80 DUP1 15A6 60 PUSH1 0x1f 15A8 10 LT 15A9 61 PUSH2 0x15c0 15AC 57 *JUMPI 15AD 61 PUSH2 0x0100 15B0 80 DUP1 15B1 83 DUP4 15B2 54 SLOAD 15B3 04 DIV 15B4 02 MUL 15B5 83 DUP4 15B6 52 MSTORE 15B7 91 SWAP2 15B8 60 PUSH1 0x20 15BA 01 ADD 15BB 91 SWAP2 15BC 61 PUSH2 0x15eb 15BF 56 *JUMP 15C0 5B JUMPDEST 15C1 82 DUP3 15C2 01 ADD 15C3 91 SWAP2 15C4 90 SWAP1 15C5 60 PUSH1 0x00 15C7 52 MSTORE 15C8 60 PUSH1 0x20 15CA 60 PUSH1 0x00 15CC 20 SHA3 15CD 90 SWAP1 15CE 5B JUMPDEST 15CF 81 DUP2 15D0 54 SLOAD 15D1 81 DUP2 15D2 52 MSTORE 15D3 90 SWAP1 15D4 60 PUSH1 0x01 15D6 01 ADD 15D7 90 SWAP1 15D8 60 PUSH1 0x20 15DA 01 ADD 15DB 80 DUP1 15DC 83 DUP4 15DD 11 GT 15DE 61 PUSH2 0x15ce 15E1 57 *JUMPI 15E2 82 DUP3 15E3 90 SWAP1 15E4 03 SUB 15E5 60 PUSH1 0x1f 15E7 16 AND 15E8 82 DUP3 15E9 01 ADD 15EA 91 SWAP2 15EB 5B JUMPDEST 15EC 50 POP 15ED 50 POP 15EE 60 PUSH1 0x09 15F0 54 SLOAD 15F1 93 SWAP4 15F2 94 SWAP5 15F3 50 POP 15F4 50 POP 15F5 50 POP 15F6 50 POP 15F7 60 PUSH1 0x02 15F9 60 PUSH1 0x00 15FB 19 NOT 15FC 61 PUSH2 0x0100 15FF 60 PUSH1 0x01 1601 84 DUP5 1602 16 AND 1603 15 ISZERO 1604 02 MUL 1605 01 ADD 1606 90 SWAP1 1607 91 SWAP2 1608 16 AND 1609 04 DIV 160A 61 PUSH2 0x1614 160D 57 *JUMPI 160E 90 SWAP1 160F 50 POP 1610 61 PUSH2 0x05cc 1613 56 *JUMP 1614 5B JUMPDEST 1615 80 DUP1 1616 51 MLOAD 1617 15 ISZERO 1618 61 PUSH2 0x1646 161B 57 *JUMPI 161C 60 PUSH1 0x09 161E 81 DUP2 161F 60 PUSH1 0x40 1621 51 MLOAD 1622 60 PUSH1 0x20 1624 01 ADD 1625 61 PUSH2 0x162f 1628 92 SWAP3 1629 91 SWAP2 162A 90 SWAP1 162B 61 PUSH2 0x2fb0 162E 56 *JUMP 162F 5B JUMPDEST 1630 60 PUSH1 0x40 1632 51 MLOAD 1633 60 PUSH1 0x20 1635 81 DUP2 1636 83 DUP4 1637 03 SUB 1638 03 SUB 1639 81 DUP2 163A 52 MSTORE 163B 90 SWAP1 163C 60 PUSH1 0x40 163E 52 MSTORE 163F 91 SWAP2 1640 50 POP 1641 50 POP 1642 61 PUSH2 0x05cc 1645 56 *JUMP 1646 5B JUMPDEST 1647 60 PUSH1 0x09 1649 61 PUSH2 0x1651 164C 84 DUP5 164D 61 PUSH2 0x22f0 1650 56 *JUMP 1651 5B JUMPDEST 1652 60 PUSH1 0x40 1654 51 MLOAD 1655 60 PUSH1 0x20 1657 01 ADD 1658 61 PUSH2 0x1662 165B 92 SWAP3 165C 91 SWAP2 165D 90 SWAP1 165E 61 PUSH2 0x2fb0 1661 56 *JUMP 1662 5B JUMPDEST 1663 60 PUSH1 0x40 1665 51 MLOAD 1666 60 PUSH1 0x20 1668 81 DUP2 1669 83 DUP4 166A 03 SUB 166B 03 SUB 166C 81 DUP2 166D 52 MSTORE 166E 90 SWAP1 166F 60 PUSH1 0x40 1671 52 MSTORE 1672 91 SWAP2 1673 50 POP 1674 50 POP 1675 91 SWAP2 1676 90 SWAP1 1677 50 POP 1678 56 *JUMP label_1679: // Incoming jump from 0x051E 1679 5B JUMPDEST 167A 61 PUSH2 0x1681 167D 61 PUSH2 0x1e91 1680 56 *JUMP // Stack delta = +1 // Outputs[1] { @167A stack[0] = 0x1681 } // Block ends with call to 0x1e91, returns to 0x1681 label_1681: // Incoming return from call to 0x1E91 at 0x1680 // Inputs[2] // { // @1684 storage[0x0e] // @1690 stack[-1] // } 1681 5B JUMPDEST 1682 60 PUSH1 0x0e 1684 54 SLOAD 1685 60 PUSH1 0x01 1687 60 PUSH1 0x01 1689 60 PUSH1 0xa0 168B 1B SHL 168C 03 SUB 168D 90 SWAP1 168E 81 DUP2 168F 16 AND 1690 91 SWAP2 1691 16 AND 1692 14 EQ 1693 61 PUSH2 0x16ae 1696 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16ae, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_1697: // Incoming jump from 0x1696, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @1699 memory[0x40:0x60] } 1697 60 PUSH1 0x40 1699 51 MLOAD 169A 62 PUSH3 0x461bcd 169E 60 PUSH1 0xe5 16A0 1B SHL 16A1 81 DUP2 16A2 52 MSTORE 16A3 60 PUSH1 0x04 16A5 01 ADD 16A6 61 PUSH2 0x05f6 16A9 90 SWAP1 16AA 61 PUSH2 0x3666 16AD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16A9 stack[0] = 0x05f6 // @16A9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3666, returns to 0x05F6 label_16AE: // Incoming jump from 0x1696, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[2] // { // @16B1 stack[-1] // @16B2 stack[-2] // } 16AE 5B JUMPDEST 16AF 60 PUSH1 0x0a 16B1 55 SSTORE 16B2 56 *JUMP // Stack delta = -2 // Outputs[1] { @16B1 storage[0x0a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_16B3: // Incoming jump from 0x0531 // Inputs[2] // { // @16B4 msg.sender // @16B8 stack[-2] // } 16B3 5B JUMPDEST 16B4 33 CALLER 16B5 61 PUSH2 0x16bd 16B8 83 DUP4 16B9 61 PUSH2 0x0d53 16BC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16B4 stack[0] = msg.sender // @16B5 stack[1] = 0x16bd // @16B8 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0d53 16BD 5B JUMPDEST 16BE 60 PUSH1 0x01 16C0 60 PUSH1 0x01 16C2 60 PUSH1 0xa0 16C4 1B SHL 16C5 03 SUB 16C6 16 AND 16C7 14 EQ 16C8 80 DUP1 16C9 15 ISZERO 16CA 61 PUSH2 0x16e3 16CD 57 *JUMPI 16CE 50 POP 16CF 33 CALLER 16D0 61 PUSH2 0x16d8 16D3 82 DUP3 16D4 61 PUSH2 0x0d53 16D7 56 *JUMP 16D8 5B JUMPDEST 16D9 60 PUSH1 0x01 16DB 60 PUSH1 0x01 16DD 60 PUSH1 0xa0 16DF 1B SHL 16E0 03 SUB 16E1 16 AND 16E2 14 EQ 16E3 5B JUMPDEST 16E4 61 PUSH2 0x16ec 16E7 57 *JUMPI 16E8 60 PUSH1 0x00 16EA 80 DUP1 16EB FD *REVERT 16EC 5B JUMPDEST 16ED 60 PUSH1 0x13 16EF 54 SLOAD 16F0 60 PUSH1 0x40 16F2 51 MLOAD 16F3 63 PUSH4 0x0987907f 16F8 60 PUSH1 0xe4 16FA 1B SHL 16FB 81 DUP2 16FC 52 MSTORE 16FD 60 PUSH1 0x01 16FF 60 PUSH1 0x01 1701 60 PUSH1 0xa0 1703 1B SHL 1704 03 SUB 1705 90 SWAP1 1706 91 SWAP2 1707 16 AND 1708 90 SWAP1 1709 63 PUSH4 0x987907f0 170E 90 SWAP1 170F 61 PUSH2 0x171e 1712 90 SWAP1 1713 85 DUP6 1714 90 SWAP1 1715 85 DUP6 1716 90 SWAP1 1717 60 PUSH1 0x04 1719 01 ADD 171A 61 PUSH2 0x3062 171D 56 *JUMP 171E 5B JUMPDEST 171F 60 PUSH1 0x20 1721 60 PUSH1 0x40 1723 51 MLOAD 1724 80 DUP1 1725 83 DUP4 1726 03 SUB 1727 81 DUP2 1728 60 PUSH1 0x00 172A 87 DUP8 172B 80 DUP1 172C 3B EXTCODESIZE 172D 15 ISZERO 172E 80 DUP1 172F 15 ISZERO 1730 61 PUSH2 0x1738 1733 57 *JUMPI 1734 60 PUSH1 0x00 1736 80 DUP1 1737 FD *REVERT 1738 5B JUMPDEST 1739 50 POP 173A 5A GAS 173B F1 CALL 173C 15 ISZERO 173D 80 DUP1 173E 15 ISZERO 173F 61 PUSH2 0x174c 1742 57 *JUMPI 1743 3D RETURNDATASIZE 1744 60 PUSH1 0x00 1746 80 DUP1 1747 3E RETURNDATACOPY 1748 3D RETURNDATASIZE 1749 60 PUSH1 0x00 174B FD *REVERT 174C 5B JUMPDEST 174D 50 POP 174E 50 POP 174F 50 POP 1750 50 POP 1751 60 PUSH1 0x40 1753 51 MLOAD 1754 3D RETURNDATASIZE 1755 60 PUSH1 0x1f 1757 19 NOT 1758 60 PUSH1 0x1f 175A 82 DUP3 175B 01 ADD 175C 16 AND 175D 82 DUP3 175E 01 ADD 175F 80 DUP1 1760 60 PUSH1 0x40 1762 52 MSTORE 1763 50 POP 1764 81 DUP2 1765 01 ADD 1766 90 SWAP1 1767 61 PUSH2 0x1770 176A 91 SWAP2 176B 90 SWAP1 176C 61 PUSH2 0x2d8a 176F 56 *JUMP 1770 5B JUMPDEST 1771 61 PUSH2 0x1779 1774 57 *JUMPI 1775 60 PUSH1 0x00 1777 80 DUP1 1778 FD *REVERT 1779 5B JUMPDEST 177A 60 PUSH1 0x12 177C 54 SLOAD 177D 60 PUSH1 0x40 177F 51 MLOAD 1780 63 PUSH4 0x2770a7eb 1785 60 PUSH1 0xe2 1787 1B SHL 1788 81 DUP2 1789 52 MSTORE 178A 60 PUSH1 0x01 178C 60 PUSH1 0x01 178E 60 PUSH1 0xa0 1790 1B SHL 1791 03 SUB 1792 90 SWAP1 1793 91 SWAP2 1794 16 AND 1795 90 SWAP1 1796 63 PUSH4 0x9dc29fac 179B 90 SWAP1 179C 61 PUSH2 0x17b4 179F 90 SWAP1 17A0 33 CALLER 17A1 90 SWAP1 17A2 68 PUSH9 0x2086ac351052600000 17AC 90 SWAP1 17AD 60 PUSH1 0x04 17AF 01 ADD 17B0 61 PUSH2 0x3113 17B3 56 *JUMP 17B4 5B JUMPDEST 17B5 60 PUSH1 0x00 17B7 60 PUSH1 0x40 17B9 51 MLOAD 17BA 80 DUP1 17BB 83 DUP4 17BC 03 SUB 17BD 81 DUP2 17BE 60 PUSH1 0x00 17C0 87 DUP8 17C1 80 DUP1 17C2 3B EXTCODESIZE 17C3 15 ISZERO 17C4 80 DUP1 17C5 15 ISZERO 17C6 61 PUSH2 0x17ce 17C9 57 *JUMPI 17CA 60 PUSH1 0x00 17CC 80 DUP1 17CD FD *REVERT 17CE 5B JUMPDEST 17CF 50 POP 17D0 5A GAS 17D1 F1 CALL 17D2 15 ISZERO 17D3 80 DUP1 17D4 15 ISZERO 17D5 61 PUSH2 0x17e2 17D8 57 *JUMPI 17D9 3D RETURNDATASIZE 17DA 60 PUSH1 0x00 17DC 80 DUP1 17DD 3E RETURNDATACOPY 17DE 3D RETURNDATASIZE 17DF 60 PUSH1 0x00 17E1 FD *REVERT 17E2 5B JUMPDEST 17E3 50 POP 17E4 50 POP 17E5 60 PUSH1 0x11 17E7 80 DUP1 17E8 54 SLOAD 17E9 60 PUSH1 0x01 17EB 80 DUP1 17EC 82 DUP3 17ED 01 ADD 17EE 90 SWAP1 17EF 92 SWAP3 17F0 55 SSTORE 17F1 60 PUSH1 0x40 17F3 80 DUP1 17F4 51 MLOAD 17F5 80 DUP1 17F6 82 DUP3 17F7 01 ADD 17F8 82 DUP3 17F9 52 MSTORE 17FA 60 PUSH1 0x00 17FC 80 DUP1 17FD 82 DUP3 17FE 52 MSTORE 17FF 42 TIMESTAMP 1800 60 PUSH1 0x20 1802 80 DUP1 1803 84 DUP5 1804 01 ADD 1805 91 SWAP2 1806 82 DUP3 1807 52 MSTORE 1808 61 PUSH2 0x03e9 180B 90 SWAP1 180C 95 SWAP6 180D 01 ADD 180E 80 DUP1 180F 83 DUP4 1810 52 MSTORE 1811 60 PUSH1 0x0f 1813 90 SWAP1 1814 95 SWAP6 1815 52 MSTORE 1816 92 SWAP3 1817 90 SWAP1 1818 20 SHA3 1819 90 SWAP1 181A 51 MLOAD 181B 81 DUP2 181C 55 SSTORE 181D 90 SWAP1 181E 51 MLOAD 181F 92 SWAP3 1820 01 ADD 1821 91 SWAP2 1822 90 SWAP1 1823 91 SWAP2 1824 55 SSTORE 1825 91 SWAP2 1826 50 POP 1827 61 PUSH2 0x1832 182A 90 SWAP1 182B 50 POP 182C 33 CALLER 182D 82 DUP3 182E 61 PUSH2 0x1dc0 1831 56 *JUMP 1832 5B JUMPDEST 1833 7F PUSH32 0xbeacfa49f9edca3f9eb455bc9a8b4c5c9be74a6b8bb0acb319427fc84c55b1c8 1854 81 DUP2 1855 83 DUP4 1856 85 DUP6 1857 60 PUSH1 0x40 1859 51 MLOAD 185A 61 PUSH2 0x1865 185D 93 SWAP4 185E 92 SWAP3 185F 91 SWAP2 1860 90 SWAP1 1861 61 PUSH2 0x38ad 1864 56 *JUMP 1865 5B JUMPDEST 1866 60 PUSH1 0x40 1868 51 MLOAD 1869 80 DUP1 186A 91 SWAP2 186B 03 SUB 186C 90 SWAP1 186D A1 LOG1 186E 50 POP 186F 50 POP 1870 50 POP 1871 56 *JUMP label_1872: // Incoming jump from 0x0544 // Inputs[6] // { // @187B stack[-2] // @188E memory[0x00:0x40] // @188F stack[-1] // @1899 memory[0x00:0x40] // @189A storage[keccak256(memory[0x00:0x40])] // @189E stack[-3] // } 1872 5B JUMPDEST 1873 60 PUSH1 0x01 1875 60 PUSH1 0x01 1877 60 PUSH1 0xa0 1879 1B SHL 187A 03 SUB 187B 91 SWAP2 187C 82 DUP3 187D 16 AND 187E 60 PUSH1 0x00 1880 90 SWAP1 1881 81 DUP2 1882 52 MSTORE 1883 60 PUSH1 0x05 1885 60 PUSH1 0x20 1887 90 SWAP1 1888 81 DUP2 1889 52 MSTORE 188A 60 PUSH1 0x40 188C 80 DUP1 188D 83 DUP4 188E 20 SHA3 188F 93 SWAP4 1890 90 SWAP1 1891 94 SWAP5 1892 16 AND 1893 82 DUP3 1894 52 MSTORE 1895 91 SWAP2 1896 90 SWAP1 1897 91 SWAP2 1898 52 MSTORE 1899 20 SHA3 189A 54 SLOAD 189B 60 PUSH1 0xff 189D 16 AND 189E 90 SWAP1 189F 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1882 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1889 memory[0x20:0x40] = 0x05 // @1894 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1898 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @189E stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_18A0: // Incoming jump from 0x0557 // Inputs[2] // { // @18A1 msg.sender // @18A5 stack[-1] // } 18A0 5B JUMPDEST 18A1 33 CALLER 18A2 61 PUSH2 0x18aa 18A5 82 DUP3 18A6 61 PUSH2 0x0d53 18A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18A1 stack[0] = msg.sender // @18A2 stack[1] = 0x18aa // @18A5 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0d53 18AA 5B JUMPDEST 18AB 60 PUSH1 0x01 18AD 60 PUSH1 0x01 18AF 60 PUSH1 0xa0 18B1 1B SHL 18B2 03 SUB 18B3 16 AND 18B4 14 EQ 18B5 61 PUSH2 0x18bd 18B8 57 *JUMPI 18B9 60 PUSH1 0x00 18BB 80 DUP1 18BC FD *REVERT 18BD 5B JUMPDEST 18BE 60 PUSH1 0x00 18C0 81 DUP2 18C1 81 DUP2 18C2 52 MSTORE 18C3 60 PUSH1 0x0f 18C5 60 PUSH1 0x20 18C7 52 MSTORE 18C8 60 PUSH1 0x40 18CA 90 SWAP1 18CB 20 SHA3 18CC 80 DUP1 18CD 54 SLOAD 18CE 15 ISZERO 18CF 61 PUSH2 0x18d7 18D2 57 *JUMPI 18D3 60 PUSH1 0x00 18D5 80 DUP1 18D6 FD *REVERT 18D7 5B JUMPDEST 18D8 60 PUSH1 0x13 18DA 54 SLOAD 18DB 60 PUSH1 0x40 18DD 51 MLOAD 18DE 63 PUSH4 0x3c511985 18E3 60 PUSH1 0xe1 18E5 1B SHL 18E6 81 DUP2 18E7 52 MSTORE 18E8 60 PUSH1 0x00 18EA 91 SWAP2 18EB 60 PUSH1 0x01 18ED 60 PUSH1 0x01 18EF 60 PUSH1 0xa0 18F1 1B SHL 18F2 03 SUB 18F3 16 AND 18F4 90 SWAP1 18F5 63 PUSH4 0x78a2330a 18FA 90 SWAP1 18FB 61 PUSH2 0x1908 18FE 90 SWAP1 18FF 86 DUP7 1900 90 SWAP1 1901 60 PUSH1 0x04 1903 01 ADD 1904 61 PUSH2 0x38a4 1907 56 *JUMP 1908 5B JUMPDEST 1909 60 PUSH1 0x20 190B 60 PUSH1 0x40 190D 51 MLOAD 190E 80 DUP1 190F 83 DUP4 1910 03 SUB 1911 81 DUP2 1912 86 DUP7 1913 80 DUP1 1914 3B EXTCODESIZE 1915 15 ISZERO 1916 80 DUP1 1917 15 ISZERO 1918 61 PUSH2 0x1920 191B 57 *JUMPI 191C 60 PUSH1 0x00 191E 80 DUP1 191F FD *REVERT 1920 5B JUMPDEST 1921 50 POP 1922 5A GAS 1923 FA STATICCALL 1924 15 ISZERO 1925 80 DUP1 1926 15 ISZERO 1927 61 PUSH2 0x1934 192A 57 *JUMPI 192B 3D RETURNDATASIZE 192C 60 PUSH1 0x00 192E 80 DUP1 192F 3E RETURNDATACOPY 1930 3D RETURNDATASIZE 1931 60 PUSH1 0x00 1933 FD *REVERT 1934 5B JUMPDEST 1935 50 POP 1936 50 POP 1937 50 POP 1938 50 POP 1939 60 PUSH1 0x40 193B 51 MLOAD 193C 3D RETURNDATASIZE 193D 60 PUSH1 0x1f 193F 19 NOT 1940 60 PUSH1 0x1f 1942 82 DUP3 1943 01 ADD 1944 16 AND 1945 82 DUP3 1946 01 ADD 1947 80 DUP1 1948 60 PUSH1 0x40 194A 52 MSTORE 194B 50 POP 194C 81 DUP2 194D 01 ADD 194E 90 SWAP1 194F 61 PUSH2 0x1958 1952 91 SWAP2 1953 90 SWAP1 1954 61 PUSH2 0x2da6 1957 56 *JUMP 1958 5B JUMPDEST 1959 80 DUP1 195A 83 DUP4 195B 55 SSTORE 195C 60 PUSH1 0x40 195E 51 MLOAD 195F 90 SWAP1 1960 91 SWAP2 1961 50 POP 1962 7F PUSH32 0xdde4a29d9b4e2fc8b8ecc3389d7a8d4ccc464ea07c41be15b06b83ebd4a37383 1983 90 SWAP1 1984 61 PUSH2 0x1865 1987 90 SWAP1 1988 85 DUP6 1989 90 SWAP1 198A 84 DUP5 198B 90 SWAP1 198C 61 PUSH2 0x3062 198F 56 *JUMP label_1990: // Incoming jump from 0x056A // Inputs[1] { @1993 msg.sender } 1990 5B JUMPDEST 1991 60 PUSH1 0x00 1993 33 CALLER 1994 73 PUSH20 0x495f947276749ce646f68ac8c248420045cb7b5e 19A9 14 EQ 19AA 61 PUSH2 0x19c5 19AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1991 stack[0] = 0x00 } // Block ends with conditional jump to 0x19c5, if 0x495f947276749ce646f68ac8c248420045cb7b5e == msg.sender label_19AE: // Incoming jump from 0x19AD, if not 0x495f947276749ce646f68ac8c248420045cb7b5e == msg.sender // Inputs[1] { @19B0 memory[0x40:0x60] } 19AE 60 PUSH1 0x40 19B0 51 MLOAD 19B1 62 PUSH3 0x461bcd 19B5 60 PUSH1 0xe5 19B7 1B SHL 19B8 81 DUP2 19B9 52 MSTORE 19BA 60 PUSH1 0x04 19BC 01 ADD 19BD 61 PUSH2 0x05f6 19C0 90 SWAP1 19C1 61 PUSH2 0x383f 19C4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19C0 stack[0] = 0x05f6 // @19C0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x383f, returns to 0x05F6 label_19C5: // Incoming jump from 0x19AD, if 0x495f947276749ce646f68ac8c248420045cb7b5e == msg.sender // Inputs[2] // { // @19CF stack[-8] // @19D0 stack[-7] // } 19C5 5B JUMPDEST 19C6 50 POP 19C7 63 PUSH4 0xf23a6e61 19CC 60 PUSH1 0xe0 19CE 1B SHL 19CF 96 SWAP7 19D0 95 SWAP6 19D1 50 POP 19D2 50 POP 19D3 50 POP 19D4 50 POP 19D5 50 POP 19D6 50 POP 19D7 56 *JUMP // Stack delta = -7 // Outputs[1] { @19CF stack[-8] = 0xf23a6e61 << 0xe0 } // Block ends with unconditional jump to stack[-8] label_19D8: // Incoming call from 0x057F, returns to 0x02F5 // Inputs[1] { @19EE stack[-1] } 19D8 5B JUMPDEST 19D9 73 PUSH20 0x495f947276749ce646f68ac8c248420045cb7b5e 19EE 81 DUP2 19EF 56 *JUMP // Stack delta = +1 // Outputs[1] { @19D9 stack[0] = 0x495f947276749ce646f68ac8c248420045cb7b5e } // Block ends with unconditional jump to stack[-1] 19F0 5B JUMPDEST 19F1 61 PUSH2 0x19f8 19F4 61 PUSH2 0x1e91 19F7 56 *JUMP 19F8 5B JUMPDEST 19F9 60 PUSH1 0x0e 19FB 54 SLOAD 19FC 60 PUSH1 0x01 19FE 60 PUSH1 0x01 1A00 60 PUSH1 0xa0 1A02 1B SHL 1A03 03 SUB 1A04 90 SWAP1 1A05 81 DUP2 1A06 16 AND 1A07 91 SWAP2 1A08 16 AND 1A09 14 EQ 1A0A 61 PUSH2 0x1a25 1A0D 57 *JUMPI 1A0E 60 PUSH1 0x40 1A10 51 MLOAD 1A11 62 PUSH3 0x461bcd 1A15 60 PUSH1 0xe5 1A17 1B SHL 1A18 81 DUP2 1A19 52 MSTORE 1A1A 60 PUSH1 0x04 1A1C 01 ADD 1A1D 61 PUSH2 0x05f6 1A20 90 SWAP1 1A21 61 PUSH2 0x3666 1A24 56 *JUMP 1A25 5B JUMPDEST 1A26 60 PUSH1 0x01 1A28 60 PUSH1 0x01 1A2A 60 PUSH1 0xa0 1A2C 1B SHL 1A2D 03 SUB 1A2E 81 DUP2 1A2F 16 AND 1A30 61 PUSH2 0x1a4b 1A33 57 *JUMPI 1A34 60 PUSH1 0x40 1A36 51 MLOAD 1A37 62 PUSH3 0x461bcd 1A3B 60 PUSH1 0xe5 1A3D 1B SHL 1A3E 81 DUP2 1A3F 52 MSTORE 1A40 60 PUSH1 0x04 1A42 01 ADD 1A43 61 PUSH2 0x05f6 1A46 90 SWAP1 1A47 61 PUSH2 0x32b6 1A4A 56 *JUMP 1A4B 5B JUMPDEST 1A4C 60 PUSH1 0x0e 1A4E 54 SLOAD 1A4F 60 PUSH1 0x40 1A51 51 MLOAD 1A52 60 PUSH1 0x01 1A54 60 PUSH1 0x01 1A56 60 PUSH1 0xa0 1A58 1B SHL 1A59 03 SUB 1A5A 80 DUP1 1A5B 84 DUP5 1A5C 16 AND 1A5D 92 SWAP3 1A5E 16 AND 1A5F 90 SWAP1 1A60 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1A81 90 SWAP1 1A82 60 PUSH1 0x00 1A84 90 SWAP1 1A85 A3 LOG3 1A86 60 PUSH1 0x0e 1A88 80 DUP1 1A89 54 SLOAD 1A8A 60 PUSH1 0x01 1A8C 60 PUSH1 0x01 1A8E 60 PUSH1 0xa0 1A90 1B SHL 1A91 03 SUB 1A92 19 NOT 1A93 16 AND 1A94 60 PUSH1 0x01 1A96 60 PUSH1 0x01 1A98 60 PUSH1 0xa0 1A9A 1B SHL 1A9B 03 SUB 1A9C 92 SWAP3 1A9D 90 SWAP1 1A9E 92 SWAP3 1A9F 16 AND 1AA0 91 SWAP2 1AA1 90 SWAP1 1AA2 91 SWAP2 1AA3 17 OR 1AA4 90 SWAP1 1AA5 55 SSTORE 1AA6 56 *JUMP 1AA7 5B JUMPDEST 1AA8 61 PUSH2 0x1aaf 1AAB 61 PUSH2 0x1e91 1AAE 56 *JUMP 1AAF 5B JUMPDEST 1AB0 60 PUSH1 0x0e 1AB2 54 SLOAD 1AB3 60 PUSH1 0x01 1AB5 60 PUSH1 0x01 1AB7 60 PUSH1 0xa0 1AB9 1B SHL 1ABA 03 SUB 1ABB 90 SWAP1 1ABC 81 DUP2 1ABD 16 AND 1ABE 91 SWAP2 1ABF 16 AND 1AC0 14 EQ 1AC1 61 PUSH2 0x1adc 1AC4 57 *JUMPI 1AC5 60 PUSH1 0x40 1AC7 51 MLOAD 1AC8 62 PUSH3 0x461bcd 1ACC 60 PUSH1 0xe5 1ACE 1B SHL 1ACF 81 DUP2 1AD0 52 MSTORE 1AD1 60 PUSH1 0x04 1AD3 01 ADD 1AD4 61 PUSH2 0x05f6 1AD7 90 SWAP1 1AD8 61 PUSH2 0x3666 1ADB 56 *JUMP 1ADC 5B JUMPDEST 1ADD 60 PUSH1 0x13 1ADF 80 DUP1 1AE0 54 SLOAD 1AE1 60 PUSH1 0x01 1AE3 60 PUSH1 0x01 1AE5 60 PUSH1 0xa0 1AE7 1B SHL 1AE8 03 SUB 1AE9 19 NOT 1AEA 16 AND 1AEB 60 PUSH1 0x01 1AED 60 PUSH1 0x01 1AEF 60 PUSH1 0xa0 1AF1 1B SHL 1AF2 03 SUB 1AF3 92 SWAP3 1AF4 90 SWAP1 1AF5 92 SWAP3 1AF6 16 AND 1AF7 91 SWAP2 1AF8 90 SWAP1 1AF9 91 SWAP2 1AFA 17 OR 1AFB 90 SWAP1 1AFC 55 SSTORE 1AFD 56 *JUMP label_1AFE: // Incoming call from 0x05AD, returns to 0x0330 // Inputs[2] // { // @1B01 storage[0x11] // @1B02 stack[-1] // } 1AFE 5B JUMPDEST 1AFF 60 PUSH1 0x11 1B01 54 SLOAD 1B02 81 DUP2 1B03 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B01 stack[0] = storage[0x11] } // Block ends with unconditional jump to stack[-1] 1B04 5B JUMPDEST 1B05 60 PUSH1 0x00 1B07 61 PUSH2 0x0b02 1B0A 83 DUP4 1B0B 83 DUP4 1B0C 61 PUSH2 0x23cb 1B0F 56 *JUMP 1B10 5B JUMPDEST 1B11 60 PUSH1 0x00 1B13 61 PUSH2 0x1b26 1B16 84 DUP5 1B17 84 DUP5 1B18 60 PUSH1 0x01 1B1A 60 PUSH1 0x01 1B1C 60 PUSH1 0xa0 1B1E 1B SHL 1B1F 03 SUB 1B20 85 DUP6 1B21 16 AND 1B22 61 PUSH2 0x2415 1B25 56 *JUMP label_1B26: // Incoming return from call to 0x26FC at 0x201E // Inputs[2] // { // @1B27 stack[-2] // @1B27 stack[-1] // } 1B26 5B JUMPDEST 1B27 90 SWAP1 1B28 50 POP // Stack delta = -1 // Outputs[1] { @1B27 stack[-2] = stack[-1] } // Block continues label_1B29: // Incoming return from call to 0x3912 at 0x2DD9 // Incoming jump from 0x1B28 // Inputs[3] // { // @1B2A stack[-1] // @1B2A stack[-5] // @1B2B stack[-4] // } 1B29 5B JUMPDEST 1B2A 93 SWAP4 1B2B 92 SWAP3 1B2C 50 POP 1B2D 50 POP 1B2E 50 POP 1B2F 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B2A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1B30: // Incoming jump from 0x1E90 // Inputs[2] // { // @1B36 stack[-2] // @1B37 stack[-1] // } 1B30 5B JUMPDEST 1B31 60 PUSH1 0x00 1B33 61 PUSH2 0x0b02 1B36 83 DUP4 1B37 83 DUP4 1B38 61 PUSH2 0x24ac 1B3B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B31 stack[0] = 0x00 // @1B33 stack[1] = 0x0b02 // @1B36 stack[2] = stack[-2] // @1B37 stack[3] = stack[-1] // } // Block ends with call to 0x24ac, returns to 0x0B02 label_1B3C: // Incoming call from 0x05D9, returns to 0x05DA // Inputs[1] { @1B41 stack[-1] } 1B3C 5B JUMPDEST 1B3D 60 PUSH1 0x00 1B3F 60 PUSH1 0x60 1B41 82 DUP3 1B42 90 SWAP1 1B43 1C SHR 1B44 73 PUSH20 0xa2548e7ad6cee01eeb19d49bedb359aea3d8ad1d 1B59 14 EQ 1B5A 61 PUSH2 0x1b65 1B5D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B3D stack[0] = 0x00 } // Block ends with conditional jump to 0x1b65, if 0xa2548e7ad6cee01eeb19d49bedb359aea3d8ad1d == stack[-1] >> 0x60 label_1B5E: // Incoming jump from 0x1B5D, if not 0xa2548e7ad6cee01eeb19d49bedb359aea3d8ad1d == stack[-1] >> 0x60 1B5E 50 POP 1B5F 60 PUSH1 0x00 1B61 61 PUSH2 0x05cc 1B64 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B5F stack[-1] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1B65: // Incoming jump from 0x1B5D, if 0xa2548e7ad6cee01eeb19d49bedb359aea3d8ad1d == stack[-1] >> 0x60 // Inputs[1] { @1B66 stack[-2] } 1B65 5B JUMPDEST 1B66 81 DUP2 1B67 64 PUSH5 0xffffffffff 1B6D 16 AND 1B6E 60 PUSH1 0x01 1B70 14 EQ 1B71 61 PUSH2 0x1b7c 1B74 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b7c, if 0x01 == 0xffffffffff & stack[-2] label_1B75: // Incoming jump from 0x1B74, if not 0x01 == 0xffffffffff & stack[-2] 1B75 50 POP 1B76 60 PUSH1 0x00 1B78 61 PUSH2 0x05cc 1B7B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B76 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1B7C: // Incoming jump from 0x1B74, if 0x01 == 0xffffffffff & stack[-2] // Inputs[1] { @1B87 stack[-2] } 1B7C 5B JUMPDEST 1B7D 66 PUSH7 0xffffffffffffff 1B85 60 PUSH1 0x28 1B87 83 DUP4 1B88 90 SWAP1 1B89 1C SHR 1B8A 16 AND 1B8B 61 PUSH2 0x03ed 1B8E 81 DUP2 1B8F 11 GT 1B90 80 DUP1 1B91 61 PUSH2 0x1b9b 1B94 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B8A stack[0] = (stack[-2] >> 0x28) & 0xffffffffffffff // @1B8F stack[1] = (stack[-2] >> 0x28) & 0xffffffffffffff > 0x03ed // } // Block ends with conditional jump to 0x1b9b, if (stack[-2] >> 0x28) & 0xffffffffffffff > 0x03ed label_1B95: // Incoming jump from 0x1B94, if not (stack[-2] >> 0x28) & 0xffffffffffffff > 0x03ed // Inputs[1] { @1B96 stack[-2] } 1B95 50 POP 1B96 80 DUP1 1B97 61 PUSH2 0x0106 1B9A 14 EQ 1B9B 5B JUMPDEST 1B9C 80 DUP1 1B9D 61 PUSH2 0x1ba6 1BA0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B9A stack[-1] = 0x0106 == stack[-2] } // Block ends with conditional jump to 0x1ba6, if 0x0106 == stack[-2] label_1BA1: // Incoming jump from 0x1BA0, if not stack[-1] // Incoming jump from 0x1BA0, if not 0x0106 == stack[-2] // Inputs[1] { @1BA2 stack[-2] } 1BA1 50 POP 1BA2 80 DUP1 1BA3 60 PUSH1 0xc5 1BA5 14 EQ 1BA6 5B JUMPDEST 1BA7 80 DUP1 1BA8 61 PUSH2 0x1bb1 1BAB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BA5 stack[-1] = 0xc5 == stack[-2] } // Block ends with conditional jump to 0x1bb1, if 0xc5 == stack[-2] label_1BAC: // Incoming jump from 0x1BAB, if not 0xc5 == stack[-2] // Incoming jump from 0x1BAB, if not stack[-1] // Inputs[1] { @1BAD stack[-2] } 1BAC 50 POP 1BAD 80 DUP1 1BAE 60 PUSH1 0x4b 1BB0 14 EQ 1BB1 5B JUMPDEST 1BB2 80 DUP1 1BB3 61 PUSH2 0x1bbc 1BB6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BB0 stack[-1] = 0x4b == stack[-2] } // Block ends with conditional jump to 0x1bbc, if 0x4b == stack[-2] label_1BB7: // Incoming jump from 0x1BB6, if not 0x4b == stack[-2] // Incoming jump from 0x1BB6, if not stack[-1] // Inputs[1] { @1BB8 stack[-2] } 1BB7 50 POP 1BB8 80 DUP1 1BB9 60 PUSH1 0x22 1BBB 14 EQ 1BBC 5B JUMPDEST 1BBD 80 DUP1 1BBE 61 PUSH2 0x1bc7 1BC1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BBB stack[-1] = 0x22 == stack[-2] } // Block ends with conditional jump to 0x1bc7, if 0x22 == stack[-2] label_1BC2: // Incoming jump from 0x1BC1, if not stack[-1] // Incoming jump from 0x1BC1, if not 0x22 == stack[-2] // Inputs[1] { @1BC3 stack[-2] } 1BC2 50 POP 1BC3 80 DUP1 1BC4 60 PUSH1 0x12 1BC6 14 EQ 1BC7 5B JUMPDEST 1BC8 80 DUP1 1BC9 61 PUSH2 0x1bd0 1BCC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BC6 stack[-1] = 0x12 == stack[-2] } // Block ends with conditional jump to 0x1bd0, if 0x12 == stack[-2] label_1BCD: // Incoming jump from 0x1BCC, if not stack[-1] // Incoming jump from 0x1BCC, if not 0x12 == stack[-2] // Inputs[1] { @1BCE stack[-2] } 1BCD 50 POP 1BCE 80 DUP1 1BCF 15 ISZERO 1BD0 5B JUMPDEST 1BD1 15 ISZERO 1BD2 61 PUSH2 0x1bdf 1BD5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1bdf, if !!stack[-2] label_1BD6: // Incoming jump from 0x1BD5, if not !!stack[-2] // Incoming jump from 0x1BD5, if not !stack[-1] // Inputs[1] { @1BD8 stack[-2] } 1BD6 60 PUSH1 0x00 1BD8 91 SWAP2 1BD9 50 POP 1BDA 50 POP 1BDB 61 PUSH2 0x05cc 1BDE 56 *JUMP // Stack delta = -1 // Outputs[1] { @1BD8 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x05cc label_1BDF: // Incoming jump from 0x1BD5, if !!stack[-2] // Incoming jump from 0x1BD5, if !stack[-1] // Inputs[2] // { // @1BE3 stack[-4] // @1BE4 stack[-3] // } 1BDF 5B JUMPDEST 1BE0 50 POP 1BE1 60 PUSH1 0x01 1BE3 92 SWAP3 1BE4 91 SWAP2 1BE5 50 POP 1BE6 50 POP 1BE7 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BE3 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1BE8: // Incoming call from 0x0609, returns to 0x060A // Inputs[1] { @1BEB stack[-1] } 1BE8 5B JUMPDEST 1BE9 60 PUSH1 0x28 1BEB 1C SHR 1BEC 66 PUSH7 0xffffffffffffff 1BF4 16 AND 1BF5 60 PUSH1 0x00 1BF7 61 PUSH2 0x0106 1BFA 82 DUP3 1BFB 11 GT 1BFC 15 ISZERO 1BFD 61 PUSH2 0x1c0b 1C00 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1BF4 stack[-1] = 0xffffffffffffff & (stack[-1] >> 0x28) // @1BF5 stack[0] = 0x00 // } // Block ends with conditional jump to 0x1c0b, if !(0xffffffffffffff & (stack[-1] >> 0x28) > 0x0106) label_1C01: // Incoming jump from 0x1C00, if not !(0xffffffffffffff & (stack[-1] >> 0x28) > 0x0106) // Inputs[1] { @1C05 stack[-2] } 1C01 50 POP 1C02 60 PUSH1 0x04 1C04 19 NOT 1C05 81 DUP2 1C06 01 ADD 1C07 61 PUSH2 0x05cc 1C0A 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C06 stack[-1] = stack[-2] + ~0x04 } // Block ends with unconditional jump to 0x05cc label_1C0B: // Incoming jump from 0x1C00, if !(0xffffffffffffff & (stack[-1] >> 0x28) > 0x0106) // Inputs[1] { @1C0E stack[-2] } 1C0B 5B JUMPDEST 1C0C 60 PUSH1 0xc5 1C0E 82 DUP3 1C0F 11 GT 1C10 15 ISZERO 1C11 61 PUSH2 0x1c1f 1C14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c1f, if !(stack[-2] > 0xc5) label_1C15: // Incoming jump from 0x1C14, if not !(stack[-2] > 0xc5) // Inputs[1] { @1C19 stack[-2] } 1C15 50 POP 1C16 60 PUSH1 0x03 1C18 19 NOT 1C19 81 DUP2 1C1A 01 ADD 1C1B 61 PUSH2 0x05cc 1C1E 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C1A stack[-1] = stack[-2] + ~0x03 } // Block ends with unconditional jump to 0x05cc label_1C1F: // Incoming jump from 0x1C14, if !(stack[-2] > 0xc5) // Inputs[1] { @1C22 stack[-2] } 1C1F 5B JUMPDEST 1C20 60 PUSH1 0x4b 1C22 82 DUP3 1C23 11 GT 1C24 15 ISZERO 1C25 61 PUSH2 0x1c33 1C28 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c33, if !(stack[-2] > 0x4b) label_1C29: // Incoming jump from 0x1C28, if not !(stack[-2] > 0x4b) // Inputs[1] { @1C2D stack[-2] } 1C29 50 POP 1C2A 60 PUSH1 0x02 1C2C 19 NOT 1C2D 81 DUP2 1C2E 01 ADD 1C2F 61 PUSH2 0x05cc 1C32 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C2E stack[-1] = stack[-2] + ~0x02 } // Block ends with unconditional jump to 0x05cc label_1C33: // Incoming jump from 0x1C28, if !(stack[-2] > 0x4b) // Inputs[1] { @1C36 stack[-2] } 1C33 5B JUMPDEST 1C34 60 PUSH1 0x22 1C36 82 DUP3 1C37 11 GT 1C38 15 ISZERO 1C39 61 PUSH2 0x1c47 1C3C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c47, if !(stack[-2] > 0x22) label_1C3D: // Incoming jump from 0x1C3C, if not !(stack[-2] > 0x22) // Inputs[1] { @1C41 stack[-2] } 1C3D 50 POP 1C3E 60 PUSH1 0x01 1C40 19 NOT 1C41 81 DUP2 1C42 01 ADD 1C43 61 PUSH2 0x05cc 1C46 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C42 stack[-1] = stack[-2] + ~0x01 } // Block ends with unconditional jump to 0x05cc label_1C47: // Incoming jump from 0x1C3C, if !(stack[-2] > 0x22) // Inputs[1] { @1C4A stack[-2] } 1C47 5B JUMPDEST 1C48 60 PUSH1 0x12 1C4A 82 DUP3 1C4B 11 GT 1C4C 15 ISZERO 1C4D 61 PUSH2 0x1c5b 1C50 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c5b, if !(stack[-2] > 0x12) label_1C51: // Incoming jump from 0x1C50, if not !(stack[-2] > 0x12) // Inputs[1] { @1C55 stack[-2] } 1C51 50 POP 1C52 60 PUSH1 0x00 1C54 19 NOT 1C55 81 DUP2 1C56 01 ADD 1C57 61 PUSH2 0x05cc 1C5A 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C56 stack[-1] = stack[-2] + ~0x00 } // Block ends with unconditional jump to 0x05cc label_1C5B: // Incoming jump from 0x1C50, if !(stack[-2] > 0x12) // Inputs[1] { @1C5D stack[-2] } 1C5B 5B JUMPDEST 1C5C 50 POP 1C5D 80 DUP1 1C5E 61 PUSH2 0x05cc 1C61 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C5D stack[-1] = stack[-2] } // Block ends with unconditional jump to 0x05cc label_1C62: // Incoming jump from 0x0694 // Inputs[2] // { // @1C65 stack[-1] // @1C68 memory[0x40:0x60] // } 1C62 5B JUMPDEST 1C63 60 PUSH1 0x00 1C65 81 DUP2 1C66 60 PUSH1 0x40 1C68 51 MLOAD 1C69 60 PUSH1 0x20 1C6B 01 ADD 1C6C 61 PUSH2 0x1c75 1C6F 91 SWAP2 1C70 90 SWAP1 1C71 61 PUSH2 0x3031 1C74 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C63 stack[0] = 0x00 // @1C6F stack[1] = 0x1c75 // @1C70 stack[2] = stack[-1] // @1C70 stack[3] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3031, returns to 0x1C75 label_1C75: // Incoming return from call to 0x3031 at 0x1C74 // Inputs[7] // { // @1C78 memory[0x40:0x60] // @1C7C stack[-1] // @1C86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1C8B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1C8C stack[-2] // @1C8E stack[-4] // @1C8F stack[-3] // } 1C75 5B JUMPDEST 1C76 60 PUSH1 0x40 1C78 51 MLOAD 1C79 60 PUSH1 0x20 1C7B 81 DUP2 1C7C 83 DUP4 1C7D 03 SUB 1C7E 03 SUB 1C7F 81 DUP2 1C80 52 MSTORE 1C81 90 SWAP1 1C82 60 PUSH1 0x40 1C84 52 MSTORE 1C85 80 DUP1 1C86 51 MLOAD 1C87 90 SWAP1 1C88 60 PUSH1 0x20 1C8A 01 ADD 1C8B 20 SHA3 1C8C 90 SWAP1 1C8D 50 POP 1C8E 91 SWAP2 1C8F 90 SWAP1 1C90 50 POP 1C91 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1C80 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @1C84 memory[0x40:0x60] = stack[-1] // @1C8E 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_1C92: // Incoming jump from 0x069A // Inputs[2] // { // @1C95 stack[-1] // @1C96 memory[stack[-1]:stack[-1] + 0x20] // } 1C92 5B JUMPDEST 1C93 60 PUSH1 0x00 1C95 81 DUP2 1C96 51 MLOAD 1C97 60 PUSH1 0x41 1C99 14 EQ 1C9A 61 PUSH2 0x1cb5 1C9D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C93 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cb5, if 0x41 == memory[stack[-1]:stack[-1] + 0x20] label_1C9E: // Incoming jump from 0x1C9D, if not 0x41 == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @1CA0 memory[0x40:0x60] } 1C9E 60 PUSH1 0x40 1CA0 51 MLOAD 1CA1 62 PUSH3 0x461bcd 1CA5 60 PUSH1 0xe5 1CA7 1B SHL 1CA8 81 DUP2 1CA9 52 MSTORE 1CAA 60 PUSH1 0x04 1CAC 01 ADD 1CAD 61 PUSH2 0x05f6 1CB0 90 SWAP1 1CB1 61 PUSH2 0x31f6 1CB4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1CA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1CB0 stack[0] = 0x05f6 // @1CB0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x31f6, returns to 0x05F6 label_1CB5: // Incoming jump from 0x1C9D, if 0x41 == memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @1CB8 stack[-2] // @1CBA memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1CBF memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @1CC4 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 1CB5 5B JUMPDEST 1CB6 60 PUSH1 0x20 1CB8 82 DUP3 1CB9 01 ADD 1CBA 51 MLOAD 1CBB 60 PUSH1 0x40 1CBD 83 DUP4 1CBE 01 ADD 1CBF 51 MLOAD 1CC0 60 PUSH1 0x60 1CC2 84 DUP5 1CC3 01 ADD 1CC4 51 MLOAD 1CC5 60 PUSH1 0x00 1CC7 1A BYTE 1CC8 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 1CE9 82 DUP3 1CEA 11 GT 1CEB 15 ISZERO 1CEC 61 PUSH2 0x1d07 1CEF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1CBA stack[0] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1CBF stack[1] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @1CC7 stack[2] = byte(memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20], 0x00) // } // Block ends with conditional jump to 0x1d07, if !(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_1CF0: // Incoming jump from 0x1CEF, if not !(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @1CF2 memory[0x40:0x60] } 1CF0 60 PUSH1 0x40 1CF2 51 MLOAD 1CF3 62 PUSH3 0x461bcd 1CF7 60 PUSH1 0xe5 1CF9 1B SHL 1CFA 81 DUP2 1CFB 52 MSTORE 1CFC 60 PUSH1 0x04 1CFE 01 ADD 1CFF 61 PUSH2 0x05f6 1D02 90 SWAP1 1D03 61 PUSH2 0x33d6 1D06 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1CFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D02 stack[0] = 0x05f6 // @1D02 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x33d6, returns to 0x05F6 label_1D07: // Incoming jump from 0x1CEF, if !(memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @1D08 stack[-1] } 1D07 5B JUMPDEST 1D08 80 DUP1 1D09 60 PUSH1 0xff 1D0B 16 AND 1D0C 60 PUSH1 0x1b 1D0E 14 EQ 1D0F 15 ISZERO 1D10 80 DUP1 1D11 15 ISZERO 1D12 61 PUSH2 0x1d1f 1D15 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D0F stack[0] = !(0x1b == 0xff & stack[-1]) } // Block ends with conditional jump to 0x1d1f, if !!(0x1b == 0xff & stack[-1]) label_1D16: // Incoming jump from 0x1D15, if not !!(0x1b == 0xff & stack[-1]) // Inputs[1] { @1D17 stack[-2] } 1D16 50 POP 1D17 80 DUP1 1D18 60 PUSH1 0xff 1D1A 16 AND 1D1B 60 PUSH1 0x1c 1D1D 14 EQ 1D1E 15 ISZERO 1D1F 5B JUMPDEST 1D20 15 ISZERO 1D21 61 PUSH2 0x1d3c 1D24 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d3c, if !!(0x1c == 0xff & stack[-2]) label_1D25: // Incoming jump from 0x1D24, if not !!(0x1c == 0xff & stack[-2]) // Incoming jump from 0x1D24, if not !stack[-1] // Inputs[1] { @1D27 memory[0x40:0x60] } 1D25 60 PUSH1 0x40 1D27 51 MLOAD 1D28 62 PUSH3 0x461bcd 1D2C 60 PUSH1 0xe5 1D2E 1B SHL 1D2F 81 DUP2 1D30 52 MSTORE 1D31 60 PUSH1 0x04 1D33 01 ADD 1D34 61 PUSH2 0x05f6 1D37 90 SWAP1 1D38 61 PUSH2 0x3532 1D3B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D30 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D37 stack[0] = 0x05f6 // @1D37 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3532, returns to 0x05F6 label_1D3C: // Incoming jump from 0x1D24, if !!(0x1c == 0xff & stack[-2]) // Incoming jump from 0x1D24, if !stack[-1] // Inputs[6] // { // @1D41 stack[-6] // @1D42 stack[-1] // @1D43 stack[-3] // @1D44 stack[-2] // @1D47 memory[0x40:0x60] // @1D54 memory[0x40:0x60] // } 1D3C 5B JUMPDEST 1D3D 60 PUSH1 0x00 1D3F 60 PUSH1 0x01 1D41 87 DUP8 1D42 83 DUP4 1D43 86 DUP7 1D44 86 DUP7 1D45 60 PUSH1 0x40 1D47 51 MLOAD 1D48 60 PUSH1 0x00 1D4A 81 DUP2 1D4B 52 MSTORE 1D4C 60 PUSH1 0x20 1D4E 01 ADD 1D4F 60 PUSH1 0x40 1D51 52 MSTORE 1D52 60 PUSH1 0x40 1D54 51 MLOAD 1D55 61 PUSH2 0x1d61 1D58 94 SWAP5 1D59 93 SWAP4 1D5A 92 SWAP3 1D5B 91 SWAP2 1D5C 90 SWAP1 1D5D 61 PUSH2 0x3137 1D60 56 *JUMP // Stack delta = +8 // Outputs[10] // { // @1D3D stack[0] = 0x00 // @1D3F stack[1] = 0x01 // @1D4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1D51 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1D58 stack[2] = 0x1d61 // @1D59 stack[3] = stack[-6] // @1D5A stack[4] = stack[-1] // @1D5B stack[5] = stack[-3] // @1D5C stack[6] = stack[-2] // @1D5C stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x3137, returns to 0x1D61 label_1D61: // Incoming return from call to 0x3137 at 0x1D60 // Inputs[6] // { // @1D66 memory[0x40:0x60] // @1D6D stack[-1] // @1D70 stack[-2] // @1D71 msg.gas // @1D72 address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1D72 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1D61 5B JUMPDEST 1D62 60 PUSH1 0x20 1D64 60 PUSH1 0x40 1D66 51 MLOAD 1D67 60 PUSH1 0x20 1D69 81 DUP2 1D6A 03 SUB 1D6B 90 SWAP1 1D6C 80 DUP1 1D6D 84 DUP5 1D6E 03 SUB 1D6F 90 SWAP1 1D70 85 DUP6 1D71 5A GAS 1D72 FA STATICCALL 1D73 15 ISZERO 1D74 80 DUP1 1D75 15 ISZERO 1D76 61 PUSH2 0x1d83 1D79 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1D72 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]]) // @1D73 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 0x1d83, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1D7A: // Incoming jump from 0x1D79, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[4] // { // @1D7A returndata.length // @1D7E returndata[0x00:0x00 + returndata.length] // @1D7F returndata.length // @1D82 memory[0x00:0x00 + returndata.length] // } 1D7A 3D RETURNDATASIZE 1D7B 60 PUSH1 0x00 1D7D 80 DUP1 1D7E 3E RETURNDATACOPY 1D7F 3D RETURNDATASIZE 1D80 60 PUSH1 0x00 1D82 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D7E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1D82 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D83: // Incoming jump from 0x1D79, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[3] // { // @1D88 memory[0x40:0x60] // @1D8D memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @1D8E stack[-4] // } 1D83 5B JUMPDEST 1D84 50 POP 1D85 50 POP 1D86 60 PUSH1 0x40 1D88 51 MLOAD 1D89 60 PUSH1 0x1f 1D8B 19 NOT 1D8C 01 ADD 1D8D 51 MLOAD 1D8E 91 SWAP2 1D8F 50 POP 1D90 50 POP 1D91 60 PUSH1 0x01 1D93 60 PUSH1 0x01 1D95 60 PUSH1 0xa0 1D97 1B SHL 1D98 03 SUB 1D99 81 DUP2 1D9A 16 AND 1D9B 61 PUSH2 0x1db6 1D9E 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1D8E stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x1db6, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_1D9F: // Incoming jump from 0x1D9E, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DA1 memory[0x40:0x60] } 1D9F 60 PUSH1 0x40 1DA1 51 MLOAD 1DA2 62 PUSH3 0x461bcd 1DA6 60 PUSH1 0xe5 1DA8 1B SHL 1DA9 81 DUP2 1DAA 52 MSTORE 1DAB 60 PUSH1 0x04 1DAD 01 ADD 1DAE 61 PUSH2 0x05f6 1DB1 90 SWAP1 1DB2 61 PUSH2 0x317d 1DB5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DB1 stack[0] = 0x05f6 // @1DB1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x317d, returns to 0x05F6 label_1DB6: // Incoming jump from 0x1D9E, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1DB7 stack[-8] // @1DB7 stack[-1] // @1DB8 stack[-7] // } 1DB6 5B JUMPDEST 1DB7 96 SWAP7 1DB8 95 SWAP6 1DB9 50 POP 1DBA 50 POP 1DBB 50 POP 1DBC 50 POP 1DBD 50 POP 1DBE 50 POP 1DBF 56 *JUMP // Stack delta = -7 // Outputs[1] { @1DB7 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1DC0: // Incoming jump from 0x06F9 // Inputs[1] { @1DC9 stack[-2] } 1DC0 5B JUMPDEST 1DC1 60 PUSH1 0x01 1DC3 60 PUSH1 0x01 1DC5 60 PUSH1 0xa0 1DC7 1B SHL 1DC8 03 SUB 1DC9 82 DUP3 1DCA 16 AND 1DCB 61 PUSH2 0x1de6 1DCE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1de6, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1DCF: // Incoming jump from 0x1DCE, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DD1 memory[0x40:0x60] } 1DCF 60 PUSH1 0x40 1DD1 51 MLOAD 1DD2 62 PUSH3 0x461bcd 1DD6 60 PUSH1 0xe5 1DD8 1B SHL 1DD9 81 DUP2 1DDA 52 MSTORE 1DDB 60 PUSH1 0x04 1DDD 01 ADD 1DDE 61 PUSH2 0x05f6 1DE1 90 SWAP1 1DE2 61 PUSH2 0x35b6 1DE5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DDA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DE1 stack[0] = 0x05f6 // @1DE1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x35b6, returns to 0x05F6 label_1DE6: // Incoming jump from 0x1DCE, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1DEA stack[-1] } 1DE6 5B JUMPDEST 1DE7 61 PUSH2 0x1def 1DEA 81 DUP2 1DEB 61 PUSH2 0x1e84 1DEE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DE7 stack[0] = 0x1def // @1DEA stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1e84 1DEF 5B JUMPDEST 1DF0 15 ISZERO 1DF1 61 PUSH2 0x1e0c 1DF4 57 *JUMPI 1DF5 60 PUSH1 0x40 1DF7 51 MLOAD 1DF8 62 PUSH3 0x461bcd 1DFC 60 PUSH1 0xe5 1DFE 1B SHL 1DFF 81 DUP2 1E00 52 MSTORE 1E01 60 PUSH1 0x04 1E03 01 ADD 1E04 61 PUSH2 0x05f6 1E07 90 SWAP1 1E08 61 PUSH2 0x32fc 1E0B 56 *JUMP 1E0C 5B JUMPDEST 1E0D 61 PUSH2 0x1e18 1E10 60 PUSH1 0x00 1E12 83 DUP4 1E13 83 DUP4 1E14 61 PUSH2 0x0994 1E17 56 *JUMP 1E18 5B JUMPDEST 1E19 60 PUSH1 0x01 1E1B 60 PUSH1 0x01 1E1D 60 PUSH1 0xa0 1E1F 1B SHL 1E20 03 SUB 1E21 82 DUP3 1E22 16 AND 1E23 60 PUSH1 0x00 1E25 90 SWAP1 1E26 81 DUP2 1E27 52 MSTORE 1E28 60 PUSH1 0x01 1E2A 60 PUSH1 0x20 1E2C 52 MSTORE 1E2D 60 PUSH1 0x40 1E2F 90 SWAP1 1E30 20 SHA3 1E31 61 PUSH2 0x1e3a 1E34 90 SWAP1 1E35 82 DUP3 1E36 61 PUSH2 0x1b04 1E39 56 *JUMP 1E3A 5B JUMPDEST 1E3B 50 POP 1E3C 61 PUSH2 0x1e47 1E3F 60 PUSH1 0x02 1E41 82 DUP3 1E42 84 DUP5 1E43 61 PUSH2 0x1b10 1E46 56 *JUMP 1E47 5B JUMPDEST 1E48 50 POP 1E49 60 PUSH1 0x40 1E4B 51 MLOAD 1E4C 81 DUP2 1E4D 90 SWAP1 1E4E 60 PUSH1 0x01 1E50 60 PUSH1 0x01 1E52 60 PUSH1 0xa0 1E54 1B SHL 1E55 03 SUB 1E56 84 DUP5 1E57 16 AND 1E58 90 SWAP1 1E59 60 PUSH1 0x00 1E5B 90 SWAP1 1E5C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1E7D 90 SWAP1 1E7E 82 DUP3 1E7F 90 SWAP1 1E80 A4 LOG4 1E81 50 POP 1E82 50 POP 1E83 56 *JUMP label_1E84: // Incoming jump from 0x24D2 // Incoming jump from 0x08C8 // Incoming jump from 0x1539 // Incoming jump from 0x1DEE // Inputs[1] { @1E8C stack[-1] } 1E84 5B JUMPDEST 1E85 60 PUSH1 0x00 1E87 61 PUSH2 0x0b05 1E8A 60 PUSH1 0x02 1E8C 83 DUP4 1E8D 61 PUSH2 0x1b30 1E90 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E85 stack[0] = 0x00 // @1E87 stack[1] = 0x0b05 // @1E8A stack[2] = 0x02 // @1E8C stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1b30 label_1E91: // Incoming call from 0x1485, returns to 0x1486 // Incoming call from 0x1367, returns to 0x1368 // Incoming call from 0x1F18, returns to 0x1F19 // Incoming call from 0x2029, returns to 0x202A // Incoming call from 0x1680, returns to 0x1681 // Incoming call from 0x0ECD, returns to 0x0ECE // Incoming call from 0x12E5, returns to 0x12E6 // Incoming call from 0x1323, returns to 0x1324 // Inputs[2] // { // @1E92 msg.sender // @1E93 stack[-1] // } 1E91 5B JUMPDEST 1E92 33 CALLER 1E93 90 SWAP1 1E94 56 *JUMP // Stack delta = +0 // Outputs[1] { @1E93 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] 1E95 5B JUMPDEST 1E96 60 PUSH1 0x00 1E98 81 DUP2 1E99 81 DUP2 1E9A 52 MSTORE 1E9B 60 PUSH1 0x04 1E9D 60 PUSH1 0x20 1E9F 52 MSTORE 1EA0 60 PUSH1 0x40 1EA2 90 SWAP1 1EA3 20 SHA3 1EA4 80 DUP1 1EA5 54 SLOAD 1EA6 60 PUSH1 0x01 1EA8 60 PUSH1 0x01 1EAA 60 PUSH1 0xa0 1EAC 1B SHL 1EAD 03 SUB 1EAE 19 NOT 1EAF 16 AND 1EB0 60 PUSH1 0x01 1EB2 60 PUSH1 0x01 1EB4 60 PUSH1 0xa0 1EB6 1B SHL 1EB7 03 SUB 1EB8 84 DUP5 1EB9 16 AND 1EBA 90 SWAP1 1EBB 81 DUP2 1EBC 17 OR 1EBD 90 SWAP1 1EBE 91 SWAP2 1EBF 55 SSTORE 1EC0 81 DUP2 1EC1 90 SWAP1 1EC2 61 PUSH2 0x1eca 1EC5 82 DUP3 1EC6 61 PUSH2 0x0d53 1EC9 56 *JUMP 1ECA 5B JUMPDEST 1ECB 60 PUSH1 0x01 1ECD 60 PUSH1 0x01 1ECF 60 PUSH1 0xa0 1ED1 1B SHL 1ED2 03 SUB 1ED3 16 AND 1ED4 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1EF5 60 PUSH1 0x40 1EF7 51 MLOAD 1EF8 60 PUSH1 0x40 1EFA 51 MLOAD 1EFB 80 DUP1 1EFC 91 SWAP2 1EFD 03 SUB 1EFE 90 SWAP1 1EFF A4 LOG4 1F00 50 POP 1F01 50 POP 1F02 56 *JUMP label_1F03: // Incoming jump from 0x09D8 // Inputs[1] { @1F09 stack[-1] } 1F03 5B JUMPDEST 1F04 60 PUSH1 0x00 1F06 61 PUSH2 0x0b05 1F09 82 DUP3 1F0A 61 PUSH2 0x24c4 1F0D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F04 stack[0] = 0x00 // @1F06 stack[1] = 0x0b05 // @1F09 stack[2] = stack[-1] // } // Block ends with call to 0x24c4, returns to 0x0B05 label_1F0E: // Incoming jump from 0x0A88 // Incoming jump from 0x0A88 1F0E 5B JUMPDEST 1F0F 61 PUSH2 0x1f1f 1F12 61 PUSH2 0x1f19 1F15 61 PUSH2 0x1e91 1F18 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F0F stack[0] = 0x1f1f // @1F12 stack[1] = 0x1f19 // } // Block ends with call to 0x1e91, returns to 0x1F19 label_1F19: // Incoming return from call to 0x1E91 at 0x1F18 // Inputs[1] { @1F1A stack[-3] } 1F19 5B JUMPDEST 1F1A 82 DUP3 1F1B 61 PUSH2 0x24c8 1F1E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F1A stack[0] = stack[-3] } // Block ends with unconditional jump to 0x24c8 1F1F 5B JUMPDEST 1F20 61 PUSH2 0x1f3b 1F23 57 *JUMPI 1F24 60 PUSH1 0x40 1F26 51 MLOAD 1F27 62 PUSH3 0x461bcd 1F2B 60 PUSH1 0xe5 1F2D 1B SHL 1F2E 81 DUP2 1F2F 52 MSTORE 1F30 60 PUSH1 0x04 1F32 01 ADD 1F33 61 PUSH2 0x05f6 1F36 90 SWAP1 1F37 61 PUSH2 0x37b7 1F3A 56 *JUMP 1F3B 5B JUMPDEST 1F3C 61 PUSH2 0x0994 1F3F 83 DUP4 1F40 83 DUP4 1F41 83 DUP4 1F42 61 PUSH2 0x254d 1F45 56 *JUMP label_1F46: // Incoming jump from 0x0B01 // Inputs[2] // { // @1F4C stack[-2] // @1F4D stack[-1] // } 1F46 5B JUMPDEST 1F47 60 PUSH1 0x00 1F49 61 PUSH2 0x0b02 1F4C 83 DUP4 1F4D 83 DUP4 1F4E 61 PUSH2 0x265b 1F51 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F47 stack[0] = 0x00 // @1F49 stack[1] = 0x0b02 // @1F4C stack[2] = stack[-2] // @1F4D stack[3] = stack[-1] // } // Block ends with call to 0x265b, returns to 0x0B02 label_1F52: // Incoming jump from 0x0D20 // Inputs[1] { @1F58 stack[-2] } 1F52 5B JUMPDEST 1F53 60 PUSH1 0x00 1F55 61 PUSH2 0x1f5d 1F58 83 DUP4 1F59 61 PUSH2 0x0d53 1F5C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F53 stack[0] = 0x00 // @1F55 stack[1] = 0x1f5d // @1F58 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0d53 1F5D 5B JUMPDEST 1F5E 90 SWAP1 1F5F 50 POP 1F60 80 DUP1 1F61 60 PUSH1 0x01 1F63 60 PUSH1 0x01 1F65 60 PUSH1 0xa0 1F67 1B SHL 1F68 03 SUB 1F69 16 AND 1F6A 61 PUSH2 0x1f71 1F6D 61 PUSH2 0x1e91 1F70 56 *JUMP 1F71 5B JUMPDEST 1F72 60 PUSH1 0x01 1F74 60 PUSH1 0x01 1F76 60 PUSH1 0xa0 1F78 1B SHL 1F79 03 SUB 1F7A 16 AND 1F7B 14 EQ 1F7C 61 PUSH2 0x1f97 1F7F 57 *JUMPI 1F80 60 PUSH1 0x40 1F82 51 MLOAD 1F83 62 PUSH3 0x461bcd 1F87 60 PUSH1 0xe5 1F89 1B SHL 1F8A 81 DUP2 1F8B 52 MSTORE 1F8C 60 PUSH1 0x04 1F8E 01 ADD 1F8F 61 PUSH2 0x05f6 1F92 90 SWAP1 1F93 61 PUSH2 0x322d 1F96 56 *JUMP 1F97 5B JUMPDEST 1F98 60 PUSH1 0x00 1F9A 83 DUP4 1F9B 81 DUP2 1F9C 52 MSTORE 1F9D 60 PUSH1 0x0b 1F9F 60 PUSH1 0x20 1FA1 90 SWAP1 1FA2 81 DUP2 1FA3 52 MSTORE 1FA4 60 PUSH1 0x40 1FA6 90 SWAP1 1FA7 91 SWAP2 1FA8 20 SHA3 1FA9 83 DUP4 1FAA 51 MLOAD 1FAB 61 PUSH2 0x1fb6 1FAE 92 SWAP3 1FAF 85 DUP6 1FB0 01 ADD 1FB1 90 SWAP1 1FB2 61 PUSH2 0x2a50 1FB5 56 *JUMP 1FB6 5B JUMPDEST 1FB7 50 POP 1FB8 82 DUP3 1FB9 7F PUSH32 0xbe3e2fc72ea4bd0d860e908b1ee27aa9856809e62a75bfc0cb7f04b5d791873d 1FDA 83 DUP4 1FDB 60 PUSH1 0x40 1FDD 51 MLOAD 1FDE 61 PUSH2 0x1fe7 1FE1 91 SWAP2 1FE2 90 SWAP1 1FE3 61 PUSH2 0x316a 1FE6 56 *JUMP 1FE7 5B JUMPDEST 1FE8 60 PUSH1 0x40 1FEA 51 MLOAD 1FEB 80 DUP1 1FEC 91 SWAP2 1FED 03 SUB 1FEE 90 SWAP1 1FEF A2 LOG2 1FF0 50 POP 1FF1 50 POP 1FF2 50 POP 1FF3 56 *JUMP label_1FF4: // Incoming jump from 0x0D32 // Inputs[2] // { // @1FFD stack[-2] // @1FFE stack[-1] // } 1FF4 5B JUMPDEST 1FF5 60 PUSH1 0x00 1FF7 80 DUP1 1FF8 80 DUP1 1FF9 80 DUP1 1FFA 61 PUSH2 0x2003 1FFD 86 DUP7 1FFE 86 DUP7 1FFF 61 PUSH2 0x26a0 2002 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1FF5 stack[0] = 0x00 // @1FF7 stack[1] = 0x00 // @1FF8 stack[2] = 0x00 // @1FF9 stack[3] = 0x00 // @1FFA stack[4] = 0x2003 // @1FFD stack[5] = stack[-2] // @1FFE stack[6] = stack[-1] // } // Block ends with call to 0x26a0, returns to 0x2003 label_2003: // Incoming return from call to 0x26A0 at 0x2002 // Inputs[4] // { // @2004 stack[-1] // @2004 stack[-2] // @2005 stack[-6] // @2007 stack[-5] // } 2003 5B JUMPDEST 2004 90 SWAP1 2005 94 SWAP5 2006 50 POP 2007 92 SWAP3 2008 50 POP 2009 50 POP 200A 50 POP // Stack delta = -4 // Outputs[2] // { // @2005 stack[-6] = stack[-2] // @2007 stack[-5] = stack[-1] // } // Block continues label_200B: // Incoming jump from 0x2B35, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Incoming jump from 0x200A // Inputs[5] // { // @200C stack[-1] // @200C stack[-4] // @200E stack[-2] // @200E stack[-5] // @200F stack[-3] // } 200B 5B JUMPDEST 200C 92 SWAP3 200D 50 POP 200E 92 SWAP3 200F 90 SWAP1 2010 50 POP 2011 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @200C stack[-4] = stack[-1] // @200E stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_2012: // Incoming jump from 0x0D7A // Inputs[3] // { // @2018 stack[-3] // @2019 stack[-2] // @201A stack[-1] // } 2012 5B JUMPDEST 2013 60 PUSH1 0x00 2015 61 PUSH2 0x1b26 2018 84 DUP5 2019 84 DUP5 201A 84 DUP5 201B 61 PUSH2 0x26fc 201E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2013 stack[0] = 0x00 // @2015 stack[1] = 0x1b26 // @2018 stack[2] = stack[-3] // @2019 stack[3] = stack[-2] // @201A stack[4] = stack[-1] // } // Block ends with call to 0x26fc, returns to 0x1B26 label_201F: // Incoming jump from 0x1470 // Incoming jump from 0x1470 201F 5B JUMPDEST 2020 61 PUSH2 0x2030 2023 61 PUSH2 0x202a 2026 61 PUSH2 0x1e91 2029 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2020 stack[0] = 0x2030 // @2023 stack[1] = 0x202a // } // Block ends with call to 0x1e91, returns to 0x202A label_202A: // Incoming return from call to 0x1E91 at 0x2029 // Inputs[1] { @202B stack[-4] } 202A 5B JUMPDEST 202B 83 DUP4 202C 61 PUSH2 0x24c8 202F 56 *JUMP // Stack delta = +1 // Outputs[1] { @202B stack[0] = stack[-4] } // Block ends with unconditional jump to 0x24c8 2030 5B JUMPDEST 2031 61 PUSH2 0x204c 2034 57 *JUMPI 2035 60 PUSH1 0x40 2037 51 MLOAD 2038 62 PUSH3 0x461bcd 203C 60 PUSH1 0xe5 203E 1B SHL 203F 81 DUP2 2040 52 MSTORE 2041 60 PUSH1 0x04 2043 01 ADD 2044 61 PUSH2 0x05f6 2047 90 SWAP1 2048 61 PUSH2 0x37b7 204B 56 *JUMP 204C 5B JUMPDEST 204D 61 PUSH2 0x0c7d 2050 84 DUP5 2051 84 DUP5 2052 84 DUP5 2053 84 DUP5 2054 61 PUSH2 0x275b 2057 56 *JUMP label_2058: // Incoming jump from 0x14BB // Inputs[2] // { // @2059 stack[-1] // @205A memory[stack[-1]:stack[-1] + 0x20] // } 2058 5B JUMPDEST 2059 80 DUP1 205A 51 MLOAD 205B 61 PUSH2 0x0d21 205E 90 SWAP1 205F 60 PUSH1 0x09 2061 90 SWAP1 2062 60 PUSH1 0x20 2064 84 DUP5 2065 01 ADD 2066 90 SWAP1 2067 61 PUSH2 0x2a50 206A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @205E stack[0] = 0x0d21 // @2061 stack[1] = 0x09 // @2066 stack[2] = stack[-1] + 0x20 // @2066 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2a50 label_206B: // Incoming jump from 0x152E // Inputs[1] { @2071 stack[-2] } 206B 5B JUMPDEST 206C 60 PUSH1 0x00 206E 61 PUSH2 0x2076 2071 83 DUP4 2072 61 PUSH2 0x0d53 2075 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @206C stack[0] = 0x00 // @206E stack[1] = 0x2076 // @2071 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0d53 2076 5B JUMPDEST 2077 90 SWAP1 2078 50 POP 2079 80 DUP1 207A 60 PUSH1 0x01 207C 60 PUSH1 0x01 207E 60 PUSH1 0xa0 2080 1B SHL 2081 03 SUB 2082 16 AND 2083 61 PUSH2 0x208a 2086 61 PUSH2 0x1e91 2089 56 *JUMP 208A 5B JUMPDEST 208B 60 PUSH1 0x01 208D 60 PUSH1 0x01 208F 60 PUSH1 0xa0 2091 1B SHL 2092 03 SUB 2093 16 AND 2094 14 EQ 2095 61 PUSH2 0x20b0 2098 57 *JUMPI 2099 60 PUSH1 0x40 209B 51 MLOAD 209C 62 PUSH3 0x461bcd 20A0 60 PUSH1 0xe5 20A2 1B SHL 20A3 81 DUP2 20A4 52 MSTORE 20A5 60 PUSH1 0x04 20A7 01 ADD 20A8 61 PUSH2 0x05f6 20AB 90 SWAP1 20AC 61 PUSH2 0x322d 20AF 56 *JUMP 20B0 5B JUMPDEST 20B1 61 PUSH2 0x20b9 20B4 82 DUP3 20B5 61 PUSH2 0x10f3 20B8 56 *JUMP 20B9 5B JUMPDEST 20BA 15 ISZERO 20BB 15 ISZERO 20BC 60 PUSH1 0x01 20BE 14 EQ 20BF 61 PUSH2 0x20da 20C2 57 *JUMPI 20C3 60 PUSH1 0x40 20C5 51 MLOAD 20C6 62 PUSH3 0x461bcd 20CA 60 PUSH1 0xe5 20CC 1B SHL 20CD 81 DUP2 20CE 52 MSTORE 20CF 60 PUSH1 0x04 20D1 01 ADD 20D2 61 PUSH2 0x05f6 20D5 90 SWAP1 20D6 61 PUSH2 0x3876 20D9 56 *JUMP 20DA 5B JUMPDEST 20DB 60 PUSH1 0x00 20DD 83 DUP4 20DE 81 DUP2 20DF 52 MSTORE 20E0 60 PUSH1 0x0c 20E2 60 PUSH1 0x20 20E4 52 MSTORE 20E5 60 PUSH1 0x40 20E7 90 SWAP1 20E8 81 DUP2 20E9 90 SWAP1 20EA 20 SHA3 20EB 90 SWAP1 20EC 51 MLOAD 20ED 60 PUSH1 0x02 20EF 91 SWAP2 20F0 61 PUSH2 0x20f8 20F3 91 SWAP2 20F4 61 PUSH2 0x2f40 20F7 56 *JUMP 20F8 5B JUMPDEST 20F9 60 PUSH1 0x20 20FB 60 PUSH1 0x40 20FD 51 MLOAD 20FE 80 DUP1 20FF 83 DUP4 2100 03 SUB 2101 81 DUP2 2102 85 DUP6 2103 5A GAS 2104 FA STATICCALL 2105 15 ISZERO 2106 80 DUP1 2107 15 ISZERO 2108 61 PUSH2 0x2115 210B 57 *JUMPI 210C 3D RETURNDATASIZE 210D 60 PUSH1 0x00 210F 80 DUP1 2110 3E RETURNDATACOPY 2111 3D RETURNDATASIZE 2112 60 PUSH1 0x00 2114 FD *REVERT 2115 5B JUMPDEST 2116 50 POP 2117 50 POP 2118 50 POP 2119 60 PUSH1 0x40 211B 51 MLOAD 211C 3D RETURNDATASIZE 211D 60 PUSH1 0x1f 211F 19 NOT 2120 60 PUSH1 0x1f 2122 82 DUP3 2123 01 ADD 2124 16 AND 2125 82 DUP3 2126 01 ADD 2127 80 DUP1 2128 60 PUSH1 0x40 212A 52 MSTORE 212B 50 POP 212C 81 DUP2 212D 01 ADD 212E 90 SWAP1 212F 61 PUSH2 0x2138 2132 91 SWAP2 2133 90 SWAP1 2134 61 PUSH2 0x2da6 2137 56 *JUMP 2138 5B JUMPDEST 2139 60 PUSH1 0x02 213B 83 DUP4 213C 60 PUSH1 0x40 213E 51 MLOAD 213F 61 PUSH2 0x2148 2142 91 SWAP2 2143 90 SWAP1 2144 61 PUSH2 0x2f24 2147 56 *JUMP 2148 5B JUMPDEST 2149 60 PUSH1 0x20 214B 60 PUSH1 0x40 214D 51 MLOAD 214E 80 DUP1 214F 83 DUP4 2150 03 SUB 2151 81 DUP2 2152 85 DUP6 2153 5A GAS 2154 FA STATICCALL 2155 15 ISZERO 2156 80 DUP1 2157 15 ISZERO 2158 61 PUSH2 0x2165 215B 57 *JUMPI 215C 3D RETURNDATASIZE 215D 60 PUSH1 0x00 215F 80 DUP1 2160 3E RETURNDATACOPY 2161 3D RETURNDATASIZE 2162 60 PUSH1 0x00 2164 FD *REVERT 2165 5B JUMPDEST 2166 50 POP 2167 50 POP 2168 50 POP 2169 60 PUSH1 0x40 216B 51 MLOAD 216C 3D RETURNDATASIZE 216D 60 PUSH1 0x1f 216F 19 NOT 2170 60 PUSH1 0x1f 2172 82 DUP3 2173 01 ADD 2174 16 AND 2175 82 DUP3 2176 01 ADD 2177 80 DUP1 2178 60 PUSH1 0x40 217A 52 MSTORE 217B 50 POP 217C 81 DUP2 217D 01 ADD 217E 90 SWAP1 217F 61 PUSH2 0x2188 2182 91 SWAP2 2183 90 SWAP1 2184 61 PUSH2 0x2da6 2187 56 *JUMP 2188 5B JUMPDEST 2189 14 EQ 218A 15 ISZERO 218B 61 PUSH2 0x21a6 218E 57 *JUMPI 218F 60 PUSH1 0x40 2191 51 MLOAD 2192 62 PUSH3 0x461bcd 2196 60 PUSH1 0xe5 2198 1B SHL 2199 81 DUP2 219A 52 MSTORE 219B 60 PUSH1 0x04 219D 01 ADD 219E 61 PUSH2 0x05f6 21A1 90 SWAP1 21A2 61 PUSH2 0x3733 21A5 56 *JUMP 21A6 5B JUMPDEST 21A7 61 PUSH2 0x21af 21AA 82 DUP3 21AB 61 PUSH2 0x0999 21AE 56 *JUMP 21AF 5B JUMPDEST 21B0 15 ISZERO 21B1 61 PUSH2 0x21cc 21B4 57 *JUMPI 21B5 60 PUSH1 0x40 21B7 51 MLOAD 21B8 62 PUSH3 0x461bcd 21BC 60 PUSH1 0xe5 21BE 1B SHL 21BF 81 DUP2 21C0 52 MSTORE 21C1 60 PUSH1 0x04 21C3 01 ADD 21C4 61 PUSH2 0x05f6 21C7 90 SWAP1 21C8 61 PUSH2 0x35eb 21CB 56 *JUMP 21CC 5B JUMPDEST 21CD 60 PUSH1 0x00 21CF 83 DUP4 21D0 81 DUP2 21D1 52 MSTORE 21D2 60 PUSH1 0x0c 21D4 60 PUSH1 0x20 21D6 52 MSTORE 21D7 60 PUSH1 0x40 21D9 90 SWAP1 21DA 20 SHA3 21DB 54 SLOAD 21DC 60 PUSH1 0x02 21DE 60 PUSH1 0x00 21E0 19 NOT 21E1 61 PUSH2 0x0100 21E4 60 PUSH1 0x01 21E6 84 DUP5 21E7 16 AND 21E8 15 ISZERO 21E9 02 MUL 21EA 01 ADD 21EB 90 SWAP1 21EC 91 SWAP2 21ED 16 AND 21EE 04 DIV 21EF 15 ISZERO 21F0 61 PUSH2 0x2295 21F3 57 *JUMPI 21F4 60 PUSH1 0x00 21F6 83 DUP4 21F7 81 DUP2 21F8 52 MSTORE 21F9 60 PUSH1 0x0c 21FB 60 PUSH1 0x20 21FD 90 SWAP1 21FE 81 DUP2 21FF 52 MSTORE 2200 60 PUSH1 0x40 2202 91 SWAP2 2203 82 DUP3 2204 90 SWAP1 2205 20 SHA3 2206 80 DUP1 2207 54 SLOAD 2208 83 DUP4 2209 51 MLOAD 220A 60 PUSH1 0x1f 220C 60 PUSH1 0x02 220E 60 PUSH1 0x00 2210 19 NOT 2211 61 PUSH2 0x0100 2214 60 PUSH1 0x01 2216 86 DUP7 2217 16 AND 2218 15 ISZERO 2219 02 MUL 221A 01 ADD 221B 90 SWAP1 221C 93 SWAP4 221D 16 AND 221E 92 SWAP3 221F 90 SWAP1 2220 92 SWAP3 2221 04 DIV 2222 91 SWAP2 2223 82 DUP3 2224 01 ADD 2225 84 DUP5 2226 90 SWAP1 2227 04 DIV 2228 84 DUP5 2229 02 MUL 222A 81 DUP2 222B 01 ADD 222C 84 DUP5 222D 01 ADD 222E 90 SWAP1 222F 94 SWAP5 2230 52 MSTORE 2231 80 DUP1 2232 84 DUP5 2233 52 MSTORE 2234 61 PUSH2 0x2295 2237 93 SWAP4 2238 92 SWAP3 2239 83 DUP4 223A 01 ADD 223B 82 DUP3 223C 82 DUP3 223D 80 DUP1 223E 15 ISZERO 223F 61 PUSH2 0x2289 2242 57 *JUMPI 2243 80 DUP1 2244 60 PUSH1 0x1f 2246 10 LT 2247 61 PUSH2 0x225e 224A 57 *JUMPI 224B 61 PUSH2 0x0100 224E 80 DUP1 224F 83 DUP4 2250 54 SLOAD 2251 04 DIV 2252 02 MUL 2253 83 DUP4 2254 52 MSTORE 2255 91 SWAP2 2256 60 PUSH1 0x20 2258 01 ADD 2259 91 SWAP2 225A 61 PUSH2 0x2289 225D 56 *JUMP 225E 5B JUMPDEST 225F 82 DUP3 2260 01 ADD 2261 91 SWAP2 2262 90 SWAP1 2263 60 PUSH1 0x00 2265 52 MSTORE 2266 60 PUSH1 0x20 2268 60 PUSH1 0x00 226A 20 SHA3 226B 90 SWAP1 226C 5B JUMPDEST 226D 81 DUP2 226E 54 SLOAD 226F 81 DUP2 2270 52 MSTORE 2271 90 SWAP1 2272 60 PUSH1 0x01 2274 01 ADD 2275 90 SWAP1 2276 60 PUSH1 0x20 2278 01 ADD 2279 80 DUP1 227A 83 DUP4 227B 11 GT 227C 61 PUSH2 0x226c 227F 57 *JUMPI 2280 82 DUP3 2281 90 SWAP1 2282 03 SUB 2283 60 PUSH1 0x1f 2285 16 AND 2286 82 DUP3 2287 01 ADD 2288 91 SWAP2 2289 5B JUMPDEST 228A 50 POP 228B 50 POP 228C 50 POP 228D 50 POP 228E 50 POP 228F 60 PUSH1 0x00 2291 61 PUSH2 0x278e 2294 56 *JUMP 2295 5B JUMPDEST 2296 61 PUSH2 0x22a0 2299 82 DUP3 229A 60 PUSH1 0x01 229C 61 PUSH2 0x278e 229F 56 *JUMP 22A0 5B JUMPDEST 22A1 60 PUSH1 0x00 22A3 83 DUP4 22A4 81 DUP2 22A5 52 MSTORE 22A6 60 PUSH1 0x0c 22A8 60 PUSH1 0x20 22AA 90 SWAP1 22AB 81 DUP2 22AC 52 MSTORE 22AD 60 PUSH1 0x40 22AF 90 SWAP1 22B0 91 SWAP2 22B1 20 SHA3 22B2 83 DUP4 22B3 51 MLOAD 22B4 61 PUSH2 0x22bf 22B7 92 SWAP3 22B8 85 DUP6 22B9 01 ADD 22BA 90 SWAP1 22BB 61 PUSH2 0x2a50 22BE 56 *JUMP 22BF 5B JUMPDEST 22C0 50 POP 22C1 82 DUP3 22C2 7F PUSH32 0x7e632a301794d8d4a81ea7e20f37d1947158d36e66403af04ba85dd194b66f1b 22E3 83 DUP4 22E4 60 PUSH1 0x40 22E6 51 MLOAD 22E7 61 PUSH2 0x1fe7 22EA 91 SWAP2 22EB 90 SWAP1 22EC 61 PUSH2 0x316a 22EF 56 *JUMP 22F0 5B JUMPDEST 22F1 60 PUSH1 0x60 22F3 81 DUP2 22F4 61 PUSH2 0x2315 22F7 57 *JUMPI 22F8 50 POP 22F9 60 PUSH1 0x40 22FB 80 DUP1 22FC 51 MLOAD 22FD 80 DUP1 22FE 82 DUP3 22FF 01 ADD 2300 90 SWAP1 2301 91 SWAP2 2302 52 MSTORE 2303 60 PUSH1 0x01 2305 81 DUP2 2306 52 MSTORE 2307 60 PUSH1 0x03 2309 60 PUSH1 0xfc 230B 1B SHL 230C 60 PUSH1 0x20 230E 82 DUP3 230F 01 ADD 2310 52 MSTORE 2311 61 PUSH2 0x05cc 2314 56 *JUMP 2315 5B JUMPDEST 2316 81 DUP2 2317 60 PUSH1 0x00 2319 5B JUMPDEST 231A 81 DUP2 231B 15 ISZERO 231C 61 PUSH2 0x232d 231F 57 *JUMPI 2320 60 PUSH1 0x01 2322 01 ADD 2323 60 PUSH1 0x0a 2325 82 DUP3 2326 04 DIV 2327 91 SWAP2 2328 50 POP 2329 61 PUSH2 0x2319 232C 56 *JUMP 232D 5B JUMPDEST 232E 60 PUSH1 0x60 2330 81 DUP2 2331 67 PUSH8 0xffffffffffffffff 233A 81 DUP2 233B 11 GT 233C 80 DUP1 233D 15 ISZERO 233E 61 PUSH2 0x2346 2341 57 *JUMPI 2342 60 PUSH1 0x00 2344 80 DUP1 2345 FD *REVERT 2346 5B JUMPDEST 2347 50 POP 2348 60 PUSH1 0x40 234A 51 MLOAD 234B 90 SWAP1 234C 80 DUP1 234D 82 DUP3 234E 52 MSTORE 234F 80 DUP1 2350 60 PUSH1 0x1f 2352 01 ADD 2353 60 PUSH1 0x1f 2355 19 NOT 2356 16 AND 2357 60 PUSH1 0x20 2359 01 ADD 235A 82 DUP3 235B 01 ADD 235C 60 PUSH1 0x40 235E 52 MSTORE 235F 80 DUP1 2360 15 ISZERO 2361 61 PUSH2 0x2371 2364 57 *JUMPI 2365 60 PUSH1 0x20 2367 82 DUP3 2368 01 ADD 2369 81 DUP2 236A 80 DUP1 236B 36 CALLDATASIZE 236C 83 DUP4 236D 37 CALLDATACOPY 236E 01 ADD 236F 90 SWAP1 2370 50 POP 2371 5B JUMPDEST 2372 50 POP 2373 85 DUP6 2374 93 SWAP4 2375 50 POP 2376 90 SWAP1 2377 50 POP 2378 60 PUSH1 0x00 237A 19 NOT 237B 82 DUP3 237C 01 ADD 237D 5B JUMPDEST 237E 83 DUP4 237F 15 ISZERO 2380 61 PUSH2 0x23c2 2383 57 *JUMPI 2384 60 PUSH1 0x0a 2386 84 DUP5 2387 06 MOD 2388 60 PUSH1 0x30 238A 01 ADD 238B 60 PUSH1 0xf8 238D 1B SHL 238E 82 DUP3 238F 82 DUP3 2390 80 DUP1 2391 60 PUSH1 0x01 2393 90 SWAP1 2394 03 SUB 2395 93 SWAP4 2396 50 POP 2397 81 DUP2 2398 51 MLOAD 2399 81 DUP2 239A 10 LT 239B 61 PUSH2 0x23a0 239E 57 *JUMPI 239F FE *ASSERT 23A0 5B JUMPDEST 23A1 60 PUSH1 0x20 23A3 01 ADD 23A4 01 ADD 23A5 90 SWAP1 23A6 60 PUSH1 0x01 23A8 60 PUSH1 0x01 23AA 60 PUSH1 0xf8 23AC 1B SHL 23AD 03 SUB 23AE 19 NOT 23AF 16 AND 23B0 90 SWAP1 23B1 81 DUP2 23B2 60 PUSH1 0x00 23B4 1A BYTE 23B5 90 SWAP1 23B6 53 MSTORE8 23B7 50 POP 23B8 60 PUSH1 0x0a 23BA 84 DUP5 23BB 04 DIV 23BC 93 SWAP4 23BD 50 POP 23BE 61 PUSH2 0x237d 23C1 56 *JUMP 23C2 5B JUMPDEST 23C3 50 POP 23C4 94 SWAP5 23C5 93 SWAP4 23C6 50 POP 23C7 50 POP 23C8 50 POP 23C9 50 POP 23CA 56 *JUMP 23CB 5B JUMPDEST 23CC 60 PUSH1 0x00 23CE 61 PUSH2 0x23d7 23D1 83 DUP4 23D2 83 DUP4 23D3 61 PUSH2 0x24ac 23D6 56 *JUMP 23D7 5B JUMPDEST 23D8 61 PUSH2 0x240d 23DB 57 *JUMPI 23DC 50 POP 23DD 81 DUP2 23DE 54 SLOAD 23DF 60 PUSH1 0x01 23E1 81 DUP2 23E2 81 DUP2 23E3 01 ADD 23E4 84 DUP5 23E5 55 SSTORE 23E6 60 PUSH1 0x00 23E8 84 DUP5 23E9 81 DUP2 23EA 52 MSTORE 23EB 60 PUSH1 0x20 23ED 80 DUP1 23EE 82 DUP3 23EF 20 SHA3 23F0 90 SWAP1 23F1 93 SWAP4 23F2 01 ADD 23F3 84 DUP5 23F4 90 SWAP1 23F5 55 SSTORE 23F6 84 DUP5 23F7 54 SLOAD 23F8 84 DUP5 23F9 82 DUP3 23FA 52 MSTORE 23FB 82 DUP3 23FC 86 DUP7 23FD 01 ADD 23FE 90 SWAP1 23FF 93 SWAP4 2400 52 MSTORE 2401 60 PUSH1 0x40 2403 90 SWAP1 2404 20 SHA3 2405 91 SWAP2 2406 90 SWAP1 2407 91 SWAP2 2408 55 SSTORE 2409 61 PUSH2 0x0b05 240C 56 *JUMP 240D 5B JUMPDEST 240E 50 POP 240F 60 PUSH1 0x00 2411 61 PUSH2 0x0b05 2414 56 *JUMP 2415 5B JUMPDEST 2416 60 PUSH1 0x00 2418 82 DUP3 2419 81 DUP2 241A 52 MSTORE 241B 60 PUSH1 0x01 241D 84 DUP5 241E 01 ADD 241F 60 PUSH1 0x20 2421 52 MSTORE 2422 60 PUSH1 0x40 2424 81 DUP2 2425 20 SHA3 2426 54 SLOAD 2427 80 DUP1 2428 61 PUSH2 0x247a 242B 57 *JUMPI 242C 50 POP 242D 50 POP 242E 60 PUSH1 0x40 2430 80 DUP1 2431 51 MLOAD 2432 80 DUP1 2433 82 DUP3 2434 01 ADD 2435 82 DUP3 2436 52 MSTORE 2437 83 DUP4 2438 81 DUP2 2439 52 MSTORE 243A 60 PUSH1 0x20 243C 80 DUP1 243D 82 DUP3 243E 01 ADD 243F 84 DUP5 2440 81 DUP2 2441 52 MSTORE 2442 86 DUP7 2443 54 SLOAD 2444 60 PUSH1 0x01 2446 81 DUP2 2447 81 DUP2 2448 01 ADD 2449 89 DUP10 244A 55 SSTORE 244B 60 PUSH1 0x00 244D 89 DUP10 244E 81 DUP2 244F 52 MSTORE 2450 84 DUP5 2451 81 DUP2 2452 20 SHA3 2453 95 SWAP6 2454 51 MLOAD 2455 60 PUSH1 0x02 2457 90 SWAP1 2458 93 SWAP4 2459 02 MUL 245A 90 SWAP1 245B 95 SWAP6 245C 01 ADD 245D 91 SWAP2 245E 82 DUP3 245F 55 SSTORE 2460 91 SWAP2 2461 51 MLOAD 2462 90 SWAP1 2463 82 DUP3 2464 01 ADD 2465 55 SSTORE 2466 86 DUP7 2467 54 SLOAD 2468 86 DUP7 2469 84 DUP5 246A 52 MSTORE 246B 81 DUP2 246C 88 DUP9 246D 01 ADD 246E 90 SWAP1 246F 92 SWAP3 2470 52 MSTORE 2471 92 SWAP3 2472 90 SWAP1 2473 91 SWAP2 2474 20 SHA3 2475 55 SSTORE 2476 61 PUSH2 0x1b29 2479 56 *JUMP 247A 5B JUMPDEST 247B 82 DUP3 247C 85 DUP6 247D 60 PUSH1 0x00 247F 01 ADD 2480 60 PUSH1 0x01 2482 83 DUP4 2483 03 SUB 2484 81 DUP2 2485 54 SLOAD 2486 81 DUP2 2487 10 LT 2488 61 PUSH2 0x248d 248B 57 *JUMPI 248C FE *ASSERT 248D 5B JUMPDEST 248E 90 SWAP1 248F 60 PUSH1 0x00 2491 52 MSTORE 2492 60 PUSH1 0x20 2494 60 PUSH1 0x00 2496 20 SHA3 2497 90 SWAP1 2498 60 PUSH1 0x02 249A 02 MUL 249B 01 ADD 249C 60 PUSH1 0x01 249E 01 ADD 249F 81 DUP2 24A0 90 SWAP1 24A1 55 SSTORE 24A2 50 POP 24A3 60 PUSH1 0x00 24A5 91 SWAP2 24A6 50 POP 24A7 50 POP 24A8 61 PUSH2 0x1b29 24AB 56 *JUMP label_24AC: // Incoming call from 0x1B3B, returns to 0x0B02 // Inputs[5] // { // @24AF stack[-1] // @24B4 stack[-2] // @24BE memory[0x00:0x40] // @24BF storage[keccak256(memory[0x00:0x40])] // @24C2 stack[-3] // } 24AC 5B JUMPDEST 24AD 60 PUSH1 0x00 24AF 90 SWAP1 24B0 81 DUP2 24B1 52 MSTORE 24B2 60 PUSH1 0x01 24B4 91 SWAP2 24B5 90 SWAP1 24B6 91 SWAP2 24B7 01 ADD 24B8 60 PUSH1 0x20 24BA 52 MSTORE 24BB 60 PUSH1 0x40 24BD 90 SWAP1 24BE 20 SHA3 24BF 54 SLOAD 24C0 15 ISZERO 24C1 15 ISZERO 24C2 90 SWAP1 24C3 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @24B1 memory[0x00:0x20] = stack[-1] // @24BA memory[0x20:0x40] = 0x01 + stack[-2] // @24C2 stack[-3] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_24C4: // Incoming call from 0x1F0D, returns to 0x0B05 // Inputs[3] // { // @24C5 stack[-1] // @24C5 storage[stack[-1]] // @24C6 stack[-2] // } 24C4 5B JUMPDEST 24C5 54 SLOAD 24C6 90 SWAP1 24C7 56 *JUMP // Stack delta = -1 // Outputs[1] { @24C6 stack[-2] = storage[stack[-1]] } // Block ends with unconditional jump to stack[-2] label_24C8: // Incoming jump from 0x1F1E // Incoming jump from 0x202F // Inputs[1] { @24CE stack[-1] } 24C8 5B JUMPDEST 24C9 60 PUSH1 0x00 24CB 61 PUSH2 0x24d3 24CE 82 DUP3 24CF 61 PUSH2 0x1e84 24D2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24C9 stack[0] = 0x00 // @24CB stack[1] = 0x24d3 // @24CE stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1e84 24D3 5B JUMPDEST 24D4 61 PUSH2 0x24ef 24D7 57 *JUMPI 24D8 60 PUSH1 0x40 24DA 51 MLOAD 24DB 62 PUSH3 0x461bcd 24DF 60 PUSH1 0xe5 24E1 1B SHL 24E2 81 DUP2 24E3 52 MSTORE 24E4 60 PUSH1 0x04 24E6 01 ADD 24E7 61 PUSH2 0x05f6 24EA 90 SWAP1 24EB 61 PUSH2 0x3418 24EE 56 *JUMP 24EF 5B JUMPDEST 24F0 60 PUSH1 0x00 24F2 61 PUSH2 0x24fa 24F5 83 DUP4 24F6 61 PUSH2 0x0d53 24F9 56 *JUMP 24FA 5B JUMPDEST 24FB 90 SWAP1 24FC 50 POP 24FD 80 DUP1 24FE 60 PUSH1 0x01 2500 60 PUSH1 0x01 2502 60 PUSH1 0xa0 2504 1B SHL 2505 03 SUB 2506 16 AND 2507 84 DUP5 2508 60 PUSH1 0x01 250A 60 PUSH1 0x01 250C 60 PUSH1 0xa0 250E 1B SHL 250F 03 SUB 2510 16 AND 2511 14 EQ 2512 80 DUP1 2513 61 PUSH2 0x2535 2516 57 *JUMPI 2517 50 POP 2518 83 DUP4 2519 60 PUSH1 0x01 251B 60 PUSH1 0x01 251D 60 PUSH1 0xa0 251F 1B SHL 2520 03 SUB 2521 16 AND 2522 61 PUSH2 0x252a 2525 84 DUP5 2526 61 PUSH2 0x08be 2529 56 *JUMP 252A 5B JUMPDEST 252B 60 PUSH1 0x01 252D 60 PUSH1 0x01 252F 60 PUSH1 0xa0 2531 1B SHL 2532 03 SUB 2533 16 AND 2534 14 EQ 2535 5B JUMPDEST 2536 80 DUP1 2537 61 PUSH2 0x2545 253A 57 *JUMPI 253B 50 POP 253C 61 PUSH2 0x2545 253F 81 DUP2 2540 85 DUP6 2541 61 PUSH2 0x1872 2544 56 *JUMP label_2545: // Incoming return from call to 0x2B3A at 0x2E28 // Inputs[3] // { // @2546 stack[-6] // @2546 stack[-1] // @2547 stack[-5] // } 2545 5B JUMPDEST 2546 94 SWAP5 2547 93 SWAP4 2548 50 POP 2549 50 POP 254A 50 POP 254B 50 POP 254C 56 *JUMP // Stack delta = -5 // Outputs[1] { @2546 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 254D 5B JUMPDEST 254E 82 DUP3 254F 60 PUSH1 0x01 2551 60 PUSH1 0x01 2553 60 PUSH1 0xa0 2555 1B SHL 2556 03 SUB 2557 16 AND 2558 61 PUSH2 0x2560 255B 82 DUP3 255C 61 PUSH2 0x0d53 255F 56 *JUMP 2560 5B JUMPDEST 2561 60 PUSH1 0x01 2563 60 PUSH1 0x01 2565 60 PUSH1 0xa0 2567 1B SHL 2568 03 SUB 2569 16 AND 256A 14 EQ 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 0x05f6 2581 90 SWAP1 2582 61 PUSH2 0x369b 2585 56 *JUMP 2586 5B JUMPDEST 2587 60 PUSH1 0x01 2589 60 PUSH1 0x01 258B 60 PUSH1 0xa0 258D 1B SHL 258E 03 SUB 258F 82 DUP3 2590 16 AND 2591 61 PUSH2 0x25ac 2594 57 *JUMPI 2595 60 PUSH1 0x40 2597 51 MLOAD 2598 62 PUSH3 0x461bcd 259C 60 PUSH1 0xe5 259E 1B SHL 259F 81 DUP2 25A0 52 MSTORE 25A1 60 PUSH1 0x04 25A3 01 ADD 25A4 61 PUSH2 0x05f6 25A7 90 SWAP1 25A8 61 PUSH2 0x3333 25AB 56 *JUMP 25AC 5B JUMPDEST 25AD 61 PUSH2 0x25b7 25B0 83 DUP4 25B1 83 DUP4 25B2 83 DUP4 25B3 61 PUSH2 0x0994 25B6 56 *JUMP 25B7 5B JUMPDEST 25B8 61 PUSH2 0x25c2 25BB 60 PUSH1 0x00 25BD 82 DUP3 25BE 61 PUSH2 0x1e95 25C1 56 *JUMP 25C2 5B JUMPDEST 25C3 60 PUSH1 0x01 25C5 60 PUSH1 0x01 25C7 60 PUSH1 0xa0 25C9 1B SHL 25CA 03 SUB 25CB 83 DUP4 25CC 16 AND 25CD 60 PUSH1 0x00 25CF 90 SWAP1 25D0 81 DUP2 25D1 52 MSTORE 25D2 60 PUSH1 0x01 25D4 60 PUSH1 0x20 25D6 52 MSTORE 25D7 60 PUSH1 0x40 25D9 90 SWAP1 25DA 20 SHA3 25DB 61 PUSH2 0x25e4 25DE 90 SWAP1 25DF 82 DUP3 25E0 61 PUSH2 0x27cb 25E3 56 *JUMP 25E4 5B JUMPDEST 25E5 50 POP 25E6 60 PUSH1 0x01 25E8 60 PUSH1 0x01 25EA 60 PUSH1 0xa0 25EC 1B SHL 25ED 03 SUB 25EE 82 DUP3 25EF 16 AND 25F0 60 PUSH1 0x00 25F2 90 SWAP1 25F3 81 DUP2 25F4 52 MSTORE 25F5 60 PUSH1 0x01 25F7 60 PUSH1 0x20 25F9 52 MSTORE 25FA 60 PUSH1 0x40 25FC 90 SWAP1 25FD 20 SHA3 25FE 61 PUSH2 0x2607 2601 90 SWAP1 2602 82 DUP3 2603 61 PUSH2 0x1b04 2606 56 *JUMP 2607 5B JUMPDEST 2608 50 POP 2609 61 PUSH2 0x2614 260C 60 PUSH1 0x02 260E 82 DUP3 260F 84 DUP5 2610 61 PUSH2 0x1b10 2613 56 *JUMP 2614 5B JUMPDEST 2615 50 POP 2616 80 DUP1 2617 82 DUP3 2618 60 PUSH1 0x01 261A 60 PUSH1 0x01 261C 60 PUSH1 0xa0 261E 1B SHL 261F 03 SUB 2620 16 AND 2621 84 DUP5 2622 60 PUSH1 0x01 2624 60 PUSH1 0x01 2626 60 PUSH1 0xa0 2628 1B SHL 2629 03 SUB 262A 16 AND 262B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 264C 60 PUSH1 0x40 264E 51 MLOAD 264F 60 PUSH1 0x40 2651 51 MLOAD 2652 80 DUP1 2653 91 SWAP2 2654 03 SUB 2655 90 SWAP1 2656 A4 LOG4 2657 50 POP 2658 50 POP 2659 50 POP 265A 56 *JUMP label_265B: // Incoming call from 0x1F51, returns to 0x0B02 // Inputs[3] // { // @265C stack[-2] // @265D storage[stack[-2]] // @2661 stack[-1] // } 265B 5B JUMPDEST 265C 81 DUP2 265D 54 SLOAD 265E 60 PUSH1 0x00 2660 90 SWAP1 2661 82 DUP3 2662 10 LT 2663 61 PUSH2 0x267e 2666 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2660 stack[0] = 0x00 } // Block ends with conditional jump to 0x267e, if stack[-1] < storage[stack[-2]] label_2667: // Incoming jump from 0x2666, if not stack[-1] < storage[stack[-2]] // Inputs[1] { @2669 memory[0x40:0x60] } 2667 60 PUSH1 0x40 2669 51 MLOAD 266A 62 PUSH3 0x461bcd 266E 60 PUSH1 0xe5 2670 1B SHL 2671 81 DUP2 2672 52 MSTORE 2673 60 PUSH1 0x04 2675 01 ADD 2676 61 PUSH2 0x05f6 2679 90 SWAP1 267A 61 PUSH2 0x31b4 267D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2672 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2679 stack[0] = 0x05f6 // @2679 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x31b4, returns to 0x05F6 label_267E: // Incoming jump from 0x2666, if stack[-1] < storage[stack[-2]] // Inputs[3] // { // @267F stack[-3] // @2683 stack[-2] // @2685 storage[0x00 + stack[-3]] // } 267E 5B JUMPDEST 267F 82 DUP3 2680 60 PUSH1 0x00 2682 01 ADD 2683 82 DUP3 2684 81 DUP2 2685 54 SLOAD 2686 81 DUP2 2687 10 LT 2688 61 PUSH2 0x268d 268B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2682 stack[0] = 0x00 + stack[-3] // @2683 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x268d, if stack[-2] < storage[0x00 + stack[-3]] label_268C: // Incoming jump from 0x268B, if not stack[-2] < storage[0x00 + stack[-3]] 268C FE *ASSERT // Stack delta = +0 // Outputs[1] { @268C assert(); } // Block terminates label_268D: // Incoming jump from 0x268B, if stack[-2] < storage[0x00 + stack[-3]] // Inputs[7] // { // @268E stack[-1] // @268E stack[-2] // @2696 memory[0x00:0x20] // @2698 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2699 stack[-3] // @269B stack[-6] // @269C stack[-5] // } 268D 5B JUMPDEST 268E 90 SWAP1 268F 60 PUSH1 0x00 2691 52 MSTORE 2692 60 PUSH1 0x20 2694 60 PUSH1 0x00 2696 20 SHA3 2697 01 ADD 2698 54 SLOAD 2699 90 SWAP1 269A 50 POP 269B 92 SWAP3 269C 91 SWAP2 269D 50 POP 269E 50 POP 269F 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2691 memory[0x00:0x20] = stack[-2] // @269B stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_26A0: // Incoming call from 0x2002, returns to 0x2003 // Inputs[3] // { // @26A1 stack[-2] // @26A2 storage[stack[-2]] // @26A8 stack[-1] // } 26A0 5B JUMPDEST 26A1 81 DUP2 26A2 54 SLOAD 26A3 60 PUSH1 0x00 26A5 90 SWAP1 26A6 81 DUP2 26A7 90 SWAP1 26A8 83 DUP4 26A9 10 LT 26AA 61 PUSH2 0x26c5 26AD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26A5 stack[0] = 0x00 // @26A7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x26c5, if stack[-1] < storage[stack[-2]] label_26AE: // Incoming jump from 0x26AD, if not stack[-1] < storage[stack[-2]] // Inputs[1] { @26B0 memory[0x40:0x60] } 26AE 60 PUSH1 0x40 26B0 51 MLOAD 26B1 62 PUSH3 0x461bcd 26B5 60 PUSH1 0xe5 26B7 1B SHL 26B8 81 DUP2 26B9 52 MSTORE 26BA 60 PUSH1 0x04 26BC 01 ADD 26BD 61 PUSH2 0x05f6 26C0 90 SWAP1 26C1 61 PUSH2 0x3574 26C4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @26B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @26C0 stack[0] = 0x05f6 // @26C0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3574, returns to 0x05F6 label_26C5: // Incoming jump from 0x26AD, if stack[-1] < storage[stack[-2]] // Inputs[3] // { // @26C8 stack[-4] // @26CC stack[-3] // @26CE storage[0x00 + stack[-4]] // } 26C5 5B JUMPDEST 26C6 60 PUSH1 0x00 26C8 84 DUP5 26C9 60 PUSH1 0x00 26CB 01 ADD 26CC 84 DUP5 26CD 81 DUP2 26CE 54 SLOAD 26CF 81 DUP2 26D0 10 LT 26D1 61 PUSH2 0x26d6 26D4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @26C6 stack[0] = 0x00 // @26CB stack[1] = 0x00 + stack[-4] // @26CC stack[2] = stack[-3] // } // Block ends with conditional jump to 0x26d6, if stack[-3] < storage[0x00 + stack[-4]] label_26D5: // Incoming jump from 0x26D4, if not stack[-3] < storage[0x00 + stack[-4]] 26D5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @26D5 assert(); } // Block terminates label_26D6: // Incoming jump from 0x26D4, if stack[-3] < storage[0x00 + stack[-4]] // Inputs[11] // { // @26D7 stack[-1] // @26D7 stack[-2] // @26DF memory[0x00:0x20] // @26E5 stack[-3] // @26EB storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @26F0 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @26F1 stack[-4] // @26F3 stack[-5] // @26F6 stack[-7] // @26F8 stack[-8] // @26F9 stack[-6] // } 26D6 5B JUMPDEST 26D7 90 SWAP1 26D8 60 PUSH1 0x00 26DA 52 MSTORE 26DB 60 PUSH1 0x20 26DD 60 PUSH1 0x00 26DF 20 SHA3 26E0 90 SWAP1 26E1 60 PUSH1 0x02 26E3 02 MUL 26E4 01 ADD 26E5 90 SWAP1 26E6 50 POP 26E7 80 DUP1 26E8 60 PUSH1 0x00 26EA 01 ADD 26EB 54 SLOAD 26EC 81 DUP2 26ED 60 PUSH1 0x01 26EF 01 ADD 26F0 54 SLOAD 26F1 92 SWAP3 26F2 50 POP 26F3 92 SWAP3 26F4 50 POP 26F5 50 POP 26F6 92 SWAP3 26F7 50 POP 26F8 92 SWAP3 26F9 90 SWAP1 26FA 50 POP 26FB 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @26DA memory[0x00:0x20] = stack[-2] // @26F6 stack[-7] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @26F8 stack[-8] = storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-8] label_26FC: // Incoming call from 0x201E, returns to 0x1B26 // Inputs[5] // { // @26FF stack[-2] // @2704 stack[-3] // @270C memory[0x00:0x40] // @270D storage[keccak256(memory[0x00:0x40])] // @270E stack[-1] // } 26FC 5B JUMPDEST 26FD 60 PUSH1 0x00 26FF 82 DUP3 2700 81 DUP2 2701 52 MSTORE 2702 60 PUSH1 0x01 2704 84 DUP5 2705 01 ADD 2706 60 PUSH1 0x20 2708 52 MSTORE 2709 60 PUSH1 0x40 270B 81 DUP2 270C 20 SHA3 270D 54 SLOAD 270E 82 DUP3 270F 81 DUP2 2710 61 PUSH2 0x272c 2713 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @26FD stack[0] = 0x00 // @2701 memory[0x00:0x20] = stack[-2] // @2708 memory[0x20:0x40] = stack[-3] + 0x01 // @270D stack[1] = storage[keccak256(memory[0x00:0x40])] // @270E stack[2] = stack[-1] // } // Block ends with conditional jump to 0x272c, if storage[keccak256(memory[0x00:0x40])] label_2714: // Incoming jump from 0x2713, if not storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @2716 memory[0x40:0x60] // @2726 stack[-1] // } 2714 60 PUSH1 0x40 2716 51 MLOAD 2717 62 PUSH3 0x461bcd 271B 60 PUSH1 0xe5 271D 1B SHL 271E 81 DUP2 271F 52 MSTORE 2720 60 PUSH1 0x04 2722 01 ADD 2723 61 PUSH2 0x05f6 2726 91 SWAP2 2727 90 SWAP1 2728 61 PUSH2 0x316a 272B 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @271F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2726 stack[-1] = 0x05f6 // @2727 stack[1] = 0x04 + memory[0x40:0x60] // @2727 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x316a label_272C: // Incoming jump from 0x2713, if storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @272E stack[-6] // @2734 stack[-2] // @2737 storage[0x00 + stack[-6]] // } 272C 5B JUMPDEST 272D 50 POP 272E 84 DUP5 272F 60 PUSH1 0x00 2731 01 ADD 2732 60 PUSH1 0x01 2734 82 DUP3 2735 03 SUB 2736 81 DUP2 2737 54 SLOAD 2738 81 DUP2 2739 10 LT 273A 61 PUSH2 0x273f 273D 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2731 stack[-1] = 0x00 + stack[-6] // @2735 stack[0] = stack[-2] - 0x01 // } // Block ends with conditional jump to 0x273f, if stack[-2] - 0x01 < storage[0x00 + stack[-6]] label_273E: // Incoming jump from 0x273D, if not stack[-2] - 0x01 < storage[0x00 + stack[-6]] 273E FE *ASSERT // Stack delta = +0 // Outputs[1] { @273E assert(); } // Block terminates label_273F: // Incoming jump from 0x273D, if stack[-2] - 0x01 < storage[0x00 + stack[-6]] // Inputs[7] // { // @2740 stack[-1] // @2740 stack[-2] // @2748 memory[0x00:0x20] // @2751 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @2752 stack[-4] // @2755 stack[-8] // @2756 stack[-7] // } 273F 5B JUMPDEST 2740 90 SWAP1 2741 60 PUSH1 0x00 2743 52 MSTORE 2744 60 PUSH1 0x20 2746 60 PUSH1 0x00 2748 20 SHA3 2749 90 SWAP1 274A 60 PUSH1 0x02 274C 02 MUL 274D 01 ADD 274E 60 PUSH1 0x01 2750 01 ADD 2751 54 SLOAD 2752 91 SWAP2 2753 50 POP 2754 50 POP 2755 93 SWAP4 2756 92 SWAP3 2757 50 POP 2758 50 POP 2759 50 POP 275A 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @2743 memory[0x00:0x20] = stack[-2] // @2755 stack[-8] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-8] 275B 5B JUMPDEST 275C 61 PUSH2 0x2766 275F 84 DUP5 2760 84 DUP5 2761 84 DUP5 2762 61 PUSH2 0x254d 2765 56 *JUMP 2766 5B JUMPDEST 2767 61 PUSH2 0x2772 276A 84 DUP5 276B 84 DUP5 276C 84 DUP5 276D 84 DUP5 276E 61 PUSH2 0x27d7 2771 56 *JUMP 2772 5B JUMPDEST 2773 61 PUSH2 0x0c7d 2776 57 *JUMPI 2777 60 PUSH1 0x40 2779 51 MLOAD 277A 62 PUSH3 0x461bcd 277E 60 PUSH1 0xe5 2780 1B SHL 2781 81 DUP2 2782 52 MSTORE 2783 60 PUSH1 0x04 2785 01 ADD 2786 61 PUSH2 0x05f6 2789 90 SWAP1 278A 61 PUSH2 0x3264 278D 56 *JUMP 278E 5B JUMPDEST 278F 80 DUP1 2790 60 PUSH1 0x0d 2792 61 PUSH2 0x279a 2795 84 DUP5 2796 61 PUSH2 0x0f70 2799 56 *JUMP 279A 5B JUMPDEST 279B 60 PUSH1 0x40 279D 51 MLOAD 279E 61 PUSH2 0x27a7 27A1 91 SWAP2 27A2 90 SWAP1 27A3 61 PUSH2 0x2f24 27A6 56 *JUMP 27A7 5B JUMPDEST 27A8 90 SWAP1 27A9 81 DUP2 27AA 52 MSTORE 27AB 60 PUSH1 0x40 27AD 51 MLOAD 27AE 90 SWAP1 27AF 81 DUP2 27B0 90 SWAP1 27B1 03 SUB 27B2 60 PUSH1 0x20 27B4 01 ADD 27B5 90 SWAP1 27B6 20 SHA3 27B7 80 DUP1 27B8 54 SLOAD 27B9 91 SWAP2 27BA 15 ISZERO 27BB 15 ISZERO 27BC 60 PUSH1 0xff 27BE 19 NOT 27BF 90 SWAP1 27C0 92 SWAP3 27C1 16 AND 27C2 91 SWAP2 27C3 90 SWAP1 27C4 91 SWAP2 27C5 17 OR 27C6 90 SWAP1 27C7 55 SSTORE 27C8 50 POP 27C9 50 POP 27CA 56 *JUMP 27CB 5B JUMPDEST 27CC 60 PUSH1 0x00 27CE 61 PUSH2 0x0b02 27D1 83 DUP4 27D2 83 DUP4 27D3 61 PUSH2 0x28b6 27D6 56 *JUMP 27D7 5B JUMPDEST 27D8 60 PUSH1 0x00 27DA 61 PUSH2 0x27eb 27DD 84 DUP5 27DE 60 PUSH1 0x01 27E0 60 PUSH1 0x01 27E2 60 PUSH1 0xa0 27E4 1B SHL 27E5 03 SUB 27E6 16 AND 27E7 61 PUSH2 0x297c 27EA 56 *JUMP 27EB 5B JUMPDEST 27EC 61 PUSH2 0x27f7 27EF 57 *JUMPI 27F0 50 POP 27F1 60 PUSH1 0x01 27F3 61 PUSH2 0x2545 27F6 56 *JUMP 27F7 5B JUMPDEST 27F8 60 PUSH1 0x60 27FA 61 PUSH2 0x287f 27FD 63 PUSH4 0x0a85bd01 2802 60 PUSH1 0xe1 2804 1B SHL 2805 61 PUSH2 0x280c 2808 61 PUSH2 0x1e91 280B 56 *JUMP 280C 5B JUMPDEST 280D 88 DUP9 280E 87 DUP8 280F 87 DUP8 2810 60 PUSH1 0x40 2812 51 MLOAD 2813 60 PUSH1 0x24 2815 01 ADD 2816 61 PUSH2 0x2822 2819 94 SWAP5 281A 93 SWAP4 281B 92 SWAP3 281C 91 SWAP2 281D 90 SWAP1 281E 61 PUSH2 0x30a8 2821 56 *JUMP 2822 5B JUMPDEST 2823 60 PUSH1 0x40 2825 51 MLOAD 2826 60 PUSH1 0x20 2828 81 DUP2 2829 83 DUP4 282A 03 SUB 282B 03 SUB 282C 81 DUP2 282D 52 MSTORE 282E 90 SWAP1 282F 60 PUSH1 0x40 2831 52 MSTORE 2832 90 SWAP1 2833 60 PUSH1 0x01 2835 60 PUSH1 0x01 2837 60 PUSH1 0xe0 2839 1B SHL 283A 03 SUB 283B 19 NOT 283C 16 AND 283D 60 PUSH1 0x20 283F 82 DUP3 2840 01 ADD 2841 80 DUP1 2842 51 MLOAD 2843 60 PUSH1 0x01 2845 60 PUSH1 0x01 2847 60 PUSH1 0xe0 2849 1B SHL 284A 03 SUB 284B 83 DUP4 284C 81 DUP2 284D 83 DUP4 284E 16 AND 284F 17 OR 2850 83 DUP4 2851 52 MSTORE 2852 50 POP 2853 50 POP 2854 50 POP 2855 50 POP 2856 60 PUSH1 0x40 2858 51 MLOAD 2859 80 DUP1 285A 60 PUSH1 0x60 285C 01 ADD 285D 60 PUSH1 0x40 285F 52 MSTORE 2860 80 DUP1 2861 60 PUSH1 0x32 2863 81 DUP2 2864 52 MSTORE 2865 60 PUSH1 0x20 2867 01 ADD 2868 61 PUSH2 0x3929 286B 60 PUSH1 0x32 286D 91 SWAP2 286E 39 CODECOPY 286F 60 PUSH1 0x01 2871 60 PUSH1 0x01 2873 60 PUSH1 0xa0 2875 1B SHL 2876 03 SUB 2877 88 DUP9 2878 16 AND 2879 91 SWAP2 287A 90 SWAP1 287B 61 PUSH2 0x2982 287E 56 *JUMP 287F 5B JUMPDEST 2880 90 SWAP1 2881 50 POP 2882 60 PUSH1 0x00 2884 81 DUP2 2885 80 DUP1 2886 60 PUSH1 0x20 2888 01 ADD 2889 90 SWAP1 288A 51 MLOAD 288B 81 DUP2 288C 01 ADD 288D 90 SWAP1 288E 61 PUSH2 0x2897 2891 91 SWAP2 2892 90 SWAP1 2893 61 PUSH2 0x2dda 2896 56 *JUMP 2897 5B JUMPDEST 2898 60 PUSH1 0x01 289A 60 PUSH1 0x01 289C 60 PUSH1 0xe0 289E 1B SHL 289F 03 SUB 28A0 19 NOT 28A1 16 AND 28A2 63 PUSH4 0x0a85bd01 28A7 60 PUSH1 0xe1 28A9 1B SHL 28AA 14 EQ 28AB 92 SWAP3 28AC 50 POP 28AD 50 POP 28AE 50 POP 28AF 94 SWAP5 28B0 93 SWAP4 28B1 50 POP 28B2 50 POP 28B3 50 POP 28B4 50 POP 28B5 56 *JUMP 28B6 5B JUMPDEST 28B7 60 PUSH1 0x00 28B9 81 DUP2 28BA 81 DUP2 28BB 52 MSTORE 28BC 60 PUSH1 0x01 28BE 83 DUP4 28BF 01 ADD 28C0 60 PUSH1 0x20 28C2 52 MSTORE 28C3 60 PUSH1 0x40 28C5 81 DUP2 28C6 20 SHA3 28C7 54 SLOAD 28C8 80 DUP1 28C9 15 ISZERO 28CA 61 PUSH2 0x2972 28CD 57 *JUMPI 28CE 83 DUP4 28CF 54 SLOAD 28D0 60 PUSH1 0x00 28D2 19 NOT 28D3 80 DUP1 28D4 83 DUP4 28D5 01 ADD 28D6 91 SWAP2 28D7 90 SWAP1 28D8 81 DUP2 28D9 01 ADD 28DA 90 SWAP1 28DB 60 PUSH1 0x00 28DD 90 SWAP1 28DE 87 DUP8 28DF 90 SWAP1 28E0 83 DUP4 28E1 90 SWAP1 28E2 81 DUP2 28E3 10 LT 28E4 61 PUSH2 0x28e9 28E7 57 *JUMPI 28E8 FE *ASSERT 28E9 5B JUMPDEST 28EA 90 SWAP1 28EB 60 PUSH1 0x00 28ED 52 MSTORE 28EE 60 PUSH1 0x20 28F0 60 PUSH1 0x00 28F2 20 SHA3 28F3 01 ADD 28F4 54 SLOAD 28F5 90 SWAP1 28F6 50 POP 28F7 80 DUP1 28F8 87 DUP8 28F9 60 PUSH1 0x00 28FB 01 ADD 28FC 84 DUP5 28FD 81 DUP2 28FE 54 SLOAD 28FF 81 DUP2 2900 10 LT 2901 61 PUSH2 0x2906 2904 57 *JUMPI 2905 FE *ASSERT 2906 5B JUMPDEST 2907 60 PUSH1 0x00 2909 91 SWAP2 290A 82 DUP3 290B 52 MSTORE 290C 60 PUSH1 0x20 290E 80 DUP1 290F 83 DUP4 2910 20 SHA3 2911 90 SWAP1 2912 91 SWAP2 2913 01 ADD 2914 92 SWAP3 2915 90 SWAP1 2916 92 SWAP3 2917 55 SSTORE 2918 82 DUP3 2919 81 DUP2 291A 52 MSTORE 291B 60 PUSH1 0x01 291D 89 DUP10 291E 81 DUP2 291F 01 ADD 2920 90 SWAP1 2921 92 SWAP3 2922 52 MSTORE 2923 60 PUSH1 0x40 2925 90 SWAP1 2926 20 SHA3 2927 90 SWAP1 2928 84 DUP5 2929 01 ADD 292A 90 SWAP1 292B 55 SSTORE 292C 86 DUP7 292D 54 SLOAD 292E 87 DUP8 292F 90 SWAP1 2930 80 DUP1 2931 61 PUSH2 0x2936 2934 57 *JUMPI 2935 FE *ASSERT 2936 5B JUMPDEST 2937 60 PUSH1 0x01 2939 90 SWAP1 293A 03 SUB 293B 81 DUP2 293C 81 DUP2 293D 90 SWAP1 293E 60 PUSH1 0x00 2940 52 MSTORE 2941 60 PUSH1 0x20 2943 60 PUSH1 0x00 2945 20 SHA3 2946 01 ADD 2947 60 PUSH1 0x00 2949 90 SWAP1 294A 55 SSTORE 294B 90 SWAP1 294C 55 SSTORE 294D 86 DUP7 294E 60 PUSH1 0x01 2950 01 ADD 2951 60 PUSH1 0x00 2953 87 DUP8 2954 81 DUP2 2955 52 MSTORE 2956 60 PUSH1 0x20 2958 01 ADD 2959 90 SWAP1 295A 81 DUP2 295B 52 MSTORE 295C 60 PUSH1 0x20 295E 01 ADD 295F 60 PUSH1 0x00 2961 20 SHA3 2962 60 PUSH1 0x00 2964 90 SWAP1 2965 55 SSTORE 2966 60 PUSH1 0x01 2968 94 SWAP5 2969 50 POP 296A 50 POP 296B 50 POP 296C 50 POP 296D 50 POP 296E 61 PUSH2 0x0b05 2971 56 *JUMP 2972 5B JUMPDEST 2973 60 PUSH1 0x00 2975 91 SWAP2 2976 50 POP 2977 50 POP 2978 61 PUSH2 0x0b05 297B 56 *JUMP 297C 5B JUMPDEST 297D 3B EXTCODESIZE 297E 15 ISZERO 297F 15 ISZERO 2980 90 SWAP1 2981 56 *JUMP 2982 5B JUMPDEST 2983 60 PUSH1 0x60 2985 61 PUSH2 0x1b26 2988 84 DUP5 2989 84 DUP5 298A 60 PUSH1 0x00 298C 85 DUP6 298D 60 PUSH1 0x60 298F 61 PUSH2 0x2997 2992 85 DUP6 2993 61 PUSH2 0x297c 2996 56 *JUMP 2997 5B JUMPDEST 2998 61 PUSH2 0x29b3 299B 57 *JUMPI 299C 60 PUSH1 0x40 299E 51 MLOAD 299F 62 PUSH3 0x461bcd 29A3 60 PUSH1 0xe5 29A5 1B SHL 29A6 81 DUP2 29A7 52 MSTORE 29A8 60 PUSH1 0x04 29AA 01 ADD 29AB 61 PUSH2 0x05f6 29AE 90 SWAP1 29AF 61 PUSH2 0x3808 29B2 56 *JUMP 29B3 5B JUMPDEST 29B4 60 PUSH1 0x00 29B6 60 PUSH1 0x60 29B8 86 DUP7 29B9 60 PUSH1 0x01 29BB 60 PUSH1 0x01 29BD 60 PUSH1 0xa0 29BF 1B SHL 29C0 03 SUB 29C1 16 AND 29C2 85 DUP6 29C3 87 DUP8 29C4 60 PUSH1 0x40 29C6 51 MLOAD 29C7 61 PUSH2 0x29d0 29CA 91 SWAP2 29CB 90 SWAP1 29CC 61 PUSH2 0x2f24 29CF 56 *JUMP 29D0 5B JUMPDEST 29D1 60 PUSH1 0x00 29D3 60 PUSH1 0x40 29D5 51 MLOAD 29D6 80 DUP1 29D7 83 DUP4 29D8 03 SUB 29D9 81 DUP2 29DA 85 DUP6 29DB 87 DUP8 29DC 5A GAS 29DD F1 CALL 29DE 92 SWAP3 29DF 50 POP 29E0 50 POP 29E1 50 POP 29E2 3D RETURNDATASIZE 29E3 80 DUP1 29E4 60 PUSH1 0x00 29E6 81 DUP2 29E7 14 EQ 29E8 61 PUSH2 0x2a0d 29EB 57 *JUMPI 29EC 60 PUSH1 0x40 29EE 51 MLOAD 29EF 91 SWAP2 29F0 50 POP 29F1 60 PUSH1 0x1f 29F3 19 NOT 29F4 60 PUSH1 0x3f 29F6 3D RETURNDATASIZE 29F7 01 ADD 29F8 16 AND 29F9 82 DUP3 29FA 01 ADD 29FB 60 PUSH1 0x40 29FD 52 MSTORE 29FE 3D RETURNDATASIZE 29FF 82 DUP3 2A00 52 MSTORE 2A01 3D RETURNDATASIZE 2A02 60 PUSH1 0x00 2A04 60 PUSH1 0x20 2A06 84 DUP5 2A07 01 ADD 2A08 3E RETURNDATACOPY 2A09 61 PUSH2 0x2a12 2A0C 56 *JUMP 2A0D 5B JUMPDEST 2A0E 60 PUSH1 0x60 2A10 91 SWAP2 2A11 50 POP 2A12 5B JUMPDEST 2A13 50 POP 2A14 91 SWAP2 2A15 50 POP 2A16 91 SWAP2 2A17 50 POP 2A18 81 DUP2 2A19 15 ISZERO 2A1A 61 PUSH2 0x2a26 2A1D 57 *JUMPI 2A1E 91 SWAP2 2A1F 50 POP 2A20 61 PUSH2 0x2545 2A23 90 SWAP1 2A24 50 POP 2A25 56 *JUMP 2A26 5B JUMPDEST 2A27 80 DUP1 2A28 51 MLOAD 2A29 15 ISZERO 2A2A 61 PUSH2 0x2a36 2A2D 57 *JUMPI 2A2E 80 DUP1 2A2F 51 MLOAD 2A30 80 DUP1 2A31 82 DUP3 2A32 60 PUSH1 0x20 2A34 01 ADD 2A35 FD *REVERT 2A36 5B JUMPDEST 2A37 83 DUP4 2A38 60 PUSH1 0x40 2A3A 51 MLOAD 2A3B 62 PUSH3 0x461bcd 2A3F 60 PUSH1 0xe5 2A41 1B SHL 2A42 81 DUP2 2A43 52 MSTORE 2A44 60 PUSH1 0x04 2A46 01 ADD 2A47 61 PUSH2 0x05f6 2A4A 91 SWAP2 2A4B 90 SWAP1 2A4C 61 PUSH2 0x316a 2A4F 56 *JUMP label_2A50: // Incoming jump from 0x206A // Inputs[5] // { // @2A51 stack[-3] // @2A53 storage[stack[-3]] // @2A6D memory[0x00:0x20] // @2A78 stack[-2] // @2A79 stack[-1] // } 2A50 5B JUMPDEST 2A51 82 DUP3 2A52 80 DUP1 2A53 54 SLOAD 2A54 60 PUSH1 0x01 2A56 81 DUP2 2A57 60 PUSH1 0x01 2A59 16 AND 2A5A 15 ISZERO 2A5B 61 PUSH2 0x0100 2A5E 02 MUL 2A5F 03 SUB 2A60 16 AND 2A61 60 PUSH1 0x02 2A63 90 SWAP1 2A64 04 DIV 2A65 90 SWAP1 2A66 60 PUSH1 0x00 2A68 52 MSTORE 2A69 60 PUSH1 0x20 2A6B 60 PUSH1 0x00 2A6D 20 SHA3 2A6E 90 SWAP1 2A6F 60 PUSH1 0x1f 2A71 01 ADD 2A72 60 PUSH1 0x20 2A74 90 SWAP1 2A75 04 DIV 2A76 81 DUP2 2A77 01 ADD 2A78 92 SWAP3 2A79 82 DUP3 2A7A 60 PUSH1 0x1f 2A7C 10 LT 2A7D 61 PUSH2 0x2a91 2A80 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2A68 memory[0x00:0x20] = stack[-3] // @2A6E stack[0] = keccak256(memory[0x00:0x20]) // @2A78 stack[1] = stack[-2] // @2A78 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x2a91, if 0x1f < stack[-1] label_2A81: // Incoming jump from 0x2A80, if not 0x1f < stack[-1] // Inputs[4] // { // @2A81 stack[-1] // @2A82 memory[stack[-1]:stack[-1] + 0x20] // @2A87 stack[-3] // @2A8B stack[-5] // } 2A81 80 DUP1 2A82 51 MLOAD 2A83 60 PUSH1 0xff 2A85 19 NOT 2A86 16 AND 2A87 83 DUP4 2A88 80 DUP1 2A89 01 ADD 2A8A 17 OR 2A8B 85 DUP6 2A8C 55 SSTORE 2A8D 61 PUSH2 0x2abe 2A90 56 *JUMP // Stack delta = +0 // Outputs[1] { @2A8C storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2abe label_2A91: // Incoming jump from 0x2A80, if 0x1f < stack[-1] // Inputs[2] // { // @2A92 stack[-3] // @2A98 stack[-5] // } 2A91 5B JUMPDEST 2A92 82 DUP3 2A93 80 DUP1 2A94 01 ADD 2A95 60 PUSH1 0x01 2A97 01 ADD 2A98 85 DUP6 2A99 55 SSTORE 2A9A 82 DUP3 2A9B 15 ISZERO 2A9C 61 PUSH2 0x2abe 2A9F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2A99 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2abe, if !stack[-3] label_2AA0: // Incoming jump from 0x2A9F, if not !stack[-3] // Inputs[2] // { // @2AA0 stack[-3] // @2AA0 stack[-1] // } 2AA0 91 SWAP2 2AA1 82 DUP3 2AA2 01 ADD 2AA3 5B JUMPDEST 2AA4 82 DUP3 2AA5 81 DUP2 2AA6 11 GT 2AA7 15 ISZERO 2AA8 61 PUSH2 0x2abe 2AAB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2AA0 stack[-3] = stack[-1] // @2AA2 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2abe, if !(stack[-1] + stack[-3] > stack[-1]) label_2AAC: // Incoming jump from 0x2AAB, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2AAB, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @2AAC stack[-3] // @2AAD memory[stack[-3]:stack[-3] + 0x20] // @2AAE stack[-2] // @2AB0 stack[-1] // } 2AAC 82 DUP3 2AAD 51 MLOAD 2AAE 82 DUP3 2AAF 55 SSTORE 2AB0 91 SWAP2 2AB1 60 PUSH1 0x20 2AB3 01 ADD 2AB4 91 SWAP2 2AB5 90 SWAP1 2AB6 60 PUSH1 0x01 2AB8 01 ADD 2AB9 90 SWAP1 2ABA 61 PUSH2 0x2aa3 2ABD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2AAF storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @2AB4 stack[-3] = 0x20 + stack[-3] // @2AB9 stack[-2] = 0x01 + stack[-2] // @2AB9 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2aa3 label_2ABE: // Incoming jump from 0x2A90 // Incoming jump from 0x2A9F, if !stack[-3] // Incoming jump from 0x2AAB, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2AAB, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @2AC3 stack[-4] // @2AC4 stack[-3] // } 2ABE 5B JUMPDEST 2ABF 50 POP 2AC0 61 PUSH2 0x2aca 2AC3 92 SWAP3 2AC4 91 SWAP2 2AC5 50 POP 2AC6 61 PUSH2 0x2ace 2AC9 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2AC3 stack[-4] = 0x2aca // @2AC4 stack[-3] = stack[-4] // } // Block ends with call to 0x2ace, returns to 0x2ACA label_2ACA: // Incoming jump from 0x2AD7, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2ACE at 0x2AC9 // Incoming jump from 0x2AD7, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @2ACC stack[-2] // @2ACC stack[-3] // } 2ACA 5B JUMPDEST 2ACB 50 POP 2ACC 90 SWAP1 2ACD 56 *JUMP // Stack delta = -2 // Outputs[1] { @2ACC stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2ACE: // Incoming call from 0x2AC9, returns to 0x2ACA // Inputs[2] // { // @2AD0 stack[-1] // @2AD1 stack[-2] // } 2ACE 5B JUMPDEST 2ACF 5B JUMPDEST 2AD0 80 DUP1 2AD1 82 DUP3 2AD2 11 GT 2AD3 15 ISZERO 2AD4 61 PUSH2 0x2aca 2AD7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2aca, if !(stack[-2] > stack[-1]) label_2AD8: // Incoming jump from 0x2AD7, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x2AD7, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2ADA stack[-1] } 2AD8 60 PUSH1 0x00 2ADA 81 DUP2 2ADB 55 SSTORE 2ADC 60 PUSH1 0x01 2ADE 01 ADD 2ADF 61 PUSH2 0x2acf 2AE2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2ADB storage[stack[-1]] = 0x00 // @2ADE stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2acf label_2AE3: // Incoming call from 0x2BD2, returns to 0x0B02 // Incoming call from 0x2C74, returns to 0x2C75 // Incoming call from 0x2BEE, returns to 0x2BEF // Incoming call from 0x2C65, returns to 0x2C66 // Incoming call from 0x2D7B, returns to 0x2D7C // Incoming call from 0x2D44, returns to 0x2D45 // Incoming call from 0x2BFD, returns to 0x2BFE // Inputs[2] // { // @2AE4 stack[-1] // @2AE5 msg.data[stack[-1]:stack[-1] + 0x20] // } 2AE3 5B JUMPDEST 2AE4 80 DUP1 2AE5 35 CALLDATALOAD 2AE6 60 PUSH1 0x01 2AE8 60 PUSH1 0x01 2AEA 60 PUSH1 0xa0 2AEC 1B SHL 2AED 03 SUB 2AEE 81 DUP2 2AEF 16 AND 2AF0 81 DUP2 2AF1 14 EQ 2AF2 61 PUSH2 0x0b05 2AF5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AE5 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0b05, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2AF6: // Incoming jump from 0x2AF5, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2AF9 memory[0x00:0x00] } 2AF6 60 PUSH1 0x00 2AF8 80 DUP1 2AF9 FD *REVERT // Stack delta = +0 // Outputs[1] { @2AF9 revert(memory[0x00:0x00]); } // Block terminates label_2AFA: // Incoming call from 0x2D16, returns to 0x2D17 // Incoming call from 0x2EEB, returns to 0x2EEC // Inputs[2] // { // @2AFE stack[-2] // @2B01 stack[-1] // } 2AFA 5B JUMPDEST 2AFB 60 PUSH1 0x00 2AFD 80 DUP1 2AFE 83 DUP4 2AFF 60 PUSH1 0x1f 2B01 84 DUP5 2B02 01 ADD 2B03 12 SLT 2B04 61 PUSH2 0x2b0b 2B07 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2AFB stack[0] = 0x00 // @2AFD stack[1] = 0x00 // } // Block ends with conditional jump to 0x2b0b, if stack[-1] + 0x1f i< stack[-2] label_2B08: // Incoming jump from 0x2B07, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2B08 stack[-2] // @2B0A memory[stack[-2]:stack[-2] + stack[-2]] // } 2B08 81 DUP2 2B09 82 DUP3 2B0A FD *REVERT // Stack delta = +0 // Outputs[1] { @2B0A revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2B0B: // Incoming jump from 0x2B07, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2B0D stack[-3] // @2B0E msg.data[stack[-3]:stack[-3] + 0x20] // } 2B0B 5B JUMPDEST 2B0C 50 POP 2B0D 81 DUP2 2B0E 35 CALLDATALOAD 2B0F 67 PUSH8 0xffffffffffffffff 2B18 81 DUP2 2B19 11 GT 2B1A 15 ISZERO 2B1B 61 PUSH2 0x2b22 2B1E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2B0E stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2b22, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2B1F: // Incoming jump from 0x2B1E, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2B1F stack[-2] // @2B21 memory[stack[-2]:stack[-2] + stack[-2]] // } 2B1F 81 DUP2 2B20 82 DUP3 2B21 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B21 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2B22: // Incoming jump from 0x2B1E, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @2B25 stack[-3] // @2B27 stack[-2] // @2B29 stack[-4] // @2B2C stack[-1] // } 2B22 5B JUMPDEST 2B23 60 PUSH1 0x20 2B25 83 DUP4 2B26 01 ADD 2B27 91 SWAP2 2B28 50 POP 2B29 83 DUP4 2B2A 60 PUSH1 0x20 2B2C 82 DUP3 2B2D 85 DUP6 2B2E 01 ADD 2B2F 01 ADD 2B30 11 GT 2B31 15 ISZERO 2B32 61 PUSH2 0x200b 2B35 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2B27 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x200b, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_2B36: // Incoming jump from 0x2B35, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @2B39 memory[0x00:0x00] } 2B36 60 PUSH1 0x00 2B38 80 DUP1 2B39 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B39 revert(memory[0x00:0x00]); } // Block terminates label_2B3A: // Incoming call from 0x2E7B, returns to 0x2E7C // Incoming call from 0x2CA2, returns to 0x2CA3 // Incoming call from 0x2E28, returns to 0x2545 // Inputs[2] // { // @2B3D stack[-2] // @2B40 stack[-1] // } 2B3A 5B JUMPDEST 2B3B 60 PUSH1 0x00 2B3D 82 DUP3 2B3E 60 PUSH1 0x1f 2B40 83 DUP4 2B41 01 ADD 2B42 12 SLT 2B43 61 PUSH2 0x2b4a 2B46 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B3B stack[0] = 0x00 } // Block ends with conditional jump to 0x2b4a, if stack[-1] + 0x1f i< stack[-2] label_2B47: // Incoming jump from 0x2B46, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2B47 stack[-1] // @2B49 memory[stack[-1]:stack[-1] + stack[-1]] // } 2B47 80 DUP1 2B48 81 DUP2 2B49 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B49 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2B4A: // Incoming jump from 0x2B46, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2B4B stack[-2] // @2B4C msg.data[stack[-2]:stack[-2] + 0x20] // } 2B4A 5B JUMPDEST 2B4B 81 DUP2 2B4C 35 CALLDATALOAD 2B4D 67 PUSH8 0xffffffffffffffff 2B56 80 DUP1 2B57 82 DUP3 2B58 11 GT 2B59 15 ISZERO 2B5A 61 PUSH2 0x2b61 2B5D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B4C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2B4D stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2b61, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2B5E: // Incoming jump from 0x2B5D, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2B5E stack[-3] // @2B60 memory[stack[-3]:stack[-3] + stack[-3]] // } 2B5E 82 DUP3 2B5F 83 DUP4 2B60 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B60 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2B61: // Incoming jump from 0x2B5D, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2B64 memory[0x40:0x60] // @2B67 stack[-2] // @2B72 stack[-1] // } 2B61 5B JUMPDEST 2B62 60 PUSH1 0x40 2B64 51 MLOAD 2B65 60 PUSH1 0x1f 2B67 83 DUP4 2B68 01 ADD 2B69 60 PUSH1 0x1f 2B6B 19 NOT 2B6C 16 AND 2B6D 81 DUP2 2B6E 01 ADD 2B6F 60 PUSH1 0x20 2B71 01 ADD 2B72 82 DUP3 2B73 81 DUP2 2B74 11 GT 2B75 82 DUP3 2B76 82 DUP3 2B77 10 LT 2B78 17 OR 2B79 15 ISZERO 2B7A 61 PUSH2 0x2b81 2B7D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2B64 stack[0] = memory[0x40:0x60] // @2B71 stack[1] = 0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) // } // Block ends with conditional jump to 0x2b81, if !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) > stack[-1])) label_2B7E: // Incoming jump from 0x2B7D, if not !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) > stack[-1])) // Inputs[2] // { // @2B7E stack[-5] // @2B80 memory[stack[-5]:stack[-5] + stack[-5]] // } 2B7E 84 DUP5 2B7F 85 DUP6 2B80 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B80 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_2B81: // Incoming jump from 0x2B7D, if !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-2] + 0x1f) > stack[-1])) // Inputs[6] // { // @2B84 stack[-1] // @2B85 stack[-4] // @2B86 stack[-2] // @2B88 stack[-5] // @2B8B stack[-6] // @2B91 stack[-7] // } 2B81 5B JUMPDEST 2B82 60 PUSH1 0x40 2B84 52 MSTORE 2B85 82 DUP3 2B86 81 DUP2 2B87 52 MSTORE 2B88 92 SWAP3 2B89 50 POP 2B8A 82 DUP3 2B8B 84 DUP5 2B8C 83 DUP4 2B8D 01 ADD 2B8E 60 PUSH1 0x20 2B90 01 ADD 2B91 86 DUP7 2B92 10 LT 2B93 15 ISZERO 2B94 61 PUSH2 0x2b9c 2B97 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @2B84 memory[0x40:0x60] = stack[-1] // @2B87 memory[stack[-2]:stack[-2] + 0x20] = stack[-4] // @2B88 stack[-5] = stack[-2] // @2B8A stack[-2] = stack[-2] // } // Block ends with conditional jump to 0x2b9c, if !(stack[-7] < 0x20 + stack[-4] + stack[-6]) label_2B98: // Incoming jump from 0x2B97, if not !(stack[-7] < 0x20 + stack[-4] + stack[-6]) // Inputs[1] { @2B9B memory[0x00:0x00] } 2B98 60 PUSH1 0x00 2B9A 80 DUP1 2B9B FD *REVERT // Stack delta = +0 // Outputs[1] { @2B9B revert(memory[0x00:0x00]); } // Block terminates label_2B9C: // Incoming jump from 0x2B97, if !(stack[-7] < 0x20 + stack[-4] + stack[-6]) // Inputs[7] // { // @2B9D stack[-3] // @2BA0 stack[-5] // @2BA4 stack[-1] // @2BA6 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @2BB3 stack[-7] // @2BB3 stack[-4] // @2BB4 stack[-6] // } 2B9C 5B JUMPDEST 2B9D 82 DUP3 2B9E 60 PUSH1 0x20 2BA0 86 DUP7 2BA1 01 ADD 2BA2 60 PUSH1 0x20 2BA4 83 DUP4 2BA5 01 ADD 2BA6 37 CALLDATACOPY 2BA7 60 PUSH1 0x00 2BA9 60 PUSH1 0x20 2BAB 84 DUP5 2BAC 83 DUP4 2BAD 01 ADD 2BAE 01 ADD 2BAF 52 MSTORE 2BB0 50 POP 2BB1 50 POP 2BB2 50 POP 2BB3 92 SWAP3 2BB4 91 SWAP2 2BB5 50 POP 2BB6 50 POP 2BB7 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @2BA6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + stack[-3]] // @2BAF memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @2BB3 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2BB8: // Incoming jump from 0x035D // Incoming jump from 0x05A0 // Incoming jump from 0x0396 // Incoming jump from 0x0430 // Incoming jump from 0x058D // Inputs[2] // { // @2BBD stack[-1] // @2BBE stack[-2] // } 2BB8 5B JUMPDEST 2BB9 60 PUSH1 0x00 2BBB 60 PUSH1 0x20 2BBD 82 DUP3 2BBE 84 DUP5 2BBF 03 SUB 2BC0 12 SLT 2BC1 15 ISZERO 2BC2 61 PUSH2 0x2bc9 2BC5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2BB9 stack[0] = 0x00 } // Block ends with conditional jump to 0x2bc9, if !(stack[-2] - stack[-1] i< 0x20) label_2BC6: // Incoming jump from 0x2BC5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2BC6 stack[-1] // @2BC8 memory[stack[-1]:stack[-1] + stack[-1]] // } 2BC6 80 DUP1 2BC7 81 DUP2 2BC8 FD *REVERT // Stack delta = +0 // Outputs[1] { @2BC8 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2BC9: // Incoming jump from 0x2BC5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2BCD stack[-3] // @2BCE stack[-2] // } 2BC9 5B JUMPDEST 2BCA 61 PUSH2 0x0b02 2BCD 83 DUP4 2BCE 83 DUP4 2BCF 61 PUSH2 0x2ae3 2BD2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2BCA stack[0] = 0x0b02 // @2BCD stack[1] = stack[-3] // @2BCE stack[2] = stack[-2] // } // Block ends with call to 0x2ae3, returns to 0x0B02 label_2BD3: // Incoming call from 0x053F, returns to 0x0540 // Inputs[2] // { // @2BD9 stack[-1] // @2BDA stack[-2] // } 2BD3 5B JUMPDEST 2BD4 60 PUSH1 0x00 2BD6 80 DUP1 2BD7 60 PUSH1 0x40 2BD9 83 DUP4 2BDA 85 DUP6 2BDB 03 SUB 2BDC 12 SLT 2BDD 15 ISZERO 2BDE 61 PUSH2 0x2be5 2BE1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2BD4 stack[0] = 0x00 // @2BD6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2be5, if !(stack[-2] - stack[-1] i< 0x40) label_2BE2: // Incoming jump from 0x2BE1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2BE2 stack[-1] // @2BE4 memory[stack[-1]:stack[-1] + stack[-1]] // } 2BE2 80 DUP1 2BE3 81 DUP2 2BE4 FD *REVERT // Stack delta = +0 // Outputs[1] { @2BE4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2BE5: // Incoming jump from 0x2BE1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2BE9 stack[-4] // @2BEA stack[-3] // } 2BE5 5B JUMPDEST 2BE6 61 PUSH2 0x2bef 2BE9 84 DUP5 2BEA 84 DUP5 2BEB 61 PUSH2 0x2ae3 2BEE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2BE6 stack[0] = 0x2bef // @2BE9 stack[1] = stack[-4] // @2BEA stack[2] = stack[-3] // } // Block ends with call to 0x2ae3, returns to 0x2BEF label_2BEF: // Incoming return from call to 0x2AE3 at 0x2BEE // Inputs[4] // { // @2BF0 stack[-1] // @2BF0 stack[-3] // @2BF5 stack[-5] // @2BF8 stack[-4] // } 2BEF 5B JUMPDEST 2BF0 91 SWAP2 2BF1 50 POP 2BF2 61 PUSH2 0x2bfe 2BF5 84 DUP5 2BF6 60 PUSH1 0x20 2BF8 85 DUP6 2BF9 01 ADD 2BFA 61 PUSH2 0x2ae3 2BFD 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2BF0 stack[-3] = stack[-1] // @2BF2 stack[-1] = 0x2bfe // @2BF5 stack[0] = stack[-5] // @2BF9 stack[1] = stack[-4] + 0x20 // } // Block ends with call to 0x2ae3, returns to 0x2BFE label_2BFE: // Incoming return from call to 0x2AE3 at 0x2BFD // Inputs[6] // { // @2BFF stack[-1] // @2BFF stack[-2] // @2C01 stack[-5] // @2C03 stack[-6] // @2C03 stack[-3] // @2C04 stack[-4] // } 2BFE 5B JUMPDEST 2BFF 90 SWAP1 2C00 50 POP 2C01 92 SWAP3 2C02 50 POP 2C03 92 SWAP3 2C04 90 SWAP1 2C05 50 POP 2C06 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2C01 stack[-5] = stack[-1] // @2C03 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2C07: // Incoming call from 0x03B1, returns to 0x03B2 // Incoming call from 0x034A, returns to 0x034B // Inputs[2] // { // @2C0F stack[-1] // @2C10 stack[-2] // } 2C07 5B JUMPDEST 2C08 60 PUSH1 0x00 2C0A 80 DUP1 2C0B 60 PUSH1 0x00 2C0D 60 PUSH1 0x60 2C0F 84 DUP5 2C10 86 DUP7 2C11 03 SUB 2C12 12 SLT 2C13 15 ISZERO 2C14 61 PUSH2 0x2c1b 2C17 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2C08 stack[0] = 0x00 // @2C0A stack[1] = 0x00 // @2C0B stack[2] = 0x00 // } // Block ends with conditional jump to 0x2c1b, if !(stack[-2] - stack[-1] i< 0x60) label_2C18: // Incoming jump from 0x2C17, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2C18 stack[-1] // @2C1A memory[stack[-1]:stack[-1] + stack[-1]] // } 2C18 80 DUP1 2C19 81 DUP2 2C1A FD *REVERT // Stack delta = +0 // Outputs[1] { @2C1A revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2C1B: // Incoming jump from 0x2C17, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2C1C stack[-4] // @2C1D msg.data[stack[-4]:stack[-4] + 0x20] // } 2C1B 5B JUMPDEST 2C1C 83 DUP4 2C1D 35 CALLDATALOAD 2C1E 61 PUSH2 0x2c26 2C21 81 DUP2 2C22 61 PUSH2 0x38ef 2C25 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C1D stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @2C1E stack[1] = 0x2c26 // @2C21 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x38ef, returns to 0x2C26 label_2C26: // Incoming return from call to 0x38EF at 0x2C25 // Inputs[4] // { // @2C27 stack[-1] // @2C27 stack[-4] // @2C2B stack[-5] // @2C2D msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 2C26 5B JUMPDEST 2C27 92 SWAP3 2C28 50 POP 2C29 60 PUSH1 0x20 2C2B 84 DUP5 2C2C 01 ADD 2C2D 35 CALLDATALOAD 2C2E 61 PUSH2 0x2c36 2C31 81 DUP2 2C32 61 PUSH2 0x38ef 2C35 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2C27 stack[-4] = stack[-1] // @2C2D stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2C2E stack[0] = 0x2c36 // @2C31 stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x38ef, returns to 0x2C36 label_2C36: // Incoming return from call to 0x38EF at 0x2C35 // Inputs[6] // { // @2C37 stack[-1] // @2C37 stack[-4] // @2C38 stack[-7] // @2C3A stack[-6] // @2C40 stack[-5] // @2C44 msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 2C36 5B JUMPDEST 2C37 92 SWAP3 2C38 95 SWAP6 2C39 92 SWAP3 2C3A 94 SWAP5 2C3B 50 POP 2C3C 50 POP 2C3D 50 POP 2C3E 60 PUSH1 0x40 2C40 91 SWAP2 2C41 90 SWAP1 2C42 91 SWAP2 2C43 01 ADD 2C44 35 CALLDATALOAD 2C45 90 SWAP1 2C46 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2C38 stack[-7] = stack[-4] // @2C3A stack[-6] = stack[-1] // @2C45 stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2C47: // Incoming call from 0x04C5, returns to 0x04C6 // Inputs[2] // { // @2C50 stack[-1] // @2C51 stack[-2] // } 2C47 5B JUMPDEST 2C48 60 PUSH1 0x00 2C4A 80 DUP1 2C4B 60 PUSH1 0x00 2C4D 80 DUP1 2C4E 60 PUSH1 0x80 2C50 85 DUP6 2C51 87 DUP8 2C52 03 SUB 2C53 12 SLT 2C54 15 ISZERO 2C55 61 PUSH2 0x2c5c 2C58 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2C48 stack[0] = 0x00 // @2C4A stack[1] = 0x00 // @2C4B stack[2] = 0x00 // @2C4D stack[3] = 0x00 // } // Block ends with conditional jump to 0x2c5c, if !(stack[-2] - stack[-1] i< 0x80) label_2C59: // Incoming jump from 0x2C58, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2C59 stack[-1] // @2C5B memory[stack[-1]:stack[-1] + stack[-1]] // } 2C59 80 DUP1 2C5A 81 DUP2 2C5B FD *REVERT // Stack delta = +0 // Outputs[1] { @2C5B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2C5C: // Incoming jump from 0x2C58, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2C60 stack[-6] // @2C61 stack[-5] // } 2C5C 5B JUMPDEST 2C5D 61 PUSH2 0x2c66 2C60 86 DUP7 2C61 86 DUP7 2C62 61 PUSH2 0x2ae3 2C65 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C5D stack[0] = 0x2c66 // @2C60 stack[1] = stack[-6] // @2C61 stack[2] = stack[-5] // } // Block ends with call to 0x2ae3, returns to 0x2C66 label_2C66: // Incoming return from call to 0x2AE3 at 0x2C65 // Inputs[4] // { // @2C67 stack[-5] // @2C67 stack[-1] // @2C6C stack[-7] // @2C6F stack[-6] // } 2C66 5B JUMPDEST 2C67 93 SWAP4 2C68 50 POP 2C69 61 PUSH2 0x2c75 2C6C 86 DUP7 2C6D 60 PUSH1 0x20 2C6F 87 DUP8 2C70 01 ADD 2C71 61 PUSH2 0x2ae3 2C74 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2C67 stack[-5] = stack[-1] // @2C69 stack[-1] = 0x2c75 // @2C6C stack[0] = stack[-7] // @2C70 stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x2ae3, returns to 0x2C75 label_2C75: // Incoming return from call to 0x2AE3 at 0x2C74 // Inputs[6] // { // @2C76 stack[-1] // @2C76 stack[-4] // @2C7A stack[-6] // @2C7C msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2C7D stack[-3] // @2C83 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2C75 5B JUMPDEST 2C76 92 SWAP3 2C77 50 POP 2C78 60 PUSH1 0x40 2C7A 85 DUP6 2C7B 01 ADD 2C7C 35 CALLDATALOAD 2C7D 91 SWAP2 2C7E 50 POP 2C7F 60 PUSH1 0x60 2C81 85 DUP6 2C82 01 ADD 2C83 35 CALLDATALOAD 2C84 67 PUSH8 0xffffffffffffffff 2C8D 81 DUP2 2C8E 11 GT 2C8F 15 ISZERO 2C90 61 PUSH2 0x2c97 2C93 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2C76 stack[-4] = stack[-1] // @2C7D stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2C83 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2c97, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2C94: // Incoming jump from 0x2C93, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2C94 stack[-2] // @2C96 memory[stack[-2]:stack[-2] + stack[-2]] // } 2C94 81 DUP2 2C95 82 DUP3 2C96 FD *REVERT // Stack delta = +0 // Outputs[1] { @2C96 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2C97: // Incoming jump from 0x2C93, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2C9B stack[-7] // @2C9C stack[-1] // @2C9D stack[-6] // } 2C97 5B JUMPDEST 2C98 61 PUSH2 0x2ca3 2C9B 87 DUP8 2C9C 82 DUP3 2C9D 88 DUP9 2C9E 01 ADD 2C9F 61 PUSH2 0x2b3a 2CA2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C98 stack[0] = 0x2ca3 // @2C9B stack[1] = stack[-7] // @2C9E stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x2b3a, returns to 0x2CA3 label_2CA3: // Incoming return from call to 0x2B3A at 0x2CA2 // Inputs[8] // { // @2CA4 stack[-3] // @2CA4 stack[-1] // @2CA7 stack[-6] // @2CA8 stack[-9] // @2CA9 stack[-5] // @2CAA stack[-8] // @2CAC stack[-7] // @2CAC stack[-4] // } 2CA3 5B JUMPDEST 2CA4 91 SWAP2 2CA5 50 POP 2CA6 50 POP 2CA7 92 SWAP3 2CA8 95 SWAP6 2CA9 91 SWAP2 2CAA 94 SWAP5 2CAB 50 POP 2CAC 92 SWAP3 2CAD 50 POP 2CAE 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2CA7 stack[-6] = stack[-1] // @2CA8 stack[-9] = stack[-6] // @2CAA stack[-8] = stack[-5] // @2CAC stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2CAF: // Incoming call from 0x0565, returns to 0x0566 // Inputs[2] // { // @2CBB stack[-1] // @2CBC stack[-2] // } 2CAF 5B JUMPDEST 2CB0 60 PUSH1 0x00 2CB2 80 DUP1 2CB3 60 PUSH1 0x00 2CB5 80 DUP1 2CB6 60 PUSH1 0x00 2CB8 80 DUP1 2CB9 60 PUSH1 0xa0 2CBB 87 DUP8 2CBC 89 DUP10 2CBD 03 SUB 2CBE 12 SLT 2CBF 15 ISZERO 2CC0 61 PUSH2 0x2cc7 2CC3 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2CB0 stack[0] = 0x00 // @2CB2 stack[1] = 0x00 // @2CB3 stack[2] = 0x00 // @2CB5 stack[3] = 0x00 // @2CB6 stack[4] = 0x00 // @2CB8 stack[5] = 0x00 // } // Block ends with conditional jump to 0x2cc7, if !(stack[-2] - stack[-1] i< 0xa0) label_2CC4: // Incoming jump from 0x2CC3, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @2CC4 stack[-2] // @2CC6 memory[stack[-2]:stack[-2] + stack[-2]] // } 2CC4 81 DUP2 2CC5 82 DUP3 2CC6 FD *REVERT // Stack delta = +0 // Outputs[1] { @2CC6 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2CC7: // Incoming jump from 0x2CC3, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @2CC8 stack[-7] // @2CC9 msg.data[stack[-7]:stack[-7] + 0x20] // } 2CC7 5B JUMPDEST 2CC8 86 DUP7 2CC9 35 CALLDATALOAD 2CCA 61 PUSH2 0x2cd2 2CCD 81 DUP2 2CCE 61 PUSH2 0x38ef 2CD1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2CC9 stack[0] = msg.data[stack[-7]:stack[-7] + 0x20] // @2CCA stack[1] = 0x2cd2 // @2CCD stack[2] = msg.data[stack[-7]:stack[-7] + 0x20] // } // Block ends with call to 0x38ef, returns to 0x2CD2 label_2CD2: // Incoming return from call to 0x38EF at 0x2CD1 // Inputs[4] // { // @2CD3 stack[-1] // @2CD3 stack[-7] // @2CD7 stack[-8] // @2CD9 msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } 2CD2 5B JUMPDEST 2CD3 95 SWAP6 2CD4 50 POP 2CD5 60 PUSH1 0x20 2CD7 87 DUP8 2CD8 01 ADD 2CD9 35 CALLDATALOAD 2CDA 61 PUSH2 0x2ce2 2CDD 81 DUP2 2CDE 61 PUSH2 0x38ef 2CE1 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2CD3 stack[-7] = stack[-1] // @2CD9 stack[-1] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @2CDA stack[0] = 0x2ce2 // @2CDD stack[1] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // } // Block ends with call to 0x38ef, returns to 0x2CE2 label_2CE2: // Incoming return from call to 0x38EF at 0x2CE1 // Inputs[8] // { // @2CE3 stack[-6] // @2CE3 stack[-1] // @2CE7 stack[-8] // @2CE9 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @2CEA stack[-5] // @2CF0 msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // @2CF1 stack[-4] // @2CF7 msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } 2CE2 5B JUMPDEST 2CE3 94 SWAP5 2CE4 50 POP 2CE5 60 PUSH1 0x40 2CE7 87 DUP8 2CE8 01 ADD 2CE9 35 CALLDATALOAD 2CEA 93 SWAP4 2CEB 50 POP 2CEC 60 PUSH1 0x60 2CEE 87 DUP8 2CEF 01 ADD 2CF0 35 CALLDATALOAD 2CF1 92 SWAP3 2CF2 50 POP 2CF3 60 PUSH1 0x80 2CF5 87 DUP8 2CF6 01 ADD 2CF7 35 CALLDATALOAD 2CF8 67 PUSH8 0xffffffffffffffff 2D01 81 DUP2 2D02 11 GT 2D03 15 ISZERO 2D04 61 PUSH2 0x2d0b 2D07 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2CE3 stack[-6] = stack[-1] // @2CEA stack[-5] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @2CF1 stack[-4] = msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // @2CF7 stack[-1] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x2d0b, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) label_2D08: // Incoming jump from 0x2D07, if not !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2D08 stack[-3] // @2D0A memory[stack[-3]:stack[-3] + stack[-3]] // } 2D08 82 DUP3 2D09 83 DUP4 2D0A FD *REVERT // Stack delta = +0 // Outputs[1] { @2D0A revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2D0B: // Incoming jump from 0x2D07, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2D0F stack[-9] // @2D10 stack[-1] // @2D11 stack[-8] // } 2D0B 5B JUMPDEST 2D0C 61 PUSH2 0x2d17 2D0F 89 DUP10 2D10 82 DUP3 2D11 8A DUP11 2D12 01 ADD 2D13 61 PUSH2 0x2afa 2D16 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2D0C stack[0] = 0x2d17 // @2D0F stack[1] = stack[-9] // @2D12 stack[2] = stack[-8] + stack[-1] // } // Block ends with call to 0x2afa, returns to 0x2D17 label_2D17: // Incoming return from call to 0x2AFA at 0x2D16 // Inputs[10] // { // @2D18 stack[-9] // @2D18 stack[-1] // @2D19 stack[-12] // @2D1A stack[-8] // @2D1B stack[-11] // @2D1D stack[-2] // @2D1D stack[-7] // @2D1E stack[-10] // @2D20 stack[-3] // @2D20 stack[-6] // } 2D17 5B JUMPDEST 2D18 97 SWAP8 2D19 9A SWAP11 2D1A 96 SWAP7 2D1B 99 SWAP10 2D1C 50 POP 2D1D 94 SWAP5 2D1E 97 SWAP8 2D1F 50 POP 2D20 92 SWAP3 2D21 95 SWAP6 2D22 93 SWAP4 2D23 94 SWAP5 2D24 92 SWAP3 2D25 50 POP 2D26 50 POP 2D27 50 POP 2D28 56 *JUMP // Stack delta = -6 // Outputs[6] // { // @2D19 stack[-12] = stack[-9] // @2D1B stack[-11] = stack[-8] // @2D1E stack[-10] = stack[-7] // @2D21 stack[-9] = stack[-6] // @2D22 stack[-7] = stack[-1] // @2D23 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-12] label_2D29: // Incoming call from 0x0491, returns to 0x0492 // Inputs[2] // { // @2D2F stack[-1] // @2D30 stack[-2] // } 2D29 5B JUMPDEST 2D2A 60 PUSH1 0x00 2D2C 80 DUP1 2D2D 60 PUSH1 0x40 2D2F 83 DUP4 2D30 85 DUP6 2D31 03 SUB 2D32 12 SLT 2D33 15 ISZERO 2D34 61 PUSH2 0x2d3b 2D37 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2D2A stack[0] = 0x00 // @2D2C stack[1] = 0x00 // } // Block ends with conditional jump to 0x2d3b, if !(stack[-2] - stack[-1] i< 0x40) label_2D38: // Incoming jump from 0x2D37, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2D38 stack[-2] // @2D3A memory[stack[-2]:stack[-2] + stack[-2]] // } 2D38 81 DUP2 2D39 82 DUP3 2D3A FD *REVERT // Stack delta = +0 // Outputs[1] { @2D3A revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2D3B: // Incoming jump from 0x2D37, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2D3F stack[-4] // @2D40 stack[-3] // } 2D3B 5B JUMPDEST 2D3C 61 PUSH2 0x2d45 2D3F 84 DUP5 2D40 84 DUP5 2D41 61 PUSH2 0x2ae3 2D44 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2D3C stack[0] = 0x2d45 // @2D3F stack[1] = stack[-4] // @2D40 stack[2] = stack[-3] // } // Block ends with call to 0x2ae3, returns to 0x2D45 label_2D45: // Incoming return from call to 0x2AE3 at 0x2D44 // Inputs[4] // { // @2D46 stack[-1] // @2D46 stack[-3] // @2D4A stack[-4] // @2D4C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2D45 5B JUMPDEST 2D46 91 SWAP2 2D47 50 POP 2D48 60 PUSH1 0x20 2D4A 83 DUP4 2D4B 01 ADD 2D4C 35 CALLDATALOAD 2D4D 61 PUSH2 0x2d55 2D50 81 DUP2 2D51 61 PUSH2 0x3904 2D54 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2D46 stack[-3] = stack[-1] // @2D4C stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2D4D stack[0] = 0x2d55 // @2D50 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x3904, returns to 0x2D55 label_2D55: // Incoming return from call to 0x3904 at 0x2D54 // Inputs[6] // { // @2D56 stack[-1] // @2D57 stack[-2] // @2D5A stack[-5] // @2D5C stack[-3] // @2D5C stack[-6] // @2D5D stack[-4] // } 2D55 5B JUMPDEST 2D56 80 DUP1 2D57 91 SWAP2 2D58 50 POP 2D59 50 POP 2D5A 92 SWAP3 2D5B 50 POP 2D5C 92 SWAP3 2D5D 90 SWAP1 2D5E 50 POP 2D5F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2D5A stack[-5] = stack[-1] // @2D5C stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2D60: // Incoming call from 0x0370, returns to 0x0371 // Incoming call from 0x030F, returns to 0x0310 // Inputs[2] // { // @2D66 stack[-1] // @2D67 stack[-2] // } 2D60 5B JUMPDEST 2D61 60 PUSH1 0x00 2D63 80 DUP1 2D64 60 PUSH1 0x40 2D66 83 DUP4 2D67 85 DUP6 2D68 03 SUB 2D69 12 SLT 2D6A 15 ISZERO 2D6B 61 PUSH2 0x2d72 2D6E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2D61 stack[0] = 0x00 // @2D63 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2d72, if !(stack[-2] - stack[-1] i< 0x40) label_2D6F: // Incoming jump from 0x2D6E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2D6F stack[-2] // @2D71 memory[stack[-2]:stack[-2] + stack[-2]] // } 2D6F 81 DUP2 2D70 82 DUP3 2D71 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D71 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2D72: // Incoming jump from 0x2D6E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2D76 stack[-4] // @2D77 stack[-3] // } 2D72 5B JUMPDEST 2D73 61 PUSH2 0x2d7c 2D76 84 DUP5 2D77 84 DUP5 2D78 61 PUSH2 0x2ae3 2D7B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2D73 stack[0] = 0x2d7c // @2D76 stack[1] = stack[-4] // @2D77 stack[2] = stack[-3] // } // Block ends with call to 0x2ae3, returns to 0x2D7C label_2D7C: // Incoming return from call to 0x2AE3 at 0x2D7B // Inputs[5] // { // @2D7D stack[-6] // @2D7D stack[-1] // @2D80 stack[-4] // @2D84 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2D85 stack[-5] // } 2D7C 5B JUMPDEST 2D7D 94 SWAP5 2D7E 60 PUSH1 0x20 2D80 93 SWAP4 2D81 90 SWAP1 2D82 93 SWAP4 2D83 01 ADD 2D84 35 CALLDATALOAD 2D85 93 SWAP4 2D86 50 POP 2D87 50 POP 2D88 50 POP 2D89 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2D7D stack[-6] = stack[-1] // @2D85 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] 2D8A 5B JUMPDEST 2D8B 60 PUSH1 0x00 2D8D 60 PUSH1 0x20 2D8F 82 DUP3 2D90 84 DUP5 2D91 03 SUB 2D92 12 SLT 2D93 15 ISZERO 2D94 61 PUSH2 0x2d9b 2D97 57 *JUMPI 2D98 80 DUP1 2D99 81 DUP2 2D9A FD *REVERT 2D9B 5B JUMPDEST 2D9C 81 DUP2 2D9D 51 MLOAD 2D9E 61 PUSH2 0x1b29 2DA1 81 DUP2 2DA2 61 PUSH2 0x3904 2DA5 56 *JUMP 2DA6 5B JUMPDEST 2DA7 60 PUSH1 0x00 2DA9 60 PUSH1 0x20 2DAB 82 DUP3 2DAC 84 DUP5 2DAD 03 SUB 2DAE 12 SLT 2DAF 15 ISZERO 2DB0 61 PUSH2 0x2db7 2DB3 57 *JUMPI 2DB4 80 DUP1 2DB5 81 DUP2 2DB6 FD *REVERT 2DB7 5B JUMPDEST 2DB8 50 POP 2DB9 51 MLOAD 2DBA 91 SWAP2 2DBB 90 SWAP1 2DBC 50 POP 2DBD 56 *JUMP label_2DBE: // Incoming call from 0x029C, returns to 0x029D // Inputs[2] // { // @2DC3 stack[-1] // @2DC4 stack[-2] // } 2DBE 5B JUMPDEST 2DBF 60 PUSH1 0x00 2DC1 60 PUSH1 0x20 2DC3 82 DUP3 2DC4 84 DUP5 2DC5 03 SUB 2DC6 12 SLT 2DC7 15 ISZERO 2DC8 61 PUSH2 0x2dcf 2DCB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2DBF stack[0] = 0x00 } // Block ends with conditional jump to 0x2dcf, if !(stack[-2] - stack[-1] i< 0x20) label_2DCC: // Incoming jump from 0x2DCB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2DCC stack[-1] // @2DCE memory[stack[-1]:stack[-1] + stack[-1]] // } 2DCC 80 DUP1 2DCD 81 DUP2 2DCE FD *REVERT // Stack delta = +0 // Outputs[1] { @2DCE revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2DCF: // Incoming jump from 0x2DCB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2DD0 stack[-2] // @2DD1 msg.data[stack[-2]:stack[-2] + 0x20] // } 2DCF 5B JUMPDEST 2DD0 81 DUP2 2DD1 35 CALLDATALOAD 2DD2 61 PUSH2 0x1b29 2DD5 81 DUP2 2DD6 61 PUSH2 0x3912 2DD9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DD1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2DD2 stack[1] = 0x1b29 // @2DD5 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3912, returns to 0x1B29 2DDA 5B JUMPDEST 2DDB 60 PUSH1 0x00 2DDD 60 PUSH1 0x20 2DDF 82 DUP3 2DE0 84 DUP5 2DE1 03 SUB 2DE2 12 SLT 2DE3 15 ISZERO 2DE4 61 PUSH2 0x2deb 2DE7 57 *JUMPI 2DE8 80 DUP1 2DE9 81 DUP2 2DEA FD *REVERT 2DEB 5B JUMPDEST 2DEC 81 DUP2 2DED 51 MLOAD 2DEE 61 PUSH2 0x1b29 2DF1 81 DUP2 2DF2 61 PUSH2 0x3912 2DF5 56 *JUMP label_2DF6: // Incoming call from 0x047E, returns to 0x047F // Incoming call from 0x0322, returns to 0x0323 // Incoming call from 0x04E0, returns to 0x04E1 // Incoming call from 0x0463, returns to 0x0464 // Inputs[2] // { // @2DFB stack[-1] // @2DFC stack[-2] // } 2DF6 5B JUMPDEST 2DF7 60 PUSH1 0x00 2DF9 60 PUSH1 0x20 2DFB 82 DUP3 2DFC 84 DUP5 2DFD 03 SUB 2DFE 12 SLT 2DFF 15 ISZERO 2E00 61 PUSH2 0x2e07 2E03 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2DF7 stack[0] = 0x00 } // Block ends with conditional jump to 0x2e07, if !(stack[-2] - stack[-1] i< 0x20) label_2E04: // Incoming jump from 0x2E03, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2E04 stack[-1] // @2E06 memory[stack[-1]:stack[-1] + stack[-1]] // } 2E04 80 DUP1 2E05 81 DUP2 2E06 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E06 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2E07: // Incoming jump from 0x2E03, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2E08 stack[-2] // @2E09 msg.data[stack[-2]:stack[-2] + 0x20] // } 2E07 5B JUMPDEST 2E08 81 DUP2 2E09 35 CALLDATALOAD 2E0A 67 PUSH8 0xffffffffffffffff 2E13 81 DUP2 2E14 11 GT 2E15 15 ISZERO 2E16 61 PUSH2 0x2e1d 2E19 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E09 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2e1d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2E1A: // Incoming jump from 0x2E19, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2E1A stack[-2] // @2E1C memory[stack[-2]:stack[-2] + stack[-2]] // } 2E1A 81 DUP2 2E1B 82 DUP3 2E1C FD *REVERT // Stack delta = +0 // Outputs[1] { @2E1C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2E1D: // Incoming jump from 0x2E19, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2E21 stack[-4] // @2E22 stack[-1] // @2E23 stack[-3] // } 2E1D 5B JUMPDEST 2E1E 61 PUSH2 0x2545 2E21 84 DUP5 2E22 82 DUP3 2E23 85 DUP6 2E24 01 ADD 2E25 61 PUSH2 0x2b3a 2E28 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2E1E stack[0] = 0x2545 // @2E21 stack[1] = stack[-4] // @2E24 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x2b3a, returns to 0x2545 label_2E29: // Incoming call from 0x0383, returns to 0x0384 // Incoming call from 0x041D, returns to 0x041E // Incoming call from 0x0402, returns to 0x0403 // Incoming call from 0x0552, returns to 0x0553 // Incoming call from 0x03E7, returns to 0x03E8 // Incoming call from 0x04A4, returns to 0x04A5 // Incoming call from 0x02EF, returns to 0x02F0 // Incoming call from 0x0519, returns to 0x051A // Incoming call from 0x0506, returns to 0x0507 // Inputs[2] // { // @2E2E stack[-1] // @2E2F stack[-2] // } 2E29 5B JUMPDEST 2E2A 60 PUSH1 0x00 2E2C 60 PUSH1 0x20 2E2E 82 DUP3 2E2F 84 DUP5 2E30 03 SUB 2E31 12 SLT 2E32 15 ISZERO 2E33 61 PUSH2 0x2e3a 2E36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E2A stack[0] = 0x00 } // Block ends with conditional jump to 0x2e3a, if !(stack[-2] - stack[-1] i< 0x20) label_2E37: // Incoming jump from 0x2E36, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2E37 stack[-1] // @2E39 memory[stack[-1]:stack[-1] + stack[-1]] // } 2E37 80 DUP1 2E38 81 DUP2 2E39 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E39 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2E3A: // Incoming jump from 0x2E36, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2E3C stack[-2] // @2E3C msg.data[stack[-2]:stack[-2] + 0x20] // @2E3D stack[-4] // @2E3E stack[-3] // } 2E3A 5B JUMPDEST 2E3B 50 POP 2E3C 35 CALLDATALOAD 2E3D 91 SWAP2 2E3E 90 SWAP1 2E3F 50 POP 2E40 56 *JUMP // Stack delta = -3 // Outputs[1] { @2E3D stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2E41: // Incoming call from 0x04F3, returns to 0x04F4 // Incoming call from 0x03D4, returns to 0x03D5 // Inputs[2] // { // @2E47 stack[-1] // @2E48 stack[-2] // } 2E41 5B JUMPDEST 2E42 60 PUSH1 0x00 2E44 80 DUP1 2E45 60 PUSH1 0x40 2E47 83 DUP4 2E48 85 DUP6 2E49 03 SUB 2E4A 12 SLT 2E4B 15 ISZERO 2E4C 61 PUSH2 0x2e53 2E4F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2E42 stack[0] = 0x00 // @2E44 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2e53, if !(stack[-2] - stack[-1] i< 0x40) label_2E50: // Incoming jump from 0x2E4F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2E50 stack[-2] // @2E52 memory[stack[-2]:stack[-2] + stack[-2]] // } 2E50 81 DUP2 2E51 82 DUP3 2E52 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E52 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2E53: // Incoming jump from 0x2E4F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2E54 stack[-3] // @2E55 msg.data[stack[-3]:stack[-3] + 0x20] // @2E56 stack[-2] // @2E5C msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 2E53 5B JUMPDEST 2E54 82 DUP3 2E55 35 CALLDATALOAD 2E56 91 SWAP2 2E57 50 POP 2E58 60 PUSH1 0x20 2E5A 83 DUP4 2E5B 01 ADD 2E5C 35 CALLDATALOAD 2E5D 67 PUSH8 0xffffffffffffffff 2E66 81 DUP2 2E67 11 GT 2E68 15 ISZERO 2E69 61 PUSH2 0x2e70 2E6C 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2E56 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @2E5C stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2e70, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_2E6D: // Incoming jump from 0x2E6C, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2E6D stack[-2] // @2E6F memory[stack[-2]:stack[-2] + stack[-2]] // } 2E6D 81 DUP2 2E6E 82 DUP3 2E6F FD *REVERT // Stack delta = +0 // Outputs[1] { @2E6F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2E70: // Incoming jump from 0x2E6C, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2E74 stack[-5] // @2E75 stack[-1] // @2E76 stack[-4] // } 2E70 5B JUMPDEST 2E71 61 PUSH2 0x2e7c 2E74 85 DUP6 2E75 82 DUP3 2E76 86 DUP7 2E77 01 ADD 2E78 61 PUSH2 0x2b3a 2E7B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2E71 stack[0] = 0x2e7c // @2E74 stack[1] = stack[-5] // @2E77 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x2b3a, returns to 0x2E7C label_2E7C: // Incoming return from call to 0x2B3A at 0x2E7B // Inputs[6] // { // @2E7D stack[-1] // @2E7D stack[-3] // @2E80 stack[-6] // @2E82 stack[-7] // @2E82 stack[-4] // @2E83 stack[-5] // } 2E7C 5B JUMPDEST 2E7D 91 SWAP2 2E7E 50 POP 2E7F 50 POP 2E80 92 SWAP3 2E81 50 POP 2E82 92 SWAP3 2E83 90 SWAP1 2E84 50 POP 2E85 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2E80 stack[-6] = stack[-1] // @2E82 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2E86: // Incoming call from 0x052C, returns to 0x052D // Inputs[2] // { // @2E8C stack[-1] // @2E8D stack[-2] // } 2E86 5B JUMPDEST 2E87 60 PUSH1 0x00 2E89 80 DUP1 2E8A 60 PUSH1 0x40 2E8C 83 DUP4 2E8D 85 DUP6 2E8E 03 SUB 2E8F 12 SLT 2E90 15 ISZERO 2E91 61 PUSH2 0x2e98 2E94 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2E87 stack[0] = 0x00 // @2E89 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2e98, if !(stack[-2] - stack[-1] i< 0x40) label_2E95: // Incoming jump from 0x2E94, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2E95 stack[-2] // @2E97 memory[stack[-2]:stack[-2] + stack[-2]] // } 2E95 81 DUP2 2E96 82 DUP3 2E97 FD *REVERT // Stack delta = +0 // Outputs[1] { @2E97 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2E98: // Incoming jump from 0x2E94, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @2E9B stack[-3] // @2E9C msg.data[stack[-3]:stack[-3] + 0x20] // @2E9D stack[-5] // @2EA3 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2EA4 stack[-4] // } 2E98 5B JUMPDEST 2E99 50 POP 2E9A 50 POP 2E9B 80 DUP1 2E9C 35 CALLDATALOAD 2E9D 92 SWAP3 2E9E 60 PUSH1 0x20 2EA0 90 SWAP1 2EA1 91 SWAP2 2EA2 01 ADD 2EA3 35 CALLDATALOAD 2EA4 91 SWAP2 2EA5 50 POP 2EA6 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2E9D stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @2EA4 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_2EA7: // Incoming call from 0x02C5, returns to 0x02C6 // Inputs[2] // { // @2EB0 stack[-1] // @2EB1 stack[-2] // } 2EA7 5B JUMPDEST 2EA8 60 PUSH1 0x00 2EAA 80 DUP1 2EAB 60 PUSH1 0x00 2EAD 80 DUP1 2EAE 60 PUSH1 0x60 2EB0 85 DUP6 2EB1 87 DUP8 2EB2 03 SUB 2EB3 12 SLT 2EB4 15 ISZERO 2EB5 61 PUSH2 0x2ebc 2EB8 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2EA8 stack[0] = 0x00 // @2EAA stack[1] = 0x00 // @2EAB stack[2] = 0x00 // @2EAD stack[3] = 0x00 // } // Block ends with conditional jump to 0x2ebc, if !(stack[-2] - stack[-1] i< 0x60) label_2EB9: // Incoming jump from 0x2EB8, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @2EB9 stack[-2] // @2EBB memory[stack[-2]:stack[-2] + stack[-2]] // } 2EB9 81 DUP2 2EBA 82 DUP3 2EBB FD *REVERT // Stack delta = +0 // Outputs[1] { @2EBB revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2EBC: // Incoming jump from 0x2EB8, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[6] // { // @2EBD stack[-5] // @2EBE msg.data[stack[-5]:stack[-5] + 0x20] // @2EBF stack[-4] // @2EC5 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2EC6 stack[-3] // @2ECC msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 2EBC 5B JUMPDEST 2EBD 84 DUP5 2EBE 35 CALLDATALOAD 2EBF 93 SWAP4 2EC0 50 POP 2EC1 60 PUSH1 0x20 2EC3 85 DUP6 2EC4 01 ADD 2EC5 35 CALLDATALOAD 2EC6 92 SWAP3 2EC7 50 POP 2EC8 60 PUSH1 0x40 2ECA 85 DUP6 2ECB 01 ADD 2ECC 35 CALLDATALOAD 2ECD 67 PUSH8 0xffffffffffffffff 2ED6 81 DUP2 2ED7 11 GT 2ED8 15 ISZERO 2ED9 61 PUSH2 0x2ee0 2EDC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2EBF stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @2EC6 stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2ECC stack[0] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2ee0, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) label_2EDD: // Incoming jump from 0x2EDC, if not !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2EDD stack[-3] // @2EDF memory[stack[-3]:stack[-3] + stack[-3]] // } 2EDD 82 DUP3 2EDE 83 DUP4 2EDF FD *REVERT // Stack delta = +0 // Outputs[1] { @2EDF revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_2EE0: // Incoming jump from 0x2EDC, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2EE4 stack[-7] // @2EE5 stack[-1] // @2EE6 stack[-6] // } 2EE0 5B JUMPDEST 2EE1 61 PUSH2 0x2eec 2EE4 87 DUP8 2EE5 82 DUP3 2EE6 88 DUP9 2EE7 01 ADD 2EE8 61 PUSH2 0x2afa 2EEB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2EE1 stack[0] = 0x2eec // @2EE4 stack[1] = stack[-7] // @2EE7 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x2afa, returns to 0x2EEC label_2EEC: // Incoming return from call to 0x2AFA at 0x2EEB // Inputs[7] // { // @2EED stack[-7] // @2EED stack[-1] // @2EEE stack[-10] // @2EEF stack[-6] // @2EF0 stack[-9] // @2EF2 stack[-2] // @2EF2 stack[-8] // } 2EEC 5B JUMPDEST 2EED 95 SWAP6 2EEE 98 SWAP9 2EEF 94 SWAP5 2EF0 97 SWAP8 2EF1 50 POP 2EF2 95 SWAP6 2EF3 50 POP 2EF4 50 POP 2EF5 50 POP 2EF6 50 POP 2EF7 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2EED stack[-7] = stack[-1] // @2EEE stack[-10] = stack[-7] // @2EF0 stack[-9] = stack[-6] // @2EF2 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_2EF8: // Incoming call from 0x317C, returns to 0x0B02 // Inputs[3] // { // @2EFB stack[-1] // @2EFC memory[stack[-1]:stack[-1] + 0x20] // @2EFE stack[-2] // } 2EF8 5B JUMPDEST 2EF9 60 PUSH1 0x00 2EFB 81 DUP2 2EFC 51 MLOAD 2EFD 80 DUP1 2EFE 84 DUP5 2EFF 52 MSTORE 2F00 61 PUSH2 0x2f10 2F03 81 DUP2 2F04 60 PUSH1 0x20 2F06 86 DUP7 2F07 01 ADD 2F08 60 PUSH1 0x20 2F0A 86 DUP7 2F0B 01 ADD 2F0C 61 PUSH2 0x38c3 2F0F 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2EF9 stack[0] = 0x00 // @2EFC stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2EFF memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2F00 stack[2] = 0x2f10 // @2F03 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2F07 stack[4] = stack[-2] + 0x20 // @2F0B stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x38c3, returns to 0x2F10 label_2F10: // Incoming return from call to 0x38C3 at 0x2F0F // Inputs[4] // { // @2F13 stack[-1] // @2F18 stack[-4] // @2F19 stack[-2] // @2F1F stack[-5] // } 2F10 5B JUMPDEST 2F11 60 PUSH1 0x1f 2F13 01 ADD 2F14 60 PUSH1 0x1f 2F16 19 NOT 2F17 16 AND 2F18 92 SWAP3 2F19 90 SWAP1 2F1A 92 SWAP3 2F1B 01 ADD 2F1C 60 PUSH1 0x20 2F1E 01 ADD 2F1F 92 SWAP3 2F20 91 SWAP2 2F21 50 POP 2F22 50 POP 2F23 56 *JUMP // Stack delta = -4 // Outputs[1] { @2F1F stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2F24: // Incoming call from 0x09B2, returns to 0x09B3 // Inputs[3] // { // @2F27 stack[-2] // @2F28 memory[stack[-2]:stack[-2] + 0x20] // @2F2D stack[-1] // } 2F24 5B JUMPDEST 2F25 60 PUSH1 0x00 2F27 82 DUP3 2F28 51 MLOAD 2F29 61 PUSH2 0x2f36 2F2C 81 DUP2 2F2D 84 DUP5 2F2E 60 PUSH1 0x20 2F30 87 DUP8 2F31 01 ADD 2F32 61 PUSH2 0x38c3 2F35 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2F25 stack[0] = 0x00 // @2F28 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @2F29 stack[2] = 0x2f36 // @2F2C stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @2F2D stack[4] = stack[-1] // @2F31 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x38c3, returns to 0x2F36 label_2F36: // Incoming return from call to 0x38C3 at 0x2F35 // Inputs[5] // { // @2F37 stack[-1] // @2F37 stack[-3] // @2F38 stack[-2] // @2F3B stack[-5] // @2F3C stack[-4] // } 2F36 5B JUMPDEST 2F37 91 SWAP2 2F38 90 SWAP1 2F39 91 SWAP2 2F3A 01 ADD 2F3B 92 SWAP3 2F3C 91 SWAP2 2F3D 50 POP 2F3E 50 POP 2F3F 56 *JUMP // Stack delta = -4 // Outputs[1] { @2F3B stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] 2F40 5B JUMPDEST 2F41 60 PUSH1 0x00 2F43 80 DUP1 2F44 83 DUP4 2F45 54 SLOAD 2F46 60 PUSH1 0x01 2F48 80 DUP1 2F49 82 DUP3 2F4A 16 AND 2F4B 60 PUSH1 0x00 2F4D 81 DUP2 2F4E 14 EQ 2F4F 61 PUSH2 0x2f5f 2F52 57 *JUMPI 2F53 60 PUSH1 0x01 2F55 81 DUP2 2F56 14 EQ 2F57 61 PUSH2 0x2f76 2F5A 57 *JUMPI 2F5B 61 PUSH2 0x2fa5 2F5E 56 *JUMP 2F5F 5B JUMPDEST 2F60 60 PUSH1 0xff 2F62 19 NOT 2F63 83 DUP4 2F64 16 AND 2F65 86 DUP7 2F66 52 MSTORE 2F67 60 PUSH1 0x02 2F69 83 DUP4 2F6A 04 DIV 2F6B 60 PUSH1 0x7f 2F6D 16 AND 2F6E 86 DUP7 2F6F 01 ADD 2F70 93 SWAP4 2F71 50 POP 2F72 61 PUSH2 0x2fa5 2F75 56 *JUMP 2F76 5B JUMPDEST 2F77 60 PUSH1 0x02 2F79 83 DUP4 2F7A 04 DIV 2F7B 87 DUP8 2F7C 86 DUP7 2F7D 52 MSTORE 2F7E 60 PUSH1 0x20 2F80 80 DUP1 2F81 87 DUP8 2F82 20 SHA3 2F83 87 DUP8 2F84 5B JUMPDEST 2F85 83 DUP4 2F86 81 DUP2 2F87 10 LT 2F88 15 ISZERO 2F89 61 PUSH2 0x2f9d 2F8C 57 *JUMPI 2F8D 81 DUP2 2F8E 54 SLOAD 2F8F 8A DUP11 2F90 82 DUP3 2F91 01 ADD 2F92 52 MSTORE 2F93 90 SWAP1 2F94 85 DUP6 2F95 01 ADD 2F96 90 SWAP1 2F97 82 DUP3 2F98 01 ADD 2F99 61 PUSH2 0x2f84 2F9C 56 *JUMP 2F9D 5B JUMPDEST 2F9E 50 POP 2F9F 50 POP 2FA0 50 POP 2FA1 86 DUP7 2FA2 01 ADD 2FA3 93 SWAP4 2FA4 50 POP 2FA5 5B JUMPDEST 2FA6 50 POP 2FA7 91 SWAP2 2FA8 95 SWAP6 2FA9 94 SWAP5 2FAA 50 POP 2FAB 50 POP 2FAC 50 POP 2FAD 50 POP 2FAE 50 POP 2FAF 56 *JUMP 2FB0 5B JUMPDEST 2FB1 60 PUSH1 0x00 2FB3 80 DUP1 2FB4 84 DUP5 2FB5 54 SLOAD 2FB6 60 PUSH1 0x01 2FB8 80 DUP1 2FB9 82 DUP3 2FBA 16 AND 2FBB 60 PUSH1 0x00 2FBD 81 DUP2 2FBE 14 EQ 2FBF 61 PUSH2 0x2fcf 2FC2 57 *JUMPI 2FC3 60 PUSH1 0x01 2FC5 81 DUP2 2FC6 14 EQ 2FC7 61 PUSH2 0x2fe6 2FCA 57 *JUMPI 2FCB 61 PUSH2 0x3015 2FCE 56 *JUMP 2FCF 5B JUMPDEST 2FD0 60 PUSH1 0xff 2FD2 19 NOT 2FD3 83 DUP4 2FD4 16 AND 2FD5 86 DUP7 2FD6 52 MSTORE 2FD7 60 PUSH1 0x02 2FD9 83 DUP4 2FDA 04 DIV 2FDB 60 PUSH1 0x7f 2FDD 16 AND 2FDE 86 DUP7 2FDF 01 ADD 2FE0 93 SWAP4 2FE1 50 POP 2FE2 61 PUSH2 0x3015 2FE5 56 *JUMP 2FE6 5B JUMPDEST 2FE7 60 PUSH1 0x02 2FE9 83 DUP4 2FEA 04 DIV 2FEB 88 DUP9 2FEC 86 DUP7 2FED 52 MSTORE 2FEE 60 PUSH1 0x20 2FF0 80 DUP1 2FF1 87 DUP8 2FF2 20 SHA3 2FF3 87 DUP8 2FF4 5B JUMPDEST 2FF5 83 DUP4 2FF6 81 DUP2 2FF7 10 LT 2FF8 15 ISZERO 2FF9 61 PUSH2 0x300d 2FFC 57 *JUMPI 2FFD 81 DUP2 2FFE 54 SLOAD 2FFF 8A DUP11 3000 82 DUP3 3001 01 ADD 3002 52 MSTORE 3003 90 SWAP1 3004 85 DUP6 3005 01 ADD 3006 90 SWAP1 3007 82 DUP3 3008 01 ADD 3009 61 PUSH2 0x2ff4 300C 56 *JUMP 300D 5B JUMPDEST 300E 50 POP 300F 50 POP 3010 50 POP 3011 86 DUP7 3012 01 ADD 3013 93 SWAP4 3014 50 POP 3015 5B JUMPDEST 3016 50 POP 3017 50 POP 3018 50 POP 3019 83 DUP4 301A 51 MLOAD 301B 61 PUSH2 0x3028 301E 81 DUP2 301F 83 DUP4 3020 60 PUSH1 0x20 3022 88 DUP9 3023 01 ADD 3024 61 PUSH2 0x38c3 3027 56 *JUMP 3028 5B JUMPDEST 3029 01 ADD 302A 94 SWAP5 302B 93 SWAP4 302C 50 POP 302D 50 POP 302E 50 POP 302F 50 POP 3030 56 *JUMP label_3031: // Incoming call from 0x1C74, returns to 0x1C75 // Inputs[3] // { // @3053 stack[-1] // @3059 stack[-2] // @3060 stack[-3] // } 3031 5B JUMPDEST 3032 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 3053 81 DUP2 3054 52 MSTORE 3055 60 PUSH1 0x1c 3057 81 DUP2 3058 01 ADD 3059 91 SWAP2 305A 90 SWAP1 305B 91 SWAP2 305C 52 MSTORE 305D 60 PUSH1 0x3c 305F 01 ADD 3060 90 SWAP1 3061 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @3054 memory[stack[-1]:stack[-1] + 0x20] = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 // @305C memory[stack[-1] + 0x1c:stack[-1] + 0x1c + 0x20] = stack[-2] // @3060 stack[-3] = 0x3c + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3062: // Incoming call from 0x0679, returns to 0x067A // Incoming call from 0x04B7, returns to 0x02AF // Inputs[4] // { // @3063 stack[-3] // @3063 stack[-1] // @306A stack[-2] // @306E stack[-4] // } 3062 5B JUMPDEST 3063 91 SWAP2 3064 82 DUP3 3065 52 MSTORE 3066 60 PUSH1 0x20 3068 82 DUP3 3069 01 ADD 306A 52 MSTORE 306B 60 PUSH1 0x40 306D 01 ADD 306E 90 SWAP1 306F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3065 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @306A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-2] // @306E stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_3070: // Incoming call from 0x0C4E, returns to 0x0C4F // Incoming call from 0x0301, returns to 0x02AF // Inputs[3] // { // @3079 stack[-2] // @307A stack[-1] // @3082 stack[-3] // } 3070 5B JUMPDEST 3071 60 PUSH1 0x01 3073 60 PUSH1 0x01 3075 60 PUSH1 0xa0 3077 1B SHL 3078 03 SUB 3079 91 SWAP2 307A 90 SWAP1 307B 91 SWAP2 307C 16 AND 307D 81 DUP2 307E 52 MSTORE 307F 60 PUSH1 0x20 3081 01 ADD 3082 90 SWAP1 3083 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @307E memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @3082 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3084: // Incoming call from 0x0A11, returns to 0x0A12 // Incoming call from 0x13F8, returns to 0x13F9 // Incoming call from 0x0BEC, returns to 0x0BED // Inputs[5] // { // @308D stack[-4] // @3090 stack[-1] // @3092 stack[-3] // @3093 stack[-2] // @30A6 stack[-5] // } 3084 5B JUMPDEST 3085 60 PUSH1 0x01 3087 60 PUSH1 0x01 3089 60 PUSH1 0xa0 308B 1B SHL 308C 03 SUB 308D 93 SWAP4 308E 84 DUP5 308F 16 AND 3090 81 DUP2 3091 52 MSTORE 3092 91 SWAP2 3093 90 SWAP1 3094 92 SWAP3 3095 16 AND 3096 60 PUSH1 0x20 3098 82 DUP3 3099 01 ADD 309A 52 MSTORE 309B 60 PUSH1 0x40 309D 81 DUP2 309E 01 ADD 309F 91 SWAP2 30A0 90 SWAP1 30A1 91 SWAP2 30A2 52 MSTORE 30A3 60 PUSH1 0x60 30A5 01 ADD 30A6 90 SWAP1 30A7 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @3091 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @309A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @30A2 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-2] // @30A6 stack[-5] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-5] 30A8 5B JUMPDEST 30A9 60 PUSH1 0x01 30AB 60 PUSH1 0x01 30AD 60 PUSH1 0xa0 30AF 1B SHL 30B0 03 SUB 30B1 85 DUP6 30B2 81 DUP2 30B3 16 AND 30B4 82 DUP3 30B5 52 MSTORE 30B6 84 DUP5 30B7 16 AND 30B8 60 PUSH1 0x20 30BA 82 DUP3 30BB 01 ADD 30BC 52 MSTORE 30BD 60 PUSH1 0x40 30BF 81 DUP2 30C0 01 ADD 30C1 83 DUP4 30C2 90 SWAP1 30C3 52 MSTORE 30C4 60 PUSH1 0x80 30C6 60 PUSH1 0x60 30C8 82 DUP3 30C9 01 ADD 30CA 81 DUP2 30CB 90 SWAP1 30CC 52 MSTORE 30CD 60 PUSH1 0x00 30CF 90 SWAP1 30D0 61 PUSH2 0x1db6 30D3 90 SWAP1 30D4 83 DUP4 30D5 01 ADD 30D6 84 DUP5 30D7 61 PUSH2 0x2ef8 30DA 56 *JUMP 30DB 5B JUMPDEST 30DC 60 PUSH1 0x01 30DE 60 PUSH1 0x01 30E0 60 PUSH1 0xa0 30E2 1B SHL 30E3 03 SUB 30E4 94 SWAP5 30E5 85 DUP6 30E6 16 AND 30E7 81 DUP2 30E8 52 MSTORE 30E9 92 SWAP3 30EA 90 SWAP1 30EB 93 SWAP4 30EC 16 AND 30ED 60 PUSH1 0x20 30EF 83 DUP4 30F0 01 ADD 30F1 52 MSTORE 30F2 60 PUSH1 0x40 30F4 82 DUP3 30F5 01 ADD 30F6 52 MSTORE 30F7 60 PUSH1 0x60 30F9 81 DUP2 30FA 01 ADD 30FB 91 SWAP2 30FC 90 SWAP1 30FD 91 SWAP2 30FE 52 MSTORE 30FF 60 PUSH1 0xa0 3101 60 PUSH1 0x80 3103 82 DUP3 3104 01 ADD 3105 81 DUP2 3106 90 SWAP1 3107 52 MSTORE 3108 60 PUSH1 0x00 310A 90 SWAP1 310B 82 DUP3 310C 01 ADD 310D 52 MSTORE 310E 60 PUSH1 0xc0 3110 01 ADD 3111 90 SWAP1 3112 56 *JUMP label_3113: // Incoming call from 0x14F2, returns to 0x14F3 // Incoming call from 0x0CE4, returns to 0x0CE5 // Inputs[4] // { // @311C stack[-3] // @311D stack[-1] // @3126 stack[-2] // @312A stack[-4] // } 3113 5B JUMPDEST 3114 60 PUSH1 0x01 3116 60 PUSH1 0x01 3118 60 PUSH1 0xa0 311A 1B SHL 311B 03 SUB 311C 92 SWAP3 311D 90 SWAP1 311E 92 SWAP3 311F 16 AND 3120 82 DUP3 3121 52 MSTORE 3122 60 PUSH1 0x20 3124 82 DUP3 3125 01 ADD 3126 52 MSTORE 3127 60 PUSH1 0x40 3129 01 ADD 312A 90 SWAP1 312B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3121 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3126 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-2] // @312A stack[-4] = 0x40 + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_312C: // Incoming call from 0x02AE, returns to 0x02AF // Incoming call from 0x139F, returns to 0x13A0 // Inputs[3] // { // @312D stack[-2] // @312D stack[-1] // @3135 stack[-3] // } 312C 5B JUMPDEST 312D 90 SWAP1 312E 15 ISZERO 312F 15 ISZERO 3130 81 DUP2 3131 52 MSTORE 3132 60 PUSH1 0x20 3134 01 ADD 3135 90 SWAP1 3136 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3131 memory[stack[-1]:stack[-1] + 0x20] = !!stack[-2] // @3135 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_3137: // Incoming call from 0x1D60, returns to 0x1D61 // Inputs[6] // { // @3138 stack[-5] // @3138 stack[-1] // @313D stack[-4] // @313E stack[-2] // @314A stack[-3] // @3153 stack[-6] // } 3137 5B JUMPDEST 3138 93 SWAP4 3139 84 DUP5 313A 52 MSTORE 313B 60 PUSH1 0xff 313D 92 SWAP3 313E 90 SWAP1 313F 92 SWAP3 3140 16 AND 3141 60 PUSH1 0x20 3143 84 DUP5 3144 01 ADD 3145 52 MSTORE 3146 60 PUSH1 0x40 3148 83 DUP4 3149 01 ADD 314A 52 MSTORE 314B 60 PUSH1 0x60 314D 82 DUP3 314E 01 ADD 314F 52 MSTORE 3150 60 PUSH1 0x80 3152 01 ADD 3153 90 SWAP1 3154 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @313A memory[stack[-1]:stack[-1] + 0x20] = stack[-5] // @3145 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0xff & stack[-4] // @314A memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @314F memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-2] // @3153 stack[-6] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-6] label_3155: // Incoming call from 0x0577, returns to 0x02AF // Inputs[3] // { // @315F stack[-2] // @3160 stack[-1] // @3168 stack[-3] // } 3155 5B JUMPDEST 3156 60 PUSH1 0x01 3158 60 PUSH1 0x01 315A 60 PUSH1 0xe0 315C 1B SHL 315D 03 SUB 315E 19 NOT 315F 91 SWAP2 3160 90 SWAP1 3161 91 SWAP2 3162 16 AND 3163 81 DUP2 3164 52 MSTORE 3165 60 PUSH1 0x20 3167 01 ADD 3168 90 SWAP1 3169 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3164 memory[stack[-1]:stack[-1] + 0x20] = ~((0x01 << 0xe0) - 0x01) & stack[-2] // @3168 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_316A: // Incoming jump from 0x02E1 // Incoming jump from 0x272B // Inputs[2] // { // @316F stack[-1] // @3178 stack[-2] // } 316A 5B JUMPDEST 316B 60 PUSH1 0x00 316D 60 PUSH1 0x20 316F 82 DUP3 3170 52 MSTORE 3171 61 PUSH2 0x0b02 3174 60 PUSH1 0x20 3176 83 DUP4 3177 01 ADD 3178 84 DUP5 3179 61 PUSH2 0x2ef8 317C 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @316B stack[0] = 0x00 // @3170 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3171 stack[1] = 0x0b02 // @3177 stack[2] = stack[-1] + 0x20 // @3178 stack[3] = stack[-2] // } // Block ends with call to 0x2ef8, returns to 0x0B02 label_317D: // Incoming call from 0x1DB5, returns to 0x05F6 // Inputs[2] // { // @3181 stack[-1] // @31B2 stack[-2] // } 317D 5B JUMPDEST 317E 60 PUSH1 0x20 3180 80 DUP1 3181 82 DUP3 3182 52 MSTORE 3183 60 PUSH1 0x18 3185 90 SWAP1 3186 82 DUP3 3187 01 ADD 3188 52 MSTORE 3189 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 31AA 60 PUSH1 0x40 31AC 82 DUP3 31AD 01 ADD 31AE 52 MSTORE 31AF 60 PUSH1 0x60 31B1 01 ADD 31B2 90 SWAP1 31B3 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3182 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3188 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x18 // @31AE memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 // @31B2 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_31B4: // Incoming call from 0x267D, returns to 0x05F6 // Inputs[2] // { // @31B8 stack[-1] // @31F4 stack[-2] // } 31B4 5B JUMPDEST 31B5 60 PUSH1 0x20 31B7 80 DUP1 31B8 82 DUP3 31B9 52 MSTORE 31BA 60 PUSH1 0x22 31BC 90 SWAP1 31BD 82 DUP3 31BE 01 ADD 31BF 52 MSTORE 31C0 7F PUSH32 0x456e756d657261626c655365743a20696e646578206f7574206f6620626f756e 31E1 60 PUSH1 0x40 31E3 82 DUP3 31E4 01 ADD 31E5 52 MSTORE 31E6 61 PUSH2 0x6473 31E9 60 PUSH1 0xf0 31EB 1B SHL 31EC 60 PUSH1 0x60 31EE 82 DUP3 31EF 01 ADD 31F0 52 MSTORE 31F1 60 PUSH1 0x80 31F3 01 ADD 31F4 90 SWAP1 31F5 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @31B9 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @31BF memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @31E5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x456e756d657261626c655365743a20696e646578206f7574206f6620626f756e // @31F0 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6473 << 0xf0 // @31F4 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_31F6: // Incoming call from 0x1CB4, returns to 0x05F6 // Inputs[2] // { // @31FA stack[-1] // @322B stack[-2] // } 31F6 5B JUMPDEST 31F7 60 PUSH1 0x20 31F9 80 DUP1 31FA 82 DUP3 31FB 52 MSTORE 31FC 60 PUSH1 0x1f 31FE 90 SWAP1 31FF 82 DUP3 3200 01 ADD 3201 52 MSTORE 3202 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 3223 60 PUSH1 0x40 3225 82 DUP3 3226 01 ADD 3227 52 MSTORE 3228 60 PUSH1 0x60 322A 01 ADD 322B 90 SWAP1 322C 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @31FB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3201 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1f // @3227 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @322B stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 322D 5B JUMPDEST 322E 60 PUSH1 0x20 3230 80 DUP1 3231 82 DUP3 3232 52 MSTORE 3233 60 PUSH1 0x1f 3235 90 SWAP1 3236 82 DUP3 3237 01 ADD 3238 52 MSTORE 3239 7F PUSH32 0x4552433732313a2063616c6c6572206973206e6f7420746865206f776e657200 325A 60 PUSH1 0x40 325C 82 DUP3 325D 01 ADD 325E 52 MSTORE 325F 60 PUSH1 0x60 3261 01 ADD 3262 90 SWAP1 3263 56 *JUMP 3264 5B JUMPDEST 3265 60 PUSH1 0x20 3267 80 DUP1 3268 82 DUP3 3269 52 MSTORE 326A 60 PUSH1 0x32 326C 90 SWAP1 326D 82 DUP3 326E 01 ADD 326F 52 MSTORE 3270 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 3291 60 PUSH1 0x40 3293 82 DUP3 3294 01 ADD 3295 52 MSTORE 3296 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 32A9 60 PUSH1 0x71 32AB 1B SHL 32AC 60 PUSH1 0x60 32AE 82 DUP3 32AF 01 ADD 32B0 52 MSTORE 32B1 60 PUSH1 0x80 32B3 01 ADD 32B4 90 SWAP1 32B5 56 *JUMP 32B6 5B JUMPDEST 32B7 60 PUSH1 0x20 32B9 80 DUP1 32BA 82 DUP3 32BB 52 MSTORE 32BC 60 PUSH1 0x26 32BE 90 SWAP1 32BF 82 DUP3 32C0 01 ADD 32C1 52 MSTORE 32C2 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 32E3 60 PUSH1 0x40 32E5 82 DUP3 32E6 01 ADD 32E7 52 MSTORE 32E8 65 PUSH6 0x646472657373 32EF 60 PUSH1 0xd0 32F1 1B SHL 32F2 60 PUSH1 0x60 32F4 82 DUP3 32F5 01 ADD 32F6 52 MSTORE 32F7 60 PUSH1 0x80 32F9 01 ADD 32FA 90 SWAP1 32FB 56 *JUMP 32FC 5B JUMPDEST 32FD 60 PUSH1 0x20 32FF 80 DUP1 3300 82 DUP3 3301 52 MSTORE 3302 60 PUSH1 0x1c 3304 90 SWAP1 3305 82 DUP3 3306 01 ADD 3307 52 MSTORE 3308 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 3329 60 PUSH1 0x40 332B 82 DUP3 332C 01 ADD 332D 52 MSTORE 332E 60 PUSH1 0x60 3330 01 ADD 3331 90 SWAP1 3332 56 *JUMP 3333 5B JUMPDEST 3334 60 PUSH1 0x20 3336 80 DUP1 3337 82 DUP3 3338 52 MSTORE 3339 60 PUSH1 0x24 333B 90 SWAP1 333C 82 DUP3 333D 01 ADD 333E 52 MSTORE 333F 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 3360 60 PUSH1 0x40 3362 82 DUP3 3363 01 ADD 3364 52 MSTORE 3365 63 PUSH4 0x72657373 336A 60 PUSH1 0xe0 336C 1B SHL 336D 60 PUSH1 0x60 336F 82 DUP3 3370 01 ADD 3371 52 MSTORE 3372 60 PUSH1 0x80 3374 01 ADD 3375 90 SWAP1 3376 56 *JUMP label_3377: // Incoming call from 0x1316, returns to 0x05F6 // Inputs[2] // { // @337B stack[-1] // @33AC stack[-2] // } 3377 5B JUMPDEST 3378 60 PUSH1 0x20 337A 80 DUP1 337B 82 DUP3 337C 52 MSTORE 337D 60 PUSH1 0x19 337F 90 SWAP1 3380 82 DUP3 3381 01 ADD 3382 52 MSTORE 3383 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 33A4 60 PUSH1 0x40 33A6 82 DUP3 33A7 01 ADD 33A8 52 MSTORE 33A9 60 PUSH1 0x60 33AB 01 ADD 33AC 90 SWAP1 33AD 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @337C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3382 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x19 // @33A8 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @33AC stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_33AE: // Incoming call from 0x05F5, returns to 0x05F6 // Inputs[2] // { // @33B2 stack[-1] // @33D4 stack[-2] // } 33AE 5B JUMPDEST 33AF 60 PUSH1 0x20 33B1 80 DUP1 33B2 82 DUP3 33B3 52 MSTORE 33B4 60 PUSH1 0x0e 33B6 90 SWAP1 33B7 82 DUP3 33B8 01 ADD 33B9 52 MSTORE 33BA 6D PUSH14 0x4e6f742076616c6964204b6f6e67 33C9 60 PUSH1 0x90 33CB 1B SHL 33CC 60 PUSH1 0x40 33CE 82 DUP3 33CF 01 ADD 33D0 52 MSTORE 33D1 60 PUSH1 0x60 33D3 01 ADD 33D4 90 SWAP1 33D5 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @33B3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @33B9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0e // @33D0 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4e6f742076616c6964204b6f6e67 << 0x90 // @33D4 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_33D6: // Incoming call from 0x1D06, returns to 0x05F6 // Inputs[2] // { // @33DA stack[-1] // @3416 stack[-2] // } 33D6 5B JUMPDEST 33D7 60 PUSH1 0x20 33D9 80 DUP1 33DA 82 DUP3 33DB 52 MSTORE 33DC 60 PUSH1 0x22 33DE 90 SWAP1 33DF 82 DUP3 33E0 01 ADD 33E1 52 MSTORE 33E2 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 3403 60 PUSH1 0x40 3405 82 DUP3 3406 01 ADD 3407 52 MSTORE 3408 61 PUSH2 0x7565 340B 60 PUSH1 0xf0 340D 1B SHL 340E 60 PUSH1 0x60 3410 82 DUP3 3411 01 ADD 3412 52 MSTORE 3413 60 PUSH1 0x80 3415 01 ADD 3416 90 SWAP1 3417 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @33DB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @33E1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @3407 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @3412 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x7565 << 0xf0 // @3416 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3418 5B JUMPDEST 3419 60 PUSH1 0x20 341B 80 DUP1 341C 82 DUP3 341D 52 MSTORE 341E 60 PUSH1 0x2c 3420 90 SWAP1 3421 82 DUP3 3422 01 ADD 3423 52 MSTORE 3424 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 3445 60 PUSH1 0x40 3447 82 DUP3 3448 01 ADD 3449 52 MSTORE 344A 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 3457 60 PUSH1 0xa1 3459 1B SHL 345A 60 PUSH1 0x60 345C 82 DUP3 345D 01 ADD 345E 52 MSTORE 345F 60 PUSH1 0x80 3461 01 ADD 3462 90 SWAP1 3463 56 *JUMP label_3464: // Incoming call from 0x06C0, returns to 0x05F6 // Inputs[2] // { // @3468 stack[-1] // @3489 stack[-2] // } 3464 5B JUMPDEST 3465 60 PUSH1 0x20 3467 80 DUP1 3468 82 DUP3 3469 52 MSTORE 346A 60 PUSH1 0x0d 346C 90 SWAP1 346D 82 DUP3 346E 01 ADD 346F 52 MSTORE 3470 6C PUSH13 0x14da59c81b9bdd081d985b1a59 347E 60 PUSH1 0x9a 3480 1B SHL 3481 60 PUSH1 0x40 3483 82 DUP3 3484 01 ADD 3485 52 MSTORE 3486 60 PUSH1 0x60 3488 01 ADD 3489 90 SWAP1 348A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3469 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @346F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0d // @3485 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x14da59c81b9bdd081d985b1a59 << 0x9a // @3489 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 348B 5B JUMPDEST 348C 60 PUSH1 0x20 348E 80 DUP1 348F 82 DUP3 3490 52 MSTORE 3491 60 PUSH1 0x38 3493 90 SWAP1 3494 82 DUP3 3495 01 ADD 3496 52 MSTORE 3497 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 34B8 60 PUSH1 0x40 34BA 82 DUP3 34BB 01 ADD 34BC 52 MSTORE 34BD 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 34DE 60 PUSH1 0x60 34E0 82 DUP3 34E1 01 ADD 34E2 52 MSTORE 34E3 60 PUSH1 0x80 34E5 01 ADD 34E6 90 SWAP1 34E7 56 *JUMP 34E8 5B JUMPDEST 34E9 60 PUSH1 0x20 34EB 80 DUP1 34EC 82 DUP3 34ED 52 MSTORE 34EE 60 PUSH1 0x2a 34F0 90 SWAP1 34F1 82 DUP3 34F2 01 ADD 34F3 52 MSTORE 34F4 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 3515 60 PUSH1 0x40 3517 82 DUP3 3518 01 ADD 3519 52 MSTORE 351A 69 PUSH10 0x726f2061646472657373 3525 60 PUSH1 0xb0 3527 1B SHL 3528 60 PUSH1 0x60 352A 82 DUP3 352B 01 ADD 352C 52 MSTORE 352D 60 PUSH1 0x80 352F 01 ADD 3530 90 SWAP1 3531 56 *JUMP label_3532: // Incoming call from 0x1D3B, returns to 0x05F6 // Inputs[2] // { // @3536 stack[-1] // @3572 stack[-2] // } 3532 5B JUMPDEST 3533 60 PUSH1 0x20 3535 80 DUP1 3536 82 DUP3 3537 52 MSTORE 3538 60 PUSH1 0x22 353A 90 SWAP1 353B 82 DUP3 353C 01 ADD 353D 52 MSTORE 353E 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 355F 60 PUSH1 0x40 3561 82 DUP3 3562 01 ADD 3563 52 MSTORE 3564 61 PUSH2 0x7565 3567 60 PUSH1 0xf0 3569 1B SHL 356A 60 PUSH1 0x60 356C 82 DUP3 356D 01 ADD 356E 52 MSTORE 356F 60 PUSH1 0x80 3571 01 ADD 3572 90 SWAP1 3573 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3537 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @353D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @3563 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @356E memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x7565 << 0xf0 // @3572 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3574: // Incoming call from 0x26C4, returns to 0x05F6 // Inputs[2] // { // @3578 stack[-1] // @35B4 stack[-2] // } 3574 5B JUMPDEST 3575 60 PUSH1 0x20 3577 80 DUP1 3578 82 DUP3 3579 52 MSTORE 357A 60 PUSH1 0x22 357C 90 SWAP1 357D 82 DUP3 357E 01 ADD 357F 52 MSTORE 3580 7F PUSH32 0x456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e 35A1 60 PUSH1 0x40 35A3 82 DUP3 35A4 01 ADD 35A5 52 MSTORE 35A6 61 PUSH2 0x6473 35A9 60 PUSH1 0xf0 35AB 1B SHL 35AC 60 PUSH1 0x60 35AE 82 DUP3 35AF 01 ADD 35B0 52 MSTORE 35B1 60 PUSH1 0x80 35B3 01 ADD 35B4 90 SWAP1 35B5 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @3579 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @357F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x22 // @35A5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e // @35B0 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6473 << 0xf0 // @35B4 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_35B6: // Incoming call from 0x1DE5, returns to 0x05F6 // Inputs[2] // { // @35BA stack[-1] // @35E9 stack[-2] // } 35B6 5B JUMPDEST 35B7 60 PUSH1 0x20 35B9 80 DUP1 35BA 82 DUP3 35BB 52 MSTORE 35BC 81 DUP2 35BD 81 DUP2 35BE 01 ADD 35BF 52 MSTORE 35C0 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 35E1 60 PUSH1 0x40 35E3 82 DUP3 35E4 01 ADD 35E5 52 MSTORE 35E6 60 PUSH1 0x60 35E8 01 ADD 35E9 90 SWAP1 35EA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @35BB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @35BF memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @35E5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @35E9 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 35EB 5B JUMPDEST 35EC 60 PUSH1 0x20 35EE 80 DUP1 35EF 82 DUP3 35F0 52 MSTORE 35F1 60 PUSH1 0x15 35F3 90 SWAP1 35F4 82 DUP3 35F5 01 ADD 35F6 52 MSTORE 35F7 74 PUSH21 0x13985b5948185b1c9958591e481c995cd95c9d9959 360D 60 PUSH1 0x5a 360F 1B SHL 3610 60 PUSH1 0x40 3612 82 DUP3 3613 01 ADD 3614 52 MSTORE 3615 60 PUSH1 0x60 3617 01 ADD 3618 90 SWAP1 3619 56 *JUMP 361A 5B JUMPDEST 361B 60 PUSH1 0x20 361D 80 DUP1 361E 82 DUP3 361F 52 MSTORE 3620 60 PUSH1 0x2c 3622 90 SWAP1 3623 82 DUP3 3624 01 ADD 3625 52 MSTORE 3626 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 3647 60 PUSH1 0x40 3649 82 DUP3 364A 01 ADD 364B 52 MSTORE 364C 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 3659 60 PUSH1 0xa1 365B 1B SHL 365C 60 PUSH1 0x60 365E 82 DUP3 365F 01 ADD 3660 52 MSTORE 3661 60 PUSH1 0x80 3663 01 ADD 3664 90 SWAP1 3665 56 *JUMP label_3666: // Incoming call from 0x0EFA, returns to 0x05F6 // Incoming call from 0x16AD, returns to 0x05F6 // Incoming call from 0x14B2, returns to 0x05F6 // Inputs[2] // { // @366A stack[-1] // @3699 stack[-2] // } 3666 5B JUMPDEST 3667 60 PUSH1 0x20 3669 80 DUP1 366A 82 DUP3 366B 52 MSTORE 366C 81 DUP2 366D 81 DUP2 366E 01 ADD 366F 52 MSTORE 3670 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 3691 60 PUSH1 0x40 3693 82 DUP3 3694 01 ADD 3695 52 MSTORE 3696 60 PUSH1 0x60 3698 01 ADD 3699 90 SWAP1 369A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @366B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @366F memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @3695 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @3699 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 369B 5B JUMPDEST 369C 60 PUSH1 0x20 369E 80 DUP1 369F 82 DUP3 36A0 52 MSTORE 36A1 60 PUSH1 0x29 36A3 90 SWAP1 36A4 82 DUP3 36A5 01 ADD 36A6 52 MSTORE 36A7 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 36C8 60 PUSH1 0x40 36CA 82 DUP3 36CB 01 ADD 36CC 52 MSTORE 36CD 68 PUSH9 0x39903737ba1037bbb7 36D7 60 PUSH1 0xb9 36D9 1B SHL 36DA 60 PUSH1 0x60 36DC 82 DUP3 36DD 01 ADD 36DE 52 MSTORE 36DF 60 PUSH1 0x80 36E1 01 ADD 36E2 90 SWAP1 36E3 56 *JUMP 36E4 5B JUMPDEST 36E5 60 PUSH1 0x20 36E7 80 DUP1 36E8 82 DUP3 36E9 52 MSTORE 36EA 60 PUSH1 0x2f 36EC 90 SWAP1 36ED 82 DUP3 36EE 01 ADD 36EF 52 MSTORE 36F0 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 3711 60 PUSH1 0x40 3713 82 DUP3 3714 01 ADD 3715 52 MSTORE 3716 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 3726 60 PUSH1 0x89 3728 1B SHL 3729 60 PUSH1 0x60 372B 82 DUP3 372C 01 ADD 372D 52 MSTORE 372E 60 PUSH1 0x80 3730 01 ADD 3731 90 SWAP1 3732 56 *JUMP 3733 5B JUMPDEST 3734 60 PUSH1 0x20 3736 80 DUP1 3737 82 DUP3 3738 52 MSTORE 3739 60 PUSH1 0x23 373B 90 SWAP1 373C 82 DUP3 373D 01 ADD 373E 52 MSTORE 373F 7F PUSH32 0x4e6577206e616d652069732073616d65206173207468652063757272656e7420 3760 60 PUSH1 0x40 3762 82 DUP3 3763 01 ADD 3764 52 MSTORE 3765 62 PUSH3 0x6f6e65 3769 60 PUSH1 0xe8 376B 1B SHL 376C 60 PUSH1 0x60 376E 82 DUP3 376F 01 ADD 3770 52 MSTORE 3771 60 PUSH1 0x80 3773 01 ADD 3774 90 SWAP1 3775 56 *JUMP 3776 5B JUMPDEST 3777 60 PUSH1 0x20 3779 80 DUP1 377A 82 DUP3 377B 52 MSTORE 377C 60 PUSH1 0x21 377E 90 SWAP1 377F 82 DUP3 3780 01 ADD 3781 52 MSTORE 3782 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 37A3 60 PUSH1 0x40 37A5 82 DUP3 37A6 01 ADD 37A7 52 MSTORE 37A8 60 PUSH1 0x39 37AA 60 PUSH1 0xf9 37AC 1B SHL 37AD 60 PUSH1 0x60 37AF 82 DUP3 37B0 01 ADD 37B1 52 MSTORE 37B2 60 PUSH1 0x80 37B4 01 ADD 37B5 90 SWAP1 37B6 56 *JUMP 37B7 5B JUMPDEST 37B8 60 PUSH1 0x20 37BA 80 DUP1 37BB 82 DUP3 37BC 52 MSTORE 37BD 60 PUSH1 0x31 37BF 90 SWAP1 37C0 82 DUP3 37C1 01 ADD 37C2 52 MSTORE 37C3 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 37E4 60 PUSH1 0x40 37E6 82 DUP3 37E7 01 ADD 37E8 52 MSTORE 37E9 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 37FB 60 PUSH1 0x7a 37FD 1B SHL 37FE 60 PUSH1 0x60 3800 82 DUP3 3801 01 ADD 3802 52 MSTORE 3803 60 PUSH1 0x80 3805 01 ADD 3806 90 SWAP1 3807 56 *JUMP 3808 5B JUMPDEST 3809 60 PUSH1 0x20 380B 80 DUP1 380C 82 DUP3 380D 52 MSTORE 380E 60 PUSH1 0x1d 3810 90 SWAP1 3811 82 DUP3 3812 01 ADD 3813 52 MSTORE 3814 7F PUSH32 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 3835 60 PUSH1 0x40 3837 82 DUP3 3838 01 ADD 3839 52 MSTORE 383A 60 PUSH1 0x60 383C 01 ADD 383D 90 SWAP1 383E 56 *JUMP label_383F: // Incoming call from 0x19C4, returns to 0x05F6 // Inputs[2] // { // @3843 stack[-1] // @3874 stack[-2] // } 383F 5B JUMPDEST 3840 60 PUSH1 0x20 3842 80 DUP1 3843 82 DUP3 3844 52 MSTORE 3845 60 PUSH1 0x1f 3847 90 SWAP1 3848 82 DUP3 3849 01 ADD 384A 52 MSTORE 384B 7F PUSH32 0x577261707065644b6f6e677a3a206e6f74206f70656e73656120617373657400 386C 60 PUSH1 0x40 386E 82 DUP3 386F 01 ADD 3870 52 MSTORE 3871 60 PUSH1 0x60 3873 01 ADD 3874 90 SWAP1 3875 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3844 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @384A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1f // @3870 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x577261707065644b6f6e677a3a206e6f74206f70656e73656120617373657400 // @3874 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3876 5B JUMPDEST 3877 60 PUSH1 0x20 3879 80 DUP1 387A 82 DUP3 387B 52 MSTORE 387C 60 PUSH1 0x14 387E 90 SWAP1 387F 82 DUP3 3880 01 ADD 3881 52 MSTORE 3882 73 PUSH20 0x4e6f7420612076616c6964206e6577206e616d65 3897 60 PUSH1 0x60 3899 1B SHL 389A 60 PUSH1 0x40 389C 82 DUP3 389D 01 ADD 389E 52 MSTORE 389F 60 PUSH1 0x60 38A1 01 ADD 38A2 90 SWAP1 38A3 56 *JUMP label_38A4: // Incoming call from 0x033C, returns to 0x02AF // Inputs[3] // { // @38A5 stack[-1] // @38A5 stack[-2] // @38AB stack[-3] // } 38A4 5B JUMPDEST 38A5 90 SWAP1 38A6 81 DUP2 38A7 52 MSTORE 38A8 60 PUSH1 0x20 38AA 01 ADD 38AB 90 SWAP1 38AC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @38A7 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @38AB stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 38AD 5B JUMPDEST 38AE 92 SWAP3 38AF 83 DUP4 38B0 52 MSTORE 38B1 60 PUSH1 0x20 38B3 83 DUP4 38B4 01 ADD 38B5 91 SWAP2 38B6 90 SWAP1 38B7 91 SWAP2 38B8 52 MSTORE 38B9 60 PUSH1 0x40 38BB 82 DUP3 38BC 01 ADD 38BD 52 MSTORE 38BE 60 PUSH1 0x60 38C0 01 ADD 38C1 90 SWAP1 38C2 56 *JUMP label_38C3: // Incoming call from 0x2F35, returns to 0x2F36 // Incoming call from 0x2F0F, returns to 0x2F10 // Inputs[1] { @38C7 stack[-3] } 38C3 5B JUMPDEST 38C4 60 PUSH1 0x00 38C6 5B JUMPDEST 38C7 83 DUP4 38C8 81 DUP2 38C9 10 LT 38CA 15 ISZERO 38CB 61 PUSH2 0x38de 38CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @38C4 stack[0] = 0x00 } // Block ends with conditional jump to 0x38de, if !(0x00 < stack[-3]) label_38CF: // Incoming jump from 0x38CE, if not !(0x00 < stack[-3]) // Incoming jump from 0x38CE, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @38CF stack[-2] // @38D0 stack[-1] // @38D2 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @38D3 stack[-3] // } 38CF 81 DUP2 38D0 81 DUP2 38D1 01 ADD 38D2 51 MLOAD 38D3 83 DUP4 38D4 82 DUP3 38D5 01 ADD 38D6 52 MSTORE 38D7 60 PUSH1 0x20 38D9 01 ADD 38DA 61 PUSH2 0x38c6 38DD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @38D6 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @38D9 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x38c6 label_38DE: // Incoming jump from 0x38CE, if !(0x00 < stack[-3]) // Incoming jump from 0x38CE, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @38DF stack[-4] // @38E0 stack[-1] // } 38DE 5B JUMPDEST 38DF 83 DUP4 38E0 81 DUP2 38E1 11 GT 38E2 15 ISZERO 38E3 61 PUSH2 0x0c7d 38E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c7d, if !(stack[-1] > stack[-4]) label_38E7: // Incoming jump from 0x38E6, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @38EB stack[-4] // @38EC stack[-3] // @38EE stack[-5] // } 38E7 50 POP 38E8 50 POP 38E9 60 PUSH1 0x00 38EB 91 SWAP2 38EC 01 ADD 38ED 52 MSTORE 38EE 56 *JUMP // Stack delta = -5 // Outputs[1] { @38ED memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_38EF: // Incoming call from 0x2C35, returns to 0x2C36 // Incoming call from 0x2C25, returns to 0x2C26 // Incoming call from 0x2CE1, returns to 0x2CE2 // Incoming call from 0x2CD1, returns to 0x2CD2 // Inputs[1] { @38F8 stack[-1] } 38EF 5B JUMPDEST 38F0 60 PUSH1 0x01 38F2 60 PUSH1 0x01 38F4 60 PUSH1 0xa0 38F6 1B SHL 38F7 03 SUB 38F8 81 DUP2 38F9 16 AND 38FA 81 DUP2 38FB 14 EQ 38FC 61 PUSH2 0x14bc 38FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14bc, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_3900: // Incoming jump from 0x38FF, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @3903 memory[0x00:0x00] } 3900 60 PUSH1 0x00 3902 80 DUP1 3903 FD *REVERT // Stack delta = +0 // Outputs[1] { @3903 revert(memory[0x00:0x00]); } // Block terminates label_3904: // Incoming call from 0x2D54, returns to 0x2D55 // Inputs[1] { @3905 stack[-1] } 3904 5B JUMPDEST 3905 80 DUP1 3906 15 ISZERO 3907 15 ISZERO 3908 81 DUP2 3909 14 EQ 390A 61 PUSH2 0x14bc 390D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14bc, if stack[-1] == !!stack[-1] label_390E: // Incoming jump from 0x390D, if not stack[-1] == !!stack[-1] // Inputs[1] { @3911 memory[0x00:0x00] } 390E 60 PUSH1 0x00 3910 80 DUP1 3911 FD *REVERT // Stack delta = +0 // Outputs[1] { @3911 revert(memory[0x00:0x00]); } // Block terminates label_3912: // Incoming call from 0x2DD9, returns to 0x1B29 // Inputs[1] { @391C stack[-1] } 3912 5B JUMPDEST 3913 60 PUSH1 0x01 3915 60 PUSH1 0x01 3917 60 PUSH1 0xe0 3919 1B SHL 391A 03 SUB 391B 19 NOT 391C 81 DUP2 391D 16 AND 391E 81 DUP2 391F 14 EQ 3920 61 PUSH2 0x14bc 3923 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14bc, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_3924: // Incoming jump from 0x3923, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @3927 memory[0x00:0x00] } 3924 60 PUSH1 0x00 3926 80 DUP1 3927 FD *REVERT // Stack delta = +0 // Outputs[1] { @3927 revert(memory[0x00:0x00]); } // Block terminates 3928 FE *ASSERT 3929 45 GASLIMIT 392A 52 MSTORE 392B 43 NUMBER 392C 37 CALLDATACOPY 392D 32 ORIGIN 392E 31 BALANCE 392F 3A GASPRICE 3930 20 SHA3 3931 74 PUSH21 0x72616e7366657220746f206e6f6e20455243373231 3947 52 MSTORE 3948 65 PUSH6 0x636569766572 394F 20 SHA3 3950 69 PUSH10 0x6d706c656d656e746572 395B 45 GASLIMIT 395C 52 MSTORE 395D 43 NUMBER 395E 37 CALLDATACOPY 395F 32 ORIGIN 3960 31 BALANCE 3961 3A GASPRICE 3962 20 SHA3 3963 6F PUSH16 0x776e657220717565727920666f72206e 3974 6F PUSH16 0x6e6578697374656e7420746f6b656ea2 3985 64 PUSH5 0x6970667358 398B 22 22 398C 12 SLT 398D 20 SHA3 398E C7 C7 398F CC CC 3990 63 PUSH4 0x415295da 3995 FF *SELFDESTRUCT 3996 B0 PUSH 3997 76 PUSH23 0x5b719570ed69f6323e1591c492449e5154078be944ce64 39AF 73 PUSH20 0x6f6c634300060c0033